Copy Link

Add to Bookmark

Report

Hitnote 0x05

Published in

· 4 years ago

     __  _____________   ______  ____________ 
    / / / /  _/_  __/ | / / __ \/_  __/ ____/ 
   / /_/ // /  / / /  |/ / / / / / / / __/ 
  / __  // /  / / / /|  / /_/ / / / / /___ 
 /_/ /_/___/ /_/ /_/ |_/\____/ /_/ /_____/ [0x05 :: February 2011] 
                 Hackkappatoio Isn't The Name Of This Ezine 

http://hitnote.gotdns.org :: http://unofficialhj.gotdns.org

HITNOTE 0x05 :: Happy new Fear

Penso che un bell'effetto narrativo sarebbe il dire:

«Al momento in cui sto scrivendo non si sa se il governo cadrà o meno, certo è più probabile la prima rispetto alla seconda ipotesi, ma quest'incertezza sarà risolta solo dopo che questo editoriale verrà pubblicato, dunque adesso spunterà (spero) un sorrisetto sulla faccia del lettore soddisfatto»

ma so che al di là della caduta di un regime dovrà esservi la volontà popolare di risollevare un Paese stremato, agonizzante, quasi in fin di vita, sull'orlo del default e della follia psicotica indotta da mass-media superficiali e strumentalizzati.
Ma andiamo per gradi, eseguiamo quella che i professori di letteratura chiamerebbero climax, in musica «crescendo».

Sono approdato su unofficialhj.gotdns.org ad Agosto e subito ho compreso che i contenuti in mio possesso erano qualitativamente e quantitativamente inferiori rispetto a quelli dei membri di questa piccola ma vivace community.
Il progetto Hitnote mi ha particolarmente interessato per la sua estrema semplicità -è una ezine, un sistema vecchio come il web- nell'aggregare contenuti gratuitamente e diligentemente spiegati da chi, per puro spirito di condivisione e divulgazione, presta il proprio operato ai curiosi.

Questa ezine si alimenta grazie all'evoluzione del forum ospitato dal buon r0b0t82, a cui va tutto tribuito il rispetto, nonché l'ammirazione di coloro che usufruiscono del suo servizio, un forum dicevo modesto e serio.
Dall'altra parte della barricata c'è chi crede di essere migliore, chi pensa che divulgare in questo modo sia una perdita di tempo, un inutile impantanarsi nella spiegazione di cose basilari: queste persone hanno aggredito le nostre strutture, hanno prepotentemente e violentemente tentato di impedirci la prosecuzione del nostro umile lavoro, hanno minacciato l'esistenza di una concorrenza che fra l'altro non è nemmeno commerciale.

Possono essere costoro i rappresentanti di chi è curioso o ama condividere? Possono paragonarsi a quelle menti che hanno abbattuto barriere d'ogni tipo, siano esse matematiche, politiche, teoriche, fisiche (in senso sportivo), sociali?

La risposta è ovvia, ed induce ad una conclusione che ritengo inutile riportare. Soffocare la libertà, o peggio ancora confonderla, mistificarla o addirittura appropriarsi dei suoi vessilli per eliminare in modo poco ortodosso la sgradita concorrenza intellettuale: non vi sembra di parlare di temi che riguardano una più alta sfera d'influenza delle nostre vite?
Ebbene sì, è lo stesso comportamento del Nano (potrei chiamarlo da editorialista antefiducia «il gatto» in riferimento al gatto di Schrödinger), poiché proprio come i succitati ha sfruttato la sua potenza quantitativa, si noti bene questa parola: quantitativa, per sminuire e gettare fango sull'avversario, attaccandolo poi direttamente, cercando lo scontro secondo una logica terribile, una logica che implica l'affidare l'attacco ad uno dei propri adepti, o supportarlo tramite il silenzio omertoso (che il caro Dell'Utri ha ben insegnato al Gatto), per poi indifferentemente dribblare la questione svicolando alle domande dei giornalisti.

Davvero non ho parole per descrivere un sistema maligno e cangerogeno, che ha infracidito persino le stabili ed inalterabili fondamenta della Repubblica Italiana replicando sé stesso attraverso la trasmissione del proprio «codice genetico», insieme di informazioni, e direi più propriamente di modi di fare, incerti fra l'ipocrita e il mafioso, che contaminano prima le sedi più proprie della politica, quelle fisiche, sarebbe a dire i palazzi del potere, i comitati provinciali et similia, e poi la sede che inizia a perdere «metri quadri», ossia le menti degli italiani: il cancro ha colpito i loro cervelli e sta mangiando i neuroni deputati all'analisi critica di ogni situazione, all'elaborazione del pensiero filosofico più alto, appunto il pensiero politico (Platone era letteralmente innamorato della politica, Hannah Arendt la definiva come quintessenza della filosofia).

Mi chiedo come abbiano fatto 60 milioni di italiani a sopportare per 15 anni imbrogli, allusioni al mondo della criminalità organizzata, modi di fare spregiudicati spudoratamente sbandierati, spacciati per sacrosante prerogative del capo del governo.
Mi chiedo anche come facciamo noi a resistere alle provocazioni di Denis Verdini, che afferma di fregarsene dei poteri del Presidente della Repubblica, o di chi asserisce che il Gatto può (e spero correggiate, o lettori, con un bel poteva) ignorare le leggi perché incoronato dal Popolo (entità sacra, che io non citerei mai se non in rarissime occasioni), e mi domando anche quale razza di microencefali siano i finiani per non citare a memoria il "divieto di mandato imperativo", sancito sommamente nella Costituzione quale principio di libertà e di massima rappresentanza di ogni delegato parlamentare.

Amici, compagni, ci sarebbe da onorare paladini della conoscenza e da condannare alla damnatio memoriae perpetua ed irreversibile i loro antagonisti, ci sarebbe da denunciare misfatti gravissimi, ipocrisie, qualunquismi, demagogie, ignoranza che fanno letteralmente accaponare la pelle, ma non voglio affatto rovinarvi la salute.

E' per questo che la conclusione non è né amara, né incoraggiante: sta ad ognuno di noi trovarne una, sulla scorta magari di quell'importante risultato ottenuto il 14 Dicembre, e di trovare la forza di andare avanti, sia nel nostro piccolo che in grande.

Con sincero affetto, da parte mia e dei miei fieri compagni, vi auguro una buona lettura :)

Piston Churchell

                    ______________ 
                   /             /\ 
                  /             /  \ 
