Skip navigation

Category Archives: C/C++

Scaricando i sorgenti del windowmanager più geek della storia mi sono accorto di una voce nuova nuova nella fluxbox-project-page su sourceforge.net: la versione 1.3 del suddetto wm è stata rilasciata (5 ora fa).

Era il 18 settembre 2008 il giorno dell’ultima release (la 1.1) e dopo 4 lunghi anni come niente fosse ecco che il progetto si aggiorna e pubblica questo comunicato:

You did’nt see that coming, did you?

Sat Feb 19 18:50:02 UTC 2011

Fluxbox 1.3 has arrived! A long long long time is over, and we finally decided to make a release.

  • Added support for bidirectional text, #2801836.
  • Allow to override ‘Focus New Windows’ via .fluxbox/apps
  • New actions:
    • ActivateTab
    • ArrangeWindowsVertical
  • New ‘MoveN’ and ‘ClickN’ action support for keys file
  • New focus model ‘StrictMouseFocus’. This will affect focus when closing, moving, lowering windows, changing desktops, etc, whereas the ‘MouseFocus’ model will only change focus when you move the mouse.
  • New “background: unset” property for use in overlays.
  • Allowing relative paths for background images in style files.
  • Allowing matching screen number in ClientPattern.
  • Removed rootcommand from init, as fbsetbg is run automatically nowadays.
  • Removed line style resources from init file.

In any case, we hope to get more into the ‘flux’ way of doing things, aka release early and often. So, have fun with this release.

Personal note from Mathias: This one is dedicated to the first official ‘fluxbaby’ on the planet: my daughter Karo, born on 6th of November 2010. Which is, btw, the birthday of Henrik as well 🙂

The Fluxbox Team 

Non ho resistito, ho dovuto assolutamente compilarla!

Presto il feedback!

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.