jeudi 29 septembre 2011

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/




lundi 26 septembre 2011

CTF Quals CSAW 2011 - Forensics EvilBurritos1 !

Hey !
On continue avec les writeups du CSAW CTF ! Un challenge "networking" encore, EvilBurritos1 ! à 300 pt.

  1. What ?

    On nous fournit un core dump d'un programme : core.burritos
    Il nous faut retrouver l'adresse email du contact chez Evil Burritos :

    We're currently investigating a company named Evil Burritos,
    we recovered this from one of their suspected programmer's
    computers. If you can find evidence of their involvement
    with Evil Burritos that would help greatly! Please find an
    email address of someone from Evil Burritos!


  2. Un peu de recherche

    Voyons les strings de notre fichier :

    1. strings core.burritos > strings.txt

    On cherche un peu dans les strings si on trouve "burritos" puis on tombe rapidement sur :

    1. [Gmail]/Drafts
    2. x* 1 FETCH (UID 6 BODY[] {1071}
    3. MIME-Version: 1.0
    4. Received: by 10.42.241.10 with HTTP; Sun, 28 Aug 2011 18:22:41 -0700 (PDT)
    5. To: shrlchn99@evil-inc.burritos
    6. Date: Sun, 28 Aug 2011 19:22:41 -0600
    7. Message-ID: <CAETwm9ZgPAwARUw34_Jy=LdP3WPTuU68UCQUBeVswu-9OkVUxA@mail.gmail.com>
    8. Subject: Evil Burritos
    9. From: Kim Jung <kmjng6@gmail.com>
    10. Content-Type: multipart/alternative; boundary=20cf30363ae736dd1204ab9abb2f
    11. --20cf30363ae736dd1204ab9abb2f
    12. Content-Type: text/plain; charset=UTF-8
    13. Shirly, I changed the name of the burrito making machine to KILLTHEPLANET.
    14. If you want to change it back fell-free, just log in and type:
    15. change-burrito-machine-name, if you forgot the password let me know.
    16. LONG LIVE THE EVIL BURRITOS!
    17. --20cf30363ae736dd1204ab9abb2f
    18. Content-Type: text/html; charset=UTF-8
    19. Shirly, I changed the name of the burrito making machine to KILLTHEPLANET. If you want to change it back fell-free, just log in and type: change-burrito-machine-name, if you forgot the password let me know.<br><br>LONG LIVE THE EVIL BURRITOS!<br>
    20. <br>
    21. --20cf30363ae736dd1204ab9abb2f--)
    22. a0007 OK Success

    Et voilà, l'adresse email de la personne de EvilBurritos est : shrlchn99@evil-inc.burritos

CTF Quals CSAW 2011 - Networking Patch Management