_______          /   M E R I   /    \                           _______________ 
______/|        /   T O C R   /      \                        _/_______________ 
_|____||       /   A Z I A   /        \                    __/:___favoritismo__ 
____|__/      /             /          \               ___/:____|_____|_____|__ 
_|_____|_    /_____________/     V      \             /_/uzione____|_____|_____ 
____|___/|   \             \      E      \           |____|_____|_____|_____|__ 
_|_____|/:    \             \      R      \            |____disinformazione____ 
_____corr|     \    ______   \      I      |           /__|_____|_____|_____|__ 
_|_____/|       \  /     /\   \      T     |          /|_____|_____|_____|_____ 
____|___|_       \/        \   \      A    |         |____|_ipocrisia_|_____|_ 
_|_____|_/|      /  A      /    \          |         /_|_____|_____|_____|_____ 
____|____|/     /  I      /      \         |         \____|_____|_____|_____|__ 
_|_____|__/|   /  Z      /        \        |       __/_|_____|_____|_____|_____ 
____|_____|/  /  I      /__________\_______|    _ /_|___nepotismo_____|_____|__ 
__ignoranza\_/  T      /___________  ____      /_|_____|_____|_____|_____|_____ 
____|_____|_/  S      /__/_____/__/\/:__/\____|_____|_____|_____|_oscurantismo_ 
_|_____|___/  U      /___|_____|__\/_|__\/_/:____|_____|_____|_____|_____|_____ 
____|_____/  I      /_|_____|_monopolio_|_____|_____|_connivenza______|_____|__ 
_|_____|_/  G      /_____|_____|_____|_____|_____|_____|_____|_____|_____|_____ 
        /         / 
       /         /

Indice

0x00 . MBB: Reversing al buio
0x01 . The Dark Side of C++
0x02 . Introduzione al Turbo Pascal
0x03 . Valute e sistemi di pagamento elettronici
0x04 . Lettera ad un figlio che forse non potrò mai avere
0x05 . La mistica select()
0x06 . La posta a scrocco
0x07 . Fenomeno Wikileaks -- A tribute to Piston
0x08 . Riddle
0x09 . Ringraziamenti

0x00 :: MBB: Reversing al buio

[ Questo articolo è pensato per chì sa già muoversi con comunicazioni seriali, ]
[ convertitori, oscilloscopi, ecc., cioè per chi è già pratico in elettronica. ]
[ e sappia cosa non fare, cioè cosa può eventualmente danneggiare gli IC. ]

A chi non sa che cosa sia un convertitore USB<-->RS232, consiglio di cominciare a leggere un pochetto sull'argomento e di cercare informazioni su questo protocollo da molti considerato obsoleto ma che invece è ancòra molto impiegato nei settori professionali che esigono affidabilità, e che piace molto ai nostalgici.

Un'ottima spiegazione su:

http://it.wikipedia.org/wiki/EIA_RS-232

e un esempio di convertitore USB/RS232 free&open su:

http://it.emcelettronica.com/usb2usart

Di che si tratta

Questa volta parliamo un pò di reversing dell'hardware, una delle cose più soddisfacenti che quest'ignobile epoca possa offrire.
Con reversing dell'hardware intendo lo smontare e il capire l'hardware in modo da riutilizzarlo in propri progetti o a puro titolo di curiosità.
Un esempio potrebbe essere quello del lettore-MP3 "rotto" che viene smontato e riparato senza averne nessuno schema anzi talvolta creandone la documentazione per far sapere ad altri cosa contiene e come funziona.

Obiettivo attuale

L'obiettivo è trovare i segnali digitali di una blackbox, e di dumparli sul PC per esaminarli.

Cosa serve

Ovviamente la solita attrezzatura da banco e i soliti strumenti di misura: pinzette, "terza-mano", lente d'ingrandimento, una miriade di cacciaviti, saldatore a stagno elettrico di bassa potenza (e del buon stagno almeno "60/40" con anima), almeno un multimetro (i digitali hanno una maggiore impedenza di ingresso quindi interferiscono di meno sui circuiti in tensione), e un alimentatore tuttofare (che di solito è il primo gioiellino creato dagli appassionati).

Questa volta però abbiamo bisogno di qualcosina in più:

un oscilloscopio (ancòra meglio un analizzatore di segnali/spettro), caro strumento di misura che rappresenta esattamente le forme-d'onda cioè le tensioni (se vi piace l'elettronica e volete fare reversing, è ora che ve ne procuriate uno :) ) che ci servirà per trovare i segnali digitali;
un convertitore USB/seriale (lascio a voi la scelta) che ci servirà per leggere i segnali digitali trovati, evitando di utilizzare la porta seriale del PC e quindi evitando eventuali danni da collegamento; i fortunati possessori di un Arduino (ho testato col duemilanove) possono semplicemente usare Arduino come convertitore seriale/USB.
Caramelle gommose a forma di orsetto; non sono proprio indispensabili ma sono sempre gradite.

Esecuzione

Compensiamo le sonde ma attenzione: è vivamente sconsigliato l'introdurre sonde per oscilloscopi nel naso, usate gli appositi attrezzi(sia per sturare il naso che per compensare le sonde).

Cominciamo con l'aprire la nostra cavia aka blackbox per esporre piste e pin varii al puntale della nostra sonda.

Poi alimentiamola e cerchiamo i segnali a onda quadra toccando tutti i probabili punti-caldi aka hotspots (perchè l'english fa figo).

Poi togliamo tensione, e saldiamo uno spezzone di filo su ciascun punto-caldo e infine anche uno spezzone sul GND (negativo generale) della blackbox stessa.

Come capire a cosa corrisponde quell'onda?
Bèh se sai tenere in mano un saldatore, sai anche seguire una pista: scoprilo!

Finito di saldare tutti gli spezzoni, si collega il GND della blackbox col GND del convertitore, poi si collega uno degli spezzoni al pin RX del convertitore seriale, poi si alimenta la cavia, e infine si connette la USB.
Finito di esaminare il segnale su un hotspot, si scollega la USB e si collega lo spezzone successivo all'RX del convertitore. Si capisce che c'è lo sbattimento di dover collegare e scollegare uno per volta tutti gli spezzoni e anche il connettore alla USB, ma quando si và a caccia la pazienza è necessaria :)

NOTA PER ARDUINO:
In Arduino usate il pin TX con la stessa procedura spiegata sopra dato che secondo piedinatura il pin TX di arduino corrisponde al ricevente (RX) del lato computer e al mittente (TX) che sarebbe Arduino.

Per il primo test, apriamo il nostro terminale di fiducia (tty oppure X) e lanciamo Screen sul device che corrisponde al nostro adattatore oppure Arduino (consiglio di togliere prima il microcontrollore da Arduino per questa fase, ovviamente prima spegnete Arduino) così:

screen -A -f -i -t serial_monitor_MIO /dev/tty$porta $velocita

Vedremo un sacco di caratteri non codificati e simili: ora sappiamo che il collegamento funziona e che c'è un segnale digitale valido.

