ONO digital

[presario2500]

otra cosa yo lo compré en la zona de andalucia (como creo que todos)yo soy de zona catalana ,y no veo tv1,la2,tv3,c33,t5,a3 y la cuatro ,la sexta y demas del tdt si los veo que puedo hacer para ver los teoricos libres?he probado poniendo zona "cataluña"me hace una rapida busqueda y no veo nada lo pongo en andalucia hago la busqueda y me quedo como estaba algun metodo para poder ver esos restos de canales?SALUDOS

[fblasco69]

lo ke se de los canales estos es ke son aereos ,no estan en digital aun
y referente alo del tlf ,si no me ekivoco el deco resetea la tarjeta al mes este utilizada o no
y la recarga o deja en su estado actual
en la tdt no t salen ningun canal de los nuevos de las privadas ? tele v ,antena III,etc?

y referente a los privados :solo e recibido uno y era para vendermelo a mi
no veas lo ke lee la peña

[presario2500]

si que estan en digital eso seguro por lo menos en cataluña esos canales que no veo yo y comento antes lo unico que pregunto es si hago bien la busqueda ,o no?y se sabe cuanto es el tope de la recarga para no blokear el deco?salu2

[acidillo]

Siento deciros una cosita..... en o*o parece ser que no son tontos, y al igual que no se puede investigar Motorola, tampoco es que se masturben precisamente sabiendo que los abq 1h4g si son educables, además no están por la labor de que una zona en concreto como es la antigua a**a les fastidie, ellos lo que quieren es unificar el sistema y los dekos, además en los abq 1h4g parece ser que no hay soporte para ojo, y aquí os pongo una cosita que he visto en otro foro... todo empezó cuando yo les pregunté si era cierto el rumor de que estaba colgando de un hilo el contrato con Motorola porque éstos pedían más dinero por mantener (alquilarles) su sistema de encriptación propio implantado en sus dekos.

"""" Dicen por ahi que está a punto de romperse el contrato con Motorola por subida de precios por mantener el sistema MediaCipher II.
Dicen que en agosto ahi un ultimátum... se dice en muchos foros, pero nadie sabe de dónde salió la fuente principal
Alguien sabe algo?? """"

"""" No tenemos constancia de que haya malas relaciones con Motorola.
De momento si hay conversaciones con ADB, la suministradora de decos en las zonas A**a que se supone seran retirados y tendran que ponerse de acuerdo para rescindir ese contrato. """"

Osea que según esto están en conversaciones con ADB para finiquitar esos molestos dekos que además de ser educables nisiquiera les aportan ingresos por el ojo... yo si fuera vosotros no gastaría mi dinero para que me dejen con cara de imbécil en 4 dias.

Espero que me equivoque y dure muxo la educación en la zona a**a.
Ójala me equivoque.

SAludos

[novato1223]

x acidillo

No estoy del todo de acuerdo contigo.

Yo soy de la zona auna y acaban de cambiar todos los analogicos por los abq.

Segun yo he leido la politica de ono es recortar al maximo los gastos en las zonas auna incluydo en la atencion al cliente.

Si quieren recortar gastos no creo que se metan en cambiar otra vez miles de dekos.

Creo que la cosa durara bastante mas.

x fblasco69

Ataste los cabos tal y como te dije? jeje lo siento colega te han echo la cabra supongo sabras ya quien soy.

Tengo tarjetas de sobra procedientes de bajas t21 y uploap y estoy a vuestra disposicion para lo que sea.

Un saludo

[acidillo]

Si? pues entonces genial, ya os decía yo que ójala me equivocara , larga vida al los abq entonces jejej

Saludos y muy buena educación

[novato1223]

informacion de una educada

Trying to reset card...
Reset Successful

RX ATR : 3F 7F 13 25 02 40 B0 12 69 FF 4A 50 90 41 55 00 00 00 00 00

Card Information Hex Decimal
---------------------------------------------------
Card ID 000xxxxx 00000xxxxxxx
IRD Number xxxxxxxx xxxxxxxx
USW 0000 0
Fuse/Guide 05 91 05 145
Time Zone 00 ???
Rating 0F ???
Spending Limit FFFF $655.35
---------------------------------------------------

Channel Tier Expires
---------------------------------------------------
1. 32 5B Sept 2006 Day 25 (M=B0, D=D9)
2. 37 54 Sept 2006 Day 25 (M=B0, D=D9)
3. 47 95 Sept 2006 Day 25 (M=B0, D=D9)
4. 45 B3 Sept 2006 Day 25 (M=B0, D=D9)
5. 00 07 Sept 2006 Day 24 (M=B0, D=D8)
6. 00 00 Jan 1992 Day 00 (M=00, D=00)
7. 00 00 Jan 1992 Day 00 (M=00, D=00)
8. 00 00 Jan 1992 Day 00 (M=00, D=00)
9. 00 00 Jan 1992 Day 00 (M=00, D=00)
10. 00 00 Jan 1992 Day 00 (M=00, D=00)
11. 00 00 Jan 1992 Day 00 (M=00, D=00)
12. 00 00 Jan 1992 Day 00 (M=00, D=00)
---------------------------------------------------

Broadcaster Purchases Purchase Limit


informacion de una de bajaa


Trying to reset card...
Reset Successful

RX ATR : 3F 7F 13 25 02 40 B0 12 69 FF 4A 50 90 41 55 00 00 00 00 00

Card Information Hex Decimal
---------------------------------------------------
Card ID 00094787 000006081350
IRD Number 03E1527D 65098365
USW 0000 0
Fuse/Guide 05 93 05 147
Time Zone 00 ???
Rating 0F ???
Spending Limit FFFF $655.35
---------------------------------------------------

Channel Tier Expires
---------------------------------------------------
1. 32 0A Jun 2004 Day 01 (M=95, D=C1)
2. 00 00 Jan 1992 Day 00 (M=00, D=00)
3. 00 00 Jan 1992 Day 00 (M=00, D=00)
4. 00 00 Jan 1992 Day 00 (M=00, D=00)
5. 00 00 Jan 1992 Day 00 (M=00, D=00)
6. 00 00 Jan 1992 Day 00 (M=00, D=00)
7. 00 00 Jan 1992 Day 00 (M=00, D=00)
8. 00 00 Jan 1992 Day 00 (M=00, D=00)
9. 00 00 Jan 1992 Day 00 (M=00, D=00)
10. 00 00 Jan 1992 Day 00 (M=00, D=00)
11. 00 00 Jan 1992 Day 00 (M=00, D=00)
12. 00 00 Jan 1992 Day 00 (M=00, D=00)
---------------------------------------------------

Broadcaster Purchases Purchase Limit
---------------------------------------------------
DirectTV $0.00 $ 0.00
USSB $0.00 $ 0.00



decirme que pruevo y como y lo hago

un saludo3

[fblasco69]

novato1223 _SI ME LA ICIERON SI
LOS MUI CABRONES
POR ESO KIERO DESMANTELAR EL TEMA
Y SE JODAN LOS DEL MONOPOLIO
AKI ESTOI PA LO KE SEA

[N@RKO]

se ke este post no debe ir aki pero bueno. necesito saber como crear nuevos post. no responder a otros, sino crear nuevos. hay un par de temas ke me gustaria comentar

[acidillo]

pues en el hilo principal de TVCABLE le das a nuevo tema.....
más facil imposible jejejeje

[novato1223]

Alguno entiende italiano?
Se supone o yo entiendo que usan el mismo sistema y ellos lo tienen mas que reventado creo que ay esta la clave.

Sobre la tarjeta esta vale para cualquier deko salvo para la compra de takis para ello deve estar casada pero solo para la taquis para el resto no



NDS ITALIA

La SmartCard
________________________________________

La struttura di una smartcard con CPU ( + CoProcesore o ASIC) è strutturata come in figura:



Lo schema rappresentativo fa vedere che i contatti servono a collegare il reader con i componenti all’interno del microprocessore attraverso una interfaccia. Questa collega direttamente con la CPU.
Sono presenti tre livello di memoria:

1) RAM (Random Access Memory - Memoria di accesso casuale)

2) ROM (Ready Only Memory - Memoria a sola lettura)

