On continue dans les writeups de la NDH 2011 avec celui pour le crackme1. Gogogo !
Analyse
On nous a fourni un exécutable, safecrypt.exe, ainsi qu'un fichier PNG chiffré.
On se doute bien du but de l'épreuve, c'est à dire, déchiffrer cette image qui doit contenir le flag.
On lance alors ce safecrypt.exe pour voir, ça ne coûte rien (pour un crackme :))
D:\Devs\NDH2K11>SafeCrypt.exe
Use : [1/2] SafeCrypt.exe input output
1 : Crypt
2 : UnCrypt
On apprend qu'il veut 3 arguments, le mode, le fichier d'entrée et le fichier de sortie. Rien de particulier.
Un petit coup de PeID pour voir s'il est packé ou s’il utilise des fonctions crypto (md5, base64...). Mais non, toujours rien :)
C’est fini pour les préliminaires, on passe aux choses sérieuses ! On l’ouvre avec notre ImmunityDbg préféré et on obtient ceci :
On voit 3 blocs de code, puis le saut vers une certaine adresse. Ensuite plus rien.
On reconnait tout de suite un code qui unpack par les routines qui déchiffrent les sections, puis un saut vers l'OEP.
L'adresse de début de la section est mise dans EAX, la fin dans ECX, ensuite on xor chaque octet avec 2D (la clé). Et on fait ça pour les 3 sections.
On peut le vérifier en comparant avec les adresses des sections avec LordPE (VOffset et RSize) :
On unpack ou pas ? On verra si il y besoin, pour le moment on laisse comme ça.
Quelques touches F7/F8 plus tard, on arrive bien au début de notre programme.
Reverse
On descend un peu et on tombe sur des choses plus intéressantes.
Il vérifie si le nombre d’arguments est au moins 3, si c’est bon on demande le mot de passe sinon ça affiche le message "usage".
Une partie importante, après avoir lu le mot de passe, on calcule sa taille (avec strlen), puis on passe le tout à la fonction SafeCryp.00401637.
Cette fonction calcule un hash du mot de passe sur 4 octets, qui sera ensuite utilisé (heureusement :) ) pour le chiffrement/déchiffrement.
On ouvre notre fichier d’entrée, de même pour la sortie. Pour calculer la taille du fichier d’entrée, on utilise lseek en se plaçant à la fin du fichier, puis on revient au début.
Avec cette taille, on alloue un buffer qui servira surement à mettre notre version chiffrée/déchiffrée du fichier. Tout est prêt ! go !
Voilà la partie du chiffrement, au début on compare le paramètre à "1", si ça correspond on chiffre, sinon on le compare avec "2" pour le déchiffrement, et si ça correspond toujours pas, ben ... tant pis, on continue quand même :).
La partie finale, on ne va pas la détailler, on écrit notre buffer dans le fichier de sortie, on dit « Finished! » et voilà.
Si vous avez bien suivi, dans le cas d’une opération inconnue, on aura des valeurs indéfinies dans le fichier de sortie, et ui, mais on s’en fou et l'auteur du chall aussi :)
Revenons à notre chiffrement, au début on lit notre fichier et on met dans le buffer. ok.
Ensuite pour chaque DWORD du buffer, on XOR avec le hash précédemment calculé, ce qui donne notre DWORD chiffré, puis on met à jour la « clé » en utilisant la même fonction qu'au début, SafeCryp.00401637 et le DWORD en clair. Un genre de mode CBC sauf qu’on utilise le clair.
Donc voilà, c’est juste un XOR avec une clé de 4 octets. On pourrait bruteforcer, mais bon, c’est une épreuve de crackme, il doit y avoir plus simple ou en-tout-cas moins long :) . Avant d’utiliser le brain, regardons le déchiffrement.
Le début est le même, on met tout le fichier dans le buffer. Ensuite pour chaque DWORD chiffré, on le XOR avec le hash du mot de passe, on retrouve notre octet clair.
On garde ce DWORD déchiffré pour mettre à jour le hash et on passe au DWORD suivant.
Ainsi de suite …
Brain
Voici donc pour résumer l’algorithme utilisé :
fonction chiffre(buffer, hash){
pour chaque DWORD i du buffer {
tmp = buffer[i]
buffer[i] = buffer[i] XOR hash
hash = updateHash(hash, tmp)
}
}
fonction dechiffre(buffer, hash)
pour chaque octet i du buffer {
buffer[i] = buffer[i] XOR hash
hash = updateHash(hash, buffer[i])
}
}
Bon alors, comment qu’on fait maintenant ? :)
Il faut remarquer que le hash de départ est le seul à utiliser le mot de passe, donc c’est sur celui-là qu’il faudra jouer.
Le reste des hashs dépend des octets déchiffrés et des hashs précédents, si le premier est bon, les autres le seront.
Donc il faudrait forcer le premier hash à être bon, peut importe la clé qu’on entre.
On se rappelle qu’on a : clair = hash XOR chiffré, le chiffré on l’a, le clair on l’a ….? Et UI ! C’est un fichier png donc l’entête est standard et vaut 89 50 4E 47.
Donc on peut calculer le hash pour déchiffrer les premiers octets. Pour trouver le mot de passe derrière, c’est un autre problème, mais on n’en a pas besoin ici.
Pas besoin de rappeler comment marche le XOR, on sait que hash = chiffré XOR clair.
#include <stdio.h>
unsigned int sw(unsigned int x){
return (x>>24) |
((x<<8) & 0x00FF0000) |
((x>>8) & 0x0000FF00) |
(x<<24);
}
int main(int argc, char* argv[]){
FILE* in = fopen("Challenge.png", "r");
int b, hash;
if (in){
fread(&b, 4, 1, in);
printf("First dword is %.08x and first hash should be %.08x\n", b, b ^ sw(0x89504e47));
fclose(in);
}
return 0;
}
Quelques lignes de C ou une ligne de Python plus tard, on sait que le hash doit être 80ce21e8.
(J'ai rajouté une fonction swap, ça peut toujours être utile à quelqu'un :) )
Crack
On va patcher la valeur du hash avec Immunity, c'est la méthode la plus rapide.
Pour cela, il faut déjà mettre les arguments au programme (Debug > Arguments) et on met quelque chose du genre : 2 Challenge.png Flag.png.
Avant de run le programme, on met un breakpoint à l'adresse 0x00401347, c'est à cette adresse que le programme récupère la valeur du hash (depuis EAX) et la sauvegarde quelque part.
Maintenant c'est bon, on trace à fond, on donne un mot de passe comme demandé, ensuite on arrive à notre breakpoint. On modifie la valeur d'EAX par 0x80ce21e8 puis on laisse le programme finir.
Et voilà, le flag est dans Flag.png :)
Une autre méthode ?
On peut aussi patcher safecrypt.exe, pour faire simple, faut unpacker, éditer le fichier et remplacer le call juste avant 0x00401347 (offset 0x1342) par un mov eax, 0x80ce21e8 (qui donne B8E821CE80) en héxa.
Références & tools
[1] - PeID
[2] - LordPE
[3] - ImmunityDbg
[4] - Unpack d'UPX, mais la méthode est la même ici
