================================================================================ ---------------------[ BFi14-dev - file 04 - 11/07/2007 ]----------------------- ================================================================================ -[ DiSCLAiMER ]----------------------------------------------------------------- Tutto il materiale contenuto in BFi ha fini esclusivamente informativi ed educativi. Gli autori di BFi non si riterranno in alcun modo responsabili per danni perpetrati a cose o persone causati dall'uso di codice, programmi, informazioni, tecniche contenuti all'interno della rivista. BFi e' libero e autonomo mezzo di espressione; come noi autori siamo liberi di scrivere BFi, tu sei libero di continuare a leggere oppure di fermarti qui. Pertanto, se ti ritieni offeso dai temi trattati e/o dal modo in cui lo sono, * interrompi immediatamente la lettura e cancella questi file dal tuo computer * . Proseguendo tu, lettore, ti assumi ogni genere di responsabilita` per l'uso che farai delle informazioni contenute in BFi. Si vieta il posting di BFi in newsgroup e la diffusione di *parti* della rivista: distribuite BFi nella sua forma integrale ed originale. -------------------------------------------------------------------------------- -[ PHREAKiNG ]------------------------------------------------------------------ ---[ PR0GETT0 MAGNET0 / DYNAMAGNET0 ]------------------------------------------- -----[ EPTO (A) ]------------------------------------------------ -------------------------------------------------------------------------------- :..::-= PROGETTO MAGNETO / DYNAMAGNETO =-::..: ::....:: UN PROGETTO DI PHREAK ESTREMO ::....:: :.............:: By EPTO (A) ::..............: -------------------------------------------------------------------------------- Indice: [1] Introduzione: che cos'e' il Progetto Magneto. [2] Stato attuale del progetto Magneto e del progetto DynaMagneto. [3] Schede telefoniche: funzionamento, stuttura dei dati, codifica. [4] La lettura passo-passo (dalla scheda al dump dei dati). [5] Ipotesi varie ed eventuali sulle codifiche. [6] Scelta del compilatore, linguaggio visuale, interfaccia grafica [7] Algoritmi di Magneto, funzionamento ed implementazione. [8] Dati tecnici su Magneto e lettori fatti in casa, per cominciare a leggere e scrivere le schede. [9] HDSS: Hardware Digito Smanettament System [10] DynaMagneto [11] Progetti collaterali, work in progress... Sito del progetto: http://magneto.r8.org http://magneto.eptousa.altervista.org Sito dei tramaci di Epto: http://tramaci.r8.org http://eptousa.altervista.org EPTO (A) epto@usa.com -------------------------------------------------------------------------------- [1] INTRODUZIONE: CHE COS'E' IL PROGETTO MAGNETO / DYNAMAGNETO Il progetto Magneto consiste nel riuscire a leggere e scrivere le schede telefoniche SIP/Telecom e studiarne la codifica. Fin dai tempi dei primi "magnetisti" che studiavano le schede, si sapeva attraverso un lentino magnetico a grandi linee dove erano scritti i dati della scheda. Si possono trovare anche una serie di datasheet a riguardo, indicano la posizione delle varie trame, ma le informazioni riguardano le schede del 2^o tipo (vedi seguito per la distinzione) e suggeriscono solo che le "barrette vericali" che stanno alla fine della scheda sono il credito e a grandi linee la posizione degli altri dati. Vedi immagine allegata: Magneto/image/ANABAND.gif La codifica delle schede telefoniche ed anche la modulazione sono un brevetto della Urmet e non sono stati diffusi dati tecnici. Lo studio sulle schede nasce da quando ho trovato per caso un "lettore sospetto" per terra a 100 metri da una cabina telefonica Digito. All'inizio non avevo intuito cosa fosse, ma poi ho riconosciuto l'apposita feritoia dove si inseriscono le schede! Ho eliminato la scheda di controllo che c'e' sul lettore della Digito (Lettore Urmet/IPM) ed ho creato un'interfaccia compatibile con il PC. L'unica cosa che potevo fare era interfacciarmi direttamente alle parti meccaniche del lettore non avendo subito capito il funzionamento completo del lettore. Collegando opportunamente le testine magnetiche del lettore alla scheda audio, dopo la prima lettura ho ottenuto il wave della banda magnetica (vedi immagini allegate: Magneto/image/WAVE.gif e Magneto/image/Banda.html). Dopo vari studi sui wave di piu' schede telefoniche ho fatto il programma Magneto che consente di leggere e scrivere schede basate sul sistema Urmet (non necessariamente telefoniche). Puo' leggere e scrivere le schede telefoniche Urmet/Telecom/SIP. La modulazione: Si tratta di un sistema pseudo-ternario che viene intervallato da degli spazi costituiti da interruzioni del segnale. La modulazione pseudo ternaria si evidenzia dal fatto che non esistono sequenze arbitrarie di + 0 - ma che le sequenze di poli diversi da zero sono sempre alternative: Dopo un + c'e' sempre un - Dopo un - c'e' sempre un + Non e' un sistema F/2F perche' esistono sequenze di spazi doppie ed il segnale si interrompe in piu' punti. Dopo l'evoluzione di Magneto per la lettura e la scrittura delle schede si e' pensato alla realizzazione del progetto DynaMagneto: DynaMagneto e' un programma simile a Magneto, ma riscritto da capo, che serve per leggere e scrivere qualunque tipo di scheda a banda magnetica con qualsiasi tipo di codifica e di struttura, anche inventata. In pratica e' un editor di schede magnetiche molto potente che permette di editare non solo le schede magnetiche, ma anche le loro codifiche, magari puo' essere usato per sperimentare nuovi sistemi di memorizzazione dati su banda magnetica. DynaMagneto non e' altro che l'abbreviazione di Dynamic Magneto ovvero l'estensione del progetto Magneto a tutte le schede di ogni tipo. -------------------------------------------------------------------------------- [2] STATO ATTUALE DEL PROGETTO MAGNETO / DYNAMAGNETO Il progetto Magneto continua sempre, siamo riusciti a leggere le schede telefoniche ed anche a scriverle. La codifica resta confermata, siamo riusciti a tracciare l'automa a stati finiti (vedi seguito) per verificare la validita' delle schede. Oggi siamo arrivati alla versione Open Extra di Magneto che non e' piu' legata al funzionamento del vecchio driver TVIcLpt, ma funziona con NinOut32 sfruttando gia' una versione ridotta dell'lptclass di DynaMagneto (vedi seguito). Essendo Magneto nelle prime versioni un programma sperimentale e' stato usato il driver TVIcLpt che e' un driver per l'accesso alla porta LPT sulla quale va collegato il lettore. Dalle versioni piu' recenti e' stato impiegato il driver NINOUT32 per l'accesso alle risorse I/O dirette. Da questo e' stata creata la LptClass che implementa le stesse funzionalita' di TVIcLpt, ma non e' piu' legata al driver precedente. La LptClass e' una libreria che utilizza le porte LPT con I/O diretto ed e' una valida interfaccia software per la porta parallela LPT. Gli algoritmi di lettura sono diventati "piu' resistenti" e Magneto puo' lavorare anche in condizioni piu' estreme per leggere le schede piu' vecchie che avevano rimbalzi dell'onda wave piu' marcati od erano piu' smagnetizzate o con un segnale piu' debole. Ora stiamo lavorando alla codifica dei byte per estrarre le informazioni come taglio della scheda, data di scandenza, numero di serie, etc... Stiamo sperimentando e testando tutti gli algoritmi di DynaMangeto. Il programma funziona dinamicamente su piu' livelli. Inizialmente non sara' impostabile tutto per mezzo della grafica, ma si useranno file XML (codec/rml) per impostare i parametri della codifica. DynaMagneto funziona cosi': Dall'inserimento della scheda si arriva ad una form dinamica che visualizza i parametri memorizzati sulla scheda in modo chiaro e semplice. Siamo riusciti a leggere molto bene queste codifiche: Ternario, Pseudo-ternario, F/2F, FSK, ASK, Fn/F (dove n e' variabile), Manchester, MFM, MLT-3 e molte molte altre... Eccetto Fn/F sono tutte codifiche standard. Fn/F e' una codifca implementata come tutorial di una codifica inventata per testare DynaMagneto. Legge gia' trame di tessere sanitarie, carte di credito, schede telefoniche, etc... Si possono eseguire moltissime operazioni sui bit ed i byte, addirittura sulle onde in caso di modulazioni "X" definite dall'utente. Supporta piu' tracce, si possono definire le singole posizioni e dimensioni per ogni banda, si possono definire le codifiche e le modulazioni per ogni singolo token in una banda. Sto anche lavorando ad un sistema intelligente di riconoscimento delle schede composite (fatte a piu' codifiche miste). Se riesce del tutto e' un bel programmaccio! Siccome il programma fa uso intensivo di grafici ho riscritto la GUI prendendola da un mio vecchio progetto per evitare di usare la gestione grafica di Windows che nei vari 98, XP, NT, 2000 o altri cambia sempre ed e' brutta. Allo stato attuale e' disponibile la versione OpenExtra di Magneto (vedi archivio allegato: Magneto/stm4src.zip e http://magneto.r8.org per nuove versioni) per DynaMagneto il coding e' ancora in corso (per una preview vedi immagine Magneto/image/DYNA.jpg)... -------------------------------------------------------------------------------- [3] SCHEDE TELEFONICHE: FUNZIONAMENTO STRUTTURA CODIFICA (FULL IMMERSION) Spieghero' qui di seguito il funzionamento delle schede telefoniche descrivendo un livello alla volta. Partendo dal wave: Si nota un picco all'inizio. Questo e' il cancelletto di apertura (l'inizio della banda magnetica). A seguito c'e' uno spazio molto lungo (questo viene riconosciuto come spazio). A seguito c'e' una prima trama di dati/onde. Poi uno spazio. Poi un'oscillazione +- (separatore). Poi uno spazio. Una seconda trama di dati/onde. Poi uno spazio. Una terza trama di onde ripetitive (credito). Poi uno spazio. Un picco. Questo e' il cancelletto di chiusura (la fine della banda magnetica). In alcuni casi dopo il picco separatore +- puo' esserci una trama di onde/dati in piu' (la trama aggiunta). Ora vediamo nel dettaglio come funzionano queste onde: Sul nastro sono possibili solo 3 stadi: Positivo (+) Zero/Neutro (0) Negativo (-) La modulazione e' pseudo ternaria e funziona cosi': Un picco (oppure un quanto di tempo pari alla lunghezza del picco) corrisponde ad un impulso di clock (manda avanti di 1 bit). Quando c'e' un picco + o - viene considerato come un bit 0, tieni in considerazione la lunghezza del picco (non di una oscillazione). Quando c'e' uno spazio (grande quanto un picco) viene considerato un bit 1. Ovvio che in un'onda c'e' sempre un'oscillazione e che dopo un + ci puo' essere solo un - e dopo un - ci puo' essere solo un +. Questo vuol dire che non capitera' mai: ++ -- +0+ -0- Tuttavia ci possono essere dei rimbalzi: +r0- -r0+ (vedi immagine allegata: Magneto/image/Rimbalzi.gif) Si e' notato che le onde mano a mano che sono ripetitive sono sempre piu' forti (come se ci fosse inerzia) poi quando si arriva ad uno spazio talvolta la transizione e' lenta o ci sono proprio dei rimbalzi. Questa inerzia e' dovuta evidentemente a motivazioni elettroniche degli amplificatori oppure all'isteresi magnetica delle bobine della testina ed anche alla risposta dovuta al fatto che le bobine possono caricarsi e dar luogo ad un piccolo riflusso di correnti parassite. Per fare un esempio basta immaginare una retta orizzontale (e' l'asse X di un piano cartesiano che rappresenta il tempo). L'asse Y rappresenta la posizione di un punto attaccato con un elastico all' asse X. Se sposto il punto, questo torna verso l'asse X a 0 appena lo lascio. Se gli do un bel calcio questo torna anche oltre l'asse X, ritornando verso X=0, supera lo 0 e rimbalza nel quandrante negativo per poi tornare a 0. Si e' visto anche che al massimo gli spazi vuoti (i neutri, gli 0) possono essere non piu' di 2 di seguito. Per esempio si puo' fare: +- -+ +0- -0+ +00- -00+ Capiamo al volo che il sistema pseudo-ternario prevede: + = 0 - = 0 0 = 1 Questo ti fa capire che si decodifica cosi': +0-+-00+-+-00+-+-00+- = (Sostituzione) 010001100001100001100 A questo punto si deve tener conto che per il principio di oscillazione le trame di onde iniziano con una polarita' e finiscono con un'altra (come si vede nell'esempio di cui sopra +-+-+-+-+-) Le trame iniziano sempre con un +, finiscono con un - che NON SONO INCLUSI NEI DATI. E' come un'apertura e chiusura della trama. La struttura di una trama di onde/dati e': +- Vista la corrispondenza binaria ora possiamo passare al livello sucessivo. Riprendendo la nostra sequenza: +0-+-00+-+-00+-+-00+0- Leviamo i picchi iniziali e finali: 0-+-00+-+-00+-+-00+0 Decodifichiamo i bit: 0-+-00+-+-00+-+-00+0 10001100001100001101 Visto il numero divisibile dei bit in tutte le letture e il comportamento dei dati in tutti i casi, dopo prove e prove si e' scoperto che i dati sono dei nibble. I nibble sono sequenze a 4 bit, in questo caso MSB senza parita' che d'ora in poi chiameremo impropriamente byte da 4 bit. 1000 1100 0011 0000 1101.. etc... 1 3 C 0 etc... N.B: I byte sono descritti in esadecimale. L'ultimo byte e' il test con il sistema LRC ovvero la parita' di tutti i bit eseguita per mezzo di uno XOR di tutti i byte della stringa. Se e' corretto deve risultare "0". In alcuni casi risulta "3" oppure "C" (in schede del 2^o tipo). C'e' una limitazione dovuta al fatto che non possono esserci piu' di due spazi (0) di seguito e di conseguenza non ci possono essere piu' di due 1 di seguito. Questo taglia fuori i seguenti byte: 7 = 1110 E = 0111 F = 1111 Analizzando le stringhe di bit, si e' notata un'altra caratteristica costante ed anche ovvia: Prova a scrivere 13C3 ? 1 3 C * 3 1000 1100 0011 * 1100 * = Ci sono addirittura 4 uno di seguito e non e' lecito che ce ne siano piu' di 2. La soluzione e' mettere in mezzo un byte 0, cosi' il problema non c'e' piu'! 1 3 C 0 3 1000 1100 0011 0000 1100 Ora sappiamo che i byte che non vengono usati sono i seguenti (tra parentesi elenco anche il motivo): 0 = 0000 (Elimina i troppi 1 tra i byte) 7 = 1110 (Ha 3 uno di fila) B = 1101 (Non c'e' mai anche se si puo' scrivere tranquillamente) E = 0111 (Ha 3 uno di fila) F = 1111 (Ha 4 uno di fila) Rimangono: 123456 89A CD 11 possibili nibble! Se siamo molto svegli notiamo anche una cosa, grazie al + iniziale non c'e' il problema per sequenze che iniziano con 1 che poi sarebbe rappresentato come uno spazio e farebbe perdere l'inizio della trama durante la lettura. Grazie alla forma +- questo problema non sussiste. Ma alla fine potrebbe finire con uno spazio, ma grazie al - finale non si perde la fine della trama. Come dicevo nella forma +- i + e - finali non sono inclusi nei dati percio' meglio chiarire subito un dettaglio: ... 0100 FINE (-) dove '...' sta per cio' che c'e' prima. Come lo traduco? ... -0+- + (non si puo' fare) ... -0+- - (non si puo' fare) Aggiungere un byte 0 e' uno spreco, allora se c'e' un finale di una trama che e' un picco - viene aggiunto un bit 0 (o se preferisci un picco +): ... -0+- + - Cosi' la trama viene chiusa correttamente. Allora riassumiamo: Viene usato il sistema pseudo ternario: 0=1 +=0 -=0 L'oscillazione e' continua: -+-+-+-+-+-+-+-+ Ci sono i rimbalzi da togliere. Ci sono piu' elementi separati da spazi. La forma e': Picco Trama Separatore Trama Trama/Credito Picco I byte sono a 4 bit MSB senza parita'. C'e' LRC alla fine (chiamato in Magneto LRU). C'e' un controllo sui picchi delle onde. Non ci son i byte: 0 7 B E F Il byte B non appare mai (non e' usato). Il byte 0 spezza le sequenze di 1 consecutivi tra i byte. I dati sono contentuti tra picchi + e - ( +- ) Viene aggiunto un picco + se la trama finisce con - Questo sistema controlla i picchi e verifica una parita'/disparita' sui picchi a livello ternario per controllare se ci sono errori. Il sistema pseudo-ternario e' resistente a cambi di velocita' (salvo quelli umanamente impossibili). C'e' un LRU che verifica i dati della trama. Capito questo possiamo passare al livello sucessivo, le trame: Per facilitare la scrittura di un'intera scheda telefonica mi sono inventato il formato MTEX: M come Mangeto, TEX come TEXT. Funziona cosi', associo ad ogni cosa un simbolo piu' congeniale: { = Cancelletto di apertura } = Cancelletto di chiusura | = Picco di separazione 012345689ABCD = Dati ° = Bit 0 (alla fine) ' = Bit 1 (alla fine) () = Tra questa parentesi metto il credito in numero evitando di scrivere tutti i 33333333 (per il motivo vedi oltre): Se e' 3.50 euro metto (3.50E). Se sono 35 unita' metto (35). Se sono 6000£ metto (6000£) se sono 3.50 Euro ed un bit zero metto (3.50E°). Se voglio essere cosi' malato da mettere tutti i 3 (vedi seguito) scrivo con queste parentesi: [3333333] Nel caso dell'euro tra parentesi () posso anche mettere il simbolino dell'euro. Lo spazio corrisponde allo spazio, uno spazio extra come il doppio spazio (magari serve a qualcosa) e' il carattere _ In pratica: {<1^a Trama> | <2^a Trama> [] } Detto questo scrivo qui il contenuto completo di una scheda telefonica della SIP da 10.000£ scarica (la famosa "Compagna di tutti i giorni" meglio conosciuta come "portafoglio"). {13C03C0942946816CC8432966664296433A19643 |333 A194332DCCC8642D84 [3']} Si vede subito che c'e' una trama in piu' e che c'e' solo un 3' alla fine. Non ho scelto la scheda a caso, ora spiego tutto: Ho diviso le schede in 3 tipi: 1^ Tipo: { | } Scheda tel. Normale (Recente) 2^ Tipo: { | 333 } Scheda Tel. Normale (vecchia e Recente) 3^ Tipo: { | } Scheda Tel. Speciale (Concorsi o tariffe speciali) Questa e' la prima trama: 13C03C0942946816CC8432966664296433A19643 Questa e' la trama aggiunta (non c'e' sempre): 333 Questa e' la seconda trama: A194332DCCC8642D84 Questo e' il credito: [3'] Capito questo, passiamo al livello sucessivo: Secondo i "magnetisti" il credito veniva memorizzato in una serie di barrette verticali. Basta immaginare che loro vedevano la scheda dall'alto, noi la vediamo di taglio: Le barrette verticali sono delle sequenze fatte cosi': + -+00 -+00 -+00 -+00 -+00 -+00 - Onda ternaria 1100 1100 1100 1100 1100 1100 Bit 3 3 3 3 3 3 Byte | | | | | | Barrette verticali ovvero unita' di credito da 200£ o 10 eurocent (esclusa una) Gli spazi che ho scritto qui servono solo per dividere i byte! Ogni singolo 3, o barretta se preferite, corrisponde ad un'unita' di credito del valore di 200£ o di 10 centesimi di euro, escluso un 3 o barretta. Questo 3 in piu' distingue il credito dal separatore. Questa trama non ha LRU! Una scheda scarica ha solo un 3 che diventa: 1100 + 00-+ - Sulle schede vecchie quando erano scariche aggiungevano anche un bit 1 alla fine: 1100 1 + 00-+ 0 - Ora vediamo come funziona la prima trama: 13C03C0 9 4 29 46816CC8432966664296433 A19643 13C03C0 e' il magic number che e' una sequenza sempre identica per riconoscere le schede telefoniche. 9 e' il codice di applicazione 9 = Scheda 2 = Test card (A riconferma della tesi che il byte "0" spezza le sequenze di 1 tra i byte: sulle schede normali la 1^a trama inizia con 13C03C09 = 13C3C9 Sulla scheda test il 9 e' sostituito con il 2 percio' si ha 13C03C2 = 13C3C2) 4 Tipo di scheda 29 Resta invariato in schede dello stesso tipo 46816CC Codici che seguono un'automa a stati finiti (vedi seguito) 8432966 6642964 33 A19643 Resta invariato in schede dello stesso tipo Ora la seconda trama: A194332DCCC8642D84 Solo nelle schede vecchie o del 2^o tipo ci sono molti CCC di seguito. Ora un confronto con schede del 1^o e del 2^o tipo a distanza di 10 anni: (Gli spazi allineano le 2 schede, ma in realta' non ci sono. I veri spazi sono rappresentati con "_" ) Anno Trame Valuta Tipo 1993/1994 _ 333 _ A19433 2DCCC8 642D84 (Lire) 2^o Tipo 2003/2004 294333294329433 329666 642D84 (Euro) 1^o Tipo Nel 1993/1994 non esisteva ancora la rete intelligente che in teoria avrebbe tutti i codici di tutte le schede e verificherebbe il credito da remoto. L'unica differenza palese sta nelle sequenze: 2DCCC8 329666 Con 11 simboli (in base 11) e 6 cifre si possono memorizzare solo 1.771.561 schede (un numero un po' corto per confrontarlo con quello che si trova scritto visibile sulla scheda telefonica). Tutte le schede vecchie avevano sequenze anche piu' lunghe di 2DCCC8. Ora la trama aggiunta: Su schede del 2^o Tipo e' sempre 333 Su schede speciali per esempio contiene: A19643A9 Cio' comporta meno codici per la trama sucessiva. Questa trama e'ancora in fase di studio. Capito questo possiamo passare al livello sucessivo: Tutte le trame seguono (sono valide) rispetto ad un'automa a stati finiti, la cosa assurda e' che non potendo usare tutti i byte siano riusciti con un automa a stati finiti a fare sequenze che hanno LRU=0 e che non violino il codice proprio avendo magari un LRU su 7, B, E, F. Ma che cos'e' l'automa a stati finiti delle schede? Supponiamo che ogni numero sia un incrocio da cui dovrebbero (visto il sistema) partire 11 collegamenti ad altri 11 numeri e dovrebbero arrivare 11 collegamenti a tutti i numeri (questo se l'automa non ci fosse). Per esempio se esistessero solo i simboli ABC sarebbe cosi': A -> A B -> A C -> A A -> B B -> B C -> B A -> C B -> C C -> C Se sono su "A" posso andare a scelta tra A, B, C. E questo anche per altre lettere. In questo caso posso scrivere tutte le sequenze non banali (non vuote) di A, B, C. Ma se fosse: A -> A B -> C C -> A A -> B C -> B Non potrei scrivere tutte le sequenze possibili, potrei scrivere per esempio: AABCABCBC Perche' i soli cammini consentiti sono quelli. Non potrei scrivere: ACBACC Perche' A non va a C Perche' B non va a A Perche' C non va a C Un sistema del genere e' stato usato per le schede telefoniche con tutti i simboli esadecimali. Lo riporto qui mettendo anche il punto "." che significa fine della trama. I cammini sono scritti in questo modo: Per esempio: 1 => 357 Vuol dire 1 va su 3 oppure su 5 oppure su 7 N.B.: Ho messo anche lo Zero. 0 => 369A 1 => 2369D 2 => 23459D 3 => 23AC. 4 => 02346A. 5 => 4 6 => 3468C 8 => 0146 9 => 1468. A => 1489C C => 028C D => 8C Tra l'altro le cifre 3 6 C sono sempre ripetitive. Come si puo' vedere nessun numero ha 22 accessi (11 in ingresso e 11 in uscita) percio' c'e' l'automa. Poi c'e'anche una sintassi: ci sono delle stringhe che sono ripetitive e comunque i cammini degli automi a stati finiti hanno dei passaggi e dei percorsi che si susseguono in una certa logica. La prima trama e' ancora in fase di studio, vi riporto alcune sintassi (cioe' quelle della seconda trama e della trama aggiunta): Queste sono le piu' ricorrenti: 333 294333294 296+ 3+29[4] A19[6]4[3]A9+1 8[6]4[3+][2] [2]D[C+]84[A19]. 1D[C+]8[6]4[3+][A91] Dove [] sta per facoltativo, '+' sta per stringhe non banali (ad esempio 3+ stringhe non banali di 3 ovvero 3, 33, 33333, etc..). Una tipica stringa puo' essere: 294333294A19643A99912DCCC84A19 Ho inventato una trama un po' lunga! Riassumendo: Vengono verificate le onde. Vengono verificate le polarita'. Vengono verificate le trame con LRU. Vengono verificate le trame con i codici e l'automa. Il credito e' contenuto nella parte finale della scheda. Le schede con concorsi o tariffe particolari (3^o Tipo) hanno la trama aggiunta con diversi codici, che sia un numero di serie oppure un identificativo dell'applicazione tariffa o concorso??? In alcune schede non c'e'. In altre e' solo 333. 333 in base 11 e' 2906 secondo l'alfabeto 12345689ACD ? Lascio l'interrogativo con alcune schede: Compagna di tutti i giorni {13C03C0942946816CC8432966664296433A19643 | 333 A194332DCCC8642D84 [3']} Stop AIDS {1124024804020440846491923A991923ACC8° | A19643A9 296642D84 [3]} (La prima trama non e' corretta perche' la scheda e' rovinata) Dilungatevi pure {13C03C09129123C0942542542942D843A84A44|294333294329433329666642D84 (3E)} Urmet Test Card (Prototipo) RARISSIMA {13C03C2246840632980AC864296664A9194333 | 333 2DCC8666432DC84A19° [3'']} Seconde trame: 294333294329433329666642D84 333 A194332DCCC8642D84 333 2964A991D8643323D84 333 1D86433A91DCCC842D84 333 2DCC8666432DC84A19 333 329432DCCCCCCC84A19 -------------------------------------------------------------------------------- [4] LA LETTURA PASSO PASSO (dalla scheda al dump dei dati) La lettura di una scheda telefonica o magnetica di qualsiasi tipo con Magneto non e' sempre diretta, se la scheda e' nuova ed e' letta correttamente dopo averla inserita nel lettore (o dopo aver aperto il wave) Magneto visualizza il contenuto corretto. Se la scheda e' stata letta male oppure non e' stato possibile ritrovare correttamente il livello minimo (o altri parametri) avviene una lettura distorta. Per capire se una lettura e' corretta (nel campo delle schede telefoniche) Magneto ha 3 strumenti di verifica che si trovano sulla finestra della scheda: Ci sono 3 spie sotto il dump della banda magnetica: 3 DATI LRU Se sono tutte verdi la trama e' corretta, in alcune trame LRU non e' da considerare. LRU viene considerato in questi casi: Schede del 1^o Tipo: Dati LRU 3 1^a Trama Si Si Si 2^a Trama Si Si Si Credito Si X Si Schede del 2^o Tipo o schede speciali del 3^o Tipo: Dati LRU 3 1^a Trama Si Si Si Trama aggiunta Si X Si 2^a Trama Si X Si Credito Si X Si X = Condizione di indifferenza, ovvero Si' o No non cambia nulla! L'altro strumento e' il tasto "rileva" che controlla la scheda in tutte le sue parti e riconosce secondo gli studi fatti che tipo di scheda e'. L'altro strumento e' l'integrita' del segnale in ampiezza e frequenza: Sono quelle due barre a destra che devono avere l'indicatore su verde, tra l'altro viene visualizzata la banda magnetica vista dall'alto come se ci fosse un lentino magnetico. Se una parte e' rossa e' evidentemente letta male. Se la lettura non e' corretta basta andare sulla finestra "wave della banda" e spostarsi all'inizio della prima trama, per fare questo piu' semplicemente puoi andare anche sulla finestra "scheda", selezionare la prima trama e cliccare sul tasto a sinistra "trova": il wave verra' posizionato sul punto corretto della banda e sara' possibile vedere sulla visuale tipo lentino magnetico la trama evidenziata con un riquadro giallo. Sulla finestra "wave della banda" basta vedere l'onda wave (quella verde) e trovare un rimbalzo (un punto +-0- per esempio), cliccare col tasto sinistro del mouse dove inizia il rimbalzo, cliccare col tasto destro del mouse dove finisce il rimbalzo. Si evidenzia una porzione dell'onda (solo il picco sbagliato). Sul menu' "Selezione" si clicca su "imposta come" e poi "rimbalzo". Questo cambia il valore minimo che e' indicato da 2 rette orizzontali rosse. Basta cliccare poi su "traduci" e la finestra "scheda" viene aggiornata. Se ci sono errori nell'onda andranno rimessi a posto manualmente. Per provare a fare questo sul sito di Magneto c'e' un file di esempio che si chiama esercita.wav. E' una banda magnetica creata in laboratorio (Magneto si lamenta perche' non e' una situazione decisamente reale). Per altre informazioni a riguardo dalla versione OpenExtra esiste la guida completa. Stiamo anche preparando dei video per rendere anche piu' facile interpretare la guida (Magneto fa tante cose!). -------------------------------------------------------------------------------- [5] IPOTESI VARIE ED EVENTUALI SULLE CODIFICHE Ci sono stati molti esperimenti e molti test sulla codifica della banda magnetica, un'ipotesi tra le tante e' stata avanzata da Alex36987: Si presume che la banda magnetica sia codificata in f/2f a mezz'onda con l'ausilio dello "0" e poi in mfm. Questo tipo di modulazione non e' f/2f perche' ci sono sequenze 0 e 00 messe non a caso, ma con ordine logico. Poi verrebbe smentito dal fatto che se ci sono sequenze nel sistema pseudo ternario del tipo: xx11 0000 1xxx xxx1 0000 11xx xx11 0000 11xx Viene aggiunto un byte 0 che sono 4 onde -+-+ o +-+- Si incasinerebbe poi con i bit 0 aggiunti alla fine se la trama finisce con - Francamente un f/2f inizia e finisce con la banda, non si interrompe in piu' punti. La codifca f/2f consiste in un segnale che e' lungo tutta la banda magnetica che modula 0 o 1 in base al fatto che un picco sia o meno la frequenza di clock oppure il doppio. Si implementa anche con picchi della stessa frequenza mettendo nell'istante dello zero crossing (quando l'onda passa per zero) uno zero (un quanto di tempo con polarita' neutra 0). Comunque ecco come funziona l'ipotesi sopracitata: La nostra sequenza di esempio: +0-+-00+-+-00+-+-00+- Si legge un picco alla volta e risulta 0 o 1 se tra i picchi ci sono degli 0. +0- -+ +- -00+ Trascuriamo 00 +- Etc... Sulla sequenza di bit ricavata, l'ultimo bit e' la parita' di tutto. Poi viene applicata la codifica MFM prendendo i bit a 2 a 2: 00 = 0 01 = 1 10 = 1 11 = Errore Fatto questo la trama diventa molto piu' piccola. Tra l'altro poi non fa una grinza nemmeno questa codifica. Certo non c'e' un LRU, un CHECKSUM o altro che ci faccia intuire se questi dati letti sono corretti. Fatti vari test si e' visto che finche' sono schede comuni il sistema MFM da' validita' quando da' validita il sistema pseudo-ternario. In pratica se una scheda risulta corretta per il sistema MFM in F/2F (quello dell'ipotesi) risulta corretta anche per il sistema pseudo ternario. Questo non avviene in tutti i casi: Non avviene sempre con le schede del 2^o e 3^o tipo che danno LRU = C Non e' nemmeno stabilito di che lunghezza siano i byte, sembra variabile. Tra l'altro ci si accorge che nel sistema pseudo ternario e' possibile leggere una scheda valida per il sistema pseudo ternario che pero' non sia valida per il sistema con MFM. Il sistema pseudo ternario ha molti controlli per la validita' della scheda. Un'altra ipotesi e' che la codifica sia F/3F: +- = 0 +0- = 1 +00- = 2 (valido anche per le polarita' inverse). La nostra sequenza: +0-+-00+-+-00+-+-00+- Verrebbe letta cosi': +0- 1 -+ 0 +- 0 -00+ 2 +- 0 -+ 0 +- 0 -00+ 2 +- 0 -+ 0 +- 0 -00+ 2 +- 0 Magari corrisponde direttamente a MFM saltando un passaggio: +- = 00 = 0 +0- = 01 = 1 +00- = 10 = 1 Oppure e' una codifica in base 3: 1002000200020 Un'ipotesi e' che secondo il sistema pseudo ternario siano sequenze a 12 bit: {13C03C0942946816CC8432966664296433A19643 | 333 A194332DCCC8642D84 [3']} 13C 3C9 429 468 16C C84 329 666 642 964 33A 196 43 333 A19 433 2DC CC8 642 D84 C'e' un sistema che consente di scrivere i byte liberamente e poi vengono codificati per usare solo 11 simboli. Oppure che ci sia di mezzo un alfabeto in base 11: 12345689ACD = 0123456789_ Oppure che ci siano dei caratteri di controllo ed un alfabeto ottale: 12345689ACD = .01234567.. Oppure: 01234567ACD Insomma ci stiamo ancora lavorando.... -------------------------------------------------------------------------------- [6] SCELTA DEL COMPILATORE, LINGUAGGIO VISUALE, INTERFACCIA GRAFICA. Purtroppo Magneto non e' ancora multipiattaforma, come compilatore e' stato usato Visual Basic 6. Il programma gira sotto varie versioni di Windows: Windows 98 Windows 98Se Windows NT Windows 2000 Windows ME Windows XP Inizialmente volevo fare il programma in C++, ma c'e' un piccolo particoalre che mi ha fatto cambiare rotta: la mia necessita' era fare un programma che operasse ad alto livello con molta grafica (per vedere grafici, fare esperimenti in real time, modificare velocemente il programma senza essere troppo vicino al linguaggio macchina, avere la possibilita' di vedere il contenuto di variabili in memoria, seguire il debug passo passo, etc...). Per ogni esperimento mi servono grafici che vengano su rapidi. Allora ho dovuto usare il sistema Windows e visto che Visual Basic e' un compilatore per applicazioni Windows in modalita' visuale, non mi sono mosso a lavorare in modalita' testuale e riga di comando. Tuttavia l'interfaccia di Windows ti rompe le balle per alcune cose: non e' facile in VB6 fare alcuni accorgimenti grafici come per esempio le icone come un desktop, ogni sistema operativo le visualizza come vuole, cosi' ho creato il desktop virtuale prendendo un mio vecchio programma addirittura scritto in QB45 ed in assembler, lo ho tradotto in VB6 rifacendo cosi' le icone ed il desktop. Mi serviva anche la possibilita' di usare un linguaggio che programmasse in modo lineare, ad oggetti, ad eventi e che non avesse un minimo tipi dinamici (penso che Java sia un po' una porcheria per fare Magneto), cosi' ho scelto Visual Basic 6 che me lo giro come voglio! Addirittura in DynaMagneto ho rifatto proprio la GUI da capo, cosi' posso mettere i menu sulle MDIForm, posso mettere le icone come un desktop a parte, so come viene visualizzato, posso mettere l'immagine di sfondo, posso mettere delle OCX fatte da me piu' belle. Posso anche creare form dinamiche, mentre in VB6 e' difficile. Sono state aggiunte anche nuove routine di base al linguaggio tramite molte classi e dll (come per esempio VBE Visual Basic Extended by EPTO). Ho aggiunto addirittura la possibilita' di compilare alcuni file per il programma all'interno del file EXE stesso. Insomma lo ho spinto oltre le sue possibilita', di VB6 classico e' rimasto poco. -------------------------------------------------------------------------------- [7] ALGORITMI DI MAGNETO: FUNZIONAMENTO ED IMPLEMENTAZIONE Il programma e' sviluppato su piu' livelli e ognuno di questi si occupa di una parte della traduzione dal wave ai byte e viceversa. Ecco (per riferirsi) le principali parti: Moduli di Magneto: WaveLevel Questo modulo esegue tutte le funzioni sul wave a basso livello, esegue anche la conversione in wave ternario. Wavesolder Modulo che gestisce il trattamento a livello intermedio del wave. Contiene: DynaNorm Normalizzazione dinamica GetPiccoMini Rileva il valore minimo GetWaveMatrix Rileva la matrice wave RilevaFondo Riconosce il rumore di fondo RemoveReboun Elimina i rimblazi WaveTern Questo modulo riconosce il sistema ternario. Contiene: AggiustaTernario Corregge gli errori -- ++ ClockDetect Rileva il clock dei dati FreQScan Rileva la stabilita' della banda magnetica trama per trama AnalizzaPicco Analizza ogni singolo picco dell'onda MakeObjs Crea la lista di picchi e di oggetti Tipi: Obj E' il tipo di dati per creare la lista di informazioni sul wave. WaveBinary Questo modulo esegue la traduzione finale e tratta i byte della scheda. Contiene: TramaCheck Controlla la correttezza della trama letta Stream2Byte Da insieme di bit a byte UrmetDecoder Dalla stringa ternaria riconosciuta decodifica tutta la scheda in ogni sua parte UrmetEncoder Dalla scheda crea la stringa ternaria per la scrittura Tipi: Token Oggetto della banda magnetica Skeda Oggetto della scheda magnetica WaveWrite Questo modulo si occupa della scrittura. Contiene: WriteToWav Crea il wave della banda da scrivere Skedakey Controlla la scheda secondo gli automi a stati finiti, etc. LettoreMod Gestisce il lettore/scrittore. GapModule101 Dalla versione 101 di Magneto c'e' questo modulo che rileva il gap dal picco di separazione. BitWise Contiene tutte le funzioni per operare sui bit. Ci sono altri moduli (il doppio tra finestre e robe varie, questi sono quelli piu' importanti). Inizieremo da WaveLevel: Viene caricato il wave della banda magnetica in un array che contiene il PCM. Il wave viene normalizzato. La prima funzione ad intervenire e' RilevaFondo. In seguito con GetPiccoMini si riconosce il picco minimo dal wave della banda. Per rilevare il fondo basta ricampionare la scheda con risoluzione bassa, vedere dove sono i valori piu' bassi rispetto alle trame (all'inizio ed alla fine, tra gli spazi) calcolare tra questi il valore piu' alto e piu' usato. Per rilevare il valore minimo basta, dopo aver tolto il rumore di fondo, dividere il wave (Wpk) in tronconi con un sistema di zero crossing, ovvero l'onda viene messa nel troncone corrente finche' non passa per lo 0 o cambia direzione. Si prendono poi i tronconi e si trova il modulo del valore piu' alto. Si mette in un array in modo crescente e con una risoluzione ridotta che ci serve per evitare gli intoppi. Da questi tronconi si cancellano tutti i picchi sotto al rumore di fondo. Si fa anche una statistica di quanto riappaiono i valori dei picchi. Viene scelto un valore che sia il minimo, ma usato (GetMinSoglia). Questo valore, tolto il fondo, e' il valore del picco piu' basso appartenente al segnale (salvo somme strane di onde). Viene anche controllato se la misura e' coerente con il livello minimo rilevato prima. A questo punto GateSoglia leva i rumori di fondo di mezzo, portandoli a 0. GateTern trasforma cosi' i valori PCM in 3 Livelli + 0 -. MakeObjs attraverso un ciclo con AnalizzaPicco crea una lista di tutti i picchi e tutti gli spazi rilevati dal wave (Obj). Il nostro wave della banda e' diventato una lista di informazioni che si puo' vedere sulla finestra "wave della banda" sottoforma di divisioni verticali con le scritte + 0 - R G etc. Viene vista a questo punto consultando la lista la frequenza media del segnale. Viene chiamata ClockDetect che si occupa di trasformare gli spazi in divisioni o bit 1, rileva il clock del segnale. ClockDetect aggiunge informazioni alla lista OBjs e riconosce i Gap delle onde nei passaggi +- -+ per evitare di incappare in errori. Visualizza anche il rapporto tra l'ultimo picco e lo spazio (scritto in blu sul wave) per dare ulteriori informazioni. Vengono controllate le trame e/o viene eseguita la normalizzazione dinamica DynaNorm. Tutte le onde vengono portate a livello alto e corretto. A questo punto occorre ripetere i passaggi di sopra perche' il wave puo' cambiare: vengono rilevati fondo e valore minimo. Il wave viene convertito in Ternario con WaveTrinaryconvert. Viene creata la Matrice Wave con GatWaveMatrix. Vengono eliminati i rimbalzi con RemoveRebound. Si tiene conto del fattore relativo: se un'onda si e' mossa molto transitera' lentamente quando passa per 0. Viene rianalizzata l'onda ciclicamente piu' volte, finche' tutti i picchi sono ai livelli giusti. Viene usata ClockDetect per ottenere la lista corretta e viene passata a UrmetDecoder che decodifica tutto e crea l'oggetto Skeda. Viene controllata la stabilita' della banda magnetica. A questo punto se e' tutto corretto il programma finisce l'operazione, altrimenti riprova con valori diversi. I passaggi sono: Wave Wave a 3 livelli Liste oggetti: + f=100 a=20 0 f=100 a=0 - f=100 a=20 etc. Ternario: - +0-+-00+-+-00+-+-00+-+-00+-+-0+-00+-+-0+-0+-00+-+-0+-00+-+-00+-+-... +- +-0+-0+-0+-0+00-+00-+00-+-0+-0+-0+-0+00-+-0+-0+-0+-0+00-+00-+00-+... +00-+00-+00-+00-+00-+00-+00-+00-+00-+00-+00-+00-+00-+00-+00-+00-+... + Token: { | } Bit: 0100100100101100110011000100100100101100010010010010110011001100 ... etc... Trame: 13C03C09129123C0942542542942D843A84A44 294333294329433329666642D84 3333333333333333333333333333333 Scheda: {13C03C09129123C0942542542942D843A84A44 |294333294329433329666642D84 (3E)} Analizzando vari wave ed utilizzando i vari algoritmi sono emersi dei teoremi sulle onde abbastanza interessanti: RUMORE DI FONDO: Per trovarlo basta cercare tra i valori piu' bassi escludendo i segnali piu' forti, i valori piu' alti. E' una cosa elementare da fare: si trova al parte di segnale piu' bassa (per zone), poi da questa si escludono i segnali piu' forti. Il valore piu' alto tra i rimanenti e' il rumore di fondo. VALORE MINIMO: E' il primo picco piu' usato e piu' basso dopo il rumore di fondo. VALORE CORRETTO DI DYNANORM: Il valore piu' usato tra i piu' alti (in ampiezza del picco). FATTORE RELATIVO: Amplificando con DynaNorm, o per effetto della modulazione analogica delle schede, un'onda puo' transitare in +0- o -0+ facendo sullo 0 una transizione lenta ed ingannevole. Questa transizione e' tanto lenta quanto piu' e' alta l'onda e tanto piu' e' preceduta da oscillazioni complete. -------------------------------------------------------------------------------- [8] DATI TECNICI SU MAGNETO E LETTORI FATTI IN CASA, PER COMINCIARE A LEGGERE E SCRIVERE LE SCHEDE. Un lettore che possa funzionare correttamente con Magneto puo' essere: * Il lettore alternativo di Alex36987 (solo lettura) Vedi: http://eptousa.altervista.org/progetti/magneto/inta2/ * Il lettore Digito modificato. * Un lettore fatto in casa. Come progettare un lettore/scrittore fatto in casa: La prima cosa da fare e' trovare una testina per un registratore audio. Bisogna sapere che siccome e' di forma diversa occorrera' fare molte prove per azzeccare l'azimuth (l'angolo della testina rispetto al nastro). Una volta costruita l'interfaccia come descritto nel progetto Magneto: Vedi: http://eptousa.altervista.org/progetti/magneto/int/ (un sensore ottico vicino alla testina, un sensore per l'ingresso della scheda nel lettore, un sensore sulla ruota dentata del motorino, etc.) occorre tener conto appunto della ruota dentata del motore. Si consiglia di collegarla meccanicamente attraverso ingranaggi e non cinghie. Questa ruota deve essere grande ed avere molti fori, puoi anche giocare su riduzioni o moltiplicazioni meccaniche. Questi fori interrompono il sensore ottico e informano Magneto sulla velocita' e sulla posizione della banda magnetica. Una cosa che deve essere fatta lentamente e' contare le seguenti misure di impulsi (fronte di salita e fronte di discesa) del rotore: Lunghezza della scheda durante il passaggio sotto la testina: Quando il sensore della testina va a 1 bisogna contare quanti impulsi il rotore genera prima che la scheda finisca. Questo parametro e' la lunghezza della scheda. ZonaExit: Quanti impulsi servono per far uscire la scheda telefonica dopo che e' passata tutta sotto alla testina (quando il sensore della testina torna a 0). Lunghezza + ZonaExit + IngressoScheda = Percorso di tutta la scheda. Occorre mettere un condensatore in serie tra le testine e l'input MIC del Computer per evitare che l'alimentazione del microfono esterno danneggi le schede durante la lettura. Si sconsiglia di utilizzare l'amplificatore audio di un registratore a cassette perche' non e' del tutto fedele all'onda wave della banda: Ha una pendenza di -20 dB per decade, sulle cassette audio viene sovrapposta una frequenza di bias per enfatizzare i toni alti ed eliminare la pendenza di 20 dB per decade del nastro magnetico. Trovate le misure di prima, basta andare sul menu' opzioni di Magneto, alla voce Imposta Lettore. Nel riquadro Dimensioni: Alla voce ZonaExit va messo il numero di impulsi per far uscire la scheda. Alla voce Lettore va messa la lunghezza della scheda in impulsi. Poi occorre fare delle prove di lettura con diverse velocita'. Trovata la velocita' giusta cliccando sulla finestra Wave Della Banda al menu' Traduttore, sul tasto Trova della voce Zero Crossing apparira' la frequenza da mettere sulla finestra di calibratura del lettore alla voce Frequenza Di Scrittura nel riquadro Segnale. Esegui il test, ed inserisci la velocita' trovata, poi salvi il settaggio ed esegui il test. Fatto questo hai regolato tutti i parametri di Magneto per leggere e scrivere le schede telefoniche con il tuo lettore fatto in casa. Per fare delle schede compatibili con quelle telefoniche si possono usare dei fogli di cartoncino con appiccicato sopra del nastro di una cassetta VHS vergine; mettendoci poi sopra un peso, il collage viene uniforme. Si consiglia di seguire come esempio le vecchie schede SIP. -------------------------------------------------------------------------------- [9] HDSS: HARDWARE DIGITO SMANETTAMENT SYSTEM. HDSS (in inglese maccheronico) e' un progetto collaterale di Magneto sull'analisi del funzionamento della lettura/scrittura delle schede telefoniche effettuata dalla Digito con tecniche di debug applicate direttamente sull'hardware della Digito. Viene collegata una Digito accesa al computer e tramite vari strumenti di analisi degli stati logici viene fatto un reverse hardware della Digito e dei relativi segnali che circolano dentro. Ci focalizzeremo per ora su 2 componenti: * Scheda logica * Lettore Urmet/IPM Sulla scheda logica ci sono 2 processori: * HD6433047 * 68LC302 Il core principale e' costituito dalle 2 CPU, da una serie di memorie RAM, una scheda EEPROM collegata come espansione, 2 EEPROM siglate come MEW 320 e MEW 321. In questo articolo descriveremo l'HDSS relativo al processore HD6433047 (Microcomputer Processore multiprotocollo della hitachi). Questo processorino ha tutta una serie di pin I/O programmabili con vari ingressi analogici, infatti tutti i segnali del lettore arrivano analogici fino a qui. Nel lettore ci sono dei dispositivi di comando, amplificatori dei segnali, una EEPROM AT24LC02 (famosa per essere quella delle chiavette connectionless) contente i dati del lettore e il sommario delle operazioni compiute dal lettore sotto forma di statistiche. In realta' la lettura viene fatta dalla scheda logica e dal microcomputer. Sulla scheda logica ci sono degli stadi analogici che sono basati su amplificatori operazionali in grado di normalizzare il segnale (rimbalzi compresi): in pratica gli algoritmi DynaNorm e tutto cio' che riguarda il modulo WaveSolder di Magneto viene eseguito dalla scheda logica. A seguito di un errore commesso da noi siamo riusciti ad avere un dump non del tutto fedele del work in progress all'interno del databus della Digito. Collegando l'ingresso della scheda audio alla data line della CPU nel punto di collegamento con la RAM abbiamo registrato qualcosa che e' un disturbo generato da diversi Mega hertz che la schedina audio non ha ovviamente potuto digitalizzare del tutto. Analizzando lo spettro dell'onda, come facevo nel 1992 con i cicli macchina dell'MSX (un computer basato su Z80), con una tecnica simile al Tempest, sono risucito a vedere cosa potrebbe fare la CPU (vedi immagine allegata: Magneto/image/CPUSTM.gif). In primo luogo si vede che la CPU campiona ciclicamente il segnale della banda magnetica. In seguito fa dei cicli macchina per un breve periodo che hanno a che fare con il controllo del lettore. La sequenza pare essere: Ciclo { Qualcosa Ciclo { Lavoro intenso } Evento che esce dal ciclo Lavoro intenso } evento di fine banda Ciclo { poco segnale } fine ciclo A seguito c'e' un marasma che francamente non saprei cosa sia! A seguito si vede un ciclo macchina che segue fedelmente la forma d'onda letta dalla Digito (quella della banda magnetica). La forma dell'onda viene poi processata e cambia forma seguendo la sequenza della banda magnetica. A questo punto esce da una seriale una sequenza di dati che stiamo ancora cercando di decifrare, evidentemente non e' completa dal nostro punto di vista. Un dettaglio e' emerso dalla lettura dei wave attraverso gli stadi di ingresso della CPU: Nella prima parte della prima trama, gli impulsi - sono a distanze apparentemente casuali. Da un certo punto in poi gli impulsi - sono equidistanti nel tempo come se fossero un impulso di clock del sistema ternario. I rimbalzi amplificati come i segnali + fanno pensare ad una codifica del tipo: 0 = -0+ 1 = -+0 1 = -r+ I dati tirati fuori da questa codifca non hanno alcuna verifica interna tipo parita' o checksum e sembrano casuali, non si esclude una modalita' da parte della Digito che sia leggermente diversa da Magneto nella lettura, anche se per il momento l'unica ipotesi che regge e' quella del sistema pseudo ternario perche' ha piu' riscontro (99.99% dei casi) ed i checksum risultano validi. Si e' visto che si puo' collegare la Digito direttamente al computer e leggere le schede con il lettore originale facendole leggere dalla Digito alla velocita' giusta. Per fare questo implementero' nella prossima versione di Magneto due cose: * HDSS: Lettura dalla Digito. * DynaMagnetoLib: alcune librerie di DynaMagneto. Gia nella versione OpenExtra alcune parti dei sorgenti provengono da DynaMagneto, come per esempio la LptClass ed altri sistemi per le diverse codifiche. Queste librerie servono per implementare HDSS e le codifiche alternative poi verrano usate per rendere Magneto compatibile con DynaMagneto. La sperimentazione con HDSS e' ancora in atto... -------------------------------------------------------------------------------- [10] DYNAMAGNETO. DynaMagneto e' completamente realizzato in VB6 con alcune estensioni del linguaggio (le VBE di ROTOR.DLL). Il programma dispone di un'interfaccia grafica (WinGui 2006) ed e' composto da 9 progetti (e' un project group) e da una cinquantina di moduli. Teoricamente lavorera' sulla superficie della scheda e le tracce saranno definite da un file XML che appartiene al linguaggio codec/rml. Il programma si basa su una procedura reversibile che attraverso il linguaggio dichiarativo codec/rml elabora i dati e le schede di qualsiasi tipo e codifica supportata. Ecco come funziona la codifica reversibile di DynaMagneto: La prima parte e' quella fisica: Viene creata un'immagine MxN bitmap magnetica della scheda in corrispondeza delle tracce. La seconda parte divide le tracce: Vengono divise e riconosciute le tracce magnetiche della superficie e viene creato un wave multitraccia. La terza parte divide gli eventuali token o trame: Si occupa di divisioni interne delle tracce. La quarta parte si occupa della modulazione: Decodifica le trame di bit. La quinta parte si occupa della codifica dei dati: Si occupa di passare da sequenze di bit, codifiche, alle form dinamiche dove si possono modificare i dati in modo semplice ed intellegibile. Il tutto viene controllato dal linguaggio codec/rml reversibile di DynaMagneto. Con lo stesso codice e' possibile transcodificare schede, leggerle, scriverle e modificarle. E' un progetto ambizioso che purtroppo procede a rilento a causa dell'esiguo numero di collaboratori. La scelta del codice dichiarativo a layer di DynaMagneto e' dovuta all'implementazione del programma. Visto che XML era il linguaggio che si avvicinava di piu' alle nostre esigenze, lo abbiamo cambiato di qualche dettaglio per avere un codice piu' semplice. Codec/rml sta per: Encoder/Decoder Reversible Markup Language. Tutte le operazioni possono essere fatte dritte o rovesce con lo stesso codice che dichiara il funzionamento della scheda. Riporto un esempio di codec/rml nella sezione di dichiarazione della codifica di una traccia nel membro scheda.traccia.codifica: <$strlen1 NIBBLE HIDE> Questo definisce una classica situazione: 1 Nibble per la lunghezza della stringa di nibble espressa in nibble. N Nibble per la stringa nell'alfabeto esadecimale di lunghezza massima di 4 nibble. Visualizza nella form dinamica una casella di testo chiamata Dati, internamente la variabile si chiama 'stringa'. Esempio del dump della stringa '13C0': 413C0 Un tipico linguaggio codec/rml e' strutturato in diversi layer che sono annidati tra loro creando cosi' un oggetto dinamico di transcodifica. codifica ... In questo modo la prima versione di DynaMagneto usa un parser scritto da me per controllare tutto il programma. Allo stato attuale e' anche stato creato un generatore di parser per la classe Pharser di DynaMagneto e mi sono ritrovato a scrivere il codice dei sorgenti e del parser in altri ulteriori linguaggi dichiarativi piu' semplici. Ne riporto una porzione di codice: TAG{,* COMP CLO REQ,CAPTION $ Cap , FAC,SIZE $# FAC,NOT ! FAC,LSB ! FAC,MSB ! FAC,BENDIAN ! FAC,LENDIAN ! FAC,RENDIAN ! ... }, Sembra un misto tra assembly ed una dichiarazione di qualche tipo. Queste sono le prime righe del parser codec/rml nella sezione di dichiarazione delle form dinamiche. Definisce un tag dal nome arbitrario con dei parametri richiesti e facoltativi di vario tipo. Insomma: dietro c'e' molto lavoro... Sicuramente mi servira' una mano per scrivere guide e manuali vari. Nelle versioni successive faro' un'interfaccia grafica ad oggetti per semplificare la cosa (che in realta' e' gia' semplice). Per il momento il programma transcodifica i dati, ha un'interfaccia GUI stabile, utilizza il directsound per leggere e scrivere con lettori collegati alla scheda sonora, utilizza la LPTCLass per connettersi all'I/O per i lettori vari. Non so ancora quanto ci vorra' per la prima versione pubblica di DynaMagneto, per il momento sono a buon punto. -------------------------------------------------------------------------------- [11] PROGETTI COLLATERALI, WORK IN PROGRESS... Work in progress dei progetti collaterali o collegati al progetto Magneto: Allo stato attuale il progetto Magneto si trova in fase di studio per l'implementazione dell'HDSS, in rete ed in allegato a questo articolo (vedi archivio: Magneto/stm4src.zip) e' disponibile la versione Open Extra che supporta l'elaborazione di schede telefoniche ed altre schede basate sul sistema pseudo-ternario. Possiamo tranquillamente dire che Magneto e' diventato un po piu' "Dyna" (dinamico), ma e' legato sempre alla codifica Urmet ed al sistema pseudo-ternario. Per quanto riguarda DynaMagneto il coding ed il test sono in corso. Si sono fatte anche alcune sperimentazioni di codifiche e test in tutte le modalita', in questo periodo ho ultimato il parser del linguaggio codec/rml; l'interfaccia I/O e' stata ampliata anche per l'utilizzo di schede PCI aggiuntive. Il progetto HDSS e' stato gia portato a compimento, piu' avanti si faranno ulteriori test. Il progetto Digito Chipset direi e' a buon punto, e' stato studiato il funzionamento della Digito in ogni sua parte, ora abbiamo un'idea molto precisa di come sia stata implementata a livello hardware. Faremo presto una pubblicazione in merito. SMS Gratis da cabine Digito: Allo stato attuale si puo' fare. Pare che, salvo errori della Digito, l'ipotesi del Database delle schede possa essere smentita e il credito si trovi memorizzato all'interno della scheda telefonica. Allo stato attuale pare che la scheda (anche una degli anni '90) venga riconosciuta dalla Digito come carica, tuttavia appena la Digito ha a che fare con la rete da' un errore di invalidita' della scheda. Nonostante questo io posso scalare credito sulla Digito che sto usando e non scalarlo sulla scheda. Questo crea forti dubbi sul fatto che il credito sia un'entita' remota in tutti i casi. Progetto 4444: Per il momento abbiamo visto che in ogni profilo si manifesta la stessa situazione, non e' dovuto ad un errore di installazione, ma ad un preciso profilo di centrale. Con il # sembra darci retta ed accettare altre cifre, ma pare che nel terminale ci sia un sistema che in caso di # tenta la sequenza di configurazione. E' un preciso profilo di centrale che accetta numeri corti che iniziano con 4, il servizio 400 infatti funziona. Lo 0 da' invece la linea, ma non accetta chiamate. Con alcuni servizi come 400 o 410 la centrale stabilisce la comunicazione voce ed e' stabile. Quando pero' i servizi accedono all'identificazione dei numeri o consultano qualche db, il software di centrale sgancia la linea. E' da vedere se con il nuovo cambiamento del firmware e' variato qualcosa. Per il momento non posso comunicare altro sul progetto 4444. Infine ecco alcuni collegamenti a studi di terze parti sulle tessere magnetiche: "MTF project", Jack McKrak, BFi#2 Maggio 1998 "Project MTF: localista o serialista?", Jack McKrak e |PazzO|, BFi#3 Luglio 1998 "Mag Stripe Madness", Major Malfunction, CanSecWest Aprile 2006 -------------------------------------------------------------------------------- [OUTRO] Ci sono tanti altri progetti in corso... di vario tipo... Facciamo sempre un sacco di tramaci anche MultiMendi. Con probabilita' molto alta anche quest'anno faremo un Phreak Meeting dove verranno presentati i nuovi progetti. E non dimenticate di venire ai tramacing... EPTO (A) -------------------------------------------------------------------------------- ------------------------------------- FINE ------------------------------------- -------------------------------------------------------------------------------- Fine? I tramaci continuano :) ... ================================================================================ ------------------------------------[ EOF ]------------------------------------- ================================================================================