3) EEPROM (Electrically Erasable Programmable ROM - Memoria programmabile/cancellabile elettronicamente.

E presente una CPU che gestisce tramite un bus di sistema il I/O dei dati da/verso i "gestori" delle memorie e Firmware. I "gestori" sono (sommariamente): uno Stack (sicuro) per l'esecuzione del programma; provabile uno (oppure due) dal codice di Sistema Operativo per eseguire annidamenti di chiamate a subroutine; provabile un altro per StackPointer, ProgrammCounter, Registri di Stato, etc etc. Presente anche un CoProcessore crittografico (ASIC).
A richiesta del codice, l'ASIC esegue i processi di crittatura di primo/secondo livello a seconda del sistema in uso (esempio: RSA per il Seka2 ed Irdeto2).

Il seguente schema contiene la definizione dei contatti d’accordo all’ISO7816-2



La tabella seguente determina il nome del contato nel chip ed uso secondo ISO 7816

Contato Designazione Uso
C1 Vcc Collegamento attraverso cui l'alimentazione di funzionamento è fornita al circuito integrato del microprocessore nella scheda.
C2 RST Contato che permette l’accesso alla linea attraverso cui il IFD può segnalare al circuito integrato del microprocessore della smartcard
di iniziare la relativa sequenza di reset.
C3 CLK Contato di linea che fornisce un segnale di clock al circuito integrato del microprocessore.
Questa linea controlla la velocità di funzionamento e fornisce una struttura comune per la comunicazione di dati fra il IFD ed il ICC.
C4 RFU Riservato per futuri usi.
C5 GND Contato nel chip che fornisce il negativo comune fra il IFD ed il ICC.
C6 Vpp Contato d’alimentazione usato per programmare EEPROM della prima generazione ICCs.
C7 I/O Contato di input/output che fornisce una linea di comunicazione in semiduplex fra il lettore e la smartcard.
C8 RFU Riservato per futuri usi.



Funzionamento dell’IRD
________________________________________



LNB LowNoiseBlock
Sintonizzatore Sintonizza la frequenza del canale che si vuole vedere.
Demodulatore QPSK transforma il segnale armonico modulato in sequenza binaria.
FEC corregge gli eventuali errori nei pacchetti DVB/MPEG2. Utilizza i bit di ridondanza per fare le eventuali correzioni.
Demultiplixer in base all'header di ogni pacchetto determina scartare il pacchetto, inviarlo alla CAM,inviarlo al DecoderMPEG oppure (in caso di pacchetti di dati) alla CPU.
CAM Modulo d'accesso condizionato. E' in grado di eseguire il Descrambling.Per effettuare il Descrambling (nel caso di segnale crittato) utilizza una Smartcard Nel caso di acquisto di eventi PPV la CAM comunica al Provider via Modem.
DecoderMPEG2 riporta in forma non compressa il flusso audio/video
DAC Converte il flusso audio / video in analogico per collegare al video.
EEProm Memoria riprogramabile elettronicamente.


























Lo standard ISO 7816-3
________________________________________

Un’operazione di RESET consiste in una risposta della card che, secondo lo standard ISO 7816-3, inizia con il carattere TS seguito da al più 32 caratteri nel seguente ordine:

Reset
|
| _________________________________________ _______ _________
| | | | | | | | | | | | | | | | |
'-->| TS| T0|TA1|TB1|TC1|TD1|TA2|TB2|TC2|TD2| ......... | T1| ... | TK|TCK|
|___|___|___|___|___|___|___|___|___|___|_ _|___|_ _|__ |___|


TS Initial Character
TO Format Character (obbligatorio). Si compone di due parti:

I primi quattro bits (quelli più significativi b8, b7, b6, b5) denominati Y1 indicano con il valore 1, la presenza dei rispettivi successivi caratteri TA1, TB1, TC1, TD1.

Gli ultimi quattro bits (quelli meno significativi b4…b1) denominati K indicano il numero (0...15) di Historical Characters presenti

Y1 K
b8 b7 b6 b5 b4 b3 b2 b1


Y1 Indicatore della presenza dei caratteri di interfaccia

b5=1 indica la presenza di TA1
b6=1 indica la presenza di TB1
b7=1 indica la presenza di TC1
b8=1 indica la presenza di TD1

K Numero di Historical Characters (max. 15)

TAi Interface Character
Codes F1 (Clock Rate Conversion Factor) e D1 (Bit Rate Adjustment Factor)

TBi Interface Character
Codes I1 (Maximum Programming Current) e P11 (Programming Voltage)

TCi Interface Character
Codes N (Extra Guard Time)

TDi Interface Character
Si compone di due parti:

I bits b5, b6, b7, b8 di TDi contenenti Yi per i > 1 (Y1 è contenuto in TO come visto prima) definiscono o meno la presenza di ulteriori caratteri di interfaccia TAi…TDi trasferiti in ordine dopo il carattere che contiene Yi.
Quando necessario, il decoder dovrà attribuire un valore di default per i caratteri di interfaccia non trasmessi.
Quando TDi non è trasmesso, il valore di default per Yi+1 è zero, indicando con ciò che nessun ulteriore carattere di interfaccia TAi+j, TBi+j, TCi+j, TDi+j sarà trasmesso.
Gli ultimi quattro bits del carattere TDi specificano il tipo di protocollo T, fornendo le regole utilizzate nel processo di trasmissione. Quando TDi non è trasmesso, si assume T=0.

T=0 asynchronous half duplex character transmission protocol.
T=1 asynchronous half duplex block transmission protocol.
T=2 riservato per operazioni future full duplex.
T=3 riservato per operazioni future full duplex.
T=4 riservato per un asynchronous half duplex character transmission protocol avanzato.
T=5 riservato per usi futuri.
T=13 riservato per usi futuri.
T=14 riservato per protocolli ISO standardizzati.
T=15 riservato per estensioni future.

Quando T=0, TCK non deve essere inviato. In tutti gli altri casi TCK deve essere inviato.


Yi+1 T
b8 b7 b6 b5 b4 b3 b2 b1


Y1 indicatore della presenza dei caratteri di interfaccia
b5=1 indica la presenza di TAi+1
b6=1 indica la presenza di TBi+1
b7=1 indica la presenza di TCi+1
b8=1 indica la presenza di TDi+1

T Tipo di protocollo


T1 ... TK Historical Character (max. 15 ed opzionali)

TCK Check Character (condizionato)



I caratteri TAi, TBi, TCi, TDi (opzionali) specificano i parametri fisici del circuito integrato nella card e le caratteristiche logiche del successivo protocollo di scambio.
I caratteri T1…TK forniscono informazioni generali quali, ad esempio, il produttore della card, il chip e la ROM utilizzati, lo stato di vita della card. La specifica di tali caratteri non è contemplata nello standard ISO/IEC7816.







L’Answer To Reset delle nuove carte
________________________________________

L’ATR delle nuove card NDS è:


TS TO TA1 TB1 TC1 TD1 TA2 HISTORICAL CHARACTERS (T1 ... Tk)
3F FF 13 25 03 10 80 33 B0 0E 69 FF 4A 50 70 00 00 49 54 02 00 00


Dallo standard ISO poco sopra esaminato, abbiamo:


TS 0x3F INVERSE convention (differentemente dal sistema Mediaguard dove si aveva una convenzione DIRETTA, essendo TS=FF)

TO 0xFF L’HighNibble (1111) indica la presenza dei successivi caratteri TA1, TB1, TC1 e TD1;
Il LowNibble (1111) indica che ci sono 15 Historical Charatecters

TA1 0x13 F1 (Clock Rate Conversion Factor) pari a 1
D1 (Bit Rate Adjustment Factor) pari 3

TA2 0x80

TB1 0x25 I1 (Maximum Programming Current) pari a 50mA
P11 (Programming Voltage) pari a 5.0 volts

TC1 0x03 N (Extra Guard Time) pari a 2

TD1 0x10 L’HighNibble (0001) indica la presenza di un ulteriore carattere (TA2)


I 15 bytes successivi a TA2 ( T1 ... T15 ) sono gli Historical Characters.


Programming Voltage 5.0 volts
Programming Current 50ma
Maximum Clock Frequency 5.0MHz

Assuming a 3.5790MHz clock

Work ETU 0.0000259849 seconds
Guard Time 0.0003897737 seconds
Baud Rate After Reset 38484


Il Baud Rate iniziale durante la fase di reset e di generazione ATR è 9600 b/s, dopo la richiesta ATR il Baud Rate è 38400 b/s.

Per informazioni più dettagliate sullo standard ISO7816-3 e sull’ATR in gererale delle carte NDX, vi rimando al fantastico documento di Micromax.


La struttura delle istruzioni NDX
________________________________________

Il sistema NDS riconosce tre livelli d’operazioni. E' importante distinguerli:

• Comando: una funzione che interviene per mezzo di determinati valori assegnati all’INS-Byte;

• Nano: una funzione che interviene per mezzo dei valori inseriti nel DataPacket (Pacchetto Dati). Il DataPacket é la parte che segue l’invio dell’HeaderPacket (Pacchetto Header) che contiene l’INS-Byte, ossia il Comando da eseguire;

• uNano: alcuni Nano prevedono delle sottoperazioni dette appunto uNano che sono identificate da particolari valori inseriti nel NanoPacket (Pacchetto-Nano).


Un Comando NDS ha quindi la seguente struttura:

Header Data-Packet Nano Signature
CLA INS P1 P2 Len [Nano..nano-len…nano-data]..[Nano1… 67 08 SIGN


Tutti i comandi NDS si possono analizzare tenendo conto dei due pacchetti cui sono composti:

Header
CLA Classe del comando da eseguire
INS Tipo di istruzione da eseguire
P1 Parametro 1
P2 Parametro 2
LEN Lunghezza del comando (in esadecimale)


DataPacket segue il pacchetto Header e contiene l’INS Byte (Echo Byte), ossia il byte che indica il comando da eseguire. Il DataPacket compone il comando, varia per ogni comando e contiene Nani ed Indicatori seguiti dai relativi dati.
Il DataPacket può essere inviato dall’IRD (Cam) alla card [IRD → CARD], ovvero dalla card all’IRD [CARD → IRD].

Seguono infine

67 08 Precede la firma elettronica (Signature). Come vedremo successivamente, 0x67 indica la presenza di una SIGNATURE di LEN 0x08 (quindi SIGNATURE di 8 bytes), indicabile anche con 67_08;

SIGN Signature (composta da 8 bytes, non necessaria per tutte le istruzioni).







Nani ed Indicatori
________________________________________

Le istruzioni NDS contengono Nani ed Indicatori.

I NANO(comandi) sono delle funzioni che vengono eseguite attraverso i dati che sono ivi contenuti. Ogni Nano ha una sua lunghezza. Alcuni Nano sono a lunghezza fissa, altri a lunghezza variabile. Possiamo quindi avere i seguenti casi:

(Cx) d1 d2 ..dn Nano a lunghezza fissa. I dati seguono immediatamente il Nano.

(Cx) LL d1 d2 ..dn Nano a lunghezza variabile. La lunghezza segue immediatamente l’identificativo del Nano (Nano Indicator); i dati seguono immediatamente dopo. Da notare che se LL=FF allora la Len del Nano è dato dal byte seguente quello con valore FF.

I Nanocomandi sono contenuti negli ECM e negli EMM, oltre che nell’INS 36.
Alcuni Nano possono contenere delle sotto-operazioni da eseguire: queste sotto-operazioni, chiamate u-NANO, sono di solito a LEN fissa.

Distinti dai Nanocomandi sono gli INDICATORI (o Type Info). Gli Indicatori, a differenza dei Nano che eseguono certe funzioni, servono soltanto a indicare i tipi di dati presenti nella card.
Gli Indicatori sono presenti in molte risposte della card.


INDICATORI dell'INS 74
________________________________________

03 [02] 01 F6 Sempre lo stesso risultato

05 [20] 4954410000000000
0000000000000000
0000008000000000
0001000000000000 Il 28°byte è 00 su card virgin, 01 su card attive
INS 74 05

15 [10] 0000000000000000
0000000000000000 PPV record

16 [48] 800702424FFFFFFF Phone Number PPv download
800702424FFFFFFF
FFFFFFFFFFFFFFFF
FFFFFFFFFFFFFFFF
FFFFFFFFFFFFFFFF
FFFFFFFFFFFFFFFF
FFFFFFFFFFFFFFFF
FFFFFFFFFFFFFFFF
FFFFFFFFFFFFFFFF INS 74 09

17 [04] 5B0D 76F1 Data&Time richiesta INS.

18 [02] 00 00 ??

19 [04] FF FF FF FF Indica il contenuto del 12°,13°,14°,15° byte del Nano E2

1A [04] 00 00 00 00 Indica il contenuto del 16°,17°,18°,19° byte del Nano E2

1B [04] FF FF FF FF Indica il contenuto del 5°(PCB),6°,7°,8° byte del Nano E2

1C [10] 0000000000000000
0000000000000000

1D [08] 4954414C49412020 PostCode indicator

23 [04] 80 00 PP PP Indica il contenuto del 1°,2°,3°(PIN),4°(PIN) byte del Nano E2

24 [03] 00 00 64 Indica il contenuto del 9°,10°(LIMITE di SPESA),11°(LIMITE di SPESA)
byte del Nano E2

24 [05] 03 20 5B 0A 20 Indica che c'è stata la visione di tutti i canali fino al 10/08

25 [01] xx ??

26 [02] 3F 00 In fase boot uguale x tutti

28 [01] xx ??

43 [02] xx xx Contatore giornaliero iniziante dall'Att. E' lo stesso contatore presente
nell’indicatore 5E_05 dell'INS 36

44 [01] xx ??

46 [01] xx ??

50 [01] xx ?? sempre uguali

51 [07] 00000000000000 ??

52 [08] 0000000000000000 ??



INDICATORE dell'INS 70
________________________________________

39 [23] 00000000404100000000000000000000
00002000000000000000000000000040
5C1900



INDICATORE dell'INS 72
________________________________________

23 [21] 00000000000000000000000000000000
00000000000000000000000000000000
20 PPV record





INDICATORE dell'INS 76
________________________________________

24 [08] 0226 5D0F 00000000 Tier



INDICATORI dell'INS 6C
________________________________________

6A [06] 001000102300

6B [08] 0000000800000000

6E [10] 00x16 bytes

6F [60] 00x96 bytes



INDICATORE dell'INS 4E
________________________________________

26 [03] 84 01 04



INDICATORE dell'INS 1E
________________________________________

27 [07] 01 00 00 02 00 00 00



INDICATORI dell'INS 36
________________________________________

E9 [04] Indica il numero dei tiers attivi e loro scadenza

F3 Indica l'IRD Number

5E [05] Activation Counter, i primi 2 bytes indicano da quanti giorni è attiva la card

DF [04] Mese e giorno in cui il decoder cercherà di collegarsi al server SKY (INS 7Cool

E2 [13] PIN, PCB, SpendingLimit Indicator
E2_13
80 00
00 00 PIN
FF PCB
FF FF FF 00
00 64 Limite di spesa
FF FF FF FF ?? modificabili con l'iINS 2E 03
00 00 00 00 ?? modificabili con l'INS 2E 05, legati alla PPV

EF [02] ?? (nelle card virgin 00 01, in quelle attive 00 00)

F8 [24] Old PPV Event Record
F8_24
02 Slot Record
CC54 Ev.ID
5E09 Data di acquisto+1giorno
BF7D ??
012C Costo evento
01 Status visione (00:ev. non visionato; 01:ev. visionato; 02:acquisto
non confermato e dunque non visionato)
040180 ??
5E0853EB Data e ora acquisto (l’ora è indietro di 1ora)
00000000
5E0854AA Data e ora di fine preview (l’ora è indietro di 1ora)
000000000000
5E09 Data acquisto+1
0065 Tipo di acquisto credito a scalare
80 Status: visionato (se 20 allora non visionato)

L'indicatore F8 è presente tante volte quanti sono gli eventi acquistati registrati sulla card.


FA [08] Nella vecchia codifica indicava dei bytes variabili usati per la generazione della signature. Oggi indica 8 bytes che variano molto raramente e che forse possono essere legate alla signa.

FD [11] Provider Last PPV record indicator
FD_11
01 Prov.number
00 65 Tipo di acquisto credito a scalare via telefono
00 01 Number PPV record
00 01 Costo evento
06 41 Credito totale spendibile
03 21 Metà del credito totale(dipende da questo)
000000000000 ??























Nano a LEN fissa
________________________________________

Nano 00
Null Nano
Non esegue alcuna funzione.


Nano 01 [LEN 04]
Set Data & Time
I 4 bytes della data e dell'ora sembrano concorrere all'elaborazione della signature degli ECM e degli EMM. Così la signature diventa unica e sempre diversa, perchè relazionata a valori temporali. La presenza di vincoli temporali e la loro rilevanza in fase di generazione signature costituisce un punto di forza della codifica NDS.



Nano 02 [LEN 01]
Sets Rating Byte, marks message as ECM (only ECM)
Il contenuto di questo Nano descrive il tipo di contenuto della programmazione. Analizzando il bitmap possiamo dire:

7654 3210
0000 0001 01 canale criptato standard
0000 0010 02 canale PPV, evento già iniziato non più aquistabile
0000 0101 05 canale PPV, evento iniziato ma ancora aquistabile, con preview terminata.
1000 0001 81 canale PPV, evento non ancora iniziato e aquistabile.
1000 0010 82 canale PPV, evento iniziato, aquistabile con preview non ancora terminata.


Nano 03 [LEN 03]
Checks channel entitlement
I primi 2 bytes rappresentano il Channel ID associato al canale su cui siamo sintonizzati nel momento in cui l’ECM/EMM è stato generato dall’IRD.
Ad uno stesso canale, possono essere associati più Channel ID, tutti presenti nell’ECM/EMM.
La card effettua due controlli: dapprima verifica se il Channel ID associato al Nano 03 è contenuto tra quelli presenti nella smartcard; poi verifica se il valore del 3° byte del nano è minore del valore della data di scadenza del Tier. In caso affermativo setta dei flags interni che permetteranno la generazione della DCW (Decrypted ControlWord) come risposta al comando D1 54. Viceversa la DCW di risposta sarà tutta a 00.


Nano 04
Significato NON noto.


Nano 06
Significato NON noto.


Nano 07
Significato NON noto.


Nano 09 [LEN 03]
Initialise ASIC with specified ***, flushes the command buffer (no signature stay)
Dai primi di Ottobre 2004 è stato integralmente sostituito dal Nano 90, che sostanzialmente è analogo.


Nano 10 [LEN 02]
Some form of counter
I due bytes dell’argomento del nano mostrano una sequenza che si incrementa ad ogni successivo EMM contenente il Nano 10. Come si evince dall’NDSFaq 1.0 di Micromax, per NDS 1 ciascun Provider (ad esesempio Stream e Tele+) aveva il proprio numero di sequenza. Esempio:

29 FE 29 FF 2A 00
2A 01 2A 02 2A 03


Nano 14
Significato NON noto


Nano 18
Significato NON noto


Nano 19 [LEN 01]
Set region code
Richiede i Filtri OPEN per essere eseguito. L’argomento corrisponde al Region Code.


Nano 1E [LEN 08]
Set Postcode Value
Questo Nano setta il valore del PostCode.
Gli 8 bytes contengono solo numeri, lettere maiuscole o blanks e rappresentano il Codice Postale (PostCode).

Esempio:

Valore Descrizione
41 42 31 30 20 20 20 20 "AB10 "
43 48 34 20 20 37 45 4° "CH4 7EJ"
5A 45 32 20 20 20 20 20 "ZE2 "

Il Nano 1E è sempre usato in combinazione con il Nano 31. Il Nano 1E e il Nano 38 non sono mai presenti insieme nello stesso data-block.
Richiede i Filtri OPEN e minimo la Group *** per essere eseguito.


Nano 1F
Significato NON noto


Nano 24
Close Filters


Nano 25
Flip filters, from open to closed or vice versa
Se i Filtri sono aperti li chude. Viceversa se sono chiusi li apre.


Nano 2D [LEN 04]
Set Activation Date&time
Richiede i Filtri OPEN e minimo la Public *** per essere eseguito.


Nano 2E
Significato NON noto

Nano 30
Open filters


Nano 31 [LEN 04]
Opens filters if the Unique Address (UA) matches exactly
I quattro bytes del comando rappresentano l'Unique Address della card.
Solo se il Numero Seriale è identico a quello della card i successivi Nano verranno eseguiti.
Il Nano 31 (UniqueAddress) e il Nano 38 (PostCode) non sono mai presenti insieme nello stesso data-block.


Nano 32 [LEN 03]
Open Filters if Shared Address Match
I tre bytes del comando rappresentano il gruppo di cards (card group o Shared Address) a cui e’ diretto l’EMM.
Solo se questi bytes sono identici ai primi tre bytes del UniqueAddress i successivi Nano sono eseguiti.
Il Nano 32 (Card Group Select) e il Nano 33 (CUSTWP Bitmap) non sono mai presenti insieme nello stesso data-block.


Nano 33 [LEN 23]
Open Filters if CUSTWP Bitmap Set
I primi tre bytes rappresentano il Card Group (Shared Address o SA).
I rimanenti 0x20 bytes (32 decimale) rappresentano l’AddressMatrix (simile al Nano F0 del Seca).
Questo AddressMatrix contiene esattamente 256 bits: ciascun bit corrisponde ad una delle 256 cards del gruppo, cioè corrisponde al valore del quarto byte del Unique Addresses, detto CUSTWP (Customer Word Pointer che, appunto, può assumere FF=256 valori).
L’EMM è indirizzato solo alle cards corrispondenti ai bits “settati” (ossia che assumono valore 1).
Il bit corrispondente ad un dato CUSTWP è individuato nel seguente modo:

Esempio con CUSTWP = AE

1. Dividendo il valore del CUSTWP per 8 si ricava quale dei 32 bytes, numerati a partire da 00, contiene il bit corrispondente al CUSTWP.

CUSTWP/8 = AE/8 = 15h

2. Il resto della divisione tra il valore del CUSTWP e 8 fornisce la posizione del bit all’interno del byte.
I bits vanno numerati da 0 a 7 da sinistra verso destra.

Nel nostro esempio, il bit associato al CUSTWP AE è il bit 6:

7 6 5 4 3 2 1 0

Alcuni esempi rendono il tutto più chiaro:

33001234800000 la card 00 12 34 07 é indirizzata
(Bitstring: 100000000000000000000000...).

330012340A4000l le cards 00 12 34 03, 00 12 34 01 e 00 12 34 0E sono indirizzate
(Bitstring: 000010100100000000000000...)

Questo Nano di solito è usato in combinazione con il Nano 41 per aggiornare la Data di Scadenza di un Channel ID. In questo caso il comando dovrebbe essere criptato con chiave di gruppo. Da quando è stato generalizzato il Nano 90, non si sono più visti EMM criptati con la chiave di gruppo.


Nano 3D [LEN 02]
Set PPV spending limit e fuse byte
Richiede i Filtri OPEN e minimo la Group *** per essere eseguito.


Nano 3E
Significato NON noto


Nano 41 [LEN 05]
Add or Update (Expiration Date) Channel Entitlement
Questo nano crea, se non già presente, un nuovo Channel ID sulla card e relativa Data di Scadenza.
Se il Channel ID è già presente sulla card, il Nano aggiorna la data di scadenza e alcuni valori e flags.
Dei 5 bytes associati al nano, i primi due rappresentano il Channel Entitlement (Channel ID).
I successivi due bytes costituiscono l’Expiration Date del Channel ID: il primo di questi due bytes rappresenta l’anno e il mese, il secondo il giorno.


Nano 42 [LEN 02]
Delete Channel ID
Questo Nano cancella definitivamente il Channel ID indicato dai due successivi bytes, dalla lista di quelli presenti sulla card. Questo nano può essere presente più volte nello stesso data-block.
Richiede i Filtri OPEN e minimo la Public *** per essere eseguito.


Nano 43
Significato NON noto


Nano 44
Significato NON noto


Nano 48 [LEN 02]
Enable PPv Preview
I due bytes che seguono (xx xx), indicano che l'evento è già iniziato ed è attiva la preview. La preview rimane attiva fino a 6-7 minuti dopo l'inizio del film. Dipende dunque dall'orario di inizio del film, non dal momento in cui noi lo visioniamo (come nel Seca).


Nano 49
Significato NON noto
Nano 4A
Significato NON noto


Nano 4B
Significato NON noto

Nano 4D [LEN 0B]
Purchase PPV info
Questo Nano fornisce informazioni sull'evento PPV in corso. E' contenuto negli ECM degli eventi PPV e nelle INS 46.


Nano 67 [LEN 08]
Signature
Vedi paragrafo sulla Signature.


Nano 6D [LEN 09]
Server Number
Il Nano 6D viene inviato tramite EMM, contiene il numero di telefono del server dove il decoder si collega quando la scheda ha terminato il credito PPV. Quando il decoder si collega, scarica gli eventi scritti e ricarica la scheda. Vedi INS 78.


Nano 7F [LEN 0A]
*** Adjustment
I 10 bytes di argomento del Nano 7F dovrebbero rappresentare i *** Adjustment Bytes usati per aggiustare la risposta della card all'ECM. Vedi paragrafo sulla Signature.


Nano 90 [LEN 03]
Inizialize ASIC
Analogo al Nano 09, usato per i recenti comandi criptati, tale nano ci dice se e come l'ASIC è inizializzato.

90 YY XX ZZ

XX Indica il numero di bytes criptati che seguiranno

YY Rappresenta un bitmap, in cui l’HighNibble (bits 7, 6, 5 e 4) indica il COMANDO mentre il LowNibble (bits 3, 2, 1 e 0) indica la configuración con la quale il COMANDO di cui sopra è firmato. Dunque

7654
0000 0 Non inizializza l'ASIC
0100 4 Individua un EMM
0110 6 Individua il particolare EMM LEN 83
1100 C Individua un ECM o una INS46

3210
0000 0 Chiave pubblica primaria
0001 1 Chiave pubblica secondaria
0010 2 Chiave di gruppo primaria
0011 3 Chiave di gruppo secondaria
0100 4 Chiave privata primaria
0101 5 Chiave privata secondaria


ZZ Indica la versione della CARD. Per la italiane e le inglesi abbiamo 02, per le HU americane abbiamo 03, per le P4 e P5/D1 sempre americane abbiamo 05.



Nano DE [LEN 28]
Vedi INS36
Il Nano DE presenta 24 bytes che possono variare in relazione a specifiche INS 42 e 16 bytes che variano a ogni reset. Questi 16 bytes variabili, con molta probabilità sono legati alla generazione della signature.



Nano a LEN variabile
________________________________________

Nano 38
Check Data and Open Filters If Match
Questo Nano a lunghezza variabile ha il compito di aprire i filtri se il dato associato corrisponde a quello presente sulla card. Il tipo di dato su cui è effettuato il confronto è indicato dal 1° byte dopo la LEN, che può quindi essere considerato un uNano.

uNano
01 Channel Entitlemen (Channel ID)
02 PPV Event ID
03 Activation date (Mese e Giorno)
06 PostCode (FF's nel PostCode sono trattati come wildcards)
08 ????

Le LEN ammesse sono 03, 05, 07, 09.
Per esempio, se il Nano si presenta in questa forma:

38 09 06 aa bb cc dd ee ff gg hh

viene verificato se aa bb cc dd ee ff gg hh è uguale al valore del PostCode presente sulla SC. In caso positivo i filtri vengono aperti.
Il Nano 38 e il Nano 31 (Unique Address) non sono mai presenti insieme nello stesso data-block.


Nano 75 [LEN 0F]
Set Local Region Code


Nano 75 [LEN 13]
Set Country Code & Region Code
Normalmente utilizzato durante l’attivazione, questo Nano setta il Country Code e il Region Code:
Valore Descrizione
0047425201 0000000000000000000000000000 474252 = GBR
0047425202 0000000000000000000000000000 474252 = GBR
0047425208 0000000000000000000000000000 474252 = GBR
0049544100 0000000000000000000000000000 495441 = ITA

Il byte sottolineato rappresenta l’identità della regione (RegionCode) all’interno dell’area di appartenenza.











































Le nuove classi
________________________________________

Con l’avvento della nuova codifica sono cambiate le classi delle istruzioni. Nella vecchia codifica l’unica classe con la quale venivano inviati i comandi era la 48. Adesso le classi supportate dalle nuove card sono ben 8:

D0 D1 D2 D3
D4 D5 D6 D7




Le ultime 4 sono antagoniste delle prime 4, ossia si comportano allo stesso modo.
Analizziamo brevemente queste classi:


CLASSE D0 Usata in fase di boot prima della ricezione dell’INS BE, agisce “in chiaro” senza alcun crypt;

CLASSE D1 è la classe “standard”, usata dopo l’invio dell’INS BE in fase di boot, agisce “in chiaro” senza alcun processo di crypt;

CLASSE D2 è una classe particolare, perché agisce con un particolare processo di crypt. Infatti “appende” alla fine dell’INS, 16 bytes di dati criptati (una specie di signature aggiuntiva). Questi bytes vengono sempre aggiunti: se la LEN è sufficiente a contenerli (LEN>11hex) allora “coprono” gli ultimi 16 bytes di dati in chiaro dell’INS; se la LEN minima non è sufficiente (LEN<11hex) la risposta dell’INS sarà 00xLEN + 16 bytes. C’è da considerare comunque che se l’INS viene chiesta dall’IRD, è quest’ultimo che aggiunge 10hex alla LEN prevista per il comando.

CLASSE D3 agisce criptando tutto il DataPacket più la “signature” di 16 bytes. Questa classe è usata per l’INS 2E_04, per l’INS 54 e per la INS BE. Il processo di cifratura per le classi D2 e D3 (D6, D7) non usa l’ASIC (Application Specific Integrated Circuit) usato invece per cifrare i dati tramite il Nano 90. Anche la classe D3 necessita di una LEN minima maggiore di 0x11, proprio perché anche per questa classe è prevista questa specie di “signature” finale.



Le chiavi
________________________________________

Nel Sistema NDS esistono 3 tipi di chiavi:

Public *** è la stessa su tutte le card. La Signature calcolata con questa *** è quindi valida per qualsiasi card.
Group *** è la stessa per un gruppo di 256 cards. La Signature calcolata con questa *** è quindi valida per tutto il gruppo.
Private *** è specifica per ogni card. La Signature calcolata con questa *** è quindi valida solo per una card. Principalmente usata durante l’ attivazione.


Le chiavi:

*** 00 é la primary public ***
*** 01 é la secondary public ***
*** 02 é la primary group ***
*** 03 é la secondary group ***
*** 04 é la primary private ***
*** 05 é la secondary private ***

Oltre a queste chiavi, è molto probabile che le nuove card contengano altri 2 tipi di chiavi:

*** 06 é la Card Swap Receive ***
*** 07 é la Card Swap Send ***

Queste chiavi intervengono in un’eventuale processo di swap della card. In breve la Card Swap Receive *** serve per autenticare il pacchetto dati che la nuova card riceve dall’IRD (è scritta dal produttore della nuova card) ; la Card swap Send *** serve per autenticare il pacchetto dati che l’IRD riceve dalla vecchia card (è scritta attraverso un apposito EMM).



Signature Calculation NDS 1
Signature Calculation & Signature Adjustement Bytes
________________________________________

Durante l’elaborazione del Nano 09, l‘ASIC (Application Specific Integrated Circut) è inizializzato usando la configuración indicata in questo Nano. Successivamente ogni byte che segue il Nano 09 fino al Nano 67(0Cool è “stritolato” da un algoritmo segreto di calcolo della Signature. Questa Signature è successivamente confrontata con 8 bytes risultanti dallo XOR dei primi 8 bytes associati al Nano 7E(14), i Signature Adjustement Bytes, e gli 8 bytes associati al Nano 67(0Cool. E’ verificato quindi che:

Signature Calcolata dalla Card. = Signature 67(0Cool XOR Signature Adjustement Bytes 7E(14)

Non ci sono differenze nel tempo di calcolo (tempo di risposta della card.) tra il caso d’invio di una Signature completamente errata ed una corretta.
Tutti i nano compresi tra il Nano 09 e il Nano 67(0Cool sono ‘Signature Protected’. Essi non saranno
eseguiti se la Signature non è preventivamente validata.

Control Word Encryption Process
________________________________________

Il processo di calcolo della Encrypted Control Word si attiva alla ricezione di un ECM (Entitlement Control Message) nel quale sia presente il Nano 02 (Rating). In realtà il principale processo di calcolo parte alla ricezione dell’INS54 che deve sempre seguire un ECM.
Se la Signature era corretta ed il Nano 02 era incluso, la card, attraverso un algoritmo segreto di calcolo che fa uso della configuración specificata dal Nano 09, genera, utilizzando TUTTI i bytes a partire da questo Nano fino alla fine della Signature, una Encrypted Control Word (***). Non è noto se l’ASIC è reinizializzato in questo processo, dopo il calcolo della Signature.
Questa *** di 10 bytes è quindi ‘aggiustata’ utilizzando i 10 *** Adjustment Bytes presenti nel Nano 7E(14). Questa *** di 10 bytes è restituita alla CAM dall’INS54.
L’algoritmo di ‘aggiustamento’ é semplicemente uno XOR :

[10 ***] XOR [*** Adjustement Bytes] = [10 *** returned by INS54, if 7E nano present]

In entrambi i casi, gli ultimi 2 dei *** Adjustement Bytes sembrano essere sempre 00 00, e quindi non sembrano intervenire nel processo di aggiustamento.

Notare che se tra la ricezione di un ECM e la INS54 è inviata una INS5C, si ottiene una ECW completamente errata.
Molto probabilmente la CAM, da questa 10 bytes ECW, genera una 10 bytes Decrypted Control Word - DCWs - (odd or even) che è trasferita al chip CSA per la decodifica del flusso MPEG.





























Status Bytes
________________________________________

Lo status byte indica lo stato della card alla fine del comando: lo SB è composto da due bytes, detti SW1 e SW2.
Analizziamo prima la SW1, dove solamente 3 sono i bits significativi (0, 4, 7):

76543210
1001 0000 90 INS eseguita, flags resettati
1001 0001 91 INS eseguita, flags non resettati.

I bit 7 e 4 sono sempre settati e rappresentano il valore normale della risposta indicante la corretta esecuzione del comando.

Il bit 0 non settato indica che tutti i flags sono stati resettati dopo l'esecuzione del comando.
Il bit 0 settato indica che alcuni flags non sono stati resettati. Ciò non significa che l'INS non sia stata eseguita.

Nella SW2, invece, i bits significativi non sono solamente più 3 (come avveniva in NDS 1), bensì sono diventati 6:

7 6 5 4 3 2 1 0

Bit 0=1 Indica che durante l’ esecuzione del comando, una modifica è stata apportata al contenuto della EEPROM.
Bit 0=0 Indica che durante l’ esecuzione del comando nessuna modifica è stata apportata al contenuto della EEPROM.

Bit 5=1 Indica che la card. ha ricevuto il Comando 48 4C (Send IRD Serial Number) ed ha completato il Marriage.
Bit 5=0 Indica che la card. ha non ha ricevuto il Comando 48 4C (Send IRD Serial Number) , oppure che, pur a*****lo ricevuto, non ha completato il Marriage perché l’IRD Serial Number era diverso da quello già registrato.

Bit 7=1 Indica che lo stato dei Filtri dopo l’esecuzione del comando è OPEN.
Bit 7=0 Indica che lo stato dei Filtri dopo l’esecuzione del comando è CLOSED.

In definitiva, i seguenti valori sono possibili:

00 Filters closed when packet finished IRD Number match flag not set No EEPROM Update
01 Filters closed when packet finished IRD Number match flag not set EEPROM Update
20 Filters closed when packet finished IRD Number match flag set No EEPROM Update
21 Filters closed when packet finished IRD Number match flag set EEPROM Update
80 Filters open when packet finished IRD Number match flag not set No EEPROM Update
81 Filters open when packet finished IRD Number match flag not set EEPROM Update
A0 Filters open when packet finished IRD Number match flag set No EEPROM Update
A1 Filters open when packet finished IRD Number match flag set EEPROM Update


Con l'avvento della nuova codifica, il valore di SW2 ha subito delle modifiche, in quanto sono stati abilitati altri tre bits del bitmap: i bits 2, 4 e 6.

Il bit 2, se settato, determina un LowNibble di SW2 pari a 4. Lo SW2 04 si osserva quando la card riceve un IRD number diverso da quello presente nella locazione #CurrentIRD#. Questo status si osserva anche nel caso in cui si richieda una INS BC non preceduta da una INS B4. Possiamo dire che questo status indica un tipo di errore che però non determina il blocco della card. Per approfondire il suo significato, vedi il Marriage.

Il bit 4, se settato, determina un HighNibble di SW2 pari a 1. Lo SW2 10 si osserva in caso di errore sulla LEN minima per le INS con classe D2 e D3. Di norma il decoder adotta una LEN adeguandola automaticamente al tipo di classe. Le classi D2 e D3 infatti necessitano di una LEN minima pari a 0x11, se questa non è fornita, la card risponde 00xLEN + 16 bytes di “signa” e rispondono 9040. Ma se prima inviamo l’INS BE, allora la risposta ad una INS con classe D2/D3 con LEN<11 sarà 9010.
Lo SB 9010 determina il blocco della card che dovrà essere necessariamente resettata.
Vedi Paragrafo Classi.

Il bit 6, se settato, determina un HighNibble di SW2 pari a 4. Lo SW2 40 si osserva in caso di errore sulla classe delle INS. Ad esempio provando ad inviare una INS con una classe diversa da D0 senza inviare prima l'INS BE, otterremo uno SB 9040.
Questo SB determina un blocco della card che dovrà necessariamente subire un reset.
Vedi INS BE.



La fase di BOOT delle nuove CARD
________________________________________

[16.03.23]: Richiede la LEN per l'INS successiva
D0 74 01 80 01 (74) 7C [90 00]

[16.03.23]: Elenca le INS supportate in EEProm (tra parentesi le varie INS)
D0 74 01 00 7C (74) 01 7A 1E 01 [D0 0E FF 02] [D0 1E 09 03] [D0 2E FF 00]
[D0 32 01 01] [D0 36 FF 02] [D0 38 02 03] [D0 40 FF 00]
[D0 42 FF 00] [D0 44 35 01] [D0 46 FF 00] [D0 4A FF 00]
[D0 4C 09 01] [D0 4E 05 03] [D0 50 FF 02] [D0 54 2C 03]
[D0 56 FF 02] [D0 58 4A 03] [D0 5A FF 02] [D0 5C 04 03]
[D0 5E FF 02] [D0 6A FF 00] [D0 6C FF 02] [D0 70 25 03]
[D0 72 23 03] [D0 74 FF 02] [D0 76 0A 03] [D0 78 18 03]
[D0 B4 40 01] [D0 BC 50 03] [D0 BE 10 03] [90 00]

Queste elencate sono i comandi che il decoder può inviare alla carta e NON le INS che la carta accetta realmente. I primi 4 bytes, hanno uno specifico significato:

01 Type Info
7A Byte restanti della INS
1E Indica (in HEX) il numero di INS supportate che verrano elencate in seguito (per l’Italia 1E=30)
01 Valore fisso

[16.03.23]: Richiede la LEN per l'INS successiva
D0 74 16 80 01 (74) 04 [90 00]

[16.03.23]: Risponde sempre così per tutte le card
D0 74 16 00 04 (74) 26 02 3F 00 [90 00]

[16.03.23]: Marriage
D0 4C 00 00 09 (4C) in in in in 03 00 00 05 04 [90 20]

[16.03.23]: Send Card Info
D0 58 00 00 4A (5Cool 15 48 25 UA UA UA UA 06 95 CE 6F 42 00 00 00 00
00 00 00 00 1D 8F C7 00 09 19 UA UA UA UA FF FF
FF FF SA SA SA 00 FF FF FF 00 00 00 00 00 00 00
00 00 08 00 00 00 01 49 54 41 00 00 49 54 41 4C
49 41 20 20 5E 1A B2 22 00 00 [90 20]

[16.03.23]: Abilita le altri classi
D3 BE 00 00 20 (BE) 89 65 1F 18 4C A7 4D CE 19 71 B0 D0 87 D0 16 E7
3B 53 E7 DA 05 06 DD E9 2A A6 71 C1 A9 55 CC EF [90 20]
[16.03.23]: Send Card Info
D1 58 00 00 4A (5Cool 15 48 25 UA UA UA UA 06 95 CE 6F 42 00 00 00 00
00 00 00 00 1D 8F C7 00 09 19 UA UA UA UA FF FF
FF FF SA SA SA 00 FF FF FF 00 00 00 00 00 00 00
00 00 08 00 00 00 01 49 54 41 00 00 49 54 41 4C
49 41 20 20 5E 1A B2 22 00 00 [90 20]

[16.03.24]: Marriage
D1 4C 00 00 09 (4C) in in in in 03 00 00 05 04 [90 20]

[16.03.24]: Richiede la LEN per l'INS successiva
D1 74 11 80 01 (74) 06 [90 20]

[16.03.24]: Richiede Codice PIN (vedi INS 74_11, in fase di boot con classe D3)
D3 74 11 00 16 (74) DF 76 68 18 4D AB 81 B1 0D A8 11 42 FE 12 27 64
1D 3C 57 D7 38 77 [90 20]

[16.03.24]: Richiede il valore max di P2 per l'INS 74_05
D1 74 05 7F 01 (74) 04 [90 20]

[16.03.24]: Richiede la LEN per la richiesta PIN
D1 74 11 80 01 (74) 06 [90 20]

[16.03.24]: Richiede Codice Pin (vedi INS 74_11, in fase di boot con classe D3)
D3 74 11 00 16 (74) 0A 93 23 C3 B9 5D 6B 30 2B 64 E8 8F EB 6A 56 2D
CE 41 66 43 3C A3 [90 20]

[16.03.24]: Richiede la LEN per l'INS successiva
D1 74 0E 80 01 (74) 06 [90 20]

[16.03.24]: Richiede il PCB
D1 74 0E 00 06 (74) 1B 04 FF FF FF FF [90 20]

[16.03.24]: Richiede la LEN per l'INS 74_05 (send country code & other info)
D1 74 05 80 01 (74) 22 [90 20]

[16.03.24]: Richiede la LEN per l'INS successiva
D1 74 12 80 01 (74) 05 [90 20]

[16.03.24]: Richiede il limite di spesa
D1 74 12 00 05 (74) 24 03 00 00 64 [90 20]

[16.03.24]: Richiede il valore max di P2 per l'INS 74_05
D1 74 05 7F 01 (74) 04 [90 20]

[16.03.24]: Richiede la LEN per l'INS successiva
D1 74 0C 80 01 (74) 06 [90 20]

[16.03.24]: Richiede 4 Bytes dal significato ignoto (12°,13°,14°,15° byte del Nano E2 dell'INS36)
D1 74 0C 00 06 (74) 19 04 FF FF FF FF [90 20]

[16.03.24]: Richiede la len per l'INS 74_05
D1 74 05 80 01 (74) 22 [90 20]

[16.03.24]: Richiede la LEN per l'INS successiva
D1 74 0D 80 01 (74) 06 [90 20]

[16.03.24]: Richiede 4 bytes PPv total Cost (16°,17°,18°,19° byte del Nano E2 dell'INS36)
D1 74 0D 00 06 (74) 1A 04 00 00 00 00 [90 20]

[16.03.24]: Richiede il postcode e altre info
D1 74 05 00 22 (74) 05 20 49 54 41 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 80 00 00 00 00 00 01 00 00 00 00
00 00 [90 20]

[16.03.24]: Richiede il valore max di P2 per l'INS 72
D1 72 00 7F 02 (72) 00 32 [90 20]


[16.03.24]: Richiede la len dell'INS 72
D1 72 00 80 01 (72) 23 [90 20]

[16.03.24]: Richiede il valore max di p2 per l'INS 74_04
D1 74 04 7F 01 (74) 20 [90 20]

[16.03.24]: Richiede la len dell'INS 74_04
D1 74 04 80 01 (74) 12 [90 20]

[16.03.24]: Richiede il valore max di P2 per l'INS 76
D1 76 00 7F 02 (76) 00 FA [90 20]

[16.03.24]: Richiede la LEN dell'INS 76
D1 76 00 80 01 (76) 0A [90 20]

Da questo momento in poi si ha la visione, con i normali ECM/EMM/54. Tutti questi comandi vengono inviati nell’arco di un secondo.



Le nuove attivazioni
________________________________________

Allego un log che riporta un esempio di attivazione: questo log si riferisce ad una attivazione ricevuta da una card già attiva e funzionante. Purtroppo non ho potuto loggare la prima attivazione, ma credo che grosso modo dovrebbe essere molto simile.

Ho omesso di inserire in questo log INS 40, 54, 4A, 5A e 42 di LEN 16, che arrivano regolarmente in quanto la card è perfettamente funzionante.

La prima INS 42 che arriva è quella con LEN 50, che apre i filtri e scrive qualcosa.
La LEN di questo primo EMM può variare in relazione ai dati contenuti dall’INS. Questa INS infatti ha sostituito le varie 42 firmate con chiave privata che venivano inviate con le precedenti card.

D1 42 00 00 50 (42) 90 4E 44 02 9E 74 FA BA 83 CE FA BA 83 C5 B3 4D
2A FA BA 83 57 95 FA AB 83 E4 B4 FA BA 83 24 77
3F 98 83 C4 54 17 67 12 FA BA 83 60 C3 33 C3 37
24 49 DC B8 E5 FB 26 AA 5F 29 60 20 1C 53 AE DF
AC 97 45 C8 25 BB CA DE 45 81 E1 2E F7 57 34 91
[90 A1]

D1 42 00 00 37 (42) 90 35 40 02 FC FA 9A 38 3B 13 80 00 93 E7 1A E9
81 70 76 19 0F FC 32 79 35 69 C0 45 18 B9 6C E0
27 74 27 D2 B8 93 3D 50 76 1B B6 E5 9D 83 F7 4C
16 78 C4 D3 CD 43 2C [90 A0]

LEN 37, non scrive nulla ma lascia filtri aperti; criptata con chiave pubblica

D1 42 00 00 37 (42) 90 35 40 02 FC 04 3D 9B 57 D0 B3 63 E4 8E 5E 40
DE 64 81 8F 9F 23 75 06 3B F0 05 BF 55 35 A6 F7
A5 B8 F2 F2 18 6D 64 29 8B 90 BD 7C FE A3 37 F5
D2 FD 17 FD 4B A2 C4 [90 A0]

LEN 37, non scrive nulla, lascia i filtri open, criptata con chiave pubblica ma in modo diverso rispetto alla precedente.

D1 42 00 00 25 (42) 90 23 40 02 C8 E6 07 B8 FB D3 9C 0D 42 7F 19 BA
7B 2A 91 28 9F CB AF 77 E5 F1 10 64 54 64 BE 77
8A 19 2B 58 AF [90 A0]

LEN 25, non scrive nulla, lascia i filtri open, criptata con pubblic ***

D1 42 00 00 83 (42) 90 81 60 02 3F 67 0B 71 26 C0 E4 7E AA CB 73 E3
F7 98 9A 17 C8 AB AE 32 D1 32 48 26 51 35 8E C7
BB 43 D3 43 3B 8A 49 BA 6E D4 1E D3 9F F9 32 AA
9B 9B 81 C5 4E 0D 88 36 3D 20 B0 A3 CE AA A9 EF
E9 79 2D 16 2D C8 A0 5E 7A 54 5B 9C F0 85 C6 DD
0D 0E CE 6D 78 B6 4C EE 0A D1 B5 E8 A2 EB D0 A9
03 49 A4 CE B5 3B DB 81 E8 84 42 87 CC D2 77 EE
D3 C0 83 E5 C3 B9 63 14 B6 05 F4 B9 91 78 97 EF
65 A6 78 [90 A0]

LEN 83, non scrive nulla, criptata con pubbl. ***, con hash 60, arriva sempre uguale per tutti.

D1 42 00 00 27 (42) 90 25 40 02 40 DD 5C 27 54 75 E9 A3 06 46 B9 89
91 68 1F 4C 67 5B 95 68 C4 2C 29 46 8D 6F ED 8F
D5 8A 33 64 5F 3B 3D [90 A0]

LEN 27, non scrive nulla, hash 40, filtri aperti

D1 42 00 00 21 (42) 90 1F 44 02 25 FA BA 83 27 54 4B 67 73 15 3E 83
6F 51 80 7F 46 4F 45 F7 10 0C 5B 33 4C 24 6B 02
02 [90 A1]

LEN 21, scrive qualcosa, hash 44 e filtri open

D1 42 00 00 20 (42) 90 1E 44 02 D5 40 7D 8F 09 1E E8 4C 96 2C 95 84
6B EE AF A4 16 B8 2B F3 7F 6E 47 81 50 F1 0E 3E
[91 A1]

LEN 20, scrive qualcosa, hash 44 e filtri open


A questo punto inizia una fase di boot

D1 58 00 00 4A (5Cool 15 48 25 UA UA UA UA 06 D7 75 12 10 00 00 00 00
00 00 00 00 xx xx xx 00 09 19 UA UA UA UA FF FF
FF FF SA SA SA 00 FF FF FF 00 00 00 00 00 00 00
00 00 08 00 00 00 01 49 54 41 00 00 49 54 41 4C
49 41 20 20 5F 1A B2 22 00 00 [91 A0]

D1 4C 00 00 09 (4C) in in in in 03 00 00 05 04 [90 A0]


Richiesta PIN

D1 74 11 80 01 (74) 06 [90 20]

D3 74 11 00 16 (74) E4 BD 51 7D C0 F7 15 E7 6E DA 97 3C B9 6E 55 53
88 EA EC E1 B7 88 [90 20]


Sequenza INS 74, 72 e 76 di boot

D1 74 05 7F 01 (74) 04 [90 20]
D1 74 0E 80 01 (74) 06 [90 20]
D1 74 0E 00 06 (74) 1B 04 FF FF FF FF [90 20]
D1 74 05 80 01 (74) 22 [90 20]
D1 74 12 80 01 (74) 05 [90 20]
D1 74 12 00 05 (74) 24 03 00 00 64 [90 20]
D1 74 05 7F 01 (74) 04 [90 20]
D1 74 0C 80 01 (74) 06 [90 20]
D1 74 0C 00 06 (74) 19 04 FF FF FF FF [90 20]
D1 74 05 80 01 (74) 22 [90 20]
D1 74 0D 80 01 (74) 06 [90 20]
D1 74 0D 00 06 (74) 1A 04 00 00 03 E8 [90 20]
D1 74 05 00 22 (74) 05 20 49 54 41 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 80 00 00 00 00 00 01 00 00 00 00
00 00 [90 20]

D1 72 00 7F 02 (72) 00 32 [90 20]
D1 72 00 80 01 (72) 23 [90 20]

D1 74 04 7F 01 (74) 20 [90 20]
D1 74 04 80 01 (74) 12 [90 20]

D1 76 00 7F 02 (76) 00 FA [90 20]
D1 76 00 80 01 (76) 0A [90 20]

Da qui iniziano i normali ECM e INS 54

Tutte queste INS arrivano nell'arco di qualche secondo.

Purtroppo non posso dire cosa contengono le INS 42, in quanto sono criptate con il Nano 90, ma di sicuro le più importanti sono quelle con LEN 50, 21 e 20 le quali scrivono qualcosa in EEProm (ricordo che la LEN varia in relazione ai pacchetti sottoscritti: più pacchetti, maggiore LEN).
Le altre settano filtri o abilitano la card a ricevere altri comandi (lo si desume dallo StatusWord).




Transazioni PPV
Commento di un LOG di acquisto tramite telecomando
________________________________________

Prima dell'inizio dell'evento, arrivano ECM del tipo:

D1 40 00 80 22 (40) 00 7F 0A 51 CC 4A EC 35 5D E6 2C 00 00 90 13 C0
02 B3 28 C5 58 0B 74 46 9E B4 4B 4D 8C 40 68 FB
12 62 [90 20]


All'ora di inizio dell'evento, in questo caso un film, si attiva la preview, ed arrivano degli ECM del tipo:

D1 40 00 80 42 (40) 00 7F 0A 89 2E B1 E6 01 9A 4C C9 00 00 90 33 C0
02 63 8B 6F 87 D0 05 E1 C7 52 CC 2B EA E0 1D 72
73 14 06 45 80 B4 9B 9E 48 F2 C1 0F FC 57 8D 6C
DF AE D5 AA 40 D7 B2 D9 A6 99 2A BD 57 C0 B5 FE
E6 71 [90 20]


Premendo il tasto OK del telecomando, la card richiede le informazioni sull'evento da acquistare:

D1 46 00 01 33 (46) 08 90 30 C0 02 86 72 6C CB CE 06 86 28 67 F8 9D
42 10 03 8A 28 05 79 CA 54 CA 88 71 F8 3E 95 99
51 1C 6C 86 08 AE 8D 0A FB FA 9A 2D 2F AF 9D 15
16 48 B0 [90 20]


Anzitutto arriva l'INS 46 LEN 33, che contiene varie informazioni dell'evento selezionato, tra le quali il Nano 4D ed i Tiers.

D1 0E 00 81 01 (0E) 06 [90 20]
D1 0E 00 01 06 (0E) 00 05 05 05 05 00 [90 20]


seguono le INS 0E 00x1, che sembrano sempre uguali per tutti gli eventi

D1 74 05 7F 01 (74) 04 [90 20]
D1 74 05 80 01 (74) 22 [90 20]
D1 74 05 7F 01 (74) 04 [90 20]
D1 74 05 80 01 (74) 22 [90 20]
D1 74 05 00 22 (74) 05 20 49 54 41 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 80 00 00 00 00 00 01 00 00 00 00
00 00 [90 20]

Segue la sequenza per determinare l'INS 74 05, che fornisce il Country Code e altre info.

D1 46 00 01 33 (46) 08 90 30 C0 02 86 72 6C CB CE 06 86 28 67 F8 9D
42 10 03 8A 28 05 79 CA 54 CA 88 71 F8 3E 95 99
51 1C 6C 86 08 AE 8D 0A FB FA 9A 2D 2F AF 9D 15
16 48 B0 [90 20]
D1 0E 00 81 01 (0E) 06 [90 20]
D1 0E 00 01 06 (0E) 00 05 05 05 05 00 [90 20]
D1 0E 00 82 01 (0E) 0A [90 20]
D1 0E 00 02 0A (0E) 00 05 02 1C 05 00 03 00 00 00 [90 20]


Determinazione dell'INS 0E 00 02, che fornisce un Tier dell'evento

D1 46 00 01 33 (46) 08 90 30 C0 02 86 72 6C CB CE 06 86 28 67 F8 9D
42 10 03 8A 28 05 79 CA 54 CA 88 71 F8 3E 95 99
51 1C 6C 86 08 AE 8D 0A FB FA 9A 2D 2F AF 9D 15
16 48 B0 [90 20]
D1 0E 00 81 01 (0E) 06 [90 20]
D1 0E 00 01 06 (0E) 00 05 05 05 05 00 [90 20]
D1 0E 01 82 01 (0E) 0A [90 20]
D1 0E 01 02 0A (0E) 00 05 02 1C 05 03 F9 00 00 00 [90 20]


Determinazione dell'INS 0E 01 02, che fornisce un altro Tier dell'evento

D1 46 00 01 33 (46) 08 90 30 C0 02 86 72 6C CB CE 06 86 28 67 F8 9D
42 10 03 8A 28 05 79 CA 54 CA 88 71 F8 3E 95 99
51 1C 6C 86 08 AE 8D 0A FB FA 9A 2D 2F AF 9D 15
16 48 B0 [90 20]
D1 0E 00 81 01 (0E) 06 [90 20]
D1 0E 00 01 06 (0E) 00 05 05 05 05 00 [90 20]
D1 0E 02 82 01 (0E) 0A [90 20]
D1 0E 02 02 0A (0E) 00 05 02 1C 05 01 00 00 00 00 [90 20]


Determinazione dell'INS 0E 02 02, che fornisce un altro Tier dell'evento

D1 46 00 01 33 (46) 08 90 30 C0 02 86 72 6C CB CE 06 86 28 67 F8 9D
42 10 03 8A 28 05 79 CA 54 CA 88 71 F8 3E 95 99
51 1C 6C 86 08 AE 8D 0A FB FA 9A 2D 2F AF 9D 15
16 48 B0 [90 20]

D1 0E 00 81 01 (0E) 06 [90 20]
D1 0E 00 01 06 (0E) 00 05 05 05 05 00 [90 20]
D1 0E 03 82 01 (0E) 0A [90 20]
D1 0E 03 02 0A (0E) 00 05 02 1C 05 01 00 00 00 00 [90 20]


Determinazione dell'INS 0E 03 02, che fornisce un altro Tier dell'evento

D1 46 00 01 33 (46) 08 90 30 C0 02 86 72 6C CB CE 06 86 28 67 F8 9D
42 10 03 8A 28 05 79 CA 54 CA 88 71 F8 3E 95 99
51 1C 6C 86 08 AE 8D 0A FB FA 9A 2D 2F AF 9D 15
16 48 B0 [90 20]
D1 0E 00 81 01 (0E) 06 [90 20]
D1 0E 00 01 06 (0E) 00 05 05 05 05 00 [90 20]
D1 0E 04 82 01 (0E) 1E [90 20]
D1 0E 04 02 1E (0E) 00 00 02 08 07 CC 54 00 65 5E 09 80 09 04 80 02
00 00 0A 06 00 00 00 01 2C 02 29 02 00 80 [90 20]


Determinazione dell'INS 0E 04 02, che fornisce varie informazioni sull'evento

D1 74 05 7F 01 (74) 04 [90 20]
D1 74 05 80 01 (74) 22 [90 20]
D1 74 05 7F 01 (74) 04 [90 20]
D1 74 05 80 01 (74) 22 [90 20]
D1 74 05 00 22 (74) 05 20 49 54 41 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 80 00 00 00 00 00 01 00 00 00 00
00 00 [90 20]
D1 74 05 7F 01 (74) 04 [90 20]
D1 74 05 80 01 (74) 22 [90 20]
D1 74 05 7F 01 (74) 04 [90 20]
D1 74 05 80 01 (74) 22 [90 20]
D1 74 05 00 22 (74) 05 20 49 54 41 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 80 00 00 00 00 00 01 00 00 00 00
00 00 [90 20]


Doppia sequenza dell'INS 74

D1 46 20 01 33 (46) 08 90 30 C0 02 86 72 6C CB CE 06 86 28 67 F8 9D
42 10 03 8A 28 05 79 CA 54 CA 88 71 F8 3E 95 99
51 1C 6C 86 08 AE 8D 0A FB FA 9A 2D 2F AF 9D 15
16 48 B0 [90 20]


Cambia il valore del P1 dell'INS: adesso il bit 6 è settato, quindi la card bypassa il controllo sul limite di spesa. Credo che questa ins viene inviata quando si scrive il PIN per confermare l'acquisto.

D1 0E 00 81 01 (0E) 06 [90 20]
D1 0E 00 01 06 (0E) 00 05 05 05 05 00 [90 20]

D1 46 20 02 3A (46) 00 00 FF 08 04 00 00 00 90 30 C0 02 86 72 6C CB
CE 06 86 28 67 F8 9D 42 10 03 8A 28 05 79 CA 54
CA 88 71 F8 3E 95 99 51 1C 6C 86 08 AE 8D 0A FB
FA 9A 2D 2F AF 9D 15 16 48 B0 [91 21]


Questa INS 46 è molto significativa: anzitutto si nota il valore di P2 che indica l'acquisto, la LEN passa da 33 a 3A, in quanto vengono aggiunti, prima del Nano 90, 8 bytes, che sembrano essere sempre uguali per tutti gli acquisti, almeno per i film. Dallo SB si nota che alcuni flags non sono stati resettati e soprattutto è avvenuta una scrittura in EEProm, infatti è stato scritto il record dell'evento PPV.

D1 1E 20 02 09 (1E) 27 07 00 02 70 02 00 00 00 [91 20]


Dopo la INS 46 di acquisto segue l'INS 1E, che presenta gli stessi P1 e P2 della INS 46 che precede. Questa ins fornisce informazioni sulla transazione PPV in corso.

D1 72 02 00 23 (72) 23 21 CC 54 5E 09 BF 7D 01 2C 00 04 01 80 5E 08
53 EB 00 00 00 00 00 00 00 00 00 00 00 00 00 00
5E 09 20 [91 20]


Segue l'INS 72, che indica il record (si nota dal P1) sul quale sono stati scritti i dati dell'evento acquistato.

D1 74 04 81 01 (74) 12 [91 20]
D1 74 04 01 12 (74) 15 10 00 65 00 05 01 2D 13 89 09 C5 00 00 00 00
00 00 [91 20]


L'INS 74 04 indica anch'essa le informazioni sulla transazione PPV.

D1 5E 00 04 01 (5E) 02 [90 20]


A questo punto appare l'INS 5E, che in questo caso sembra indicare il record in cui è messo l'evento. Ma non è certo, potrebbe infatti essere uno status di visione (????) Comunque lo SW torna ad essere 9020, quindi vengono resettati i flags aperti dall'ultima INS 46 ricevuta.

D1 72 02 00 23 (72) 23 21 CC 54 5E 09 BF 7D 01 2C 00 04 01 80 5E 08
53 EB 00 00 00 00 00 00 00 00 00 00 00 00 00 00
5E 09 20 [90 20]
D1 74 04 81 01 (74) 12 [90 20]
D1 74 04 01 12 (74) 15 10 00 65 00 05 01 2D 13 89 09 C5 00 00 00 00
00 00 [90 20]
Seguono le INS 72 e 74 04.

A questo punto arrivano gli ECM di visione, seguiti dalle INS 54.

D1 40 20 80 42 (40) 00 7F 0A 4F BF 8B D6 8B F2 FE 00 00 00 90 33 C0
02 8D 95 F2 65 06 EA F2 F7 79 AE BB B0 05 24 59
74 23 5F CD 03 AF B9 A2 C7 72 A9 99 0F BD 07 61
8E 70 08 48 F3 84 D1 DF C0 A0 18 12 D8 D4 31 60
6E 4C [90 20]
D3 54 00 00 3C (54) 92 45 EA 92 84 BB F8 A8 41 26 7E 6A B0 E5 16 F7
E4 DD 89 3D 21 06 8F EE A2 92 D7 A4 72 63 4D C0
AA 2A E3 A9 EE FF F1 28 AE FA 68 22 C9 36 7F EE
E4 55 E7 A5 A6 9F 8D A8 85 97 54 AD [90 20]


La LEN è 42, infatti la preview è ancora attiva. Si può notare il valore di P1 che è cambiato, infatti è stato settato il bit 6.
Questo valore dura per tutta la durata del film, ma se si toglie la card e la si rimette, il valore di P1 torna ad essere 00.
Dopo 7 minuti dall'inizio del film finisce la preview.
Quindi cambiano gli ECM, che arrivano con una LEN minore di 3F.

E' importante il primo ECM che la card riceve dopo la fine della preview:

D1 40 20 80 3F (40) 00 7F 0A EC 26 D2 EA 5B 8B 5D 4A 00 00 90 30 C0
02 AF 28 3D 00 33 86 A9 0F 49 8E 8F 79 1F 61 C9
73 E5 71 DA 3D 54 18 6B 59 1C 37 EA 11 EC 98 69
82 58 3D 68 11 3E 6C 6B F2 8F C2 70 9D E2 2C [91 20]
D1 54 00 00 3C (54) C4 6A 76 FE 06 1D 76 C5 1C 53 B2 B7 34 5E 22 7E
D7 5A 5B 2C 75 9F C6 62 59 63 69 4E C4 17 5C 1F
40 F0 DF CC 00 4E A4 5D BF 66 8B F9 0A 7A D7 2B
3B E7 9A B2 D1 B8 6D A9 82 64 EA 14 [91 20]


Si nota infatti che lo status dell'ECM e della successiva INS 54, sono 9120, quindi alcuni flags non vengono resettati.
Proprio perchè i flags non sono stati resettati, viene inviata un'INS 5E che risponde indicando tutti gli EvID registrati in Eeprom.

D1 5E 00 0E C8 (5E) C4 9D 02 04 C4 9D 02 04 CC 54 01 04 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 .. [90 20]

Si noti come lo SW torni ad essere 9020.


Da qui in poi arrivano ECM del tipo:

D1 40 20 80 3F (40) 00 7F 0A 94 5A AD B8 FC 38 FE 68 00 00 90 30 C0
02 E1 E5 A9 77 85 1B D4 90 25 0C 67 65 BA 9B 2E
75 73 5F C1 AB EA 0A E6 DA D5 2A 5D BC F3 46 7C
51 16 8F 94 5B 6B 20 70 5F 8D 90 8B E3 9C 97[90 20]
D3 54 00 00 3C (54) 10 F5 FD FA 54 5B 69 B1 B4 22 39 FF 81 9F 88 CD
DD BA 4F 50 98 36 86 84 41 94 5A 72 5B 47 08 18
07 A4 E4 EF FB 33 3A 03 82 D1 DB 2D AB E5 07 F7
05 3B 8E EE 36 4C E9 C6 D7 27 90 EC [90 20]


Queste INS sono intervallate ogni 10 secondi circa da INS 4A e 5A, oltre che dalle INS 42 di LEN 16 che settano l'orario.




Quando il film finisce, gli ECM tornano ad avere LEN 22:

D1 40 00 80 3F (40) 00 7F 0A EA 89 B2 39 DC 44 23 C6 00 00 90 30 C0
02 DE E8 9D 4C 4C 28 F6 0B 6D D3 71 B9 93 19 0E
B8 A7 34 6A 57 83 5B C4 8C 37 84 D4 3E EB 56 E9
77 CC 6A 19 07 7F AD B9 B1 5C 1A 8A 52 3B BD [90 20]
D1 40 00 80 22 (40) 00 7F 0A 51 CC 4A EC 35 5D E6 2C 00 00 90 13 C0
02 B3 28 C5 58 0B 74 46 9E B4 4B 4D 8C 40 68 FB
12 62 [90 20]


Va ricordato inoltre che una volta terminato l'evento, non è possibile visionarlo un'altra volta.
E questo è tutto, almeno per ora....










































Istruzioni di una Card NDS
________________________________________

Comando 0x02 – Send Card Type and ROM Version

Comando
D0 02 00 00 08

P1 Non significativo
P2 Non significativo
LEN Valore 08 - LEN maggiori restituisce 8 bytes di dati e 00xLEN di padding

Questo comando fornisce il Tipo di Card e la versione della ROM.

D0 02 00 00 58 (02) 49 54 54 56 02 00 4C 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [90 00]

49 54 54 56 Card Type ITTV
02 00 4C 45 ROM Version V.2 LE
90 00 SB



Comando 0x04 – Receive Byte (H-Card 8022)

Comando
D0 04 00 00 01

P1 Non significativo
P2 Non significativo
LEN Non significativo - Valori diversi da 01h danno sempre lo stesso risultato

Questo comando setta presumibilmente una locazione di memoria in EEProm con il valore fornito nel comando, in maniera simile a quanto avviene per le H-Card. E come su queste card, il byte può essere riletto con il Comando D0 06.
Anche se scrive in EEProm, lo status byte rimane 9000 e non 9001.
L’utilità del comando non è nota. In ogni caso non altera, apparentemente, lo stato della card.

D0 04 00 00 01 (04) XX 90 00

XX Sconosciuto
90 00 SB



Comando 0x06 – Send Byte (H-Card 8022)

Comando
D0 06 00 00 01

P1 Non significativo
P2 Non significativo
LEN Non significativo - Valori diversi da 01h danno sempre lo stesso risultato

Questo comando, presumibilmente, legge un byte da una locazione di memoria in EEProm. Questo byte può essere settato dal Comando D0 04.
Per valori di P1 da 01 a 07 la risposta è 00, per qualunque altro valore dà XX, ossia il byte scritto con l’INS 04.

D0 06 00 00 01 (06) XX 90 00

XX Sconosciuto
90 00 SB



Comando 0x0E – Send PPV event info

Comando
D0 0E P1 P2 LEN

L'INS 0E è legata alla PPV e all'INS 46, infatti appare solo dopo aver ricevuto una INS 46. Tra l'altro varia in relazione al contenuto dell’INS 46 che la precede e la determina.
Se non è preceduta dalla INS 46, restituisce tutti 00 per valori di P2 pari, per valori di P2 dispari restituisce 09 se P2<80, restituisce 01 se P2>79.

Sono significativi sia il P1 che il P2.

I valori di P1 fin qui osservati vanno da 00 a 04:

7654 3210
0000 0000 00 Sconosciuto (risposte sempre uguali)
0000 0001 01 \
0000 0010 02 |------------ Vengono indicati i Tiers dell’evento
0000 0011 03 /
0000 0100 04 Vengono indicati i dati di acquisto

I valori di P2 fin qui osservati presentano valori del LowNibble pari a 1 e 2 e valori dell’HighNibble pari a 0 e 8:

7654 3210
0000 0001 01
1000 0001 81
0000 0010 02
1000 0010 82

HighNibble = 8 indica la LEN del comando successivo (che naturalmente deve presentare lo stesso LowNibble e lo stesso P1).
HighNibble = 0 indica il contenuto della risposta del comando.
LowNibble = 1 si osserva soltanto accoppiato a P1=00
LowNibble = 2 si osserva con tutti i valori di P1.

Esempio:

D1 0E 00 81 01 (0E) 06 [90 20]
D1 0E 00 01 06 (0E) 00 05 05 05 05 00 [90 20]


Si osserva che vengono inviate in serie queste INS 0E per ricevere informazioni sull'evento PPV:

D1 0E 00 81 01 (0E) 06 [90 20]
D1 0E 00 01 06 (0E) 00 05 05 05 05 00 [90 20]
D1 0E 00 82 01 (0E) 0A [90 20]
D1 0E 00 02 0A (0E) 00 05 05 1C 05 02 45 00 00 00 [90 20]

D1 0E 01 82 01 (0E) 0A [90 20]
D1 0E 01 02 0A (0E) 00 05 05 1C 05 00 03 00 00 00 [90 20]

D1 0E 02 82 01 (0E) 0A [90 20]
D1 0E 02 02 0A (0E) 00 05 05 1C 05 04 4F 00 00 00 [90 20]

D1 0E 03 82 01 (0E) 0A [90 20]
D1 0E 03 02 0A (0E) 00 05 05 1C 05 01 00 00 00 00 [90 20]

D1 0E 04 82 01 (0E) 1E [90 20]
D1 0E 04 02 1E (0E) 00 00 05 08 07 C4 9D 00 65 5E 05 80 09 04 80 02
00 00 0A 06 00 00 00 01 F4 02 29 02 00 80 [90 20]


Volendo fare un parsing:

D1 0E 02 02 0A (0E)

00 ??
05 05 ??
1C 05 ??
04 4F 00 Tier
00 00 ??
90 20 SB


D1 0E 04 02 1E (0E)

00 00 05 08 07 ??
C4 9D PPV EventID
00 65 Tipo acquisto
5E 05 Mese e giorno dell’acquisto+1
80 09 04 80 02 00 00 0A 06 00 00 00 ??
01 F4 Costo evento
02 29 02 00 ??
80 ??
[90 20] SB


Queste INS vengono intervallate da INS 46 (che in questa fase dell'info sull'acquisto sono sempre uguali), e da INS 74 05.



Comando 0x12 – Send Technical Info

Comando
D0 12 00 00 08

P1 Non significativo
P2 Non significativo
LEN Valore 08 - LEN maggiori restituiscono 8 bytes di dati ed i rimanenti 00xLEN di padding


D0 12 00 00 08 (12) 04 12 1B 31 06 14 24 02 90 00

04 CMS Version
10 0F 59 Batch number
02 Wafer number
0C 0A Die position
02 Microcode ROM version
90 00 SB
Comando 0x1E – Send PPV Purchasing Info

Comando
D0 1E P1 P2 LEN

Il parametro P1 sembra non essere significativo in una card attiva senza acquisti PPV.
Il parametro P2, invece, fa variare la risposta della card, che sarà:

27 07 01 00 00 02 00 20 00 90 00 per LowNibble=2, 3, 6, 7, A, B, E, F
27 07 01 00 00 02 00 00 00 90 00 per LowNibble=0, 1, 4, 5, 8, 9, C, D


Come si vede, a variare è il byte numero 8 (da 20 a 00).
Il valore dell'HighNibble di P2 è i

[presario2500]

hola alguien sabe la configuracion de cataluña,para el abq?los parametros,la qam y algun parametro mas que ahora no me acuerdo por que no tengo el deco aqui ,pues no me consigue coger los tdt ,como la tve1,la2 etc...SALUDOS

[novato1223]

no se si se permiten enlaces a otras paginas pero esta me parece muy muy interesante

http://www.studionds.altervista.org//modules.php?name=Forums&file=viewtopic&t=466

[GALLEGO]

hola alguien sabe la configuracion de cataluña,para el abq?los parametros,la qam y algun parametro mas que ahora no me acuerdo por que no tengo el deco aqui ,pues no me consigue coger los tdt ,como la tve1,la2 etc...SALUDOS

la configuracion de los abq se hace con el mando en herramientas pones codigo cuatro ceros y busqueda de canales el solo se actualiza y salen todos los canales (en una targeta sin manipular y dada de alta).
he leido por ahi que las manipuladas como son de sevilla para cataluña es mas complicado.

[novato1223]

ver si a alguien le va este scrip


' ================
' = Turbo Unloop =
' ================
' = v1.0 =
' ================
'
' by aol6945
'
' This script uses WildThing-style glitching to read and fix cards. It works on
' both regular H cards and Black-Sunday H cards.
' It does so more reliably than SU2v2 or The WildThing 6/7 software, and will
' work with any WildThing-compatible unlooper, using any Atmel code - WT, WT2, WTX, or SU2
'
' It requires WinExplorer 4.5 set to Unlooper mode quicksettings, and you must
' disable Transaction Logging, Display Fuse after Script, and Display USW after Script
'

' Global Variable Definitions
Option Explicit

' Constants used throughout script
Const ScriptName="TurboUnloop"
Const ScriptVer="1.0"

' Glitching values/constants
Dim DAC(8),Delay(8),GlitchDelay(8) ' Working values
Dim DACL(8),DelayL(8),GlitchDelayL(8) ' Lower range limit constants
Dim DACI(8),DelayI(8),GlitchDelayI(8) ' Initial Value Constants
Dim DACH(8),DelayH(8),GlitchDelayH(8) ' High range limit constants
Dim Tries(8) ' Running total of number of times a glitch has been tried
Dim TotalTries(8) ' Running total of number of times a glitch task has been tried
Dim TriesLimit(8) ' Upper limit for trying this glitch - exceeding it means new glitch values will be selected
Dim TriesLimitN(8) ' Normal limit for number of times to try a glitch
Dim TriesLimitI(8) ' Initial limit for trying initial glitches
Dim AltProcTriesLimit(8) ' Limit on Total tries before switching glitch procedures
Dim AltProc(8) ' The glitch set that is the alternate procedure
Dim GlitchProc(8) ' The procedure number within the task that should be run with these glitch parameters
Dim FailsLimit(8) ' Failure limit for trying previously successful glitches - exceeding it means saved glitch values will be deleted and new ones will be searched for
Dim GlitchLogic(8) ' 0=Try successive glitches by incrementing glitch values, 1=Try random glitch values
Dim Search(8) ' 0=Using saved glitch parameters, 1=Searching for new glitch parameters
Dim TaskSet(5) ' Holds which set of glitches is currently being used for a task

' Global Unlooper Packet Variables
Dim ATR(13)
Dim PacketResponse(4)
Dim GPPLen,GPRLen
Dim GPR(70)
Const MasterFailLimit=20000

' Constants for file manipulation
Const fsoError=-1
Const fsoOpenRead=0
Const fsoOpenWrite=1
Const fsoOpenReadWrite=2
Const fsoSEEK_SET=0
Const fsoSEEK_CUR=1
Const fsoSEEK_END=2



' ==================
' = Main Procedure =
' ==================

Sub Main()
' Main Program Loop and Menu
Dim MenuChoice
Dim MsgPrompt
Dim ErrorValue

' Suppress window output
Sc.Verbose=False

' Verify correct version of WinExplorer
Call SetupWinExplorer()

' Show Splash screen
Call Sc.PictureBox("Turbo-Unloop.jpg",5)

Do
MsgPrompt="=== "+ScriptName+" "+ScriptVer+" ==="+vbCr+vbCr
MenuChoice=Sc.ButtonBox(MsgPrompt,vbDefaultButton2 ,ScriptName+" "+ScriptVer+" - Main Menu","Read Card","Fix Card","Exit")

' Initialize Glitch values
Call SetGlitchValues()

Select Case MenuChoice
Case 1:
ErrorValue=ReadCard()
Case 2:
ErrorValue=FixCard()
End Select
Loop Until MenuChoice=3

' Show ending graphic
Call Sc.PictureBox("Turbo-Unloop-b.jpg",5)
End Sub

' =========================
' = High-Level Procedures =
' =========================

Function FixCard()
' This function drives the unlooper to fix a card.
Dim i,j
Dim Stage
Dim RetVal
Dim MsgPrompt
Dim Display
Dim MasterTries
Dim Finished
Dim EID,CAMID,USW,IRD,LastDynCode

FixCard=0
MasterTries=0
Finished=0

' Turn off LED
Sc.Write("A0")

' Wait for a card to be inserted
Call WaitCardInsert()

' Turn on LED Green
Sc.Write("A1")

' See if the card needs to be fixed
Call GenericMsg("Checking ATR ...")
Sc.Delay(500)
If CheckGoodCard() Then
RetVal=1
ElseIf CheckGoodCardBS() Then
RetVal=2
Else
RetVal=0
End If
If RetVal>0 Then
Sc.Write("A0")
Call RemoveMsg()
MsgPrompt="This card has a good ATR and can process packets."+vbCr+_
"It is probably not looped."+vbCr
If RetVal=2 Then
MsgPrompt=MsgPrompt+"(Although this is a Black Sunday card)."+vbCr
End If
MsgPrompt=MsgPrompt+vbCr+"Do you want to fix/unloop the card anyway?"
RetVal=Sc.MsgBox(MsgPrompt,vbQuestion+vbYesNo+vbDe faultButton2,ScriptName+" "+ScriptVer+" - Fix Good Card?")
If RetVal=vbNo Then
FixCard=0
Exit Function
End If
End If

' Turn on LED Green
Sc.Write("A1")

' Glitcher Driver (The Illudium PU-36 Explosive Glitch Modulator)
Stage=1
Display=0
Do While (Finished=0)
If CardInserted()=0 Then
Stage=8
End If
If MasterTries>MasterFailLimit Then
Stage=9
End If
MasterTries=MasterTries+1

Select Case Stage
Case 1: ' Glitch Task 1 - Attempt to get 1st byte of ATR
If Params(TaskSet(1)) Or Display<1 Then
Call GlitchMsg(1)
Display=1
End If
If GlitchTask1(TaskSet(1)) Then
Stage=2
Tries(TaskSet(1))=0
Search(TaskSet(1))=0
Else
If TotalTries(TaskSet(1))>=AltProcTriesLimit(TaskSet( 1)) Then
' If we've tried AltProcTriesLimit glitches for one glitch parameter set and won't pop, try alternate glitch parameter set
TotalTries(TaskSet(1))=0
TaskSet(1)=AltProc(TaskSet(1))
' TaskSet(5)=TaskSet(1)
End If
End If
Case 2: ' Glitch Task 2 - Get Next 10 bytes of ATR
If Params(TaskSet(2)) Or Display<2 Then
Call GlitchMsg(2)
Display=2
End If
If GlitchTask2(TaskSet(2)) Then
Stage=3
Tries(TaskSet(2))=0
Search(TaskSet(2))=0
Else
Stage=1
End If
Case 3: ' Glitch Task 3 - Get last 2 bytes of ATR and get card to process a packet
If Params(TaskSet(3)) Or Display<3 Then
Call GlitchMsg(3)
Display=3
End If
If GlitchTask3(TaskSet(3)) Then
Stage=4
Tries(TaskSet(3))=0
Search(TaskSet(3))=0
Else
Stage=1
End If
Case 4: ' Glitch Task 4 - Fill Memory to overwrite stack
If Params(TaskSet(4)) Or Display<4 Then
Call GlitchMsg(4)
Display=4
End If
If GlitchTask4(TaskSet(4)) Then
Stage=5
Tries(TaskSet(4))=0
Search(TaskSet(4))=0
Else
Stage=1
End If
Case 5: ' Check for normal bootloader
If CheckBootloader() Then
If GetCardInfo(EID,CAMID,USW,IRD,LastDynCode) Then
Stage=7 ' Got info, go to write Fixbin
Else
Stage=1 ' Bootloader is on card but failed? Probable corrupted bootloader. Reglitch.
End If
Else
Stage=6 'Bootloader is supposed to be here, but isn't. Glitch into bootloader (Black Sunday card)
End If
Case 6: ' Attempt to glitch into bootloader for BS card
Search(TaskSet(5))=1 ' This makes sure we don't keep trying the same glitch to get into the bootloader every time
Tries(TaskSet(5))=TriesLimit(TaskSet(5))+1
If Params(TaskSet(5)) Or Display<5 Then
Call RWMsg("Glitching into Bootloader ...",1,225)
Display=5
End If
If GlitchTask5(TaskSet(5)) Then
' Successfully glitched into bootloader, attempt to get card info
If GetCardInfo(EID,CAMID,USW,IRD,LastDynCode) Then
Stage=7 ' Got info, go to write Fixbin
Else
Stage=1 ' Bootloader is on card but failed? Probable corrupted bootloader. Reglitch.
End If
ElseIf TotalTries(TaskSet(5))>TriesLimitI(TaskSet(1)) Then
Stage=1 ' Tried to glitch into bootloader many times, can't get in. Reglitch.
TotalTries(TaskSet(5))=0
End If ' Otherwise try to glitch into bootloader again
Case 7: ' Attempt to write Fixbin
If WriteFixBin63() And ExitBootloader() Then
Stage=10 ' Finished and successful
Else
Stage=9 ' Error
End If
Case 8: ' Card was Removed
' Turn off LED
Sc.Write("A0")
' Clear Progress Box
Call RemoveMsg()
RetVal=Sc.MsgBox("Card was Removed",vbInformation+vbOKOnly,ScriptName+" "+ScriptVer+" - Unloop Procedure")
Finished=1
Case 9: ' Error loading/glitching card
' Turn on LED Red
Sc.Write("A2")
' Disconnect Card
SendGP("02")
' Clear Progress Box
Call RemoveMsg()
RetVal=Sc.MsgBox("Error: Unable to Glitch/Load Card",vbExclamation+vbOKOnly,ScriptName+" "+ScriptVer+" - Unloop Procedure")
' Turn off LED
Sc.Write("A0")
Finished=1
Case 10: ' Finished & successful
' Disconnect Card
SendGP("02")
' Turn off LED
Sc.Write("A0")
' Clear Progress Box
Call RemoveMsg()
Finished=1
FixCard=1
End Select
Loop

' If glitching and fixing was successful, inform user
If FixCard=1 Then
MsgPrompt="Finished Fixing Card, Repair Sequence: "+HexString(DAC(TaskSet(1)),2)+"/"+HexString(Delay(TaskSet(1)),2)+"/"+_
HexString(GlitchDelay(TaskSet(1)),2)+"/"+HexString(DAC(TaskSet(3)),2)+"/"+HexString(Delay(TaskSet(3)),2)+"/"+HexString(GlitchDelay(TaskSet(3)),2)+"/"+_
HexString(DAC(TaskSet(4)),2)+"/"+HexString(Delay(TaskSet(4)),2)+"/"+HexString(GlitchDelay(TaskSet(4)),2)+vbCr+vb Cr
MsgPrompt=MsgPrompt+"Before Repair:"+vbCr
MsgPrompt=MsgPrompt+"EID: "+EID+vbCr+_
"CAM ID: "+CStr(HexToDec(CAMID))+"_ ("+CAMID+")"+vbCr+_
"USW: "+CStr(HexToDec(USW))+" ("+USW+")"+vbCr+_
"IRD: "+IRD+vbCr
If HexToDec(USW)=63 Then
MsgPrompt=MsgPrompt+"Last Executed Dynamic Code: "
For i=0 to (Len(LastDynCode)\2)-1
MsgPrompt=MsgPrompt+Mid(LastDynCode,i*2+1,2)+" "
Next
End If
MsgPrompt=MsgPrompt+vbCr+vbCr
MsgPrompt=MsgPrompt+"After Repair:"+vbCr+"ATR: "
If CheckGoodCard() Then
RetVal=1
ElseIf CheckGoodCardBS() Then
RetVal=2
Else
RetVal=0
End If
If RetVal>0 Then
For i=0 to 12
MsgPrompt=MsgPrompt+HexString(ATR(i),2)+" "
Next
Else
MsgPrompt=MsgPrompt+"Error! Still bad ATR!"
End If
MsgPrompt=MsgPrompt+vbCr
If RetVal=2 Then
MsgPrompt=MsgPrompt+"(This is a Black Sunday card)."
End If
RetVal=Sc.MsgBox(MsgPrompt,vbInformation+vbOKOnly, ScriptName+" "+ScriptVer+" - Unloop Procedure")
End If
End Function

Function ReadCard()
' This function drives the unlooper to fix a card.
Dim i,j
Dim Stage
Dim RetVal
Dim MsgPrompt
Dim Display
Dim MasterTries
Dim Finished
Dim EID,CAMID,USW,IRD,LastDynCode

ReadCard=0
MasterTries=0
Finished=0

' Turn off LED
Sc.Write("A0")

' Wait for a card to be inserted
Call WaitCardInsert()

' Turn on LED Green
Sc.Write("A1")

' Glitcher Driver (The Illudium PU-36 Explosive Glitch Modulator)
Stage=1
Display=0
Do While (Finished=0)
If CardInserted()=0 Then
Stage=8
End If
If MasterTries>MasterFailLimit Then
Stage=9
End If
MasterTries=MasterTries+1

Select Case Stage
Case 1: ' Glitch Task 1 - Attempt to get 1st byte of ATR
If Params(TaskSet(1)) Or Display<1 Then
Call GlitchMsg(1)
Display=1
End If
If GlitchTask1(TaskSet(1)) Then
Stage=2
Tries(TaskSet(1))=0
Search(TaskSet(1))=0
Else
If TotalTries(TaskSet(1))>=AltProcTriesLimit(TaskSet( 1)) Then
' If we've tried AltProcTriesLimit glitches for one glitch parameter set and won't pop, try alternate glitch parameter set
TotalTries(TaskSet(1))=0
TaskSet(1)=AltProc(TaskSet(1))
TaskSet(5)=TaskSet(1)
End If
End If
Case 2: ' Glitch Task 2 - Get Next 10 bytes of ATR
If Params(TaskSet(2)) Or Display<2 Then
Call GlitchMsg(2)
Display=2
End If
If GlitchTask2(TaskSet(2)) Then
Stage=3
Tries(TaskSet(2))=0
Search(TaskSet(2))=0
Else
Stage=1
End If
Case 3: ' Glitch Task 3 - Get last 2 bytes of ATR and get card to process a packet
If Params(TaskSet(3)) Or Display<3 Then
Call GlitchMsg(3)
Display=3
End If
If GlitchTask3(TaskSet(3)) Then
Stage=4
Tries(TaskSet(3))=0
Search(TaskSet(3))=0
Else
Stage=1
End If
Case 4: ' Glitch Task 4 - Fill Memory to overwrite stack
If Params(TaskSet(4)) Or Display<4 Then
Call GlitchMsg(4)
Display=4
End If
If GlitchTask4B(TaskSet(4)) Then
Stage=5
Tries(TaskSet(4))=0
Search(TaskSet(4))=0
Else
Stage=1
End If
Case 5: ' Attempt to read card
If ReadBin() Then
Stage=10 ' Successfully read EEPROM, go to finished.
Else
Stage=9 ' Couldn't read card, display error.
End If
Case 8: ' Card was Removed
' Turn off LED
Sc.Write("A0")
' Clear Progress Box
Call RemoveMsg()
RetVal=Sc.MsgBox("Card was Removed",vbInformation+vbOKOnly,ScriptName+" "+ScriptVer+" - Unloop Procedure")
Finished=1
Case 9: ' Error loading/glitching card
' Turn on LED Red
Sc.Write("A2")
' Disconnect Card
SendGP("02")
' Clear Progress Box
Call RemoveMsg()
RetVal=Sc.MsgBox("Error: Unable to Glitch/Read Card",vbExclamation+vbOKOnly,ScriptName+" "+ScriptVer+" - Unloop Procedure")
' Turn off LED
Sc.Write("A0")
Finished=1
Case 10: ' Finished & successful
' Disconnect Card
SendGP("02")
' Turn off LED
Sc.Write("A0")
' Clear Progress Box
Call RemoveMsg()
Finished=1
ReadCard=1
End Select
Loop

' If glitching and fixing was successful, inform user
If ReadCard=1 Then
MsgPrompt="Finished Reading Card, Glitch Sequence: "+HexString(DAC(TaskSet(1)),2)+"/"+HexString(Delay(TaskSet(1)),2)+"/"+_
HexString(GlitchDelay(TaskSet(1)),2)+"/"+HexString(DAC(TaskSet(3)),2)+"/"+HexString(Delay(TaskSet(3)),2)+"/"+HexString(GlitchDelay(TaskSet(3)),2)+"/"+_
HexString(DAC(TaskSet(4)),2)+"/"+HexString(Delay(TaskSet(4)),2)+"/"+HexString(GlitchDelay(TaskSet(4)),2)+vbCr+vb Cr
RetVal=Sc.MsgBox(MsgPrompt,vbInformation+vbOKOnly, ScriptName+" "+ScriptVer+" - Unloop Procedure")
End If
End Function


' ========================
' = Mid-Level Procedures =
' ========================

Sub WaitCardInsert()
' This function waits for a card to be inserted
Call Sc.ProgressBox("Please Insert A Card",1,100,ScriptName+" "+ScriptVer+" - Unloop Procedure")
Do While (CardInserted()=0)
Loop
End Sub

Function Params(g)
' This function updates the glitch parameters of the selected glitch
' parameter set. The function returns 1 if the current working glitches
' were updated, 0 otherwise.

Dim Temp

Params=0
' Initialize to starting values if this is first entry
If DAC(g)=0 And Search(g)=1 Then
DAC(g)=DACI(g)
Delay(g)=DelayI(g)
GlitchDelay(g)=GlitchDelayI(g)
TriesLimit(g)=TriesLimitI(g)
Tries(g)=0
Params=1
Else
Tries(g)=Tries(g)+1
TotalTries(g)=TotalTries(g)+1
If Search(g)=0 Then
' If we have tried these settings repeatedly and reached the fail limit, try to find a different set.
If Tries(g)>FailsLimit(g) Then
Search(g)=1
Tries(g)=TriesLimit(g)+1
End If
End If
If Search(g)=1 Then
' If we have tried these settings repeatedly and reached the tries limit, try to find a different set.
If Tries(g)>TriesLimit(g) Then
If GlitchLogic(g)=0 Then ' Increment the parameters
Temp=ParmInc(DAC(g),DACL(g),DACH(g),ParmInc(Delay( g),DelayL(g),DelayH(g),ParmInc(GlitchDelay(g),Glit chDelayL(g),GlitchDelayH(g),1)))
Else
DAC(g)=RandomRange(DACL(g),DACH(g)) ' Select random voltage
Delay(g)=RandomRange(DelayL(g),DelayH(g)) ' Select random delay
GlitchDelay(g)=RandomRange(GlitchDelayL(g),GlitchD elayH(g)) ' Select random glitch delay
End If
TriesLimit(g)=TriesLimitN(g)
Tries(g)=0
Params=1
End If
End If
End If
End Function

Sub GlitchMsg(t)
' This function displays a progress box on the status of unlooping
' What is displayed depends on the task the sub is called with, t

Dim i
Dim Msg

Msg="Status: Glitching ..."+vbCr+"Sequence: "
If t>=1 Then
Msg=Msg+HexString(DAC(TaskSet(1)),2)+"/"+HexString(Delay(TaskSet(1)),4)+"/"+HexString(GlitchDelay(TaskSet(1)),2)
End If
If t>=3 Then
Msg=Msg+"/"+HexString(DAC(TaskSet(3)),2)+"/"+HexString(Delay(TaskSet(3)),4)+"/"+HexString(GlitchDelay(TaskSet(3)),2)
End If
If t>=4 Then
Msg=Msg+"/"+HexString(DAC(TaskSet(4)),2)+"/"+HexString(Delay(TaskSet(4)),4)+"/"+HexString(GlitchDelay(TaskSet(4)),2)
End If
Msg=Msg+vbCr+"ATR: "
If t>=1 Then
Msg=Msg+HexString(ATR(i),2)+" "
End If
If t>=2 Then
For i=1 to 10
Msg=Msg+HexString(ATR(i),2)+" "
Next
End If
If t>=3 Then
For i=11 to 12
Msg=Msg+HexString(ATR(i),2)+" "
Next
End If
Call Sc.ProgressBox(Msg,t,5,ScriptName+" "+ScriptVer+" - Unloop Procedure")
End Sub

Sub GenericMsg(Message)
' This function displays a progress box on the status of unlooping
' No glitches or ATR are displayed, only the passed Message

Dim i
Dim Msg

Msg="Status: "+Message+vbCr+"Sequence: "+vbCr+"ATR: "
Call Sc.ProgressBox(Msg,1,5,ScriptName+" "+ScriptVer+" - Unloop Procedure")
End Sub

Sub RWMsg(Message,Progress,MaxProgress)
' This function displays a progress box on the status of unlooping
' The full glitch sequence and ATR are displayed along with the passed Message
' The Progress and MaxProgress control the progress bar, Progress is auto-incremented

Dim i
Dim Msg

Msg="Status: "+Message+vbCr+"Sequence: "
Msg=Msg+HexString(DAC(TaskSet(1)),2)+"/"+HexString(Delay(TaskSet(1)),4)+"/"+HexString(GlitchDelay(TaskSet(1)),2)+"/"
Msg=Msg+HexString(DAC(TaskSet(3)),2)+"/"+HexString(Delay(TaskSet(3)),4)+"/"+HexString(GlitchDelay(TaskSet(3)),2)+"/"
Msg=Msg+HexString(DAC(TaskSet(4)),2)+"/"+HexString(Delay(TaskSet(4)),4)+"/"+HexString(GlitchDelay(TaskSet(4)),2)+" ... Success!"+vbCr+"ATR: "
For i=0 to 12
Msg=Msg+HexString(ATR(i),2)+" "
Next
Call Sc.ProgressBox(Msg,Progress,MaxProgress,ScriptName +" "+ScriptVer+" - Unloop Procedure")
Progress=Progress+1
End Sub

Sub RemoveMsg()
' This function removes the progress box from the screen.
Call Sc.ProgressBox("",0,0,"")
End Sub

Function GetCardInfo(EID,CAMID,USW,IRD,LastDynCode)
GetCardInfo=0
If ReadViaBootloader("8008",&H08,EID)=0 Then Exit Function
If ReadViaBootloader("8374",&H04,CAMID)=0 Then Exit Function
If ReadViaBootloader("8406",&H02,USW)=0 Then Exit Function
If ReadViaBootloader("83C0",&H04,IRD)=0 Then Exit Function
If ReadViaBootloader("893C",&H11,LastDynCode)=0 Then Exit Function
GetCardInfo=1
End Function

Function WriteFixbin63()
' This function writes a clean USW 63 non-clone image to the EEPROM using the bootloader
' 8020-8067 is skipped because this area will be cleaned when the bootloader is erased
' Returns 1 on successful write, 0 on failure
Dim Progress

Progress=1
WriteFixBin63=0
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8067",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8077",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8087",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8097",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("80A7",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("80B7",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("80C7",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("80D7",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("80E7",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("80F7",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8107",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8117",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8127",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8137",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8147",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8157",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8167",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8177",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8187",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8197",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("81A7",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("81B7",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("81C7",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("81D7",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("81E7",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("81F7",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8207",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8217",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8227",&H10,"000000000000000000 02072302894E02")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8237",&H10,"89E8028FC60289E102 8FD60205E9028A")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8247",&H10,"B4028BA5028F19021C B4028D96028CF2")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8257",&H10,"028AB0028C22021D28 021EA3020D2502")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8267",&H10,"8E6C0210A6028D8502 8CBF021462028E")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8277",&H10,"92021B31028D03028F BC028972028D96")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8287",&H10,"028FB0042200040103 00000B02FF0305")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8297",&H10,"000000000402041202 01FF07FF030104")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("82A7",&H10,"0300FF080000000000 0000010D070801")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("82B7",&H10,"02040408FF00040303 FF0000FF000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("82C7",&H10,"FFFF02000200050202 0405FF01000205")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("82D7",&H10,"04FFFF0414FFFFFF00 FFFFFF0000FFFF")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("82E7",&H10,"FFFFFFFFFF63297C44 98C52FD5279394")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("82F7",&H05,"741C7B64FF")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("836C",&H08,"4855545602004833") =0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8379",&H10,"0300009501288FFFFF FF001800328242")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8389",&H10,"7FFF0018005315602F FF001800631320")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8399",&H10,"1FFF00010201010102 01010102010103")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("83A9",&H10,"040000010201010000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("83B9",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("83C9",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("83D9",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("83E9",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("83F9",&H10,"000000000000000000 00000000003F00")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8409",&H10,"000000000000000000 00000000010000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8419",&H10,"000000080009010000 000BFFFFFFFF00")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8429",&H10,"000000FFFFFF000102 03040000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8439",&H10,"000000000013040000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8449",&H10,"000000000000000000 00000000000000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8459",&H0F,"00000000000000A876 B8E8002205E3")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("84F8",&H10,"00021CC10000000000 0000007D37D051")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8508",&H10,"5A4CB8BA6C0B65A3B0 144B1C4E445220")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8518",&H10,"5445414DD4CC171929 DE8D59634E95CC")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8528",&H10,"023D0000DD28977943 8A71801227C692")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8538",&H10,"022D000058A3A43AF6 47066EC21893F9")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8548",&H10,"79CD95C00555958575 653500434784F9")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8558",&H10,"FDCF949E8645000022 22222222222200")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8568",&H10,"01000000121C6CE412 1C6C7576D379D3")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8578",&H10,"770074AAC0E07485C0 E0B1AFCDB1AFFF")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8588",&H10,"FC91F9EDB4AA004018 900C98848008B4")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8598",&H10,"C6028003B4BB0AC005 7485C0E0798078")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("85A8",&H10,"8022128D9680CB1206 7E028D96802B80")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("85B8",&H10,"258042804102856002 86350285CF0286")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("85C8",&H10,"C60285D20287450286 870286C3E6F583")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("85D8",&H10,"08E6F5820822D27380 02C273B1D55382")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("85E8",&H10,"F886057908E4933073 03120035128D96")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("85F8",&H10,"A3D9F2DDEE22158115 81E4F544849160")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8608",&H10,"305F055003F6057622 79D3E709B40001")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8618",&H10,"22B4FF0DE709870590 87B31287850980")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8628",&H10,"EAFF87830987820912 057C80DE90855C")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8638",&H10,"E0FAA3E0FB4A6004C0 03C00222908406")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8648",&H10,"E0F874019304700108 C3798197702EE8")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8658",&H10,"199770290286602260 0E7982E7648580")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8668",&H10,"1C09E7C39441501502 8FF18479827A06")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8678",&H10,"E7D10609DAFA908406 7980D1E1E422EC")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8688",&H10,"6011B41200500CF5F0 E760139088EEE0")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8698",&H10,"4760030282847400D1 A7028725D106D5")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("86A8",&H10,"F00579100287F3AFF0 09BF110050E4C0")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("86B8",&H10,"01A1F1E9D001AFF002 887B1CE720E50C")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("86C8",&H10,"541F702A7910C004F1 F3D004EC75F000")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("86D8",&H10,"8027B818F7E0701409 7402D106E583D1")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("86E8",&H10,"06E582D106E7D10609 E7D106E422F5F0")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("86F8",&H10,"C004D1AFD0E0C335F0 B4120050956093")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8708",&H10,"FF8006D1067403D106 7980E754C04FFD")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8718",&H10,"84748025F0F9028741 06DFFA22E49088")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8728",&H10,"EFC001791012008DD0 0153D0E77810E6")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8738",&H10,"518408B8200040F722 ED541F6005B412")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8748",&H10,"0040012209C0E0FF78 8012887D7422F6")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8758",&H10,"D0070F90893CC00112 057AD001ED54C0")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8768",&H10,"D62342D0744D028726 E7D00008E27918")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8778",&H10,"47128D9608E2094722 908792E77374FF")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8788",&H10,"D106E7D10609E7D106 22E58022E58122")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8798",&H10,"E58222E583224E4443 2D3936E59022E5")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("87A8",&H10,"9922E5A022E5E022E5 F0228D80228DA0")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("87B8",&H10,"228DA8228DB0228DB3 228DB8228DBD22")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("87C8",&H10,"8DC6228DC7228DD022 8DE0228DF02254")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("87D8",&H10,"92F587C0BBA82AD146 1C693DEF730E78")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("87E8",&H10,"807910E6F70908DFFA 8003A70109B920")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("87F8",&H10,"FA7F067B007879E411 49740B11497407")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8808",&H10,"11499087D7E57B9354 0FFDE57EC31392")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8818",&H10,"E393D6540F2D540FAC 796204E57C93D6")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8828",&H10,"540FFDE57DC31392E3 93540F6D257A54")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8838",&H10,"0FD64CFD74102BF9A7 050BBB10B7DFB3")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8848",&H10,"222B540F2410F9E754 0FF608E7D6540F")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8858",&H10,"F60822128284121CEE B44F0040030208")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8868",&H10,"91FFF54B7880BF0001 22121CEEF60880")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8878",&H10,"F57F107810E7F60809 DFFA227F107810")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8888",&H10,"8146F608E8540F20D5 02540745F0F8DF")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8898",&H0E,"EF227F107810814670 F708DFF922")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("894E",&H10,"7581E7A23792769084 F8E0F577D27012")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("895E",&H10,"06E41206787421F14B 742045777151E5")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("896E",&H10,"31B42603020D1DB454 02800878BF7600")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("897E",&H10,"08B8CEFAB4381B8532 20200715C20830")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("898E",&H10,"1810B1001211B66004 D20874137F3502")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("899E",&H10,"091AB44403853475B4 4C12B10012107C")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("89AE",&H10,"9084FC1218AEC235C2 080209CEB47F00")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("89BE",&H10,"4003753300303718B4 5C0DB1007410B1")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("89CE",&H10,"00740C7F02020A72B4 5E05B10002096B")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("89DE",&H10,"020796E53130E40F80 28307107C271E4")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("89EE",&H10,"D22B715102068AF1AD F53D916179807F")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("89FE",&H10,"4090832C12057C7980 E4F709B9C0FB02")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8A0E",&H10,"8A55E53320E0179161 300803020967C2")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8A1E",&H10,"0851604004D2088011 E53230E00C1212")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8A2E",&H10,"4DC208E53320E03FD2 09798090832CE5")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8A3E",&H10,"32A2E0920AE4200805 E7200A01E0B100")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8A4E",&H10,"A309B9C0F0D256E526 546CF526C25402")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8A5E",&H10,"0D1D7980908468E047 F709A3B988F890")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8A6E",&H10,"84687980028B8D857F 5B852F5C908514")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8A7E",&H10,"519C7961E7B10009B9 69F980CA79AD77")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8A8E",&H10,"4009B9C0FA90832451 A3153180E4E532")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8A9E",&H10,"20E00CB1797855E493 F6A308B85DF802")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8AAE",&H10,"0F687E06807279807D FFE53130E407B4")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8ABE",&H10,"363CA74E7DFBD29074 255D7151742145")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8ACE",&H10,"77715175B385784CE7 90851C30E60390")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8ADE",&H10,"852C7907714BD9FC79 06714AD9FCE0F5")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8AEE",&H10,"7874255D7151742645 777151D271B196")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8AFE",&H10,"E4F54FF550E5317980 B45E02801CB438")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8B0E",&H10,"028017B43609E54E54 C04424CE800987")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8B1E",&H10,"4EB456067E077C808E 4E7154E53120E3")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8B2E",&H10,"097951E0F7A309B959 F9C270E4F559F5")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8B3E",&H10,"5AF55DF52DF56DF56E C20A2208E25D71")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8B4E",&H10,"51E0A30205F99082EC E54E540FB40800")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8B5E",&H10,"500AD6032582F58250 02058322E531B4")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8B6E",&H10,"42D9AF4BBF00012290 88EE02057A2279")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8B7E",&H10,"80E0F709A3B988F9C3 E5829410F5827F")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8B8E",&H10,"0802057C7A05D29074 175DD22B715112")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8B9E",&H10,"068AB196DAF022E550 70FEF150D29074")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8BAE",&H10,"357151E57871517425 71517422457771")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8BBE",&H10,"51740571517851E671 51D27178CE79BF")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8BCE",&H10,"F1AD47F60908B8D3F7 D254785179CEE4")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8BDE",&H10,"B196B196E7C3966002 C254E60809B856")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8BEE",&H10,"EF305416C0E0716BD0 E0F145B196DFFC")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8BFE",&H10,"305406204703028F70 22C232C25FD253")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8C0E",&H10,"22E532B40BB679A6B7 02B179A377FC09")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8C1E",&H10,"770180A87435B575E8 78807984E7F609")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8C2E",&H10,"08B9B1F9E7F57579AD 774009B9C0FA90")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8C3E",&H10,"831C51A37961D254E5 758002F1AD4760")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8C4E",&H10,"02C25409B969F578AC 79B0E6F71918B9")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8C5E",&H10,"83F922C2087961E4F7 09B96AFB7F4078")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8C6E",&H10,"BFF67961908468E047 F7A309B969F879")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8C7E",&H10,"61873B09E7B53B0280 085006E719F709")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8C8E",&H10,"A73B09B969EB796290 8470E019270947")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8C9E",&H10,"232323F7A309B96AF2 7961F718DFC279")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8CAE",&H10,"8090832CE0C3976002 D208A309B9C0F4")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8CBE",&H10,"22E544B46003028611 201A030215EBB4")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8CCE",&H10,"18067880B6FF0122B4 0B087F0E908452")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8CDE",&H10,"021713B466E6788074 C056F69084F87F")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8CEE",&H10,"0102057A9084687F04 EF93B100DFFA02")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8CFE",&H10,"0A250205F7121BFA30 3B02D231B16678")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8D0E",&H10,"C47951C746F7F60809 B95BF720381090")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8D1E",&H10,"832C795178C4E0F7F6 A30809B95BF730")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8D2E",&H10,"6602D1B5205005E4F5 59F55A7951E7B1")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8D3E",&H10,"00F709B95BF878C479 51E6F70809B959")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8D4E",&H10,"F9E529B100E5275407 B100E545B40501")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8D5E",&H10,"E4D216B100020D1D7A 05C270D22B7413")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8D6E",&H10,"1205F912068AB196DA F2223016088557")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8D7E",&H10,"7F85582FC21622E531 B4360A74011205")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8D8E",&H10,"F9E5201205F9E520F5 71B17930700122")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8D9E",&H10,"D2D3C083C082C0B3F5 72785930680108")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8DAE",&H10,"7B05E57223F5722608 B85B02785146F6")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8DBE",&H10,"08B85B027851DBEA90 8503E531B44402")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8DCE",&H10,"8009854E2020070390 853BE571817008")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8DDE",&H10,"75B3857800E2540825 5D93F573D15D24")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8DEE",&H10,"51F570F8E573F456F5 72E573D1602451")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8DFE",&H10,"F55EF8E655734572C0 E0E52D2451F8D0")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8E0E",&H10,"E066F6F572A870E6C3 13787246F56FF5")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8E1E",&H10,"F0D425F034F6543F70 02056FE56F540F")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8E2E",&H10,"93F573E56FD6540F93 C33573F404A85E")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8E3E",&H10,"26F6257213A87046F6 055D535D0F7401")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8E4E",&H10,"D160F52DD0B3D082D0 83E571C2D32203")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8E5E",&H10,"03035407252DB40A00 4002940A223009")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8E6E",&H10,"03028A8B740C1210A1 E531B436047DFB")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8E7E",&H10,"7192D20A7951E4B196 B196E71210A109")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8E8E",&H10,"B956F4221211B670FA D23590831C7980")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8E9E",&H10,"E047F7A309B988F87F 0812057A9083BC")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8EAE",&H10,"7F04798802057C9084 FC7836E0F608A3")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8EBE",&H10,"B83AF9E53D9011C330 E4039011C37F04")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8ECE",&H10,"7E00EE0454072451F8 EE54032436F9E7")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8EDE",&H10,"26F6EE0454032436F9 E7FDEE2451F9E7")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8EEE",&H10,"C39D543F9346F6E76D 0303543F932326")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8EFE",&H10,"F6E536337C037837E6 33F608DCFAE536")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8F0E",&H10,"33F5360EEEB408BADF B622B40C0C7424")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8F1E",&H10,"1205F9740C307602D2 37B4600302856C")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8F2E",&H10,"B40909E52854801213 487409B4480385")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8F3E",&H10,"4C4FB4575A8061AF31 63076022F55002")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8F4E",&H10,"05F9305103854F4C53 321FC2707DFF02")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8F5E",&H10,"8B92E54E24FE540C02 8660D271E54412")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8F6E",&H10,"1CF1E54C2441403302 15BFE7543FF702")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8F7E",&H10,"8781AF34121CEAB163 B4EF2002885B03")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8F8E",&H10,"F1AD300002F709DC02 800DDDF380E3B4")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8F9E",&H10,"66E7121C961213F275 440022021C9602")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8FAE",&H10,"067E78BF7980E7F608 09B8CEF922E4F5")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8FBE",&H10,"29F527C257020DC7C0 00A831B856048C")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8FCE",&H10,"00F60CD0000205FF90 1203E531B44402")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8FDE",&H10,"800DB456028008E53D 20E4039011C3E5")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8FEE",&H10,"3F932279811CECFA24 FD028679FFFFFF")=0 Then Exit Function
Call RWMsg("Writing Fixbin .img ...",Progress,225)
If WriteViaBootloader("8FFE",&H02,"FFFF")=0 Then Exit Function
WriteFixBin63=1
End Function

