CTF Quals CSAW 2011 - Networking Hardware

Salut !

Voici le writeup du 2eme challenge de la partie Networking, pour 200 pts.

Description

On nous fournit un fichier capture .pcap et on nous demande de trouver le md5 de l’image.

1. Analyse

On ouvre le fichier pcap avec Wireshark pour analyser le contenu des échanges.On constate qu’il s’agit d’une transmission via USB.

On sait qu’on doit trouver une image donc on peut faire une recherche sur la chaîne de caractère JFIF par exemple.

On arrive directement sur le paquet 1534 qui contient effectivement le début d’une image jpeg. En cherchant les octets FF D9 (fin d’une image jpeg), on remarque que l’image est contenue entre les paquets 1534 et 1542. Voyons voir un peu ce que représente cette image.

2.Travail sur l'image

On peut extraire l’image à partir d’un éditeur hexadécimal. On ouvre le pcap dans Hex Workshop par exemple et on ne garde que le code contenu entre les paires d’octets FF D8 et FF D9. On enregistre le fichier en .jpeg et on l’ouvre :



On pourrait penser que l’image est incomplète mais en regardant de plus près les paquets dans Wireshark, on remarque que c’est le contraire. En effet, chaque paquet transmis est affublé d’une sorte d’en-tête facilement repérable car elle contient les octets F3 4D 75 4E.


L’image étant contenue dans 9 paquets, on a 8 blocs similaires à cet en-tête qui ont été répartis au sein du code de l’image. Cette dernière était donc bruitée.Notre but va être de chercher les occurrences des octets F3 4D 75 4E et de supprimer les blocs de code associés.

On supprime les 8 blocs de 80 octets, on enregistre et on ouvre le fichier :

C’est déjà beaucoup mieux !!!

Bon on récupère le md5 de l’image et on le rentre comme flag… mais ça marche pas !

Est-ce qu’on aurait oublié de supprimer un bloc ?Eh bien non ! La solution est bien plus perfide. En effet, en examinant de plus près le contenu des paquets sur Wireshark, on voit que la fin du dernier ressemble à ça :

Les octets FF D9 désignant la fin de l’image ne sont pas immédiatement suivis par des zéros mais par les 5 octets suivants : 35 50 46 34 0A. Ceci peut faire penser aux techniques de stéganographie utilisées pour signer certaines images. On rajoute de l’information après les marqueurs de fin FF D9 et ainsi la qualité de l’image n’est pas altérée. On peut donc interpréter les 5 octets supplémentaires comme une signature.

On enregistre la nouvelle image obtenue après l’ajout de ces octets et on calcule son md5, ce qui nous donne : 1d45728c91cc401f546178664e42f471.

On rentre donc le flag 1d45728c91cc401f546178664e42f471 qui cette fois valide l’épreuve.

3. Tools

• Wireshark
• Hex Workshop

CTF Quals CSAW 2011 - Crypto (1 à 10)

Salut à tous !

On continue avec les writeups du CSAW CTF. Voici les 10 épreuves de crypto, 1900 pts en tout.

Crypto1

Texte chiffré :

87 101 108 99 111 109 101 32 116 111 32 116 104 101 32 50 48 49 49 32 78 89 85 32 80 111 108 121 32 67 83 65 87 32 67 84 70 32 101 118 101 110 116 46 32 87 101 32 104 97 118 101 32 112 108 97 110 110 101 100 32 109 97 110 121 32 99 104 97 108 108 101 110 103 101 115 32 102 111 114 32 121 111 117 32 97 110 100 32 119 101 32 104 111 112 101 32 121 111 117 32 104 97 118 101 32 102 117 110 32 115 111 108 118 105 110 103 32 116 104 101 109 32 97 108 108 46 32 84 104 101 32 107 101 121 32 102 111 114 32 116 104 105 115 32 99 104 97 108 108 101 110 103 101 32 105 115 32 99 114 121 112 116 111 103 114 97 112 104 121 46