A questo punto con un programma come moserial (il mio preferito, lo trovate su http://freshmeat.net/projects/moserial oppure http://live.gnome.org/moserial) possiamo provare la baud-rate dove ci sono più caratteri riconoscibili.
Se non va la prima, proviamole tutte, mai demordere!
Una volta trovata possiamo salvare ciò che c'è in un file che poi andremo a convertire in esadecimale, decimale oppure ottale (a seconda delle preferenze) con un programma che chiunque può farsi in casa (ma non io non mastico molto il C quindi... Grazie r0b0t82 ;) ).
Dovete solo preoccuparvi di annotare bene che cosa state facendo fare alla cavia mentre visualizzate il segnale digitale, ed è fatta!

Vi ricordo che per cavia non si intendono esseri viventi, cotolette turbo o esseri eterei o inanimati in genere.

Con questo metodo sono riuscito a utilizzare un sensore ottico del mouse come encoder o come sensore di contatto col suolo, per uno dei miei robot.
Con un pò di perseveranza possiamo mandare lo stesso tipo di dato all'hotspot per usare ad esempio un accellerometro al posto della rotellina o qualunque altra cosa ci salti in mente :)

Non diventerete il doctor Octopus ma chi ben comincia è già a metà dell'opera...

Fine. WiiiiiIIIIIII!

d0ct0r

0x01 :: The Dark Side of C++

Ereditarietà Multipla

L'Ereditarietà Multipla è una delle caratteristiche più potenti della programmazione orientata agli oggetti, tanto potente quanto a rischio di errori, tant'è che alcuni moderni linguaggi di programmazione come Java o PHP neanche supportano questa caratteristica.

Il concetto di ereditarietà multipla si può utilizzare quando un oggetto mantiene una relazione è-un non con una sola classe base, ma con più classi base. Idealmente non sarebbe mai da utilizzare quando è possibile svolgere lo stesso compito in modo elegante con una gerarchia di classi singola.

Iniziamo ad addentrarci in un pò di codice, per capire subito questa caratteristica della OOP.

class Base1 
{ 
    public: 
        Base1() : value(0) {} 
        Base1(double v) : value(v) {} 

        double getData() const { return this->value; } 
    private: 
        double value; 
};

Questa è una semplicissima classe base che contiene un valore double, la quale fornisce una funzione membro per accedere a quest'ultimo.

class Base2 
{ 
    public: 
        Base2() : value(0) {} 
        Base2(int v) : value(v) {} 

        int getData() const { return this->value; } 
    private: 
        int value; 
};

Un altra classe base, praticamente uguale alla Base1, se non per il tipo di dato contenuto, in questo caso un intero.

class Derived : public Base1, public Base2 
{ 
    public: 
        Derived() : Base1(), Base2(), value(0) {} 
        Derived(double v1, int v2, char v3) : Base1(v1), 
        Base2(v2), value(v3) {} 

        char getData() const { return this->value; } 
    private: 
        char value; 
};

Ed ecco la classe derivata, notare come l'ereditarietà multipla si realizza in modo molto simile a quella singola, ovvero con un ':' dopo la dichiarazione della classe, ma in questo caso, per derivare da più classi, si utilizza l'operatore ',' per separare le classi da cui deriva.

Inoltre si può notare come il costruttore della classe derivata, chiami esplicitamente i costruttori delle sue classi Base per inizializzarne i membri privati.

Passiamo al codice del main.

int main() 
{ 
    Base1 b1(2.5), *b1Ptr; 
    Base2 b2(6), *b2Ptr; 
    Derived d(5.5, 9, 'A'); 

    //Accesso ai valori tramite le singole classi 
    std::cout << "b1 contiene: " << b1.getData() 
        << ", b2 contiene: " << b2.getData() 
        << ", d contiene: " << d.getData() << std::endl; 

    //Accesso ai valori tramite la classe derivata 
    std::cout << "Valore double: " << d.Base1::getData() 
        << ", valore intero: " << d.Base2::getData() 
        << ", valore char: " << d.getData() << std::endl; 

    //Accesso agli elementi di derived tramite puntatori base 

    b1Ptr = &d; //d è-un b1 
    std::cout << "d contiene: " << b1Ptr->getData() << std::endl; 

    b2Ptr = &d; //d è-un b2 
    std::cout << "d contiene: " << b2Ptr->getData() << std::endl; 
}

Allora, all'inizio della procedura main, instanziamo 3 oggetti, le due classi base e la classe derivata, più 2 puntatori alle classi base.

Il primo cout, semplicemente stampa i membri delle classi, ma andiamo alla seconda cout più interessante.
La classe derivata, essendo derivata sia da Base1 che da Base2, contiene i membri e le funzioni di entrambe le classi base, perciò, per chiamare le giuste funzioni per ottenere il dato desiderato, si usa il nome della classe base più l'operatore binario di risoluzione dello scope :: .

In seguito, viene dimostrata come sussiste la relazione è-un tra la classe derivata e le sue basi.

Con b1Ptr = &d; , il puntatore alla classe Base1, punta ad una classe derivata, ciò è permesso dal fatto che Derived è-un Base1. Notare come con questa operazione non è necessario utilizzare l'operatore binario di risoluzione dello scope per accedere al membro della classe Base1. Stessa cosa in seguito con la classe Base2.

Ora, verrà introdotta un tipo di ereditarietà che ci introdurrà al prossimo argomento, ovvero l'ereditarietà virtuale. L'ereditarietà che introduciamo adesso si chiama ereditarietà romboidale, un tipo di ereditarietà esplicabile tramite un esempio grafico.

            classe Base_Superiore 
    |------------------------------|--------------------------| 
classe Base1                        classe Base2 
    |--------------------------|------------------------------| 
            classe Derivata

Con un pò di fantasia si può intravedere un rombo in questa gerarchia :D

Questo tipo di ereditarietà è utilizzata anche nella libreria standard del C++, nel quale basic_ios rappresenta la classe Base_Superiore, basic_istream e basic_ostream rappresentano le classi Base1 e Base2, mentre basic_iostream rappresenta la classe Derivata da entrambe.

C'è però un problema con questo tipo di ereditarietà, che necessita di un esempio per essere illustrata.

class Base_Superiore 
{ 
    public: 
        virtual void doIt() const = 0; 
}; 

class Base1 : public Base_Superiore 
{ 
    public: 
        void doIt() const 
        { 
            std::cout << "Base1" << std::endl; 
        } 
}; 

class Base2 : public Base_Superiore 
{ 
    public: 
        void doIt() const 
        { 
            std::cout << "Base2" << std::endl; 
        } 
}; 

class Derived : public Base1, public Base2 
{ 
    public: 
        void doIt() const 
        { 
            std::cout << "Derived" << std::endl; 
        } 
};

Molto semplicemente, Base_Superiore è una classe Base astratta che fornisce il metodo virtuale puro doIt() da ridefinire in basso alla gerarchia. In seguito, Base1, Base2 e Derived ridefiniscono questo metodo.

Passiamo al main.

int main() 
{ 
    Base_Superiore* bs; 
    Derived d; 

    bs = &d; 
}

Abbiamo un puntatore alla classe Base_Superiore e un oggetto Derived.

Con bs = &d; associamo un oggetto di tipo Derived ad un puntatore a Base_Superiore. Sembrerebbe tutto lecito, dato che Derived è-un Base_Superiore.

Però, qui arriva un problema, infatti se compiliamo quel codice, per esempio con gcc 4.5.1, otteniamo:

error: 'Base_Superiore' is an ambiguous base of 'Derived'

La spiegazione è dietro l'angolo, infatti Derived è si un elemento della gerarchia romboidale, ma contiene al suo interno due copie dei membri di Base_Superiore, ereditati da Base1 e Base2, come fa il compilatore a scegliere?

Per risolvere questo si fa utilizzo dell'ereditarietà virtuale.

Il codice cambiato è il seguente:

class Base_Superiore 
{ 
    public: 
        virtual void doIt() const = 0; 
}; 

class Base1 : virtual public Base_Superiore 
{ 
    public: 
        void doIt() const 
        { 
            std::cout << "Base1" << std::endl; 
        } 
}; 

class Base2 : virtual public Base_Superiore 
{ 
    public: 
        void doIt() const 
        { 
            std::cout << "Base2" << std::endl; 
        } 
}; 

class Derived : public Base1, public Base2 
{ 
    public: 
        void doIt() const 
        { 
            std::cout << "Derived" << std::endl; 
        } 
}; 

int main() 
{ 
    Base_Superiore* bs; 
    Derived d; 

    bs = &d; 

    bs->doIt(); 
}

Come vedete, ho solo aggiunto la keyword virtual nella dichiarazione delle classi Base1, e Base2.

Questo informa il compilatore di istanziare per Derived i membri di Base_Superiore una sola volta.

Puntatori ai membri delle classi

Ci sono due operatori in C++ che raramente vengono utilizzati ma anche loro necessitano di una spiegazione.
Gli operatori in questione sono .* e ->* e servono ad accedere ai membri di un oggetto tramite dei puntatori.

Niente può essere più esplicativo di un esempio.

class A 
{ 
    public: 
        A() : value(0) {} 
        A(int v) : value(v) {} 

        int getValue() const { return this->value; } 

        int value; 
}; 

int main() 
{ 
    A a(5); 
    A* aPtr = &a; 

    int A::*valPtr = &A::value; 
    int (A::*funPtr)() const = &A::getValue; 

    std::cout << "a.value, operatore .*: " << a.*valPtr << std::endl; 
    std::cout << "a.value, operatore .*: " << (a.*funPtr)() << std::endl; 

    std::cout << "a.value, operatore ->*: " << aPtr->*valPtr << std::endl; 
    std::cout << "a.value, operatore ->*: " << (aPtr->*funPtr)() << std::endl; 
}

Allora, abbiamo una semplice classe con un metodo pubblico getValue e un dato membro pubblico value.
Nel main, instanziamo un oggetto della classe A e un puntatore ad esso.

Poi incontriamo due dichiarazioni particolari:

int A::*valPtr = &A::value;

Questa dichiarazione dichiara un puntatore ad un membro int _NELLA_ classe A, inizializzato con il dato membro value della classe A.

int (A::*funPtr)() const = &A::getValue;

Questa dichiarazione dichiara un puntatore a funzione _NELLA_ classe A, una funzione del tipo int (A::*)() const, inizializzata alla funzione getValue della classe A.

Il tutto è abbastanza difficile da spiegare, ma il codice è abbastanza autoesplicativo.

Con le prime due cout facciamo utilizzo dell'operatore .*, che ha come parametro sinistro l'istanza della classe puntata, quindi 'a', e come parametro destro il puntatore alla classe, nel nostro caso valPtr e funPtr.

L'operatore ->* è praticamente analogo, e si utilizza quando invece di un istanza della classe puntata, si ha un puntatore all'istanza della classe puntata.

Il qualificatore mutable

Il qualificatore mutable è un altra caratteristica poco usata in C++ ma anch'essa merita una spiegazione.
Sostanzialmente è un metodo alternativo all'utilizzo dell'operatore const_cast per eludere l'attributo const di una variabile.

Supponiamo di avere questo codice.

class A 
{ 
    public: 
        A() : value(0) {} 
        A(int v) : value(v) {} 

        int getValue() const { return this->value++; } 
    private: 
        int value; 
}; 

int main() 
{ 
    const A a(7); 

    std::cout << a.getValue() << std::endl; 
    std::cout << a.getValue() << std::endl; 
}

Tutto è abbastanza autoesplicativo.

Questo codice scritto così non funzionerebbe, dato che getValue(), che è const cerca di modificare un oggetto const direttamente.
Per farlo compilare, si potrebbe cambiare la funzione getValue() in questo modo.

int getValue() const { return (const_cast<A*>(this))->value++; }

Ovvero togliere al momento il qualificatore const da this.

È una soluzione che magari andrebbe bene per un codice piccolo come questo, ma in caso di diverse funzioni come getValue, invece di utilizzare ogni volta l'operatore const_cast, si può cambiare il codice in questo modo.

class A 
{ 
    public: 
        A() : value(0) {} 
        A(int v) : value(v) {} 

        int getValue() const { return this->value++; } 
    private: 
        mutable int value; 
}; 

int main() 
{ 
    const A a(7); 

    std::cout << a.getValue() << std::endl; 
    std::cout << a.getValue() << std::endl; 
}

Ovvero, la funzione getValue è stata riportata al suo stato iniziale, e al dato membro value è stato assegnato il qualificatore mutable.
In questo caso, il codice compilerà, questo perchè il qualificatore mutable rende un dato sempre modificabile, anche se la classe è const.

Il qualificatore explicit

Bisogna sapere che in C++, un costruttore che prende un unico parametro, viene utilizzato implicitamente come costruttore di copia, un esempio.

class A 
{ 
    public: 
        A() : value(0) {} 
        A(int v) : value(v) 
        { 
            std::cout << "Calling A(int)" << std::endl; 
        } 
    private: 
        int value; 
}; 

int main() 
{ 
    A a(3); 
    A b = 8; 
    A c = A(2); 
}

Compilando ed eseguendo questo codice, vedremo che per ognuna delle tre classi istanziate, verrà chiamato il costruttore A(int), che nella prima occasione, ovvero A a(3); è esplicito, ma nelle seguenti 2 è usato implicitamente come costruttore di copia.

In alcuni casi come questo può andar bene, ma in altri no, ecco perchè è necessario utilizzare il qualificatore explicit davanti alla dichiarazione di A(int), che impedisce la chiamata in modo implicito del costruttore come costruttore di copia.

edx

0x02 :: Introduzione al Turbo Pascal

Quando qualcuno si iscrive all'ITI per la specializzazione informatica ha in mente vari progetti, e ha voglia di affrontare tanti fantastici argomenti che possono essere trattati durante i 3 anni di specificazione, ma a volte non è così.
Al sottoscritto è capitato di dover buttar via il primo anno di specializzazione affrontando un linguaggio di programmazione da me considerato molto inutile come il Turbo Pascal.

In questo articolo, intendo dare un'introduzione agli argomenti che andranno affrontati al 1° Anno di specializzazione informatica.

Gli argomenti che andrete ad affrontare (o che forse avete già affrontato) sono:
Programmazione con Turbo Pascal con l'aggiunta di diagramma a blocchi (simil diagrammi di flusso), Testing del Programma e Tabella delle Variabili.

Il tutto funziona in questo modo:
Viene assegnato un esercizio (spesso richiamano vecchi argomenti di matematica)
ad Esempio:
"Programma che calcoli l'area di un rettangolo".
Si inizia con un Diagramma a Blocchi del Software che si deve scrivere.
(http://it.wikipedia.org/wiki/Diagramma_a_blocchi)
Un diagramma a blocchi serve per schematizzare il nostro software e di comprenderne meglio il funzionamento.

Iniziamo quindi a rappresentare l'esercizio:
http://oi52.tinypic.com/34estq9.jpg

Dando un'occhiata si riesce a capire che abbiamo una parte iniziale (Inizio o Start) e una finale (Fine o End), il triangolo viene usato per l'output.. cioè tutto quello che viene messo al suo interno verrà stampato (echo, print, write ecc), il parallelogramma invece si occupa della lettura di una variabile, cioè si occupa di dare un valore a una variabile prendendo il valore all'esterno del programma (quando viene eseguito), il rettangolo viene usato per rappresentare le operazione che il programma attua, nel nostro caso il rettangolo ci spiega che la variabile C prende il valore del contenuto di A e lo moltiplica per il contenuto di B.
Infine l'ultimo triangolo "stampa":
'Area :' + il contenuto della variabile C.
Proviamo a tradurre ora lo schema in Pascal:

Program Base_Altezza_rettangolo; {Base_Altezza_rettangolo è uguale al nome del programma, posso assegnare qualsiasi nome a un programma affinchè non contenga caratteri 'speciali' e che non ci sia spazio fra le parole}

Var a,b,c:Real; {Qui dichiaro di che tipo sono le variabili utilizzate}

Begin {Inizio} 
 Write('Inserisci base e altezza del rettangolo : ');{Ecco il nostro triangolo} 
 readln(a,b); {Assegna i valori a 'a' e 'b', (parallelogramma) } 
 c:=a*b; {calcolo il valore di a*b inserendo il risultato nella variabile 'c'} 
 Writeln('Area :',c); {Stampo finale del contenuto di c} 
end.

E ora passiamo al testing, il testing del programma è un po' come provare se funziona senza averne il compilatore.. illustrando cosa viene inserito e cosa verrà outputtato.

__________________________________________ 
| |   a  |  b  |  c  | Visualizzazione    | 
| |      |     |     |                    | 
| |   2  |  5  | 10  |    Area : 10       | 
|_|______|_____|_____|____________________|

E ora la tabella della variabili che ci mostra quali variabili utilizzate sono di input e quali si output e se qualcuna viene utilizzate come variabile di lavoro.

___________________________________________ 
|            | I | O   |       Lavoro      | 
|      a     | X |     |                   | 
|      b     | X |     |                   | 
|__ c __|____|___|_X___|___________________| 
I <- Input 
O <- Output

Ecco come dovrete lavorare con la programmazione quando frequenterete quest'anno scolastico (+ o -, dipendono da come i professori impostano la programmazione scolastica.. può darsi che sarete più fortunati xD)
Nelle prossime edizioni, se avrò voglia andrò avanti con le spiegazioni su nuove funzioni del Pascal e come rappresentare la cosa in uno schema grafico.

jackdharma
From Morano School xD

0x03 :: Valute e sistemi di pagamento elettronici

Eccovi una lista di valute elettroniche, sistemi di pagamento on line e simili che potrebbero tornarvi utili.

Prima di tutto però facciamo distinzione tra i classici sistemi di pagamento e le valute elettroniche:

I sistemi di pagamento online sono i classici metodi di pagamento che tutti noi conosciamo, quelli che ci permettono di comprare e/o di vendere sul web in tutta sicurezza e con estrema semplicità, come ad esempio PayPal e PostePay. Possono essere delle carte prepagate o delle vere e propie carte di credito.
Ma è anche vero che ci sono altri metodi di pagamento per acquistare l'oggetto che ci interessa ad esempio sul famoso e annoverato Ebay, metodi che nel 2011 possono ormai sembrare obsoleti e superati. Alcuni esempi di tipi di pagamento diversi possono essere il bonifico bancario, che rimane ancora oggi uno dei metodi più sicuri e il contrassegno, ovvero quello che ci permette di pagare l'oggetto direttamente al corriere, con l'aggiunta di una piccola sovrattassa sul prezzo totale (solitamente si aggira sui 5 euro).
Le valute elettroniche invece (a volte dette anche "moneta elettronica") sono un classico metodo di pagamento online, ma invece di essere messa in circolo moneta cartacea, viene messo in circolo l'oro. Una delle più famose, nonchè delle prime valute elettroniche è stata la GoldMoney, con essa i possessori possono fare diverse transazioni (e acquisti) online, oppure rivendere il proprio oro al prezzo di quotazione corrente.

Ma vediamo nel dettaglio alcuni esempi di metodi di pagamento:

PayPal: È forse il sistema di pagamento online più famoso e più longevo del mondo (nato addirittura nel "lontano" 1998). In pratica il fulcro di tutto, sarà l'e-mail creata e associata al proprio account Una volta iscritti, infatti si potrà associare alla mail PayPal fino a otto carte di credito o carte prepagate, di qualsiasi tipo. Molto utile per siti quali Ebay e Web shop.
PostePay: È una vera e propria carta prepagata accettata per molti servizi in Italia, ma anche all'estero, in tutti i siti ad esempio che accettano carte Visa.
AlertPay: È un sistema di pagamento e storaggio di soldi, molto famoso nei siti di guadagno "bux" e nelle varie eurobarre. Molto in auge da quando paypal ha abbandonato questa fetta di mercato.
Gold Money: Come abbiamo già detto, è una moneta digitale che ha la peculiarità di essere basata sull'oro. cioè se si possiede 1$ nel proprio account, esso verrà modificato in base alle quotazioni dell'oro, facendogli acquistare o perdere valore.
E-Gold: Moneta digitale simile a Gold Money, anche qui i soldi sul proprio conto variano col variare delle quotazioni aurifere nel mondo. Esso è noto per essere tra le monete preferite dalle principali organizzazioni criminali informatiche...
OneBip: Non è propriamente una moneta elettronica ne una specie di banca online, bensì è un sistema di trasferimento di denaro tramite.. cellulare! In pratica basta fare delle "normali" ricariche telefoniche sul proprio telefono cellulare, e si potrà acquistare da alcuni siti, usando difatto il credito come se fossero soldi caricati su una normale carta di credito. Questo servizio ultimamente è stato implementato anche da altre aziende, come ad esempio Poste Italiane, che da poco offre un servizio simile.

Detto questo ci sarebbe da menzionare l'ebanking, ovvero tutti quei servizi che le banche offrono online, dalle transazioni, alla lettura degli estratti conto ad esempio. È però un argomento che sarebbe da approfondire a parte, e non è detto che non verrà fatto!

Ora potrete scegliere con più chiarezza e semplicità il metodo di pagamento che fa al caso vostro!

Turbocotoletta MMX && dany15gni

0x04 :: Lettera ad un figlio che forse non potrò mai avere

Scrivo questa "lettera" per dei motivi molto semplici e banali: soprattutto perchè sono stufo. Sono stufo della Mafia, sono stufo dei politici, sono stufo delle speculazioni e delle promesse mai mantenute, del petrolio e del presente, sono stufo di pensare a come potrà essere il mio futuro in questo paese... Scrivo questa "lettera" ad un figlio che non ho, ad un figlio che vorrei, ad un figlio che molto probabilmente non avrò mai.

Ho solo ventunanni è vero, ma il presente su questo strano pianeta è già diventato passato, il tempo di una pubblicità in televisione o di bere un caffè, e la "storia" è già cambiata.

È un concetto paradossalmente dolce e sensuale se ci pensiamo un attimo, ma in realtà, almeno per quanto riguarda l'Italia, non è così. Non è così perchè questo è un paese che da troppo tempo è impegnato solo a litigare e a darsi colpe sugli errori del passato, è un paese che litiga per "accaparrarsi" quel poco presente che rimane, è un paese che non pensa minimamente al nostro futuro, tutto ciò semplicemente perchè non ha tempo.

Il tempo serve prima di tutto per parlare di escort, il tempo serve per far chiudere le aziende e a lasciare migliaia di padri di famiglia per strada, il tempo serve per fare leggi ad personam, e per creare nuovi partiti e alleanze, non c'è tempo per parlare o solo per pensare al futuro, non c'è tempo per tentare di migliorare questo paese.

C'è il tempo per parlare di Ruby, ma non c'è quello per creare nuovi posti di lavoro.

Ho solo ventunanni è vero, ma per un motivo o per un altro mentalmente sono dovuto crescere in fretta.

Quando sei un ragazzino le tue ambizioni sono banali e ridondanti, fare tanti soldi, tanti abbastanza per poterti comprare una o più macchine di lusso, tanti abbastanza per comprarti una o più case, le tue ambizioni sono avere tante donne, essere potenti...
Poi si cresce, e quei "sogni" adolescenziali li ritrovi letteralmente "reincarnati" in alcune di quelle persone che ci governano, ti guardi bene intorno e vedi solo rabbia, tristezza e desolazione.

Solo allora capisci che le ambizioni non sono quelle, ambire ad essere uno dei tanti potenti che ci marionettano dall'alto, non è propriamente qualcosa di buono, ambire ad essere un giornalista bavoso non è il massimo, solo allora capisci che ambire ad essere "ricchi" comporta tanto dolore per gli "altri", e se nasci nella classica famiglia che nel bene o nel male fa parte della categoria degli "altri", crescendo il potere finisce col farti schifo.

Ho notato poi come i miei coetanei, anche quelli che attivamente o per "ignoranza" appoggiavano o dicevano di appoggiare certe "fazioni" politiche estremiste sia di destra che di sinistra, ultimamente si sono indignati, alcuni sono scesi addirittura in piazza, altri si limitano a condividere qualche link sarcastico o satirico su Facebook, sembra una cavolata, ma è già qualcosa, è già un piccolo passo avanti.

Noi giovani dovremmo essere il futuro...

C'è però chi non ci lascia il posto ed è incollato alla sua poltrona da troppo tempo, c'è chi ci ostacola, c'è chi non pensa minimamente a noi, o meglio, preferisce non pensarci e far finta di niente, perchè noi in qualche modo siamo scomodi. Cresci e le tue ambizioni si allontano dal semplice "avere potere", cresci e la tua ambizione più grande sembra incredibile, ma diviene avere un figlio...

Dovrebbe essere un proposito per l'avvenire, qualcosa a cui pensare sorridendo, qualcosa di concreto che possa accadere prima o poi, quando la stabilità te lo concede, ma in questo "clima di terrore", appesi ad un filo sottilissimo che rischia sempre più spesso di strapparsi, avere un figlio è diventato il pensiero più triste che ci sia, avere un figlio è diventato un sogno, o meglio, lo hanno fatto diventare un sogno, alla pari di possedere quella macchina di lusso o una casa in centro a Milano.

Avere un figlio dovrebbe essere la cosa più bella del mondo, ma oramai è un pensiero che si allontana sempre più da noi giovani.

E allora quando vai a dormire, e ci sono quei dieci minuti dove il tuo cervello pensa al tutto e pensa al niente, credo che a noi ventenni, ma non solo, almeno una volta sia apparsa dal nulla in mente una domanda del tipo: "Tra qualche anno potrò permettermi di avere un figlio?"

Se la si analizza, è una domanda che squarcia il cuore, è la domanda che mi incute più terrore in assoluto...

Potremo mai permetterci un figlio?

È un concetto duro da pensare se guadagni 600 euro al mese come stagista e hai trent anni, è duro da pensare se sei un ragazzo che studia ed insegue un pezzo di carta che, diciamocelo chiaro, in questo paese vale sempre più quanto un rotolo di carta igienica, è duro pensare ad un figlio se sei disoccupato, se non sei figlio di papà o raccomandato.

E allora caro figlio, ora mi rivolgo a te come entità "in sospeso" che aspetti solo il momento opportuno per venire al mondo.

Non nascere dal mio seme, non nascere figlio di un ricercatore o di un operaio, cerca di trovare la via "giusta", nasci figlio di un politico, loro potranno darti tutto, anche delle leggi che faranno al caso tuo se ne avrai bisogno, oppure nasci figlio di una escort, loro si che guadagnano bene, pensa che fanno talmente tanta "tenerezza" che certi politici gli regalano migliaia e migliaia di euro senza volere nulla in cambio!

Aspetta, magari potresti nascere figlio dall'unione di un politico e di una escort!

Potresti nascere figlio di un vecchio lupo comunista, figlio dell'opposizione! Beh, forse non ti conviene più di tanto...

Se non ti piace la classe politica, ci sono sempre i cari e "vecchi" imprenditori, e se qualcosa va male o le cose si complicano, vi basterà fare i bagagli e scappare all'estero, lasciando tantissimi miserabili lavoratori con "le pezze al culo", funziona così, il pesce grosso mangia il pesce piccolo e noi siamo plancton.

Potresti anche nascere figlio di un calciatore, guadagnano minimo due milioni di euro all'anno per tirare calci ad un pallone, oppure figlio di un giornalista, o anche di una bella conduttrice televisiva, che magari poi in futuro diventerà Ministro.

Scegli bene, ma non scegliere me, non scegliere un operaio, un ricercatore, un informatico, ...

Oppure scegli un operaio, un ricercatore, un informatico, ma sceglili all'estero...

dany15gni

0x05 :: La mistica select()

Vorrei presentare al nostro piccolo pubblico una simpatica funzione disponibile per i programmatori C/C++ messa a disposizione dalla maggior parte dei sistemi operativi esistenti oggi.

Questa funzione permette di sapere se un file descritor (un socket, generalmente) è pronto per la lettura o scrittura.

Anche se all'apparenza tale funzione può sembrare completamente inutile, dopo aver letto questo breve articolo, capirete l'utilità di essa. :)

Iniziamo subito vedendo la sintassi di questa funzione

int select( int nfds, 
            fd_set *readfds, 
            fd_set *writefds, 
            fd_set *exceptfds, 
            const struct timeval *timeout 
          );

Come prima cosa, ci terrei a farvi conoscere un simpatico tipo (fd_set) con delle sue relative macro (FD_ZERO, FD_SET, FD_CLR, FD_ISSET); Esso permette di associare ad una singola variabile più sockets.

Le quattro macro sono:

FD_ZERO(fd)      => azzera le "associazioni" fd_set <=> socket 
FD_SET(sck,fd)   => associa un socket all'fd_set 
FD_CLR(sck,fd)   => dissocia un socket all'fd_set 
FD_ISSET(sck,fd) => controlla se, dopo la select(), è ancora attivo il socket 
                    (ci sono dati o è pronto per la scrittura) :)