Function ReadBin()
' This function reads the bin off the card via the stack unwind, and saves
' it to a file. The read stack must already be on the card. The function
' returns 1 on successful read, 0 on failure.
Dim Progress
Dim i,j,k
Dim EEPROM(4096)
Dim ToWrite

ReadBin=0
For i=&H80 to &H8F
For j=&H00 to &HC0 Step &H40
Call RWMsg("Reading EEPROM ...",Progress,64)
ToWrite="BF" ' Glitch Procedure, read 64 bytes, end procedure
SendGP(ToWrite)
If GPRLen<>&H40 Then Exit Function
For k=&H0 to &H3F
EEPROM((i-&H80)*&H100+j+k)=GPR(k)
Next
Next
Next

i=SaveEEPROMFile(EEPROM)
ReadBin=1
End Function


' =============================
' = Basic Unlooper Procedures =
' =============================

Function CardInserted()
' This function determines whether a card is inserted in the unlooper.
' 1 is returned if Yes, 0 if no.
Dim RetVal
RetVal=Sc.Flush()
Sc.Write("80")
Sc.Read(1)
If Sc.GetByte(0)=&HFF Then
CardInserted=1
Else
CardInserted=0
End If
End Function

Function CheckBootloader()
' This function checks the card to see whether the unlooper bootloader
' is already on the card. 1 is returned if yes, 0 if no. This function
' is for non-BS'd H cards.
Dim ToWrite