Salut à tous !
On continue avec les writeups du CSAW CTF ! Un challenge "networking", patch management à 400 pt.

  1. What ?

    On nous fournit un fichier "capture.pcap" que vous pouvez retrouver sur shell-storm ici On go sur wireshark et on look :


    On voit les versions du client et du serveur. Si vous ne connaissez pas la fameuse vuln OpenSSL de 2008 que l'on peut retrouver en détails ici, en mettant la version du client sur Google, on arrive rapidement à cette vuln.
    Maintenant il faut exploiter cette vuln pour dechiffrer la conversation.

  2. Déchiffrement

    En premier, on va séparer le traffic client et serveur. Pour celà, on va utiliser tcpick que l'on peut télécharger ici puis cette commande :

    1. keysec@debian:/media/DATA/Devs/CSAW$ tcpick -wRC -wRS -r capture.pcap
    2. Starting tcpick 0.2.1 at 2011-09-26 20:34 CEST
    3. Timeout for connections is 600
    4. tcpick: reading from capture.pcap
    5. 1      SYN-SENT       192.168.0.119:58214 > 192.168.0.222:ssh
    6. 1      SYN-RECEIVED   192.168.0.119:58214 > 192.168.0.222:ssh
    7. 1      ESTABLISHED    192.168.0.119:58214 > 192.168.0.222:ssh
    8. 1      FIN-WAIT-1     192.168.0.119:58214 > 192.168.0.222:ssh
    9. 1      TIME-WAIT      192.168.0.119:58214 > 192.168.0.222:ssh
    10. 1      CLOSED         192.168.0.119:58214 > 192.168.0.222:ssh
    11. tcpick: done reading from capture.pcap
    12.  
    13. 74 packets captured
    14. 1 tcp sessions detected

    Maintenant on a besoin de 2 tools, ssh_kex_keygen disponible sur le site de l'auteur Raphael Rigo ici et ssh_decoder.rb ici.
    Copiez ssh_decoder.rb dans ssh_kex_keygen/, vous pourrez ensuite utiliser ssh_decoder.rb sans problèmes :

    1. keysec@debian:/media/DATA/Devs/CSAW/ssh_kex_keygen-1.1$ ssh_decoder -c -n2 ../tcpick_192.168.0.119_192.168.0.222_ssh.*
    2.  * read handshake
    3. cipher: aes128-cbc, mac: hmac-md5, kex_hash: sha1, compr: none
    4.  * bruteforce DH
    5. DH shared secret : 028b79a7ee617e11fe3cc5600b93b9423e75c494dcc5e12fed2d99864dd940838c09f77f62356d600c32a37c9e585b21fa0f9c11dc97f7bac6a9a8864fe55a210048c149ae9bf3c6399a8c162bb7cbf1cf7678b34ffe7c118ee34a1239fb4b9d960b6746e60a456a0284c0e2210b837c554c9ef857b6f25ea106422c881c08aa
    6.  * derive keys
    7.  * decipher streams
    8.  * successful authentication packet
    9. {:key=>
    10.   {:g=>
    11.     "l\232\203\271\265$'\003g\000\317\335\003\222\304\f\357h\f^\016\311\261\023\001JR\352\363\262\3556\251\227$FB\307\344\370\277u\362\017d\003\222\227v\305\034\363\220Sz<\"\232\003\235\025\210B\240%\3114\021Cu\017\340\317\306\221\306\241\217\025O\254\230\004\212\311\204\263\206\224\004\317\035{\271\262\027J\373\350\325P\201\226\364K{\242\2747\"\274\243\257\002D\2743\231`wc\b\312\276D\3614\022",
    12.   :type=>"ssh-dss",
    13.   :p=>
    14.    "\000\207\364\bvQR\300$U\371\317``\322\021\037X\235P\032\261\244\277\352\327\277\247O\020\253\b\250z#3\004\223\022\021\256\237\203\253*mh;\311\323\031\302\005\025\204o6\270\"*\256\244\027s\242Q\020j\nb\234\"\252\372\2415x\273?U1\bj\237\270J\a6\350\246n\027\322\"6\022\311\310\374F\346P<\261A\266*\320\333C\304\004X\300\217\241g\267\334}\005\026\345}\223aXD\255",
    15.    :q=>"\000\260~\350\024\215\231t\206>\233\324\212_\206\322Q\0066(\225",
    16.    :y=>
    17.     "\016\371O\332\bw\276\300\367\373\350\3223XX\205\340W\267r\246\f\265\0349}1Q>\245r\021\262\244\004\3437\"\377\247\257\344\304\344EP\250\021k'\261$N\346\230\321\273hTq?O\274\335\260)\266[<L \231\b%\367\262\353\307\002\b\026\20148\004\352\036\a]\025\204\300\210W{\035YML>\311\274\024I\307N:\375\264\340\000\346\331\023\301N\002\327\263\026\217p\233\300\230@\351\333"},
    18.  :testic=>1,
    19.  :username=>"mosdef",
    20.  :keytype=>"ssh-dss",
    21.  :nextservice=>"ssh-connection",
    22.  :auth_method=>"publickey"}
    23.  * deciphered streams saved to "sshdecrypt.client.dat" & "sshdecrypt.server.dat"
    24.  


    On aurait obtenu les 2 conversations en clair si les 2 versions d'OpenSSL utilisées étaient vulnérables, mais dans notre cas seul la version du client est vulnérable, on retrouve donc le plaintext dans le fichier sshdecrypt.0.server.dat

    On retrouve la clé dans le fichier : key{you_broke_ssh_im_calling_teh_cops}

CTF Quals CSAW 2011 - Reversing Linux

Salut à tous !

