Skip navigation

Category Archives: Programmazione

come su windows anche su wine certe librerie non vengono installate con l‘installer.

L’editor senza il file MSCOMCTL.OCX funziona lo stesso, ma su windows compare un errore quando si lancia il “simulatore” (SXSim), su wine invece non succede niente.

Il problema si risolve velocemente lanciando e installando questo eseguibile libraryfiles.exe (sia su windows che su wine)

Un metodo migliore però è copiare il file MSCOMCTL.OCX recuperabile facilmente su internet. Io l’ho trovato qua: http://www.ocxdump.com/download-ocx-files_new.php/ocxfiles/M/MSCOMCTL.OCX/6.01.9782/download.html

Copiarlo nella cartella windows/system32 .

(leggendo in giro consigliano eseguire dal prompt dei comanti regsvr32 MSCOMCTL.OCX per registrare il file,  penso comunque che sia inutile per il funzionamento del programma )

Annunci

android
Di articoli sullo sviluppo di applicazioni Android si è fatta indigestione. Tutti parlano di dover studiare Java, Ant, SQlite e GnuPG.
Ma se uno non avesse voglia di diventare un programmatore?
C’è un modo, molto sofisticato di sviluppare applicazioni complesse senza scrivere una riga di codice. Il progetto arriva direttamente da Montain View e si chiama Google App Inventor.
Lo sviluppo della grafica dell’applicazione è gestita in modo visuale e le funzionaità si creano con schemi a blocchi.
I blocchi disponibili sono davvero tanti, tanto che si potrebbe pensare che non ne abbiano dimenticata neanche una (ci sono blocchi addirittura per interfacciuarsi con i social network).
Il progetto è ancora in fase beta, la registrazione è consentita solo ai possessori di un account Google (è richiesto un indirizzo Gmail) e bisogna aspettare l’approvazione da parte di Google.
Per testare le applicazioni viene fornita una applicazione java che provvederà ad interfacciare l’applicazione web con il vostro smartphone .

Nell’era di internet le password (intendo codici chiave che ci permettono di autenticarci e proteggere informazioni, servizi ecc..) sono entrate prepotentemente nelle nostre vite. Giusto l’altro giorno ho dovuto trascriverne alcune perchè non riuscito a ricordarle tutte (e beh a dire la verità ho riempito completamente un foglio A4).

Ma ricordarle e archiviarle non è l’unico problema legato alle chiavi (o password, come preferite), bisogna anche inventarsele. Ci si aggrappa a tutto pur di inventarsi una password che non sia banale e magari anche facilmente ricordabile: per esempio mi è capitato di utilizzare il nome del modello del mio stereo (che era anche buona come password: conteneva sia lettere maiuscole e minuscole, che simboli per esempio il ‘–‘ ).

Altri utilizzano il ritornello della loro canzone preferita per poter generare una password abbastanza lunga da essere abbastanza sicura: ‘ Lucy in the Sky with Diamondssenza un dizionario che contiene questa frase esatta è quasi “in-crackabile” (molto sicura). Tenendo a mente sempre la stessa frase si potrebbe considerare solo le prime due lettere di ogni parola e di avrebbe una password del genere ‘ LuinthSkwiDi’ che ha anche lei la sua bella complessità anche senza contenere caratteri speciali ne numeri. (una password non è più sicura solo quanto più è lunga, ma anche quanti più tipi di caratteri contiene, spesso ci è infatti consigliato di utilizzare sia numeri sia lettere (MAIUSCOLE e minuscole) e quando è possibile anche caratteri speciali ‘ &%$£!= ‘).

Potremmo anche non volere una password che sia facile da ricordare, potremmo non aver fantasia e volere una chiave particolare senza stare a battere le dita sulla tastiera in modo casuale (questo metodo non l’ho ancora provato, ma è interessante! °.°). Quindi veniamo a quello promesso dal titolo: un programmino molto banale scritto in c++ che generi una password lunga quanto vogliamo e con un livello di complessità definito da noi.

Ecco che con questo pensiero in testa, con tutte le cose che avevo da fare oggi mi sono messo davanti all’IDE Code::blocks e ho incominciato a scrivere il programma.

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
using namespace std;