ToWrite="1F0120271080" ' Glitch procedure, set baud to Debug, reset card, delay 2710h clock cycles, receive 1 byte, end procedure
SendGP(ToWrite)

CheckBootloader=0
If (GPRLen=1 And GPR(0)=&H52) Then
CheckBootloader=1
End If
End Function

Function CheckGoodCard()
' This function checks to see if the card currently in the unlooper is not looped
' 1 is returned if the card is currently good, 0 if there is something wrong with it
Dim ToWrite
Dim GoodATR(13)
Dim i

GoodATR(0)=&H3F
GoodATR(1)=&H78
GoodATR(2)=&H12
GoodATR(3)=&H25
GoodATR(4)=&H01
GoodATR(5)=&H40
GoodATR(6)=&HB0
GoodATR(7)=&H03
GoodATR(8)=&H4A
GoodATR(9)=&H50
GoodATR(10)=&H20
GoodATR(11)=&H48
GoodATR(12)=&H55

ToWrite="10018C" ' Glitch procedure, set baud to ATR, reset card, receive 13 bytes, end procedure
SendGP(ToWrite)
i=0
Do While (GPRLen>i)
ATR(i)=GPR(i)
i=i+1
Loop

CheckGoodCard=0

' See if the ATR is good
If (GPRLen=13) Then
CheckGoodCard=1
For i=0 to 12
If ATR(i)<>GoodATR(i) Then
CheckGoodCard=0
End If
Next
End If

