Prequals NDH 2k13 - Crackme Huge.js

Voici le write-up d'une d'une autre épreuve des prequals de la NDH 2k13.

Description

On nous donne un fichier .js mais assez "huge". Evidemment ca rame à mort si on l'ouvre avec notepad, etc ...

Analyse du script

Donc on l'ouvre avec notre éditeur héxa préféré ou même Chrome et là on découvre :

function d() {
  return (window.console &&
         (window.console.firebug || window.console.exception));
}

function x(c, k) {
  o = '';
  for (i = 0; i < c.length; i++) {
    o += String.fromCharCode(c.charCodeAt(i) ^ k.charCodeAt(i % k.length));
  }
}

On a donc une fonction d(debug) qui check si on debug le script et une fonction x(or) qui déchiffre une string xorée. Dans la suite du code, les strings sont évidemment xorées avec cette fonction. : 

window[x('\x44\x29\x42\x42','\x21\x5f\x23\x2e\x2b\x28\x3f\x2d')](x('\x42\x4b\x17\x0f\x5b\x01\x08\x02\x56\x48\x47\x51\x4d...));

Déchiffrement

Il suffit donc d'écrire un script qui va remplacer chaque appelle à la fonction "x" par son résultat. A la fin on aura notre fichier Javascript en clair et avec une taille correct !

def xor(c, k):
  return "".join([chr(ord(c[i])^ord(k[i%len(k)])) for i in range(len(c))])


def decode(f):
  data = open("huge.js", "r").read()
  pos = data.find("x('\\", 0)
  while pos != -1:
    sep = data.find(",", pos)
    end = data.find(")", pos)
    c = data[pos+3:sep-1].replace("\\x", "").decode("hex")
    k = data[sep+2:end-1].replace("\\x", "").decode("hex")
    data = data[:pos] + xor(c, k) + data[end+1:]
    pos = data.find("x('\\", 0)
  f = open("result.js", "w")
  f.write(data)
  f.close()

decode("huge.js")

Et oui, on parse à l'ancienne avec des "pos" et des "substrings" !

On obtient une fonction "xxx" qui est en fait un md5, "kkk" qui reverse une string et une fonction "unlock" pour tester le mot de passe :

function unlock(node){
  var code = node.value;
  if (code && (code.length == 5)){
    if ((xxx(code).substr(0,16)=='b3336efd42e29780') &&
        (xxx(kkk(code)).substr(16,16)=='261804c5f2f0a47e')){
      var flag = document.createElement('span');
      var t = document.createTextNode('YAY, you got the flag ! --> '+xxx(code));
      flag.appendChild(t);
      flag.style.font='Helvetica, 1.2em, bold';
      document.getElementById('panel').appendChild(flag);
      node.style.display = 'none';
      node.value = '';
    }
  }
}

Il suffit donc de trouver un pass de 5 caractères dont le début du md5 est "b3336efd42e29780". Bf :

import sys


charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789<>(){}-+"

h = "b3336efd42e29780".decode("hex")


def brute(n, s):
  if n>0:
    for c in charset:
      brute(n-1, s+c)
  else:
    if hashlib.md5(s).digest()[:8] == h:
      print s
      sys.exit(0)

brute(5, "")

Au bout de quelques temps on obtient : i<3Js

Et voilà :)

Prequals NDH 2k13 – Fappers Gonna Fap – Crypto 200 pts

Voici le write-up d'une des épreuves de crypto des prequals de la NDH 2k13. Au menu, du XOR, du format BMP et du Python ! 

Description

On nous fournit le fichier dafuq.bmp et un script python encrypt.py.

L'épreuve va consister à décoder l'image Bitmap qui a apparemment été chiffrée en utilisant le script python.

Analyse du script

On va regarder d'un peu plus près encrypt.py histoire de voir si on peut le reverse pour récupérer l'image d'origine.

Une classe BitmapFile est définie dans laquelle on trouve une fonction très intéressante :

On remarque que les données binaires de l'image sont xorées avec une clé de longueur 337 dont les valeurs des octets sont pris aléatoirement entre 0 et 255. L'algorithme n'est donc pas réversible mais il doit être possible de récupérer la clé en utilisant les caractéristiques du format BMP.

Récupération de la clé

La structure d'une image Bitmap est composée de plusieurs en-têtes et options en plus des données de l'image. On trouve notamment le Bitmap File Header et le DIB Header qui vont permettre de stocker des informations sur l'image.

On va alors pouvoir recomposer le File Header de l'image d'origine en utilisant notamment le fait que plusieurs champs sont communs à toutes les images BMP. Ensuite comme il s'agit d'un simple XOR il suffira de xorer les octets trouvés avec ceux de dafuq.bmp pour avoir le début de la clé (le File Header fait 14 octets).

Par exemple, on sait déjà que l'en-tête va commencer par les octets 42 4D qui sont en fait les caractères B et M. Le champ suivant qui occupe 4 octets contient la taille du fichier qui sera donc la même que dafuq.bmp c'est-à-dire 2993058 octets soit 2DABA2 en héxadécimal. Par ailleurs les données étant stockées en Little Endian on obtient A2AB2D00 pour ces 4 octets du File Header.

Les 4 octets suivants sont réservés et généralement à 0 et les 4 d'après représentent l'adresse de départ des données de l'image qui commencent habituellement après le File Header (14 octets) et le DIB Header (40 octets). On obtient donc la valeur 54 soit 36 en héxadécimal stockées sous la forme 36000000.

On arrive ensuite sur le premier champ du DIB Header qui est en fait invariable puisqu'il s'agit de la taille du Header soit 40 octets. On a donc la valeur héxadécimale 28 stockées sur 4 octets : 28000000.

Pour le moment, nous avons reconstruit les 18 premiers octets de l'image :

424DA2AB2D00000000003600000028000000

Nous pouvons donc d'ores et déjà les xorer avec les 18 premiers octets de l'image chiffrée pour obtenir le début de la clé.

Après avoir xoré tout ça, on obtient le début de clé suivant :

C31AD80D5C84E09149D9E19A79164A18338B

A ce stade, on sait que ça ne sert à rien de continuer à reconstruire les en-têtes car la clé est censé faire 337 octets ce qui est largement supérieur à la taille des en-têtes (54 octets).

Il va donc falloir utiliser le début de la clé pour en déduire le reste.

On peut légitimement supposer que les données de l'image d'origine contiennent par endroit des séquences de 0 qui une fois xorées avec la clé donneront des parties de la clé dans l'image chiffrée.

On va donc rechercher dans les données de l'image chiffrée toutes les occurrences de la séquence C31AD80D5C84E09149D9E19A79164A18338B.

On trouve de nombreuses occurrences de cette séquence dont 2 sont montrées au-dessus.

On constate qu'à chaque fois ces séquences sont séparées de 319 octets identiques ce qui nous donne des blocks de 337 octets soit la longueur de la clé utilisé lors du XOR.

On dirait bien qu'on vient juste de récupérer notre fameux « keystream ».

Décodage

On a tout ce qu'il faut pour décoder le fichier dafuq.bmp et obtenir l'image de départ.

On fait un petit script python qui va xorer les données binaires de dafuq.bmp avec la clé de 337 octets ci-dessous :

C31AD80D5C84E09149D9E19A79164A18338B1E78446DB8B8D25431071C320DE6231EBB0E882351217666AAB9209DD00AD142B10F45DE0AA522B3459A14523A5F01DC5ECC67F62584FB7064B7832AC9FC43CA8A299189F5818B8BE7970034600C3317A44883F7CB77060460FFE8048DF4CBF6AA60DCB73229BD0444504715614F43CE360B852B846D43B606B69F257672E02DAF7BC40554B5121A8A6D9AB933F28F8A9D95858CA7AFE947D63C979445B645DE920E9A7EE5F6F065AB7529E6DE1EDE9DFFA50F32632E4C9EE30E088238C106E385EA6C8B2296D7F485A171E7A8EE163B24E6BDCEF979490BF1839EA5773275D83D8583AFF2E6A5279A7DB36CBD1914B91389820E6576B84E832FFEC4184846E59980096FEBE28ED66FB08637D40530DCBE3AC481F38EEB04E00FB4F60F13B047343BC230F200C2419F4271E2584508BE3B56164F522060DA23D0DDCD97055C

On obtient alors l'image suivante :

On valide l'épreuve avec le flag : ecb_mode_is_weak_mofo

Liens

http://en.wikipedia.org/wiki/BMP_file_format

NDH 2k12 - Stay Alive - 500 pts

Dernier crackme de cette série de writeup de la NDH 2k12, une application windows phone !

1.       What

On a donc une application Windows phone dans son fichier « xap », en regardant de plus près on voit qu’il s’agit d’un fichier compressé (PK).

On decompresse puis on se retrouve avec les fichiers de l’application :

Si on passe les images, le xaml pour l’interface et le manifest, il reste la dll qui contient le code de l’application, probablement une appli qui demande un mot de passe …

On peut essayer d’ouvrir la dll avec IDA mais on voit rapidement qu’il s’agit de .Net. On switch donc dans notre décompileur de .Net préféré (pour moi Reflector).

private void ndhPasswordLogin_Click(object sender, RoutedEventArgs e)
{
    string password = this.ndhPassword.get_Password();
    if (password.Length > 0)
    {
        if (string.Equals(this.cryptPassword(password), this.trustedHash()))
        {
            base.get_NavigationService().Navigate(new Uri("/LoginError.xaml", UriKind.Relative));
        }
        else
        {
            MessageBox.Show("Login failed, try again.", "Error", 0);
        }
    }
}

On a une fonction qui sera appelé pour vérifier un password. On test si le mot de passe chiffré avec « cryptPassword » correspond au « trustedHash() ». Rien de spécial, continuons …

2.       TrustedHash

Un simple writeLn ou copier/coller et on obtient :

+R2kbpJn0tqCMmUNZzFwQFMU+EW0/Nkoup5Zl4hxoPFRfmk1fhKJhfBkdhNYiDqt23jbRoxDbO3
QHpy6M2kY/8hd3Z1ds8a1StSQkXxNyjZd2mTQPpTR4zmyf9FzK4Y4XUfzw1hUP3qj+dGyKgNjQm
XdtPTOqRVh2T41NSvmK/YV6XzIk6SFdhF9XyXUJOlcII5mXQ/SuHiHmkEoTJiUF3XGN/LkjnNy6pRzZH6s2YC27g7sqqFj71xPY+S3KHLy1y/PwJtz1E7EBzqaXxTxDOE9wiPArIoY9Rl//8RalprwBKeEzZajgbqFz5sEkV6hplGCkiua1FfPXht9Ef8br

3.       CryptPassword

private string cryptPassword(string password)
{
    string key = "AYOOYOYOAYOOYOYO";
    string salt = "WOLOLOWOLOLOOOO";
    string str3 = "ndh2k12!";
    string str4 = null;
    string data = null;
    for (int i = 0; i < password.Length; i++)
    {
        string str6 = password[i].ToString();
        string str7 = null;
        if ((i % 2) == 0)
        {
            str7 = this.base64Encode(str3 + str6);
        }
        else
        {
            str7 = this.aesEncode(str6, str4, str3);
        }
        data = data + str7;
        str4 = str7;
    }
    return this.aesEncode(data, key, salt);
}

On parcours donc notre password, si on est sur un caractère pair on ajoute à « data » base64(ndh2k12 ! + char) sinon on ajoute à « data » le caractère chiffré avec la clé « key »  et le salt « salt ».

A la fin, “data” subit une dernière transformation, aesEncode, toujours avec la même key et salt.

Pourquoi ne pas faire l’inverse !

On part du « trustedHash », on sait qu’en dernier il a été chiffré alors on le déchiffre. On obtient ensuite un certain nombre de blocs suivant la taille du mot de passe hashé.

Pour les blocs pairs, il suffit de le décodé en base64 puis de garder le dernier caractère.

Pour les blocs impairs, il faut le déchiffrer avec le bloc précédent comme clé et toujours le même salt.

Ainsi de suite pour chaque bloc pair et impair …

4.       Résultat

Pour déchiffrer, la fonction s’écrit plus ou moins en copiant la fonction de chiffrement :

private string aesDecode(string data, string key, string salt)
{
    byte[] bytes = new byte[salt.Length];
    bytes = Encoding.UTF8.GetBytes(salt);
    Aes aes = (Aes) new AesManaged();
    aes.Key = new Rfc2898DeriveBytes(key, bytes).GetBytes(0x10);
    aes.IV = aes.Key;
    MemoryStream stream = new MemoryStream();
    CryptoStream stream2 = new CryptoStream(stream, aes.CreateDecryptor(), CryptoStreamMode.Write);
    byte[] buffer = Convert.FromBase64String(data);
    stream2.Write(buffer, 0, buffer.Length);
    stream2.FlushFinalBlock();
    return Encoding.UTF8.GetString(stream.ToArray());
}

Notre “trustedHash” déchiffré donne :

bmRoMmsxMiFomEpoK3JjVufPG4PHIZOr8A==bmRoMmsxMiF2yXWqntvVZX50EN1IlnTo3w==bmRoMmsxMiF3bZY/Kf1nEbIZJkxufD/aAQ==bmRoMmsxMiFs28dlLHl69r6pmBbjIPgYBw==bmRoMmsxMiEtpGqGLudtlrHht7kVeEfMLA==bmRoMmsxMiFlCW4AQUIJeTVAbcdBXbRDQg==bmRoMmsxMiFlMZm7jEzQutN6OwSAVddgAw==bmRoMmsxMiEtVbvy0FmdISllXQlSmMRR0w==bmRoMmsxMiFpWGsPB3wrW20H79tUp8T47w==

On peut ensuite découper ça en bloc :

bmRoMmsxMiFo

mEpoK3JjVufPG4PHIZOr8A==

bmRoMmsxMiF2

yXWqntvVZX50EN1IlnTo3w==

bmRoMmsxMiF3

bZY/Kf1nEbIZJkxufD/aAQ==

bmRoMmsxMiFs

28dlLHl69r6pmBbjIPgYBw==

bmRoMmsxMiEt

pGqGLudtlrHht7kVeEfMLA==

bmRoMmsxMiFl

CW4AQUIJeTVAbcdBXbRDQg==

bmRoMmsxMiFl

MZm7jEzQutN6OwSAVddgAw==

bmRoMmsxMiEt

Vbvy0FmdISllXQlSmMRR0w==

bmRoMmsxMiFp

WGsPB3wrW20H79tUp8T47w==

Le premier bloc décodé donne : ndh2k12!h donc le caractère du passe est : h

Le deuxième bloc déchiffré donne : z

On continue comme ça jusqu’au dernier bloc pour obtenir : hzv-will-never-die