int main (){
int n;
char c;
int risp,i,scelta;

do{
    srand(time(NULL));
    cout<<"\tGENEREATORE CHIAVI CASUALI \t ** il Katta **"
        <<"\n\t\tMenu:"
        <<"\n 1-chiave alfanumerica con caratteri speciali"
        <<"\n 2-solo nuemeri"
        <<"\n 3-numeri e lettere maiuscole e minuscole"
        <<"\n 4-lettere minuscole"
        <<"\n 5-lettere maiuscole e minuscole (utile per chiavi di cifratura WPA e WEP)"
        <<"\n 0-esci\n_";
    cin>>scelta;

    switch (scelta){

    case 1:                             //chaive alfanumerica + caratteri speciali
        cout<<"\nlunghezza chiave:\n_";
        cin>>n;
        for (i=0;i<n;i++){
            c=33+rand() % 94;           //il codice ASCII è visto dal C codificato
                                                     //nella sua forma decimale
            cout<<c;                  /* tutti i caratteri che interessano
                                       * questa chiave sono tra il 33 e il 126
                                       * in pratica genero semplicemente dei
                                       * numeri interi che poi verranno
                                       * codificati assegnandoli a una
                                       * variabile di tipo ' char '*/
        }
        do{getchar();}while(!getchar());
        break;

    case 2:                             //chiave numerica
        cout<<"\nlunghezza chiave:\n_";
        cin>>n;
        cout<<"\n chiave:\n";
        for (i=0;i<n;i++){
            cout<<rand()%10;
        }
        do{getchar();}while(!getchar());
        break;

    case 3:;case 4:;case 5:               //gli altri tre casi raggruppati
        cout<<"\nlunghezza chiave:\n_";      /* in questi 3 casi la funzione rand genererà
                                              * molti più numeri di quelli che verranno utilizzati.*/
       /* Questo è quello che si definisce un programma non ottimizzato. */
        cin>>n;
        cout<<"\n chaive: \n";
        i=0;
        while (i<n){
               c=33+rand() % 93;
 if(scelta==3){                  //chiave alfanumerica
 if ((c>=48 && c<=57)||(c>=65 && c<=90) || (c>=97 && c<=122)){
//con questo 'if' si stampa a video solo se il numero generato è tra quelli che interessano il tipo di chiave
//in ASCII dal 48 al 57 rappresentano i numeri, dal 65 al 90 l'alfabeto maiuscolo e dal 97 al 122 le lettere in minuscolo
                    cout<<c;
                    i++;
                }
            }
            if (scelta==4){                   //solo lettere dell'alfabeto
                if (c>=97 && c<=122){
                    cout<<c;
                    i++;
                }
            }
            if (scelta==5){                   //lettere maiuscole e minuscole
                if ((c>=65 && c<=90) || (c>=97 && c<=122)){
                    cout<<c;
                    i++;
                }
            }
        }
        do{getchar();}while(!getchar());
        break;
    }
}while(scelta!=0);
return 0;
}

Il tutto restituisce a video la chiave di lunghezza desiderata, bisogna premere invio dopo ogni visualizzazione (il ‘ do{getchar();}while(!getchar()); ‘ serve a quello , utilizzato per poter compilare il programma con diversi sistemi operativi).

Il programma è scritto molto “di getto”. Con i ‘ case ‘ abbastanza incasinati (ero indeciso tra gli if e lo swicht)

comunque:
il sorgente è scaricabile qui generatore_pswrd.cpp

l’eseguibile  per linux quo generatore_pswrd

e invece il file eseguibile per windows qua generatore_pswrd.exe

Coma hanno insegnato anche a me, per scambiare il contenuto di due variabili ne serve una d’appoggio, dove copiare temporaneamente il contenuto di una delle due:

int temp, a=15, b=8;

a=temp;       //copio ‘a’ nella variabile di “appoggio”

a=b;             //assegno il contenuto di ‘a’ in ‘b’

b=temp;     //e assegno il valore temporaneamente assegnato a ‘temp’ a ‘b’.

Tre semplici passaggi più l’inizializzazione della variabile temporanea.

Ma possibile che questa operazione così semplice debba essere svolta per forza in questo modo?

Purtroppo per come è strutturato questo linguaggio questa non è così semplice ma c’è una soluzione, lavorare sui bit con un’opportuno operatore: lo XOR, che in pratica (secondo la tabella di verità) restituisce 1 se i due bit sono diversi e 0 se sono uguali. Nel nostro caso per ogni bit della variabile.

L’operazione di scambio risulterebbe quindi così:

Partendo da

A=15   in binario: 1111        e

B=9     in binario: 1001      si ha:

A=A^B                   0110      confrontando bit a bit tutti i valori delle due variabili in binario

sapendo che B=   1001     e quindi confronto 0110 e 1001

B=B^A                   1111       che è giusto giusto 15

A=A^B                   1001      che se controllate è 9: il valore iniziale di B

il codice ovviamente sarebbe più corretto e comodo scritto in una funzione e tengo a precisare che so di non aver scoperto niente di particolare, solo una curiosità già nota.