' If so, see if the card will process a packet
If CheckGoodCard=1 Then
ToWrite="15C448060000000E0283" ' Glitch procedure, transmit packet header, Set watchdog timer to 02, receive 4 bytes, end procedure
SendGP(ToWrite)
If (GPRLen<>4 Or GPR(2)<>&H90 Or GPR(3)<>&H00) Then
CheckGoodCard=0 ' See if we get a response from the packet
End If
End If
End Function

Function CheckGoodCardBS()
' This function checks to see if the card currently in the unlooper is not looped
' 1 is returned if the card is currently good, 0 if there is something wrong with it
Dim ToWrite
Dim GoodATR(13)
Dim i

GoodATR(0)=&H3F
GoodATR(1)=&H78
GoodATR(2)=&H12
GoodATR(3)=&H25
GoodATR(4)=&H01
GoodATR(5)=&H40
GoodATR(6)=&HB0
GoodATR(7)=&H03
GoodATR(8)=&H4A
GoodATR(9)=&H50
GoodATR(10)=&H20
GoodATR(11)=&H48
GoodATR(12)=&H55

ToWrite="10012003D50B8C" ' Glitch procedure, set baud to ATR, reset card, delay 03D5 clock cycles, glitch Vcc, receive 13 bytes, end procedure
SendGP(ToWrite)
i=0
Do While (GPRLen>i)
ATR(i)=GPR(i)
i=i+1
Loop

