;file coclide.asm ;Note legali: ; ; *************************************************************************** ; * Copyright (C) 2006 by vitogambi * ; * vitogambi@gmail.com * ; * * ; * This program is free software; you can redistribute it and/or modify * ; * it under the terms of the GNU General Public License as published by * ; * the Free Software Foundation; either version 2 of the License, or * ; * (at your option) any later version. * ; * * ; * This program is distributed in the hope that it will be useful, * ; * but WITHOUT ANY WARRANTY; without even the implied warranty of * ; * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * ; * GNU General Public License for more details. * ; * * ; * This program is free for individuals, * ; * You should have received a copy of the GNU General Public License * ; * along with this program; if not, write to the * ; * Free Software Foundation, Inc., * ; * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ; *************************************************************************** ;compilare da shell usando i comandi: ; ;[xx@localhost coclide]$ nasm -f elf coclide-K10.0.asm ;[xx@localhost coclide]$ ld -o coclide coclide-K10.0.o ; ;mandare in esecuzione col comando: ; ;[xx@localhost coclide]$ ./coclide ZMZS -n nick ; ; ; ;datacoclide.asm ;contiene i dati del programma coclide, oltre ad alcuni dati predefiniti utili per ;eventuali sessioni di debug o di verifiche. ;integrati vi sono tutti i dati necessari per una sessione debug come debug.exe del dos. ; section .data ;qui abbiamo le Kiavi predefinite (standard); si raccomanda di non modificarle; cambiarle ;da comando durante la fase di esecuzione. Si avra' lo stesso livello di sicurezza ma ;lasciando queste kiavi standard invariate sara' possibile dialogare in modalita' CODEC con ;altri coclide; in caso di modifica anche di una sola di queste chiavi il programma sara' ;inutilizzabile. ;Si rammenta che la modifica delle chiavi da programma si ottiene facilmente col comando: ; /CODE[C] Kxxxxxxxxxxxx per esempio, volendo cammbiare la Kiave8 lasciando invariate le altre ; si dara' il comando: ; /CODE[C] Kiiiiiiin nuova chiave_otto da usare integralmente ; Inoltre cambiando il PIN code o la sequenza delle keys si hanno 1.000.000 X !13 ovvero oltre sei ; milioni di miliardi di combinazioni diverse con le sole chiavi di default. ; allinea_k1 times 1000 db 0 ;K1s db "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" ;K1s db "cococococococococococococococococococococo" ;K1s db "abcdefghijklmnopqrstuvwxyz" K1s db "colli\n@1et4tasCa bcdefg3hij k�lmno �pqrstuv2wxyzo1Li Natac4a# laAbanzlamucola n�9ampkldgsh yef cgszysup erca,li&fragil iol56esZxtichke spi WraliQdo,so3a*afdghs mbdi+�mbarabQa h&2gi:gW ig8o_gotrxe^sEim miett epat!5X6dKOs75alosco Lt us[asdp}cho8ylanae inoltre u;n po di74 caZl!abrano che non fXa mainala scupaVuyMlaGara!BolTa sBcaNzu�nata capiNlLi|era scaz>unuta- p�iu o- vir?gola 5,lana.punto" lK1s dd $ - K1s ;K2s times 1000 db 0 ;K2s dd 0,0,0,0,0,0,0,0 ;K2s db 1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0 ;K2s db "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" K2s db "KLMJUHIYTREpUMBORECQOLRH-RZH",245,"ZAFDLNEDMF",157,"MCOZPIZUEZH^'?0=9)8(7/7&5%4$3�",179,"2!216\|s�-_-������++*��lL.:,;�0��sp",219,"erandosperanzoso.,clko985774",197,163,"66645535542443312!|!6//654(9==)'^?*�����#��� ciaulonio.-.,nl�l�+�+�^-��g�",123,"�jlh,mvbchfgdtxcdgsdkaslokesbxhd254005'=��d�� ��spkekitgdtf,.lkd",28,"hsyjd",193,"ukfoll�clsc",138,"bnfhjdkkfl",232,115,"skokijehd&",20,"677&544��22�9?0'/8&&�*������@#+��skkhhakjkkainccm" lK2s dd $ - K2s ;80 chars ;K3s db 1,2,3,4,5,6 ;"12345678" ;K3s db "aaaaaaaaaaaaaaaaaaaa" K3s db "nel mezzo del cammin di nostra vita mi ritrovai per una selva oscura chela diritta via era smarrita e c'era una zorba nera nfransciunata MENTRE LA DONZELLETTA VIENDALLACAMPAGNAIN sul calar del sole e reca in mano un mazzolin di rose e di viole,. Onde siccome suole Silvia rimembri ancora ecc ecc. solo la gente malvagia sente la necessita' dell'esistenza di un Dio che lo assolva e lo perdoni dei suoi misfatti, e sara' vero che i nani sono carogne di sicuro perche' hanno il cuore troppo vicino al buco del culo?" lK3s dd $ - K3s ;K4s db 0,1,0,0,0,0,0,0 K4s db 01010101b, 00100100b, 00010001b, 00001000b, 10000010b, "ABRACADABRAAPRITISESAMOHCHAFTVBLABLA e ora raccontiamo la bella storia di come e' nata l'idea di questa K4 che opera nel seguente modo: I bit delle chiavi sono i bit che compongono questo messaggio, per esempio al lettera B che ha codice binario 01000010 entra in gioco nel seguente modo: immaginiamo di voler criptare la parola seguente -> CORNELIO ebbene come si vede in corrispondenza degli 1 ci sono le lettere O e I mentre alle altre lettere corrispondono gli zeri di conseguenza la O e la I subiranno uno swap delle coppie dei bit 12 34 56 78 mentre le altre lettere subiranno un rotazione di un bit che quindi portera' i bit dalla sequenza originaria 87654321 alla nuova sequenza 18765432. capito il meccanismo? naturalmente tutto questo ripetuto sull'intera lunghezza del messaggio e per tutta la lunghezza della chiave, a partire dal pointer casuale generato dal numero random ecc. ecc. leggetevi l'help per maggiori dettagli." lK4s dd $ - K4s ;34 K5s db "NON TI CURAR DI LOR MA GUARDA E PASSA e MMUCCT STAH ZORBAnzrbugliata OkkkjsHgtFrddTTCCVah bbdh NNCKML SLP��D��SP E RTTIJGNMVFDLSKAL" db 87,30,33,49,67,17,22,13,12,15,91,9,8,142,17,22,13,12,18,27,33,12,15,91 db " e come se non bastasse ecco ancora altri caratteri per la chiave5 1234567890, abcdefghijklmnopqrstuvz ancora ALTRI CODICI" db 44,4,41,23,19,1,7,15,13,79,121,223,119,217,115,254,2,5,13,17,49,212,223,250,243,149,198,197,190,91,0,12,1,23,230,22,222,29,229 lK5s dd $ - K5s ;K6s db "AAAAAAAAAA" ;K6s db 0,0,0,0,0,0,0,0,0,0 K6s db "ma come balli bene bella bimba, sembri proprio zoppa bella bimba" db 13,15,13,79,121,1,28,78,8,99,97,123,1,2,3,5,6,7,16 db "e cosi via; se la frase e' finita si prosegue di nuovo a partire da 4, 8, 16, 32 ecc fino esaurimento del codice.Naturalmente nell'esempio sopra viene lasciata sempre la stessa frase originaria, in realta gia al primo passaggio 'ciao' potrebbe diventare ocia oppure aoci o iaoc o restare ciao." lK6s dd $ - K6s ;30 K7s db "ABCDEFGHIJKLMNOPQRSTUVWXYZ cifre e numeri non importa 123456765434567890'0ecc ecc" db 2,3,5,7,9,18,27,30,33,49,67,17,22,13,12,15,91,9,8,4,6,3,2,4,5,9,8,7,4,5,6,7,2 db 12,5,7,5,3,4,8,9,3,18,17,21,23,19,17,15,13 lK7s dd $ - K7s ;max valore dei bytes 240 (pari a 480/2 tagli con inversione della frase) K8s db "Hello baby! Come te la passi passando per questa selva oscura? Quesi brevi messaggi sono solo degli esempi di potenzialita' di coclide; basterebbero da soli a rendere infernale la sua risoluzione, ma pensa a questo messaggio sostituito a piacere da un utente con un messaggio assolutamente nuovo e persino privo di senso e di significato. E in piu eccoti altri caratteri casuali giano da solo a far la guerra bhs fjdhyr grtfsdh sjkdollekdhgs sjdjsiekd blablabla" lK8s dd $ - K8s ;28 K9s db "Chiave di traslazione i cui bit fanno traslare a gruppi di 8 bytes per volta i bytes del messaggio verso l'inizio; questa spiegazione ne e' gia' la chiave 9. e se non sei contento tricchebballacche e tricchebballacchete; ah dimenticavo i codici PIN e il codice di sequenza, che da soli basterebbero e avanzerebbero in fatto di sicurezza... oltre 6 mega.giga.ecc milioni di miliardi di combinazioni, e il punto di attacco viene calcolato con un algoritmo semplice ma efficacemente intrappolato all'interno del messaggio... ma diamine leggiti l'help e ci troverai tutte le spiegazioni minuziosamente dettagliate. Open e' piu sicuro" lK9s dd $ - K9s ;K0s db 0,0,0,0,0,0,0,0 ;K0s db 0xff,0xff,0xff,0xff K0s db "Se pensi che sia facile decodificare un messaggio CODEC di coclide senza conoscerne le chiavi, o che sia facile reperire le chiavi che chiunque potra' costruirsi come meglio ritiene opportuno, ti sbagli di grosso. Questo breve messaggio e' gia una chiave..... compresi i puntini naturalmente e in fase di esecuzione del programma potra' essere cambiata con lunghezza fino a 1 milione di caratteri e qualsiasi tipo di carattere, compreso questo codice zero",0,"si proprio zero; unico limite la RAM del tuo calcolatore; solo per motivi contingenti le chiavi le abbiamo limitate a 1 megabyte. Ovviamente anche le chiavi precedenti possono essere estese fino a 1 megabyte. e tanto per complicarti la vita eccoti alcuni codici di caratteri strani:",02,03,79,7,1,23,"Napoli 2* estratto hihihihiih, e pirla chi se li gioca." lK0s dd $ - K0s ;Chiavi extra attivabili da comando manuale: K11s db "chiave11 da attivare con un comando extra AK11 : esegue un ADD con chiave immediata o chiave estratta da File. Chi l'ha detto che Open Source sia meno sicuro? Questo coclide ne e' un esempio! leggete l'help allegato, e' tutto dettagliato minuziosamente nel suo funzionamento, eppure sta tutta qui la sua estrema sicurezza. Durante l'esecuzione sostituite una sola di queste chiavi a piacere, verificatene il funzionamento con VKXX e i vostri dati viaggeranno sicuri perche' il vero messaggio e' la chiave che avrete utilizzato; dopo la sessione codec distruggete entrambre le copie delle chiavi e nessuna potenza al mondo neppure arcana potra' mai risalire al messaggio originario." lK11s dd $ - K11s ;110 K12s db "Questa chiave12 e' da attivare anch'essa con un comando extra: comando AK12 ; se K12 e' attiva viene eseguita prima di K2 e subito dopo K1 e K3; sostanzialmente e' una K825 da usare specificatamente per caratteri alfabetici in quanto ricodifica con 5 bit gli 8 bit dei caratteri. Open source, e' il futuro delle comunicazioni codec" lK12s dd $ - K12s ;279 K13s db "this is la kiave 13; (mi piace mischiare inglese e italiano), Ma non preoccupatevi, potete mischiare tutte le lingue che volete. Questa chiave 13 per ora non e' attiva ne funzionante ma e' attivabile in futuro e funziona cosi: I primi 2 bit di ogni byte della chiave individuano il numero di byte interessati a una operazione di ROR o ROL, gli altri 5 bit identificano il numero di rotazioni sui bit da effettuare, l'ultimo bit definisce se ROR o ROL. Capitoooo?" lK13s dd $ - K11s act_K: act_K01 dd 1 act_K02 dd 1 act_K03 dd 1 act_K04 dd 1 act_K05 dd 1 act_K06 dd 1 act_K07 dd 1 act_K08 dd 1 act_K09 dd 1 act_K00 dd 1 act_K11 dd 0 act_K12 dd 0 act_K13 dd 0 sequenza_Kiavi_default: seq_kiavi_no_mod dd 1,3,12 seq_kiavi_mod dd 2,4,5,6,7,8,9,10,11,13 sequenza_Kiavi dd 1,3,12,2,4,5,6,7,8,9,10,11,13 key_is_attiva db 0,0,0,0 P1 dd 0 P2 dd 0 P1max dd 0 P1max_base dd 0 P3_7 dd 0 P3_8 dd 0 P3_9 dd 0 P3_7max dd 0 P3_8max dd 0 P3_9max dd 0 P3_7_p dd 0 P3_8_p dd 0 P3_9_p dd 0 P3_7max_p dd 0 P3_8max_p dd 0 P3_9max_p dd 0 P3 dd 0 P3i dd 0 P3v dd 0 P3max dd 0 P3max_K4 dd 0 P3_master dd 0 L1 dd 0 L2 dd 0 fatto_k1 dd 0 P1i dd 0 lungh_key_DK dd 0 errore_l_mesg dd 0 prov_K4 db 0 provv_1_max db 0 op_ebp dd 0 op_edi dd 0 ;CH1_4 e' il byte i cui bit servono alla kiave4 CH1_4 db 0 ;blocchi_Da8b_K4 quanti blocchi da 8 bytes (o meno) ci sono per DK4 Bda8 dd 0 NCR4 dd 0 Lchx4 dd 0 blocchi_Da8b_K4 dd 0 resto_blk_8b_DK4 dd 0 NCRIP_K4 dd 0 resto_NCRIP_K4 dd 0 no_e dd 0 no_s dd 0 provv_789 dd 0 msg_err_CODE db "Errore CODE! Controllare che sia tutto a posto prima di proseguire",0xa msg_err_CODE_l dd $ - msg_err_CODE ok_file_F dd 0 msg_accettato db "Il comando " msg_acc db " e' stato eseguito",0xA msg_acc_l dd $ - msg_accettato msg_seq_k789 db 0xa,"ATTENZIONE!",0xa db " Ricordarsi che scambiare le sequenze K7-K8-K9 con altre chiavi e' una operazione complessa...",0xa db " Sei sicuro di quello che fai? Rileggersi l'help completo se si hanno dei dubbi. ",0xa,0xa msg_seq_k789_l dd $ - msg_seq_k789 msg_HELP: db "Il client coclide accetta i seguenti comandi:",0xa db "/ComandoIRC = Esegue il comando IRC specificato, (join, mode, privmsg, nick ecc.)",0xA db "/ComandoCoclide = Esegue il comando coclide a 4 byte che puo' essere uno tra quelli di seguito specificati:",0xA db "/AK00 ... /AK13 = Attiva chiavi da 00 a 13. (Le chiavi da 1 a 10 sono gia' attive per default, K00 e K10 coincidono)",0xA db "/CPIN xxxxxx = Cambia il codice PIN generico da 0 a 999999",0xa db "/CP00 ... /CP13 xxxxxx = Cambia i codici PIN delle singole chiavi da 0 a 999999",0xa db "/CSEQ XX YY = Scambia la sequenza di codifica della chiave XX con la chiave YY --- sinonimo di /SEQK",0xA db "/DSEQ or /RSEQ = Ripristina la sequenza delle chiavi di default 1 3 12 2 4 5 6 7 8 9 10 11 13",0xA db "/DK00 ... /DK13 = Disattiva chiavi da 00 a 13. (Le chiavi 11, 12 e 13 sono disattivate per default)",0xA db "/EMSG ON | [OF] = Messaggi in formato Esteso ON oppure OFF",0xA db "/HELP = Esegue questo Help; il comando /help (minuscolo) esegue l'help del server",0xa db "/MSG2 nick|chan = Cambia destinazione di default dei messaggi",0xA db "/RPIN = Reset PIN CODE, resetta tutti i PIN CODE rimettendo i valori di default",0xa db "/RSTK = Esegue un reset di tutte le chiavi rimettendo le chiavi di default",0xa db "/SCOD = Set CODE MODE: Inizia una sessione CODEC",0xA db "/SEQK XX YY = Scambia la sequenza di codifica della chiave XX con la chiave YY --- sinonimo di /CSEQ",0xA db "/UCOD = Unset CODE MODE: Termina sessione CODEC",0xA db "/VERS = Versione N... del... e breve messsaggio di Copyright",0xA db "/VK00 ... /VK13 = Verifica le chiavi da 1 a 13 (la K00 e la K10 coincidono)",0xa db "/VPIN = Verifica tutti i codici PIN ",0xa db "/VSEQ = Verifica la sequenza delle chiavi e quali chiavi sono attive",0xA db "....",0xa db "/CODE Kxxxxxxxxxxxxx [chiave immediata digitata al volo]",0xa db "/CODE Fxxxxxxxxxxxxx nomefile [-s 3000] [-e 5000] dove x individua la posizione del numero di chiave che puo' essere:" db " void = i = invariata ------ " db "d = default ------ " db "n = nuova key ",0xa db " dove K = K(ch)iave immediata -------- F = chiave da File. -s = start_point -e = end_point",0xA db " 1� Es.: /CODE Kiiin Questa e' una key",0xa db " Cambiera' la quarta chiave in 'Questa e' una key'",0xa db " 2� Es. /CODE Fiiiiiin File.ext -s 100000 -e 300000",0xa db " Da File.ext saranno estratti come 7^ chiave 200.000 bytes a partire dalla pos. 100.000 fino alla pos. 300.000",0xA db "...",0xA db "N.B.:IMPORTANTE!!!! in questa versione sono implementate solo le prime 10 chiavi attive di default.",0xa msg_HELP_l dd $ - msg_HELP ;Help supplementari: db "/CODE[C] Fxxxxxxxxxxxx ",0xA db " Es. /CODE Fiin MioFile.ext [-s 3000] [-e 5000]",0xa db " dal quale vengono estratti come terza kiave 2000 caratteri a partire dalla posizione 3000 fino alla pos. 5000 del file MioFile.ext )",0xA db "-in caso di omissione di -s si intendera' per default inizio file",0xa db "-in caso di omissione di -e si intendera' per default la fine del file",0xa db "-in caso di omissione di entrambi verra' utilizzato l'intero file a partire dal primo byte fino a un massimo di 1 megabytes",0xa db "...",0xA db " La sessione CODEC e' valida solo per nick|chan di default (settabile col comando /MSG2 )",0xa db " Se durante una sessione CODEC attiva si vuole inviare un messaggio in chiaro a nick|chan di default si puo' ricorrere al comando:",0xa db " /PRIVMSG nick|chan :Il testo di un messaggio inviato utilizzando il comando /PRIVMSG viene inviato sempre in chiaro.",0xa ;msg_HELP_l dd $ - msg_HELP schema: rt0 db "____________________________________________________________________________________",0xa rt1 db "| EAX EBX ECX EDX ESI EDI EBP ESP |",0xa rt2 db "| xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx |",0xa rt3 db "| |",0xa rt4 db "| EIP CS DS ES SS FS GS EFLAGS ???????? SZ?H?P?C |",0xa rt5 db "| xxxxxxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxxxxxx xxxxxxxx |",0xa rt6 db "| 0 0 1 |",0xa rt7 db "|I iiiiiiii |",0xa rt8 db "|F ffffffff | _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F |___________________|",0xa rt9 db "| | | |",0xA r1 db "| 00000000 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r2 db "| =====+10 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r3 db "| =====+20 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r4 db "| =====+30 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r5 db "| =====+40 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r6 db "| =====+50 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r7 db "| =====+60 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r8 db "| =====+70 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa rs db "| | | |",0xA r9 db "| =====+80 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r10 db "| =====+90 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r11 db "| =====+A0 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r12 db "| =====+B0 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r13 db "| =====+C0 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r14 db "| =====+D0 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r15 db "| =====+E0 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r16 db "| =====+F0 | xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx | ........ ........ |",0xa r17 db "|___________|______________________________________________________________________|",0xa db 0xa," Digitare 'q' e entro 90 secondi per uscire ed evitare il PING Timeout;",0xa," a vuoto per nuova pagina; 'h' per help",0xa,0x0a l_schema dd $ - schema fine_schema db 0xa,0xa,0xa,0xa,0xa,2025 msg_vers db "coclide - irc client. Copyright by vitogambi@gmail.com. Versione: " versione db "K10.0 del 04/Apr/2006",0xa l_msg_vers dd $ - msg_vers buff_struc_time: t_MMl db "X........ ",0xA,0,0 ; (Gennaio - Dicembre) MESEnome t_GGl db "Xxx ",0xA ;(Lun - Dom) GIORNOset t_GG db "00","/" ;00 GIORNOnum t_MMs db "00","/" ; MESEnum t_AAAA db "0000",0xA ; ANNO t_HHpre db " <" t_HH db "00",":" ; (da 00 a 24) ORE t_MMm db "00",":" ; (da 00 a 59) MIN t_SS db "00","> ",0xA ; (da 00 a 59) SEC t_GS db "00",0xA,0xA,0xA,0xA ;(da 0 a 6) t_giosetN dd 0 ; e' un doppione di t_ggNs t_ggN dd 0 ; (giorno da 1 a 31) t_ggNs dd 0 ; (giorno settimana da 0 a 6 ... Dom = 0 ... sab = 6 ) t_mmN dd 0 ; (mese da 1 a 12) t_aaN dd 0 ; (anno da 0 a 4miliardiecc) t_hhN dd 0 ; ore t_MMnN dd 0 ; min t_ssN dd 0 ; sec ;struct sock------- ;struttura socket ;socket su sys_call 66h ---> eax ;#define SYS_SOCKET 1 /* sys_socket(2) */ ;#define SYS_BIND 2 /* sys_bind(2) */ ;#define SYS_CONNECT 3 /* sys_connect(2) */ ;#define SYS_LISTEN 4 /* sys_listen(2) */ ;#define SYS_ACCEPT 5 /* sys_accept(2) */ ;#define SYS_GETSOCKNAME 6 /* sys_getsockname(2) */ ;#define SYS_GETPEERNAME 7 /* sys_getpeername(2) */ ;#define SYS_SOCKETPAIR 8 /* sys_socketpair(2) */ ;#define SYS_SEND 9 /* sys_send(2) */ ;#define SYS_RECV 10 /* sys_recv(2) */ ;#define SYS_SENDTO 11 /* sys_sendto(2) */ ;#define SYS_RECVFROM 12 /* sys_recvfrom(2) */ ;#define SYS_SHUTDOWN 13 /* sys_shutdown(2) */ ;#define SYS_SETSOCKOPT 14 /* sys_setsockopt(2) */ ;#define SYS_GETSOCKOPT 15 /* sys_getsockopt(2) */ ;#define SYS_SENDMSG 16 /* sys_sendmsg(2) */ ;#define SYS_RECVMSG 17 /* sys_recvmsg(2) */ ;per recv: mov eax,102 ;0x66 ; mov ebx,10 ;funzione 10 recv(int s, void *buf, size_t len, int flags) ; mov ecx,args_per_recv ;struttura args_per_recv: ;in ecx arg_r0 dd 0 ;????? sock si.... numero di sock? arg_r1 dd 0 ;????? ptr_2_buffer si suffer_2_recv_dopo arg_r2 dd 512 ;????? lungh_buffer? arg_r3 dd 0 ;??? ;finalemnte FLAGS 0x40 MSG_NOBLOCKING arg_r4 dd 0 ;??? arg_r5 dd 0 ;? fino a 6 args da passare in caso di chiamate SYS_SOCKET da 1 a 17 ;Flags args: ;in ecx arg0 dd 2 ;AF_INET arg1 dd 1 ;SOCK_STREAM arg2 dd 6 ;IPPPROTO_TCP o Socket Option Level 6=TCP arg3 dd 0 ; arg4 dd 0 arg5 dd 0 ; fino a 6 args da passare in caso di chiamate SYS_SOCKET da 1 a 17 sock dd 0 ;fd di socket sock_ID ;---DA VERIFICARE E CORREGGERE------------- ;0x66 --> eax ;0x3 --> ebx subfunzione 3 CONNECT ;ptr args_Conn ---> ecx server: AF_INETs dw 0x2 port1 dw 0x0B1A ;6667 ;ircserver1 dd 0x745D33E ;irc1.tin.it ;ircserver1 dd 0x945D33E ;irc2.tin.it ircserver1 dd 0xE649D33E ;era 0x945D33E ;irc2.tin.it NATOI inverso ;ircserver1 dd 0x645D33E ;irc3.tin.it ;ircserver1 dd 0x2563C8D5 ;irc.tiscali.it riemp_serv times 100 db " " zero_term_serv db 0 server_l dd $ - server args_Conn: arg0C dd 0 ; sock_ID arg1C dd 0 ; ptr su irc_server1 arg2C dd 0 ; ptr su server_l venti_bytes1 db "12345678901234567890" join db "JOIN " where_2_join db "#coclide ",0x0D,0x0A join_l dd $ - join no_join dd 0 ;0 = ok join 1 = No_join nick db "NICK " nickn db "sonoio^^^^ ",0x0D,0x0A nick_l dd $ - nick user db "USER " ident db "ioi1 " ;-i user1 db "ioi2 " ;-u userid db "ioi3 " ;-d realname db "ioi4 ",0x0D,0x0A ;-r user_l dd $ - user flag_codec dd 0 ;0 = no codec 1 = codec venti_bytes db "12345678901234567890" buffer_2send db "PRIVMSG " ;8 where_2_msg db "#coclide :" ;20 buffer_2send_dopo times 480 db 0 poi2b2s db 0,0,0xa,0x0a,0x0a popipoi db 0x0a,0x0a,0,0,0,0,0,0,0,0,0,0,0,0,0 Kripta dd 0 ;0 = UNCOD 1=CODEC mesg_pulito_0 db " < " canale2_pulito db "PRIVMSG canale >: " mesg_pulito times 512 db 0 mesg_estesi dd 1 ;default 1 messaggi in formato esteso (ora nick!ident@host... ecc" Testata_msg_pul dd 48 ;b2s_l dd $ - buffer_2send b2s_dopo times 480 db 0 ping db "PING" pong db "PONG" buffer_2recv times 510 db 0 rb2r db 0xA,0xA pong_l dd $ - pong l_header dd 0 char_bel times 100 db 7 ;---DA CORREGGERE---------------- ;-------fine sock struc msg_err_file db 0xA,"REGISTRO EAX HEX... " codice_errore db "--------",0xA,0xA,0xA,0xA msg_ascizza db "VAL. ASCII di EAX: " asci4 db " ",0xA,0xA,0xA,0xA mask1 dd 0x00000000 ;access mode 00 = read anly mask2 dd 0x00000666 ;rw by owner 400+200 e by group 40+20 sara' vero ;mask1_a dd 0x00000777 ;modo di accesso mask1_w dd 0x00000201 ;access mode 2000 = append 100 = create 001 = Write Only ;flag permmessi mask2_w dd 0x000001B6 ;mask2_w dd 0x000001A0 ;rw by owner cazzate nere funziona su 9 bit se lo crea err dd 0 fd1 dd 0 b_letti dd 0 EOF1 dd 0 fd_generico dd 0 tot_conn dd 0 tot_connA db "##########",0xA,0xA provv1 dd 0 provv2 dd 0 provv dd 0 edi_provv dd 0 ebx_provv dd 0 eax_provv dd 0 buff_std_prova db "PRIVMSG " ;8 can_std_prova db "#canmio :" ;20 provv_buff times 480 db 0x41 fin_buff_stdprv db 0xd,0xA riemp_buff_prov times 480 db 0 ggl: db "Dom " db "Lun " db "Mar " db "Mer " db "Gio " db "Ven " db "Sab " db "Dom ",0xA,0xA mese: db "Gennaio ",0 db "Febbraio ",0 db "Marzo ",0 db "Aprile ",0 db "Maggio ",0 db "Giugno ",0 db "Luglio ",0 db "Agosto ",0 db "Settembre",0 db "Ottobre ",0 db "Novembre ",0 db "Dicembre ",0 mes: db "Jan " dd 1 giorn dd 31 db "Feb " dd 2 dd 28 db "Mar " dd 3 dd 31 db "Apr " dd 4 dd 30 db "May " dd 5 dd 31 db "Jun " dd 6 dd 30 db "Jul " dd 7 dd 31 db "Aug " dd 8 dd 31 db "Sep " dd 9 dd 30 db "Oct " dd 10 dd 31 db "Nov " dd 11 dd 30 db "Dec " dd 12 dd 31 giorni_mese dd 0 Indirizzo db "Indirizzo " indA db "######## : " numindA db "######## ",0xA,0xA ;tot32 file_name_cod times 256 db 0 lungh_nome_file_F dd 0 lungh_buff_file_F dd 0 ptr1_fn_cod dd 0 ptr2_fn_cod dd 0 new_line1 db 0xA,0xD bisest dd 0 sono_qui dd 0 pre_prova1 db "AAAAAAAAAAAAAAAA" ;prova1 db 0,0,0,0x50,0x0E8,0x32,0,0,0,0x89,0x0C6,0,0,0,0,0 ;0x58,0x0E8,0x5D,0x07,0 prova1 db 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56 prova1a db 57,58,59,60,61,62,63,64,65,66,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101 prova1aa db 102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119 prova1b db 120,121,122,123,124,125,126,127 msg_few_par: db 0xa db "================================================================================================",0xa,0xa db "Esempio di avvio di una sessione coclide standard:",0xa,0xa db "./coclide ZMZS -n tuo_nick",0xa,0xa db "attendere qualche secondo che si sia connessi al server, quindi:",0xa,0xa db "/JOIN #chan",0xa db "/MSG2 nick | #chan",0xa db "/SCOD",0xa,0xa db " ... e buona conversazione coclide....",0xa,0xa db "/HELP per saperne di piu",0xa db "/UCOD per terminare la sessione coclide",0xa db " Ctrl+C per uscire",0xa,0xa,0xa db " ...... ",0xa,0xa,0xa ; db "================================================================================================",0xa,0xa db "La sintassi completa e':",0xA,0xa db "./coclide ZMZS [-s xxx.xxx.xxx.xxx(ircServer)] [-p Port] [-n Nickname] [-i Ident] [-r Realname] [-u User] [-d useriD] [+j]",0xA,0xa ; db " (ZMZS Only = default session)",0xa db " +j Senza opzioni = /join #coclide ",0xA,0xa db "================================================================================================",0xa,0xa msg_few_par_l dd $ - msg_few_par tin_dot1 db "62.211.69.7",0 tin_dot2 db "62.211.69.9",0 tin_dot3 db "62.211.69.6",0 ptr_2_server dd 0 server_numero_dotted db "xxx.xxx.xxx.xxx",0 ptr_2_port dd 0 ptr_2_nick dd 0 ptr_2_realname dd 0 ptr_2_user dd 0 ptr_2_userid dd 0 ptr_DK4 dd 0 p_file_iniziale dd 0 N_par dd 0 input_msg db "Digitare INDIRIZZO VALORE ( XX YY ) ",0xA,0xa input_msg_dumpa db "Digitare indirizzo (da 00000000 a FFFFFFFF) ",0xA,0xA input_msg_I db "Digitare nuovo indirizzo di Inizio file (in HEX XXXXXXXX) ",0xA,0xA input_msg_F db "Digitare nuovo indirizzo di Fine file (in HEX XXXXXXXX) ",0xA,0xA ;input_msg_help db "h=help ; D=Dumpa a XXXXXXXX ; M|m= modifica valore memoria XX YY ; W=Write file ; u=pagina Up di 256 bytes ; =pagina Down di 256 bytes ; I=Nuovo inizio file ; F=Nuova fine file ; q|x=EXIT",0xa,0xA input_msg_help db " h=help ; D=Dumpa a XXXXXXXX ; M|m= modifica valore memoria XX YY ; ............ ; u=pagina Up di 256 bytes ; =pagina Down di 256 bytes ; ................... ; ................ ; q|x=EXIT",0xa,0xA ok_scritto db "OK il Buffer � stato scritto su file ",0xA val_fin dd 0 conta dd 0 buff_provv times 256 db 0 validate_file dd 0 fd_W1 dd 0 riempitivo times 2000 db "Z" inizio_buff dd 0 ;l'inizio del buff puo spostarsi indietro fino a 10 mb inizio_buff1 dd 0 ;INIZIO BUFF ORIGINALE fine_buff1 dd 0 ;FINE BUFF ORIGINALE fine_buff dd 0 ;la fine del buffer puo arrivare fino al limite superiore dei 30 mega byte_rec db 0 attiva db 0 timer dd 0 timer4 dd 0 oltretim times 256 db 0 timer1 dd 0 timer5 dd 0 quanti_bytes dd 0 primo_byte dd 0 %define DATAOFF(addr) byte ebp + ((addr) - score) host1 db "/usr/bin/host",0 par_host1p dd 0 dd 0 par_host1d db "irc.tin.it",0 par2_host1p dd 0 dd 0 par2_host1d db "irc.tin.it",0 times 32 db " ",0 times 32 db " ",0 times 32 db " ",0 times 32 db " ",0 times 32 db " ",0 host1_l dd $ - host1 primo_pass dd 0 offset_inizio_F dd 0 offset_fine_F dd 0 l_buff_da_cryptare dd 0 lungh_kiave_attuale dd 0 Ptr_2_buffKeys_attuale dd 0 Ptr_2_buffKeys_precedente dd 0 l_buff_da_DE_cryptare dd 0 Ptr_2_buffKeys_attuale_2_DK dd 0 mesg_seq_kiavi db 0xa,"Sequenza Chiavi:",0xa,0xa," " seq_tutte db ".. - .. - .. - .. - .. - .. - .. - .. - .. - .. - .. - .. - .. ",0xa,0xa ;seq_dopo_tutte db "Chiavi attive : " ;seq_attive db ".. - .. - .. - .. - .. - .. - .. - .. - .. - .. - .. - .. - .. ",0xa,0xa l_mesg_seq_kiavi dd $ - mesg_seq_kiavi seq_dopo_tutte db "Chiavi attive : " seq_attive db ".. - .. - .. - .. - .. - .. - .. - .. - .. - .. - .. - .. - .. ",0xa,0xa mesg_PIN_CODE db "Codici PIN :",0x0a CPIN_GEN_msg db "CPGEN XXXXXXxxxx",0x0a CPIN_01_msg db "PIN01 XXXXXXxxxx",0x0a CPIN_02_msg db "PIN02 XXXXXXxxxx",0x0a CPIN_03_msg db "PIN03 XXXXXXxxxx",0x0a CPIN_04_msg db "PIN04 XXXXXXxxxx",0x0a CPIN_05_msg db "PIN05 XXXXXXxxxx",0x0a CPIN_06_msg db "PIN06 XXXXXXxxxx",0x0a CPIN_07_msg db "PIN07 XXXXXXxxxx",0x0a CPIN_08_msg db "PIN08 XXXXXXxxxx",0x0a CPIN_09_msg db "PIN09 XXXXXXxxxx",0x0a CPIN_10_msg db "PIN10 XXXXXXxxxx",0x0a CPIN_11_msg db "PIN11 XXXXXXxxxx",0x0a CPIN_12_msg db "PIN12 XXXXXXxxxx",0x0a CPIN_13_msg db "PIN13 XXXXXXxxxx",0x0a,0xa l_mesg_PIN_CODE dd $ - mesg_PIN_CODE mesg_som_PIN_CODE db "Somma cifre H Codici PIN :",0x0a som_CPIN_GEN_msg db "SMGEN XXXXXXxxxx",0x0a som_CPIN_01_msg db "SOM01 XXXXXXxxxx",0x0a som_CPIN_02_msg db "SOM02 XXXXXXxxxx",0x0a som_CPIN_03_msg db "SOM03 XXXXXXxxxx",0x0a som_CPIN_04_msg db "SOM04 XXXXXXxxxx",0x0a som_CPIN_05_msg db "SOM05 XXXXXXxxxx",0x0a som_CPIN_06_msg db "SOM06 XXXXXXxxxx",0x0a som_CPIN_07_msg db "SOM07 XXXXXXxxxx",0x0a som_CPIN_08_msg db "SOM08 XXXXXXxxxx",0x0a som_CPIN_09_msg db "SOM09 XXXXXXxxxx",0x0a som_CPIN_10_msg db "SOM10 XXXXXXxxxx",0x0a som_CPIN_11_msg db "SOM11 XXXXXXxxxx",0x0a som_CPIN_12_msg db "SOM12 XXXXXXxxxx",0x0a som_CPIN_13_msg db "SOM13 XXXXXXxxxx",0x0a,0x0a l_mesg_som_PIN_CODE dd $ - mesg_som_PIN_CODE PIN_CODE_d dd 123456 PIN_COD01_d dd 102031 PIN_COD02_d dd 234567 PIN_COD03_d dd 355678 PIN_COD04_d dd 402034 PIN_COD05_d dd 507035 PIN_COD06_d dd 632570 PIN_COD07_d dd 422913 PIN_COD08_d dd 919978 PIN_COD09_d dd 143259 PIN_COD10_d dd 987654 PIN_COD11_d dd 879543 PIN_COD12_d dd 609977 PIN_COD13_d dd 731598 PIN_PROVV_PTR dd 0 som_PIN_CODE dd 0 PIN_CODG dd 0 PIN_COD_XX: PIN_CODE dd 123456 PIN_COD01 dd 102031 PIN_COD02 dd 102032 PIN_COD03 dd 102033 PIN_COD04 dd 102034 PIN_COD05 dd 102035 PIN_COD06 dd 102036 PIN_COD07 dd 102037 PIN_COD08 dd 102038 PIN_COD09 dd 102039 PIN_COD10 dd 102040 PIN_COD11 dd 102041 PIN_COD12 dd 102042 PIN_COD13 dd 102043 som_PIN_COD01 dd 0 som_PIN_COD02 dd 0 som_PIN_COD03 dd 0 som_PIN_COD04 dd 0 som_PIN_COD05 dd 0 som_PIN_COD06 dd 0 som_PIN_COD07 dd 0 som_PIN_COD08 dd 0 som_PIN_COD09 dd 0 som_PIN_COD10 dd 0 som_PIN_COD11 dd 0 som_PIN_COD12 dd 0 som_PIN_COD13 dd 0 CRIP dd 0 ;ognuno lo modifica col proprio CPIN e lo lascia al successivo ; CRIP contiene sempre NUM_RAND XOR CPIN (generico) lungh_kiave_attuale_01 dd 0 lungh_kiave_attuale_02 dd 0 lungh_kiave_attuale_03 dd 0 lungh_kiave_attuale_04 dd 0 lungh_kiave_attuale_05 dd 0 lungh_kiave_attuale_06 dd 0 lungh_kiave_attuale_07 dd 0 lungh_kiave_attuale_08 dd 0 lungh_kiave_attuale_09 dd 0 lungh_kiave_attuale_10 dd 0 lungh_kiave_attuale_11 dd 0 lungh_kiave_attuale_12 dd 0 lungh_kiave_attuale_13 dd 0 Ptr_2_buffKeys_attuale_01 dd 0 Ptr_2_buffKeys_attuale_02 dd 0 Ptr_2_buffKeys_attuale_03 dd 0 Ptr_2_buffKeys_attuale_04 dd 0 Ptr_2_buffKeys_attuale_05 dd 0 Ptr_2_buffKeys_attuale_06 dd 0 Ptr_2_buffKeys_attuale_07 dd 0 Ptr_2_buffKeys_attuale_08 dd 0 Ptr_2_buffKeys_attuale_09 dd 0 Ptr_2_buffKeys_attuale_10 dd 0 Ptr_2_buffKeys_attuale_11 dd 0 Ptr_2_buffKeys_attuale_12 dd 0 Ptr_2_buffKeys_attuale_13 dd 0 Ptr_2_buffKeys_attuale_2_DK_01 dd 0 Ptr_2_buffKeys_attuale_2_DK_02 dd 0 Ptr_2_buffKeys_attuale_2_DK_03 dd 0 Ptr_2_buffKeys_attuale_2_DK_04 dd 0 Ptr_2_buffKeys_attuale_2_DK_05 dd 0 Ptr_2_buffKeys_attuale_2_DK_06 dd 0 Ptr_2_buffKeys_attuale_2_DK_07 dd 0 Ptr_2_buffKeys_attuale_2_DK_08 dd 0 Ptr_2_buffKeys_attuale_2_DK_09 dd 0 Ptr_2_buffKeys_attuale_2_DK_10 dd 0 Ptr_2_buffKeys_attuale_2_DK_11 dd 0 Ptr_2_buffKeys_attuale_2_DK_12 dd 0 Ptr_2_buffKeys_attuale_2_DK_13 dd 0 struct_tms: t_u dd 0 ; /* user time */ t_s dd 0 ; /* system time */ t_cu dd 0 ; /* user time of children */ t_cs dd 0 ; /* system time of children */ buff_crypt_start: db "PRIVMSG " where_2_msg_K db "provaasm2 :" ;20 buff1_2K_defa db "BAU BAU",0xd, "messaggio",0xa, "per l'altro bot",0,"ciao" ;01,02,03,04,05,06,07,08,09,0xb,0xc,14,15,16,17,18,19,20,31,22,23,24,25,26,27,28,29,30,31,32,33,34,35 buffw2kdopo times 2048 db 0 codice_0AD db 0x3E,41,0xD3,0x98 identificativo_0AD db 14,1 ;1 puo essere 1= 0 11 = A 14 = D buff_norm_prova times 512 db 0x41 section .bss score: resd 1 ;timer: resd 4 fdset: resd 32 fdset1 resd 32 K1u resb 2000000 ;chiave Ultima K2u resb 2000000 ;chiave Ultima K3u resb 2000000 ;chiave Ultima K4u resb 2000000 ;chiave Ultima K5u resb 2000000 ;chiave Ultima K6u resb 2000000 ;chiave Ultima K7u resb 2000000 ;chiave Ultima K8u resb 2000000 ;chiave Ultima K9u resb 2000000 ;chiave Ultima K0u resb 2000000 ;chiave Ultima K11u resb 2000000 ;chiave Ultima K12u resb 2000000 ;chiave Ultima K13u resb 2000000 ;chiave Ultima K1a resb 2000000 ;chiave Attiva K2a resb 2000000 ;chiave Attiva K3a resb 2000000 ;chiave Attiva K4a resb 2000000 ;chiave Attiva K5a resb 2000000 ;chiave Attiva K6a resb 2000000 ;chiave Attiva K7a resb 2000000 ;chiave Attiva K8a resb 2000000 ;chiave Attiva K9a resb 2000000 ;chiave Attiva K0a resb 2000000 ;chiave Attiva K11a resb 2000000 ;chiave Attiva K12a resb 2000000 ;chiave Attiva K13a resb 2000000 ;chiave Ultima buff_provv_32k resb 32000 buff_vuoto_2mega resb 2000000 riempi1 resb 2000000 buff1 resb 3000000 ;-------------------------------- ;������������������������������������������������������������������������������� ;������������������������������������������������������������������������������� ;-------------------------------- section .text global _start _start: pop eax ; 0-Get the number of arguments cmp al,2 jae is_2_n jmp fine_con_msg is_2_n: is_2: mov [N_par],eax pop ebx ; 1-get command line pop ebx ; 2-Get p* to 1� parametro ZMZS cmp dword [ebx],"ZMZS" jae is_2_p jmp fine_con_msg is_2_p: mov ecx,[N_par] sub ecx,2 ;i parametri gia estratti, command line e ZMZS jz near is_2_vai_dopo cmp ecx,16 ja near fine_con_msg is_2_p_dopo_set: mov eax,[err] cmp eax,0 ;jne near fine_con_msg pop eax xor ebx,ebx mov bx,[eax] cmp bx,"-s" je near vai_is_server cmp bx,"-p" je near vai_is_port cmp bx,"-n" je near vai_is_nick cmp bx,"-r" je near vai_is_realname cmp bx,"-u" je near vai_is_user cmp bx,"-d" je near vai_is_userid cmp bx,"-i" je near vai_is_ident cmp bx,"+j" je near vai_is_join jmp fine_con_msg va_a_visualizza: ; mov eax,"BENE" ; call visualizza ; jmp fine ;mov eax,ebx ;call visualizza ;jmp fine jmp fine_con_msg ;---------- vai_is_server: ; mov eax,"Is_s" ; call visualizza ; jmp fine pop esi ;ptr 2 parametro mov dword [err],0 call Natoi bswap eax mov [ircserver1],eax ;call errorizza mov eax,[err] cmp eax,0 jne near fine_con_msg dec ecx jnz near vedi_se_fine_par jmp is_2_vai_dopo ;---------- vai_is_port: ;mov eax,"Is_p" pop eax ;ptr parametro mov eax,[eax] call numerizza_eax bswap eax ror eax,16 cmp eax,0xffff ja near fine_con_msg mov [port1],ax dec ecx jnz near vedi_se_fine_par jmp is_2_vai_dopo ;---------- vai_is_nick: mov dword [err],0 ;mov eax,"Is_n" ;call visualizza mov esi,nickn call pulisci_con_space_16_bytes pop esi pusha mov ecx,16 ;max 16 chars mov edi,nickn cont_vai_is_nick mov al,[esi] cmp al,0 je fine_vai_nick mov [edi],al inc esi inc edi dec ecx jnz cont_vai_is_nick fine_vai_nick: cmp ecx,16 jb fine_vai_nick_ok1 mov dword [err],1 fine_vai_nick_ok1: popa dec ecx jnz near vedi_se_fine_par jmp is_2_vai_dopo ;---------- vai_is_realname: mov dword [err],0 ;mov eax,"Is_r" ;call visualizza mov esi,realname call pulisci_con_space_8_bytes pop esi ;ptr parametro r pusha mov ecx,8 ;max 8 chars mov edi,realname cont_vai_is_nick_ir mov al,[esi] cmp al,0 je fine_vai_nick_ir mov [edi],al inc esi inc edi dec ecx jnz cont_vai_is_nick_ir fine_vai_nick_ir: cmp ecx,8 jb fine_vai_nick_ok1_ir mov dword [err],1 fine_vai_nick_ok1_ir: popa dec ecx jnz near vedi_se_fine_par jmp is_2_vai_dopo ;---------- vai_is_user: mov dword [err],0 ;mov eax,"Is_u" ;call visualizza mov esi,user1 call pulisci_con_space_8_bytes pop esi ;ptr parametro pusha mov ecx,8 ;max 8 chars mov edi,user1 cont_vai_is_nick_iru: mov al,[esi] cmp al,0 je fine_vai_nick_iru mov [edi],al inc esi inc edi dec ecx jnz cont_vai_is_nick_iru fine_vai_nick_iru: cmp ecx,8 jb fine_vai_nick_ok1_iru mov dword [err],1 fine_vai_nick_ok1_iru: popa dec ecx jnz near vedi_se_fine_par jmp is_2_vai_dopo ;---------- vai_is_userid: mov dword [err],0 ;mov eax,"Is_d" ;call visualizza ;mov eax,ecx ;call errorizza mov esi,userid call pulisci_con_space_8_bytes pop esi ;ptr parametro pusha mov ecx,8 ;max 8 chars mov edi,userid cont_vai_is_nick_irud: mov al,[esi] cmp al,0 je fine_vai_nick_irud mov [edi],al inc esi inc edi dec ecx jnz cont_vai_is_nick_irud fine_vai_nick_irud: cmp ecx,8 jb fine_vai_nick_ok1_irud mov dword [err],1 fine_vai_nick_ok1_irud: popa dec ecx jnz near vedi_se_fine_par jmp is_2_vai_dopo ;---------- vai_is_ident: mov dword [err],0 ;mov eax,"Is_i" ;call visualizza ;mov eax,ecx ;call errorizza mov esi,ident call pulisci_con_space_8_bytes pop esi ;ptr 2 parametro pusha mov ecx,8 ;max 8 chars mov edi,ident cont_vai_is_nick_i mov al,[esi] cmp al,0 je fine_vai_nick_i mov [edi],al inc esi inc edi dec ecx jnz cont_vai_is_nick_i fine_vai_nick_i: cmp ecx,8 jb fine_vai_nick_ok1_i mov dword [err],1 fine_vai_nick_ok1_i: popa dec ecx jnz vedi_se_fine_par jmp is_2_vai_dopo ;---------- vai_is_join: mov dword [no_join],1 ;mov eax,"Is_u" ;call visualizza ;mov esi,where_2_join; user1 ;call pulisci_con_space_16_bytes ;mp fine jmp near vedi_se_fine_par ;jmp is_2_vai_dopo ;------------ vedi_se_fine_par: dec ecx jz is_2_vai_dopo jmp is_2_p_dopo_set ;-----------------gia SISTEMAto--------- is_2_vai_dopo: ; mov eax,"BENE" ; call visualizza ;jmp fine mov eax,1 mov ebx,2 mov ecx,3 mov edx,4 mov ebp,5 mov esi,6 mov edi,7 push eax call vedi_stack_su_buff ; mov esi,prova1 ;eax pop eax ;mov ebx,[p_file_iniziale] ;call esegui_letture ;mov esi,[p_file_iniziale] ;call sistema_sequenza_chiavi_default call metti_chiavi_default call RPIN_ROUT ;mette i codici pin di default call inizializza_buff_vuoto_2mega ;------------------ mov esi,buff_vuoto_2mega mov [P3_7_p],esi mov [P3_8_p],esi mov [P3_9_p],esi inc esi mov [P3_7max_p],esi mov [P3_8max_p],esi mov [P3_9max_p],esi ;----FORK------ ;mov eax,2 ;mov ebx,1 ???? ;int 0x80 ;call errorizza ;jmp fine ;-------------- call apri_sock1 cmp eax,1 jnb no_err jmp fine_con_msg no_err: mov [sock],eax mov [arg0C],eax mov eax,server mov [arg1C],eax mov eax,[server_l] mov [arg2C],eax call connetti_sock1 cmp eax,0 jae no_err_conn jmp fine_con_msg no_err_conn: ;call errorizza ;ok siamo connessi mov eax,4 mov ebx,[sock] mov ecx,nick mov edx,[nick_l] int 0x80 mov eax,4 mov ebx,[sock] mov ecx,user mov edx,[user_l] int 0x80 mov eax,[no_join] cmp eax,1 jne Loop1 mov eax,4 mov ebx,[sock] mov ecx,join mov edx,[join_l] int 0x80 Loop1: call getkey dopo_Loop1: ;call pulisci_buffer_2recv call sock_recv1 ;usiamo sock_recv1 invece della sottostante per avere un recv_NO_BLOCKING ;mov eax,3 ;mov ebx,[sock] ;mov ecx,buffer_2recv ;mov edx,512 ;int 0x80 mov esi,[buffer_2recv] ;solo 4 bytes mov edi,[ping] cmp esi,edi ; controlliamo se PING je near pongroutine ; e in caso affermativo rispondiamo con PONG cmp esi,0 ; se e' 0 (no chars received) je Loop1 ; torniamo sul loop principale ;vediamo se attivo Kripta call calcola_l_header ;-------------- ;---------------- mov eax,[Kripta] cmp eax,0 je near visual_normale_NoK cmp eax,1 jne near visual_normale_NoK ;per maggior sicurezza, DEVE essere 1 per avviare CODEC mov edi,where_2_msg mov esi,buffer_2recv xor ebx,ebx inc esi mov ecx,16 va_forse_nick: mov al,[esi] mov ah,[edi] cmp al,ah jne no_nick_forse_chan inc ebx inc esi inc edi dec ecx jnz va_forse_nick no_nick_forse_chan: cmp ebx,0 je prova_se_chan cmp al,"!" jne prova_se_chan cmp al,0x20 jbe prova_se_chan forse_nick_2: cmp ah," " jne prova_se_chan ;OK e' sicuramente nick jmp OK_is_Kripta_nick_chan prova_se_chan: ;cercare PRIVMSG #canmio mov edi,where_2_msg mov esi,buffer_2recv xor ebx,ebx add esi,11 ; minimo n!i@1.2.3.4 NOTICE mov ecx,80 cont1_prova_se_chan: mov al,[esi] cmp al," " je ok_primo_spazio_chan inc esi dec ecx jnz cont1_prova_se_chan jmp visual_normale_NoK ok_primo_spazio_chan: inc esi mov al,[esi] cmp al," " je ok_secondo_spazio_chan dec ecx jnz ok_primo_spazio_chan jmp visual_normale_NoK ok_secondo_spazio_chan: inc esi xor ebx,ebx mov edi,where_2_msg mov ecx,20 ok_2_sp_chan_va: mov al,[esi] mov ah,[edi] cmp al," " je va_forse_chan_verifica1 cmp ah," " je va_forse_chan_verifica_ah cmp ah,al jne va_forse_chan_verifica inc ebx inc edi inc esi dec ecx jnz ok_2_sp_chan_va jmp visual_normale_NoK va_forse_chan_verifica_ah: cmp al,0 je OK_is_Kripta_nick_chan va_forse_chan_verifica1: cmp ah," " je OK_is_Kripta_nick_chan va_forse_chan_verifica: cmp ebx,1 ja si_deciso_isKripta OK_is_Kripta_nick_chan: cmp ebx,1 ja si_deciso_isKripta jmp visual_normale_NoK ;--- si_deciso_isKripta: ;ed eccoci qui a decodificare le Keys in ordine inverso ;appena pronta SEQK (o KSEQ) sara' fatta secondo l'ordine ;stabilito da KSEQ ;call errorizza pusha call calcola_som_PIN_CODE popa mov ebp,sequenza_Kiavi mov edx,48 mov ecx,13 mov dword [errore_l_mesg],0 mov dword [P3_7],0 mov dword [P3_8],0 mov dword [P3_9],0 mov dword [P3_7max],0 mov dword [P3_8max],0 mov dword [P3_9max],0 mov esi,buff_vuoto_2mega mov [P3_7_p],esi mov [P3_8_p],esi mov [P3_9_p],esi inc esi mov [P3_7max_p],esi mov [P3_8max_p],esi mov [P3_9max_p],esi call primo_passo_DK cmp dword [errore_l_mesg],0 jne near visual_normale_NoK call primo_passo_fase_DK chiavi_in_seq_DK: mov ebx,[ebp+edx] call mettiK_su_eax_DK cmp eax,0xFFFFFFFF je near fine_chiavi_in_seq_DK ;ERROREEEEEEEEEEEEEE ;mov eax,decodkiave5 ;provvisorio pusha call eax popa sub edx,4 dec ecx jnz chiavi_in_seq_DK jmp fine_chiavi_in_seq_DK mettiK_su_eax_DK: cmp ebx,dword 1 je is_kiave1_DK cmp ebx,2 je is_kiave2_DK cmp ebx,3 je is_kiave3_DK cmp ebx,4 je is_kiave4_DK cmp ebx,5 je is_kiave5_DK cmp ebx,6 je is_kiave6_DK cmp ebx,7 je is_kiave7_DK cmp ebx,8 je is_kiave8_DK cmp ebx,9 je is_kiave9_DK cmp ebx,10 je is_kiave10_DK cmp ebx,11 je is_kiave11_DK cmp ebx,12 je is_kiave12_DK cmp ebx,13 je is_kiave13_DK mov eax,0xFFFFFFFF ret is_kiave1_DK: mov eax,decodkiave1 ret is_kiave2_DK: mov eax,decodkiave2 ret is_kiave3_DK: mov eax,decodkiave3 ret is_kiave4_DK: mov eax,decodkiave4 ret is_kiave5_DK: mov eax,decodkiave5 ret is_kiave6_DK: mov eax,decodkiave6 ret is_kiave7_DK: mov eax,decodkiave7 ret is_kiave8_DK: mov eax,decodkiave8 ret is_kiave9_DK: mov eax,decodkiave9 ret is_kiave10_DK: mov eax,decodkiave10 ret is_kiave11_DK: mov eax,decodkiave11 ret is_kiave12_DK: mov eax,decodkiave12 ret is_kiave13_DK: mov eax,decodkiave13 ret fine_chiavi_in_seq_DK_ERRORE: ;qui mettere salto a gestione eventuale errore ; call errorizza fine_chiavi_in_seq_DK: ;e da qui si puo proseguire ok mov dword [P3_7],0 mov dword [P3_8],0 mov dword [P3_9],0 call pulisci_buffer_2recv call sistema_ultima_x_visual call pulisci_buffer_2recv cmp dword [mesg_estesi],0 ;jmp near vis_norm_fine_DK jne near vis_norm_fine_DK mov esi,mesg_pulito_0 inc esi call pulisci_buff_16_bytes mov esi,canale2_pulito call pulisci_con_space_8_bytes mov esi,canale2_pulito add esi,8 call pulisci_buff_16_bytes mov esi,mesg_pulito call pulisci_buff_480_bytes mov edi,mesg_pulito_0 mov esi,buff1_2K_defa inc edi inc edi inc esi ;superiamo i : iniziali mov ecx,16 cont_su_buf_pul1: mov al,[esi] cmp al,"!" je OK_su_buf_pul mov [edi],al inc esi inc edi dec ecx jnz cont_su_buf_pul1 jmp vis_norm_fine_DK_pre OK_su_buf_pul: ; jmp vis_nick_ch_DK add esi,10 mov ecx,120 OK_su_buf_pul_02: mov al,[esi] cmp al," " je ok_dest_DK_pul inc esi dec ecx jnz OK_su_buf_pul_02 jmp vis_norm_fine_DK_pre ok_dest_DK_pul: mov edi,canale2_pulito mov ecx,28 inc esi cont_ok_dest_DK_pul: mov eax,[esi] cmp eax,"PRIV" jne cont_ok_dest_DK_pul1 call sistema_PRIVMSG cont_ok_dest_DK_pul1: mov al,[esi] cmp al,":" je cont_ult_sist_DK_pre mov [edi],al inc edi inc esi dec ecx jnz cont_ok_dest_DK_pul jmp vis_norm_fine_DK_pre cont_ult_sist_DK_pre: inc esi ;inc esi mov edi,mesg_pulito mov ecx,480 cont_ult_sist_DK: mov al,">" mov [edi],al mov al,[esi] cmp al,0xa jbe ok_fine_nick_ch_DK mov [edi],al inc esi inc edi dec ecx jnz cont_ult_sist_DK jmp vis_norm_fine_DK_pre ok_fine_nick_ch_DK: mov al,0xd mov [edi],al inc edi mov al,0xa mov [edi],al mov edx,[Testata_msg_pul] add edx,[l_buff_da_DE_cryptare] add edx,3 ;0xd oxa e space separatore tra : primo char ;vis_nick_ch_DK: mov eax,4 mov ebx,1 mov ecx,mesg_pulito_0 ;buff1_2K_defa ;buffer_2recv ;mov edx,512 int 0x80 call pulisci_buffer_2recv jmp Loop1 vis_norm_fine_DK_pre: vis_norm_fine_DK: mov eax,4 mov ebx,1 mov ecx,buff1_2K_defa ;buffer_2recv mov edx,512 int 0x80 jmp Loop1 ;---------------------------------- ;mov eax,"DCOD" ;call visualizza ;Qui dobbiamo chiudere visualizzando il buffer decriptato ; e quindi: ;quando pronto eliminare i 2 commenti sotto ;call pulisci_buffer_2recv ;jmp Loop1 ;------------------------- visual_normale_NoK: ;------------------- ;prova ticks counts (times) ;pusha ;mov eax,43 ;mov ebx,struct_tms ;int 0x80 ;mov eax,[t_u] ;call errorizza ;mov eax,[t_s] ;call errorizza ;mov eax,[t_cu] ;call errorizza ;mov eax,[t_cs] ;call errorizza ;popa ;------------------ call get_time call aggiusta_time mov ecx,t_HHpre mov edx,12 call msg_gen mov eax,4 mov ebx,1 mov ecx,buffer_2recv mov edx,512 int 0x80 call pulisci_buffer_2recv ;call getkey jmp Loop1 pongroutine: ; call get_time ; call aggiusta_time ; mov ecx,t_HHpre ; mov edx,12 ; call msg_gen ; mov eax,4 ; mov ebx,1 ; mov ecx,buffer_2recv ; mov edx,512 ; int 0x80 mov eax,"PONG" mov ecx,buffer_2recv mov [ecx],eax mov eax,4 mov ebx,[sock] ;mov ecx,pong mov edx,512 ;512 ;[pong_l] int 0x80 ; call get_time ; call aggiusta_time ; mov ecx,t_HHpre ; mov edx,12 ; call msg_gen ; mov eax,"PONG" ; mov ecx,buffer_2recv ; mov [ecx],eax ; mov eax,4 ; mov ebx,1 ; anche a video [sock] ;mov ecx,pong ; mov edx,512 ;512 ;[pong_l] ; int 0x80 ; call ritardo call pulisci_buffer_2recv jmp Loop1 mov esi,buff1 ; call debugga call get_time call aggiusta_time mov ecx,buff_struc_time mov edx,42 call msg_gen jmp fine ;------------------------ fine_con_msg: mov ecx,msg_few_par mov edx,[msg_few_par_l] ;120 fine_con_msg_gia_settato: mov eax,4 mov ebx,1 int 0x80 ;------------------- fine: mov eax,6 ;chiudi file mov ebx,[sock] int 0x80 mov eax,1 mov ebx,0 int 80h ; Exit ;---------------------FINE------------------------------------------------ ;�������������������������������������������������������������������������������������������� ;�������������������������������������������������������������������������������������������� ;---------------ROUTINES------- (00)------------------------- getkey: ;entra senza parametri, torna in in AL 0 se nokey altrimenti keycode ;e torna in byte_rec una copia di AL pusha xor eax,eax xor ebx,ebx cdq mov ecx,byte_rec mov [ecx],al pusha inc ebx mov ecx,fdset mov [ecx],ebx xor esi,esi ;lea edi, [DATAOFF(timer)] mov edi,timer mov eax,0 ;1 secondo mov [edi],eax ;mov eax,1000 mov [byte edi+4],eax xor eax,eax mov al,142 int 0x80 dec eax popa jl returna js retquita mov ecx,buffer_2send_dopo add ecx,[quanti_bytes] mov dword [primo_byte],0 mov eax,1 add [quanti_bytes],eax mov eax,[quanti_bytes] cmp eax,1 jne pre_retquit mov [primo_byte],eax pre_retquit: cmp eax,480 jna pre_retquit_poi1 dec eax mov [quanti_bytes],eax ;ietta sangu coglione che batti piu di 480 charatteri ;call sound pre_retquit_poi1: mov al,3 mov edx,1 int 0x80 dec eax jz returna retquita: nop ; mov byte[ecx],0 ;"q" returna: mov al,[ecx] cmp al,0xA jne near dopo_return mov eax,[quanti_bytes] mov [l_buff_da_cryptare],eax mov eax,0 mov [quanti_bytes],eax mov ecx,buffer_2send_dopo mov al,[ecx] cmp al,"/" jne near return_dopo5 inc ecx mov eax,[ecx] mov esi,msg_acc mov [esi],eax mov ebx,eax cmp bx,"AK" je near is_ADKxx cmp bx,"DK" je near is_ADKxx cmp eax,"ACTC" je near is_SCOD cmp eax,"CODE" je near is_CODE cmp eax,"CPIN" je near is_CPIN cmp eax,"CSEQ" ;cambia sequenza kiavi je near is_SEQK cmp bx,"CP" je near is_CPxx cmp eax,"DEAC" je near is_UCOD cmp eax,"DEFK" ;senza parametri Mette le Kiavi di Default je near is_RSTK cmp eax,"RSEQ" ;reset sequenza di default je near is_DSEQ cmp eax,"DSEQ" ;reset sequenza di default je near is_DSEQ cmp eax,"EMSG" je near is_EMSG cmp eax,"HELP" je near is_CODEHELP cmp eax,"MSG2" je near is_MSG2 cmp eax,"RPIN" ;reset PIN CODE je near is_RPIN cmp eax,"RSTC" je near is_UCOD cmp eax,"RSTK" je near is_RSTK cmp eax,"SCOD" ;SET (Attiva) sessione CODEC je near is_SCOD cmp eax,"SEQK" ;cambia sequenza kiavi je near is_SEQK cmp eax,"SEQD" ;sequenza di default sinonimo di DSEQ je near is_DSEQ cmp eax,"SETC" ;SET (Attiva sessione CODEC = sinonimo di SCOD je near is_SCOD cmp eax,"UCOD" ;Unset (Disattiva) sessione CODEC je near is_UCOD cmp eax,"VERS" ;Versione.... e Copyright je near is_VERS cmp bx,"VK" ;VKnn Verifica Kiave nn je near is_VKxx cmp eax,"VPIN" ;Verifica Codice PIN je near is_VPIN cmp bx,"VP" ;VKnn Verifica Kiave nn je near is_VPxx cmp eax,"VSEQ" ;Verifica sequenza Keys je near is_VSEQ jmp manda_comando nop manda_comando: mov eax,4 mov ebx,[sock] ; anche a video [sock] mov ecx,buffer_2send_dopo inc ecx ;scartiamo la / mov edx,483 ;512 ;[pong_l] int 0x80 call get_time call aggiusta_time mov ecx,t_HHpre mov edx,12 call msg_gen mov eax,4 mov ebx,1 ; anche a video [sock] mov ecx,buffer_2send_dopo inc ecx ;scartiamo la / mov edx,483 ;512 ;[pong_l] int 0x80 jmp dopo_return_pre2 return_dopo5: mov ecx,buffer_2send_dopo mov al,[ecx] cmp al,0xA jbe near return_dopo5_noKript mov eax,[Kripta] cmp eax,0 je near return_dopo5_noKript cmp eax,1 jne near return_dopo5_noKript ;per maggior sicurezza, DEVE essere 1 per avviare CODEC ;----------------------------------------- si_deciso_isKripta_K: ;ed eccoci qui a decodificare le Keys in ordine inverso ;appena pronta SEQK (o KSEQ) sara' fatta secondo l'ordine ;stabilito da KSEQ ;call errorizza mov ebp,sequenza_Kiavi mov edx,0 mov ecx,13 call primo_passo_fase_K ;------------------------- mov esi,buff_vuoto_2mega mov [P3_7_p],esi mov [P3_8_p],esi mov [P3_9_p],esi inc esi mov [P3_7max_p],esi mov [P3_8max_p],esi mov [P3_9max_p],esi ;-------------------------- mov eax,[l_buff_da_cryptare] cmp eax,0 ja chiavi_in_seq_DK_K jmp near return_dopo5_noKript chiavi_in_seq_DK_K: mov ebx,[ebp+edx] call mettiK_su_eax_DK_K cmp eax,0xFFFFFFFF je near fine_chiavi_in_seq_DK_K ;ERROREEEEEEEEEEEEEE ;mov eax,decodkiave5 ;provvisorio pusha call eax popa add edx,4 dec ecx jnz chiavi_in_seq_DK_K ;-------------------------- mov ebx,[Ptr_2_buffKeys_attuale] xor ebx,[PIN_CODE] mov [buff1_2K_defa+2],ebx ;successivi 4 bytes = Ptr_2_buffer_Keys_precedente ;-------------------------- call ultimo_passo_K jmp fine_chiavi_in_seq_DK_K mettiK_su_eax_DK_K: cmp ebx,dword 1 je is_kiave1_DK_K cmp ebx,2 je is_kiave2_DK_K cmp ebx,3 je is_kiave3_DK_K cmp ebx,4 je is_kiave4_DK_K cmp ebx,5 je is_kiave5_DK_K cmp ebx,6 je is_kiave6_DK_K cmp ebx,7 je is_kiave7_DK_K cmp ebx,8 je is_kiave8_DK_K cmp ebx,9 je is_kiave9_DK_K cmp ebx,10 je is_kiave10_DK_K cmp ebx,11 je is_kiave11_DK_K cmp ebx,12 je is_kiave12_DK_K cmp ebx,13 je is_kiave13_DK_K mov eax,0xFFFFFFFF ret is_kiave1_DK_K: mov eax,codkiave1 ret is_kiave2_DK_K: mov eax,codkiave2 ret is_kiave3_DK_K: mov eax,codkiave3 ret is_kiave4_DK_K: mov eax,codkiave4 ret is_kiave5_DK_K: mov eax,codkiave5 ret is_kiave6_DK_K: mov eax,codkiave6 ret is_kiave7_DK_K: mov eax,codkiave7 ret is_kiave8_DK_K: mov eax,codkiave8 ret is_kiave9_DK_K: mov eax,codkiave9 ret is_kiave10_DK_K: mov eax,codkiave10 ret is_kiave11_DK_K: mov eax,codkiave11 ret is_kiave12_DK_K: mov eax,codkiave12 ret is_kiave13_DK_K: mov eax,codkiave13 ret fine_chiavi_in_seq_DK_ERRORE_K: ;qui mettere salto a gestione eventuale errore ;call errorizza fine_chiavi_in_seq_DK_K: ;e da qui si puo proseguire ok mov dword [P3_7],0 mov dword [P3_8],0 mov dword [P3_9],0 call pulisci_buffer_2recv ;call pulisci_buff1_2K_defa jmp Loop1 ;---------------------------------- return_dopo5_noKript: mov ecx,buffer_2send_dopo mov al,[ecx] cmp al,0xA jbe near dopo_return mov eax,4 mov ebx,[sock] ; anche a video [sock] mov ecx,buffer_2send mov edx,512 ;512 ;[pong_l] int 0x80 call get_time call aggiusta_time mov ecx,t_HHpre mov edx,12 call msg_gen mov eax,4 mov ebx,1 ; anche a video [sock] mov ecx,buffer_2send mov edx,512 ;512 ;[pong_l] int 0x80 dopo_return_pre2: mov ecx,buffer_2send_dopo mov al,0 mov edx,480 dopo_return_pre1: mov [ecx],al inc ecx dec edx jnz dopo_return_pre1 mov ax,0x0d0a mov [ecx],ax add ecx,2 mov [ecx],ax jmp dopo_return is_MSG2: add ecx,5 mov ebx,18 ;max 19 caratteri canale o nick mov edi,where_2_msg mov ebp,where_2_msg_K is_MSG2_d0: mov al,[ecx] cmp al,0x20 jbe is_MSG2_d1 mov [edi],al mov [ebp],al inc ecx inc edi inc ebp dec ebx jnz is_MSG2_d0 is_MSG2_d1: cmp ebx,18 je is_MSG2_d2 cmp ebx,0 je is_MSG2_d2 mov al,0x20 is_MSG2_dpre: mov [edi],al mov [ebp],al inc edi inc ebp dec ebx jnz is_MSG2_dpre is_MSG2_d2: mov ecx,buffer_2send_dopo mov al,"K" mov [ecx],al ; sostituiamo / con K mov eax,4 mov ebx,1 mov ecx,buffer_2send mov edx,60 ;512 ; confermiamo che ok MSG2 e'cambiato int 0x80 call pulisci_buffer_2send_dopo jmp dopo_return ;--------ROUTINE frammezza------------------- pulisci_buffer_2send_dopo: pusha mov ecx,buffer_2send_dopo mov edi,480 mov al,0 pul_buf_MSG2: ;jmp dopo_return mov [ecx],al inc ecx dec edi jnz pul_buf_MSG2 popa ret ;------------------------------------------ is_SCOD: mov [mesg_estesi],dword 0 mov edi,where_2_msg_K mov esi,where_2_msg mov ecx,5 is_SCOD_sistema_where2msg: mov eax,[esi] mov [edi],eax add esi,4 add edi,4 dec ecx jnz is_SCOD_sistema_where2msg mov dword [Kripta],1 call msg_comando_accettato call pulisci_buffer_2send_dopo jmp dopo_return is_UCOD: mov [mesg_estesi],dword 1 mov dword [Kripta],0 call msg_comando_accettato call pulisci_buffer_2send_dopo jmp dopo_return is_AK11: mov dword [act_K11],1 call msg_comando_accettato call pulisci_buffer_2send_dopo jmp dopo_return is_DK11: mov dword [act_K11],0 call msg_comando_accettato call pulisci_buffer_2send_dopo jmp dopo_return is_AK12: mov dword [act_K12],1 call msg_comando_accettato call pulisci_buffer_2send_dopo jmp dopo_return is_DK12: mov dword [act_K12],0 call msg_comando_accettato call pulisci_buffer_2send_dopo jmp dopo_return is_CODE: ;push eax add ecx,4 mov eax,[ecx] cmp eax,"HELP" jne vai_is_CODE ;pop eax jmp is_CODEHELP vai_is_CODE: cmp eax,"RSTK" je near is_RSTK ;qui il resto di CODExxxx ;inc ecx mov al,[ecx] cmp al,"C" je forse_FK cmp al,0x20 je forse_FK_sp jmp fine_is_CODE forse_FK: inc ecx forse_FK_sp: ;mov esi,K0u ;call debugga ;jmp fine inc ecx mov al,[ecx] cmp al,"F" je is_F cmp al,"K" je is_K jmp fine_is_CODE is_F: call is_F_sistema jmp fine_is_CODE is_K: call is_K_sistema fine_is_CODE: ;pop eax call msg_comando_accettato call pulisci_buffer_2send_dopo jmp dopo_return is_CODEHELP: mov eax,4 mov ebx,1 mov ecx,msg_HELP mov edx,[msg_HELP_l] int 0X80 jmp dopo_return ;METTERE qui altre is_XXXX dopo_return: ;mov al,[ecx] ; call errorizza mov [provv],al popa mov al,[provv] ret ;--------------------------------------- is_RSTK: call metti_chiavi_default call msg_comando_accettato call pulisci_buffer_2send_dopo jmp dopo_return ;---------------------------------------- is_VKxx: ;verifica le key bswap eax and eax,0x0F0F0F0F xor edx,edx xor ecx,ecx xor ebx,ebx mov cx,ax mov bl,ah xor eax,eax mov al,bl cmp al,9 ja is_VK_err cmp cl,9 ja is_VK_err mov bl,10 mul bl add al,cl mov cl,al xor ebx,ebx xor edx,edx mov bl,cl mov eax,ebx cmp eax,0 ;dobbiamo equipararlo a 10 jne va_dopo_VKxx mov eax,10 ;quindi lo settiamo K0=K10 va_dopo_VKxx: dec eax ;zero_based quindi x=n-1 mov ebx,2000000 mul ebx mov esi,K1a add esi,eax call debugga ;call errorizza ;call visualizza is_VK_err: call pulisci_buffer_2send_dopo jmp dopo_return ;--------------------- is_ADKxx: mov edi,ebx xor eax,eax xor edx,edx bswap ebx mov ax,bx mov al,bh ;xor ax,0xFF sub al,0x30 mov cl,10 mul cl mov ch,al mov ah,bl sub ah,0x30 add ch,ah xor eax,eax mov al,ch cmp al,13 ;12 ja fine_isAKxx_no_msg ;cmp al,1 ; ;je fine_isAKxx_no_msg cmp al,0 jne ok_vaiAK mov eax,10 ok_vaiAK: dec eax ;zero based mov ebx,4 mul ebx mov esi,act_K add esi,eax mov ebx,edi mov eax,1 cmp bx,"AK" je va_dopo_ADK mov eax,0 va_dopo_ADK: mov [esi],eax call msg_comando_accettato fine_isAKxx_no_msg: call pulisci_buffer_2send_dopo jmp dopo_return ;--------------------- is_CPxx: push ecx mov edi,ebx xor eax,eax xor edx,edx bswap ebx mov ax,bx mov al,bh ;xor ax,0xFF sub al,0x30 mov cl,10 mul cl mov ch,al mov ah,bl sub ah,0x30 add ch,ah xor eax,eax mov al,ch cmp al,13 ;12 ja near fine_isCPxx_no_msg ;cmp al,1 ; ;je fine_isAKxx_no_msg cmp al,0 jne ok_vaiCP mov eax,10 ok_vaiCP: ;dec eax ;zero based mov ebx,4 mul ebx ;call errorizza mov esi,PIN_COD_XX add esi,eax mov [PIN_PROVV_PTR],esi ;push esi ;(CALCOLA PIN_CODE_XX su eax ) e quindi: ;========================== pop ecx xor edi,edi xor eax,eax xor ebx,ebx xor edx,edx mov edx,6 add ecx,5 cont_is_PIN_XX: mov al,[ecx] sub al,0x30 cmp al,9 ja is_PIN_dopo1_XX inc ecx inc ebx dec edx jnz cont_is_PIN_XX is_PIN_dopo1_XX: cmp ebx,0 je fine_isCPxx_no_msg_dopo_pop ;fine_is_PIN_no_msg sub ecx,ebx xor edi,edi mov esi,10 xor edx,edx mov ebp,ebx ;dec ebx mol_PIN_XX: ;mov ebx,ebp xor eax,eax mov al,[ecx] sub al,0x30 dec ebp jz dopo_mol_PIN_XX mov ebx,ebp mov esi,10 mol_PIN_1_XX: mul esi xor edx,edx dec ebx jnz mol_PIN_1_XX add edi,eax inc ecx mov ebx,ebp jmp mol_PIN_XX dopo_mol_PIN_XX: add edi,eax mov esi,[PIN_PROVV_PTR] mov [esi],edi ;mov [PIN_CODE],edi mov eax,edi call errorizza fine_is_PIN_XX: ;============================ call msg_comando_accettato jmp fine_isCPxx_no_msg_dopo_pop fine_isCPxx_no_msg: pop ecx fine_isCPxx_no_msg_dopo_pop: call pulisci_buffer_2send_dopo jmp dopo_return ;---------------------------- is_VPxx: mov edi,ebx xor eax,eax xor edx,edx bswap ebx mov ax,bx mov al,bh ;xor ax,0xFF sub al,0x30 mov cl,10 mul cl mov ch,al mov ah,bl sub ah,0x30 add ch,ah xor eax,eax mov al,ch cmp al,13 ;12 ja fine_is_VPxx_no_msg ;cmp al,1 ; ;je fine_isAKxx_no_msg cmp al,0 jne ok_vaiVP mov eax,10 ok_vaiVP: dec eax ;zero based mov ebx,4 mul ebx ;call errorizza mov esi,PIN_COD_XX add esi,eax ;(CALCOLA PIN_CODE_XX su eax ) e quindi: ;========================== mov eax,[esi] call errorizza call msg_comando_accettato fine_is_VPxx_no_msg: call calcola_som_PIN_CODE call pulisci_buffer_2send_dopo jmp dopo_return ;--------------------- is_SEQK: ;serve a cambiare la sequenza delle kiavi add ecx,5 ;puntiamo alla prima cifra N di SEQK NNNNNNNNNN..NN xor edx,edx xor ebx,ebx xor eax,eax xor ebp,ebp xor edi,edi mov esi,10 mov al,[ecx] sub al,0x30 ;call errorizza cmp al,9 ja near fine_is_SEQK_no_msg cmp al,1 ja near fine_is_SEQK_no_msg mul esi mov ebp,eax xor eax,eax inc ecx mov al,[ecx] sub al,0x30 cmp al,9 ja near fine_is_SEQK_no_msg add ebp,eax ;n kiave 1 cmp ebp,13 ja near fine_is_SEQK_no_msg ;cmp ebp,1 ;je fine_is_SEQK_no_msg ;kiave1 inamovibile ;call errorizza inc ecx inc ecx xor eax,eax mov al,[ecx] sub al,0x30 cmp al,9 ja near fine_is_SEQK_no_msg cmp al,1 ja near fine_is_SEQK_no_msg mul esi mov edi,eax xor eax,eax inc ecx mov al,[ecx] sub al,0x30 cmp al,9 ja near fine_is_SEQK_no_msg add edi,eax ;n.kiave 2 cmp edi,13 ja near fine_is_SEQK_no_msg ;cmp edi,1 ;je fine_is_SEQK_no_msg ;call errorizza ;mov esi,sequenza_Kiavi mov ebx,sequenza_Kiavi mov ecx,13 cont_is_SEQK_2: mov eax,[ebx] cmp eax,ebp je is_k_ebp cmp eax,edi je is_k_edi cont_is_SEQK_3: ;add esi,4 add ebx,4 dec ecx jnz cont_is_SEQK_2 jmp fine_is_SEQK is_k_ebp: cmp edi,7 jne no_7 xor dword [provv_789],1 no_7: cmp edi,8 jne no_8 xor dword [provv_789],1 no_8: cmp edi,9 jne no_9 xor dword [provv_789],1 no_9: mov [ebx],edi jmp cont_is_SEQK_3 is_k_edi: cmp ebp,7 jne no_7_edi xor dword [provv_789],1 no_7_edi: cmp ebp,8 jne no_8_edi xor dword [provv_789],1 no_8_edi: cmp ebp,9 jne no_9_edi xor dword [provv_789],1 no_9_edi: mov [ebx],ebp jmp cont_is_SEQK_3 fine_is_SEQK: call msg_comando_accettato cmp dword [provv_789],1 jne fine_is_seq_no789 mov dword [provv_789],0 call invia_mesg_789 fine_is_seq_no789: fine_is_SEQK_no_msg: call pulisci_buffer_2send_dopo jmp dopo_return ;-------------------------------------- is_VSEQ: ;verifica sequenza call ripulisci_sequenze mov ebx,sequenza_Kiavi mov esi,seq_tutte mov edx,act_K mov ecx,13 cont_is_VSEQ: mov eax,[ebx] mov edi,esi call verifica_se_key_attiva cmp byte [key_is_attiva],1 jne dopo_is_seq pusha call ascizzaNsu_buff_2ch popa dopo_is_seq: ;call errorizza add ebx,4 add esi,5 dec ecx jnz cont_is_VSEQ jmp fine_VSEQ_pre ;---------- mov ebp,seq_attive mov edx,act_K01 mov ecx,1 cont_is_VSEQ_att: mov eax,[edx] cmp eax,1 jne dopo_is_seq_att mov edi,ebp pusha mov eax,ecx call ascizzaNsu_buff_2ch popa dopo_is_seq_att: ;call errorizza add edx,4 add ebp,5 inc ecx cmp ecx,13 jna cont_is_VSEQ_att ;ascizzaNsu_buff_2ch: ; entra con eax = valore da ascizzare ; edi = ptr su buff (2 bytes .. fino a 99) fine_VSEQ_pre: mov eax,4 mov ebx,1 mov ecx,mesg_seq_kiavi mov edx,[l_mesg_seq_kiavi] int 0x80 fine_VSEQ: call pulisci_buffer_2send_dopo jmp dopo_return ;------------------------------------------ is_CPIN: ;per cambiare il codice pin xor edi,edi xor eax,eax xor ebx,ebx xor edx,edx mov edx,6 add ecx,5 cont_is_PIN: mov al,[ecx] sub al,0x30 cmp al,9 ja is_PIN_dopo1 inc ecx inc ebx dec edx jnz cont_is_PIN is_PIN_dopo1: cmp ebx,0 je fine_is_PIN_no_msg sub ecx,ebx xor edi,edi mov esi,10 xor edx,edx mov ebp,ebx ;dec ebx mol_PIN: ;mov ebx,ebp xor eax,eax mov al,[ecx] sub al,0x30 dec ebp jz dopo_mol_PIN mov ebx,ebp mov esi,10 mol_PIN_1: mul esi xor edx,edx dec ebx jnz mol_PIN_1 add edi,eax inc ecx mov ebx,ebp jmp mol_PIN dopo_mol_PIN: add edi,eax mov [PIN_CODE],edi mov eax,edi call errorizza fine_is_PIN: ;call ; som_PIN_CODE call msg_comando_accettato fine_is_PIN_no_msg: call calcola_som_PIN_CODE call pulisci_buffer_2send_dopo jmp dopo_return ;--------------------------- is_RPIN: ;reset codici_pin ; rimette i codici pin di default call RPIN_ROUT jmp dopo_RPIN RPIN_ROUT: pusha mov esi,PIN_CODE_d mov edi,PIN_CODE mov ecx,14 cont_is_RPIN: mov eax,[esi] mov [edi],eax add esi,4 add edi,4 dec ecx jnz cont_is_RPIN popa ret dopo_RPIN: call msg_comando_accettato call pulisci_buffer_2send_dopo jmp dopo_return ;----------------------------- is_DSEQ: call sistema_sequenza_chiavi_default call msg_comando_accettato call pulisci_buffer_2send_dopo jmp dopo_return ;------------------------- is_VPIN: mov ecx,14 mov ebp,PIN_CODE mov edi,CPIN_GEN_msg add edi,6 ;CPIN_GEN_msg db "CPGEN XXXXXX",0x0a cont_is_VPIN: mov eax,[ebp] call ascizzaNsu_buff ;sistema_NUM_su_6bytes mov eax," " mov [edi],eax ;ripuliamo i primi 4 caratteri che la call preced. mette a 0000 add ebp,4 add edi,17 dec ecx jnz cont_is_VPIN mov eax,4 mov ebx,1 mov ecx,mesg_PIN_CODE mov edx,[l_mesg_PIN_CODE] int 0x80 ;------------------ mov ecx,14 mov ebp,PIN_CODE mov edi,som_CPIN_GEN_msg add edi,6 ;CPIN_GEN_msg db "CPGEN XXXXXX",0x0a cont_is_VPIN_som: xor eax,eax mov ebx,[ebp] mov edx,ebx and edx,0xff add eax,edx ror ebx,8 mov edx,ebx and edx,0xff add eax,edx ror ebx,8 mov edx,ebx and edx,0xff add eax,edx ror ebx,8 mov edx,ebx and edx,0xff add eax,edx call ascizzaNsu_buff ;sistema_NUM_su_6bytes mov eax," " mov bx," " mov [edi],eax ;ripuliamo i primi 4 caratteri che la call preced. mette a 0000 mov [edi+4],bx add ebp,4 add edi,17 dec ecx jnz cont_is_VPIN_som mov eax,4 mov ebx,1 mov ecx,mesg_som_PIN_CODE mov edx,[l_mesg_som_PIN_CODE] int 0x80 ;call errorizza ;call msg_comando_accettato call pulisci_buffer_2send_dopo jmp dopo_return ;--------------------------- is_VERS: mov eax,4 mov ebx,1 mov ecx,msg_vers mov edx,[l_msg_vers] int 0x80 call pulisci_buffer_2send_dopo jmp dopo_return ;--------------------------- is_EMSG: ;Pessaggi estesi ON | OF add ecx,5 mov ax,[ecx] cmp ax,"ON" je is_EMSG_on mov [mesg_estesi],dword 0 jmp fine_is_EMSG is_EMSG_on: mov [mesg_estesi],dword 1 fine_is_EMSG: call msg_comando_accettato call pulisci_buffer_2send_dopo jmp dopo_return ;--------------------------- ;������������������������������������������������������������������������������������������ ;������������������������������������������������������������������������������������������� ; ;codkiavi.asm ; sistema_sequenza_chiavi_default: pusha mov esi,sequenza_Kiavi_default mov edi,sequenza_Kiavi ;mov edx,0 mov ecx,13 cont_sist_seq_K: mov eax,[esi] mov [edi],eax add esi,4 add edi,4 dec ecx jnz cont_sist_seq_K popa ret ;----------------------------- metti_chiavi_default: pusha mov ebp,K1s mov ebx,[lK1s] mov edi,K1u call metti_chiave mov ebp,K1s mov ebx,[lK1s] mov edi,K1a call metti_chiave ;----------------------- mov ebp,K2s mov ebx,[lK2s] mov edi,K2u call metti_chiave mov ebp,K2s mov ebx,[lK2s] mov edi,K2a call metti_chiave ;----------------------- mov ebp,K3s mov ebx,[lK3s] mov edi,K3u call metti_chiave mov ebp,K3s mov ebx,[lK3s] mov edi,K3a call metti_chiave ;----------------------- mov ebp,K4s mov ebx,[lK4s] mov edi,K4u call metti_chiave mov ebp,K4s mov ebx,[lK4s] mov edi,K4a call metti_chiave ;----------------------- mov ebp,K5s mov ebx,[lK5s] mov edi,K5u call metti_chiave mov ebp,K5s mov ebx,[lK5s] mov edi,K5a call metti_chiave ;----------------------- mov ebp,K6s mov ebx,[lK6s] mov edi,K6u call metti_chiave mov ebp,K6s mov ebx,[lK6s] mov edi,K6a call metti_chiave ;----------------------- mov ebp,K7s mov ebx,[lK7s] mov edi,K7u call metti_chiave mov ebp,K7s mov ebx,[lK7s] mov edi,K7a call metti_chiave ;----------------------- mov ebp,K8s mov ebx,[lK8s] mov edi,K8u call metti_chiave mov ebp,K8s mov ebx,[lK8s] mov edi,K8a call metti_chiave ;----------------------- mov ebp,K9s mov ebx,[lK9s] mov edi,K9u call metti_chiave mov ebp,K9s mov ebx,[lK9s] mov edi,K9a call metti_chiave ;----------------------- mov ebp,K0s mov ebx,[lK0s] mov edi,K0u call metti_chiave mov ebp,K0s mov ebx,[lK0s] mov edi,K0a call metti_chiave ;----------------------- mov ebp,K11s mov ebx,[lK11s] mov edi,K11u call metti_chiave mov ebp,K11s mov ebx,[lK11s] mov edi,K11a call metti_chiave ;----------------------- mov ebp,K12s mov ebx,[lK12s] mov edi,K12u call metti_chiave mov ebp,K12s mov ebx,[lK12s] mov edi,K12a call metti_chiave ;----------------------- mov ebp,K13s mov ebx,[lK13s] mov edi,K13u call metti_chiave mov ebp,K13s mov ebx,[lK13s] mov edi,K13a call metti_chiave ;----------------------- ;mov esi,K0u ;call debugga ;jmp fine popa ret ;-------------------------------- metti_chiave: mov edx,2000000 mov ecx,ebx push ebp ; mov esi,ebp add edx,1 metti_chiave_1: dec edx jz metti_chiave_fine mov al,[ebp] mov [edi],al inc ebp inc edi dec ecx jnz metti_chiave_1 mov ecx,ebx pop ebp push ebp ;mov esi,ebp jmp metti_chiave_1 metti_chiave_fine: pop ebp ret ;-------------------------------- is_F_sistema: ;qui entra con ecx che punta a F di Fxxxxxxxxxxxxx pusha mov ebx,0 cont_is_F: inc ebx cmp ebx,13 jae near fine_is_F inc ecx mov al,[ecx] cmp al,0x20 jbe near fine_is_F cmp al,"i" je cont_is_F cmp al,"d" je is_dF ;cmp al,"u" ;je is_uK cmp al,"n" je is_nF jmp fine_is_F is_dF: xor edx,edx dec ebx mov eax,2000000 mul ebx mov ebp,K1u add ebp,eax mov edi,K1a add edi,eax mov ebx,2000000 ;mov ebp,K11s ;mov ebx,[lK11s] ;mov edi,K11u ;cmp dword [err],0 ;jne near fine_F_err call metti_chiave jmp fine_is_F is_nF: ;impostare Kna con valore nuovo digitato di seguito mov dword [offset_inizio_F],0 mov dword [offset_fine_F],0 dec ebx mov eax,2000000 mul ebx push eax ;da riprendere e addare a edi xor ebx,ebx cont_is_nF: inc ecx pusha mov edi,file_name_cod mov al,0 mov edx,256 cont_pul_F: mov [edi],al ;azzeriamo filename inc edi dec edx jnz cont_pul_F ;prendere nome_file mov edi,file_name_cod mov edx,256 cont_nome_file_F_nonC: inc ebx ;mov eax,ebx ;call errorizza dec edx jz near fine_F_err inc ecx mov al,[ecx] cmp al,0x20 jbe ok_nomefile_F mov [edi],al inc edi jmp cont_nome_file_F_nonC ok_nomefile_F: push ecx mov [lungh_nome_file_F],ebx mov ecx,[lungh_nome_file_F] mov ebx,file_name_cod call leggi_file_F pop ecx mov dword [no_s],0 mov dword [no_e],0 ;cerchiamo ora -s e -e mov al,[ecx] cmp al,0xa je near fine_F_se_std inc ecx xor ebp,ebp mov ebx,256 mov al,[ecx] cmp al,"-" jne near fine_F_se_std inc ecx mov al,[ecx] cmp al,"e" je near solo_e_forse cmp al,"s" jne near fine_F_se_std is_s_F: mov dword [no_s],1 mov edx,7 ;fino a 7-1 = 6 cifre xor ebx,ebx xor eax,eax inc ecx ;superiamo lo spazio tra -s NNNNNN is_s_F1: inc ecx mov al,[ecx] sub al,0x30 cmp al,9 ja near fine_num_s ;jc fine_num_s inc ebx cmp ebx,edx ;max 6 cifre je near fine_F_se_std jmp is_s_F1 fine_num_s: cmp ebx,0 je near fine_F_se_std ;in ebx abbiamo il numero di cifre del numero -s sub ecx,ebx xor edx,edx xor esi,esi xor ebp,ebp mol_10_F_pre: dec ebx jz dopo_mol10_F xor eax,eax mov al,[ecx] sub al,0x30 mov esi,10 mov edi,ebx mol_10_F: mul esi dec edi jnz mol_10_F add ebp,eax inc ecx jmp mol_10_F_pre dopo_mol10_F: xor eax,eax mov al,[ecx] sub al,0x30 add ebp,eax mov esi,[lungh_buff_file_F] ;controlliamo che lungh_buff_file > di ebp pointer cmp ebp,esi ja near fine_F_se_std mov eax,ebp mov [offset_inizio_F],ebp ;jmp dopo_solo_e_forse ;call errorizza add ecx,2 ;push eax ;mov eax,[ecx] ;call visualizza ;pop eax mov al,[ecx] cmp al,"-" jne near fine_F_se_std inc ecx mov al,[ecx] cmp al,"e" jne near fine_F_se_std jmp solo_e_forse_si solo_e_forse: mov dword [no_e],1 solo_e_forse_si: inc ecx mov al,[ecx] cmp al," " jne near fine_F_se_std ;========================= is_s_F1_e: inc ecx mov al,[ecx] sub al,0x30 cmp al,9 ja fine_num_s_e ;jc fine_num_s inc ebx cmp ebx,edx ;max 6 cifre je near fine_F_se_std jmp is_s_F1_e fine_num_s_e: cmp ebx,0 je near fine_F_se_std ;in ebx abbiamo il numero di cifre del numero -s sub ecx,ebx xor edx,edx xor esi,esi xor ebp,ebp mol_10_F_pre_e: dec ebx jz dopo_mol10_F_e xor eax,eax mov al,[ecx] sub al,0x30 mov esi,10 mov edi,ebx mol_10_F_e: mul esi dec edi jnz mol_10_F_e add ebp,eax inc ecx jmp mol_10_F_pre_e dopo_mol10_F_e: xor eax,eax mov al,[ecx] sub al,0x30 add ebp,eax mov edi,[offset_inizio_F] cmp ebp,edi jna fine_F_se_std add ebp,edi mov esi,[lungh_buff_file_F] ;controlliamo che lungh_buff_file > di ebp pointer cmp ebp,esi ja fine_F_se_std mov eax,ebp mov [offset_fine_F],ebp ;======================== ;ora cerchiamo e popa ;ora prendiamo i numeri ;mov ebp,K1s ;mov ebx,[lK1s] ;mov edi,K1u ;call metti_chiave ;mov dword [err],1 ;jmp fine_F_err vai_avanti_giusto_F: cmp dword [no_s],1 je vai_avanti_giusto_F_dopo cmp dword [no_e],0 ;deve esserci s | ( s && e ) je vai_avanti_giusto_F_dopo mov dword [err],1 ;jmp fine_F_err vai_avanti_giusto_F_dopo: mov esi,[offset_inizio_F] mov ebx,[offset_fine_F] sub ebx,esi mov ebp,buff1 add ebp,esi ; in ebx abbiamo gia la lunghezza della chiave pop eax mov edi,K1a add edi,eax cmp dword [err],0 jne fine_F_err call metti_chiave ;mov esi,K5a ;call debugga jmp fine_is_F fine_F_se_std: popa mov ebp,buff1 add ebp,[offset_inizio_F] mov ebx,[lungh_buff_file_F] pop eax mov edi,K1a add edi,eax ;---------------- cmp dword [no_s],1 je vai_avanti_giusto_F_dopo_dopo cmp dword [no_e],0 ;deve esserci s | ( s && e ) je vai_avanti_giusto_F_dopo_dopo mov dword [err],1 ;--------------------- vai_avanti_giusto_F_dopo_dopo: cmp dword [err],0 jne fine_F_err call metti_chiave ;mov esi,K4a ;call debugga ;jmp fine jmp fine_is_F fine_F_err: ;qui mettere messaggio errore mov ecx,msg_err_CODE mov edx,[msg_err_CODE_l] call msg_gen fine_is_F: mov eax,0 cmp eax,[lungh_buff_file_F] jne fine_fine_is_F jmp fine_fine_is_F mov ecx,msg_err_CODE mov edx,[msg_err_CODE_l] call msg_gen fine_fine_is_F: mov eax,[lungh_buff_file_F] call errorizza popa ret ;--------------------------------- is_K_sistema: ;qui entra con ecx che punta a K di Kxxxxxxxxxxxxx pusha ;max 12 keys mov ebx,0 cont_is_K: inc ebx cmp ebx,13 jae near fine_is_K inc ecx mov al,[ecx] cmp al,0x20 jbe near fine_is_K cmp al,"i" je cont_is_K cmp al,"d" je is_dK ;cmp al,"u" ;je is_uK cmp al,"n" je is_nK jmp fine_is_K is_dK: xor edx,edx dec ebx mov eax,2000000 mul ebx mov ebp,K1u add ebp,eax mov edi,K1a add edi,eax mov ebx,2000000 ;mov ebp,K11s ;mov ebx,[lK11s] ;mov edi,K11u call metti_chiave jmp fine_is_K is_nK: ;impostare Kna con valore nuovo digitato di seguito dec ebx mov eax,2000000 mul ebx push eax ;da riprendere e addare a edi push ecx xor ebx,ebx cont_is_nK: inc ecx mov al,[ecx] inc ebx cmp ebx,480 ja fine_Kpop ;c'e' errore quindi esci senza azioni cmp al,0xa jne cont_is_nK ;e qui abbiamo ebx lungh. pop ebp ;il valore ex di ecx inc ebp inc ebp dec ebx dec ebx ; in ebx abbiamo gia la lunghezza della chiave pop eax mov edi,K1a add edi,eax call metti_chiave ;vedere quanti caratteri ci sono di kiave immediata ;e passarli come parametri ptr ---> ebp e su ebx=numero_chars ;mov ebp,K11s ;mov ebx,[lK11s] ;mov edi,K11u ;call metti_chiave ;qui vediamo se ha funzionato jmp fine_is_K fine_Kpop: pop eax fine_is_K: ; mov eax,[primo_pass] ; cmp eax,1 ; jne oltre_K ; mov esi,K4a ; call debugga ; jmp fine ;oltre_K: ; mov eax,1 ; mov [primo_pass],eax popa ret ;---------------------------------______________________ primo_passo_fase_K: pusha call pulisci_buff1_2K_defa call randomizza mov [Ptr_2_buffKeys_attuale],eax ;nuova funzione randomizza call calcola_som_PIN_CODE mov ebx,[l_buff_da_cryptare] ; lunghezza messaggio (una copia di quanti_bytes ; prima di essere azzerato dec ebx ;leviamo il carattere 0xA mov [l_buff_da_cryptare],ebx add eax,ebx mov [lungh_kiave_attuale],eax mov [buff1_2K_defa],bx ; primi 2 bytes = Lungh messaggio mov ebx,[Ptr_2_buffKeys_attuale] xor ebx,[PIN_CODE] mov [buff1_2K_defa+2],ebx ;successivi 4 bytes = Ptr_2_buffer_Keys_precedente ;---------------------------------------- mov ecx,[l_buff_da_cryptare] inc ecx ;compreso 0xa mov esi,buffer_2send_dopo mov [P1i],esi mov [P1],esi mov edi,buff1_2K_defa add edi,6 ;dopo 2+4 bytes mov [P2],edi mov edx,[lungh_kiave_attuale] mov [L2],edx mov esi,[P1i] ;esi gia settato a mov edi,[P2] ;edi era cmq gia settato a fuffer_2kdefa + 2+4 char iniziali ;mettiamo buffer_2sendopo to buffer_2Kdefa ;inc ecx cont_P600K1_prima_fase_K: mov al,[esi] mov [edi],al inc esi inc edi dec ecx jnz cont_P600K1_prima_fase_K ;--------------------------------------------- ; call allinea_P2_2_P1 popa ret ;------------------------------------------------------- codkiave1: pusha ;qui inserire le routines da master mov eax,[act_K01] cmp eax,1 jne near fine_codkiave1 mov eax,[PIN_COD01] xor [Ptr_2_buffKeys_attuale],eax ;mov eax,"K 01" ;call visualizza ;popa ;provvisorio ;ret ;provvisorio ;jmp fine_codkiave1 ;provvisorio ; Da eseguire all'inizio di codKiave1 prima di act_K01 ; variabili da tenere presenti ; A) PIN_CODE ; B) Ptr_2_buffKeys Pointer_preced a Buffer_keys (da 1 a 1000000) ;generare un numero random da 4 bytes da usare come individuatore di codificatore di 0-A-D ; Algoritmo da usare: ; 1) lungh_kiave_attuale = l_buff_da_cryptare + Cod_PIN ; alla fine di kript_K1 eseguire le seguenti azioni: ; - ; 2) -salvare una copia di Ptr_2_buffKeys_attuale prima di aggiornarlo chiamandolo ; Ptr_2_buffKeys_provvisorio ; - aggiornare: ; 3) Ptr_2_buffKeys_attuale = Ptr_2_buffKeys_precedente + lungh_kiave_attuale ; 4) - se Ptr_2_buffKeys_attuale > 1000000 ----> ; Ptr_2_buffKeys_attuale = Ptr_2_buffKeys_attuale - 1000000 ; ; sul Buff_da_inviare scrivere: ; 5) PRIVMSG Def_chan :XXYYYY ;dove: XX = l_buff_da_cryptare (2 bytes, numero puro) ; YYYY = Ptr2_buffKeys_precedente ;ERANO QUIIIIIIIIIIII vai_k1_pre_ok_lmsg: ok_ptr_prossimo_msg: ;mov [Ptr_2_buffKeys_attuale],ebx ;-------------- mov esi,buffer_2send_dopo mov [P1i],esi mov [P1],esi mov edi,buff1_2K_defa add edi,6 ;dopo 2+4 bytes mov [P2],edi mov edx,[lungh_kiave_attuale] mov [L2],edx mov ebp,K1a ;kiave1 ;--------------------------------- mov eax,[som_PIN_COD01] add eax,[Ptr_2_buffKeys_attuale] ;--------------------------------- add ebp,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] xor ebp,[PIN_COD01] mov [P3i],ebp mov [P3max],ebp add [P3max],edx add dword [P3max],5000 ;���������������������������� mov edx,ebp ;ebx=P3v mov ecx,[l_buff_da_cryptare] ;dec ecx mov [L1],ecx mov [P1max],ecx add [P1max],esi mov [P1i],esi ;da ora esi=P1v sist_buff_12345: mov bl,[edx] ;5 mov bh,[edx+1] primo_char_K1: mov al,[esi] ;10 cmp al,bl ;20 je P100K1 ; uguali_al_bl ; goto 100 cmp al,bh ;30 je P200K1 ; uguali_al_bh ; goto 200 linea40: inc esi ;40 P1v=P1v+1 cmp esi,[P1max] ;50 jae P500K1 ;non_ugiuali_al,bl-bh ; goto 500 jmp primo_char_K1 ; goto 20 P100K1: mov [esi],bh ;100 al= bh inc esi ;110 P1v = P1v +1 cmp esi,[P1max] ;120 If P1v > P1max then 500 jae P500K1 jmp primo_char_K1 ;130 goto 10 P200K1: mov [esi],bl ;200 al=bl inc esi ;210 P1v = P1v+1 cmp esi,[P1max] ;220 If P1v > P1max then 500 jae P500K1 jmp primo_char_K1 ;230 goto 10 P500K1: ;ok siamo fuori sistemato il buffer inc edx cmp edx,[P3max] jae P600K1 inc edx cmp edx,[P3max] jae P600K1 mov esi,[P1i] jmp sist_buff_12345 P600K1: mov ecx,[l_buff_da_cryptare] inc ecx ;compreso 0xa mov esi,[P1i] ;esi gia settato a mov edi,[P2] ;edi era cmq gia settato a fuffer_2kdefa + 2+4 char iniziali ;mettiamo buffer_2sendopo to buffer_2Kdefa ;inc ecx cont_P600K1: mov al,[esi] mov [edi],al inc esi inc edi dec ecx jnz cont_P600K1 ;finiu ;mov esi,buff1_2K_defa ;buffer_2send_dopo ;buff1_2K_defa ;call debugga ;----------- ;pusha ;mov edx,[l_header] ;add edx,[l_buff_da_cryptare] ;add edx,9 ;mov eax,4 ;mov ebx,1 ;mov ecx,buff1_2K_defa ;dec ecx ;mov edx,512 ;int 0x80 ;popa ;--------------- ;============== ;mov esi,[P1] ;add esi,[l_header] ;mov eax,esi ;call visualizza ;mov esi,[P2] ;add esi,[l_header] ;mov eax,esi ;call visualizza ;============== fine_codkiave1: sub dword [P3max],5000 ;���������������������������� popa ret ;--------------------------------- codkiave2: pusha mov eax,[act_K02] cmp eax,1 jne near fine_codkiave2 mov eax,[PIN_COD02] xor [Ptr_2_buffKeys_attuale],eax ; mov eax,"K 02" ;call visualizza ;call visualizza ; vediamo in che buffer abbiamo il messaggio consegnato da K01 ;abbiamo in [P1i] buffer_2send_dopo da----> mov esi,buffer_2send_dopo ;abbiamo in [P2] buff1_2K_defa da ----> mov edi,buff1_2K_defa ; QUINDI ALLINEATI con: ;add edi,6 ;dopo 2+4 bytes ;e quindi mov [P2],edi ; QUINDI ALLINEATI CON: ;mov ecx,[l_buff_da_cryptare] ;mov esi,[P1i] ;esi gia settato a ;mov edi,[P2] ;edi era cmq gia settato a fuffer_2kdefa + 2+4 char iniziali ; inoltre far riferimento a: ; l_header ; l_buff_da_cryptare = lunghezza messaggio attuale ; Ptr_2_buffKeys_precedente = quello gia scritto nei 4 bytes del messaggio ; som_PIN_CODE il pin code per costruire la lungh chiave att ;sistemiamoli nei registri: ;mov edi,[P1i] ; qui il msg SENZA i 2+4 bytes mov esi,[P2] ;[P2] ; qui buff1_2K_defa = il msg prov da K01 con i 2+4 bytes ; no add esi,[l_header] ;add esi,28 ;allineati dopo "PRIVMSG.... Nick|#Chan..... :" ;add esi,6 ;2+4 bytes mov [P1],esi ;buffer_2send_dopo usiamo al solito P1 e P1max mov ecx,[l_buff_da_cryptare] ;dec ecx ;leviamo 0xa mov [l_buff_da_cryptare],ecx add esi,ecx mov [P1max],esi mov esi,[P1] mov edx,K2a mov ebp,[Ptr_2_buffKeys_attuale] mov eax,[som_PIN_COD02] ;--------------------------------- add ebp,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] add edx,ebp xor edx,[PIN_COD02] mov [P3],edx mov ecx,[l_buff_da_cryptare] add edx,ecx mov eax,[som_PIN_COD02] ;[som_PIN_CODE] add edx,eax mov [P3max],edx mov edx,[P3] ;dec edx ;0 based mov ecx,480 ;max 480 caaratteri call xora_K02 ;come call da usare anche per decodifica jmp fine_codkiave2_pre ;--------------- xora_K02: mov al,[esi] mov ah,[edx] xor al,ah mov [esi],al ;rimettiamolo xorato inc esi cmp esi,[P1max] jae K100_K02 xora_K02_dopo: inc edx cmp edx,[P3max] je K600_K02 ;fine dec ecx jnz xora_K02 K100_K02: mov esi,[P1] jmp xora_K02_dopo K600_K02: ret ;----------------- fine_codkiave2_pre: ;preparare buffer per prossima key o e' gia pronto?? ;mov esi,[P1] ;buffer_2send_dopo call allinea_P1_2_P2 mov esi,buffer_2send_dopo mov [P1i],esi mov [P1],esi fine_codkiave2: popa ret ;--------------------------------- codkiave3: pusha mov eax,[act_K03] cmp eax,1 jne near fine_codkiave3 mov eax,[PIN_COD03] xor [Ptr_2_buffKeys_attuale],eax mov ecx,[l_buff_da_cryptare] cmp ecx,1 jna near fine_codkiave3 ; |------------------------------:Messaggio.............| ;buffer_2_send -----^ buffer_2send_dopo = P1 -----^ ; |------------------------:LmCodkMessaggio.............| ;buff_crypt_start --^ buff1_2K_defa -----^ ^---P2 ; |----------------------------------------i----------------f--------------| ; Kna--^ Ptr_2_buffKeys_attuale= P3---^ ^---P3max ;-------------------Il messaggio---------------- mov esi,buff1_2K_defa ;buffer_2send_dopo add esi,6 ;mov esi,[P2] ;=========EV.te da ripristinare================== ;--------------------La chiave------------------ mov edx,K3a ;la chiave 3 add edx,[Ptr_2_buffKeys_attuale] mov eax,[som_PIN_COD03] ;--------------------------------- add edx,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] xor edx,[PIN_COD03] mov [P3],edx ;-------------------------------------------- ;=============================================== add edx,ecx dec ecx ;mettiamolo zero_based mov eax,[som_PIN_COD03] add edx,eax mov [P3max],edx ;P3max = base_addr_attuale+lungh_mesg+som_PIN_CODE mov edx,[P3] ;base_addr_attuale ;----------------------------------------------- ;xor,ecx,ecx inizia_K3: xor ebx,ebx mov bl,[edx] pre_va_oltre_K3: cmp ebx,ecx ;[l_buff_da_cryptare] jb va_oltre_K3 sub ebx,ecx jmp pre_va_oltre_K3 va_oltre_K3: mov ebp,ebx xor ebx,ebx mov bl,[edx+1] pre_va_oltre_K3_B2: cmp ebx,ecx ;[l_buff_da_cryptare] jb va_oltre_K3_B2 sub ebx,ecx jmp pre_va_oltre_K3_B2 va_oltre_K3_B2: mov al,[esi+ebp] mov ah,[esi+ebx] mov [esi+ebp],ah mov [esi+ebx],al inc edx cmp edx,[P3max] jna inizia_K3 ;------------ ; gia finito, sistemiamo qui anche il buffer di P2 ; rendiamo identico P2 a P1 ; ; fine_codkiave3_pre: call allinea_P1_2_P2 fine_codkiave3: popa ret ;--------------------------------- codkiave4: pusha mov eax,[act_K04] cmp eax,1 jne near fine_codkiave4 mov eax,[PIN_COD04] xor [Ptr_2_buffKeys_attuale],eax ;jmp fine_codkiave4 ;mov eax,"K 04" ;call visualizza ; Come chiave4 viene effettuato un doppio taglio con doppia inversione sui bit dei bytes individuati dai bit di kiave4, esempio: ;kiave4 (bit) 0100 0010 ;frase ???????? = (bit) abcdwxyz abcdwxyz abcdwxyz abcdwxyz abcdwxyz abcdwxyz abcdwxyz abcdwxyz ;dopo kiave4 sara': abcdwxyz badcxwzy abcdwxyz abcdwxyz abcdwxyz abcdwxyz badcxwzy abcdwxyz ;Se il bit vale zero invece fara' effettuare al byte corrispondente rotazione di 1 bit a destra ;alla fine per effetto di kiave4: ; abcdwxyz badcxwzy abcdwxyz abcdwxyz abcdwxyz abcdwxyz abcdwxyz abcdwxyz diventera': ; zabcdwxy adcxwzya zabcdwxy zabcdwxy zabcdwxy zabcdwxy badcxwzy zabcdwxy ;-------------------Il messaggio---------------- mov esi,buff1_2K_defa ;buffer_2send_dopo add esi,6 mov [P1],esi add esi,[l_buff_da_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi ;--------------------La chiave------------------ mov edx,K4a ;la chiave 4 add edx,[Ptr_2_buffKeys_attuale] mov eax,[som_PIN_COD04] add edx,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] xor edx,[PIN_COD04] mov [P3],edx mov ecx,[l_buff_da_cryptare] cmp ecx,0 jna near fine_codkiave4 ;dec ecx ;mettiamolo zero_based add edx,ecx ;dec ecx ;mettiamolo zero_based mov eax,[som_PIN_COD04] add edx,eax ;inc edx ;dec edx ;P3max vero mov [P3max],edx ;P3max = base_addr_attuale+lungh_mesg+som_PIN_CODE mov edx,[P3] ;base_addr_attuale ;----------------------------------------------- mov esi,[P1] inizia_K4: mov bh,10000000b ;mov cl,8 xor eax,eax K4_va_10: mov bl,[edx] mov al,[esi] and bl,bh jz va_K4_noswap call opera_su_al_K4 ;va_a_swappare_al mov [esi],al jmp K4_50 va_K4_noswap: ror al,1 mov [esi],al K4_50: inc esi cmp esi,[P1max] jna K4_100 mov esi,[P1] inc edx cmp edx,[P3max] ja fine_codkiave4_pre jmp inizia_K4 K4_100: clc shr bh,1 cmp bh,0 je K4_200 ;jc K4_200 ;dec cl jmp K4_va_10 K4_200: inc edx cmp edx,[P3max] ja fine_codkiave4_pre jmp inizia_K4 fine_codkiave4_pre: cmp esi,[P1] jne dopo_dopo_dopo_K4_01 dopo_FcK4_01: mov esi,[P1max] mov al,[esi] ;rol al,1 mov [esi],al ;------------- jmp dopo_dopo_dopo_K4_01 dopodopoK4_01: dopo_dopo_dopo_K4_01: ;-------da qui in poi OK--------------- mov esi,[P1] add esi,[l_buff_da_cryptare] mov al,0xa mov [esi],al mov esi,[P1max] inc esi mov [P1max],esi call allinea_P1_2_P2 fine_codkiave4: popa ret ;-------------------------------------------------------------------------- codkiave5: pusha mov eax,[act_K05] cmp eax,1 jne near fine_codkiave5 mov ecx,[l_buff_da_cryptare] cmp ecx,1 jna near fine_decodkiave5 ;mov eax,"K 05" ;call visualizza mov eax,[PIN_COD05] xor [Ptr_2_buffKeys_attuale],eax ;-------------------Il messaggio---------------- mov esi,buff1_2K_defa ;buffer_2send_dopo add esi,6 mov [P1],esi add esi,[l_buff_da_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi mov esi,[P1] ;mov esi,[P2] ;=========EV.te da ripristinare================== ;--------------------La chiave------------------ mov edx,K5a ;la chiave 3 add edx,[Ptr_2_buffKeys_attuale] mov eax,[som_PIN_COD05] ;--------------------------------- add edx,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] xor edx,[PIN_COD05] mov [P3],edx ;-------------------------------------------- ;=============================================== mov ecx,[l_buff_da_cryptare] cmp ecx,1 jna near fine_codkiave5_pre2 add edx,ecx dec ecx ;mettiamolo zero_based mov eax,[som_PIN_COD05] add edx,eax mov [P3max],edx ;P3max = base_addr_attuale+lungh_mesg+som_PIN_CODE mov edx,[P3] ;base_addr_attuale ;----------------------------------------------- inizia_K5: xor ebx,ebx mov bl,[edx] mov al,[esi] inizia_K5_01: add al,bl mov [esi],al inc esi cmp esi,[P1max] ja K5_2 inc edx cmp edx,[P3max] jna inizia_K5 jmp fine_codkiave5_pre K5_2: mov esi,[P1] jmp inizia_K5 fine_codkiave5_pre: call allinea_P1_2_P2 mov esi,[P1] add esi,[l_buff_da_cryptare] mov al,0xa mov [esi],al fine_codkiave5_pre2: mov esi,[P1max] inc esi mov [P1max],esi fine_codkiave5: popa ret ;--------------------------------- codkiave6: pusha mov eax,[act_K06] cmp eax,1 jne near fine_codkiave6 ;mov eax,"K 06" ;call visualizza mov eax,[PIN_COD06] xor [Ptr_2_buffKeys_attuale],eax ;jmp fine_codkiave6 ;PROVVISORIOOOOOO!!!!!!!!!!!!! ;salto da eliminare appena pronta la decodifica di K6 ;-------------------Il messaggio---------------- mov esi,buff1_2K_defa ;buffer_2send_dopo add esi,6 mov [P1],esi add esi,[l_buff_da_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi mov esi,[P1] ;mov esi,[P2] ;=========EV.te da ripristinare================== ;--------------------La chiave------------------ mov edx,K6a ;la chiave add edx,[Ptr_2_buffKeys_attuale] mov eax,[som_PIN_COD06] ;--------------------------------- add edx,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] xor edx,[PIN_COD06] mov [P3],edx ;-------------------------------------------- ;=============================================== mov ecx,[l_buff_da_cryptare] cmp ecx,0 jna near fine_codkiave6 add edx,ecx dec ecx ;mettiamolo zero_based mov eax,[som_PIN_COD06] add edx,eax mov [P3max],edx ;P3max = base_addr_attuale+lungh_mesg+som_PIN_CODE mov edx,[P3] ;base_addr_attuale ;----------------------------------------------- inizia_K6: xor ecx,ecx ;esi ptr to >....123456.......... messaggio ;edx ptr to >...c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14.... ; ror al,cl ; ; 1 2 ; 1 2 3 ; 1 2 3 4 ; 1 2 3 4 5 ; 1 2 3 4 5 6 ; 1 ; 1 ; 1 ; 1 ; 1 c1 ror al , cl ; 1 2 ; 1 2 ; 1 2 ; 1 2 ; 1 2 c2 ror ax , cl ; 2 ; 2 ; 1 2 3 4 ; 1 2 3 4 ; 1 2 3 4 c3 ror eax , cl ; 2 3 ; 2 ; 2 ; 2 c4 ; 3 ; 2 3 ; 2 3 ; 2 3 c5 ; 3 ; 2 3 4 5 ; 2 3 4 5 c6 ; 3 4 ; 3 ; 3 c7 ; 4 ; 3 4 ; 3 4 c8 ; 4 ; 3 4 5 6 c9 ; 4 5 ; 4 c10 ; 5 ; 4 5 c11 ; 5 c12 ; 5 6 c13 " ; 6 c14 ;Lm = Lunghezza messaggio ; G_da4 = Lm - 3 ; G_da2 = Lm - 1 ; G_da1 = Lm ; Gtotali = P3max-P3 = Lm-3 + Lm -2 + Lm = 3*Lm -(3+1) NO!!!! non vale per Lm = 1 o 2 mov cl,[edx] blocco4bytes_K6_pre: mov al,[esi] ;[1].2.3.4.5 ror al,byte cl mov [esi],al inc edx ;il prossimo char come chiave mov cl,[edx] blocco4bytes_K6: ;--------primo blocco 4 bytes----------- add esi,1 cmp esi,[P1max] ja fine_codkiave6_pre ;fine messaggio e codifica sub esi,1 ;roimettiamolo come prima mov ax,[esi] ;[12].3.4.5 ror ax,byte cl mov [esi],ax inc edx mov cl,[edx] add esi,3 cmp esi,[P1max] ja meno_di_4_K6 sub esi,3 mov eax,[esi] ;[1234].5 ror eax,byte cl mov [esi],eax inc esi inc edx mov cl,[edx] jmp blocco4bytes_K6_pre meno_di_4_K6: sub esi,3 inc esi jmp inizia_K6 ;----------------------- fine_codkiave6_pre: mov esi,[P1] add esi,[l_buff_da_cryptare] mov al,0xa mov [esi],al mov esi,[P1max] inc esi mov [P1max],esi call allinea_P1_2_P2 fine_codkiave6: popa ret ;--------------------------------- codkiave7: pusha mov ecx,[l_buff_da_cryptare] cmp ecx,1 jna near fine_codkiave7 mov dword [P3_7],0 mov dword [P3_7max],0 mov esi,buff_vuoto_2mega mov dword [P3_7_p],esi inc esi mov dword [P3_7max_p],esi mov eax,[act_K07] cmp eax,1 jne near fine_codkiave7 ;mov eax,"K 07" ;call visualizza mov eax,[PIN_COD07] xor [Ptr_2_buffKeys_attuale],eax mov dword [P3_7],1 ;========================================================== ;DA QUI ��������������������������������������������������� ;-------------------Il messaggio---------------- mov esi,buff1_2K_defa ;buffer_2send_dopo add esi,6 mov [P1],esi add esi,[l_buff_da_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi mov esi,[P1] ;mov esi,[P2] ;=========EV.te da ripristinare================== ;--------------------La chiave------------------ mov edx,K7a ;la chiave ;��������������� mov eax,[som_PIN_COD07] add eax,[l_buff_da_cryptare] cmp eax,[P3_master] jbe no_master_K7 mov [P3_master],eax no_master_K7: ;��������������� add edx,[Ptr_2_buffKeys_attuale] mov eax,[som_PIN_COD07] ;--------------------------------- add edx,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] xor edx,[PIN_COD07] mov [P3_7_p],edx ;-------------------------------------------- ;=============================================== mov ecx,[l_buff_da_cryptare] cmp ecx,1 jna near fine_codkiave7_pre2 add edx,ecx dec ecx ;mettiamolo zero_based mov eax,[som_PIN_COD07] add edx,eax mov [P3_7max_p],edx ;P3max = base_addr_attuale+lungh_mesg+som_PIN_CODE ;mov edx,[P3] ;base_addr_attuale ;----------------------------------------------- inizia_K7: ;FIN QUI ��������������������������������������������������� ;=========================================================== ;======CONTROLLI INIZIALI========================= mov eax,[act_K08] cmp eax,1 je K8_is_attivo_K7 mov eax,[act_K09] cmp eax,1 je K9_is_attivo_K7 jmp tocca_a_me_K7 K8_is_attivo_K7: mov eax,[P3_8] cmp eax,1 je K8_gia_fatto_K7 jmp fine_codkiave7_pre K8_gia_fatto_K7: mov eax,[act_K09] cmp eax,1 jne tocca_a_me_K7 K9_is_attivo_K7: mov eax,[P3_9] cmp eax,1 je tocca_a_me_K7 jmp fine_codkiave7_pre ;BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB tocca_a_me_K7: ;nessuna delle condizioni di cui sopra, sono io che devo lavorare ;mov eax,"OPK7" ;call visualizza ; Funzione: settare P1 = P1_7 --- P1max = P1_7 max ... P3 = P3_7 --- P3max = P3_7max call esegui_funzione_789_K ;nella funzione 789 trovera': ; P1_7_A = 0 ecc. ; P1_8_A --> OK ; P1_9_A --> OK jmp fine_codkiave7_pre ;------------------- K89_viene_dopo: ;mettere qui le routine per lasciare il buffer pronto per K8 oppure K9 ;mov eax,"OP89" ;call visualizza ;Funzione: settare P1_7A = P1 --- P1_7A max = P1max ---- P3_7 = P3 ---- P3_7max = P3max ;uscire eseguendo le minime operazioni di ripristino jmp fine_codkiave7_pre ;======================TUTTO QUI===================== fine_codkiave7_pre: mov esi,[P1] add esi,[l_buff_da_cryptare] mov al,0xa mov [esi],al call allinea_P1_2_P2 fine_codkiave7_pre2: mov esi,[P1max] inc esi mov [P1max],esi fine_codkiave7: popa ret ;--------------------------------- codkiave8: pusha mov ecx,[l_buff_da_cryptare] cmp ecx,1 jna near fine_codkiave8 mov dword [P3_8],0 mov dword [P3_8max],0 mov esi,buff_vuoto_2mega mov [P3_8_p],esi inc esi mov [P3_8max_p],esi mov eax,[act_K08] cmp eax,1 jne near fine_codkiave8 ;mov eax,"K 08" ;call visualizza mov eax,[PIN_COD08] xor [Ptr_2_buffKeys_attuale],eax mov dword [P3_8],1 ;========================================================== ;DA QUI ��������������������������������������������������� ;-------------------Il messaggio---------------- mov esi,buff1_2K_defa ;buffer_2send_dopo add esi,6 mov [P1],esi add esi,[l_buff_da_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi mov esi,[P1] ;mov esi,[P2] ;=========EV.te da ripristinare================== ;--------------------La chiave------------------ mov edx,K8a ;la chiave ;��������������� mov eax,[som_PIN_COD08] add eax,[l_buff_da_cryptare] cmp eax,[P3_master] jbe no_master_K8 mov [P3_master],eax no_master_K8: ;��������������� add edx,[Ptr_2_buffKeys_attuale] mov eax,[som_PIN_COD08] ;--------------------------------- add edx,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] xor edx,[PIN_COD08] mov [P3_8_p],edx ;-------------------------------------------- ;=============================================== mov ecx,[l_buff_da_cryptare] cmp ecx,1 jna near fine_codkiave8_pre2 add edx,ecx dec ecx ;mettiamolo zero_based mov eax,[som_PIN_COD08] add edx,eax mov [P3_8max_p],edx ;P3max = base_addr_attuale+lungh_mesg+som_PIN_CODE ;mov edx,[P3] ;base_addr_attuale ;----------------------------------------------- inizia_K8: ;FIN QUI ��������������������������������������������������� ;=========================================================== ;======CONTROLLI INIZIALI========================= mov eax,[act_K07] cmp eax,1 je K7_is_attivo_K8 mov eax,[act_K09] cmp eax,1 je K9_is_attivo_K8 jmp tocca_a_me_K8 K7_is_attivo_K8: mov eax,[P3_7] cmp eax,1 je K7_gia_fatto_K8 jmp fine_codkiave8_pre K7_gia_fatto_K8: mov eax,[act_K09] cmp eax,1 jne tocca_a_me_K8 K9_is_attivo_K8: mov eax,[P3_9] cmp eax,1 je tocca_a_me_K8 jmp fine_codkiave8_pre ;BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB tocca_a_me_K8: ;nessuna delle condizioni di cui sopra, sono io che devo lavorare ;mov eax,"OPK8" ;call visualizza call esegui_funzione_789_K jmp fine_codkiave8_pre ;------------------- K79_viene_dopo: ;mettere qui le routine per lasciare il buffer pronto per K8 oppure K9 ;mov eax,"OP79" ;call visualizza jmp fine_codkiave8_pre ;======================TUTTO QUI===================== fine_codkiave8_pre: mov esi,[P1] add esi,[l_buff_da_cryptare] mov al,0xa mov [esi],al call allinea_P1_2_P2 fine_codkiave8_pre2: mov esi,[P1max] inc esi mov [P1max],esi fine_codkiave8: popa ret ;--------------------------------- codkiave9: pusha mov ecx,[l_buff_da_cryptare] cmp ecx,1 jna near fine_codkiave7 mov dword [P3_9],0 mov dword [P3_9max],0 mov esi,buff_vuoto_2mega mov dword [P3_9_p],esi inc esi mov dword [P3_9max_p],esi mov eax,[act_K09] cmp eax,1 jne near fine_codkiave9 ;mov eax,"K 09" ;call visualizza mov eax,[PIN_COD09] xor [Ptr_2_buffKeys_attuale],eax mov dword [P3_9],1 ;========================================================== ;DA QUI ��������������������������������������������������� ;-------------------Il messaggio---------------- mov esi,buff1_2K_defa ;buffer_2send_dopo add esi,6 mov [P1],esi add esi,[l_buff_da_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi mov esi,[P1] ;mov esi,[P2] ;=========EV.te da ripristinare================== ;--------------------La chiave------------------ mov edx,K9a ;la chiave ;��������������� mov eax,[som_PIN_COD09] add eax,[l_buff_da_cryptare] cmp eax,[P3_master] jbe no_master_K9 mov [P3_master],eax no_master_K9: ;��������������� add edx,[Ptr_2_buffKeys_attuale] mov eax,[som_PIN_COD09] ;--------------------------------- add edx,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] xor edx,[PIN_COD09] mov [P3_9_p],edx ;-------------------------------------------- ;=============================================== mov ecx,[l_buff_da_cryptare] cmp ecx,1 jna near fine_codkiave9_pre2 add edx,ecx dec ecx ;mettiamolo zero_based mov eax,[som_PIN_COD09] add edx,eax mov [P3_9max_p],edx ;P3max = base_addr_attuale+lungh_mesg+som_PIN_CODE ;mov edx,[P3] ;base_addr_attuale ;----------------------------------------------- inizia_K9: ;FIN QUI ��������������������������������������������������� ;=========================================================== ;======CONTROLLI INIZIALI========================= mov eax,[act_K08] cmp eax,1 je K8_is_attivo_K9 mov eax,[act_K07] cmp eax,1 je K7_is_attivo_K9 jmp tocca_a_me_K9 K8_is_attivo_K9: mov eax,[P3_8] cmp eax,1 je K8_gia_fatto_K9 jmp fine_codkiave9_pre K8_gia_fatto_K9: mov eax,[act_K07] cmp eax,1 jne tocca_a_me_K9 K7_is_attivo_K9: mov eax,[P3_7] cmp eax,1 je tocca_a_me_K9 jmp fine_codkiave9_pre ;BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB tocca_a_me_K9: ;nessuna delle condizioni di cui sopra, sono io che devo lavorare ;mov eax,"OPK9" ;call visualizza call esegui_funzione_789_K jmp fine_codkiave9_pre ;------------------- K78_viene_dopo: ;mettere qui le routine per lasciare il buffer pronto per K8 oppure K9 ;mov eax,"OP78" ;call visualizza jmp fine_codkiave9_pre ;======================TUTTO QUI===================== fine_codkiave9_pre: mov esi,[P1] add esi,[l_buff_da_cryptare] mov al,0xa mov [esi],al call allinea_P1_2_P2 fine_codkiave9_pre2: mov esi,[P1max] inc esi mov [P1max],esi fine_codkiave9: popa ret ;--------------------------------- codkiave10: pusha mov eax,[act_K00] cmp eax,1 jne near fine_codkiave10 ;mov eax,"K 10" ;call visualizza mov eax,[PIN_COD10] xor [Ptr_2_buffKeys_attuale],eax ;-------------------Il messaggio---------------- mov esi,buff1_2K_defa ;buffer_2send_dopo add esi,6 mov [P1],esi add esi,[l_buff_da_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi mov esi,[P1] ;mov esi,[P2] ;=========EV.te da ripristinare================== ;--------------------La chiave------------------ mov edx,K0a ;la chiave add edx,[Ptr_2_buffKeys_attuale] mov eax,[som_PIN_COD10] ;--------------------------------- add edx,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] xor edx,[PIN_COD10] mov [P3],edx ;-------------------------------------------- ;=============================================== mov ecx,[l_buff_da_cryptare] cmp ecx,0 jna near fine_codkiave10 add edx,ecx dec ecx ;mettiamolo zero_based mov eax,[som_PIN_COD10] add edx,eax mov [P3max],edx ;P3max = base_addr_attuale+lungh_mesg+som_PIN_CODE mov edx,[P3] ;base_addr_attuale ;----------------------------------------------- inizia_K10: ;=================================================================================== ;La kiave10 come chiave complessa usa i bit della key per traslare a gruppi di 8 i byte ;del messaggio originale verso l'inizio; esempio: ;kiave10 (bit) 0010 0100 ;messaggio: ABCDEFGH ;usando kiave10 il messaggio diventa: ;1� passaggio: CABDEFGH ;2� passaggio: FCABDEGH ;il tutto ripetuto sui successivi gruppi di 8 bytes di messaggio tante volte quanti ;sono i bytes di kiave9 ;:------------------------------------------ ; |------------------------------:Messaggio.............| ;buffer_2_send -----^ buffer_2send_dopo = P1 -----^ ; |------------------------:LmCodkMessaggio.............| ;buff_crypt_start --^ buff1_2K_defa -----^ ^---P2 ; |---------------------------------------------............--------------------| ; riempi1 (buff da 2 mega) <----ebp...-^-...edi----> ; |----------------------------------------i----------------f--------------| ; Kna--^ Ptr_2_buffKeys_attuale= P3---^ ^---P3max ;==================================================================================== mov dword [op_ebp],0 mov dword [op_edi],0 mov esi,[P1] mov edx,[P3] mov ebp,riempi1 ; buff da 2 mega add ebp,512 ;mettiamoci a distanza sufficiente dall'inizio per ricevere ;l'intero messaggio se tutti i bit della chiave sono a 1 mov edi,ebp ;sincr edi e ebp; edi incrementa se bit =0, ebp decrementa se bit=1 inc edi ;dec ebp inizia_K10_1: mov bl,[edx] mov cl,8 va_esi_K10: mov al,[esi] clc shl bl,1 jc is_1_K10 ;mov [edi],al ;inc edi ;jmp dopo_is_1_K10 ror al,2 is_1_K10: mov [ebp],al dec ebp dopo_is_1_K10: inc esi cmp esi,[P1max] jbe va_a_deccl_K10 call rimetti_riempi1_2_P1 ;rimetti nel buffer iniziale jmp fine_codkiave10_pre ;provvisorio ;mov esi,[P1] ;inc edx ;cmp edx,[P3max] ;ja fine_codkiave10_pre ;jmp inizia_K10_1 va_a_deccl_K10: dec cl jnz va_esi_K10 inc edx cmp edx,[P3max] ja fine_codkiave10_pre jmp inizia_K10_1 fine_codkiave10_pre: ;call rimetti_riempi1_2_P1 ;allineamolo che e' meglio mov esi,[P1] add esi,[l_buff_da_cryptare] mov al,0xa mov [esi],al mov esi,[P1max] inc esi mov [P1max],esi call allinea_P1_2_P2 fine_codkiave10: popa ret ;--------------------------------- codkiave11: pusha mov eax,[act_K11] cmp eax,1 jne fine_codkiave11 mov eax,"K 11" call visualizza mov eax,[PIN_COD11] xor [Ptr_2_buffKeys_attuale],eax fine_codkiave11: popa ret ;--------------------------------- codkiave12: pusha mov eax,[act_K12] cmp eax,1 jne fine_codkiave12 mov eax,"K 12" call visualizza mov eax,[PIN_COD12] xor [Ptr_2_buffKeys_attuale],eax fine_codkiave12: popa ret ;--------------------------------- codkiave13: pusha mov eax,[act_K13] cmp eax,1 jne fine_codkiave13 mov eax,"K 13" call visualizza mov eax,[PIN_COD13] xor [Ptr_2_buffKeys_attuale],eax fine_codkiave13: popa ret ;--------------------------------- ultimo_passo_K: pusha ;call codifica_0AD codifica_0AD_up: ;serve a codificare i bytes 0,A,D del paccketto buff1_2K_defa ;altrimenti non accettati dal server call pulisci_buff_provv_32k xor ebx,ebx mov edi,buff_provv_32k mov esi,buff1_2K_defa mov ecx,512 cod_0AD1x_poiup: mov al,[esi] cmp al,0 je is_0_cod_0ADup cmp al,0xa je is_A_cod_0ADup cmp al,0xd je is_D_cod_0ADup mov [edi],al inc edi inc esi dec ecx jnz cod_0AD1x_poiup jmp fine_0ADup is_0_cod_0ADup: call conta_otto_zeri cmp ebx,0 je near fine_0ADup mov eax,[codice_0AD] mov [edi],eax add edi,4 mov ax,[identificativo_0AD] mov [edi],ax jmp no_0ADup is_A_cod_0ADup: call conta_otto_zeri cmp ebx,0 je fine_0ADup mov eax,[codice_0AD] mov [edi],eax add edi,4 mov ax,[identificativo_0AD] add ax,0xa mov [edi],ax jmp no_0ADup is_D_cod_0ADup: call conta_otto_zeri cmp ebx,0 je fine_0ADup mov eax,[codice_0AD] mov [edi],eax add edi,4 mov ax,[identificativo_0AD] add ax,0xd mov [edi],ax jmp no_0ADup ;-------routine interna---- conta_otto_zeri: mov ebx,8 push esi continua_conta_otto: inc esi mov al,[esi] cmp al,0 jne fine_conta_otto dec ebx jnz continua_conta_otto fine_conta_otto: pop esi ret ;--------------------- no_0ADup: add edi,2 inc esi dec ecx jnz cod_0AD1x_poiup fine_0ADup: mov al,0xa mov [edi],al push edi ;popa ;ret ;qui abbiamo tutto su buff_provv_32K ;ora mettiamolo su buff_crypt mov esi,buff_provv_32k mov edi,buff1_2K_defa mov ebx,480 cont_sistema_ultimo_buffer: mov al,[esi] mov [edi],al inc esi inc edi dec ebx jnz cont_sistema_ultimo_buffer pop edx ;valore precedente del buffer mov edi,buff_provv_32k sub edx,edi ;abbiamo cosi quanti bytes add edx,29 ; i chars di privmesg ecc... ;push edx mov eax,4 mov ebx,[sock] mov ecx,buff_crypt_start ; buff_std_prova ;mov edx,510 numero di bytes e' quello calcolato int 0x80 ;pop edx ;mov eax,4 ;mov ebx,1 ;[sock] ;mov ecx,buff_crypt_start ; buff_std_prova ;mov edx,510 numero di bytes e' quello calcolato ;int 0x80 popa ret ;----------------------- ;������������������������������������������������������������������������������������������ ;������������������������������������������������������������������������������������������ ; ;decodkiavi.asm ; ;--------------------------------- decodkiave1: pusha ;qui inserire le routines da master mov eax,[act_K01] cmp eax,1 jne near fine_decodkiave1 mov eax,"DK01" ;call visualizza ;call pulisci_buff1_2K_defa call pulisci_buff1_2K_defa ;call calcola_som_PIN_CODE ;mov eax,[PIN_CODE] ;mov [som_PIN_CODE],dword 0 ;add [som_PIN_CODE],al ;add [som_PIN_CODE],ah ;bswap eax ;add [som_PIN_CODE],al ;add [som_PIN_CODE],ah ;mov eax,[som_PIN_CODE] xor eax,eax mov ebx,[l_buff_da_DE_cryptare] ;dec ebx e' gia levato ;leviamo il carattere 0xA add ebx,eax ; = lunghezza chiave da usare mov [lungh_key_DK],ebx and ebx,1 jz is_pari_K1xx mov ebx,[lungh_key_DK] inc ebx mov [lungh_key_DK],ebx is_pari_K1xx: mov ebx,[lungh_key_DK] mov ebp,K1a mov edx,[Ptr_2_buffKeys_attuale_2_DK] ;quello pervenuto nel messaggio ;-------------------------------- add edx,[som_PIN_COD01] add edx,eax ;-------------------------------- add ebp,edx ;P3i -->P3v xor ebp,[PIN_COD01] mov [P3],ebp add ebx,ebp ;aggiungiamo pin_CODE + Lungh_messaggio ; sub ebx,2 ;provvisorio mov [P3max],ebx ;e abbiamo il Puntatore_max_aKey add dword [P3max],5000 ;���������������������������� mov ebx,[l_buff_da_DE_cryptare] and ebx,1 jz is_pari_K1 sub dword [P3max],2 ;inc ebx ;mov [P3max],ebx is_pari_K1: mov edx,[P3max] ;anche in edx mov esi,buffer_2recv add esi,[l_buff_da_DE_cryptare] mov ecx,[l_header] add ecx,6 add esi,ecx mov [P1max],esi mov ebx,[l_buff_da_DE_cryptare] and ebx,1 jz is_pari_K1_peresi ;dec dword [P1max] is_pari_K1_peresi: mov ebx,[l_buff_da_DE_cryptare] and ebx,1 jnz is_dispari_K1_peredx sub dword [P3max],2 mov edx,[P3max] is_dispari_K1_peredx: ;-------------- mov esi,buffer_2recv mov edi,buff1_2K_defa ;buff_provv_32k call pulisci_buff1_2K_defa ; buff_provv_32k mov ecx,[l_header] add ecx,6 allinea_buff_K1_DK: mov al,[esi] mov [edi],al inc esi inc edi dec ecx jnz allinea_buff_K1_DK ;add esi,6 ;i 4+2 chars mov [P1i],esi ;jmp fine_decodkiave1 sist_buff_12345_DK: mov bl,[edx] ;5 mov bh,[edx+1] primo_char_K1_DK: xor eax,eax mov al,[esi] ;10 cmp al,bl ;20 je P100K1_DK ; uguali_al_bl ; goto 100 cmp al,bh ;30 je P200K1_DK ; uguali_al_bh ; goto 200 linea40_DK: inc esi ;40 P1v=P1v+1 cmp esi,[P1max] ;50 jae P500K1_DK ;non_ugiuali_al,bl-bh ; goto 500 jmp primo_char_K1_DK ; goto 20 P100K1_DK: mov [esi],bh ;100 al= bh inc esi ;110 P1v = P1v +1 cmp esi,[P1max] ;120 If P1v > P1max then 500 jae P500K1_DK jmp primo_char_K1_DK ;130 goto 10 P200K1_DK: mov [esi],bl ;200 al=bl inc esi ;210 P1v = P1v+1 cmp esi,[P1max] ;220 If P1v > P1max then 500 ja P500K1_DK jmp primo_char_K1_DK ;230 goto 10 P500K1_DK: ;ok siamo fuori sistemato il buffer dec edx cmp edx,[P3] jb P600K1_DK dec edx cmp edx,[P3] jb P600K1_DK mov esi,[P1i] jmp sist_buff_12345_DK P600K1_DK: ;mov ecx,[l_buff_da_DE_cryptare] ;mov esi,[P1i] ;esi gia settato a mov edi,buff1_2K_defa ;[P2] ;edi era cmq gia settato a fuffer_2kdefa + 2+4 char iniziali ;mettiamo buffer_2sendopo to buffer_2Kdefa ;inc ecx mov esi,buffer_2recv mov ecx,[l_header] inc ecx cont_P600K1_DK: mov al,[esi] mov [edi],al inc esi inc edi dec ecx jnz cont_P600K1_DK mov ecx,[l_buff_da_DE_cryptare] add ecx,2 ;0xD 0xA add ecx,6 ;+2 +4 dec edi dec esi ;add esi,6 ;superiamo i 2+4 bytes di controllo cont_P600K1_DK_dopo6: mov al,[esi] mov [edi],al inc esi inc edi dec ecx jnz cont_P600K1_DK_dopo6 mov eax,[PIN_COD01] xor [Ptr_2_buffKeys_attuale_2_DK],eax ;mov esi,buffer_2recv ;call debugga ;popa fine_decodkiave1: sub dword [P3max],5000 ;���������������������������� popa ret ;--------------------------------- decodkiave2: pusha mov eax,[act_K02] cmp eax,1 jne near fine_decodkiave2 ; mov eax,"DK02" ;call visualizza ;[P2] ; qui buff1_2K_defa = il msg prov da K01 con i 2+4 bytes ; no add esi,[l_header] ;add esi,28 ;allineati dopo "PRIVMSG.... Nick|#Chan..... :" ;add esi,6 ;2+4 bytes ;usiamo al solito P1 e P1max ;pusha ;call debugga ;popa ;ERANO QUIIIIIIIIIIIIIIIIIIIIIIIIII ;-------------------Il messaggio---------------- mov esi,buffer_2recv add esi,[l_header] add esi,6 mov [P1],esi mov esi,[P1] ;--------------------La chiave------------------ ;mov ebp,K3a mov ebp,K2a mov edx,[Ptr_2_buffKeys_attuale_2_DK] mov eax,[som_PIN_COD02] ;--------------------------------- add ebp,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] add edx,ebp xor edx,[PIN_COD02] mov [P3],edx add edx,[l_buff_da_DE_cryptare] add edx,[som_PIN_COD02] mov [P3max],edx ;mov edx,[P3max] mov ecx,[l_buff_da_DE_cryptare] ; cmp ecx,1 ; jna near fine_decodkiave2 dec ecx ;mettiamolo zero_based ;----------------------------------------------- mov esi,[P1] mov ebp,K2a mov edx,[P3] mov ecx,480 ;max 480 caaratteri call xora_K02 ;come call da usare anche per decodifica jmp fine_decodkiave2_pre fine_decodkiave2_pre: ;preparare buffer per prossima key o e' gia pronto?? mov esi,buffer_2recv mov edi,buff1_2K_defa mov ebx,[l_header] ;28 ;PRIVMSG ecc ;[l_header] add ebx,6 ;2+4 bytes add ebx,[l_buff_da_DE_cryptare] inc ebx ;0Xa inc ebx mov ecx,480 ;480 mov eax,[PIN_COD02] xor [Ptr_2_buffKeys_attuale_2_DK],eax fine_decodkiave2: ;sistemare il buffer giusto dec ecx jz sist_buff_K02_fin_DK mov al,[esi] mov [edi],al inc esi inc edi dec ebx jnz fine_decodkiave2 ; se ebx errato vediamo che cazz ci mette ;mov al,0xa ;mov [edi],al ;:zuppolo!~zupolon^@host200-41.pool8261.interbusiness.it PRIVMSG #coclide :@@@@@ sist_buff_K02_fin_DK: ;fine_decodkiave2: popa ret ;--------------------------------- decodkiave3: pusha mov eax,[act_K03] cmp eax,1 jne near fine_decodkiave3 mov ecx,[l_buff_da_DE_cryptare] cmp ecx,1 jna near fine_decodkiave3_pre2 dec ecx ;mettiamolo zero_based ;jmp fine_decodkiave3 ;mov esi,buffer_2recv ;call debugga ;mov esi,buff1_2K_defa ;call debugga ;mov eax,"DK03" ;call visualizza ; |----l_header -----------:LmCodkM e s s a g g i o.............| ;buffer_2recv ------^ P1--^ ^---P1max ;(dopo il preDK) ; |----l_header -----------:LmCodkM e s s a g g i o.............| ;buff1_2K_defa -----^ ; |----------------------------------------i---------------------f--------------| ; Kna--^ Ptr_2_buffKeys_attuale= P3---^ ^---P3max ;-------------------Il messaggio---------------- mov esi,buffer_2recv add esi,[l_header] add esi,6 mov [P1],esi mov esi,[P1] ;=======BLOCCO DA Riprist. se non FUNZIA======== ;--------------------La chiave------------------ mov ebp,K3a mov edx,[Ptr_2_buffKeys_attuale_2_DK] mov eax,[som_PIN_COD03] ;--------------------------------- add ebp,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] add edx,ebp xor edx,[PIN_COD03] mov [P3],edx add edx,[l_buff_da_DE_cryptare] add edx,[som_PIN_COD03] mov [P3max],edx mov edx,[P3max] ;------------------------------------------------- ;================================================= ;----------------------------------------------- inizia_DK3: xor ebx,ebx mov bl,[edx] pre_va_oltre_DK3: cmp ebx,ecx ;[l_buff_da_DE_cryptare] jb va_oltre_DK3 sub ebx,ecx jmp pre_va_oltre_DK3 va_oltre_DK3: mov ebp,ebx xor ebx,ebx mov bl,[edx+1] pre_va_oltre_DK3_B2: cmp ebx,ecx ;[l_buff_da_DE_cryptare] jb va_oltre_DK3_B2 sub ebx,ecx jmp pre_va_oltre_DK3_B2 va_oltre_DK3_B2: mov al,[esi+ebp] mov ah,[esi+ebx] mov [esi+ebp],ah mov [esi+ebx],al dec edx cmp edx,[P3] jae inizia_DK3 ;------------ ; gia finito, sistemiamo qui anche il buffer di P2 ; rendiamo identico P2 a P1 ; ; fine_decodkiave3_pre: call allinea_BUFF_DK fine_decodkiave3_pre2: mov eax,[PIN_COD03] xor [Ptr_2_buffKeys_attuale_2_DK],eax fine_decodkiave3: popa ret ;--------------------------------- decodkiave4: pusha mov eax,[act_K04] cmp eax,1 jne near fine_decodkiave4 ;mov eax,"DK04" ;call visualizza ;-------------------Il messaggio---------------- mov esi,buffer_2recv add esi,[l_header] add esi,6 mov [P1],esi add esi,[l_buff_da_DE_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi mov esi,[P1] ;=======BLOCCO DA Riprist. se non FUNZIA======== ;--------------------La chiave------------------ mov ebp,K4a mov edx,[Ptr_2_buffKeys_attuale_2_DK] mov eax,[som_PIN_COD04] ;--------------------------------- add ebp,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] add edx,ebp xor edx,[PIN_COD04] mov [P3],edx add edx,[l_buff_da_DE_cryptare] add edx,[som_PIN_COD04] ;inc edx ;dec edx mov [P3max],edx mov edx,[P3max] ;------------------------------------------------- ;================================================= mov ecx,[l_buff_da_DE_cryptare] cmp ecx,0 jna near fine_codkiave4 dec ecx ;mettiamolo zero_based ;----------------------------------------------- inizia_DK4__: ;========================================================== mov esi,[P1] mov edx,[P3] inizia_DK4_f1: mov bh,10000000b mov cl,8 xor eax,eax K4_va_10_f1: mov bl,[edx] mov al,[esi] and bl,bh jz va_K4_noswap_f1 ;call opera_su_al_K4 ;va_a_swappare_al ;mov [esi],al K4_50_f1: inc esi cmp esi,[P1max] jna K4_100_f1 mov esi,[P1] inc edx cmp edx,[P3max] ja fine_decodkiave4_pre_f1 jmp inizia_DK4_f1 K4_100_f1: clc shr bh,1 cmp bh,0 je K4_200_f1 ;dec cl jmp K4_va_10_f1 K4_200_f1: inc edx cmp edx,[P3max] ja fine_decodkiave4_pre_f1 jmp inizia_DK4_f1 va_K4_noswap_f1: ;ror al,1 ;mov [esi],al jmp K4_50_f1 fine_decodkiave4_pre_f1: dec edx ;rimettiamolo su P3max ;mov edx,[P3max] dec esi cmp esi,[P1] jnb dopo_esi_dk4 mov esi,[P1max] ;dec edx dopo_esi_dk4: ;mov edx,[P3max] ;allineiamo: mov byte [provv],00000001b ;mov byte [provv],00000001b mov ecx,[P1max] sub ecx,[P1] ;cmp ecx,8 ;jnb prova_esi_DK4 mov byte [prov_K4],10000000b ;dec cl su_k4: cmp cl,0 je prova_esi_DK4 ror byte [prov_K4],1 dec cl jnz su_k4 ;mov al,[prov_K4] ;mov [provv_1_max],al ;mov [provv],bh ;mov cl,bh ;rol bh,1 ? ;cl e bh puntano giusti? prova_esi_DK4: mov al,[prov_K4] mov [provv_1_max],al ;shl bh,1 cmp bh,0 jne dopo_dopo_esi_dk4 mov bh,[provv] ;mov cl,8 lo facciamo diventare: dopo_dopo_esi_dk4; cmp esi,[P1] ja DK4_va_10 mov esi,[P1max] ;jmp DK4_va_10 ;============================================================ ;1) calcolare blocchi da 8 Bda8 in lungh messaggio ;se c'e' resto Bda8 = Bda8 +1 ; almeno 1 blocco (anche se <8) ;2) dividere lungh chiave per Bda8 per trovare resto R_Lch = resto Lunghezza chiave (Lch/Bda8) ;3) add esi,R_Lch ;per trovare posizione iniziale ;PRIMA DI TUTTO ALLINEIAMO UBK Ultimo Byte CRIPTATO ; ||.... ....|.... ....|.... ....|.... ....|.... ....|.... ....|.... ....|.... ....||..... ^ ;---UBK------------------------------------------^ ;bh || 0 0 0 0 1 0 0 0 || ;settare i bit di bh a 00001000 ;=========================== inizia_DK4_3: cmp dword [l_buff_da_DE_cryptare],8 ; 7 ;cmp bh,0 ja dopo_dk4_3 ;DK4_va_9 cmp bh,0 ja DK4_va_10 jmp DK4_va_5 dopo_dk4_3: mov byte [prov_K4],00000001b ; cmp bh,0 ; ja DK4_va_10 DK4_va_5: mov bh,[prov_K4] ;10000000b oppure max-lungh da 100000000 a 00000001h mov cl,8 xor eax,eax DK4_va_9: cmp bh,0 je DK4_va_5 DK4_va_10: mov bl,[edx] mov al,[esi] and bl,bh jz va_DK4_noswap call opera_su_al_K4 ;va_a_swappare_al mov [esi],al DK4_50: dec esi cmp esi,[P1] jae DK4_100 mov esi,[P1max] mov bh,[provv_1_max] dec edx cmp edx,[P3] jb fine_decodkiave4_pre jmp DK4_va_10 ;DK4_va_5 ;inizia_DK4_3 DK4_100: shl bh,1 cmp bh,0 je DK4_200 ;dec cl jmp DK4_va_10 ;jnz DK4_va_10 DK4_200: dec edx cmp edx,[P3] jb fine_decodkiave4_pre mov bh,[provv_1_max] cmp dword [l_buff_da_DE_cryptare],8 jna DK4_200_1 mov bh,000000001b DK4_200_1: jmp DK4_va_10 ;inizia_DK4_3 va_DK4_noswap: rol al,1 mov [esi],al jmp DK4_50 ;=================== fine_decodkiave4_pre: call allinea_BUFF_DK mov eax,[PIN_COD04] xor [Ptr_2_buffKeys_attuale_2_DK],eax mov esi,[P1max] inc esi mov [P1max],esi fine_decodkiave4: popa ret ;--------------------------------- decodkiave5: pusha mov eax,[act_K05] cmp eax,1 jne near fine_decodkiave5 mov ecx,[l_buff_da_DE_cryptare] cmp ecx,1 jna near fine_decodkiave5 ; mov eax,"DK05" ;call visualizza ;-------------------Il messaggio---------------- mov esi,buffer_2recv add esi,[l_header] add esi,6 mov [P1],esi add esi,[l_buff_da_DE_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi mov esi,[P1] ;=======BLOCCO DA Riprist. se non FUNZIA======== ;--------------------La chiave------------------ mov ebp,K5a mov edx,[Ptr_2_buffKeys_attuale_2_DK] mov eax,[som_PIN_COD05] ;--------------------------------- add ebp,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] add edx,ebp xor edx,[PIN_COD05] mov [P3],edx add edx,[l_buff_da_DE_cryptare] add edx,[som_PIN_COD05] mov [P3max],edx mov edx,[P3] ;------------------------------------------------- ;================================================= mov ecx,[l_buff_da_DE_cryptare] cmp ecx,1 jna near fine_decodkiave5_pre2 dec ecx ;mettiamolo zero_based ;----------------------------------------------- inizia_DK5: xor ebx,ebx mov bl,[edx] mov al,[esi] inizia_DK5_01: sub al,bl mov [esi],al inc esi cmp esi,[P1max] ja DK5_2 inc edx cmp edx,[P3max] jna inizia_DK5 jmp fine_decodkiave5_pre DK5_2: mov esi,[P1] jmp inizia_DK5 fine_decodkiave5_pre: call allinea_BUFF_DK mov eax,[PIN_COD05] xor [Ptr_2_buffKeys_attuale_2_DK],eax fine_decodkiave5_pre2: mov esi,[P1max] inc esi mov [P1max],esi fine_decodkiave5: popa ret ;--------------------------------- decodkiave6: pusha mov eax,[act_K06] cmp eax,1 jne near fine_decodkiave6 ; mov eax,"DK06" ; call visualizza ;-------------------Il messaggio---------------- mov esi,buffer_2recv add esi,[l_header] add esi,6 mov [P1],esi add esi,[l_buff_da_DE_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi ;mov esi,[P1] ;ok in esi P1max ;=======BLOCCO DA Riprist. se non FUNZIA======== ;--------------------La chiave------------------ mov ebp,K6a mov edx,[Ptr_2_buffKeys_attuale_2_DK] mov eax,[som_PIN_COD06] ;--------------------------------- add ebp,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] add edx,ebp xor edx,[PIN_COD06] mov [P3],edx add edx,[l_buff_da_DE_cryptare] add edx,[som_PIN_COD06] mov [P3max],edx mov edx,[P3] ;------------------------------------------------- ;================================================= mov ecx,[l_buff_da_DE_cryptare] cmp ecx,0 jna near fine_codkiave6 dec ecx ;mettiamolo zero_based ;----------------------------------------------- ;precalcoliamo P3max xor ecx,ecx mov ecx,1 mov eax,[l_buff_da_DE_cryptare] cmp eax,1 je pre_inizia_DK6 add ecx,2 ;2+1=3 combinazioni cmp eax,2 ;2 caratteri je pre_inizia_DK6 ; >2 quindi vale la formula ; Gtotali = Lm = 3*Lm -4 mov ebx,3 mul ebx sub eax,4 mov ecx,eax pre_inizia_DK6: mov edx,[P3] add edx,ecx mov [P3max],edx dec edx ;zero based inizia_DK6: xor ecx,ecx ;esi ptr to >....123456.......... messaggio ;edx ptr to >...c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14.... ; ror al,cl ; ; 1 2 ; 1 2 3 ; 1 2 3 4 ; 1 2 3 4 5 ; 1 2 3 4 5 6 ; 1 ; 1 ; 1 ; 1 ; 1 c1 ror al , cl ; 1 2 ; 1 2 ; 1 2 ; 1 2 ; 1 2 c2 ror ax , cl ; 2 ; 2 ; 1 2 3 4 ; 1 2 3 4 ; 1 2 3 4 c3 ror eax , cl ; 2 3 ; 2 ; 2 ; 2 c4 ; 3 ; 2 3 ; 2 3 ; 2 3 c5 ; 3 ; 2 3 4 5 ; 2 3 4 5 c6 ; 3 4 ; 3 ; 3 c7 ; 4 ; 3 4 ; 3 4 c8 ; 4 ; 3 4 5 6 c9 ; 4 5 ; 4 c10 ; 5 ; 4 5 c11 ; 5 c12 ; 5 6 c13 " ; 6 c14 ;Lm = Lunghezza messaggio ; G_da4 = Lm - 3 ; G_da2 = Lm - 1 ; G_da1 = Lm ; Gtotali = P3max-P3 = Lm-3 + Lm -2 + Lm = 3*Lm -(3+1) NO!!!! non vale per Lm = 1 o 2 mov cl,[edx] mov al,[esi] ; 1.2.3.4.[5] rol al,cl mov [esi],al dec edx mov cl,[edx] blocco4bytes_DK6: ;--------primo blocco 4 bytes----------- sub esi,1 cmp esi,[P1] jb fine_decodkiave6_pre ;fine messaggio e codifica ;dec edx ;inc edx ;il prossimo char come chiave ;sub esi,1 ;roimettiamolo come prima mov ax,[esi] ; 1.2.3.[45] rol ax,byte cl ;ror ax,byte cl mov [esi],ax dec edx ;inc edx mov cl,[edx] mov al,[esi] ; 1.2.3.[4].5 rol al,byte cl mov [esi],al dec edx mov cl,[edx] sub esi,1 cmp esi,[P1] jb fine_decodkiave6_pre ;sub esi,1 ;roimettiamolo come prima mov ax,[esi] ; 1.2.[34].5 rol ax,byte cl ;ror ax,byte cl mov [esi],ax dec edx ;inc edx mov cl,[edx] mov al,[esi] ; 1.2.[3].4.5 rol al,byte cl mov [esi],al dec edx mov cl,[edx] sub esi,1 cmp esi,[P1] jb fine_decodkiave6_pre ;sub esi,1 ;roimettiamolo come prima Qui_parte4_DK6: mov eax,[esi] ; 1.[2345] rol eax,byte cl ;ror ax,byte cl mov [esi],eax dec edx ;inc edx mov cl,[edx] ;sub esi,1 ;roimettiamolo come prima mov ax,[esi] ; 1.[23].4.5 rol ax,byte cl ;ror ax,byte cl mov [esi],ax dec edx ;inc edx mov cl,[edx] ;sub esi,1 ;roimettiamolo come prima mov al,[esi] ; 1.[2].3.4.5 rol al,byte cl ;ror ax,byte cl mov [esi],al dec edx ;inc edx mov cl,[edx] sub esi,1 cmp esi,[P1] jb fine_decodkiave6_pre jmp Qui_parte4_DK6 ;-------------------------------- fine_decodkiave6_pre: call allinea_BUFF_DK mov eax,[PIN_COD06] xor [Ptr_2_buffKeys_attuale_2_DK],eax mov esi,[P1max] inc esi mov [P1max],esi fine_decodkiave6: popa ret ;--------------------------------- decodkiave7: pusha mov ecx,[l_buff_da_DE_cryptare] cmp ecx,1 jna near fine_decodkiave7 mov dword [P3_7],0 mov dword [P3_7max],0 mov esi,buff_vuoto_2mega mov dword [P3_7_p],esi inc esi mov dword [P3_7max_p],esi mov eax,[act_K07] cmp eax,1 jne near fine_decodkiave7 ;mov eax,"DK07" ;call visualizza mov dword [P3_7],1 ;================================================ ;������������������������������������������������ ;-------------------Il messaggio---------------- mov esi,buffer_2recv add esi,[l_header] add esi,6 mov [P1],esi add esi,[l_buff_da_DE_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi ;mov esi,[P1] ;ok in esi P1max ;=======BLOCCO DA Riprist. se non FUNZIA======== ;--------------------La chiave------------------ mov ebp,K7a ;��������������� mov eax,[som_PIN_COD07] add eax,[l_buff_da_cryptare] cmp eax,[P3_master] jbe no_master_DK7 mov [P3_master],eax no_master_DK7: ;��������������� mov edx,[Ptr_2_buffKeys_attuale_2_DK] mov eax,[som_PIN_COD07] ;--------------------------------- add ebp,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] add edx,ebp xor edx,[PIN_COD07] mov [P3_7_p],edx add edx,[l_buff_da_DE_cryptare] add edx,[som_PIN_COD07] mov [P3_7max_p],edx ;mov edx,[P3] ;------------------------------------------------- ;================================================= mov ecx,[l_buff_da_DE_cryptare] cmp ecx,1 jna near fine_decodkiave7_pre2 dec ecx ;mettiamolo zero_based ;----------------------------------------------- ;precalcoliamo P3max inizia_DK7: ;������������������������������������������������ ;================================================ ;======CONTROLLI INIZIALI========================= mov eax,[act_K08] cmp eax,1 je K8_is_attivo_DK7 mov eax,[act_K09] cmp eax,1 je K9_is_attivo_DK7 jmp tocca_a_me_DK7 K8_is_attivo_DK7: mov eax,[P3_8] cmp eax,1 je K8_gia_fatto_DK7 jmp fine_decodkiave7_pre K8_gia_fatto_DK7: mov eax,[act_K09] cmp eax,1 jne tocca_a_me_DK7 K9_is_attivo_DK7: mov eax,[P3_9] cmp eax,1 je tocca_a_me_DK7 jmp fine_decodkiave7_pre ;BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB tocca_a_me_DK7: ;nessuna delle condizioni di cui sopra, sono io che devo lavorare ;mov eax,"IDK7" ;call visualizza call esegui_funzione_789_K jmp fine_decodkiave7_pre ;------------------- K89_viene_dopo_DK: ;mettere qui le routine per lasciare il buffer pronto per K8 oppure K9 mov eax,"DK89" call visualizza jmp fine_decodkiave7_pre ;======================TUTTO QUI===================== fine_decodkiave7_pre: call allinea_BUFF_DK fine_decodkiave7_pre2: mov eax,[PIN_COD07] xor [Ptr_2_buffKeys_attuale_2_DK],eax mov esi,[P1max] inc esi mov [P1max],esi fine_decodkiave7: popa ret ;--------------------------------- decodkiave8: pusha mov ecx,[l_buff_da_DE_cryptare] cmp ecx,1 jna near fine_decodkiave8 mov dword [P3_8],0 mov dword [P3_8max],0 mov esi,buff_vuoto_2mega mov dword [P3_8_p],esi inc esi mov dword [P3_8max_p],esi mov eax,[act_K08] cmp eax,1 jne near fine_decodkiave8 ;mov eax,"DK08" ;call visualizza mov dword [P3_8],1 ;================================================ ;������������������������������������������������ ;-------------------Il messaggio---------------- mov esi,buffer_2recv add esi,[l_header] add esi,6 mov [P1],esi add esi,[l_buff_da_DE_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi ;mov esi,[P1] ;ok in esi P1max ;=======BLOCCO DA Riprist. se non FUNZIA======== ;--------------------La chiave------------------ mov ebp,K8a ;��������������� mov eax,[som_PIN_COD08] add eax,[l_buff_da_cryptare] cmp eax,[P3_master] jbe no_master_DK8 mov [P3_master],eax no_master_DK8: ;��������������� mov edx,[Ptr_2_buffKeys_attuale_2_DK] mov eax,[som_PIN_COD08] ;--------------------------------- add ebp,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] add edx,ebp xor edx,[PIN_COD08] mov [P3_8_p],edx add edx,[l_buff_da_DE_cryptare] add edx,[som_PIN_COD08] mov [P3_8max_p],edx ;mov edx,[P3] ;------------------------------------------------- ;================================================= mov ecx,[l_buff_da_DE_cryptare] cmp ecx,1 jna near fine_decodkiave8_pre2 dec ecx ;mettiamolo zero_based ;----------------------------------------------- ;precalcoliamo P3max inizia_DK8: ;������������������������������������������������ ;================================================ ;======CONTROLLI INIZIALI========================= mov eax,[act_K07] cmp eax,1 je K7_is_attivo_DK8 mov eax,[act_K09] cmp eax,1 je K9_is_attivo_DK8 jmp tocca_a_me_DK8 K7_is_attivo_DK8: mov eax,[P3_7] cmp eax,1 je K7_gia_fatto_DK8 jmp fine_decodkiave8_pre K7_gia_fatto_DK8: mov eax,[act_K09] cmp eax,1 jne tocca_a_me_DK8 K9_is_attivo_DK8: mov eax,[P3_9] cmp eax,1 je tocca_a_me_DK8 jmp fine_decodkiave8_pre ;BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB tocca_a_me_DK8: ;nessuna delle condizioni di cui sopra, sono io che devo lavorare ;mov eax,"IDK8" ;call visualizza call esegui_funzione_789_K jmp fine_decodkiave8_pre ;------------------- K79_viene_dopo_DK: ;mettere qui le routine per lasciare il buffer pronto per K8 oppure K9 mov eax,"DK79" call visualizza jmp fine_decodkiave8_pre ;======================TUTTO QUI===================== fine_decodkiave8_pre: call allinea_BUFF_DK fine_decodkiave8_pre2: mov eax,[PIN_COD08] xor [Ptr_2_buffKeys_attuale_2_DK],eax mov esi,[P1max] inc esi mov [P1max],esi fine_decodkiave8: popa ret ;--------------------------------- decodkiave9: pusha mov ecx,[l_buff_da_DE_cryptare] cmp ecx,1 jna near fine_decodkiave9 mov dword [P3_9],0 mov dword [P3_9max],0 mov esi,buff_vuoto_2mega mov dword [P3_9_p],esi inc esi mov dword [P3_9max_p],esi mov eax,[act_K09] cmp eax,1 jne near fine_decodkiave9 ;mov eax,"DK09" ;call visualizza mov dword [P3_9],1 ;================================================ ;������������������������������������������������ ;-------------------Il messaggio---------------- mov esi,buffer_2recv add esi,[l_header] add esi,6 mov [P1],esi add esi,[l_buff_da_DE_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi ;mov esi,[P1] ;ok in esi P1max ;=======BLOCCO DA Riprist. se non FUNZIA======== ;--------------------La chiave------------------ mov ebp,K9a ;��������������� mov eax,[som_PIN_COD09] add eax,[l_buff_da_cryptare] cmp eax,[P3_master] jbe no_master_DK9 mov [P3_master],eax no_master_DK9: ;��������������� mov edx,[Ptr_2_buffKeys_attuale_2_DK] mov eax,[som_PIN_COD09] ;--------------------------------- add ebp,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] add edx,ebp xor edx,[PIN_COD09] mov [P3_9_p],edx add edx,[l_buff_da_DE_cryptare] add edx,[som_PIN_COD09] mov [P3_9max_p],edx ;mov edx,[P3] ;------------------------------------------------- ;================================================= mov ecx,[l_buff_da_DE_cryptare] cmp ecx,1 jna near fine_decodkiave9_pre2 dec ecx ;mettiamolo zero_based ;----------------------------------------------- ;precalcoliamo P3max inizia_DK9: ;������������������������������������������������ ;================================================ ;======CONTROLLI INIZIALI========================= mov eax,[act_K08] cmp eax,1 je K8_is_attivo_DK9 mov eax,[act_K07] cmp eax,1 je K7_is_attivo_DK9 jmp tocca_a_me_DK9 K8_is_attivo_DK9: mov eax,[P3_8] cmp eax,1 je K8_gia_fatto_DK9 jmp fine_decodkiave9_pre K8_gia_fatto_DK9: mov eax,[act_K07] cmp eax,1 jne tocca_a_me_DK9 K7_is_attivo_DK9: mov eax,[P3_7] cmp eax,1 je tocca_a_me_DK9 jmp fine_decodkiave9_pre ;BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB tocca_a_me_DK9: ;nessuna delle condizioni di cui sopra, sono io che devo lavorare ;mov eax,"IDK9" ;call visualizza call esegui_funzione_789_K jmp fine_decodkiave9_pre ;------------------- K78_viene_dopo_DK: ;mettere qui le routine per lasciare il buffer pronto per K8 oppure K9 mov eax,"DK78" call visualizza jmp fine_decodkiave9_pre ;======================TUTTO QUI===================== fine_decodkiave9_pre: call allinea_BUFF_DK fine_decodkiave9_pre2: mov eax,[PIN_COD09] xor [Ptr_2_buffKeys_attuale_2_DK],eax mov esi,[P1max] inc esi mov [P1max],esi fine_decodkiave9: popa ret ;--------------------------------- decodkiave10: pusha mov eax,[act_K00] cmp eax,1 jne near fine_decodkiave10 ;mov eax,"DK10" ;call visualizza ;-------------------Il messaggio---------------- mov esi,buffer_2recv add esi,[l_header] add esi,6 mov [P1],esi add esi,[l_buff_da_DE_cryptare] dec esi ;zero based ;dec esi ;eliminare anche 0xa mov [P1max],esi ;mov esi,[P1] ;ok in esi P1max ;=======BLOCCO DA Riprist. se non FUNZIA======== ;--------------------La chiave------------------ mov ebp,K0a mov edx,[Ptr_2_buffKeys_attuale_2_DK] mov eax,[som_PIN_COD10] ;--------------------------------- add ebp,eax ;[Ptr_2_buffKeys_attuale] ;[Ptr_2_buffKeys_precedente] add edx,ebp xor edx,[PIN_COD10] mov [P3],edx add edx,[l_buff_da_DE_cryptare] add edx,[som_PIN_COD10] mov [P3max],edx mov edx,[P3] ;------------------------------------------------- ;================================================= mov ecx,[l_buff_da_DE_cryptare] cmp ecx,0 jna near fine_codkiave10 dec ecx ;mettiamolo zero_based ;----------------------------------------------- ;precalcoliamo P3max inizia_DK10: ;=================================================================================== ;La kiave10 come chiave complessa usa i bit della key per traslare a gruppi di 8 i byte ;del messaggio originale verso l'inizio; esempio: ;kiave10 (bit) 0010 0100 ;messaggio: ABCDEFGH ;usando kiave10 il messaggio diventa: ;1� passaggio: CABDEFGH ;2� passaggio: FCABDEGH ;il tutto ripetuto sui successivi gruppi di 8 bytes di messaggio tante volte quanti ;sono i bytes di kiave9 ;:------------------------------------------ ; |------------------------------:Messaggio.............| ;buffer_2_send -----^ buffer_2send_dopo = P1 -----^ ; |------------------------:LmCodkMessaggio.............| ;buff_crypt_start --^ buff1_2K_defa -----^ ^---P2 ; |---------------------------------------------............--------------------| ; riempi1 (buff da 2 mega) <----ebp...-^-...edi----> ; |----------------------------------------i----------------f--------------| ; Kna--^ Ptr_2_buffKeys_attuale= P3---^ ^---P3max ;==================================================================================== mov dword [op_ebp],0 mov dword [op_edi],0 mov esi,[P1max] mov edx,[P3] mov ebp,riempi1 ; buff da 2 mega add ebp,512 ;mettiamoci a distanza sufficiente dall'inizio per ricevere ;l'intero messaggio se tutti i bit della chiave sono a 1 mov edi,ebp ;sincr edi e ebp; edi incrementa se bit =0, ebp decrementa se bit=1 inc edi ;dec ebp inizia_DK10_1: mov bl,[edx] mov cl,8 va_esi_DK10: mov al,[esi] clc shl bl,1 jc is_1_DK10 rol al,2 ;mov [edi],al ;inc edi ;jmp dopo_is_1_DK10 is_1_DK10: mov [ebp],al dec ebp dopo_is_1_DK10: dec esi cmp esi,[P1] jae va_a_deccl_DK10 call rimetti_riempi1_2_P1_DK ;rimetti nel buffer iniziale jmp fine_decodkiave10_pre ;provvisorio ;mov esi,[P1] ;inc edx ;cmp edx,[P3max] ;ja fine_decodkiave10_pre ;jmp inizia_DK10_1 va_a_deccl_DK10: dec cl jnz va_esi_DK10 inc edx cmp edx,[P3max] ja fine_decodkiave10_pre jmp inizia_DK10_1 fine_decodkiave10_pre: call allinea_BUFF_DK mov eax,[PIN_COD10] xor [Ptr_2_buffKeys_attuale_2_DK],eax fine_decodkiave10: popa ret ;--------------------------------- decodkiave11: pusha mov eax,[act_K11] cmp eax,1 jne fine_decodkiave11 mov eax,"DK11" call visualizza fine_decodkiave11_pre: mov eax,[PIN_COD11] xor [Ptr_2_buffKeys_attuale_2_DK],eax fine_decodkiave11: popa ret ;--------------------------------- decodkiave12: pusha mov eax,[act_K12] cmp eax,1 jne fine_decodkiave12 mov eax,"DK12" call visualizza fine_decodkiave12_pre: mov eax,[PIN_COD12] xor [Ptr_2_buffKeys_attuale_2_DK],eax fine_decodkiave12: popa ret ;--------------------------------- decodkiave13: pusha mov eax,[act_K13] cmp eax,1 jne fine_decodkiave13 mov eax,"DK13" call visualizza fine_decodkiave13_pre: mov eax,[PIN_COD13] xor [Ptr_2_buffKeys_attuale_2_DK],eax fine_decodkiave13: popa ret ;-------------------------------------------------- primo_passo_fase_DK: pusha mov esi,buffer_2recv add esi,[l_header] add esi,6 ;2 + 4 bytes mov [P1],esi add esi,[l_buff_da_DE_cryptare] ;add ecx,2 ;0xD 0xA mov [P1max],esi mov esi,[P1] mov ebp,K2a mov edx,[Ptr_2_buffKeys_attuale_2_DK] add edx,ebp mov [P3],edx add edx,[l_buff_da_DE_cryptare] add edx,[som_PIN_CODE] mov [P3max],edx popa ret ;----------------------------- primo_passo_DK: pusha ; call sorrispondente decript di codifica_0AD ; chiamarlo decodifica_0AD ;jmp fine_primo_passo ;provvisorio mov dword [errore_l_mesg],0 codifica_0AD_up_pp: ;serve a de_codificare i bytes 0,A,D del paccketto buff1_2K_defa ;altrimenti non accettati dal server ;call pulisci_buff_provv_32k call pulisci_buff1_2K_defa xor ebx,ebx mov edi,buff1_2K_defa ;buff_provv_32k mov esi,buffer_2recv ;buff1_2K_defa mov ecx,512 cod_0AD1x_poiup_pp: mov al,[esi] cmp al,0xa je near is_AD_cod_0ADup_pp cmp al,0xd je near is_AD_cod_0ADup_pp mov eax,[esi] cmp eax,[codice_0AD] je near is_0AD_pp mov [edi],al inc edi inc esi su_dec_pp: dec ecx jnz cod_0AD1x_poiup_pp jmp is_A_cod_0ADup_pp_dopo is_0AD_pp: mov al,0 mov bx,[esi+4] ;bswap ebx ;rol ebx,16 cmp bx,[identificativo_0AD] je is_0_pp sub bx,0xa cmp bx,[identificativo_0AD] je is_A_pp sub bx,3 cmp bx,[identificativo_0AD] je is_D_pp jmp is_A_cod_0ADup_pp_dopo is_0_pp: mov al,0 mov [edi],al add esi,6 inc edi jmp su_dec_pp is_A_pp: mov al,0xa mov [edi],al add esi,6 inc edi jmp su_dec_pp is_D_pp: mov al,0xD mov [edi],al add esi,6 inc edi jmp su_dec_pp is_A_cod_0ADup_pp_dopo: ;c'e' un errore quindi manipolarlo avvisando... mov eax,"ERR " call visualizza mov eax,"MESG" call visualizza jmp fine_primo_passo_err is_AD_cod_0ADup_pp: ;finito, OK mov al,0xd mov [edi],al mov al,0xa inc edi mov [edi],al mov esi,buff1_2K_defa ;buff_provv_32k add esi,[l_header] xor ebx,ebx mov bx,[esi] ;lungh messaggio cmp bx,512 jna ok_MSG_giusto_pp mov dword [errore_l_mesg],1 jmp fine_primo_passo_err ok_MSG_giusto_pp: mov [l_buff_da_DE_cryptare],ebx mov ebx,[esi+2] ;Ptr_2CodKey xor ebx,[PIN_CODE] mov [Ptr_2_buffKeys_attuale_2_DK],ebx ;mov [l_buff_da_DE_cryptare],ebx ;salviamo bx su variabile lungh_messaggio ; e ebx su Pointer su BufferKeys attuale per Decript mov ebx,[l_buff_da_DE_cryptare] add ebx,[l_header] add ebx,8 ;+2 +4 e 0d+0ah ;inc ebx ;mov eax,ebx ;add eax,[l_header] ;call errorizza mov ecx,512 ;max lungh altrimenti errore mov esi,buff1_2K_defa ;buff_provv_32k mov edi,buffer_2recv call pulisci_buffer_2recv mov edi,buffer_2recv is_A_cod_0ADup_dopopp: mov al,[esi] mov [edi],al inc edi inc esi dec ecx jz fine_primo_passo_err dec ebx jnz is_A_cod_0ADup_dopopp fine_primo_passo: ;mov esi,buffer_2recv ;buff_provv_32k ;buffer_2recv ;call debugga fine_primo_passo_err: ;mov eax,"NOnP" ;call visualizza ;mov eax,ecx ;call errorizza popa ret ;--------------------- ;���������������������������������������������������������������������������������������� ;���������������������������������������������������������������������������������������� ;tools.asm ;queste sono routine utili e /o di servizio; si possono utilizzare per svariati usi ;leggere attentamente la testata di ogni routine rima di utilizzarla per altri scopi. ;---------------ROUTINES------- (00-0)------------------------- ;---------------ROUTINES------- (00)------------------------- ;getkey: EXTERNAL in comandi.asm msg_comando_accettato: pusha ;mov ebx,msg_acc ;mov [ebx],eax mov eax,4 mov ebx,1 mov ecx,msg_accettato mov edx,[msg_acc_l] int 0x80 popa ret ;---------------ROUTINES------- (01)------------------------- pulisci_buffer_2recv: pusha mov esi,buffer_2recv mov ecx,511 mov al,0 pul_b2r: mov [esi],al inc esi dec ecx jnz pul_b2r mov al,0x0A mov [esi],ax popa ret ;---------------ROUTINES------- (01-A)------------------------- pulisci_buff1_2K_defa: pusha mov esi,buff1_2K_defa mov ecx,1024 mov al,0 pul_b2r_2kdefa: mov [esi],al inc esi dec ecx jnz pul_b2r_2kdefa mov al,0x0A mov [esi],ax popa ret ;---------------ROUTINES------- (01 A)-------------------------- vedi_stack_su_buff: ;serve per capire in quale area di ram si trova il programma in esecuzione, ;in [esp] e' salvato l'indirizzo di ritorno successivo all'istruzione chiamante ;lo salviamo in [sono_qui] e ritorniamo al chiamante mov eax,[esp] mov [sono_qui],eax ret ;---------------ROUTINES------- (02)------------------------- debugga: ; Entra coi registri ATA (As They Are) tranne esi che punta a un'area di memoria ; e visualizza fotograficamente cio' che succede (come il debug del DOS) ; Da usarsi come debugger chiamandolo da una posizione qalsiasi per visualizzare ; tutti i registri e un'area di 16 x 16 bytes di RAM. ; Successivamente potra' usarsi come vero e proprio debugger pusha ini_deb: push esi ;prima cosa salviamo esi mov esi,rt2 add esi,3 ;per poter stampare il contenuto di eax usando esi come ptr sul buff call esadecizza_su_buff pop esi push esi ;ora stampiamo il valore di esi mov eax,esi ;messo in eax mov esi,rt2 ;usando acora esi come ptr sul buff add esi,43 call esadecizza_su_buff mov eax,ebx ; ora stampiamo ebx mov esi,rt2 add esi,13 call esadecizza_su_buff mov eax,ecx ;ora ecx mov esi,rt2 add esi,23 call esadecizza_su_buff mov eax,edx mov esi,rt2 add esi,33 call esadecizza_su_buff mov eax,edi mov esi,rt2 add esi,53 call esadecizza_su_buff pop esi mov edi,esi and edi,0xFFFFFF00 ;alignment alla pagina :)) mov eax,ebp mov esi,rt2 add esi,63 call esadecizza_su_buff mov eax,esp mov esi,rt2 add esi,73 call esadecizza_su_buff ;ora prendiamo il valore di EIP; non e' esattamente quello corretto ma siamo ;nelle vicinanze (E' GIUSTO se si chiama debugga subito dopo aver chiamare la routine dove_siamo) ;call dove_siamo ;va chiamata PRIMA di entrare qui mov eax,[sono_qui] mov esi,rt5 add esi,3 call esadecizza_su_buff ;in eax il valore di EIP e in esi il punto di inizio del buff push cs ;torna in ax il valore de reg di seg pop eax ; mov ax,0x5AF3 ;provv mov esi,rt5 add esi,13 call esadecizza_ax_su_buff ;in ax il valore di CS ; call esadecizza_su_buff ; call visualizza push ds pop eax mov esi,rt5 add esi,18 call esadecizza_ax_su_buff ;in ax il valore di DS push es pop eax mov esi,rt5 add esi,23 call esadecizza_ax_su_buff ;in ax il valore di ES push ss pop eax mov esi,rt5 add esi,28 call esadecizza_ax_su_buff ;in ax il valore di SS push fs pop eax mov esi,rt5 add esi,33 call esadecizza_ax_su_buff ;in ax il valore di FS push gs pop eax mov esi,rt5 add esi,38 call esadecizza_ax_su_buff ;in ax il valore di GS ; mov al,200 ; add al,1 pushfw ;lahf pop ax ;mov al,ah ; mov al,0Fh push ax mov esi,rt5 add esi,63 call binarizza_al ;la parte inferiore di EFLAGS pop ax mov al,ah mov esi,rt5 add esi,53 call binarizza_al ;la parte superiore di EFLAGS mov esi,[inizio_buff] mov eax,esi mov esi,rt7 add esi,3 call esadecizza_su_buff ; e che andiamo a mettere nella zona da dumpare mov esi,[fine_buff] mov eax,esi mov esi,rt8 add esi,3 call esadecizza_su_buff mov esi,edi ; ridondande, ma e' per capire che abbiamo a che fare con esi and esi,0xFFFFFF00 ; che avevamo salvato temporaneamente su edi mov eax,esi mov esi,r1 add esi,2 call esadecizza_su_buff ; e che andiamo a mettere nella zona da dumpare mov esi,r1 ; ora piazziamo i valori HEX della ram a 2 bytes per volta add esi,14 ; nel buffer riservato ai valori HEX mov ebp,r1 ; e i valori ASCII nel buff riservato add ebp,65 ; ai valori ASCII se stampabili altrimenti resta il puntino . mov edx,16 ; 2 blocchi da 16 colonne ciascuna dbg_1A_pre: mov ecx,8 mov ebx,2 dbg_1A: mov al,[edi] ;leggiamo la ram push esi mov esi,ebp ; mov al,"A" ;provvisorio call vis_al ; mette il valore ASCII se stampabile nel buff pop esi call esadecizza_al ;ora lo rende esadecimale e lo mette nell'area HEX del buff inc ebp ;al carattere ASCII successivo inc edi add esi,3 ;alla zona HEX successiva (2 char+1 space = 3) dec ecx jnz dbg_1A ; 8 caratteri piazzati? se no continua altrimenti inc esi ;supera lo spazio di separazione dei Blocchi aumentando di 1 i ptrs mov ecx,8 ; e ricomincia da 8 inc ebp dec ebx jnz dbg_1A ; operazione da ripetere 2 volte per ogni riga add esi,35 add ebp,67 cmp edx,9 ;qui controlliamo se siamo alla separazione delle 8 righe jne va_8 add esi,85 add ebp,85 va_8: dec edx ; tutto da ripetere per 16 righe jnz dbg_1A_pre mov ecx,schema ;una volta sistemato completamente lo schema, stampiamolo mov edx,[l_schema] ;2476 call msg_gen ;mov al,"q" call w_ch cmp al,"W" je near write_salva_su_file cmp al,"q" je near fine_deb cmp al,0x1B je near fine_deb cmp al,"x" je near fine_deb cmp al,"M" je near modifica_val_db cmp al,"m" je near modifica_val_db cmp al,"D" je near dumpa_ind cmp al,"h" je near help_dumpa cmp al,"I" je near cambia_inizio_file cmp al,"F" je near cambia_fine_file cmp al,"u" jne near is_down_forse sub edi,512 ;512 is_down_forse: ; call errorizza mov esi,edi jmp ini_deb cambia_inizio_file: pusha mov ecx,input_msg_I mov edx,58 call msg_gen mov eax,8 ;8 caratteri XXXXXXXX call input_su_buff256 mov ecx,0 mov edx,6 mov ebp,inizio_buff dumpa_ind_018v_cif: mov ax,[buff_provv+edx] call numerizza_ax_hex mov [ebp+ecx],al inc ecx sub edx,2 jnz dumpa_ind_018v_cif mov ax,[buff_provv] call numerizza_ax_hex mov [ebp+ecx],al mov eax,[fine_buff] mov ebx,[inizio_buff] sub eax,ebx inc eax ;zero based mov [b_letti],eax ; call errorizza ;entra con ax contenente Numero ASCII HESADECIMALE tipo "A4" (41h 34h); ritorna ;con eax contenente corrispondente valore numerico 164 = 00000A04 ;mov edi,[fine_buff] call w_ch popa sub edi,256 mov esi,edi jmp ini_deb cambia_fine_file: pusha mov ecx,input_msg_F mov edx,56 call msg_gen mov eax,8 ;8 caratteri XXXXXXXX call input_su_buff256 mov ecx,0 mov edx,6 mov ebp,fine_buff dumpa_ind_018v_cff: mov ax,[buff_provv+edx] call numerizza_ax_hex mov [ebp+ecx],al inc ecx sub edx,2 jnz dumpa_ind_018v_cff mov ax,[buff_provv] call numerizza_ax_hex mov [ebp+ecx],al mov eax,[fine_buff] mov ebx,[inizio_buff] sub eax,ebx inc eax ;zero based mov [b_letti],eax ; call errorizza ;entra con ax contenente Numero ASCII HESADECIMALE tipo "A4" (41h 34h); ritorna ;con eax contenente corrispondente valore numerico 164 = 00000A04 ;mov edi,[fine_buff] call w_ch popa sub edi,256 mov esi,edi jmp ini_deb dumpa_ind: pusha mov ecx,input_msg_dumpa mov edx,45 call msg_gen mov eax,8 ;5 caratteri XX YY call input_su_buff256 mov ecx,0 mov edx,6 mov ebp,val_fin dumpa_ind_018v: mov ax,[buff_provv+edx] call numerizza_ax_hex mov [ebp+ecx],al inc ecx sub edx,2 jnz dumpa_ind_018v mov ax,[buff_provv] call numerizza_ax_hex mov [ebp+ecx],al mov eax,[val_fin] ; call errorizza call w_ch ;entra con ax contenente Numero ASCII HESADECIMALE tipo "A4" (41h 34h); ritorna ;con eax contenente corrispondente valore numerico 164 = 00000A04 popa mov edi,[val_fin] mov esi,edi jmp ini_deb help_dumpa: pusha mov ecx,input_msg_help mov edx,196 call msg_gen call w_ch popa sub edi,256 mov esi,edi jmp ini_deb write_salva_su_file: push esi push edi mov eax,[validate_file] cmp eax,1 jne fine_wssf ; inserire qui call aprifile ; call scrivi file mov ebx,[p_file_iniziale] mov edi,fd_W1 call crea_file_w mov edx,[b_letti] mov ebx,[fd_W1] mov [fd_generico],ebx mov esi,[inizio_buff] call scrivi_su_file mov eax,6 ;chiudi file mov ebx,[fd_W1] int 0x80 mov ecx,ok_scritto ;una volta sistemato completamente lo schema, stampiamolo mov edx,38 call msg_gen ;call w_ch fine_wssf: pop edi pop esi sub edi,256 mov esi,edi jmp ini_deb modifica_val_db: mov ecx,input_msg mov edx,36 call msg_gen mov eax,5 ;5 caratteri XX YY call input_su_buff256 ;xor eax,eax mov ax,[buff_provv] call numerizza_ax_hex add edi,eax ;provvisorio sub edi,256 mov esi,edi mov ax,[buff_provv+3] call numerizza_ax_hex mov [esi],al pusha ; call errorizza call w_ch popa jmp ini_deb fine_deb: popa ret ;---------------ROUTINES------- (03)------------------------- ; entra con al numero da binarizzare e esi buff di 8 bytes dove salvare il risultato binarizza_al: pusha mov cl,7 mov bl,al bin_al_01: ror al,cl and al,1 or al,30h mov [esi],al inc esi mov al,bl dec cl jnz bin_al_01 and al,1 or al,30h mov [esi],al popa ret ;---------------ROUTINES------- (04)------------------------- ; entra con al numero da esadecizzare e esi buff di 2 bytes dove salvare il risultato ; ritorna in ax il valore di al esadecizzato (max FF) esadecizza_al: pusha mov bl,al and al,0xF0 ror al,4 or al,30h cmp al,39h jna ok_esadec add al,7 ok_esadec: mov [esi],al mov ah,al inc esi mov al,bl and al,0xF or al,30h cmp al,39h jna ok_esadecf add al,7 ok_esadecf: mov [esi],al mov [provv],ax popa mov ax,[provv] ret ;---------------ROUTINES------- (05)------------------------- ; entra con al carattere da visualizzare ed esi buff di 1 byte dove salvare il risultato ; controlla se il carattere e' stampabile (20h -7Eh) altrimenti non viene eseguito vis_al: pusha cmp al,20h ; no caratteri di controllo del cazzo jb no_vis cmp al,7Eh ; caratteri del cazzo che simulano backspace meglio escluderli ja no_vis mov [esi],al popa ret no_vis: mov al,"." mov [esi],al popa ret ;---------------ROUTINES------- (06)------------------------- ; entra con ax valori da esadecizzare e in esi buff di 4 byte dove salvare il risultato ; torna in eax una copia del valore esadecizzato (max FFFF) esadecizza_ax_su_buff: pusha mov ecx,4 add esi,3 mov ebx,eax ax_prima1_err_lett: and al,0Fh or al,30h cmp al,39h jna ax_oltre1_err_lett add al,7 ax_oltre1_err_lett: mov [esi],al dec esi dec ecx jz ax_oltre2_err_lett mov eax,ebx ror eax,4 mov ebx,eax jmp ax_prima1_err_lett ax_oltre2_err_lett: inc esi mov eax,[esi] mov [provv],eax popa mov eax,[provv] ret ;---------------ROUTINES------- (07)------------------------- ; Entra con Ecx settato come ptr to stringa e Edx n. di Bytes da stampare msg_gen: mov eax,4 ;write nel canale indicato da ebx mov ebx,1 ;1= std output int 0x80 ret ;---------------ROUTINES------- (08 STD)------------------------- ;entra con eax pointing to STRUC_mesg ; ;STRUC_mesg: ;msg_0 dd ptr to ASCII_STRING ;msg_leng dd length_of_string ;chan_ID dd chan_ID --> 1 = std out ; MODIFICATO Entra con Ecx settato come ptr to stringa e Edx n. di Bytes da stampare msg_gen_STD: pusha mov ecx,[eax] ;ptr to string mov edx,[eax+4] ;ptr to string_lenght mov ebx,[eax+8] ;chan_ID --> 1 = std out mov eax,4 ;funzione write nel canale indicato da ebx ;mov ebx,1 ;1= std output int 0x80 popa ret ;-----------------ROUTINES------- (09)--------------- ; Entra in eax con Codice di Errore: ritorna su codice_errore il valore hex in ASCII ; e lo visualizza come Codice Errore ........fino a FFFFFFFF errorizza: ;push esi mov esi,codice_errore mov byte [provv],1 ;pop esi esadecizza_su_buff: ;entra con eax il codice hex e esi che punta su buffer dove si vuole eax esadecizzato ;fino a FFFFFFFF pusha mov ecx,8 add esi,7 mov ebx,eax prima1_err_lett: and al,0Fh or al,30h cmp al,39h jna oltre1_err_lett add al,7 oltre1_err_lett: mov [esi],al dec esi dec ecx jz oltre2_err_lett mov eax,ebx ror eax,4 mov ebx,eax jmp prima1_err_lett oltre2_err_lett: cmp byte[provv],1 jne fine_errorizza mov ecx,msg_err_file mov edx,30 call msg_gen fine_errorizza: mov byte[provv],0 popa ret ;---------------ROUTINES------- (10)------------------------- crea_file_w: ; entra con edi=fd_xxx ; in ebx = nome_file ;mov dword [err],0 push ebx mov eax,8 ;crealo ;mov ebx,file_EnoC mov ecx,[mask2_w] ;stavolta permissions in ecx int 0x80 mov ebx,eax ;fdescriptor chiudilo mov eax,6 int 0x80 pop ebx ;nome file mov eax,5 ;mov ebx,file_EnoC mov ecx,[mask1_w] mov edx,[mask2_w] int 0x80 mov [edi],eax ;fd in edi cmp eax,0xFFFF jna fine_crea_w mov dword [err],1 fine_crea_w: ret ;---------------ROUTINES--------(11)----------------------- esegui_letture: ; esegue letture su files multipli e accoda i dati in un unico buffer ; buff1 = 30.000.000 di bytes ; entra con ebx = nomefile e ecx = ptr to lunghezza_file ; ritorna con eax= fd_xxx ; NO! e setta lungh_file_xx in lunghezza_file ; NO! e setta validate_file_xx se il file viene letto tutto mov eax,5 ;mov ebx,file_iniziale mov ecx,[mask1] ;bitmask tipo accesso r-w-a mov edx,[mask2] ;bitmask file permission int 0x80 mov [fd1],eax cmp eax,0xFFFF jna apri_file_lett_1 mov dword[err],1 jmp fine_letture apri_file_lett_1: mov ecx,buff1 ;buff dove ricevere i bytes add ecx,[b_letti] mov ebx,[fd1] ;fd in ebx mov eax,3 ;read mov edx,3000000 ;[b_da_legg] dd 1024000 bytes int 0x80 cmp edx,eax je apri_file_lett_1_dopo1 ; se letti bytes quanto richiesti no EOF cmp eax,0 je apri_file_lett_1_dopo1 ; se nessun byte letto mov edx,1 mov [validate_file],edx ; mov ecx,eax ;inc eax apri_file_lett_1_dopo1: add [b_letti],eax mov ebx,[b_letti] mov eax,buff1 mov [inizio_buff],eax mov [inizio_buff1],eax add eax,ebx dec eax ;indirizzo zero based quindi se 1 solo byte inizia e finisce allo stesso indir. mov [fine_buff],eax mov [fine_buff1],eax mov esi,buff1 dec ebx mov al,[esi+ebx] cmp al,0x20 jb apri_file_lett_1_siA mov al,0xA inc ebx add dword[b_letti],1 mov [esi+ebx],al ; mov bl,0ah ; mov [esi+eax],bl apri_file_lett_1_siA: cmp eax,edx je fine_letture ;if edx > eax then EOF e if eax=0 nessun byte nuovo letto mov dword [EOF1],1 cmp eax,0 ja fine_letture mov dword[err],1 fine_letture: mov eax,6 ;chiudi file mov ebx,[fd1] int 0x80 ret ;================================================== leggi_file_F: ; esegue letture su files multipli e accoda i dati in un unico buffer ; buff1 = 30.000.000 di bytes ; entra con ebx = nomefile e ecx = ptr to lunghezza_file ; ritorna con eax= fd_xxx ; NO! e setta lungh_file_xx in lunghezza_file ; NO! e setta validate_file_xx se il file viene letto tutto mov dword [err],0 mov edx,0 mov [validate_file],edx mov [ok_file_F],edx mov eax,0 mov [lungh_buff_file_F],eax mov eax,5 ;mov ebx,file_iniziale mov ecx,[mask1] ;bitmask tipo accesso r-w-a mov edx,[mask2] ;bitmask file permission int 0x80 mov [fd1],eax cmp eax,0xFFFF jna apri_file_lett_1_F mov dword[err],1 jmp fine_letture_F apri_file_lett_1_F: mov ecx,buff1 ;buff dove ricevere i bytes ;add ecx,[b_letti] mov ebx,[fd1] ;fd in ebx mov eax,3 ;read mov edx,3000000 ;[b_da_legg] dd 1024000 bytes int 0x80 cmp edx,eax je apri_file_lett_1_dopo1_F ; se letti bytes quanto richiesti no EOF cmp eax,0 je apri_file_lett_1_dopo1_F ; se nessun byte letto mov edx,1 mov [validate_file],edx mov [ok_file_F],edx ; mov ecx,eax ;inc eax apri_file_lett_1_dopo1_F: mov [lungh_buff_file_F],eax fine_letture_F: mov eax,6 ;chiudi file mov ebx,[fd1] int 0x80 ;mov esi,buff1 ;call debugga ;jmp fine ret ;======================================================= ;-----------------ROUTINES-----(12)-------------------------- visualizza: ;entra con 4 bytes ascii in eax ritorna in visualizza push eax push ecx push edx push edi push ebx mov edi,asci4 mov [edi],eax mov ecx,msg_ascizza ;usa un msg generico mov edx,24 ;in msg_gen si entra con Ecx settato come ptr to stringa e Edx n. di Bytes da stampare call msg_gen pop ebx pop edi pop edx pop ecx pop eax ret ;-------------------ROUTINES-----(13)-------------------------- scrivi_su_file: ;entra con edx= N.bytes da scrivere ; esi = inizio buffer ; fd_generico = fd_di file gia open push ecx mov ecx,esi ;inizio buffer mov ebx,[fd_generico] ; [fd_generico] mov eax,4 int 0x80 pop ecx ret ;---------------ROUTINES------- (14)------------------------ ritardo: push ecx mov ecx,0xFFFFFFF rit1: dec ecx jnz rit1 pop ecx ret ;--------------ROutines----------(15)-------------------- ascizzaNsu_buff_4ch: ; entra con eax = valore da ascizzare ; edi = ptr su buff (4 bytes .. fino a 9999) pusha push ebp mov ebp,10 mov ebx,3 mov ecx,4 asN_01_4ch: xor edx,edx div ebp or dl,30h mov [edi+ebx],dl dec ebx dec ecx jnz asN_01_4ch ;mov ecx,tot_connA ;mov edx,12 ;call msg_gen pop ebp popa ret ;---------------ROUTINES-------(16)------------------------- ascizzaNsu_buff_2ch: ; entra con eax = valore da ascizzare ; edi = ptr su buff (2 bytes .. fino a 99) pusha push ebp mov ebp,10 mov ebx,1 mov ecx,2 asN_01_2ch: xor edx,edx div ebp or dl,30h mov [edi+ebx],dl dec ebx dec ecx jnz asN_01_2ch ;mov ecx,tot_connA ;mov edx,12 ;call msg_gen pop ebp popa ret ;---------------ROUTINES-------(17)------------------------- ascizzaNsu_buff: ; entra con eax = valore da ascizzare ; edi = ptr su buff (10 bytes .. fino a 4294967296 ) pusha push ebp mov ebp,10 mov ebx,9 mov ecx,10 asN_01: xor edx,edx div ebp or dl,30h mov [edi+ebx],dl dec ebx dec ecx jnz asN_01 ;mov ecx,tot_connA ;mov edx,12 ;call msg_gen pop ebp popa ret ;---------------ROUTINES-------(18)------------------------- cerca_host: ;entra con puntatore su esi a inizio stringa fino a 0xA ;ritorna in eax, distanza da base esi di host xxx.yyy.zzz.aaa pusha mov dword [provv],0 xor edx,edx mov ecx,180 ;controlliamo max 180 +34 caratteri mov ebx,34 ;minimo partiamo da poco prima di @ ; jmp fine_cerca_host_ok mov eax,[esi+26] ; jmp fine_cerca_host_ok cmp eax,"EXIT" je is_ex_c_ch mov edx,1 ;mov dword[conn_o_exit],1 ;default = 0 Exit ;je near is_conn_ch1pq is_ex_c_ch: inc ebx dec ecx jnz is_exit_chpq jmp fine_cerca_host_no_ok is_exit_chpq: ;ricercare 2 parentesi quadre aperte mov al,[esi+ebx] cmp al,"@" jne is_ex_c_ch inc ebx dec ecx jz near fine_cerca_host_no_ok mov eax,[esi+ebx] cmp eax,"host" je near cont_1b_okhost cmp eax,"80.1" je near cont_1b_okhost cmp eax,"212." je cont_1b_okhost cmp eax,"213." je cont_1b_okhost cmp eax,"62.2" je cont_1b_okhost cmp eax,"82.4" je cont_1b_okhost cmp eax,"82.5" je cont_1b_okhost cmp eax,"82.6" je cont_1b_okhost cmp eax,"87.0" je cont_1b_okhost cmp eax,"87.1" je cont_1b_okhost cmp eax,"87.2" je cont_1b_okhost cmp eax,"87.3" je cont_1b_okhost mov edi,[edi_provv] push ebx mov ebx,[ebx_provv] mov eax,1 add ebx,2000004 mov [edi+ebx],eax pop ebx cont_1b_okhost: ;ora dobbiamo trovare le 2 (o 1) parentesi [ mov al,[esi+ebx] cmp al,"[" je ed_e_1a inc ebx dec ecx jnz cont_1b_okhost jmp near fine_cerca_host_no_ok ed_e_1a: cmp edx,1 je ed_e_ok ed_e_1: inc ebx dec ecx jz near fine_cerca_host_no_ok ;est connect quindi 1 sola parentesi mov al,[esi+ebx] cmp al,"[" je ed_e_ok jmp ed_e_1 ed_e_ok: inc ebx ;--------------------------------- fine_cerca_host_ok: mov [provv],ebx fine_cerca_host_no_ok: popa mov eax,[provv] ret ;-----------ROUTINES------- (19)------------------------- ;cerca_EXIT: ;extern su file cerca_EX.asm ;---------------ROUTINES------- (20)------------------------ ;cerca_CONNECT: ;extern su file cerca_CONN.asm ;---------------ROUTINES------- (21)------------------------- numerizza_mese: ;entra con eax contenente "Mes " ;ritorna con eax = 01 .. 12 oppure 00 in caso di errore push esi push ecx push ebx mov esi,mes mov ecx,12 num_mes_p1: mov ebx,[esi] cmp ebx,eax jne num_mes_p2 mov eax,[esi+4] jmp fine_num_mes num_mes_p2: add esi,12 dec ecx jnz num_mes_p1 xor eax,eax fine_num_mes: pop ebx pop ecx pop esi ret ;---------------ROUTINES------- (22)------------------------- numerizza_giorni_mese: ;entra con eax contenente "Mes " ;ritorna con eax = da 28 a 31 a secondo il mese di riferimento push esi push ecx push ebx mov esi,mes mov ecx,12 num_mes_p1_gm: mov ebx,[esi] cmp ebx,eax jne num_mes_p2_gm mov eax,[esi+8] jmp fine_num_mes num_mes_p2_gm: add esi,12 dec ecx jnz num_mes_p1_gm xor eax,eax fine_num_mes_gm: pop ebx pop ecx pop esi ret ;---------------ROUTINES------- (23)------------------------- numerizza_eax: ;entra con eax contenente ASCII numerici tipo "2005" ritorna ;con eax contenente corrispondente valore numerico 2005 push edi push ebx push ecx push edx xor edi,edi mov ebx,eax xor ecx,ecx xor edx,edx ror eax,24 ; 1234 e' scritto 4321 prendiamo il 4 and eax,0Fh ;togliamo la codifica ascii add edi,eax ;accumuliamolo in edi mov eax,ebx ror eax,16 and eax,0Fh mov ecx,10 mul ecx add edi,eax mov eax,ebx ror eax,8 and eax,0Fh mov ecx,100 mul ecx add edi,eax mov eax,ebx ;ror eax,16 and eax,0Fh mov ecx,1000 mul ecx add eax,edi ;ultima volta in eax fine_num_eax: pop edx pop ecx pop ebx pop edi ret ;---------------ROUTINES------- (24)------------------------- numerizza_ax: ;entra con ax contenente ASCII numerici tipo "12" ritorna ;con eax contenente corrispondente valore numerico 12 ;azzeriamo i primi 2 bytes di eax e chiamiamo la routine numerizza_eax ;per rispettare le inversioni and eax,0xFFFF rol eax,16 call numerizza_eax ret ;---------------ROUTINES------- (24.1)------------------------- numerizza_ax_hex: ;entra con ax contenente Numero ASCII HESADECIMALE tipo "A4" (41h 34h); ritorna ;con eax contenente corrispondente valore numerico 164 = 00000A04 pusha xor ecx,ecx mov bx,ax mov al,ah cmp al,39h jna ok_39_nh sub al,7 ok_39_nh: xor ah,ah and al,0Fh ; rol al,4 mov cl,al xor ch,ch mov al,bl cmp al,39h jna ok_39_nh_2 sub al,7 ok_39_nh_2: and al,0Fh rol al,4 add cl,al mov [provv],ecx popa mov eax,[provv] ret ;---------------ROUTINES------- (25)------------------------- ;calcola_secondi_e_tutto: ;extern su file calcola_sec.asm ;ultima routine eseguita ;---------------ROUTINES------- (26)------------------------- Natoi: ;entra in esi il puntatore a Internet Address tipo xxx.xxx.xxx.xxx ; torna in eax il valore INTERNET come numero puro pusha xor ebp,ebp xor ecx,ecx xor ebx,ebx xor edx,edx xor edi,edi mov edi,3 mov eax,10 Natoi_01: mov cl,[esi+ebp] cmp cl,"." je Nis_punto sub cl,30h cmp cl,9 ja Natoi_ok mul ch mov ch,al mov al,10 add ch,cl inc ebp cmp ebp,16 ja Natoi_err jmp Natoi_01 Nis_punto: dec edi inc ebp cmp ebp,16 ja Natoi_err ; inc edi ; cmp edi,3 ; ja Natoi_ok rol ebx,8 mov bl,ch mov al,10 mov ch,0 jmp Natoi_01 Natoi_err: mov dword [err],1 Natoi_ok: cmp edi,0 je Natoi_ok_dopo mov dword [err],1 Natoi_ok_dopo: rol ebx,8 mov bl,ch mov [provv],ebx popa mov eax,[provv] ret ;---------------ROUTINES------- (27)------------------------- ; sec_da_mezzanotte: ;external su calcola_sec_asm ;entra con: ;esi ptr su riga (EXIT) oppure (CONNECT) ;ritorna secondi da mezzanotte su eax ;---------------ROUTINES------- (28)------------------------- esplora_ram: ;entra con esi che punta a un'area della RAM si esce premendo ESC q o x ;si continua in avanti premendo un tasto qualsiasi (Invio) ; e premendo s e invio si va indietro (su nella ram) pusha xor ebp,ebp esplora_p1: mov ecx,provv_buff mov edx,1 ; numero caratteri mov ebx,1 ;standard input mov eax,3 ;funzione 3 read aspetta un carattere ;ecx ptr to input buffer ; edx buffer size, max. count of bytes to receive ;return eax no. of bytes received, file pointer advanced accordingly int 0x80 mov eax,[ecx] ;call errorizza call vis_ram add esi,4 call vis_ram add esi,4 call vis_ram add esi,4 call vis_ram add esi,4 call vis_ram add esi,4 call vis_ram add esi,4 call vis_ram add esi,4 call vis_ram mov al,[provv_buff] cmp al,27 je fine_esplora cmp al,"q" je fine_esplora cmp al,"x" je fine_esplora cmp al,"s" je vai_su_ram jmp esplora_p1 vai_su_ram: sub esi,64 call new_line jmp esplora_p1 fine_esplora: popa ret ;---------------ROUTINES------- (29)------------------------- --- vis_ram: ;entra con esi che punta su una area di memoria ;e viene visualizzato il contenuto di [esi] pusha add esi,2000000 ;provvisorio mov ecx,8 mov edi,indA add edi,7 mov eax,esi ; mov eax,esi mov ebx,eax prima1_err_lett_vr_esi1: and al,0Fh or al,30h cmp al,39h jna oltre1_err_lett_vr_esi1 add al,7 oltre1_err_lett_vr_esi1: mov [edi],al dec edi dec ecx jz oltre2_err_lett_vr_esi1 mov eax,ebx ror eax,4 mov ebx,eax jmp prima1_err_lett_vr_esi1 oltre2_err_lett_vr_esi1: ;------------------------------ mov ecx,8 mov edi,numindA add edi,7 mov eax,[esi] mov ebx,eax prima1_err_lett_vr_esi1F: and al,0Fh or al,30h cmp al,39h jna oltre1_err_lett_vr_esi1F add al,7 oltre1_err_lett_vr_esi1F: mov [edi],al dec edi dec ecx jz oltre2_err_lett_vr_esi1F mov eax,ebx ror eax,4 mov ebx,eax jmp prima1_err_lett_vr_esi1F oltre2_err_lett_vr_esi1F: ;--------------------- mov ecx,Indirizzo mov edx,32 ;32 byts call msg_gen popa ret ;---------------ROUTINES-------(30-a)------------------------- input_su_buff256: ;entra con ;eax N. bytes da ricevere ;esi buffer buff_provv (massimo 256 bytes) ;la funzione prevede: ;arg eax 3 ;ebx file descriptor ;ecx ptr to input buffer ;edx buffer size, max. count of bytes to receive pusha mov ecx,64 mov eax,0 mov esi,buff_provv inp_01: mov [esi],eax add esi,4 dec ecx jnz inp_01 popa pusha cmp eax,256 ja fine_inp mov edx,eax mov eax,3 mov ebx,1 mov ecx,buff_provv ;mov edx,256 int 0x80 fine_inp: popa ret ;---------------ROUTINES-------(30)------------------------- w_ch: ;senza parametri, attende un carattere da tastiera pusha ;arg eax 3 ;ebx file descriptor ;ecx ptr to input buffer ;edx buffer size, max. count of bytes to receive ;aspetta: ; mov ah,0 ; int 16h ; NON FUNZIONA ; jnz aspetta mov eax,3 mov ebx,1 ;1 char mov ecx,provv mov edx,256 int 0x80 ;mov [provv],eax popa mov eax,[provv] ret ;---------------ROUTINES-------(31)------------------------- ;---------------ROUTINES-------(32)------------------------- ;---------------ROUTINES-------(33)------------------------- new_line: pusha mov eax,4 ;arg eax 4 mov ebx,1 ;ebx file descriptor mov ecx,new_line1 ;ecx ptr to output buffer mov edx,2 ;edx count of bytes to send ;return eax no. of sent bytes (if POSIX conforming f.s.) int 0x80 popa ret ;---------------ROUTINES-------(34)------------------------- get_time: ; entra con eax = func 13 - ebx = 0 oppure Pointer to buff dove ricevere una copia ; restituisce in eax secondi trascorsi dalle ore 00:00:00 del 01/01/1970 a oggi pusha mov eax,13 mov ebx,provv int 0x80 add eax,3600 ; strano... manca 1 ora PROVVISORIOOOO almeno finche' non si chiarisce mov [provv],eax ;call errorizza ;call ascizza popa mov eax,[provv] ret ;---------------ROUTINES-------(35)------------------------- aggiusta_time: ; entra con eax = sec trasc dal 1970 (dopo call get_time) e in esi = ; buff_struc_time: ; t_MMl db "X........ ",0xA,0,0 ; (Gennaio - Dicembre) MESEnome ; t_GGl db "Xxx ",0xA ;(Lun - Dom) GIORNOset ; t_GG db "00","/" ;00 GIORNOnum ; t_MMs db "00","/" ; MESEnum ; t_AAAA db "0000",0xA ; ANNO ; t_HH db "00",":" ; (da 00 a 24) ORE ; t_MMm db "00",":" ; (da 00 a 59) MIN ; t_SS db "00",0xA ; (da 00 a 59) SEC ; t_GS db "00",0xA,0xA,0xA,0xA ;(da 0 a 6) ; ; t_giosetN dd 0 ; e' un doppione di t_ggNs ; t_ggN dd 0 ; (giorno da 1 a 31) ; t_ggNs dd 0 ; (giorno settimana da 0 a 6 ... Dom = 0 ... sab = 6 ) ; t_mmN dd 0 ; (mese da 1 a 12) ; t_aaN dd 0 ; (anno da 0 a 4miliardiecc) ; t_hhN dd 0 ; ore ; t_MMnN dd 0 ; min ; t_ssN dd 0 ; sec ;Secondi In ;60 1 minuto ;3.600 1 0ra ;86.400 1 giorno ;2.419.200 28 giorni ;2.592.000 30 giorni ;31.536.000 365 giorni ;31.622.400 366 giorni ; pusha push eax xor edx,edx mov ebx,604800 ;7 giorni div ebx ;resto in edx mov eax,edx ;il resto xor edx,edx mov ebx,86400 div ebx ; ora in eax numero da 0 a 6 (giorno della settimana) mov ebx,7 add eax,4 ; 1-1-70 era giovedi; aggiungere 4 per allinearlo a lunedi xor edx,edx div ebx ; e' il sistema migliore di fare un (mod 7) dividere ancora per 7 mov eax,edx ;ora prendiamo il resto (da 0 a 6... e' quello giusto di oggi) mov [t_giosetN],eax mov edi,t_GS call ascizzaNsu_buff_2ch push esi mov edi,t_GGl mov esi,ggl xor edx,edx mov ebx,4 mul ebx mov ebx,eax mov eax,[esi+ebx] ;in eax "Lun "... o "Dom " mov [edi],eax ; mettiamo su t_GGl "Lun ", "Mar " ... o "Dom " pop esi pop eax mov ecx,1970 mov ebx,eax cmp ebx,31536000 ;cominciare con 1 anno (i secondi di un anno) jna basta_an_ag_t conta_an_ag_t: sub ebx,31536000 ; (1-1-1971 - 75 79 83...) inc ecx cmp ebx,31536000 ;cominciare con 1 anno (i secondi di un anno) jna basta_an_ag_t sub ebx,31536000 ; (1-1-1972 - 76 80 84...) inc ecx cmp ebx,31622400 ;cominciare con 1 anno (i secondi di un anno) jna basta_an_ag_t ;vediamo se secolo bisest xor edx,edx mov eax,ecx mov esi,400 div esi cmp edx,0 je bisest_an xor edx,edx mov eax,ecx mov esi,100 div esi cmp edx,0 jne bisest_an sub ebx,31536000 ; (1-1-2100 ) e' secolare non bisestile inc ecx cmp ebx,31536000 ;cominciare con 1 anno (i secondi di un anno) ja dopo_bisest_an jmp basta_an_ag_t bisest_an: sub ebx,31622400 ;prec bisestile (1-1-1973 77 81 - 2001 2401 2801) inc ecx cmp ebx,31536000 ;cominciare con 1 anno (i secondi di un anno) jna basta_an_ag_t dopo_bisest_an: sub ebx,31536000 ; (1-1-1974 -78 82 86...)) inc ecx cmp ebx,31536000 ;cominciare con 1 anno (i secondi di un anno) ja conta_an_ag_t basta_an_ag_t: ;ora i mesi mov eax,ecx mov [t_aaN],eax mov edi,t_AAAA call ascizzaNsu_buff_4ch ; entra con eax = valore da ascizzare ; edi = ptr su buff (4 bytes .. fino a 9999 ) mov ecx,1 ;gen mov edi,t_MMl ;"XX?Gennaio " mov ebp,mese ;"Gennaio " conta_mes_ag_t: cmp ebx,2678400 ;31 gg jb near basta_mese_ag_t sub ebx,2678400 add ebp,10 ;Febbraio inc ecx ;1 feb mov eax,[bisest] cmp eax,0 je no_bisest cmp ebx,2505600 ;29 gg jb near basta_mese_ag_t sub ebx,2505600 inc ecx ;1 mar jmp dopo_no_bisest no_bisest: cmp ebx,2419200 ;28 gg jb near basta_mese_ag_t sub ebx,2419200 inc ecx ;1 mar dopo_no_bisest: cmp ebx,2678400 ;31 gg jb near basta_mese_ag_t add ebp,10 sub ebx,2678400 inc ecx ;1 Apr cmp ebx,2592000 ;30 gg jb near basta_mese_ag_t add ebp,10 sub ebx,2592000 inc ecx ;1 Mag cmp ebx,2678400 ;31 gg jb near basta_mese_ag_t add ebp,10 sub ebx,2678400 inc ecx ;1 Giu cmp ebx,2592000 ;30 gg jb basta_mese_ag_t add ebp,10 sub ebx,2592000 inc ecx ;1 Lug cmp ebx,2678400 ;31 gg jb basta_mese_ag_t add ebp,10 sub ebx,2678400 inc ecx ;1 Ago cmp ebx,2678400 ;31 gg jb basta_mese_ag_t add ebp,10 sub ebx,2678400 inc ecx ;1 Set cmp ebx,2592000 ;30 gg jb basta_mese_ag_t add ebp,10 sub ebx,2592000 inc ecx ;1 Ott cmp ebx,2678400 ;31 gg jb basta_mese_ag_t add ebp,10 sub ebx,2678400 inc ecx ;1 Nov cmp ebx,2592000 ;30 gg jna basta_mese_ag_t add ebp,10 sub ebx,2592000 inc ecx ;1 Dic basta_mese_ag_t: ;ora i giorni mov eax,[ebp] mov [edi],eax mov eax,[ebp+4] mov [edi+4],eax mov ax,[ebp+8] mov [edi+8],ax mov eax,ecx mov [t_mmN],eax mov edi,t_MMs call ascizzaNsu_buff_2ch mov ecx,1 basta_mese_dopo: cmp ebx,86400 ;1 gg jb basta_gio_ag_t sub ebx,86400 inc ecx ;1 gio jmp basta_mese_dopo basta_gio_ag_t: ;ora l'ora mov eax,ecx mov [t_ggN],eax mov edi,t_GG call ascizzaNsu_buff_2ch mov ecx,0 ; t_HH db "00",0xA ; (da 00 24) ; t_MMm db "00",0xA ; (da 00 a 59) ; t_SS db "00",0xA ; basta_gio_dopo: cmp ebx,3600 ;1 h jb basta_ora_ag_t sub ebx,3600 inc ecx ;1 ora jmp basta_gio_dopo basta_ora_ag_t: ;ora i min mov eax,ecx mov [t_hhN],eax mov edi,t_HH ;call ascizzaNsu_buff call ascizzaNsu_buff_2ch mov ecx,0 basta_ora_dopo: cmp ebx,60 ;1 gg jb basta_min_ag_t sub ebx,60 inc ecx ;1 ora jmp basta_ora_dopo basta_min_ag_t: ;ora i sec mov eax,ecx mov [t_MMnN],eax mov edi,t_MMm call ascizzaNsu_buff_2ch mov eax,ebx ; i pochi secondi rimasti mov [t_ssN],eax mov edi,t_SS call ascizzaNsu_buff_2ch fine_ag_t: popa ret ;---------------ROUTINES-------(36)------------------------- dove_siamo: ;torna in eax il valore di EIP pop eax ;e' quello giusto? Si nello stack c'e' l'indirizzo di ritorno push eax ;rimettiamolo al suo posto ret ; e ritorniamo col valore di EIP in eax ;---------------ROUTINES-------(37)------------------------- apri_sock1: ;entra senza parametri (sock1... perche' si possono prevedere alre sock o generalizzare ;questa funzione) ;torna in eax il valore di ID_sock oltre che sulla variabile [sock1] pusha mov eax,0x66 ;syscall N.102 socketcall mov ebx,1 ;SYS_SOCKET 1 (significa aprila o generala) mov ecx,args ;l'indirizzo di inizio della struc AF_INET, SOCK_STREAM e IPPROTO_TCP int 0x80 mov [sock],eax mov [provv],eax popa mov eax,[provv] ret ;---------------ROUTINES-------(37)------------------------- sock_recv1: pusha mov eax,0x66 mov ebx,10 ;recv mov ecx,args_per_recv mov edx,[sock] mov [arg_r0],edx mov edx,buffer_2recv mov [arg_r1],edx mov edx,512 mov [arg_r2],edx mov edx,0x40 ;MSG_DONTWAIT ... si ci vuole; errore se = FFFFFFFF mov [arg_r3],edx mov edx,0x0ffffffff ;sembra non avere alcun effetto se 0 o FFFFFFFF mov [arg_r4],edx mov esi,512 ;buffer_2recv ;sara' questo? int 0x80 ;call errorizza popa ret ;----------------------- connetti_sock1: ;entra senza parametri (sock1... perche' si possono prevedere alre sock o generalizzare ;questa funzione) pusha mov eax,0x66 ;syscall N.102 socketcall mov ebx,3 ;SYS_SOCKET 3 (significa connetti) mov ecx,args_Conn ;l'indirizzo di inizio della struc AF_INET, SOCK_STREAM e IPPROTO_TCP int 0x80 ;??mov [sock],eax mov [provv],eax popa mov eax,[provv] ret ;---------------ROUTINES-------(38)------------------------- ; suona un beeepp sound: pusha mov eax,4 mov ebx,0 mov ecx,char_bel mov edx,4 int 0x80 popa ret ;--------------------------------------- codifica_0AD: ;serve a codificare i bytes 0,A,D del paccketto buff1_2K_defa ;altrimenti non accettati dal server pusha call pulisci_buff_provv_32k xor ebx,ebx mov edi,buff_provv_32k mov esi,buff1_2K_defa mov ecx,512 cod_0AD_1: mov eax,[esi] cmp eax,0 jne cod_0AD_2 cod_0AD1x: mov eax,[esi+4] cmp eax,0 je near fine_0AD cod_0AD_2: cmp eax,0x0a jne cod_0AD1x_poi mov eax,[esi+4] cmp eax,0 je near fine_0AD cod_0AD1x_poi: mov al,[esi] cmp al,0 je is_0_cod_0AD cmp al,0xa je is_A_cod_0AD cmp al,0xd je is_D_cod_0AD mov [edi],al inc edi inc esi dec ecx jnz cod_0AD_1 jmp fine_0AD is_0_cod_0AD: mov eax,[codice_0AD] mov [edi],eax add edi,4 mov ax,[identificativo_0AD] mov [edi],ax jmp no_0AD is_A_cod_0AD: mov eax,[codice_0AD] mov [edi],eax add edi,4 mov ax,[identificativo_0AD] add ax,0xa mov [edi],ax jmp no_0AD is_D_cod_0AD: mov eax,[codice_0AD] mov [edi],eax add edi,4 mov ax,[identificativo_0AD] add ax,0xd mov [edi],ax jmp no_0AD no_0AD: add edi,2 inc esi dec ecx jnz cod_0AD_1 fine_0AD: mov al,0xa mov [edi],al popa ret ;-------------------------------------------------------- pulisci_buff_provv_32k: pusha mov eax,0 mov ecx,32000 mov esi,buff_provv_32k pul_buf_32k_cont: mov [esi],eax add esi,4 sub ecx,4 jnz pul_buf_32k_cont popa ret ;------------------------------------------------------- pulisci_con_space_8_bytes: ;entra con esi che punta a un buffer di 8 bytes da mettere a space pusha mov al," " mov ecx,8 cont_pul_c_sp_8_bts: mov [esi],al inc esi dec ecx jnz cont_pul_c_sp_8_bts popa ret ;---------------------------- pulisci_con_space_16_bytes: ;entra con esi che punta a un buffer di 16 bytes da mettere a space pusha mov al," " mov ecx,16 cont_pul_c_sp_16_bts: mov [esi],al inc esi dec ecx jnz cont_pul_c_sp_16_bts popa ret ;---------------------------- pulisci_buff_480_bytes: ;entra con esi che punta a un buffer di 480 bytes da mettere a space pusha mov al," " mov ecx,480 cont_pul_c_sp_480_bts: mov [esi],al inc esi dec ecx jnz cont_pul_c_sp_480_bts popa ret ;-------------------------------------------------- calcola_l_header: pusha mov esi,buffer_2recv mov ecx,512 xor ebx,ebx cerca_separatore_ident: mov al,[esi] cmp al,"!" je cerca_chiocciola inc esi inc ebx dec ecx jnz cerca_separatore_ident jmp errore_calcola_l_nosep cerca_chiocciola: mov al,[esi] cmp al,"@" je cerca_i_2punti inc esi inc ebx dec ecx jnz cerca_chiocciola jmp errore_calcola_l_nochiocciola cerca_i_2punti: mov al,[esi] cmp al,":" je ok_fine_header inc esi inc ebx dec ecx jnz cerca_i_2punti errore_calcola_l_no2p: mov eax,0xFFFFFFF2 mov [l_header],eax jmp dopo_fine_head errore_calcola_l_nosep: mov eax,0xFFFFFFF0 mov [l_header],eax jmp dopo_fine_head errore_calcola_l_nochiocciola: mov eax,0xFFFFFFF1 mov [l_header],eax jmp dopo_fine_head ok_fine_header: inc ebx mov [l_header],ebx dopo_fine_head: popa ret ;---------------------------------------------------- pulisci_buff_16_bytes: ;entra con esi che punta a buffer 16 chars da pulire con spazi pusha mov al," " mov ecx,16 pul_16_cont: mov [esi],al inc esi dec ecx jnz pul_16_cont popa ret ;---------------------------------------------------- randomizza: ;genera un numero random da 0 a 1.000.000 da utilizzare come puntatore casuale alle kiavi pusha mov eax,13 mov ebx,0 int 0x80 mov ecx,1000000 mov ebx,eax randomizza_01: cmp eax,ecx jb fine_randomizza sub eax,ecx jmp randomizza_01 ;ror ebx,8 ;and ebx,0xFF fine_randomizza: ror ax,7 add ax,bx ;add al,bh ;bswap ebx ;add ax,bx add al,ah add ah,al mov ebx,eax and ebx,0xFF00 bswap eax add eax,ebx bswap eax cont_33_rand: cmp eax,1000000 jb fine_fine_random sub eax,1000000 jmp cont_33_rand fine_fine_random: mov [provv],eax popa mov eax,[provv] ret ;-------------------------------------- calcola_som_PIN_CODE: ;entra con nul ;torna in eax som_PIN_CODE call calcola_som_PIN_COD_XX xor eax,eax ;da qualche parte si usa eax, meglio metterlo a zero ret mov eax,[PIN_CODE] mov [som_PIN_CODE],dword 0 add [som_PIN_CODE],al add [som_PIN_CODE],ah bswap eax add [som_PIN_CODE],al add [som_PIN_CODE],ah mov eax,[som_PIN_CODE] call calcola_som_PIN_COD_XX ret ;---------------------------------------- calcola_som_PIN_COD_XX: ;entra con nul ;torna in eax som_PIN_CODE pusha mov esi,PIN_COD01 mov edi,som_PIN_COD01 mov ecx,13 cont_calc_SPC: mov eax,[esi] mov [edi],dword 0 add [edi],al add [edi],ah bswap eax add [edi],al add [edi],ah add edi,4 add esi,4 dec ecx jnz cont_calc_SPC popa ret ;---------------------------------------- sistema_ultima_x_visual: pusha mov esi,buff1_2K_defa mov edi,buffer_2recv mov ecx,[l_header] xor eax,eax mov ax,[esi+ecx] ;pusha ;call errorizza ;popa cmp ah,1 ja fine_s_uxv s_uxv1: mov al,[esi] mov [edi],al inc esi inc edi dec ecx jnz s_uxv1 add esi,6 mov ecx,[l_buff_da_DE_cryptare] s_uxv2: mov al,[esi] mov [edi],al inc esi inc edi dec ecx jnz s_uxv2 mov al,0xd mov [edi],al inc edi mov al,0xa mov [edi],al call pulisci_buff1_2K_defa mov edi,buff1_2K_defa mov esi,buffer_2recv mov ecx,[l_header] add ecx,[l_buff_da_DE_cryptare] add ecx,2 s_uxv3: mov al,[esi] mov [edi],al inc esi inc edi dec ecx jnz s_uxv3 fine_s_uxv: popa ret ;---------------------------------------- sistema_PRIVMSG: ;abbiamo esi che punta a PRIV(MSG ) mov eax,[esi+4] cmp eax,"MSG " ;controlliamo che sia la stringa giusta je cont_sistema_PRIVMSG ret ;altrimenti ritorna senza far nulla cont_sistema_PRIVMSG: mov eax,"CRYP" ;sostituiamo PRIVMSG con CRYPTIC mov [edi],eax add edi,4 mov eax,"TIC " mov [edi],eax add edi,4 add esi,8 ret ;----------------------------------------------- allinea_P2_2_P1: pusha mov edi,buff1_2K_defa ;[P2 - 6] mov esi,buffer_2send_dopo ;[P1] add edi,6 ;2+4 ora edi = P2 mov ecx,[l_buff_da_cryptare] cont_allinea_P2_2_P1: mov al,[esi] mov [edi],al inc esi inc edi dec ecx jnz cont_allinea_P2_2_P1 popa ret ;----------------------------------------------- allinea_P1_2_P2: pusha mov esi,buff1_2K_defa ;[P2 - 6] mov edi,buffer_2send_dopo ;[P1] add esi,6 ;2+4 ora esi = P2 mov ecx,[l_buff_da_cryptare] cont_allinea_P1_2_P2: mov al,[esi] mov [edi],al inc esi inc edi dec ecx jnz cont_allinea_P1_2_P2 popa ret ;----------------------------------------------- allinea_BUFF_DK: ;non esattamente 2 a 1 (reverse di quello di cui sopra pusha mov esi,buffer_2recv ;mov [P1],esi mov edi,buff1_2K_defa mov ebx,[l_header] ;28 ;PRIVMSG ecc ;[l_header] add ebx,6 ;2+4 bytes add ebx,[l_buff_da_DE_cryptare] inc ebx ;0Xa inc ebx mov ecx,480 ;480 allinea_fine_decodkiave2: ;sistemare il buffer giusto dec ecx jz allinea_sist_buff_K02_fin_DK mov al,[esi] mov [edi],al inc esi inc edi dec ebx jnz allinea_fine_decodkiave2 ; se ebx errato vediamo che cazz ci mette ;mov al,0xa ;mov [edi],al ;:zuppolo!~zupolon^@host200-41.pool8261.interbusiness.it PRIVMSG #coclide :@@@@@ allinea_sist_buff_K02_fin_DK: popa ret ;----------------------------------------------- metti_bit_byte_K4: ;entra con la coppia eax:edx contenenti 8 bytes da uniformare al byte ;contenuto su CH1_4 pusha ror eax,1 ror edx,1 mov [esi],eax mov [esi+4],edx xor ecx,ecx mov cl,08h cont_eax_K4: mov bl,[CH1_4] and bl,cl cmp bl,0 je near oltre_bit_byte_K4_eax ;qui effettuare operazione di inversione ;push eax xor ebx,ebx cmp ecx,1 jne near dopo_ecx_no1_K4 call opera_su_al_K4 jmp oltre_bit_byte_K4_eax dopo_ecx_no1_K4: cmp ecx,2 jne dopo_ecx_no2_K4 ror eax,8 call opera_su_al_K4 rol eax,8 jmp oltre_bit_byte_K4_eax dopo_ecx_no2_K4: cmp ecx,3 jne dopo_ecx_no3_K4 ror eax,16 call opera_su_al_K4 rol eax,16 jmp oltre_bit_byte_K4_eax dopo_ecx_no3_K4: cmp ecx,4 jne dopo_ecx_no4_K4 ror eax,24 call opera_su_al_K4 rol eax,24 jmp oltre_bit_byte_K4_eax dopo_ecx_no4_K4: cmp ecx,5 jne dopo_ecx_no5_K4 mov ebp,eax mov eax,edx ;ror eax,24 call opera_su_al_K4 ;rol eax,24 mov edx,eax mov eax,ebp jmp oltre_bit_byte_K4_eax dopo_ecx_no5_K4: cmp ecx,6 jne dopo_ecx_no6_K4 mov ebp,eax mov eax,edx ror eax,8 call opera_su_al_K4 rol eax,8 mov edx,eax mov eax,ebp jmp oltre_bit_byte_K4_eax dopo_ecx_no6_K4: cmp ecx,7 jne dopo_ecx_no7_K4 mov ebp,eax mov eax,edx ror eax,16 call opera_su_al_K4 rol eax,16 mov edx,eax mov eax,ebp jmp oltre_bit_byte_K4_eax dopo_ecx_no7_K4: ; e' 8 quindi mov ebp,eax mov eax,edx ror eax,24 call opera_su_al_K4 rol eax,24 mov edx,eax mov eax,ebp jmp oltre_bit_byte_K4_eax ;-----routine interna------ opera_su_al_K4: push ebx xor ebx,ebx mov bl,al ;1� bit and bl,80h ror bl,1 or bh,bl mov bl,al ;2� bit and bl,40h rol bl,1 or bh,bl mov bl,al ;3� bit and bl,20h ror bl,1 or bh,bl mov bl,al ;4� bit and bl,10h rol bl,1 or bh,bl mov bl,al ;5� bit and bl,08h ror bl,1 or bh,bl mov bl,al ;6� bit and bl,04h rol bl,1 or bh,bl mov bl,al ;7� bit and bl,02h ror bl,1 or bh,bl mov bl,al ;8� bit and bl,01h rol bl,1 or bh,bl mov al,bh pop ebx ret ;----fine routine interna--------- oltre_bit_byte_K4_eax: shr ecx,1 cmp ecx,0 je vai_su_edx_K4 jmp cont_eax_K4 vai_su_edx_K4: mov [provv1],eax mov [provv2],edx popa mov eax,[provv1] mov edx,[provv2] ret ;---------------------------------------------- ripulisci_sequenze: pusha ;seq_tutte db "xx - xx - xx - xx - xx - xx - xx - xx - xx - xx - xx - xx - xx ",0xa,0xa ;seq_attive db ".. - .. - .. - .. - .. - .. - .. - .. - .. - .. - .. - .. - .. ",0xa,0xa mov ecx,13 mov esi,seq_tutte mov edi,seq_attive mov ax,".." mov bx,".." cont_ripulisci_sequenze: mov [esi],ax mov [edi],bx add esi,5 add edi,5 dec ecx jnz cont_ripulisci_sequenze popa ret ;------------------------------------------------ esegui_funzione_789_K: pusha ; se 7 oppure 8 oppure 9 sono inattivi, far puntare i corr. P3 a buff_vuoto ( Zero 0) mov ebp,[P3_7_p] mov edi,[P3_8_p] mov edx,[P3_9_p] mov esi,[P1] ;jmp fine_789 cont_opera_789_K: mov bl,[ebp] mov cl,[edi] xor cl,bl ;jmp fine_789 mov bl,[edx] xor bl,cl mov al,[esi] xor al,bl mov [esi],al inc ebp cmp ebp,[P3_7max_p] jna va_ebp_789 mov ebp,[P3_7_p] va_ebp_789: inc edi cmp edi,[P3_8max_p] jna va_edi_789 mov edi,[P3_8_p] va_edi_789: inc edx cmp edx,[P3_9max_p] jna va_edx_789 mov edx,[P3_9_p] ;jmp fine_789 ;provvisorio va_edx_789: inc esi cmp esi,[P1max] jna va_esi_789 mov esi,[P1] jmp fine_789 va_esi_789: ;dec eax ;dec dword [P3_master] dec dword [P3_master] jnz cont_opera_789_K fine_789: popa ret ;-------------------------------------------------- inizializza_buff_vuoto_2mega: pusha mov esi,buff_vuoto_2mega mov eax,0 mov ecx,500000 cont_in_2mega: mov [esi],eax add esi,4 dec ecx jnz cont_in_2mega popa ret ;--------------------------------------------------- verifica_se_key_attiva: pusha xor edx,edx mov byte [key_is_attiva],0 mov edi,act_K mov ebx,4 dec eax mul ebx add edi,eax cmp dword [edi],1 jne va_dopo_attiva mov byte [key_is_attiva],1 va_dopo_attiva: popa ret ;----------------------------------------------------- invia_mesg_789: pusha mov eax,4 mov ebx,1 mov ecx,msg_seq_k789 mov edx,[msg_seq_k789_l] int 0x80 popa ret ;------------------------------------------------------- rimetti_riempi1_2_P1: ;entra con ebp che punta a inizio buffer ;edi a fine buffer mov esi,[P1] ;cmp dword [op_ebp],0 ;je noebpr2_P1 noebpr2_P1: inc ebp ;cmp dword [op_edi],0 ;je noedir2_P1 ;dec edi noedir2_P1: ;nop rim_r12_P1_va: mov al,[ebp] mov [esi],al inc ebp ;cmp ebp,edi ;ja si_finito_verorim_r12_P1 ;fine_rimetti_r2P1 inc esi cmp esi,[P1max] ja si_finito_verorim_r12_P1 jmp rim_r12_P1_va fine_rimetti_r2P1: ;cmp esi,[P1max] ;ja si_finito_verorim_r12_P1 ;forse un corno ;jmp rim_r12_P1_va ; altrimenti.... cacchio... ;si trova gia allineato.... :)))) ;non serve nient'altro si_finito_verorim_r12_P1: mov ebp,riempi1 ; buff da 2 mega add ebp,512 ;mettiamoci a distanza sufficiente dall'inizio per ricevere ;l'intero messaggio se tutti i bit della chiave sono a 1 mov edi,ebp ;sincr edi e ebp; edi incrementa se bit =0, ebp decrementa se bit=1 inc edi mov dword [op_ebp],0 mov dword [op_edi],0 mov esi,[P1] ret ;---------------------------------------------------------- rimetti_riempi1_2_P1_DK: ;entra con ebp che punta a inizio buffer ;edi a fine buffer mov esi,[P1max] ;cmp dword [op_ebp],0 ;je noebpr2_P1 noebpr2_P1_DK: inc ebp ;cmp dword [op_edi],0 ;je noedir2_P1 ;dec edi noedir2_P1_DK: ;nop rim_r12_P1_va_DK: mov al,[ebp] mov [esi],al inc ebp ;cmp ebp,edi ;ja si_finito_verorim_r12_P1 ;fine_rimetti_r2P1 dec esi cmp esi,[P1] jb si_finito_verorim_r12_P1_DK jmp rim_r12_P1_va_DK fine_rimetti_r2P1_DK: ;cmp esi,[P1max] ;ja si_finito_verorim_r12_P1 ;forse un corno ;jmp rim_r12_P1_va ; altrimenti.... cacchio... ;si trova gia allineato.... :)))) ;non serve nient'altro si_finito_verorim_r12_P1_DK: mov ebp,riempi1 ; buff da 2 mega add ebp,512 ;mettiamoci a distanza sufficiente dall'inizio per ricevere ;l'intero messaggio se tutti i bit della chiave sono a 1 mov edi,ebp ;sincr edi e ebp; edi incrementa se bit =0, ebp decrementa se bit=1 inc edi mov dword [op_ebp],0 mov dword [op_edi],0 mov esi,[P1max] ret ;---------------------------------------------------------- ;da pianificare: a) lettura da 1 file random (blocchi da 256 bytes) leggi_file_256_b ; b) lettura c.s. 512 bytes leggi_file_512_b ; c) n ---> eax ; ebx F_ID leggi_file_n_b ;=====================FINE ROUTINES======================= ;---------------------FINE------------------------------------------------