Old proprietary encryption

Flag: ECW{plcFLM12}

Challenge

18KB

dga_encrypted_pass.zip

archive

Ouvrir

Description

---

Your workshop colleague challenges you to bypass his password protection. Unfortunately for him, some proprietary encryption methods aren’t very effective. To help you, you've conducted a few tests using a platform ('TestPasswordHash.txt'). The flag is in the format ECW{theDecryptedPassword}.

Challenge made by:

Solution

Il faut regarder les variations pour chaque lettre. On commence par mettre en forme les données qu'on a

banane         37 34 0c 00 37 30 42 45
banane1        37 34 0c 00 37 30 53 45
banane12       37 34 0c 00 37 30 53 57
b              37 75 42 00 37 75 42 00
ba             37 34 42 41 37 34 42 41
ban            37 34 0c 41 79 34 0c 41
bana           37 34 0c 00 79 75 0c 00
banan          37 34 0c 00 37 75 42 00
nonban         3b 3a 00 0d 34 36 41 43
siemens1       26 3c 16 04 26 3f 00 5b
siemens2       26 3c 16 04 26 3f 00 58
SIEMENS        06 1c 16 04 06 1f 00 6a
SIEMENS1       06 1c 16 04 06 1f 00 7b
p@ssw%rd       25 15 03 33 21 43 06 72
p@ssw%rh       25 15 03 33 21 43 06 7e
pass           25 34 03 12 76 67 03 12
pass           25 34 03 12 76 67 03 12
pass           25 34 03 12 76 67 03 12

---

Première observation : comparer les débuts

On voit immédiatement que le premier octet est toujours le même si la première lettre est la même. Exemples :

• Toutes les chaînes qui commencent par 'b' ont un hash qui commence par 0x37.

• Celles qui commencent par 's' commencent toujours par 0x26.

• Celles qui commencent par 'S' (majuscule) commencent par 0x06.

Conclusion : le premier octet du hash dépend uniquement du premier caractère du mot.

On fait la même chose avec le deuxième octet : il ne dépend que du deuxième caractère. Donc on devine que chaque caractère du mot influence plusieurs positions dans le hash, mais les deux premiers semblent juste transformés individuellement.

On teste avec un XOR simple (classique en CTF) :

(b = 0x62)  0x62 XOR 0x37 = 0x55. Ça marche.
(a = 0x61)  0x61 XOR 0x34 = 0x55. Ça marche aussi.

➡️ On note : c0 = p0 ^ 0x55 c1 = p1 ^ 0x55

---

On examine la fin : les tests avec "siemens"

Maintenant on veut comprendre comment la suite est construite. Bonne idée : comparer deux mots presque identiques :

siemens1 : 263c1604263f005B
siemens2 : 263c1604263f0058

Ils ne diffèrent que sur le dernier caractère (1 → 2), et on voit que seul le dernier octet change (0x5b et 0x58). Il y a donc une relation directe entre le dernier caractère et le dernier octet du hash. On le confirme avec le XOR :

(1 = 0x31)  0x31 XOR 0x5b = 0x6a
(2 = 0x32)  0x32 XOR 0x58 = 0x6a

Puis on regarde :

SIEMENS  : 061c1604061f006a
SIEMENS1 : 061c1604061f007b

(1 = 0x31)  0x31 XOR 0x7b = 0x4a

# On va faire la relation inverse pour trouver la valeur de base
(? = 0x??)  0x4a XOR 0x6a = 0x20

En comparant ces deux-là, on remarque que la transformation est exactement la même que dans siemens1 / siemens2. Donc SIEMENS est en réalité padé avec un espace à la fin.

➡️ On en déduit : toutes les chaînes sont padées à droite avec des espaces (0x20) jusqu’à 8 caractères.

---

Comprendre les octets 3 et 4 : on joue avec "ban"

Maintenant qu’on sait pour le padding, on peut revenir aux exemples simples pour trouver le reste. On compare par exemple :

ban  : 37340c4179340c41
ba␠  : 3734424137344241   (␠ = espace)

Ici, seul le 3ᵉ caractère change ('n' devient ' '), donc toute différence dans le hash vient de ce caractère.

On regarde le 3ᵉ octet du hash (0x0c ↔ 0x42). On cherche une opération simple entre p0 et p2. On teste :

0x62 ^ 0x6E = 0x0C (ça marche) 0x62 ^ 0x20 = 0x42 (ça marche aussi)

➡️ On en déduit : c2 = p0 ^ p2 Et en faisant le même test sur la colonne d’après, on obtient c3 = p1 ^ p3.

---

On continue sur le reste

On applique la même méthode avec bana, banan, banane, et on voit des schémas :

• c4 dépend de p0, p2, p4 et contient aussi le fameux 0x55

• c5 dépend de p1, p3, p5 et aussi 0x55

• c6 dépend de p0 ^ p2 ^ p4 ^ p6

• c7 dépend de p1 ^ p3 ^ p5 ^ p7

---

Formule finale trouvée

On a :

c0 = 0x55 ^ p0
c1 = 0x55 ^ p1
c2 = p0 ^ p2
c3 = p1 ^ p3
c4 = 0x55 ^ p0 ^ p2 ^ p4
c5 = 0x55 ^ p1 ^ p3 ^ p5
c6 = p0 ^ p2 ^ p4 ^ p6
c7 = p1 ^ p3 ^ p5 ^ p7

Avec padding espace (0x20) jusqu'à 8 caractères.

---

Script de résolution

Voici l'algorithme de chiffrement qu'on vient de trouver, c'est assez simple :

def encrypt(data: bytes):
  padded = data.ljust(8, b' ')
  return bytes([
    0x55 ^ padded[0],
    0x55 ^ padded[1],
    padded[0] ^ padded[2],
    padded[1] ^ padded[3],
    0x55 ^ padded[0] ^ padded[2] ^ padded[4],
    0x55 ^ padded[1] ^ padded[3] ^ padded[5],
    padded[0] ^ padded[2] ^ padded[4] ^ padded[6],
    padded[1] ^ padded[3] ^ padded[5] ^ padded[7]
  ]

Et pour déchiffrer, ça l'est tout autant, il suffit d'inverser les opérations :

def decrypt(ciphertext: bytes) -> bytes:
  out = bytearray([0x20] * 8)
  out[0] = 0x55 ^ ciphertext[0]
  out[1] = 0x55 ^ ciphertext[1]
  out[2] = out[0] ^ ciphertext[2]
  out[3] = out[1] ^ ciphertext[3]
  out[4] = 0x55 ^ out[0] ^ out[2] ^ ciphertext[4]
  out[5] = 0x55 ^ out[1] ^ out[3] ^ ciphertext[5]
  out[6] = out[0] ^ out[2] ^ out[4] ^ ciphertext[6]
  out[7] = out[1] ^ out[3] ^ out[5] ^ ciphertext[7]
  return out

Dans le PCAP, on trouve des requêts de mot de passe :

Le mot de passe qui ne génère pas d'erreur est : 2539132a0a326e55. On va donc le déchiffrer :

print(decrypt(bytes.fromhex('2539132a0a326e55')))

# plcFLM12