CheckGoodCardBS=0

' See if the ATR is good
If (GPRLen=13) Then
CheckGoodCardBS=1
For i=0 to 12
If ATR(i)<>GoodATR(i) Then
CheckGoodCardBS=0
End If
Next
End If

' If so, see if the card will process a packet
If CheckGoodCardBS=1 Then
ToWrite="15C448060000000E0283" ' Glitch procedure, set baud to P2 normal xmit/rcv, transmit packet header, set watchdog timer to 02, receive 4 bytes, end procedure
SendGP(ToWrite)
If (GPRLen<>4 Or GPR(2)<>&H90 Or GPR(3)<>&H00) Then
CheckGoodCardBS=0 ' See if we get a response from the packet
End If
End If
End Function

Sub SendGP(GP)
' This subroutine sends a glitch packet to the unlooper and receives the response
' The glitch packet should not have the length byte or the end procedure commands
Dim Length
Dim i

Call Replace(GP," ","")
GP=GP+"00" ' Add end procedure command
Length=Len(GP)\2
GP=HexString(Length,2)+GP ' Add the glitch procedure start/length byte
' Send the glitch packet
Sc.Write(GP)

' Receive the response packet "# bytes processed" byte and "bytes to send" byte
Sc.Read(2)
GPPLen=Sc.GetByte(0) ' Get the processed byte length from unlooper
GPRLen=Sc.GetByte(1) ' Get the number of bytes the unlooper has to send
Sc.Read(GPRLen)
i=0
Do While (GPRLen>i)
GPR(i)=Sc.GetByte(i)
i=i+1
Loop
i=Sc.Flush()
End Sub