Innazitutto va dichiarata una variabile di tipo fd_set e va azzerata.

fd_set r; 
FD_ZERO(&r);

successivamente vanno associati i socket:

FD_SET(socket1,&r); 
FD_SET(socket2,&r); 
...bla bla bla...

Ora vediamo un esempio di uso della funzione select():

La select() nel nostro caso ci dirà se ci sono connessioni in attesa di essere accettate su un socket in ascolto.
Come?
Se c'è un dato su un socket in ascolto, vuol dire che c'è una connessione in attesa di essere accettata :)

Quindi,

Come 1° parametro bisogna passare l'id del socket più alto incrementato di uno. (non so, chi ha inventato la select vuole che sia così! :P )
Come 2° parametro, l'fd_set associato ai vari socket
Il 3° e 4° parametro possiamo lasciarli a NULL (servono per usare fd_set come controllo in scrittura/eccezioni)
Con l'ultimo parametro va definito per quanto tempo la select può restare in attesa.

N.B: La select ritorna quanti bytes sono presenti in lettura/scrittura/ecc, oppure -1 in caso di errore.

Quindi:

int n,max; 
SOCKET a,b; 
fd_set f; 
struct timeval tv; 

/* impostazioni dei socket qui */ 

/* loop */ 
while(1) 
{ 
    tv.tv_sec = 0; 
    tv.tv_usec = 100000; /* 1/10 di secondo */ 

    FD_ZERO(&f); 
    FD_SET(a,&f); 
    FD_SET(b,&f); 

    if(a>b) 
        max = a; 
    else 
        max = b; 

    n = select(max + 1,&f,NULL,NULL,&tv); 

    if(n<0) 
    { 
        printf("Errore %d\n",errno); 
    } 
    else 
    { 
        if(n>0) 
        { 
            if(FD_ISSET(a,&f)) 
            { 
                /* leggere da questo socket */ 
            } 

            if(FD_ISSET(b,&f)) 
            { 
                /* leggere da questo socket */ 
            } 
        } 
    } 
}

