_ __________________ _ -*2*- `^°*;:,.>Le protocole AOL<.,:;*°^` _____________________________/¯¯¯¯¯ tobozo ¯¯¯¯¯\_______________________________ ¤º°`°º¤ø,¸¸,ø¤º°`°º¤ø,¸¸,ø¤º°`°º¤ø,¸¸,ø¤º°`°º¤º°`°º¤ø,¸¸,ø¤º°`°º¤ø,¸¸,ø¤º°`°º¤ø, Document original par Gods'Misfit (1999) binary0100@yahoo.com Traduit de l'anglais et adapté par tobozo (2001) tobozo@users.sourceforge.net Ce document est une traduction d'une des premieres traces de partage rencontree chez AOL, il s'agit d'un article qui explique vaguement comment fonctionne le protocole AOL et comment se bricoler un client avec du VB. Il est diffusé sur le site http://aol.necrocosm.com en version anglaise (et avec moins de coquilles) depuis 1999 et par AOL (hee oui, incroyable mais vrai!) depuis aout 2001. Introduction En évoquant "Le protocole AOL", le premier mot qui devrait venir a l'esprit est FDO. Et bien que FDO fasse partie du protocole AOL, il n'en sera que peu question dans ce document. Le terme "Protocole AOL" est utilisé ici en référence a une relation interactive entre un client et un serveur AOL, comment les données sont préparées, envoyées, et comment elles peuvent etre manipulées. Radotage mediatique fallacieux a redondance cyclique Il n'existe actuellement aucune documentation formelle sur le protocole AOL, tout au moins aucune qui soit publiquement disponible. Actuellement il n'y a aucun article qui soit formel au point de decrire le protocole AOL (en tous cas pas publiquement) et dont la disponibilité permette d'en parcourir le contenu. Il n'existe pas pour le moment de documentation disponible publiquement (a part celle ci) qui décrive formellement le protocole AOL. Sommaire 1) Etablissement d'une connexion A. Serveurs B. le "handshake" C. Envoi du Pseudo et du mot de passe D. Completer le login 2) Les paquets A. Le premier octet B. Le premier et troisieme octet(CRC) C. Le quatrieme octet D. Le cinquieme octet E. Le sixieme et septieme octet F. Le huitieme octet G. Le neuvieme et dixieme octet 3) Logguage des Paquets de Données d'AOL 4) Formation des paquets de données 5) Pinger 6) A propos de la décompression FDO 7) Vue d'ensemble 8) Utilisation du sens du jugement 1) Etablissement d'une connexion A. Serveurs - ------------- Le serveurs AOL sont généralement sur le port 5190. Le serveur auquel le client se connexte est séléctionné au hasard par la DNS roulette russe 'AmericaOnline.aol.com'. Il y a des centaines de serveurs AOL liés ensemble (des stades de foot remplis de serveurs !!). Mais comment ils font pour éviter le meme phenomene que les NetSplits d'IRC ? ? Pour se connecter a un serveur AOL, tout ce qu'il faut faire c'est se connecter a 'AmericaOnline.aol.com' sur le port 5190. Rien de bien compliqué jusqu'ici, ca peut meme etre fait par telnet. En general les serveurs sur lesquels on est redirigé lors d'une connexion a un serveur aOL s'appellent "berps" (bruit d'un ROT) ex : 'berp-cr01.dial.aol.com'. B. Le handshake - ------------------ Lors de l'etablissement de la connexion a AOL, le client envoie en premier des paquets d'identification qui incluent le numero de version du client. En cas de succes, le serveur renverra des paquets "encourageants" (SD) et le client enverra alors le Pseudo/Mot de passe. En cas d'echec, le serveur renverra des paquets d'insultes (XS) et le client se verra déconnecté. AOL utilise ca de facon a désactiver les vieilles versions de clients et les forcer a upgrader (ca fait vachement penser a m$ quand meme;-)); Quand le serveur ne donne aucune réponse c'est que le paquet n'etait pas formé correctement... Client: 5A413800347F7FA3036B0100F5000000050F00002152CBCA070A1000080400000000035F00000100 04000300080000000000000000000000020D Client: ZA8Å4£kÅõÅÅÅÅÅ!RËÊÅÅÅÅÅ_ÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅ Server: 5AB71100037F7F240D5A88E9000B107F20534454D1F68B00000D Server: Z·-Å$ZˆéÅ SDTÑö‹ÅÅ C. Envoi du Pseudo et du Mot de passe - --------------------------------------- Apres que le serveur ait accepté le "handshake", le Pseudo et le mot de passe sont envoyés. Si le Pseudo et le Mot de passe correspondent, le serveur envoie alors l'information de désactivation du Master Tool, et envoie aussi la fenetre de bienvenue FDO. Si le Pseudo et le Mot de passe ne correspondent pas, le serveur demandera le mot de passe une fois de plus, et dans le cas de deux échecs successifs, le serveur enverra des paquets d'insultes (XS) et le client sera déconnecté.. Client: 5A243F00431010A044640015000100010A0400000001010B040000000103010A686F6C797461626C 6520011D00011D00010A0400000002030108736174616E363636011D000002000D Client: Z$?ÅCDdÅÅÅÅÅÅÅÅÅholytable ÅÅÅÅÅsatan666ÅÅÅ D. Compléter le login - ----------------------- Une fois le message de bienvenue FDO, le client envoie le token "ya". Ceci permet a AOL de notifier s'il y a du courrier, d'assigner une adresse IP et, si c'est configuré, d'afficher la Buddy List. Une fois l'IP assignée il devient possible d'envoyer des commandes aux services AOL. Client: 5A4EBA00031018A40D5AC6910008111CA079610701010D5A5C340022121CA0746C00170001000A0F 04007BB5E80A10041DA6DDF20A4504000000070002000D5A6F4A000D131CA0534301500010000020 00D Client: ZNºÅ¤ZÆ‘Å-yaZ\4Å" tlÅÅÅÅ{µè¦ÝòEÅÅÅÅÅZoJÅSCÅÅÅÅÅ Server: 5A419B00351D132079610304AC992E10020102010100040498A3CE86070101050203C00A15313533 2D34362D31362E6970742E616F6C2E636F6D0D5A7E91001E1E132076A007BB5E81DA6DDF20000000 000696D66617274702E627574000D Server: ZA›Å5 ya¬™.Ř£Î†À153-46-16.ipt.aol.comZ~‘Å-- tjÅ{µè¦ÝòÅÅÅÅÅimfartp.butÅ 2) Les paquets - ---------------- La structure de ces paquets est restée mystérieuse pendant longtemps (il parait) et la description qui suit n'est qu'un essai de passage a la loupe... A ne pas prendre pour parole biblique. Voici en gros a quoi un paque ressemble : Z (CRC) (CRC) [NULL] (LENGTH BYTE) (HB 6TH) (HB 7TH) [SPACE] (TOKEN) (TOKEN) Ce sont les premier 10 octets de tous les paquets AOL. Les seuls octets qui ne changent jamais sont le premier -> Z(5A en Hexa) et le quatrieme -> A null (00 en Hexa). Tout ce qui se trouve apres les 10 premiers octets est compressé en FDO ou en ligne de données. Le passage au detail des 10 premiers octets : A. Sur toutes les version AOL, le premier octet est toujours égal a z (5A ne Hexa). C'est l'octet le moins prise de tete (il ne change jamais) mais ca n'est pas une raison pour l'oublier (quoiqu'on aurait plutot tendance a oublier le quatrieme)... B. Le deuxieme et troisieme octet sont des octets 'Hi' et 'Lo' (Haut et Bas) produits par l'algoritme CRC16. CRC veut dire "Cyclic Redundancy Check" (Vérification de Redondance Cyclique). Non il ne s'agit pas d'un gaz qui détruit la couche d'ozone, mais il est quand meme utilisé dans le cadre de la compressions. Par exemple pour s'assurer qu'aucune donnée n'a été corrompue dans un fichier, l'entete CRC doit correspondre aux données du fichier lui meme. Il en est de meme pour la lecture d'un CDROM, d'une disquette, et des paquets AOL. Si le CRC ne correspond pas au paquet, le serveur AOL l'ignore. Le CRC est extrait du paquet duquel ont été supprimés les 5 Octets (le header). Le nombre produit par l'algo est alors utilisé pour produire les bits 'Hi' et 'Lo' qui sont alors placés dans le 2e et le 3e point du header. Le CRC s'applique seulement sur les versions 3.0 du client AOL et versions anterieures. Les versions plus récentes d'AOL envoient simplement '**' en deuxieme et troisiemes Octet. On peut donc tres bien s'en sortir avec ces versions la sans avoir a utiliser ce maudit CRC, mais dans tous les cas il y aura plus de données a envoyer. Si le CRC doit etre utilisé coute que coute, les choses seront beaucoup plus simples si cette utilisation s'applique a des paquets de type ancien ou réduit. Voici la fonction CRC et les subroutines 'Hi' et 'Lo' pour les programmeurs de C++ et Visual Basic (merci a la communauté AOL et a l'auteur anonyme). C++: ---- Function AOLCrc (strng$, lenstr) unsigned short CRC16(byte * buffer, int length) { unsigned short crc = 0; unsigned short ch; int i, j; for (i = 0; i < length; i ++) { ch = (unsigned short) buffer; for (j = 0; j < 8; j ++) { if ((crc ^ ch) & 1) crc = (crc >> 1) ^ 0xa001; Else crc >>= 1; ch >>= 1; } } return (crc); } Visual Basic: ------------- Function AOLCRC(strng$, lenstr) Dim crc As Long Dim ch As Long Dim i As Long Dim j As Long For i = 0 To lenstr - 1 ch = Asc(Mid(strng$, i + 1, 1)) For j = 0 To 7 If ((crc Xor ch) And 1) Then crc = (Int((crc / 2)) Xor 40961) Else crc = Int(crc / 2) End If ch = Int(ch / 2) Next j Next i AOLCRC = crc End Function Function gethibyte(mybyte As Variant) As Variant gethibyte = Int(mybyte / 256) End Function Function getlobyte(mybyte As Variant) As Variant getlobyte = Int((mybyte - (gethibyte(mybyte) * 256))) End Function On va expliquer plus bas comment utiliser ces fonctions. C. Le 4e Octet pour toutes les versions d'aol est de valeur NULL (00 in Hex). Attention : cet Octet ne change jamais mais il est obligatoire. D. Le 5e Octet est l'Octet de longueur, il définit plus ou moins la longueur du paquet moins les 5 premiers octets (header). Plus ou moins car un autre element (qui n'est pas la longueur physique) peut en affecter la valeur. L'octet situé directement avant tout chaine contenue dans le paquet (pseudo, chat, données de formulaires, etc) est aussi un Octet de longueur. Cet Octet représente la longueur de la chaine qui suit. et n'est pas comptabilisé dans la représentation du 5e octet de longueur. Voici un subroutine Visual Basic qui pourra pallier a ce manque et calculer le 5e octet de tout paquet qu'on lui donne : Function give5th(pack As String, inputz as integer) 'La fonction EnHex est necessaire pour cela, voir suite du document. Dim give5th1 As Integer inputz = inputz + 4 give5th1 = Len(DeHex(pack)) - inputz give5th = EnHex(Chr(give5th1)) End Function L'utilisation de cette fonction est simple, il suffit d'inclure le paquet entier en hexa (y compris le header) et le # d'inputs du formulaire pour calculer le 5e octet qui doit etre placé dans le paquet. Exemple: give5th("5AD69400411010A044640015000100010A0400000001010B04000000010301" & screenname$ & "20011D00011D00010A04000000020301" & password$ & "011D000002000D", 2) E. Le 6e et 7e Octet - Ces 2 octets sont au moins aussi gonflants que le 2e et le 3e octet. Il suffit de surveiller les paquets AOL pour comprendre ce qu'on veut dire ici. Ces deux octets changent sans explication apparente et sans indice aidant a comprendre de quoi sera composé la prochaine paire. Ces paquets sont differents pour chaque nouveau paquet. Cette enigme n'est pas résolue dans ce document mais une solution de remplacement y est considérée : En mettant tous les paques dans une boucle on s'apercoit que les paquets de login ont un 6e octet de 10(hex) =16(int) et un 7e octet de 18(hex) = 24(int). Idée : Avant l'envoi de chaque paquet, on peut incrémenter chacun de ces bits de 1. Bien que le client semble se livrer a une distribution completement différente, cette methode marche a merveille ;-)) On ne peut pas incrémenter de 1 a l'infini bien sur ;-) Au bout d'un moment le serveur AOL arrete de repondre et fait couler la connexion. La solution est de restaurer le 6e et 7e Octet a leurs valeurs originales 10(hex)=16 et 18(hex)=24 Partant de ces données, seule l'imagination limite les implémentations, le 6e et 7e octet avec des valeurs de 127 et 135 par exemple (hehehe). Par hypocrisie on va appeler ces octets "octets de comptage". Spéculations mode="parano": ces octets peuvent etre cités en référence comme "battements de coeur". Les paquets "ping-like" de 9 caracteres qui sont envoyés en permanence contiennent probablement des valeurs qui informent le serveur sur la santé/utilisation du client AOL, et qui sait peut etre d'autres informations plus consistantes ?? F. Le 8e octet est simplement un espace. G. Enfin, le 9e et 10e Octet (en ASCII) représentent le token. Les habitués de FDO savent que le token prévient le serveur de ce qu'il attend. Dans le doute on peut chercher les tokens et les comparer avec les fichiers token AOL-Files pour voir de quel paquet il s'agit. 3) Logguer les paquets de données AOL est une compétence tres important quand on veut fricotter avec le protocole AOL et sans laquelle on ne peut aller nulle part. La formation des paquets AOL n'est pas quelque chose qui peut etre réalisé en direct et a la main (a moins d'avoir un implant dans la cervelle;), l'opération (pour former les paquets, pas pour l'implant) équivaudrait a écrire en FDO, compresser le FDO et ajouter le header, le tout en temps réel. Bien que cela ne soit pas completement impossible (les implants c'est pas cher), la meilleure méthode reste encore le recyclage de paquets déja loggués qu'on peut modifier a volonté la ou c'est nécéssaire. Récuperer des paquets AOL est assez simple, il suffit de créér/utiliser un programme qui va ecouter sur le port 5190 pour toutes les connexions entrantes. Ensuite il faut jeter son dévolu sur la version d'AOL a espionner.. La version US d'aol 2.5 reste encore le meilleur choix, d'ailleurs ce document ne traite que de methodes utilisables avec cette version. Il est meme possible entre la création, la diffusion et la traduction de cet article, qu'AOL ai fini d'accepter que les clients 2.5 se connectent a leurs serveur. dans le doute : http://clients.aol-files.com Il faut tripotter le client AOL pour le forcer a se connecter en local plutot que sur 'AmericaOnline.aol.com'. Pour cela il faut ouvrir le fichier 'tcp.ccl' situé dans le repertoire 'ccl' et remplacer l'occurence 'AmericaOnline.aol.com' par 'localhost', puis sauver et fermer le fichier. En ajoutant une regle de filtre au programme qui loggue les paquets (tcpdump?) on fait forwarder les paquets du port 5190 sur 'AmericaOnline.aol.com'. On peut alors lancer le client AOL et vérifier que lors d'une demande de connexion le programme de logging forwarde bien la demande. On peut alors commencer a intercepter les données en séparant les données du serveur des données du client. A partir d'une machine windows cela peut poser des problemes a cause des caracteres "NULL" qui, quand ils sont mis dans une textbox, représentent une fin de ligne et rendent illisible le texte qui suit sur la fin de la ligne. en éditant le caractere NULL d'une chaine on peut rendre lisible le paquet en entier. Voici une routine en Visual Basic qui permet de pallier a ca : Function stripnulls(thedata as String) Dim torem as Integer torem = 1 Do Until crap = 0 torem = InStr(1, thedata, Chr$(0)) If torem > 0 Then Mid(thedata, torem, 1) = "Å" Loop End Function L'edition des paquets en ASCII donne des resultats catastrophiques : le paquet est inutilisable et ne peut etre renvoyé au serveur. L'edition des paquets doit donc etre faite en Hexa dont voici quelques fonctions (toujours en Visual Basic). Public Function EnHex(Data As String) As String Dim iCount As Double Dim sTemp As String For iCount = 1 To Len(Data) sTemp = Hex$(Asc(Mid$(Data, iCount, 1))) If Len(sTemp) < 2 Then sTemp = "0" & sTemp EnHex = EnHex & sTemp Next iCount End Function Public Function DeHex(Data As String) As String Dim iCount As Double For iCount = 1 To Len(Data) Step 2 DeHex = DeHex & Chr$(Val("&H" & Mid$(Data, iCount, 2))) Next iCount End Function Public Function Int2Hex(Data As String) As String Dim sTemp As String sTemp = Hex(Data) If Len(sTemp) < 2 Then sTemp = "0" & sTemp Int2Hex = Int2Hex & sTemp End Function Public Function Hex2Int(Data As String) As String Dim iCount As Double For iCount = 1 To Len(Data) Step 2 Hex2Int = Hex2Int & CInt(Val("&H" & Mid$(Data, iCount, 2))) Next iCount End Function Il faut capturer les paquets en Hexa et a moins d'utiliser AOL Data Edit (plus dur a trouver eh?) ca ne marchera pas... 4) Formation des Paquets de Données On va maintenant essayer d'expliquer comment former un paquet et l'envoyer avec Visual Basic en utilisant les fonctions de ce document. Avant tout il faut un des paquets qui ont été loggués plus haut. Voici un paquet loggué IM : 5A21EF00401422A06953002500010001070400000003010A040000000103010A676F64736D697366 3174011D00010A04000000020301026869011D00011D00011D000002000D Z!ïÅ@"iSÅ%ÅÅÅÅÅÅÅÅgodsmisf1tÅÅÅÅhiÅÅÅÅÅ IM Envoyé au pseudo 'godsmisf1t' avec le message 'hi'. Que changer dans ce paquet ? A premiere vue on peut modifier les chaines "hi" et "godmisf1t". L'hexa pour 'godsmisf1t' est '676F64736D6973666974'. On recherche donc cette valeur dans le paquet Hexa, on rechercha aussi '6869' qui correspond a 'hi'. 5A21EF00401422A06953002500010001070400000003010A040000000103010A676F64736D697366 3174011D00010A04000000020301026869011D00011D00011D000002000D On a donc identifié les données a changer, il ne reste plus qu'a les éditer, et aussi a éditer l'octet situé directement avant les chaines en accord avec la longueur des varaibles modifiées. "5A21EF00401422A06953002500010001070400000003010A04000000010301" & screenname$ & "011D00010A04000000020301" & IM$ & "011D00011D00011D000002000D" Les variables IM$ et screenname$ prennent la valeur du pseudo et du message en hexa et les octets qui les précedent directement sont supprimés et remplacés par la valeur hexa correspondant a leurs longueurs respectives. Voici un exemple en Visual Basic : screenname$ = Int2Hex(Len("godsmisf1t")) & EnHex("godsmisf1t") IM$ = Int2Hex(Len("hello")) & EnHex("hello") Il ne reste plus qu'a mettre le paquet en hex et a le renvoyer pour que ca marche alors ? Perdu ! Il faut aussi changer la valeur du 5e octet (l'octet de longueur) en fonction de la longueur du message et du pseudo. On peut pour ca utiliser la fonction give5th (Visual Basic) : fifth$ = give5th("5A21EF00401422A06953002500010001070400000003010A04000000010301" & screenname$ & "011D00010A04000000020301" & IM$ & "011D00011D00011D000002000D", 2) Cette fonction calcule l'octet de longueur du paquet avec le nombre d'inputs. Un formulaire IM a 2 champs inputs, on en met donc 2 comme valeur. La valeur hexa de l'octet de longueur se trouve stockee dans la variable 'fifth$' pour usage ulterieur. Il faut ensuite s'assurer qu'on a les bonnes valeurs pour le 6e et 7e octet. Juste apres le login on avait remarqué que les valeurs du 6e et 7e octet etaient respectivement 16 et 24 ( 10 et 16 en hexa). Une fois que l'etape du login sera franchie, il faudra s'assurer que les valeurs de ces deux octets soient stockées dans des variables publiques afin de pouvoir les incrémenter et ainsi produire les "battements de coeur". Comme expliqué plus haut ces valeurs doivent etre réinitialisées des qu'elles atteignent respectivement les valeurs 127 et 135. sixth = CInt(sixth) + 1 seventh = CInt(seventh) + 1 Voici comment on les integre avec le 5e octet du paquet. Le paquet actuel est "5A21EF00401422A06953002500010001070400000003010A04000000010301" & screenname$ & "011D00010A04000000020301" & IM$ & "011D00011D00011D000002000D" Le 5e (hex) '40' le 6e (hex)'14', et le 7e (hex) '22' sont les octets qui doivent etre remplacés avec les variables : packet$ = DeHex("00" & fifth$ & Int2Hex(sixth) & Int2Hex(seventh) & "A06953002500010001070400000003010A04000000010301" & screenname$ & "011D00010A04000000020301" & IM$ & "011D00011D00011D000002000D") On met ainsi a jour le 5e, 6e, et 7e octet avec les variables hexa, et on met le nouveau paquet dans la variable 'packet$'. Il ne reste plus qu'a modifier l'octet CRC : crc1 = AOLCRC(packet$, Len(packet$) - 1) thehi$ = Chr(gethibyte(crc1)) thelo$ = Chr(getlobyte(crc1)) packet$ = "5A" & EnHex(thehi$) & EnHex(thelo$) & "00" & fifth$ & Int2Hex(sixth) & Int2Hex(seventh) & "A06953002500010001070400000003010A04000000010301" & screenname$ & "011D00010A04000000020301" & IM$ & "011D00011D00011D000002000D" Le paquet est pret a etre envoyé avec la fonction DeHex qui va l'envoyer au serveur. whatyousend$ = DeHex(packet$) Il suffit d'envoyer whatyousend$ au serveur, et si tout a été fait correctement ca devrait envoyer un IM. En ficelant le tout, on peut construire une fonction qui envoie un IM : Function SendIM(screenname as String, IM as String) screenname1$ = Int2Hex(Len(screenname)) & EnHex(screenname) IM1$ = Int2Hex(Len(IM)) & EnHex(IM) If sixth = "127" Then sixth = "15" 'Backtrack 1 because we are going to add 1 soon seventh = "23" 'THIS IS THE CODE TO RESET THE BYTES End If sixth = CInt(sixth) + 1 seventh = CInt(seventh) + 1 fifth$ = give5th("5A21EF00401422A06953002500010001070400000003010A04000000010301" & screenname1$ & "011D00010A04000000020301" & IM1$ & "011D00011D00011D000002000D", 2) packet$ = DeHex("00" & fifth$ & Int2Hex(sixth) & Int2Hex(seventh) & "A06953002500010001070400000003010A04000000010301" & screenname$ & "011D00010A04000000020301" & IM$ & "011D00011D00011D000002000D") crc1 = AOLCRC(packet$, Len(packet$) - 1) thehi$ = Chr(gethibyte(crc1)) thelo$ = Chr(getlobyte(crc1)) packet$ = "5A" & EnHex(thehi$) & EnHex(thelo$) & "00" & fifth$ & Int2Hex(sixth) & Int2Hex(seventh) & "A06953002500010001070400000003010A04000000010301" & screenname$ & "011D00010A04000000020301" & IM$ & "011D00011D00011D000002000D" whatyousend$ = DeHex(packet$) Form1.Winsock1.SendData whatyousend$ 'On part du principe que le formulaire 'principal s'appelle Form1 et que 'Microsoft Winsock Control est utilisé. End Function 5) Les Ping ----------- Apres avoir réussi a établir une connexion avec AOL (ca peut prendre des années;), on peut constater qu'AOL envoie des petits paquets qui ressemblent a ca : Serveur: 5A647D00032313260D Serveur: Zd}Å#& Ces paquets sont similaires a des ping. Le serveur vérifie si la connexion est toujours en bonne santé. Le fait de ne pas y répondre met la connexion en mode suspendu (aucune autre donnée ne peut circuler jusqu'a ce qu'un ping soit envoyé et/ou répondu). La réponse attendue par le serveur est heureusement simple a produire, on prend le 6e et le 7e octet du paquet ping, on les inverse, et on les renvoie au serveur. Voici a quoi ressemble une reponse d'un client a un ping : Client: 5A0AE900031323A40D Client: Z éÅ#¤ Le paquet ping du serveur a un 6e caractere dont la valeur hexa est 23. Le 7e octet a une valeur de 13 en hexa. Le client inverse les deux valeurs avant de les renvoyer avec la methode suivante : Dans le 'Winsock Data Arrival event' déposer ceci : 'Assuming sData is the incoming server data: If Len(sData) = 9 Then ping6$ = Mid(sData, 6, 1) ping7$ = Mid(sData, 7, 1) packet$ = DeHex("0003" & EnHex(ping7$) & EnHex(ping6$) & "A40D") crc1 = AOLCRC(packet$, Len(packet$) - 1) thehi$ = Chr(gethibyte(crc1)) thelo$ = Chr(getlobyte(crc1)) tosend$= DeHex("5A" & EnHex(thehi$) & EnHex(thelo$) & "0003" & EnHex(ping7$) & EnHex(ping6$) & "A40D") Winsock1.SendData tosend$ End If C'est le client qui le plus souvent envoie les ping, et c'est le serveur qui le plus souvent y repond. Le serveur AOL stoppera toute transmission jusqu'a ce que le ping recoive une reponse ou soit envoye. Pour une utilisation applicative, il est recommandé d'intégrer un timer qui aura pour role d'envoyer constamment des ping au serveur AOL. Note : lors d'une réponse a un ping, il est inutile d'incrémenter le 6e et le 7e octet, ni de chercher un 5e octet. 6) La compression FDO ---------------------- Les paquets traités plus haut ne reseemblent pas vraiment a du FDO, et pourtant il sont bien compressés en FDO. Un rapide coup d'oeil permet de localiser les zones de compression. Il est meme possible d'écrire une subroutine qui va faire le travail : Il faut localiser le fichier 'ada32.dll'. C'est la librairie de ressource qu'AOL utilise pour stocker toutes les fonctions de compression FDO. Pour ceux qui savent déclarer une fonction depuis une DLL (pour les autres faudra lire des docs avant hehe) voici la liste des fonctions qui se trouvent dans le fichier 'ada32.dll' : AdaAssembleAtomStream AdaDisassembleAtomStream AdaDoAtomCallbacks AdaAssembleArgument AdaAssembleAtomStream AdaAssembleFragment AdaDisassembleArgument AdaDisassembleAtom AdaDisassembleAtomState AdaDisassembleAtomStream AdaDisassembleAtomStreamState AdaDoAtomCallbacks AdaEnumAllAtoms AdaFreeState AdaGetAtomByName AdaGetAtomName AdaGetErrorText AdaGetVersion AdaInitialize AdaIsValidProtocol AdaLookupAtomEnum AdaNormalizeAtomStream AdaTerminate Voici les fonctions qui se trouvent dans le fichier ‘ada.dll’ : ?ADAASSEMBLEATOMSTREAM@@ZAJAFVZSTRING@@AEVZBUFFER@@I@Z ?ADADISASSEMBLEATOMSTREAM@@ZAHAFVZBUFFER@@AEVZSTRING@@I@Z ?ADADOATOMCALLBACKS@@ZAHP7AHKGGPFEG@ZKAFVZBUFFER@@I@Z ___EXPORTEDSTUB _ADAASSEMBLEARGUMENT _ADAASSEMBLEATOMSTREAM _ADAASSEMBLEFRAGMENT _ADADISASSEMBLEARGUMENT _ADADISASSEMBLEATOM _ADADISASSEMBLEATOMSTATE _ADADISASSEMBLEATOMSTREAM _ADADISASSEMBLEATOMSTREAMSTATE _ADADOATOMCALLBACKS _ADAENUMALLATOMS _ADAFREESTATE _ADAGETATOMBYNAME _ADAGETATOMNAME _ADAGETERRORTEXT _ADAINITIALIZE _ADAISVALIDPROTOCOL _ADALOOKUPATOMENUM _ADANORMALIZEATOMSTREAM _ADATERMINATE ADA Atomic Disassembler/Assembler WEP 7) Vue d'ensemble ------------------ Le résultat des sujets abordés dans ce document, c'est un client AOL en Visual Basic capable d'envoyer des IM. Ce client utilise les fonctions expliquées plus haut. 1) Démarrer un nouveau projet 2) Ajouter Microsoft Winsock Control au projet 3) Créer un controle sur le formulaire 4) Créer deux boutons de commande (Connect, Send IM) 5) Créer cinq boites texte(Status, Screenname, Password, IMName, IMMsg) Dans 'Declarations' déposer ceci : Dim sixth as String Dim seventh as String Dim packet as String Dans le bouton 'Connect' déposer ceci : Call Winsock1.Connect("AmericaOnline.aol.com", 5190) 'Ouvrir une connexion vers 'le serveur AOL Dans les évenement de 'Connect' du Winsock control, déposer ceci : status.Text = status.Text & "Connected" & vbCrLf packet$ = DeHex("5A413800347F7FA3036B0100F5000000050F00002152CBCA070A1000080400000000035F0 000010004000300080000000000000000000000020D") Winsock1.SendData packet$ ' Envoyer la version du paquet NE RIEN MODIFIER Dans les évenement des 'DataArrival' du Winsock control, déposer ceci: Winsock1.GetData sData, vbString 'Dépose les données envoyées dans 'sData' If Len(sData) = 9 Then ping6$ = Mid(sData, 6, 1) ping7$ = Mid(sData, 7, 1) packet$ = DeHex("0003" & EnHex(ping7$) & EnHex(ping6$) & "A40D") crc1 = AOLCRC(packet$, Len(packet$) - 1) thehi$ = Chr(gethibyte(crc1)) thelo$ = Chr(getlobyte(crc1)) tosend$= DeHex("5A" & EnHex(thehi$) & EnHex(thelo$) & "0003" & EnHex(ping7$) & EnHex(ping6$) & "A40D") Winsock1.SendData tosend$ End If Dim crap as Integer crap = 1 Do Until crap = 0 crap = InStr(1, sData, Chr$(0)) If crap > 0 Then Mid(sData, crap, 1) = "Å" Loop status.Text = status.Text & "Server: " & sData & vbCrLf & vbCrLf If InStr(1, sData, "Invalid password") Then status.Text = status.Text & "Invalid Password" & vbCrLf Call Winsock1.Close End If If InStr(1, sData, "Invalid account") Then status.Text = status.Text & "Invalid account" & vbCrLf Call Winsock1.Close End If If InStr(1, sData, "SD") Then screenname1$ = Int2Hex(Len(screenname.Text) + 1) & EnHex(screenname.Text) password1$ = Int2Hex(Len(password.Text)) & EnHex(password.Text) fifth$ = give5th("5AD69400411010A044640015000100010A0400000001010B04000000010301" & screenname1$ & "20011D00011D00010A04000000020301" & password1$ & "011D000002000D", 2) packet$ = DeHex("00" & fifth$ & "1010A044640015000100010A0400000001010B04000000010301" & screenname1$ & "20011D00011D00010A04000000020301" & password1$ & "011D000002000D") crc1 = AOLCRC(packet$, Len(packet$) - 1) thehi$ = Chr(gethibyte(crc1)) thelo$ = Chr(getlobyte(crc1)) packet$ = DeHex("5A" & EnHex(thehi$) & EnHex(thelo$) & "00" & fifth$ & "1010A044640015000100010A0400000001010B04000000010301" & screenname1$ & "20011D00011D00010A04000000020301" & password1$ & "011D000002000D") Winsock1.SendData packet$ 'Sends the screenname/password. If you don’t 'understand this refer above to 'Forming Packets' packet$ = DeHex("5A3A0A00031018A40D") 'This is a logged ping packet Winsock1.SendData packet$ End If If InStr(1, sData, "Master Tool") Then packet$ = DeHex("5A3A0A00031018A40D5AC6910008111CA079610701010D5A5C340022121CA0746C0017000 1000A0F04007BB5E80A10041DA6DDF20A4504000000070002000D5A6F4A000D131CA053430015000 1000002000D") Winsock1.SendData packet$ 'This sends the ya login packet, 'NO CHANGES HAVE BEEN MADE sixth=Hex2Int("13") seventh=Hex2Int("21") 'This is where you set your sixth and seventh at first. End If Dans le bouton de commande 'Send IM' déposer ceci : screenname1$ = Int2Hex(Len(IMName.Text)) & EnHex(IMName.Text) IM1$ = Int2Hex(Len(IMMsg.Text)) & EnHex(IMMsg.Text) If sixth = "127" Then sixth = "15" 'Backtrack 1 because we are going to add 1 soon seventh = "23" 'THIS IS THE CODE TO RESET THE BYTES End If sixth = CInt(sixth) + 1 seventh = CInt(seventh) + 1 fifth$ = give5th("5A606700001522A06953002500010001070400000003010A04000000010301" & screenname1$ & "011D00010A04000000020301" & IM1$ & "011D00011D00011D000002000D", 2) packet$ = DeHex("00" & fifth$ & Int2Hex(sixth) & Int2Hex(seventh) & "A06953002500010001070400000003010A04000000010301" & screenname1$ & "011D00010A04000000020301" & IM1$ & "011D00011D00011D000002000D") crc1 = AOLCRC(packet$, Len(packet$) - 1) thehi$ = Chr(gethibyte(crc1)) thelo$ = Chr(getlobyte(crc1)) packet$ = DeHex("5A" & EnHex(thehi$) & EnHex(thelo$) & "00" & fifth$ & Int2Hex(sixth) & Int2Hex(seventh) & "A06953002500010001070400000003010A04000000010301" & screenname1$ & "011D00010A04000000020301" & IM1$ & "011D00011D00011D000002000D") Winsock1.SendData packet$ IMMsg.Text="" Dans l'évenement 'SendComplete' du Winsock control déposer ceci : Dim crap as Integer crap = 1 Do Until crap = 0 crap = InStr(1, packet$, Chr$(0)) If crap > 0 Then Mid(packet$, crap, 1) = "Å" Loop status.Text = status.Text & "Client: " & packet$ & vbCrLf & vbCrLf Dans l'évenement 'Change' du status de la boite texte, déposer ceci : status.SelStart = Len(status.Text) 'Auto Scrolls If Len(status.Text) >= 32000 Then status.Text = Right$(status.Text, Len(status.Text) / 2) 'Keeps the length from getting too large Il faut s'assurer que status.Text est défini en multiline=true et qu'il possede bien des barres de scroll. Si tout a été fait correctement, on a maintenant une version fonctionnelle d'un client AOL capable d'envoyer des IM. Bienvenue a Winsuck AOL 8) Sens Commun -------------- La seule raison pour laquelle ce document n'a pas été diffusé plus tot (sa traduction remonte a 1999) est l'abus que certaines personnes et sociétés font avec de tels outils : programmes de spammming, IM bombers, cloners, etc En attendant il plus difficile d'utiliser les sources de ce document que de se procurer les programmes en question (tout ca a cause du word wrap a 80chars ;-), la nouvelle version du protocole AOL y est d'ailleurs pour beaucoup car elle rend la totalité de ce document obsolete, have phun ;-)) tobozo@madchat.org