Function ReadViaBootloader(Address,Length,Bytes)
' This function reads EEPROM via the bootloader.
' The bytes read are returned in in the Bytes variable if the read was successful
' The empty string is returned otherwise. The function returns 1 on a successful
' read, 0 on failure
Dim TempStr
Dim AddrH, AddrL, RcvLen
Dim i
Dim ToWrite

AddrH=Left(Address,2)
AddrL=Right(Address,2)
RcvLen=HexString(Length+&H80,2)
ToWrite="1F" ' Glitch procedure, set baud to Debug
ToWrite=ToWrite+InsertByteDelay(AddrH+AddrL+HexStr ing(Length,2))
ToWrite=ToWrite+RcvLen ' Receive Length+1 bytes
SendGP(ToWrite)
Bytes=""
ReadViaBootloader=0
If GPRLen>0 Then
If GPR(GPRLen-1)=&H52 Then
For i=0 to GPRLen-2
Bytes=Bytes+HexString(GPR(i),2)
Next
ReadViaBootloader=1
End If
End If
End Function

Function WriteViaBootloader(Address,DeclLength,Bytes)
' This function writes bytes to EEPROM using the bootloader
' It returns 1 on no error, 0 on unsuccessful write
Dim AddrH, AddrL, SendLen, Length
Dim ToWrite

WriteViaBootloader=0
AddrH=Left(Address,2)
AddrL=Right(Address,2)
Call Replace(Bytes," ","")
Length=Len(Bytes)\2
If Length<>DeclLength Then Exit Function ' Make sure actual number of bytes is same as declared
SendLen=HexString(Length+&H80,2)
ToWrite="1F" ' Glitch procedure, set baud rate to Debug
ToWrite=ToWrite+InsertByteDelay(AddrH+AddrL+SendLe n+Bytes)
ToWrite=ToWrite+"0E0A80" ' set watchdog timer to 0Ah, receive 1 byte, end procedure
SendGP(ToWrite)
If GPRLen=1 And GPR(0)=&HFF Then
WriteViaBootloader=1
End If
End Function

Function InsertByteDelay(Bytes)
' This function places 283 cycle clock delays in between each byte of Bytes and returns the
' resulting string. This is used when bytes need to be send to the bootloader
Dim Length,BuildString
Dim i

Call Replace(Bytes," ","")
Length=Len(Bytes)\2
BuildString="C0"+Left(Bytes,2) ' Glitch procedure, transmit 1 byte
For i=1 to Length-1
BuildString=BuildString+"200100C0"+Mid(Bytes,i*2+1 ,2) ' delay 283 clock cycles, transmit 1 byte
Next
InsertByteDelay=BuildString
End Function

Function ExitBootloader()
' This function exits the bootloader and erases it from the card
' It returns 1 when bootloader is successfully erased, 0 if error
Dim ToWrite

ToWrite=InsertByteDelay("0000D2") ' Glitch procedure, transmit 3 bytes with 283 clock cycle delay, end procedure
SendGP(ToWrite)
ToWrite=InsertByteDelay("00FF440D01031220")
SendGP(ToWrite)
ToWrite=InsertByteDelay("0000000000000000000000000 0000000")
SendGP(ToWrite)
ToWrite=InsertByteDelay("0000000000000000000000000 0000000")
SendGP(ToWrite)
ToWrite=InsertByteDelay("0000000000000000000000000 0000000")
SendGP(ToWrite)
ToWrite=InsertByteDelay("0000000000000000000000000 0000000")
SendGP(ToWrite)
ToWrite=InsertByteDelay("32000F04930468485011")
ToWrite=ToWrite+"0E0B8001" ' Glitch procedure, set watchdog timer to 0Bh, receive 1 byte, end procedure
SendGP(ToWrite)
If GPRLen=1 and GPR(0)=&H55 Then
ExitBootloader=1
Else
ExitBootloader=0
End If
End Function


' ===================================
' = Unlooper Base Glitch Procedures =
' ===================================

Function GlitchTask1(g)
' This function applies the first glitch to the card:
' Glitch Task 1 - Glitch past Black Sunday 8000h/33h check
'
' The function returns 1 if the glitch was successful, 0 if it failed.
' The current glitch values are always used - it is the responsibility
' of the caller to keep track of tries and change the glitch values
' The routine only tries the glitch once.
' The routine will try any set of glitch parameters in the array, as
' called with the g variable

Dim ToWrite
Dim i

ToWrite="B0"+HexString(DAC(g),2) ' Set glitch voltage (DAC)
Sc.Write(ToWrite)

Select Case GlitchProc(g)
Case 1:
ToWrite="10012003D5" ' Glitch procedure, set baud to ATR, reset card, delay 03D5h clock cycles
ToWrite=ToWrite+"0B" ' Glitch Vcc
ToWrite=ToWrite+"20"+HexString(Delay(g),4) ' Delay XXXX clock cycles
ToWrite=ToWrite+"0D"+HexString(GlitchDelay(g),2) ' Overrev clock, delay XX clock cycles, glitch Vcc
ToWrite=ToWrite+"0D"+HexString(GlitchDelay(g),2) ' Overrev clock, delay XX clock cycles, glitch Vcc
ToWrite=ToWrite+"80" ' Read 1 byte from unlooper, end procedure
Case 2:
ToWrite="10012003D5" ' Glitch procedure, set baud to ATR, reset card, delay 03D5h clock cycles
ToWrite=ToWrite+"0B" ' Glitch Vcc
ToWrite=ToWrite+"20"+HexString(Delay(g),4) ' Delay XXXX clock cycles
ToWrite=ToWrite+"0C"+HexString(GlitchDelay(g),2) ' Glitch Vcc, delay XX clock cycles, glitch Vcc
ToWrite=ToWrite+"0C"+HexString(GlitchDelay(g),2) ' Glitch Vcc, delay XX clock cycles, glitch Vcc
ToWrite=ToWrite+"80" ' Read 1 byte from unlooper, end procedure
Case 3:
ToWrite="1001" ' Glitch procedure, set baud to ATR, reset card
ToWrite=ToWrite+"20"+HexString(Delay(g),4) ' Delay XXXX clock cycles
ToWrite=ToWrite+"0D"+HexString(GlitchDelay(g),2) ' Overrev clock, delay XX clock cycles, glitch Vcc
ToWrite=ToWrite+"80" ' Read 1 byte from unlooper, end procedure
End Select

SendGP(ToWrite)

i=0
Do While (GPRLen>i)
ATR(i)=GPR(i)
i=i+1
Loop

GlitchTask1=0
If (GPRLen>0 And ATR(0)=&H3F) Then
GlitchTask1=1
End If
End Function

Function GlitchTask2(g)
' This function applies the second glitch to the card:
' Glitch Task 2 - Get next 10 bytes of ATR
'
' The function returns 1 if the glitch was successful, 0 if it failed.
' The current glitch values are always used - it is the responsibility
' of the caller to keep track of tries and change the glitch values
' The routine only tries the glitch once

Dim i

SendGP("89") ' Glitch procedure, receive 10 bytes, end procedure
For i=1 to 10
ATR(i)=GPR(i-1)
Next
GlitchTask2=1
End Function

Function GlitchTask3(g)
' This function applies the third glitch to the card:
' Glitch Task 3 - Glitch for last 2 bytes of ATR and packet response
'
' The function returns 1 if the glitch was successful, 0 if it failed.
' The current glitch values are always used - it is the responsibility
' of the caller to keep track of tries and change the glitch values
' The routine only tries the glitch once
' The routine will try any set of glitch parameters in the array, as
' called with the g variable

Dim ToWrite
Dim i

ToWrite="B0"+HexString(DAC(g),2)
Sc.Write(ToWrite) ' Set DAC voltage

Select Case GlitchProc(g)
Case 1:
ToWrite="040720"+HexString(Delay(g),4) ' Glitch procedure, pull I/O high, wait I/O low, delay XXXX clock cycles
ToWrite=ToWrite+"0D"+HexString(GlitchDelay(g),2) ' Overrev clock, delay XX clock cycles, glitch Vcc
ToWrite=ToWrite+"03202710" ' Pull I/O low, Delay 2710h clock cycles
ToWrite=ToWrite+"81" ' Read 2 bytes from unlooper, end procedure
End Select

SendGP(ToWrite)

i=0
Do While (GPRLen>i)
ATR(i+11)=GPR(i)
i=i+1
Loop

If Search(3)=1 Then
GlitchTask3=0
ToWrite="C4480600000083" ' Glitch procedure, transmit packet header, receive 4 bytes, end procedure
SendGP(ToWrite)
If (GPRLen=4 And GPR(2)=&H90 And GPR(3)=&H00) Then
GlitchTask3=1 ' See if we get a response from the packet
End If
Else
GlitchTask3=1
End If
End Function

Function GlitchTask4(g)
' This function applies the fourth glitch to the card:
' Glitch Task 4 - Glitch to try to fill memory with stack and bootloader for writing
'
' The function returns 1 if the glitch was successful, 0 if it failed.
' The current glitch values are always used - it is the responsibility
' of the caller to keep track of tries and change the glitch values
' The routine only tries the glitch once
' The routine will try any set of glitch parameters in the array, as
' called with the g variable

Dim ToWrite
Dim i

ToWrite="B0"+HexString(DAC(g),2) ' Set DAC Voltage
Sc.Write(ToWrite)

Select Case GlitchProc(g)
Case 1:
ToWrite="C348060000" ' Glitch procedure, transmit 4 byte header
ToWrite=ToWrite+"20"+HexString(Delay(g),4) ' Delay XXXX Cycles
ToWrite=ToWrite+"C0D2" ' Transmit 1 byte
ToWrite=ToWrite+"20"+HexString(GlitchDelay(g),4) ' Delay XXXX Cycles
ToWrite=ToWrite+"0B" ' Glitch Vcc, end procedure
End Select

SendGP(ToWrite)

ToWrite="FF" ' Glitch procedure, attempt to fill memory with 64 bytes
ToWrite=ToWrite+"030000000000000000000000000000000 00000000000000000000000000000000000000000000000000 0802802FD000000000000000000000000000000000000"
SendGP(ToWrite)

GlitchTask4=0
If (GPPLen=&H42) Then
' Try to write remainder of bootloader
ToWrite="FF" ' Glitch procedure, attempt to fill memory with 64 bytes
ToWrite=ToWrite+"000000000000000000000000000000000 00000000000000000000074081205FF1203F2745212040F795 F7A03116112116A10E706FB12014F80E9FAFF79681161"
SendGP(ToWrite)

ToWrite="FF" ' Glitch procedure, attempt to fill memory with 64 bytes
ToWrite=ToWrite+"E5836009796812057C35E080D89080208 98122091201C8DAFA2200000000003200F7056105610250119 604904050116A11F70593043600360036003600360036"
SendGP(ToWrite)

ToWrite="CA" ' Glitch procedure, attempt to fill memory with 11 bytes
ToWrite=ToWrite+"0036003600360036003600"
SendGP(ToWrite)

ToWrite="C6" ' Glitch procedure, final wrap-around to unwind the stack
ToWrite=ToWrite+"1F802000FF0301"
SendGP(ToWrite)

' See if the stack got unwound
ToWrite="80" ' Glitch procedure, receive 1 byte, end procedure
SendGP(ToWrite)

If GPRLen=1 And GPR(0)=&H55 Then ' Bootloader stack got unwound
ToWrite="0E0B80" ' Glitch procedure, set watchdog timer to 11, receive 1 byte, end procedure
SendGP(ToWrite)
If GPRLen=1 and GPR(0)=&H77 Then
GlitchTask4=1 ' Bootloader is on the card!
End If
End If
End If
End Function

Function GlitchTask4B(g)
' This function applies the first glitch to the card:
' Glitch Task 4 - Glitch to try to fill memory with stack for reading
'
' The function returns 1 if the glitch was successful, 0 if it failed.
' The current glitch values are always used - it is the responsibility
' of the caller to keep track of tries and change the glitch values
' The routine only tries the glitch once
' The routine will try any set of glitch parameters in the array, as
' called with the g variable

Dim ToWrite
Dim i

ToWrite="B0"+HexString(DAC(g),2) ' Set DAC Voltage
Sc.Write(ToWrite)

Select Case GlitchProc(g)
Case 1:
ToWrite="C348060000" ' Glitch procedure, transmit 4 byte header
ToWrite=ToWrite+"20"+HexString(Delay(g),4) ' Delay XXXX Cycles
ToWrite=ToWrite+"C0D2" ' Transmit 1 byte
ToWrite=ToWrite+"20"+HexString(GlitchDelay(g),4) ' Delay XXXX Cycles
ToWrite=ToWrite+"0B" ' Glitch Vcc, end procedure
End Select

SendGP(ToWrite)

ToWrite="FF" ' Glitch procedure, attempt to fill memory with 64 bytes
ToWrite=ToWrite+"030000000000000000000000000000000 00000000000000000000000000000000000000000000000000 080000000000000000000000000000000000000000000"
SendGP(ToWrite)

GlitchTask4B=0
If (GPPLen=&H42) Then
' Try to write remainder of stack
ToWrite="FF" ' Glitch procedure, attempt to fill memory with 64 bytes
ToWrite=ToWrite+"000000000000000000000000000000000 00000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000003200F7"
SendGP(ToWrite)

ToWrite="FF" ' Glitch procedure, attempt to fill memory with 64 bytes
ToWrite=ToWrite+"059304F70561058A078A078A078A078A0 78A078A078A078A078A078A078A078A078A078A078A0700005 5066A11F7056105F70593043600360036003600360036"
SendGP(ToWrite)

ToWrite="CA" ' Glitch procedure, attempt to fill memory with 11 bytes
ToWrite=ToWrite+"0036003600360036003600"
SendGP(ToWrite)