Certo, con un sorgente così, con massimo 2 sockets predefiniti non si va tanto avanti XD

Quindi vi allego una bozza di un mini-server costruito usando la select() appena vista.

Abbiamo un semplice socket in listening e per gestire dinamicamente i vari socket che accettano le connessioni ho usato lo std::vector delle STL (C++).

#include <cstdio> 
#include <cstdlib> 
#include <errno.h> 
#include <string.h> 
#include <sys/types.h> 
#include <sys/socket.h> 
#include <netinet/in.h> 
#include <arpa/inet.h> 
#include <unistd.h> 
#include <vector> 

#define PORT 2211 

struct sck_s 
{ 
    int s; 
    struct sockaddr_in p; 
} sck_s; 

std::vector<struct sck_s> sockets; /* tutte le connessioni accettate */ 
int l_socket; /* listen socket */ 
struct sockaddr_in l_params; /* parametri del socket in listening */ 

/* funzione inutile per dire "errore". XD */ 
void error(const char *str) 
{ 
    printf("Errore [%s] %d - %s\n",str,errno,strerror(errno)); 
    exit(1); 
} 

int main() 
{ 
    struct timeval tv; 
    fd_set f; 
    unsigned int max,i; 
    socklen_t pl; 
    int n,m; 
    struct sck_s tmp; 
    char buf[512]; 

    /* inizialliziamo il socket che resterà in ascolto */ 
    l_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 
    if(l_socket<0) 
        error("socket"); 

    /* ..e i suoi parametri */ 
    l_params.sin_family = AF_INET; 
    l_params.sin_addr.s_addr = INADDR_ANY; 
    l_params.sin_port = htons(PORT); 

    /* provo a bindare la porta... */ 
    if(bind(l_socket,(struct sockaddr *)&l_params,sizeof(struct sockaddr)) < 0) 
        error("bind"); 

    /* in ascolto! */ 
    if(listen(l_socket,10)<0) 
        error("listen"); 

    /* listen socket pronto! */ 

    /* loop */ 
    while(1) 
    { 
        tv.tv_sec = 0; 
        tv.tv_usec = 100000; /* 1/10 di secondo */ 

        FD_ZERO(&f); 
        FD_SET(l_socket,&f); /* diciamo alla select di controllare anche per */ 
                             /* l_socket */ 

 
        /* iniziamo già a dire qual è per ora il limite massimo dei sockets */ 
        max = l_socket; 

        /* aggiunge tutti i sockets */ 
        for(i=0;i<sockets.size();i++) 
        { 
            if(sockets[i].s != -1) /* se NON ci sono errori */ 
            { 
                FD_SET(sockets[i].s, &f); 
                if(max<sockets[i].s) 
                    max = sockets[i].s; 
            } 
            else /*socket non valido*/ 
            { 
                close(sockets[i].s); 
                sockets.erase(sockets.begin()+i); /*bye bye socket */ 
                i--; /* grazie all'i++ del for ricontrolla lo stesso numero */ 
            } 
        } 

        /* eccola qui la nostra amica! */ 
        n = select(max + 1,&f,NULL,NULL,&tv); 

        if(n<0) 
            error("select"); 
        else if(n>0) 
        { 
            /* controlliamo se ci son dati sul socket in listening */ 
            if(FD_ISSET(l_socket,&f)) /* connessione in arrivo */ 
            { 
                /* accettiamo la connessione */ 
                tmp.s = accept(l_socket,(struct sockaddr *)&tmp.p,&pl); 

                if(tmp.s>0) 
                { 
                    printf( "Accepted connection from %s:%d\n", 
                            inet_ntoa(tmp.p.sin_addr), tmp.p.sin_port); 

                    /* e accodiamola con gli altri sockets */ 
                    sockets.push_back(tmp); 
                } 
            } 

            /* controlliamo se ci son dati sugli altri socket */ 
            for(i=0;i<sockets.size();i++) 
            { 
                if(FD_ISSET(sockets[i].s,&f)) 
                { 
                    memset(buf,0,sizeof(buf)); /*azzeriamo il buffer */ 

                    m = recv(sockets[i].s,(char *)&buf,sizeof(buf),0); 

                    if(m<0 || !m) /* errore durante la lettura */ 
                    { 
                        printf( "Connection closed from %s:%d\n", 
                                inet_ntoa(sockets[i].p.sin_addr), 
                                sockets[i].p.sin_port); 

                        close(sockets[i].s); 
                        sockets.erase(sockets.begin()+i); 
                        i--; 
                        continue; 
                    } 
                    else /* leggiamo! */ 
                    { 
                        printf( "Data recieved from %s: %s\n", 
                                inet_ntoa(sockets[i].p.sin_addr), 
                                buf); 
                    } 
                } 
            } 
        } 
    } 

    close(listen_socket); 
    return 0; 
}