Second writeup du CSAW CTF ! Le reverse Linux à 400 pt.
  1. What ?

    On nous fournit un binaire linux "a.out" que vous pouvez retrouver sur shell-storm ici On go IDA et son pote HexRay.
    On obtient ce code (aprés quelques nettoyages ... ou pas) :

    1. int __cdecl main(int argc, char **argv)
    2. {
    3.   unsigned int v2; // eax@7
    4.   int result; // eax@11
    5.   char v4; // [sp+23h] [bp-4Dh]@3
    6.   char v5; // [sp+24h] [bp-4Ch]@8
    7.   char v6; // [sp+25h] [bp-4Bh]@9
    8.   char v7; // [sp+26h] [bp-4Ah]@9
    9.   char v8; // [sp+27h] [bp-49h]@9
    10.   char v9; // [sp+28h] [bp-48h]@9
    11.   char v10; // [sp+29h] [bp-47h]@9
    12.   char v11; // [sp+2Ah] [bp-46h]@9
    13.   char v12; // [sp+2Bh] [bp-45h]@9
    14.   char v13; // [sp+2Ch] [bp-44h]@9
    15.   char v14; // [sp+2Dh] [bp-43h]@9
    16.   char v15; // [sp+2Eh] [bp-42h]@9
    17.   char v16; // [sp+2Fh] [bp-41h]@9
    18.   char v17; // [sp+30h] [bp-40h]@9
    19.   char v18; // [sp+31h] [bp-3Fh]@9
    20.   char v19; // [sp+32h] [bp-3Eh]@9
    21.   char v20; // [sp+33h] [bp-3Dh]@9
    22.   char v21; // [sp+34h] [bp-3Ch]@9
    23.   char v22; // [sp+35h] [bp-3Bh]@9
    24.   char v23; // [sp+36h] [bp-3Ah]@9
    25.   char v24; // [sp+37h] [bp-39h]@9
    26.   char v25; // [sp+38h] [bp-38h]@9
    27.   char v26; // [sp+39h] [bp-37h]@9
    28.   char v27; // [sp+3Ah] [bp-36h]@9
    29.   char v28; // [sp+3Bh] [bp-35h]@9
    30.   char v29; // [sp+3Ch] [bp-34h]@9
    31.   char v30; // [sp+3Dh] [bp-33h]@9
    32.   char v31; // [sp+3Eh] [bp-32h]@9
    33.   char buffer; // [sp+40h] [bp-30h]@2
    34.   int v33; // [sp+5Ch] [bp-14h]@1
    35.  
    36.   v33 = *MK_FP(__GS__, 20);
    37.   if ( argc <= 1 )
    38.   {
    39.     v4 = 0;
    40.     encode_key(&buffer, &v4);
    41.   }
    42.   else
    43.   {
    44.     encode_key(&buffer, argv[1]);
    45.   }
    46.   if ( argc == 3 )
    47.   {
    48.     strncpy(&buffer, argv[2], 0x1Bu);
    49.     decode_key(&buffer);
    50.   }
    51.   else
    52.   {
    53.     if ( strcmp(argv[3], "I want to speak to a customer service representative.") )
    54.     {
    55.       decode_key(&buffer);
    56.     }
    57.     else
    58.     {
    59.       v2 = 0;
    60.       do
    61.       {
    62.         *(_DWORD *)(&v5 + v2) = 0;
    63.         v2 += 4;
    64.       }
    65.       while ( v2 < 0x1C );
    66.       v5 = 55;
    67.       v6 = 49;
    68.       v7 = 69;
    69.       v8 = 71;
    70.       v9 = -17;
    71.       v10 = -17;
    72.       v11 = 67;
    73.       v12 = -2;
    74.       v13 = 55;
    75.       v14 = 55;
    76.       v15 = 42;
    77.       v16 = 63;
    78.       v17 = 51;
    79.       v18 = 44;
    80.       v19 = -4;
    81.       v20 = 42;
    82.       v21 = 66;
    83.       v22 = 44;
    84.       v23 = 62;
    85.       v24 = 42;
    86.       v25 = -2;
    87.       v26 = 44;
    88.       v27 = -17;
    89.       v28 = 68;
    90.       v29 = -18;
    91.       v30 = -18;
    92.       v31 = 72;
    93.       decode_key(&v5);
    94.     }
    95.   }
    96.   result = 0;
    97.   if ( *MK_FP(__GS__, 20) != v33 )
    98.     __stack_chk_fail();
    99.   return result;
    100. }
    101.  

    Les v4 à v31 sont enf ait les octets d'un buffer. On voit rien de spécial excepté dans le cas ou argc est différent de 3 et que le strcmp ne correspond pas.
    Peut importe comment on y arrive (si on peut y arriver), on voit qu'il set les octets du buffer puis le décode.
    Décodons ce petit buffer !
    On a juste a copier les octets, la fonction de décodage, puis de regarder le résultat :)
    On obtient ce code :

    1. #include <stdio.h>
    2.  
    3. char* data = "\x37\x31\x45\x47\xEF\xEF\x43\xFE\x37\x37\x2A\x3F\x33\x2C\xFC\x2A\x42\x2C\x3E\x2A\xFE\x2C\xEF\x44\xEE\xEE\x48";
    4.  
    5. int main(int argc, char **argv){
    6.     int v1, i;
    7.     for(i=0; i<=26; i++){
    8.         if (i > 6) v1 = -53;
    9.         else v1 = -52;
    10.         printf("%c", (char)(data[i]-v1));
    11.     }
    12.     printf("\n");
    13.     return 0;
    14. }

    On obtient ce résultat : key{##w3ll_tha1_was_3a$y##}