ToWrite="C6" ' Glitch procedure, final wrap-around to unwind the stack
ToWrite=ToWrite+"1F000000FF0301"
SendGP(ToWrite)

' See if the stack got unwound
ToWrite="80" ' Glitch procedure, receive 1 byte, end procedure
SendGP(ToWrite)

If GPRLen=1 And GPR(0)=&H55 Then ' Stack got unwound
ToWrite="0E0B80" ' Glitch procedure, set watchdog timer to 11, receive 1 byte, end procedure
SendGP(ToWrite)
If GPRLen=1 and GPR(0)=&H77 Then
GlitchTask4B=1 ' Ready to read the card!
End If
End If
End If
End Function

Function GlitchTask5(g)
' This function attempts to glitch into the unlooper bootloader that is
' supposed to be on the card. 1 is returned if successful, 0 if not.
'
' The routine will try any set of glitch parameters in the array, as
' called with the g variable

Dim ToWrite
Dim i

' Glitch procedure 5 - Glitch past Black Sunday 8000h/33h check and into bootloader
ToWrite="B0"+HexString(DAC(g),2) ' Set glitch voltage (DAC)
Sc.Write(ToWrite)

Select Case GlitchProc(g)
Case 1:
ToWrite="1F012003D5" ' Glitch procedure, set baud to Debug, reset card, delay 03D5h clock cycles
ToWrite=ToWrite+"0B" ' Glitch Vcc
ToWrite=ToWrite+"20"+HexString(Delay(g),4) ' Delay XXXX clock cycles
ToWrite=ToWrite+"0D"+HexString(GlitchDelay(g),2) ' Overrev clock, delay XX clock cycles, glitch Vcc
ToWrite=ToWrite+"0D"+HexString(GlitchDelay(g),2) ' Overrev clock, delay XX clock cycles, glitch Vcc
ToWrite=ToWrite+"80" ' Read 1 byte from unlooper, end procedure
Case 2:
ToWrite="1F012003D5" ' Glitch procedure, set baud to Debug, reset card, delay 03D5h clock cycles
ToWrite=ToWrite+"0B" ' Glitch Vcc
ToWrite=ToWrite+"20"+HexString(Delay(g),4) ' Delay XXXX clock cycles
ToWrite=ToWrite+"0C"+HexString(GlitchDelay(g),2) ' Glitch Vcc, delay XX clock cycles, glitch Vcc
ToWrite=ToWrite+"0C"+HexString(GlitchDelay(g),2) ' Glitch Vcc, delay XX clock cycles, glitch Vcc
ToWrite=ToWrite+"80" ' Read 1 byte from unlooper, end procedure
End Select
SendGP(ToWrite)

GlitchTask5=0
If (GPRLen>0 And GPR(0)=&H52) Then
GlitchTask5=1 ' See if the bootloader is on the card
End If
End Function


' ============================
' = File-Handling Procedures =
' ============================

Function SaveEEPROMFile(EEPROM)
Dim GotInput
Dim OutFile
Dim FileSize
Dim i
Dim FileName
Dim Fuse,FuseXor
Dim CAMID
Const FileFilter="Bin Files (*.bin)|*.bin|All Files (*.*)|*.*"
FileName=""
GotInput=False
SaveEEPROMFile=False
For i=&H374 to &H377
CAMID=CAMID+HexString(EEPROM(i),2)
Next
CAMID=CAMID+".bin"
Do
FileName=Fs.FileSaveDialog(FileFilter,ScriptName+" "+ScriptVer+" - Save Bin File",CAMID)
If (FileName<>"") Then ' If the filename returned is empty, the user clicked cancel.
OutFile=Fs.FileCreate(FileName) ' Create the new file
Call Fs.FileSeek(OutFile,&H0,fsoSEEK_SET)
For i=0 to 4095
Call Fs.FilePutc(OutFile,EEPROM(i))
Next
GotInput=True
SaveEEPROMFile=True
Fs.FileClose(OutFile)
Else
GotInput=True
End If
Loop Until GotInput=True
End Function


' ========================
' = Low-Level Procedures =
' ========================

Sub SetGlitchValues()
Dim i

' Glitch Task 1 Parameter Set A
DAC(1)=&H0
DACL(1)=&H70
DACI(1)=&H82
DACH(1)=&H90
Delay(1)=&H0
DelayL(1)=&H2157
DelayI(1)=&H2158
DelayH(1)=&H2159
GlitchDelay(1)=&H0
GlitchDelayL(1)=&H10
GlitchDelayI(1)=&H20
GlitchDelayH(1)=&H40
Tries(1)=0
TotalTries(1)=0
TriesLimit(1)=0
TriesLimitN(1)=3
TriesLimitI(1)=50
GlitchProc(1)=3
AltProc(1)=5
AltProcTriesLimit(1)=500
FailsLimit(1)=35
GlitchLogic(1)=1
Search(1)=1

' Glitch Task 2 Parameter Set A
' This is an unused set of glitch parameters. Unused glitch parameters should
' be set as follows for proper glitch display.
DAC(2)=&H1
DACL(2)=&H1
DACI(2)=&H1
DACH(2)=&H1
Delay(2)=&H0
DelayL(2)=&H0
DelayI(2)=&H0
DelayH(2)=&H0
GlitchDelay(2)=&H0
GlitchDelayL(2)=&H0
GlitchDelayI(2)=&H0
GlitchDelayH(2)=&H0
Tries(2)=0
TotalTries(2)=0
TriesLimit(2)=0
TriesLimitN(2)=1
TriesLimitI(2)=1
GlitchProc(2)=1
AltProc(2)=0
AltProcTriesLimit(2)=500
FailsLimit(2)=1
GlitchLogic(2)=0
Search(2)=0

' Glitch Task 3 Parameter Set A
DAC(3)=&H0
DACL(3)=&H70
DACI(3)=&H82
DACH(3)=&H90
Delay(3)=&H0
DelayL(3)=&H600
DelayI(3)=&H604
DelayH(3)=&H618
GlitchDelay(3)=&H0
GlitchDelayL(3)=&H30
GlitchDelayI(3)=&H38
GlitchDelayH(3)=&H40
Tries(3)=0
TotalTries(3)=0
TriesLimit(3)=0
TriesLimitN(3)=2
TriesLimitI(3)=10
GlitchProc(3)=1
AltProc(3)=0
AltProcTriesLimit(3)=500
FailsLimit(3)=25
GlitchLogic(3)=1
Search(3)=1

' Glitch Task 4 Parameter Set A
DAC(4)=&H0
DACL(4)=&H80
DACI(4)=&H82
DACH(4)=&HA0
Delay(4)=&H0
DelayL(4)=&H4550
DelayI(4)=&H4E20
DelayH(4)=&H5000
GlitchDelay(4)=&H0
GlitchDelayL(4)=&H128
GlitchDelayI(4)=&H138
GlitchDelayH(4)=&H150
Tries(4)=0
TotalTries(4)=0
TriesLimit(4)=0
TriesLimitN(4)=1
TriesLimitI(4)=40
GlitchProc(4)=1
AltProc(4)=0
AltProcTriesLimit(4)=500
FailsLimit(4)=10
GlitchLogic(4)=1
Search(4)=1

' Glitch Task 1 Parameter Set B
DAC(5)=&H0
DACL(5)=&H70
DACI(5)=&H82
DACH(5)=&H90
Delay(5)=&H0
DelayL(5)=&H1D00
DelayI(5)=&H1D2B
DelayH(5)=&H1D40
GlitchDelay(5)=&H0
GlitchDelayL(5)=&H08
GlitchDelayI(5)=&H0C
GlitchDelayH(5)=&H10
Tries(5)=0
TotalTries(5)=0
TriesLimit(5)=0
TriesLimitN(5)=3
TriesLimitI(5)=100
GlitchProc(5)=1
AltProc(5)=6
AltProcTriesLimit(5)=2000
FailsLimit(5)=100
GlitchLogic(5)=1
Search(5)=1

' Glitch Task 1 Parameter Set C
DAC(6)=&H0
DACL(6)=&H70
DACI(6)=&H82
DACH(6)=&H90
Delay(6)=&H0
DelayL(6)=&H1D29
DelayI(6)=&H1D2B
DelayH(6)=&H1D2D
GlitchDelay(6)=&H0
GlitchDelayL(6)=&H0A
GlitchDelayI(6)=&H0C
GlitchDelayH(6)=&H0E
Tries(6)=0
TotalTries(6)=0
TriesLimit(6)=0
TriesLimitN(6)=3
TriesLimitI(6)=100
GlitchProc(6)=1
AltProc(6)=7
AltProcTriesLimit(6)=1000
FailsLimit(6)=100
GlitchLogic(6)=1
Search(6)=1

' Glitch Task 1 Parameter Set D
DAC(7)=&H0
DACL(7)=&H70
DACI(7)=&H82
DACH(7)=&H90
Delay(7)=&H0
DelayL(7)=&H1D29
DelayI(7)=&H1D2B
DelayH(7)=&H1D2D
GlitchDelay(7)=&H0
GlitchDelayL(7)=&H0D
GlitchDelayI(7)=&H0F
GlitchDelayH(7)=&H11
Tries(7)=0
TotalTries(7)=0
TriesLimit(7)=0
TriesLimitN(7)=3
TriesLimitI(7)=100
GlitchProc(7)=2
AltProc(7)=8
AltProcTriesLimit(7)=1000
FailsLimit(7)=100
GlitchLogic(7)=1
Search(7)=1

' Glitch Task 1 Parameter Set D
DAC(8)=&H0
DACL(8)=&H70
DACI(8)=&H82
DACH(8)=&H90
Delay(8)=&H0
DelayL(8)=&H1D19
DelayI(8)=&H1D1B
DelayH(8)=&H1D1D
GlitchDelay(8)=&H0
GlitchDelayL(8)=&H0A
GlitchDelayI(8)=&H0D
GlitchDelayH(8)=&H11
Tries(8)=0
TotalTries(8)=0
TriesLimit(8)=0
TriesLimitN(8)=3
TriesLimitI(8)=50
GlitchProc(8)=1
AltProc(8)=1
AltProcTriesLimit(8)=1000
FailsLimit(8)=100
GlitchLogic(8)=1
Search(8)=1

TaskSet(1)=1
TaskSet(2)=2
TaskSet(3)=3
TaskSet(4)=4
TaskSet(5)=5

Randomize

For i=0 To 12
ATR(i)=0
Next
End Sub

Function ParmInc(Parm,Low,High,Inc)
' This function increments the parameter Parm by one, resetting it to low if it goes beyond high
' The value of Inc specifies whether the function should do the increment or not: 1=Do the increment, 0=Don't
' This way the function can be nested
' The function returns 0 if ParmInc didn't wrap, 1 if it did
If Inc=1 Then
Parm=Parm+1
ParmInc=0
If Parm>High Then
Parm=Low
ParmInc=1
End If
End If
End Function

Function RandomRange(Low,High)
' This function returns a random integer between Low and High
RandomRange=Int(Rnd()*(High-Low+1))+Low
End Function

Sub SetupWinExplorer()
If Sc.Version<4.5 Then
ErrorString="You need version 4.5 or greater of WinExplorer to run this script"
Call Sc.MsgBox(ErrorString,vbCritical,ScriptName+" "+ScriptVer+" - Error")
Call Err.Raise(1050,,ErrorString)
End If

' Unlooper doesn't need byte delay
Sc.ByteDelay = 0
End Sub

Function HexString(Number,Length)
' This function takes 2 arguments, a number and a length. It converts the decimal
' number given by the first argument to a Hexidecimal string with its length
' equal to the number of digits given by the second argument
Dim RetVal
Dim CurLen
RetVal=Hex(Number)
CurLen=Len(RetVal)
If CurLen<Length Then
RetVal=String(Length-CurLen,"0") & RetVal
End If
HexString=RetVal
End Function

Function HexToDec(HexNumber)
' This function takes a string as input, assuming it to be a Hexidecimal string,
' and converts it to a decimal number.
HexNumber=Replace(UCase(HexNumber)," ","")
HexToDec=CLng("&H"+HexNumber)
End Function

[novato1223]

otro qu esupuestamente lee la tarjeta


Vb Script creato il 25/06 /2005 da studio-nds2
' Questo commento è necessario perchè winexplorer riconosce il vb sript
'




Call DxSetting()'con questo impostiamo i setting

Sub Main()
Dim i



sc.Verbose = False
Sc.write("D0 58 00 00 4C")
Sc.read(76 + 3)
Seriale = HexString(Sc.Getbyte(4),2) & " " & HexString(Sc.Getbyte(5),2)& " " & HexString(Sc.Getbyte(6),2) & " " & HexString(Sc.Getbyte(7),2)
Fus = HexString(Sc.Getbyte(3),2)
Share = HexString(Sc.Getbyte(35),2) & " " & HexString(Sc.Getbyte(36),2)& " " & HexString(Sc.Getbyte(37),2)

Select Case Fus
Case 25
Fuse = "25 Active"
Case 00
Fuse = "00 Virgin"
End Select
Print
Print "Seriale hex " & Seriale
Print
Print "Seriale Decimale " & "0001." & Left(HexToDec(Seriale),4) & "." & Right(HexToDec(Seriale),4)
Print
Print "Shared " & Share
Print
Print "Fuse Byte " & Fuse
Print
for i = HexToDec("00") to HexToDec("08") 'inserire tra virgolette il valore in hex

Comando = "D0 76 " & HexString(i,2) & " 00 0A"

sc.write(Comando)
Sc.read(11 + 2 )

Tiers = HexString(Sc.Getbyte(3),2) & HexString(Sc.Getbyte(4),2)

Mese = Sc.Getbyte(5)
Giorno = Sc.Getbyte(6)

Temp = DateAdd("m", Mese, #31/12/1996#)'utilizzando la funzione DateAdd è necessario mettere 31/12/1996
DataNds = DateAdd("d", Giorno , Temp) 'per avere la data corretta
Print
Print "Tiers " & Tiers & " Scadenza " & DataNds
next


End Sub


'===============================================

Function HexString(ThisNumber, Length)
Dim RetVal
Dim CurLen

RetVal = Hex(ThisNumber)
CurLen = Len(RetVal)

If CurLen < Length Then
RetVal = String(Length - CurLen, "0") & RetVal
End If

HexString = RetVal
End Function


'================================================
Function HexToDec(NumHex) ' converte un numero hex in decimale
NumHex=Replace(UCase(NumHex)," ","")
HexToDec=CLng("&H" & NumHex)
End Function

'================================================
Sub DxSetting()
Device=com1:
BaudRate=38400
ResetBaudRate=9600
ResetDelay=40000
ByteDelay=40000
RxByteTimeout=1000
Parity=1
StopBits=2
FlushBeforeWrite=1
FlushEchoByte=1
DTRControl=1
RTSControl=0
ResetMode=1
IgnoreTimeouts=0
ResetAfterTimeout=0
ResetLine=0
LogTransactions=0
DisplayUSW=1
DisplayFuse=1
ByteConvention=0
End Sub

[RuLz]

buenas, acabo de enterarme de sto de ahuna digital, llevo 20 minutos leyendo el hilo este, decirme si la conclusion q e sacao es la correcta:
ya se venden los decos digitales "trucados" y funcionando, pero kien los vende no suelta prenda y stais intentando en ste hilo el metodo pa hacerlos rular... es eso?

[presario2500]

alguna forma de resetear el deco o card para no tener que tenerlo conectado al telefono (pues no tengo telefono fijo)he leido por ahi que abriendo el de deco al lado del procesador hay un pulsador yo no lo puedo probar hasta mañana pues no estoy en casa ,alguien sabe algo,mañana lo abriré y lo miraré ,postearé resultados.y todo esto por que segun he leido la card tiene un limite de carga de eventos comprados y si se carga a tope se blokea salu2

[presario2500]

asi es rulz ,aunque la cosa esta muy escondida ,pero vamos sacando nuestras refexiones y dudas

[Noish]

otro qu esupuestamente lee la tarjeta


' Vb Script creato il 25/06 /2005 da studio-nds2
' Questo commento è necessario perchè winexplorer riconosce il vb sript
'




Call DxSetting()'con questo impostiamo i setting

Sub Main()
Dim i



sc.Verbose = False
Sc.write("D0 58 00 00 4C")
Sc.read(76 + 1) <------ He kitado el 3 y he puesto un 1 para ke lea 77 bytes en vez de 79.
Seriale = HexString(Sc.Getbyte(4),2) & " " & HexString(Sc.Getbyte(5),2)& " " & HexString(Sc.Getbyte(6),2) & " " & HexString(Sc.Getbyte(7),2)
Fus = HexString(Sc.Getbyte(3),2)
Share = HexString(Sc.Getbyte(35),2) & " " & HexString(Sc.Getbyte(36),2)& " " & HexString(Sc.Getbyte(37),2)

Select Case Fus
Case 25
Fuse = "25 Active"
Case 00
Fuse = "00 Virgin"
End Select
Print
Print "Seriale hex " & Seriale
Print
Print "Seriale Decimale " & "0001." & Left(HexToDec(Seriale),4) & "." & Right(HexToDec(Seriale),4)
Print
Print "Shared " & Share
Print
Print "Fuse Byte " & Fuse
Print
for i = HexToDec("00") to HexToDec("08") 'inserire tra virgolette il valore in hex

Comando = "D0 76 " & HexString(i,2) & " 00 0A"

sc.write(Comando)
Sc.read(11 + 2 )

Tiers = HexString(Sc.Getbyte(3),2) & HexString(Sc.Getbyte(4),2)

Mese = Sc.Getbyte(5)
Giorno = Sc.Getbyte(6)

Temp = DateAdd("m", Mese, #31/12/1996#)'utilizzando la funzione DateAdd è necessario mettere 31/12/1996
DataNds = DateAdd("d", Giorno , Temp) 'per avere la data corretta
Print
Print "Tiers " & Tiers & " Scadenza " & DataNds
next


End Sub


'===============================================

Function HexString(ThisNumber, Length)
Dim RetVal
Dim CurLen

RetVal = Hex(ThisNumber)
CurLen = Len(RetVal)

If CurLen < Length Then
RetVal = String(Length - CurLen, "0") & RetVal
End If

HexString = RetVal
End Function


'================================================
Function HexToDec(NumHex) ' converte un numero hex in decimale
NumHex=Replace(UCase(NumHex)," ","")
HexToDec=CLng("&H" & NumHex)
End Function

'================================================
Sub DxSetting()
Device=com1:
BaudRate=38400
ResetBaudRate=9600
ResetDelay=40000
ByteDelay=40000
RxByteTimeout=1000
Parity=1
StopBits=2
FlushBeforeWrite=1
FlushEchoByte=1
DTRControl=1
RTSControl=0
ResetMode=1
IgnoreTimeouts=0
ResetAfterTimeout=0
ResetLine=0
LogTransactions=0
DisplayUSW=1
DisplayFuse=1
ByteConvention=0
End Sub

Acabo de probar el script y no hace gran cosa:

Trying to reset card...
Reset Successful

RX ATR : 3F 7F 13 25 02 40 B0 12 69 FF 4A 50 90 41 55 00 00 00 00 00

Seriale hex 00 08 18 EE
Seriale Decimale 0001.5306.0670
Shared 00 08 18
Fuse Byte

Tiers 0000 Scadenza 31/12/1996
Tiers 0000 Scadenza 31/12/1996
Tiers 0000 Scadenza 31/12/1996
Tiers 0000 Scadenza 31/12/1996
Tiers 0000 Scadenza 31/12/1996
Tiers 0000 Scadenza 31/12/1996
Tiers 0000 Scadenza 31/12/1996
Tiers 0000 Scadenza 31/12/1996
Tiers 0000 Scadenza 31/12/1996

Script Script File: Transmission Completed
The Update Status Word is at 0 (Hex)

The Fuse Byte is at 4 (Hex)


novato1223 te pongo en rojo lo ke he añadido o modificado para ke funcionara el script.