Bene, per oggi è tutto :)

Alla prossima e...attenti ai buffer overflow! ;)

r0b0t82

0x06 :: La posta a scrocco

Devo ancora effettuare dei tests su una mia nuova trovata: la posta gratis.

Consiste nello sfruttare le promozioni riservate alle piccole e grandi imprese, denominate POSTATARGET e POSTAMASSIVA.

Editori e aziende fornitrici di servizi pagano un certo importo per poter inviare liberamente riviste e bollette ai loro utenti, difatti se notate il fogliettino allegato e ben visibile contenuto nell'involucro trasparente delle riviste o il marchio che sostituisce il francobollo nelle lettere inviate da Telecazz ed Eni, troverete il nome dei due tipi di contratto a cui sopra accennavo.

Quali sono dunque i "fini non previsti" per i quali potremmo usare questi autentici regali delle Poste Italiane? Ma senza dubbio corrispondenza gratis!

Nel caso delle buste che contengono le bollette, basterà semplicemente sostituire la bolletta che avete ricevuto con una lettera indirizzata al vostro destinatario.

Occorrerà stamparla al computer, affinché attraverso la plastica trasparente che permette la lettura dell'indirizzo da parte dei postini, si possa leggere l'indirizzo del vostro amico.

Dopo che avrete gettato la busta nella buca delle lettere, questa tornerà all'ufficio smistamento e verrà considerata come una bolletta fresca fresca da inoltrare al destinatario.