On reconnaît rapidement qu’il s’agit de code ascii mais plutôt que de se lancer dans un décodage à la main, on préférera utiliser le site de Paul Schou (http://home2.paulschou.net/tools/xlate/) qui va nous permettre de décoder tout ça rapidement. Voilà ce qu’on obtient après décodage :

Welcome to the 2011 NYU Poly CSAW CTF event. We have planned many challenges for you and we hope you have fun solving them all. The key for this challenge is cryptography.

On rentre donc le flag cryptography et on valide l’épreuve.

Crypto2

Texte Chiffré :

54:68:69:73:20:69:73:20:74:68:65:20:66:69:72:73:74:20:6d:65:73:73:61:67:65:20:62:65:69:6e:67:20:73:65:6e:74:20:74:6f:20:79:6f:75:20:62:79:20:74:68:65:20:6c:65:61:64:65:72:73:68:69:70:20:6f:66:20:74:68:65:20:55:6e:64:65:72:67:72:6f:75:6e:64:20:55:70:72:69:73:69:6e:67:2e:20:49:66:20:79:6f:75:20:68:61:76:65:20:64:65:63:6f:64:65:64:20:74:68:69:73:20:6d:65:73:73:61:67:65:20:63:6f:72:72:65:63:74:6c:79:20:79:6f:75:20:77:69:6c:6c:20:6e:6f:77:20:6b:6e:6f:77:20:6f:75:72:20:6e:65:78:74:20:6d:65:65:74:69:6e:67:20:77:69:6c:6c:20:62:65:20:68:65:6c:64:20:6f:6e:20:57:65:64:6e:65:73:64:61:79:20:40:20:37:70:6d:2e:20:57:65:20:77:69:6c:6c:20:61:6c:73:6f:20:72:65:71:75:69:72:65:20:61:20:6b:65:79:20:74:6f:20:62:65:20:6c:65:74:20:69:6e:74:6f:20:74:68:65:20:6d:65:65:74:69:6e:67:73:3b:20:74:68:69:73:20:77:65:65:6b:1f:73:20:6b:65:79:20:77:69:6c:6c:20:62:65:20:6f:76:65:72:74:68:72:6f:77:2e

Cette fois, il s’agit de code héxadécimal. Chaque paire de chiffre permet de coder un nombre entre 0 et 255 qui pourra représenter le code ascii d’un caractère.
On fait encore appel à Paul Schou pour un décodage rapide et voici le texte déchiffré :
This is the first message being sent to you by the leadership of the Underground Uprising. If you have decoded this message correctly you will now know our next meeting will be held on Wednesday @ 7pm. We will also require a key to be let into the meetings; this week¬s key will be overthrow.

On récupère le flag overthrow qui valide l’épreuve.

Crypto3

Texte chiffré :

0100110001100001011100110111010000100000011101110110010101100101011010110111001100100000011011010110010101100101011101000110100101101110011001110010000001110111011000010111001100100000011000010010000001100111011100100110010101100001011101000010000001110011011101010110001101100011011001010111001101110011001011100010000001010111011001010010000001110011011001010110010101101101001000000111010001101111001000000110001001100101001000000110011101100101011011100110010101110010011000010111010001101001011011100110011100100000011000010010000001101100011011110111010000100000011011110110011000100000011000100111010101111010011110100010000001100001011000100110111101110101011101000010000001110100011010000110010100100000011011010110111101110110011001010110110101100101011011100111010000101110001000000101010001101000011001010010000001101011011001010111100100100000011001100110111101110010001000000110111001100101011110000111010000100000011101110110010101100101011010110111001100100000011011010110010101100101011101000110100101101110011001110010000001101001011100110010000001110010011001010111001101101001011100110111010001100001011011100110001101100101001011100010000001001001011001100010000001110100011010000110010101110010011001010010000001101001011100110010000001100001011011100111100101101111011011100110010100100000011001010110110001110011011001010010000001111001011011110111010100100000011010110110111001101111011101110010000001101111011001100010000001110100011010000110000101110100001000000110110101100001011110010010000001100010011001010010000001101001011011100111010001100101011100100110010101110011011101000110010101100100001000000110100101101110001000000110101001101111011010010110111001101001011011100110011100100000011000100111001001101001011011100110011100100000011101000110100001100101011011010010000001110100011011110010000001110100011010000110010100100000011011010110010101100101011101000110100101101110011001110010000001110100011010000110100101110011001000000111011101100101011001010110101100101110001000000100100101110100001000000111011101101001011011000110110000100000011000100110010100100000011010000110010101101100011001000010000001110011011000010110110101100101001000000111010001101001011011010110010100101100001000000111001101100001011011010110010100100000011100000110110001100001011000110110010100101110

On a du code binaire : chaque octet (8 bits) va représenter le code ascii d’un caractère. Une fois n’est pas coutume, on va chez Paul Schou pour un décodage rapide et dans les règles :
Last weeks meeting was a great success. We seem to be generating a lot of buzz about the movement. The key for next weeks meeting is resistance. If there is anyone else you know of that may be interested in joining bring them to the meeting this week. It will be held same time, same place.

Le flag resistance valide l’épreuve.

Crypto4

Texte chiffré :

VGhhdCBtZWV0aW5nIHdhcyBhIGxpdHRsZSBjcmF6eS4gV2UgaGF2ZSBubyBpZGVhIHdoZXJlIHRob3NlIGd1eXMgaW4gdGhlIGJsYWNrIHN1aXRzIGNhbWUgZnJvbSwgYnV0IHdlIGFyZSBsb29raW5nIGludG8gaXQuIFVzZSB0aGUga2V5IGluZmlsdHJhdGlvbiBmb3IgbmV4dCB3ZWVrknMgbWVldGluZy4gU3RheSB3aXRoIHRoZSBjYXVzZSBhbmQgd2Ugd2lsbCBzdWNjZWVkLg==

Ça ressemble comme deux gouttes d’eau à de la base 64, je vous laisse deviner chez qui on va décoder ça rapidement. Voici le texte déchiffré :
That meeting was a little crazy. We have no idea where those guys in the black suits came from, but we are looking into it. Use the key infiltration for next week?s meeting. Stay with the cause and we will succeed.

On valide avec le flag infiltration.

Crypto5

Texte chiffré :

JR UNIR QVFPBIRERQ GUNG BHE YNFG GUERR GENAFZVFFVBAF JR'ER RNFVYL QRPVCURERQ. JR UNIR GNXRA PNER BS GUR CNEGL ERFCBAFVOYR SBE GURVE RAPBQVAT NAQ NER ABJ HFVAT N ARJ ZRGUBQ. HFR GUR VASBEZNGVBA CEBIVQRQ NG YNFG JRRX.F ZRRGVAT GB QRPVCURE NYY ARJ ZRFFNTRF. NAQ ERZRZORE, GUVF JRRX.F XRL VF BOSHFPNGRQ.

Le texte chiffré fait penser à un chiffrement par décalage (chiffre de César) ou un chiffrement par substitution.

On va regarder ce que ça donne si on considère qu’il s’agit d’un chiffrement par décalage.
L’un des plus célèbres chiffrements de ce type est le Rot13 qui consiste à remplacer chaque lettre de l’alphabet par celle qui se trouve 13 lettres plus loin dans ce même alphabet (on revient à A quand on dépasse Z). On décale les lettres du texte chiffré de 13 et voilà le résultat :
WE HAVE DISCOVERED THAT OUR LAST THREE TRANSMISSIONS WE'RE EASILY DECIPHERED. WE HAVE TAKEN CARE OF THE PARTY RESPONSIBLE FOR THEIR ENCODING AND ARE NOW USING A NEW METHOD. USE THE INFORMATION PROVIDED AT LAST WEEK.S MEETING TO DECIPHER ALL NEW MESSAGES. AND REMEMBER, THIS WEEK.S KEY IS OBFUSCATED.

On obtient le flag obfuscated.

Crypto6

Texte chiffré :

PYB DRO XOHD WOODSXQ LO CEBO DY ECO UOI WKXUSXN. DROBO RKFO LOOX CYWO QBOKD SNOKC PVISXQ KBYEXN YEB WOODSXQC KC YP VKDO. DRO KEDRYBSDI GSVV QY YFOB CYWO YP DROW DY COO SP DROI PSD SXDY YEB KQOXNK.

Comme pour l’épreuve précédente, on a probablement affaire à un décalage ou une substitution. On commence par le décalage et après quelques essais, on trouve que le chiffrement utilisé est le Rot10 (On peut utiliser le site suivant pour tester les décalages : http://www.apprendre-en-ligne.net/crypto/cesar/).

Voici le texte déchiffré :
FOR THE NEXT MEETING BE SURE TO USE KEY MANKIND. THERE HAVE BEEN SOME GREAT IDEAS FLYING AROUND OUR MEETINGS AS OF LATE. THE AUTHORITY WILL GO OVER SOME OF THEM TO SEE IF THEY FIT INTO OUR AGENDA.

Le flag de cette épreuve est donc mankind.

Crypto7

Texte chiffré :

VAOZM HPXC YZGDWZMVODJI OCZ VPOCJMDOT CVN YZXDYZY OCVO OCZMZ DN JIZ DYZV RCDXC RZ RDGG OVFZ PK VN KVMO JA JPM XVPNZ. OJ CZVM HJMZ VWJPO DO, WZ NPMZ OJ VOOZIY OCZ IZSO HZZODIB, PNZ OCZ FZT BZIZMVODJI OJ BZO DI. OCZMZ DN HPXC KGVIIDIB IZZYZY OJ WZ YJIZ, WPO DA RZ XVI ZSZXPOZ OCZ KGVI RZ RDGG WZ AMZZY.

Comme pour les deux épreuves précedentes, on commence par tester le chiffrement par décalage et cette fois-ci il s’agit d’un Rot21. On obtient ceci :
AFTER MUCH DELIBERATION THE AUTHORITY HAS DECIDED THAT THERE IS ONE IDEA WHICH WE WILL TAKE UP AS PART OF OUR CAUSE. TO HEAR MORE ABOUT IT, BE SURE TO ATTEND THE NEXT MEETING, USE THE KEY GENERATION TO GET IN. THERE IS MUCH PLANNING NEEDED TO BE DONE, BUT IF WE CAN EXECUTE THE PLAN WE WILL BE FREED.

On valide avec le flag generation.

Crypto8

Texte chiffré :

EKEMQ XI LEWI CIESQIH ULEU BVS USEQTPMTTMBQT ESI FIMQK PBQMUBSIH. ET E SITVCU XI ESI GLEQKMQK ULI IQGSDAUMBQ PIULBH EKEMQ. ULI QIX OID JBS QIYU PIIUMQK XMCC FI ABCDKBQ. MU MT MPAISEUMWI ULEU DBV ECC EUUIQH ECC PIIUMQKT JSBP LISI BQ MQ.

Sur ce texte chiffré, les décalages ne donnent rien, il s’agit donc certainement d’un chiffrement par substitution : on va remplacer une lettre de l’alphabet par une autre lettre du même alphabet. On va établir un nouvel alphabet qui contiendra les mêmes lettres que l’alphabet classique mais qui sera organisé autrement.

Pour retrouver l’alphabet de substitution, on va faire une analyse de la fréquence des lettres. Dans la langue anglaise, la lettre la plus fréquente est le E. Si on applique cette hypothèse sur le texte chiffré on obtient que le I doit remplacer le E. Maintenant, on sait que le mot de trois lettres le plus fréquent en anglais est THE, on va donc regarder si un mot de trois lettres se terminant par I apparaît plusieurs fois. Bingo ! On a deux fois le mot ULI et en plus on récupère ULEU qui doit dans ce cas être THAT. On résume ce qu’on a trouvé : I=E, U=T, L=H et E=A.

Voyons ce que ça donne en remplaçant dans le texte chiffré (lettres trouvées en minuscule) :

aKaMQ Xe haWe CeaSQeH that BVS tSaQTPMTTMBQT aSe FeMQK PBQMtBSeH. aT a SeTVCt Xe aSe GhaQKMQK the eQGSDAtMBQ PethBH aKaMQ. the QeX OeD JBS QeYt PeetMQK XMCC Fe ABCDKBQ. Mt MT MPAeSatMWe that DBV aCC atteQH aCC PeetMQKT JSBP heSe BQ MQ.

On peut déjà deviner quelques mots : par exemple au début si on remplace le X et le W par W et V, on obtient we have. De plus, on voit qu’on a presque deux fois le même mot à une lettre près PeetMQK et PeetMQKT ce qui nous fait penser immédiatement au mot MEETING (avec et sans S à la fin) qui est d’ailleurs présent dans la plupart des textes déchiffrés des épreuves précédentes. On a donc X=W, W=V, P=M, M=I, Q=N, K=G et T=S. On remplace :

again we have CeaSneH that BVS tSansmissiBns aSe Feing mBnitBSeH. as a SesVCt we aSe Ghanging the enGSDAtiBn methBH again. the new OeD JBS neYt meeting wiCC Fe ABCDgBn. it is imAeSative that DBV aCC attenH aCC meetings JSBm heSe Bn in.

A présent, on peut deviner des bouts de phrases à partir des mots représentés en rouge :

• Transmissions are being
• We are changing
• Next meeting will be
• Attend all meetings
• Here on in

On récupère S=R, B=O, F=B, G=C, Y=X, C=L, H=D. De plus, here on in est la fin d’une expression bien connue : FROM here on in. Le mot de quatre lettres précédent est donc surement FROM. On a alors J=F.

Un alphabet de substitution est généralement construit en écrivant les lettres d’un mot clé que l’on fait suivre par les lettres restantes de l’alphabet classique mis dans l’ordre. Cette théorie semble être corroborée par le mot ABCDgBn qui contient le 4 premières lettres de l’alphabet consécutivement. En tenant compte des déductions précédentes, on peut transformer ce mot en AolDgon. On pense au mot polygon qui nous donnerait ABCD=POLY. On sait déjà que EFGH=ABCD. On est donc maintenant sûr que le mot clé utilisé pour former l’alphabet de substitution est POLY.
On obtient alors l’alphabet suivant :POLYABCDEFGHIJKMNQRSTUVWXZ. On peut déchiffrer entièrement le texte :
AGAIN WE HAVE LEARNED THAT OUR TRANSMISSIONS ARE BEING MONITORED AS A RESULT WE ARE CHANGING THE ENCRYPTION METHOD AGAIN THE NEW KEY FOR NEXT MEETING WILL BE POLYGON IT IS IMPERATIVE THAT YOU ALL ATTEND ALL MEETINGS FROM HERE ON IN

Le flag est polygon.

Crypto9

Texte chiffré :

XI VQHISTUEQH ULEU ULMT XMCC FI QB IETD UETO UB IYIGVUI EQH ULEU XI ESI ETOMQK E CBU JSBP ECC BJ DBV. XI HB QBU JEVCU EQD PIPFIST JBS CIEWMQK, XI ESI FIUUIS BJJ XMULBVU ULBTI XIEO CMQOT. ULI ACEQQMQK TUEKI MT QBX BWIS. ULI OID JBS BVS JMQEC PIIUMQK MT JEXOIT. SIEHD DBVSTICWIT. ULI UMPI LET GBPI JBS VT UB FI JSIIH.

On remarque d’emblée que plusieurs mots du cryptogramme de l’épreuve précédente sont présents : XI, ULI, ULEU, JSBP, PIIUMQK et quelques autres. Est ce qu’ils auraient utilisé le même alphabet de substitution ? On regarde ce que ça donne :
WE UNDERSTAND THAT THIS WILL BE NO EASY TASK TO EXECUTE AND THAT WE ARE ASKING A LOT FROM ALL OF YOU. WE DO NOT FAULT ANY MEMBERS FOR LEAVING, WE ARE BETTER OFF WITHOUT THOSE WEAK LINKS. THE PLANNING STAGE IS NOW OVER. THE KEY FOR OUR FINAL MEETING IS FAWKES. READY YOURSELVES. THE TIME HAS COME FOR US TO BE FREED.

Le flag fawkes valide.

Crypto10

Texte chiffré :

LQBN XBEE IG HWV EDNL LVDCNSBNNBHC. ZHW'MG DEE VGKGBMGO ZHWV DNNBPCSGCLN. BA ZHW DVG DIEG LH KHSTEGLG ZHWV LDNR VGTEZ IDKR LH WN WNBCP LQG RGZXHVO AVHS LQBN GCKVZTLBHC DEPHVBLQS DN ZHWV RGZ. JWNL VGSGSIGV LQDL LQBN BN DEE AHV LQG PVGDLGV PHHO.

On a probablement encore affaire à un chiffrement par substitution. En tout cas, les différents décalages (chiffre de César) possibles ne donne rien.
L’analyse des fréquences nous donne G=E et on remarque plusieurs occurrences de LQG et LQBN ainsi qu’un LQDL. On sait que G=E, on peut donc penser que LQG=THE, et on peut alors en déduire LQDL=THAT et LQBN=THIS. On obtient L=T, Q=H, G=E, D=A, B=I et N=S.
On remplace dans le texte chiffré :

this XiEE Ie HWV East tVaCsSissiHC. ZHW'Me aEE VeKeiMeO ZHWV assiPCSeCts. iA ZHW aVe aIEe tH KHSTEete ZHWV tasR VeTEZ IaKR tH Ws WsiCP the ReZXHVO AVHS this eCKVZTtiHC aEPHVithS as ZHWV ReZ. JWst VeSeSIeV that this is aEE AHV the PVeateV PHHO.

On Remarque quelques mots intéressants : East, tasR, aVe, aEE et tVaCsSissiHC.
Pour tasR, la seule possibilité semble être task, on a donc R=K. En revanche East pourrait donner past, fast, last ou cast mais on constate que le E est utilisé en double dans aEE. La seule solution est E=L.
Ensuite, le mot tVaCsSissiHC fait penser à un mot déjà présent dans certains cryptogrammes précédents : transmission. On aurait V=R, C=N, S=M et H=O. Cette hypothèse donnerait aussi aVe=are ce qui paraît être un bon choix. On remplace un fois de plus :
this Xill Ie oWr last transmission. ZoW'Me all reKeiMeO ZoWr assiPnments. iA ZoW are aIle to KomTlete ZoWr task reTlZ IaKk to Ws WsinP the keZXorO Arom this enKrZTtion alPorithm as ZoWr keZ. JWst rememIer that this is all Aor the Preater PooO.

On peut reconnaître plusieurs morceaux de phrases parmi ceux en rouge :

• This will be our last transmission
• Assignments
• To complete your task
• From this encryption algorithm
• Just remember that this all for the greater good (corroboré par les précédents)

On récupère X=W, I=B, W=U, K=C, T=P, Z=Y, A=F, P=G, J=J et O=D. Il reste à trouver les lettres M, F, Y et U. On peut trouver le M facilement car en utilisant ZoW’Me qui donne you’Me, on déduit que M=V.
On peut d’ores et déjà déchiffrer tout le texte avec ce qu’on a :
THIS WILL BE OUR LAST TRANSMISSION. YOU'VE ALL RECEIVED YOUR ASSIGNMENTS. IF YOU ARE ABLE TO COMPLETE YOUR TASK REPLY BACK TO US USING THE KEYWORD FROM THIS ENCRYPTION ALGORITHM AS YOUR KEY. JUST REMEMBER THAT THIS IS ALL FOR THE GREATER GOOD.

Il va falloir déterminer l’alphabet de substitution en entier car c’est surement lui qui fera office de flag.
Pour le moment, il ressemble à ceci : FINAL?EOBJCTVSDGHKMP?RUW?Y
On voit que l’ordre de l’alphabet classique reprend à partir du D, par conséquent il ne reste qu’une seule possibilité pour U et Y car les lettres doivent se suivre. On a donc U=Q et Y=X.
On en déduit alors que F=Z.

On trouve finalement l’alphabet de substitution : FINALZEOBJCTVSDGHKMPQRUWXY
C’est le flag !!!

Liens Utiles

http://home2.paulschou.net/tools/xlate/
http://www.apprendre-en-ligne.net/crypto/cesar/

CTF Hack.lu 2011 - Unknown Planet

Hello tout le monde !

un petit writeup sur un challenge de CTF Hack.lu 2011.

Description

We got this file. Can you find the name of this planet?

Voici l’image qu’on peut télécharger en cliquant sur le lien :

1. Analyse

Comme l’indique la description du challenge, un nom de planète se cache quelque part dans cette image Jpeg.

On commence par ouvrir l’image avec un éditeur héxadécimal (Hex Workshop ici) et on remarque très vite une chose troublante.

En effet, le code héxadécimal d’une image Jpeg commence toujours par FF D8 et se termine toujours par FF D9. Voici ce qu’on peut observer avec cette image :

Début du code hexadécimal

Fin du code hexadécimal

Le code débute bien par FF D8 mais par contre les deux octets FF D9 ne sont pas présents à la fin du code. En faisant, une recherche sur ces 2 octets, on parvient néanmoins à les trouver.

On vient de trouver la fin du code hexadécimal servant à la représentation de l’image. Tout ce qui suit pourrait être supprimé sans que cela n’ait d’impact sur l’image elle-même.

Ce code hexadécimal supplémentaire mérite donc qu’on se penche dessus pour y dénicher quelque info confidentielle comme le nom d’une planète par exemple.

On récupère donc ce code et on l’insère dans une nouvelle page de l’éditeur pour une analyse plus poussée. Voici un extrait du code :

On remarque deux choses :

• - Des chaînes de 13 caractères se terminant toutes par UT (encadrées en bleu).

• - La présence des caractères PK tout au long du code (entourés en rouge).

Les caractères PK sont caractéristiques des fichiers zip : Ce sont les initiales de Phil Katz, le créateur du format.

On peut donc enregistrer notre code hexadécimal en tant que fichier .zip pour voir ce qu’on obtient.

2. Travail sur l'archive Zip

L’archive nouvellement créée contient 9 fichiers dont les noms rappellent les chaînes de caractères mentionnées plus haut.

Si on ouvre le premier avec notepad voici ce qu’on peut voir :

L’entête nous indique qu’il s’agit d’un fichier wav. On l’enregistre alors en tant que tel et on le lance avec VLC par exemple.

On entend clairement le début d’un code Morse (un point et deux traits) et on se doute qu’il va falloir concaténer les 9 fichiers dans le bon ordre afin d’obtenir l’enregistrement complet en Morse censé nous révéler le nom de cette planète (du moins on l’espère).

On connaît déjà le premier fichier : celui qui contient l’entête, mais on sait aussi que le dernier est celui dont la taille est nettement inférieure à celle des autres (on a 8 fichiers de 20 000 octets et un seul de 1324 octets).

On remarque que cet ordre est respecté lorsqu’on classe les fichiers par ordre décroissant selon la valeur de la colonne « Compressé » dans Winrar (voir capture plus haut).

On peut alors penser qu’il faudra tester deux possibilités à cause des deux fichiers à 72.

Pourtant les enregistrements ne donnent rien de probant : ils comportent notamment des coupures brèves qui nous amènent à penser que cette façon d’ordonner les fichiers n’était pas la bonne.

3. Analyse des blocs de code hexadécimal récurrents

On va alors se placer à un niveau plus bas en ouvrant les 9 fichiers dans Hex Workshop pour analyser le code hexadécimal plus en détail.

On remarque que les 9 fichiers sont composés de deux types de blocs :

1er type de bloc (Bloc A)

2ème type de bloc (Bloc B)

Si compte le nombre d’octets qui composent chacun de ces blocs dans les 9 fichiers, on constate qu’on a deux tailles possibles pour chaque bloc. Le bloc A peut faire 5761 octets ou 1921 octets alors que le bloc B peut faire 5759 octets ou 1919 octets.

On va pouvoir reconstituer ce puzzle en regardant la taille des blocs A et B inachevés en début et fin de fichiers et en cherchant le bloc complémentaire à chacun qui donnera un bloc total correspondant à l’une des tailles possibles.

Cette séance de collage nous donnera l’ordre de fichiers suivants :

1. uvlSlG3Tgow
2. 5IIUED7GheR
3. rySOWi4fZkA
4. 87F1s5POUJc
5. 6JXtwsTTh9k
6. Uw105aD3qYh
7. BPiIOASG_Z6
8. Yui5oq58hlx
9. nLPA8X0UJqf

On concatène alors ces 9 fichiers dans un seul qu’on enregistre en tant que fichier wav.

Maintenant place au décodage !!!!

4. Décodage

L’enregistrement est plutôt net et on obtient facilement le code Morse suivant :

.--. …. . .. -.- -.-- --- …

On décode alors le mot de 8 lettres : PHEIKYOS

On connaît enfin le nom de notre planète et on valide ce challenge en rentrant le flag : Pheikyos.

5. Tools

• Hex Workshop
• Winrar
• Notepad
• VLC

6. Référence

• Format JPEG (wikipédia)
  
• Format ZIP (wikipédia)
• Code Morse (wikipédia)

CTF Public NDH2K11 – Crackme1

Hello !

On continue dans les writeups de la NDH 2011 avec celui pour le crackme1. Gogogo !

1. 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.
   
   
   
   
   

2. 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 …
   
   

3. 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 :) )
   
   