Se invece vogliamo usufruire di POSTA TARGET, dopo aver ricevuto una rivista con il foglietto indicante il vostro indirizzo, scansionate quest'ultimo e poi al computer modificate il destinatario.

Prendete periodico, fogliettino falsificato e cellopane, recatevi alla posta e informate l'impiegato che non siete voi i veri destinatari di ciò che avete ricevuto: l'impiegato delle poste molto probabilmente tediato dal lavoro e stupido da tanta gentilezza di un pover'uomo che si strugge per uno sconosciuto facendo una lunga fila alle Poste, non indagherà oltre e vi ringrazierà.

Così la rivista contenente il vostro messaggio segreto verrà recapitata al vostro amico.

Un'altra variante consiste nel farvi recapitare lettere consegnando i vostri fogliettini con il vostro indirizzo agli amici, che non dovranno falsificarli.

Potreste continuare ad inviare "bollette" (eh eh :D) e riviste con "allegati non previsti" (le vostre belle lettere) cambiando sempre buca e sempre ufficio postale, per non dare nell'occhio.

Casomai dovessero scoprirvi, ricordate che sbirciare la posta altrui è un reato ben più grave di inviare false bollette ;)

Buon posta-scrocco a tutti.

Piston Churchell

0x07 :: Fenomeno Wikileaks

Piston aveva inviato quest'articolo per una possibile edizione natalizia, non più pubblicata.

Lo pubblichiamo ora, anche se con gran ritardo, almeno per rispetto di quanti si sforzano e scrivono per questa ezine. ;)

----------------

Avendo volontariamente omesso un'analisi profonda dei mali di questo Paese, parliamo di qualcosa di più elevato, certamente in senso geografico, ché sulle nostre vite forse incide più il piano inferiore che quello superiore.

Non mi interessa analizzare le notizie fornite dal sito di Assange, né tantomeno parlare di Wikileaks in modo scolastico.

Mi soffermerò invece sulla figura dell'editor-in-chief della testata (o biblioteca, essendo registrata come tale in Australia) e sulle pressioni fatte dai governi (ed in particolare da quello statunitense). Sulla testa di Assange pende un mandato di cattura dell'Interpol, vale a dire che quest'uomo è ricercato adesso in 188 paesi.

E questo costituisce un duro colpo alla libertà del progetto: è la definizione giuridica della questione, la sua regolarizzazione davanti agli occhi del mondo. Certo, mi direte che non è ricercato per crimini di guerra o per altri motivi, mi direte che è accusato di stupro. Ma si è mai visto un individuo che non vive più di una manciata di ore nello stesso luogo, che è odiato da un popolo ignorante (sapete benissimo a quale popolo, con la p minuscola, mi riferisco), darsi pena di stuprare due donne e dare anche solo una remota possibilità ai suoi nemici di far scattare il mandato di cui si dice sopra?
Perché non hanno fatto lo stesso con un noto truffatore, fondatore di Canal 5 in Spagna e lì ricercato? (già, il Gatto aveva anche quest'altra..gatta da pelare!)

Dicevamo di Assange:
vanno bene le donazioni, ma io vorrei veramente parlare anche solo 30 secondi con questa persona e fargli davvero sentire il mio affetto, fargli capire che quando ti senti crollare il mondo addosso, quando ti minacciano in così tanti e così gravemente che persino tu inizi a domandarti se forse hanno ragione, se forse hai esagerato o semplicemente sei pazzo, devi trovare la ragione che ti ha spinto a far quel che hai fatto e non devi assolutamente dargliela vinta. La sua vita per me è preziosissima, come del resto quella di tutti gli uomini, ma la sua più di quella degli altri, perché lui incarna anzitutto un ideale: quello di rivelare ciò che ipocritamente è celato nelle scartoffie d'intelligence.

Bisogna dargli coraggio, ricordargli che siamo in tanti.
Attorno al suo progetto hanno fatto vuoto tutte le industrie major d'internet, prima quelle che gli fornivano direttamente le macchine, poi quelle che erano ricollegate a Wikileaks per le donazioni.
È così che Paypal ha chiuso il rubinetto (e qui gli anglofoni avrebbero fatto un titolone stratosferico, dato che leaks significa perdita d'acqua) che erogava soldi alla fondazione.
È giusto fare qual che hanno fatto gli staffer di Wikileaks? Eticamente dovremmo supportarli, o è il nostro risentimento nei confronti dei nostri governi che ci induce a rivolgere loro un sorriso? Valga più di mille parole il video e la vicenda già esposta abbondantemente di "Collateral Murder".
Quel fatto signori, il solo fatto, schietto, crudo e nudo, è la risposta alle vostre domande.

Cosa dire invece di un governo che calpesta il Primo Emendamento, che tramite funzionari e metodi più o meno discutibili induce chi prima sosteneva Wikileaks ad allontanarsene? Beh, anzitutto assomiglia al nostro governo. Ma riflettendo bene il nostro è migliore, è scoperto: sai chi mente per interesse del capo, sai chi mente per prendere più voti e va contro il capo per questo, sai chi vuole solo vivacchiare e chi invece è veramente interessato alla situazione. Lì no: repubblicani e democratici sono ambigui, profondamente invischiati nel sistema delle intelligence, negotium (un bel fuck off a business) d'eccellenza degli americani.

Altrettanto ambiguo e promiscuo è il popolo, stregato dai mass-media, dallo stereotipo, dal "grande sogno americano", la cui realizzazione non deve essere minimamente intaccata da scomodi australiani assetati di verità. Forse ad essere eticamente riprorevoli sono loro, paese senza bussola (in positivo ed in negativo), abitato da paranoici negazionisti della strage prima irachena e poi afghana.
Da chi dobbiamo difenderci, quali affermazioni possono uccidere la nostra criticità? La mia risposta è chiara a questo punto.

Piston Churchell

0x08 :: Riddle

Abbiamo un vincitore per lo scorso riddle: gadfly.

Per risolvere il riddle bastava creare un file PBM e scriverci dentro:

---------- 
P1 
54 5 
0111110111100111011111000011000000011001110011000100000100000100010010010000000 
0011000001100001000101001000001110001111000100100000000011001001100001000101001 
0000010000010000001001000000000011010110000010001001010000011111010000011101111 
100000001101100000111001000110000 
----------

salvarlo come .pbm
e compariva una scritta "EPIC WIN".

Riddle di questo numero:

http://hitnote.gotdns.org/riddle/0x05.jpg

In bocca al lupo ;)

r0b0t82