4. 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.
   
   

5. Références & tools

   
   [1] - PeID
   [2] - LordPE
   [3] - ImmunityDbg
   [4] - Unpack d'UPX, mais la méthode est la même ici
   

CTF Public NDH2K11 – Stega4

Nous revoilà avec les write-ups du CTF Public de la NDH 2011, cette fois c'est le Stega4 !

1. Analyse

   
   On nous donne uniquement une grosse (~6mo) image SVG :(
   On l'affiche et... rien de spécial.
   On l'ouvre avec ce bon vieux Notepad++ par exemple et on découvre, au milieu, un gros paquet de données encodé en base64.
   
   
   <meta name="geturflaghere" value="Vm0...
   
   Avec le nom "geturflaghere" on en sûr ! Le flag est là !
   
   Après un premier décodage, on s’aperçoit que le flag a été encodé de nombreuses fois :(
   Il va falloir automatiser ça !
   
   

2. Décodage

   
   Chacun sa méthode pour le décodage, en voici 2 :
   
   

   • Batch + base64.exe

     
     Cette méthode nécessite d'avoir extrait la partie base64 du fichier avant.
     
     
     @echo off
     
     if "%1" == "" goto usage
     if not exist "%1" goto usage
     
     copy %1 %TEMP%\%~n1.tmp 1> NUL
     
     :l
     base64.exe -d %TEMP%\%~n1.tmp %TEMP%\%~n1.tmp.dec 2> NUL
     if %ERRORLEVEL% == 1 goto flag
     del %TEMP%\%~n1.tmp
     ren %TEMP%\%~n1.tmp.dec %~n1.tmp
     goto l
     goto exit
     
     :usage
     echo Usage: %~n0 file.b64
     goto exit
     
     :flag
     type %TEMP%\%~n1.tmp
     del %TEMP%\%~n1.tmp
     goto exit
     
     :exit
     
      
     
     

   • Python

     
     Petite astuce pour extraire les données, on cherche juste une chaine assez longue contenant uniquement les caractères d'un base64 :
     
     
     import re
     import base64
     
     image = re.findall('[\w+/=]{100,}',
         open("stega4.svg").read().replace(" ", ""))[0]
        
     try:
         while 1:
             image = base64.b64decode(image)
     except TypeError:
         print image
      
   
   Dans les 2 cas, on obtient : G1rl1en3x7d00rIz9:]
   
   Et voilà vous avez le flag ! Gogo next challenge !
   
   

3. Références & tools

   
   [1] - Base64.exe for Windows

CTF Public NDH2K11 – Crypto1

Bonjour à tous !

Voici notre premier write-up d'une épreuve de CTF et ça sera l'épreuve Crypto1 du CTF public de la NDH 2011.

Rentrons dans le vif du sujet.

1. Analyse

   
   Pour la première épreuve, nous avions un fichier texte avec le contenu suivant :
   
   
   3534315412155211431131323443441122153324344543
   
   Nous remarquons que les notre alphabet va de 1 à 5 et que c'est sûrement un algorithme de chiffrement par substitution monoalphabétique.
   
   Il y a peu d'algorithme de substitution dont le cryptogramme est composé de chiffres et le plus connu d'entre eux est le carré de Polybe. [1] [2]
   
   Nous allons donc faire quelques tests avec les deux grilles (5*5) de Polybe :
   
   • La grille française qui comporte le I et le J mais qui ne comporte pas de W :
     
     
     
     
     
   • La grille anglaise qui agrège le I et le J mais qui comporte le W :
     
     
     
     
     

2. Déchiffrement

   
   On traite le cryptogramme afin d'avoir des couples (qui seront les coordonnées des lettres dans notre grille) et nous obtenons ceci :
   
   
   35 34 31 54 12 15 52 11 43 11 31 32 34 43 44 11 22 15 33 24 34 45 43
   
   On déchiffre à l'aide de la grille française :
   
   
   O N K Y B E V A R A K L N R S A G E M I N T R
   
   Avant de tenter toutes choses sur ce "premier jet" déchiffré (ROT13, etc...), nous allons procedé au même déchiffrement mais avec la grille anglaise.
   
   Déchiffrement grille anglaise :
   
   
   P O L Y B E W A S A L M O S T A G E N I O U S
   
   Le déchiffrement avec la grille anglaise nous donne la réponse directement, il ne nous reste plus qu'à rentrer le flag : "polybewasalmostagenious" pour valider l'épreuve.
   
   Et voilà, 500 points ! Go next challenge !
   
   

3. Références

   
   [1] - Wikipedia - Le carré de Polybe
   [2] - Apprendre en ligne - Crypto