dgse - richelieu
07/07/2019Arrivé sur la page d’accueil
On arrive sur une page avec un compteur indiquant le nombre de jours restants avant la fin du challenge. Cependant, aucune information explicite sur le challenge à résoudre.
<!doctype html>
<html lang="fr">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1,shrink-to-fit=no">
<meta name="theme-color" content="#000000">
<link rel="manifest" href="manifest.json">
<title>Challenge Richelieu</title>
<link href="static/css/main.ba9d9d7d.chunk.css" rel="stylesheet">
</head>
<body>
<noscript>Vous devez activer JavaScript pour utiliser l'application.</noscript> <script>let login = "rien";
let password = "nothing";
if (login === password) {
document.location="./Richelieu.pdf";
}
</script>
</body>
</html>
Après un petit tour par le code source du site, on peut vois l’existence d’un ./Richelieu.pdf dans l’arborescence du site.
$ wget https://www.challengecybersec.fr/Richelieu.pdf
Ce fichier est un PDF assez volumineux avec plus de 9 Mo.
Composé d’un grand nombre de page (364). Cependant, il n’y a du texte (visible) que sur la première page. On se demande alors quelle est l’utilité de toutes les autres pages. On remarque avec notre souris que du texte écrit en très petite police occupe toutes les pages blanches. Il faudrait donc extraire tout le texte de ce PDF.
$ pdftotext Richelieu.pdf text_extracted.txt
Nous allons donc extraire tout le texte du fichier Richelieu.pdf vers text_extracted.txt en utilisant pdftotext.
$ cat text_extracted.txt
Richelieu
L’histoire de la cryptologie serait incomplète sans citer Richelieu qui, dès
1624, sut recruter les meilleurs spécialistes en mathématiques. Il a ainsi pu
fonder, par la suite, ce qui est considéré aujourd’hui comme l'un des tout
premiers bureaux du chiffre en Europe.
Lors du siège de La Rochelle (1627-1628), la cryptanalyse des messages des
Huguenots lui permit d’anticiper l’arrivée des Anglais venus aider ces derniers
par la mer. En octobre 1628, la ville finira par capituler sans condition.
/9j/2wBDADIiJSwlHzIsKSw4NTI7S31RS0VFS5ltc1p9tZ++u7Kfr6zI4f/zyNT/16yv+v/9////
////wfD/////////////wgALCA20CD4BAREA/8QAGQABAQEBAQEAAAAAAAAAAAAAAAECAwQF/9oA
CAEBAAAAAeFzUWUsiyzUFlgFgChLKud5lms2KluaLBNZs1neNSaRclSxqWLJ0xYVNQFyusxQlA1M
#...
x1x1eAsAAQToAwAABOgDAABQSwECHgMUAAkACACrg51OHIIIsGZHXwCfQ18ADwAYAAAAAAAAAAAA
pIFlCgAAbHNiX1JHQi5wbmcuZW5jVVQFAANCCsdcdXgLAAEE6AMAAAToAwAAUEsFBgAAAAAGAAYA
RAIAACRSXwAAAA==
On peut retrouver le texte déjà visible sur le PDF, accompagné de tout le texte cachait, qui été en blanc sur le PDF. On a sûrement à faire à de la base64.
$ cat text_extracted.txt | wc -l
117798
$ cat text_extracted.txt | sed -n 9,117797p > file.b64
$ cat file.b64 | base64 -di > file.bin
# -i, --ignore-garbage: when decoding, ignore non-alphabet characters
$ file file.bin
file.bin: JPEG image data, progressive, precision 8, 2110x3508, frames 1
$ cp file.bin file.jpg
On retire les 9 premières lignes et on crée le fichier file.b64. On le décode avec base64 -id. On remarque que l’on a à faire à un JPG, on le renomme alors. On voit alors une image de Richelieu. Il y a sûrement d’autres choses dans un fichier si grand.
ZIP
$ binwalk file.jpg
DECIMAL HEXADECIMAL DESCRIPTION
--------------------------------------------------------------------------------
445628 0x6CCBC Zip archive data, encrypted, name: .bash_history
445979 0x6CE1B Zip archive data, encrypted, name: suite.zip
446405 0x6CFC5 Zip archive data, encrypted, name: prime.txt
446943 0x6D1DF Zip archive data, encrypted, name: public.key
447670 0x6D4B6 Zip archive data, encrypted, name: motDePasseGPG.txt.enc
448289 0x6D721 Zip archive data, encrypted, name: lsb_RGB.png.enc
6693156 0x662124 End of Zip archive, footer length: 22
Avec binwalk on peut voir la présence d’une archive qui est composée de plusieurs fichiers intéressants.
$ binwalk --dd=".*" file.jpg
$ cd _file.jpg.extracted/
$ ll
-rw-r--r-- 1 adel adel 22 mai 24 19:58 662124
-rw-r--r-- 1 adel adel 6247550 mai 24 19:58 6CCBC
$ file 662124
662124: Zip archive data (empty)
$ file 6CCBC
6CCBC: Zip archive data, at least v2.0 to extract
$ cp 6CCBC file.zip
$ unzip file.zip
Archive: file.zip
[file.zip] .bash_history password:
Après extraction, on se retrouve avec 2 fichiers, un qui ne sert sûrement à rien (662124) et un qui parait être utile: 6CCBC. C’est une archive chiffrée bien sûr. Il faut trouver un mot de passe. Après quelques recherches sans succès, revenons aux basiques.
$ strings file.zip
# ...
a#W|+
~8!6
.bash_historyUT
Le mot de passePK
suite.zipUT
de cette archivePK
prime.txtUT
est : DGSE{t.D=@Bx^A%n9FQB~_VL7Zn8z=:K^4ikE=j0EGHqI}PK
public.keyUT
motDePasseGPG.txt.encUT
lsb_RGB.png.encUT
Le mot de passe est sûrement sous nos yeux…
$ mkdir zip_files
$ unzip -P "DGSE{t.D=@Bx^A%n9FQB~_VL7Zn8z=:K^4ikE=j0EGHqI}" file.zip -d zip_files
Archive: file.zip
inflating: zip_files/.bash_history
extracting: zip_files/suite.zip
inflating: zip_files/prime.txt
inflating: zip_files/public.key
extracting: zip_files/motDePasseGPG.txt.enc
inflating: zip_files/lsb_RGB.png.enc
Nous avons accès à tous les fichiers du zip.
$ cd zip_files/
$ ll
-rw-r--r-- 1 adel adel 578 avril 26 17:20 .bash_history
-rw-r--r-- 1 adel adel 6243231 avril 29 16:29 lsb_RGB.png.enc
-rw-r--r-- 1 adel adel 512 avril 29 16:29 motDePasseGPG.txt.enc
-rw-r--r-- 1 adel adel 868 avril 29 16:29 prime.txt
-rw-r--r-- 1 adel adel 800 avril 29 16:29 public.key
-rw-r--r-- 1 adel adel 331 avril 29 16:28 suite.zip
Essayons donc de les parcourir et de faire une analyse rapide.
.bash_history
$ file .bash_history
.bash_history: ASCII text
$ cat .bash_history
# gpg encryption
1337 gpg -o lsb_RGB.png.enc --symmetric lsb_RGB.png
# create file with futur GPG password ?
1338 vim motDePasseGPG.txt
# gen 4096 bits rsa private key
1339 openssl genrsa -out priv.key 4096
# gen public key
1340 openssl rsa -pubout -out public.key -in priv.key
# extract prime 1 from priv key ?
1341 openssl rsa -noout -text -in priv.key | grep prime1 -A 18 > prime.txt
# -A NUM, --after-context=NUM: Print NUM lines of trailing context after matching lines.
# change file content with sed !!
1342 sed -i 's/7f/fb/g' prime.txt
1343 sed -i 's/e1/66/g' prime.txt
1344 sed -i 's/f4/12/g' prime.txt
1345 sed -i 's/16/54/g' prime.txt
1346 sed -i 's/a4/57/g' prime.txt
1347 sed -i 's/b5/cd/g' prime.txt
# encryption of motDePasseGPG.txt with public.key
1348 openssl rsautl -encrypt -pubin -inkey public.key -in motDePasseGPG.txt -out motDePasseGPG.txt.enc
Le fichier .bash_history sous Linux contient tout l’historique des commandes qui ont étaient exécutaient sur le terminal.
motDePasseGPG.txt.enc
$ file motDePasseGPG.txt.enc
motDePasseGPG.txt.enc: data
$ cat motDePasseGPG.txt.enc
# ciphered data
On comprend rapidement que notre but sera de retrouver la clé privée utilisée pour réaliser le déchiffrement du fichier motDePasseGPG.txt.enc.
prime.txt
$ file prime.txt
prime.txt: ASCII text
$ cat prime.txt
prim66:
00:fb:40:dc:44:ba:03:d1:53:42:f7:59:08:e0:f9:
30:05:96:64:4a:de:94:68:5e:08:e2:8c:9a:b1:64:
0c:2f:62:c2:9a:b9:a2:39:82:4b:9e:be:eb:76:ae:
6d:87:21:a3:5e:9e:d9:8d:7e:57:38:3e:59:09:34:
a5:78:cd:f7:2e:89:5d:5c:37:52:ea:fd:f6:31:cc:
ba:d2:d9:60:e4:45:1d:67:76:d2:1f:12:9c:9d:c9:
b1:90:45:51:ed:d2:fb:dd:b6:74:b4:99:fb:b1:0a:
d9:b7:c2:be:8b:57:07:22:0a:8e:3a:36:ff:6d:c1:
1d:63:93:af:cb:4e:c0:47:9f:65:bf:df:e3:f0:5f:
1e:98:61:45:74:ec:36:a7:a5:b1:f1:8d:3d:97:6b:
5a:82:49:09:00:08:0d:9d:c2:74:57:4e:30:a1:39:
68:2f:22:34:71:13:aa:3b:f2:20:4f:8e:10:eb:d4:
d0:9b:cd:8c:c2:53:5f:9d:71:13:0c:0f:21:b6:6e:
13:39:40:d3:a6:b1:eb:74:ad:dd:0a:29:14:81:b1:
90:ad:e0:53:f0:89:c8:00:fe:dc:ad:56:59:fc:28:
1d:c0:cf:5e:08:c0:54:33:24:a3:52:bb:f3:25:10:
43:c3:73:b8:40:4f:fc:6b:6b:77:bd:5f:22:24:eb:
fb:15
Voici donc le fichier manipulé dans le .bash_history, il ne faut pas oublier que ce dernier à été modifié après avoir été créé. Il faut donc penser à le modifier pour retrouver ses valeurs d’origines.
public.key
$ file public.key
public.key: ASCII text
$ cat public.key
-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAzV+KJMdgUAiJejySLA6B
Lnad4KRkQsNQy3jHhoU589OKrICz5qUGYFkQ6FmYBrTR0Ujy9rgdoEeWqKWu4Y8p
6D4Wd1oqCgCHBUH2V07RQ4Y2rgoMEW4HEE9I9yCUhjo4aeHI/CIGJyeJYvsihz4x
VvGOVd7JTpcAZOx/Tg6IRUAS4v1d/l+NGb8XD5zLP0bg/RAZvLAtkIOgcDxhf5lj
eeZHg1SnOubmrLzh9DM+z68kNmo+l30808v+jYo4e9h2v9q4SI9vR78fvjMBD9LX
4itNsuVneDzgtgbbhrk3WXFMT2OWp/ufdMQCEEOw89RtJjPr1DqHeGPffWgPUGWH
wRndZBAMqDHOKvM9lRtSTF8GtJ9b8ss4HnQYGTDQaoBQXAar1b9IcPDJ+1gb2A26
iJZgY5+Tbt6o/l0Mnq5YBi7WkyUlg8ccx4K6YT4BQ45ptD+eZOyoT56gToEa17Oe
/Xh20ba1AcT0iszm8kI59sBAKHiBNc2Iw9Fb4PLrt96enBmnqTA3AF7gqaZAutoz
LsDQXunwioMjVKBIepJ9XogGbiVp5sXUaI5CK/oLJ8YXHG178Cm/2RZXUq8ZqnGz
Oh6nC2w3H7IeR/Un2At9BPWCrZ+ZNa9yNoLcAcqYgGIYcN7LetFWSM307xUwFvPm
2HkzuOxUz6H9+HxGcCCj51MCAwEAAQ==
-----END PUBLIC KEY-----
Nous possédons également, la clé publique utilisée pour le chiffrement.
lsb_RGB.png.enc
$ file lsb_RGB.png.enc
lsb_RGB.png.enc: GPG symmetrically encrypted data (AES256 cipher)
D’après le .bash_history, ce fichier a été chiffré, avec GPG.
suite.zip
$ file suite.zip
suite.zip: Zip archive data, at least v2.0 to extract
$ unzip suite.zip
Archive: suite.zip
[suite.zip] suite.txt password:
Prochaine étape du challenge.
Attaque sur RSA
Commençons par essayer d’attaquer la clé publique, même si je pense qu’il y a peu de chances d’y arriver.
$ rsactftool.py --publickey ./public.key --private
Killed
$ rsactftool.py --publickey ./public.key --uncipherfile ./motDePasseGPG.txt.enc
Killed
Pas possible d’attaquer la clé publique (module bien trop grand).
$ cat prime.txt
prim66:
00:fb:40:dc:44:ba:03:d1:53:42:f7:59:08:e0:f9:
30:05:96:64:4a:de:94:68:5e:08:e2:8c:9a:b1:64:
0c:2f:62:c2:9a:b9:a2:39:82:4b:9e:be:eb:76:ae:
6d:87:21:a3:5e:9e:d9:8d:7e:57:38:3e:59:09:34:
a5:78:cd:f7:2e:89:5d:5c:37:52:ea:fd:f6:31:cc:
ba:d2:d9:60:e4:45:1d:67:76:d2:1f:12:9c:9d:c9:
b1:90:45:51:ed:d2:fb:dd:b6:74:b4:99:fb:b1:0a:
d9:b7:c2:be:8b:57:07:22:0a:8e:3a:36:ff:6d:c1:
1d:63:93:af:cb:4e:c0:47:9f:65:bf:df:e3:f0:5f:
1e:98:61:45:74:ec:36:a7:a5:b1:f1:8d:3d:97:6b:
5a:82:49:09:00:08:0d:9d:c2:74:57:4e:30:a1:39:
68:2f:22:34:71:13:aa:3b:f2:20:4f:8e:10:eb:d4:
d0:9b:cd:8c:c2:53:5f:9d:71:13:0c:0f:21:b6:6e:
13:39:40:d3:a6:b1:eb:74:ad:dd:0a:29:14:81:b1:
90:ad:e0:53:f0:89:c8:00:fe:dc:ad:56:59:fc:28:
1d:c0:cf:5e:08:c0:54:33:24:a3:52:bb:f3:25:10:
43:c3:73:b8:40:4f:fc:6b:6b:77:bd:5f:22:24:eb:
fb:15
Nous devons donc travailler sur ce fichier.
Rappels sur RSA:
Tout d’abord, nous devons nettoyer prime.txt afin de retrouver la valeur de $p$.
1341 openssl rsa -noout -text -in priv.key | grep prime1 -A 18 > prime.txt
1342 sed -i 's/7f/fb/g' prime.txt
1343 sed -i 's/e1/66/g' prime.txt
1344 sed -i 's/f4/12/g' prime.txt
1345 sed -i 's/16/54/g' prime.txt
1346 sed -i 's/a4/57/g' prime.txt
1347 sed -i 's/b5/cd/g' prime.txt
La première commande permet de récupérer les 18 lignes se trouvant après la chaîne prime1, ce qui correspond donc à notre $p$.
$ cp prime.txt prime_good.txt
$ sed -i 's/cd/b5/g' prime_good.txt
$ sed -i 's/57/a4/g' prime_good.txt
$ sed -i 's/54/16/g' prime_good.txt
$ sed -i 's/12/f4/g' prime_good.txt
$ sed -i 's/66/e1/g' prime_good.txt
$ sed -i 's/fb/7f/g' prime_good.txt
Les lignes suivantes, réalisent des substitutions sur le fichier à l’aide de la commande sed, il faut donc les inverser pour connaître le contenu originel de prime.txt.
$ cat prime_good.txt
prime1:
00:7f:40:dc:44:ba:03:d1:53:42:f7:59:08:e0:f9:
30:05:96:64:4a:de:94:68:5e:08:e2:8c:9a:b1:64:
0c:2f:62:c2:9a:b9:a2:39:82:4b:9e:be:eb:76:ae:
6d:87:21:a3:5e:9e:d9:8d:7e:a4:38:3e:59:09:34:
a5:78:b5:f7:2e:89:5d:5c:37:52:ea:fd:f6:31:cc:
ba:d2:d9:60:e4:45:1d:67:76:d2:1f:f4:9c:9d:c9:
b1:90:45:51:ed:d2:7f:dd:b6:74:b4:99:7f:b1:0a:
d9:b7:c2:be:8b:a4:07:22:0a:8e:3a:36:ff:6d:c1:
1d:63:93:af:cb:4e:c0:47:9f:65:bf:df:e3:f0:5f:
1e:98:61:45:74:ec:36:a7:a5:b1:f1:8d:3d:97:6b:
5a:82:49:09:00:08:0d:9d:c2:74:a4:4e:30:a1:39:
68:2f:22:34:71:13:aa:3b:f2:20:4f:8e:10:eb:d4:
d0:9b:b5:8c:c2:53:5f:9d:71:13:0c:0f:21:b6:6e:
13:39:40:d3:a6:b1:eb:74:ad:dd:0a:29:14:81:b1:
90:ad:e0:53:f0:89:c8:00:fe:dc:ad:56:59:fc:28:
1d:c0:cf:5e:08:c0:16:33:24:a3:52:bb:f3:25:10:
43:c3:73:b8:40:4f:fc:6b:6b:77:bd:5f:22:24:eb:
7f:15
Voici donc la vrai valeur de notre nombre $prime1$ ou $p$. Nous devons maintenant trouver $q$, qui vaut:
Nous avons le clé publique public.key, nous pouvons donc facilement extraire $n$.
$ openssl rsa -pubin -inform PEM -text -noout -in public.key > modulus.txt
RSA Public-Key: (4096 bit)
Modulus:
00:cd:5f:8a:24:c7:60:50:08:89:7a:3c:92:2c:0e:
81:2e:76:9d:e0:a4:64:42:c3:50:cb:78:c7:86:85:
39:f3:d3:8a:ac:80:b3:e6:a5:06:60:59:10:e8:59:
98:06:b4:d1:d1:48:f2:f6:b8:1d:a0:47:96:a8:a5:
ae:e1:8f:29:e8:3e:16:77:5a:2a:0a:00:87:05:41:
f6:57:4e:d1:43:86:36:ae:0a:0c:11:6e:07:10:4f:
48:f7:20:94:86:3a:38:69:e1:c8:fc:22:06:27:27:
89:62:fb:22:87:3e:31:56:f1:8e:55:de:c9:4e:97:
00:64:ec:7f:4e:0e:88:45:40:12:e2:fd:5d:fe:5f:
8d:19:bf:17:0f:9c:cb:3f:46:e0:fd:10:19:bc:b0:
2d:90:83:a0:70:3c:61:7f:99:63:79:e6:47:83:54:
a7:3a:e6:e6:ac:bc:e1:f4:33:3e:cf:af:24:36:6a:
3e:97:7d:3c:d3:cb:fe:8d:8a:38:7b:d8:76:bf:da:
b8:48:8f:6f:47:bf:1f:be:33:01:0f:d2:d7:e2:2b:
4d:b2:e5:67:78:3c:e0:b6:06:db:86:b9:37:59:71:
4c:4f:63:96:a7:fb:9f:74:c4:02:10:43:b0:f3:d4:
6d:26:33:eb:d4:3a:87:78:63:df:7d:68:0f:50:65:
87:c1:19:dd:64:10:0c:a8:31:ce:2a:f3:3d:95:1b:
52:4c:5f:06:b4:9f:5b:f2:cb:38:1e:74:18:19:30:
d0:6a:80:50:5c:06:ab:d5:bf:48:70:f0:c9:fb:58:
1b:d8:0d:ba:88:96:60:63:9f:93:6e:de:a8:fe:5d:
0c:9e:ae:58:06:2e:d6:93:25:25:83:c7:1c:c7:82:
ba:61:3e:01:43:8e:69:b4:3f:9e:64:ec:a8:4f:9e:
a0:4e:81:1a:d7:b3:9e:fd:78:76:d1:b6:b5:01:c4:
f4:8a:cc:e6:f2:42:39:f6:c0:40:28:78:81:35:cd:
88:c3:d1:5b:e0:f2:eb:b7:de:9e:9c:19:a7:a9:30:
37:00:5e:e0:a9:a6:40:ba:da:33:2e:c0:d0:5e:e9:
f0:8a:83:23:54:a0:48:7a:92:7d:5e:88:06:6e:25:
69:e6:c5:d4:68:8e:42:2b:fa:0b:27:c6:17:1c:6d:
7b:f0:29:bf:d9:16:57:52:af:19:aa:71:b3:3a:1e:
a7:0b:6c:37:1f:b2:1e:47:f5:27:d8:0b:7d:04:f5:
82:ad:9f:99:35:af:72:36:82:dc:01:ca:98:80:62:
18:70:de:cb:7a:d1:56:48:cd:f4:ef:15:30:16:f3:
e6:d8:79:33:b8:ec:54:cf:a1:fd:f8:7c:46:70:20:
a3:e7:53
Exponent: 65537 (0x10001)
# autre façon
$ rsactftool.py --dumpkey --key ./public.key
[*] n: 837849563862443268467145186974119695264713699736869090645354954749227901572347301978135797019317859500555501198030540582269024532041297110543579716921121054608494680063992435808708593796476251796064060074170458193997424535149535571009862661106986816844991748325991752241516736019840401840150280563780565210071876568736454876944081872530701199426927496904961840225828224638335830986649773182889291953429581550269688392460126500500241969200245489815778699333733762961281550873031692933566002822719129034336264975002130651771127313980758562909726233111335221426610990708111420561543408517386750898610535272480495075060087676747037430993946235792405851007090987857400336566798760095401096997696558611588264303087788673650321049503980655866936279251406742641888332665054505305697841899685165810087938256696223326430000379461379116517951965921710056451210314300437093481577578273495492184643002539393573651797054497188546381723478952017972346925020598375000908655964982541016719356586602781209943943317644547996232516630476025321795055805235006790200867328602560320883328523659710885314500874028671969578391146701739515500370268679301080577468316159102141953941314919039404470348112690214065442074200255579004452618002777227561755664967507
[*] e: 65537
Nous connaissons maintenant la valeur de $n$, not:re $modulus$. C’est la forme en base 10 qui va nous intéresser.
$ python3
>>> p = ''.join(open('prime_good.txt').readlines())
>>> import re
>>> p = int(re.sub('[^0-9a-f]','',p[6:]), 16)
>>> import gmpy
>>> gmpy.is_prime(p)
0
Sauf que, problème, on se rend compte qu’après avoir passé notre prime_good.txt en base 10, celui-ci n’est pas premier… :(
Après réflexions, l’inversion des sed que l’on a fait plus haut n’est peut-être pas suffisante. Par exemple, si nous avons la chaîne ; xxxxbbxx et que l’on applique sed -i s/bb/xx/g, ce qui nous donne xxxxxxxx. On pense alors qu’il suffit d’inverser le sed en sed -i s/xx/bb/g pour retrouver le message originel. Sauf que non, on se retrouve avec bbbbbbbb. C’est sûrement le même problème avec notre prime_good.txt, l’inversion du sed ne garantis pas de retrouver le vrai $prime$ d’origine.
$ sed -i 's/cd/b5/g' prime_good.txt # 2 occurrences de 'b5'
$ sed -i 's/57/a4/g' prime_good.txt # 3 occurrences de 'a4'
$ sed -i 's/54/16/g' prime_good.txt # 1 occurrence de '16'
$ sed -i 's/12/f4/g' prime_good.txt # 1 occurrence de 'f4'
$ sed -i 's/66/e1/g' prime_good.txt # on ignore car présent au début
$ sed -i 's/fb/7f/g' prime_good.txt # 4 occurrences de '7f' dans godd_prime.txt
Il faut donc tester toutes les combinaisons possibles, chaque occurrence peut prendre 2 valeurs, soit garder sa valeur actuelle, soit revenir à sa valeur d’origine. Nous allons tester toutes les combinaisons possibles appliquées au fichier prime_good.txt puis tester à chaque fois si notre $q$ est premier.
Voici le script qui va effectuer cette tâche :
#/usr/bin/env python3
import re
import itertools
import subprocess as sp
import gmpy
# read modulus (n)
n = ''.join(re.findall('[0-9a-f]{2}:.*:[0-9a-f]{2}', ''.join(open('modulus.txt').readlines()), re.DOTALL)).replace('\n', '').replace(' ', '').replace(':', '')
n = int(n,16)
# read prime to ajust
f = ''.join(open('prime_good.txt').readlines())
# hex to ajust
tab_reg = ['7f', 'f4', '16', 'a4', 'b5']
# find position for each previous hex
positions_occ = []
for reg in tab_reg:
tmp = []
for m in re.compile(reg).finditer(f):
tmp.append(m.start())
positions_occ.append(tmp)
# we ill use binary to find all combinaisons
combinaisons_7f = list(itertools.product([0,1], repeat=len(positions_occ[0])))
combinaisons_f4 = list(itertools.product([0,1], repeat=len(positions_occ[1])))
combinaisons_16 = list(itertools.product([0,1], repeat=len(positions_occ[2])))
combinaisons_a4 = list(itertools.product([0,1], repeat=len(positions_occ[3])))
combinaisons_b5 = list(itertools.product([0,1], repeat=len(positions_occ[4])))
# adapt '7f'
for c_7f in combinaisons_7f:
pos_7f = positions_occ[0]
new_7f_0 = '7f' if c_7f[0] == 0 else 'fb'
new_7f_1 = '7f' if c_7f[1] == 0 else 'fb'
new_7f_2 = '7f' if c_7f[2] == 0 else 'fb'
new_7f_3 = '7f' if c_7f[3] == 0 else 'fb'
f = f[0:pos_7f[0]] + new_7f_0 + f[pos_7f[0]+2:pos_7f[1]] + new_7f_1 + f[pos_7f[1]+2:pos_7f[2]] + new_7f_2 + f[pos_7f[2]+2:pos_7f[3]] + new_7f_3 + f[pos_7f[3]+2:]
# adapt 'f4'
for c_f4 in combinaisons_f4:
pos_f4 = positions_occ[1]
new_f4_0 = 'f4' if c_f4[0] == 0 else '12'
f = f[0:pos_f4[0]] + new_f4_0 + f[pos_f4[0]+2:]
# adapt '16'
for c_16 in combinaisons_16:
pos_16 = positions_occ[2]
new_16_0 = '16' if c_16[0] == 0 else '54'
f = f[0:pos_16[0]] + new_16_0 + f[pos_16[0]+2:]
# adapt 'a4'
for c_a4 in combinaisons_a4:
pos_a4 = positions_occ[3]
new_a4_0 = 'a4' if c_a4[0] == 0 else '57'
new_a4_1 = 'a4' if c_a4[1] == 0 else '57'
new_a4_2 = 'a4' if c_a4[2] == 0 else '57'
f = f[0:pos_a4[0]] + new_a4_0 + f[pos_a4[0]+2:pos_a4[1]] + new_a4_1 + f[pos_a4[1]+2:pos_a4[2]] + new_a4_2 + f[pos_a4[2]+2:]
# adapt 'b5'
for c_b5 in combinaisons_b5:
pos_b5 = positions_occ[4]
new_b5_0 = 'b5' if c_b5[0] == 0 else 'cd'
new_b5_1 = 'b5' if c_b5[1] == 0 else 'cd'
f = f[0:pos_b5[0]] + new_b5_0 + f[pos_b5[0]+2:pos_b5[1]] + new_b5_1 + f[pos_b5[1]+2:]
# final test
p = f.replace('\n', '').replace(' ', '').replace('prime1', '').replace(':', '')
p = int(p,16)
if gmpy.is_prime(p) == 1 or gmpy.is_prime(p) == 2:
q = n//p
if p*q == n:
print('p\n', p)
print('q\n', q)
exit(0)
Code pas du tout optimal, mais fonctionnel :)
$ python3 ./find_good_prime.py
p
31717798413454838971739311391870214101486054474438584033384974797696836002786889741922328038249283935148167589396475764515984792248325276562635675483085593307632384945480084324354199386711259069590701728377654610059849152461565385315663116675949927841648944186909571007960100266136674008112969369512988507367569334838093403144731951113528040013763615354283491955226704334394856253005551393545293491547587439064269735583121706098798182168292621767902095641352443871167789104818694502605762517497996162527138366803593402358312011933528177646501311411008602369245268966975849244259437732574655956250792264392115994984213
q
26415754111957012456882978698568998595543408604540679602012008905307229528398419508696699258861541673208334031720118065722015191735056250991124159829757615035331104814626815428071461389740988358621575175288995137250131479702118666935818278843603742157096854979085966659730153703721295913600711482578441198179188796849780101926878867272222747848775311501107737838687624647749187764563156054858429897018261077616060929102880860789449995240869652963349913062375402021334173237153511868665597034141167420444312865576543827395764456254276820652449103574192677537410783040227047254038577626347718324544296319787177388746439
Nous avons maintenant notre $p$ et $q$ qui sont premiers.
$ rsatool.py -o priv.key -p 3171779841... -q 2641575411...
# ...
Saving PEM as priv.key
Avec rsatool.pynous créons notre clé privée connaissant $p$ et $q$.
$ openssl rsautl -decrypt --inkey priv.key -in motDePasseGPG.txt.enc -out motDePasseGPG.txt
$ cat motDePasseGPG.txt
DGSE{Ti,%yei3=stlh_,5@pIrrMU.^mJC:luYbt1Qe_-Y}
On déchiffre ensuite avec openssl.
1337 gpg -o lsb_RGB.png.enc --symmetric lsb_RGB.png
À ce stade nous n’avons toujours pas utilisé cette commande, étrange…
$ unzip -d suite_files/ -P "DGSE{Ti,%yei3=stlh_,5@pIrrMU.^mJC:luYbt1Qe_-Y}" suite.zip
Archive: suite.zip
skipping: suite.txt incorrect password
Et non, ce mot de passe ne permet pas de déchiffrer le zip suite.zip.
GPG
1337 gpg -o lsb_RGB.png.enc --symmetric lsb_RGB.png
En regardant la commande, on se rend compte, que nous avons à faire à un chiffrement symetric. Alors que naturellement, GPG est un système de chiffrement asymétrique avec une notion de clé privée et publique. Pour du symétrique, il ne faut que le mot de passe pour déchiffrer, pas besoin de clé privée.
$ gpg --batch --yes --passphrase "DGSE{Ti,%yei3=stlh_,5@pIrrMU.^mJC:luYbt1Qe_-Y}" -o lsb_RGB.png --decrypt lsb_RGB.png.enc
gpg: AES256 encrypted data
gpg: encrypted with 1 passphrase
En cherchant un peu, on trouve comment déchiffrer du symétrique issu de GPG. On peut alors utiliser notre mot de passe que nous avions trouvé. Le fichier déchiffré est une autre image de Richelieu encore une fois.
Le nom est assez explicite pour comprendre que la prochaine étape consiste à extraire des données en LSB.
LSB
In digital steganography, sensitive messages may be concealed by manipulating and storing information in the least significant bits of an image or a sound file. In the context of an image, if a user were to manipulate the last two bits of a color in a pixel, the value of the color would change at most +/- 3 value places, which is likely to be indistinguishable by the human eye. The user may later recover this information by extracting the least significant bits of the manipulated pixels to recover the original message. This allows for the storage or transfer of digital information to be kept concealed.
Pour cette étape, nous devons utiliser l’image lsb_RGB.png afin d’extraire des données de celle-ci. Le LSB utilise la valeur des bits de poids faible des couleurs Rouge, Vert et Bleue. La difficulté du LSB réside dans la bonne sélection des bits de poids faibles. Nous utiliserons la librairie PIL(Python Imaging Library).
>>> from PIL import Image
>>> img = Image.open('lsb_RGB.png')
>>> img.size
(1562, 2424) # (y,x)
>>> img.mode
'RGB'
>>> img_data = img.load()
>>> img_data[0,0]
(60, 180, 75)
On peut tout d’abord voir que l’on a affaire à un PNG de type RGB (et non RGBA, car pas de valeur alpha). Chaque pixel correspond alors à un tuple de taille 3, par exemple (60, 180, 75) correspond à la valeur du pixel en position [y=0,x=0]. La valeur 60 correspond à la quantité de rouge (Red) du pixel (valeur maximale de 255), 180 est la quantité de vert (Green) et 75 la quantité de bleu (Blue).
>>> [bin(i)[2:].zfill(8) for i in img_data[0,0]]
['00111100', '10110100', '01001011']
# zfill(8): prefix with "0" to fixing size
Chacune de ces valeurs est codée sur 8 bits. Par exemple, la valeur 63 en base 10, est défini par 00111100 en base 2.
'00111100' -> '.......0'
'10110100' -> '.......0'
'01001011' -> '.......1'
Pour ce premier pixel, la valeur LSB du RED est 0, celle du GREEN est 0 et celle du BLUE est 1.
La difficulté réside maintenant dans le fait de savoir si nous devons utiliser les 3 bits précédents ou simplement le LSB du RED, ou du GREEN, … ou même seulement le LSB du GREEN et BLUE.
Également, nous devons savoir dans quelle direction parcourir les pixels de notre image, soit ligne par ligne (de gauche à droite) ou en colonnes (haut en bas).
Après pas mal de tests, on sait qu’il faut utiliser les 3 LSB, le RED, GREEN et BLUE, de plus on doit parcourir les pixels de notre image en colonne, de haut en bas.
Voici notre extracteur LSB:
#!/usr/bin/env python3
import sys
from PIL import Image
def extract(src):
img = Image.open(src)
dimX,dimY = img.size
data = img.load()
all_bits = ''
for y in range(dimX):
for x in range(dimY):
r,g,b = data[y,x]
r_bit = bin(r)[2:].zfill(8)[-1] # RED last bit
g_bit = bin(g)[2:].zfill(8)[-1] # GREEN last bit
b_bit = bin(b)[2:].zfill(8)[-1] # BLUE last bit
all_bits += r_bit + g_bit + b_bit
tab_all_bits = [all_bits[i:i+8] for i in range(0, len(all_bits), 8)]
return''.join([chr(int(c,2)) for c in tab_all_bits])
print('Start')
open('lsb_data', 'wb').write(extract(src='lsb_RGB.png').encode())
print('Done')
Ce script se charge de parcourir les pixels de l’image en colonne de haut en bas. Pour chaque pixel, on récupère le dernier bit des 3 composantes (RED, GREEN, BLUE). On construit ensuite un tableau d’octets (8 bits) sur lesquels on récupère leur caractère ASCII. Pour terminer, on enregistre tout ça dans le fichier lsb_data.
# autre manière de trouver les infos LSB
$ zsteg -a ./lsb_RGB.png
...
b1,rgb,lsb,yx .. text: "00000000: 7f45 4c46 0201 0103 0000 0000 0000 0000 .ELF............\n00000010: 0200 3e00 0100 0000 107f 4400 0000 0000 ..>.......D.....\n00000020
...
$ python3 ./lsb.py
Start
Done
$ file lsb_data
lsb_data: ASCII text
$ head lsb_data
00000000: 7f45 4c46 0201 0103 0000 0000 0000 0000 .ELF............
00000010: 0200 3e00 0100 0000 107f 4400 0000 0000 ..>.......D.....
00000020: 4000 0000 0000 0000 0000 0000 0000 0000 @...............
00000030: 0000 0000 4000 3800 0200 4000 0000 0000 ....@.8...@.....
00000040: 0100 0000 0500 0000 0000 0000 0000 0000 ................
00000050: 0000 4000 0000 0000 0000 4000 0000 0000 ..@.......@.....
00000060: 2487 0400 0000 0000 2487 0400 0000 0000 $.......$.......
00000070: 0000 2000 0000 0000 0100 0000 0600 0000 .. .............
00000080: 2854 0b00 0000 0000 2854 6b00 0000 0000 (T......(Tk.....
00000090: 2854 6b00 0000 0000 0000 0000 0000 0000 (Tk.............
Notre lsb_data correspond à la vue d’un éditeur hex d’un binaire, plus précisément un ELF (Executable and Linkable Format). La prochaine étape est sûrement d’extraire ce binaire et de l’analyser.
Mais avant de continuer, on doit se rappeler que notre script python précédent va réaliser l’extraction des bits LSB sur TOUS les pixels de l’image. Mais il y a de grande chance que notre extraction va trop loin. Essayons de voir cela en ouvrant lsb_data avec vim.
$ sed -n 18592,18595p lsb_data
000489f0: 414c 4421 0d16 0807 f3b9 2205 c301 7d67 ALD!......"...}g # ligne 18592
00048a00: 0009 0000 9a02 0000 5044 0b00 4918 006b ........PD..I..k # ligne 18593
00048a10: bc00 0000 .... # ligne 18594
q?Ð qdG/A§Ge¿{`Üø)í÷Ö°Ú@¾ïÄt¤#&óP_WlòÛ<7_&f|á}ª # ligne 18595
oDî$õ¬ËÕzµ'ßØQ
On peut donc voir que nous devons couper en ligne 18594 pour ne pas polluer notre extraction.
$ sed -n 1,18594p lsb_data > lsb_data_clean
$ cat lsb_data_clean | less
00000000: 7f45 4c46 0201 0103 0000 0000 0000 0000 .ELF............
00000010: 0200 3e00 0100 0000 107f 4400 0000 0000 ..>.......D.....
00000020: 4000 0000 0000 0000 0000 0000 0000 0000 @...............
Nous avons maintenant une vision en hex propre. Pour continuer nous devons extraire toutes les valeurs hexadécimal des colonnes du milieu. La colonne de gauche représente les positions des valeurs hexa et la colonne de droite, leur traduction ASCII, ces deux informations ne nous sont pas utiles, nous devons les retirer.
$ cat lsb_data_clean | cut -d' ' -f2-9 > lsb_data_clean_center
$ python3
>>> content = open('lsb_data_clean_center').read()
>>> clean_content = content.replace(' ', '').replace('\n', '')
>>> import binascii
>>> final = binascii.unhexlify(clean_content)
>>> open('elf.bin', 'wb').write(final)
$ file elf.bin
elf.bin: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, no section header
$ chmod +x elf.bin
$ ./elf.bin
usage : ./elf.bin <mot de passe>
$ ./elf.bin test
Mauvais mot de passe
Nous avons maintenant le fichier caché dans le PNG, c’est un exécutable ELF qui prend en paramètre un mot de passe que nous devons sûrement trouver.
Reverse
$ file elf.bin
elf.bin: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, no section header
$ r2 -d ./elf.bin
Process with PID 3036 started...
= attach 3036 3036
bin.baddr 0x00400000
Using 0x400000
Warning: Cannot initialize section headers
Warning: Cannot initialize strings table
Warning: Cannot initialize dynamic strings
asm.bits 64
[0x00447f10]> afl
0x00447f10 3 50 entry0
0x00447f80 28 203 fcn.00447f80
0x00448125 15 107 -> 230 fcn.00448125
0x00448190 3 38 -> 40 fcn.00448190
On peut voir qu’il n’y a pas de main() dans notre ELF, sûrement parce que ce dernier a été packé, il faut trouver le packer utilisé.
$ strings ./elf.bin | grep upx
$Info: This file is packed with the ALD executable packer http://upx.sf.net
On a donc à faire à un packer UPX, il faut réussir à le unpacker.
$ upx -d ./elf.bin -o elf_unpacked.bin
# -d: decompress
Ultimate Packer for eXecutables
Copyright (C) 1996 - 2017
UPX 3.94 Markus Oberhumer, Laszlo Molnar & John Reiser May 12th 2017
File size Ratio Format Name
-------------------- ------ ----------- -----------
upx: ./elf.bin: NotPackedException: not packed by UPX
Unpacked 0 files.
Sauf que, upx -d n’y arrive pas. La décompression ne fonctionne pas.
$ strings -a ./elf.bin | grep -i upx
$Info: This file is packed with the ALD executable packer http://upx.sf.net $
Si nous revenons à cette étape, on peut remarquer que l’URL http://upx.sf.net correspond bien à une preuve d’UPX, mais il y a un problème sur This file is packed with the ALD executable packer. En effet, à la place de ALD on est censé avoir UPX. Également, notre grep -i upx est censé trouvé la chaîne UPX! plusieurs fois.
Après un peu de réflexion, peut-être que la chaîne UPX a été remplacé par ALD ?
$ strings -a ./elf.bin | grep -i ald
ALD!
;AlD
$Info: This file is packed with the ALD executable packer http://upx.sf.net $
$Id: ALD 3.91 Copyright (C) 1996-2013 the ALD Team. All Rights Reserved. $
ALD!
ALD!
Donc oui, tous les UPX ont été remplacé par des ALD. Nous devons donc faire l’inverse pour continuer.
$ file elf.bin
elf.bin: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, no section header
$ cat elf.bin | sed s/ALD/UPX/g > elf_upx.bin
$ upx -d ./elf_upx.bin -o ./elf_upx_unpacked.bin
# -d: decompress
Ultimate Packer for eXecutables
Copyright (C) 1996 - 2017
UPX 3.94 Markus Oberhumer, Laszlo Molnar & John Reiser May 12th 2017
File size Ratio Format Name
-------------------- ------ ----------- -----------
738384 <- 297492 40.29% linux/amd64 elf_upx_unpacked.bin
Unpacked 1 file.
$ file ./elf_upx_unpacked.bin
./elf_upx_unpacked.bin: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=280771ce69bcde48b3a996331811768a49c7c120, stripped
$ chmod +x ./elf_upx_unpacked.bin
$ ./elf_upx_unpacked.bin
usage : ./elf_upx_unpacked.bin <mot de passe>
$ ./elf_upx_unpacked.bin test
Mauvais mot de passe
Nous avons donc réussi à décompresser (unpacker) notre elf.bin en elf_upx_unpacked. Nous pouvons maintenant commencer une analyse classique du binaire.
$ r2 -d ./elf_upx_unpacked.bin
> aaaa
> afl
0x00400990 1 43 entry0
0x00400aae 9 114 sub.w0c__:_aae
0x00400b20 6 83 main
0x00401080 66 828 fcn.00401080
0x00407840 3 158 fcn.00407840
0x00408010 30 445 -> 417 fcn.00408010
0x004440f0 296 11505 -> 7157 sub.n_in_writable_segment_detected_f0
> s main
> pdf
/ (fcn) main 83
| main (int arg2);
| ; arg int arg2 @ rsi
| ; DATA XREF from entry0 (0x4009ad)
| 0x00400b20 53 push rbx
| 0x00400b21 83ff01 cmp edi, 1 ; 1
| ,=< 0x00400b24 7e1f jle 0x400b45 # on s'assure d'un argv[1]
| | 0x00400b26 488b7e08 mov rdi, qword [rsi + 8] ; arg2
| | 0x00400b2a e87fffffff call sub.w0c__:_aae # appel de fonction
| | 0x00400b2f 89c3 mov ebx, eax # on récupére une valeur de
| | 0x00400b31 85c0 test eax, eax # retour qui va nous dire si mdp
| ,==< 0x00400b33 752b jne 0x400b60 # OK ou NOT OK
| || 0x00400b35 488d3d238d08. lea rdi, qword str.Mauvais_mot_de_passe
| || 0x00400b3c e8cf740000 call fcn.00408010 # NOT OK
| || ; CODE XREFS from main (0x400b5e, 0x400b71)
| ..---> 0x00400b41 89d8 mov eax, ebx
| ::|| 0x00400b43 5b pop rbx
| ::|| 0x00400b44 c3 ret
| ::|| ; CODE XREF from main (0x400b24) # si pas d'argument
| ::|`-> 0x00400b45 488b36 mov rsi, qword [rsi] ; arg2
| ::| 0x00400b48 488d3df58c08. lea rdi, qword str.usage_:__s__mot_de_passe
| ::| 0x00400b4f b800000000 mov eax, 0
| ::| 0x00400b54 e8e76c0000 call fcn.00407840 # OK
| ::| 0x00400b59 bb02000000 mov ebx, 2
| `====< 0x00400b5e ebe1 jmp 0x400b41
| :| ; CODE XREF from main (0x400b33)
| :`--> 0x00400b60 488d3d118d08. lea rdi, qword str.Bravo___Vous_pouvez_utiliser_ce_mot_passe_pour_la_suite
| : 0x00400b67 e8a4740000 call fcn.00408010
| : 0x00400b6c bb00000000 mov ebx, 0
\ `===< 0x00400b71 ebce jmp 0x400b41
0x00400b20 53 push rbx
0x00400b21 83ff01 cmp edi, 1
0x00400b24 7e1f jle 0x400b45 # on s'assure d'un argv[1]
Rapidement, on peut dire que notre programme s’assure de la présence d’un argv[1], si rdi <= 1 alors on envoi le message d’erreur usage: ./elf_upx_unpacked.bin <mot de passe> avec un jle 0x400b45. Le registre rdi contient le nombre d’arguments du programme. Lorsque rdi = 0x00000001 alors message d’erreur, lorsque rdi = 0x00000002 on continu l’exécution.
rdietedisont la même entité.
0x00400b26 488b7e08 mov rdi, qword [rsi + 8] ; arg2
0x00400b2a e87fffffff call sub.w0c__:_aae
Ensuite, on se charge de récupérer le argv[1] et d’appeler la fonction sub.w0c__:_aae juste derrière.
0x00400b2a e87fffffff call sub.w0c__:_aae
0x00400b2f 89c3 mov ebx, eax
0x00400b31 85c0 test eax, eax # test de la valeur de retour de la fonction
0x00400b33 752b jne 0x400b60 # prise de décision succès ? ou échec ?
0x00400b35 488d3d238d08. lea rdi, qword str.Mauvais_mot_de_passe # échec
0x00400b3c e8cf740000 call fcn.00408010
0x00400b41 89d8 mov eax, ebx
0x00400b43 5b pop rbx
0x00400b44 c3 ret
...
0x00400b60 488d3d118d08. lea rdi, qword str.Bravo___Vous_pouvez_utiliser_ce_mot_passe_pour_la_suite # succès
0x00400b67 e8a4740000 call fcn.00408010
0x00400b6c bb00000000 mov ebx, 0
0x00400b71 ebce jmp 0x400b41
On peut voir que cette fonction est très importante, en effet, c’est elle qui décide quel message afficher. Lors d’un succès, on affiche Vous pouvez utiliser ce mot de passe pour la suite et lors d’un échec, on affiche Mauvais mot de passe.
Nous allons donc passer à l’analyse de la fonction sub.w0c__:_aae.
> s sub.w0c__:_aae
> pdf
/ (fcn) sub.w0c__:_aae 114
| sub.w0c__:_aae (int arg1);
| ; arg int arg1 @ rdi
| ; CALL XREF from main (0x400b2a)
| 0x00400aae 4889fe mov rsi, rdi ; arg1
| 0x00400ab1 b800000000 mov eax, 0
| 0x00400ab6 48c7c1ffffff. mov rcx, -1
| 0x00400abd f2ae repne scasb al, byte [rdi]
| 0x00400abf b800000000 mov eax, 0
| 0x00400ac4 4883f9e0 cmp rcx, -0x20
| ,=< 0x00400ac8 7402 je 0x400acc
| | ; CODE XREF from sub.w0c__:_aae (0x400b1e)
| .--> 0x00400aca f3c3 ret
| :| ; CODE XREF from sub.w0c__:_aae (0x400ac8)
| :`-> 0x00400acc 0fb60e movzx ecx, byte [rsi]
| : 0x00400acf 84c9 test cl, cl
| :,=< 0x00400ad1 7446 je 0x400b19
| :| 0x00400ad3 488d15e68d08. lea rdx, qword str.w0c__: ; 0x4898c0 ; "w0c&]:\x0e;\rM*\x1f.\x1f-O(Q7z\x14v x\x0f!M!l\x11"
| :| 0x00400ada 488d7e01 lea rdi, qword [rsi + 1] ; r11
| :| 0x00400ade b801000000 mov eax, 1
| :| 0x00400ae3 be33000000 mov esi, 0x33 ; '3' ; 51
| :| 0x00400ae8 41b900000000 mov r9d, 0
| ,===< 0x00400aee eb16 jmp 0x400b06
| |:| ; CODE XREFS from sub.w0c__:_aae (0x400b0b, 0x400b15)
| ..----> 0x00400af0 410fb6c0 movzx eax, r8b
| ::|:| 0x00400af4 0fb632 movzx esi, byte [rdx]
| ::|:| 0x00400af7 0fb60f movzx ecx, byte [rdi]
| ::|:| 0x00400afa 4883c201 add rdx, 1
| ::|:| 0x00400afe 4883c701 add rdi, 1
| ::|:| 0x00400b02 84c9 test cl, cl
| ,======< 0x00400b04 7411 je 0x400b17
| |::|:| ; CODE XREF from sub.w0c__:_aae (0x400aee)
| |::`---> 0x00400b06 4589c8 mov r8d, r9d
| |:: :| 0x00400b09 85c0 test eax, eax
| |`=====< 0x00400b0b 74e3 je 0x400af0
| | : :| 0x00400b0d 31f1 xor ecx, esi
| | : :| 0x00400b0f 3a0a cmp cl, byte [rdx]
| | : :| 0x00400b11 410f94c0 sete r8b
| | `====< 0x00400b15 ebd9 jmp 0x400af0
| `------> 0x00400b17 f3c3 ret
| :| ; CODE XREF from sub.w0c__:_aae (0x400ad1)
| :`-> 0x00400b19 b801000000 mov eax, 1
\ `==< 0x00400b1e ebaa jmp 0x400aca
0x00400aae 4889fe mov rsi, rdi
0x00400ab1 b800000000 mov eax, 0
0x00400ab6 48c7c1ffffff. mov rcx, -1
0x00400abd f2ae repne scasb al, byte [rdi]
0x00400abf b800000000 mov eax, 0
0x00400ac4 4883f9e0 cmp rcx, -0x20
0x00400ac8 7402 je 0x400acc
0x00400aca f3c3 ret
Les premières instructions servent sûrement à gérer l’argument de la fonction (qui est notre mot de passe). Après cela, on compare rcx à 0x20. Si cette comparaison et vraie, alors on continue le l’exécution (on évite le ret). Sinon on va sur le ret qui va nous faire quitter la fonction avec un eax à 0, ce qui va nous afficher Mauvais mot de passe.
Pour faire simple, le cmp rcx, -0x20 va s’assurer que le argv[1] fourni au programme va avoir une taille de 32 caractères.
argv[1] |
rcx |
-0x20 |
cmp rcx, -0x20 |
|---|---|---|---|
AAAA |
0xfffffffffffffffa |
0xffffffffffffffdf |
NOT EQUAL |
AAAAAA |
0xfffffffffffffff8 |
0xffffffffffffffdf |
NOT EQUAL |
A*32 |
0xffffffffffffffdf |
0xffffffffffffffdf |
EQUAL |
Nous devons donc avoir un argv[1] de taille 0x20, soit 32 caractères pour respecter cette condition.
> ood AAAA
> db 0x00400ac8
> dc
hit breakpoint at: 400ac8
> dr rip
0x00400ac8
> dr rip=0x00400acc
0x00400ac8 ->0x00400acc
Normalement, nous devons fournir un argument de taille 32 octets, mais nous allons juste donner ABCD au programme, placer un breakpoint sur je 0x400acc afin de modifier la valeur de rip pour passer outre la condition des 32 caractères.
0x00400acc 0fb60e movzx ecx, byte [rsi]
0x00400acf 84c9 test cl, cl
0x00400ad1 7446 je 0x400b19
0x00400ad3 488d15e68d08. lea rdx, qword str.w0c__: ; 0x4898c0 ; "w0c&]:\x0e;\rM*\x1f.\x1f-O(Q7z\x14v x\x0f!M!l\x11"
0x00400ada 488d7e01 lea rdi, qword [rsi + 1]
0x00400ade b801000000 mov eax, 1
0x00400ae3 be33000000 mov esi, 0x33 ; '3' ; 51
0x00400ae8 41b900000000 mov r9d, 0
0x00400aee eb16 jmp 0x400b06
Dans ce bloc on peut remarquer que l’on va manipuler la chaîne w0c&]:\x0e;\rM*\x1f.\x1f-O(Q7z\x14v x\x0f!M!l\x11.
0x00400af0 410fb6c0 movzx eax, r8b
0x00400af4 0fb632 movzx esi, byte [rdx]
0x00400af7 0fb60f movzx ecx, byte [rdi]
0x00400afa 4883c201 add rdx, 1
0x00400afe 4883c701 add rdi, 1
0x00400b02 84c9 test cl, cl
0x00400b04 7411 je 0x400b17
0x00400b06 4589c8 mov r8d, r9d
0x00400b09 85c0 test eax, eax
0x00400b0b 74e3 je 0x400af0
0x00400b0d 31f1 xor ecx, esi
0x00400b0f 3a0a cmp cl, byte [rdx]
0x00400b11 410f94c0 sete r8b
0x00400b15 ebd9 jmp 0x400af0
0x00400b17 f3c3 ret
0x00400b19 b801000000 mov eax, 1
0x00400b1e ebaa jmp 0x400aca
Dans la suite on observe une ligne intéressante xor ecx, esi.
0x00400b0d 31f1 xor ecx, esi
0x00400b0f 3a0a cmp cl, byte [rdx]
On réalise un XOR puis un comparaison, c’est sûrement une partie importante du prgramme. Pour ce xor on utilise ecx et esi.
0x00400af4 0fb632 movzx esi, byte [rdx]
0x00400af7 0fb60f movzx ecx, byte [rdi]
0x00400afa 4883c201 add rdx, 1
0x00400afe 4883c701 add rdi, 1
Après pas mal de debug sur le programme sur les instructions importantes, on comprend comment fonctionne la vérification du mot de passe.
On peut retrouver ce dernier avec le script suivant :
#!/usr/bin/env python3
string = '3w0c&]:\x0e;\rM*\x1f.\x1f-O(Q7z\x14v x\x0f!M!l\x11'
for i in range(1, len(string)):
print(chr(ord(string[i-1]) ^ ord(string[i])), end='')
print()
# DGSE{g456@g5112bgyfMnbVXw.llM}
ZIP
$ unzip -d suite_files/ -P "DGSE{g456@g5112bgyfMnbVXw.llM}" suite.zip
Archive: suite.zip
inflating: suite_files/suite.txt
$ cat suite_files/suite.txt
Suite du challenge Richelieu :
ssh defi1.challengecybersec.fr -l defi1 -p 2222
mot de passe : DGSE{2f77c517b06f1cd1ce864f79f41f25ca8874413c8c1204f7ec9c6728c87f270a}
C’est ici que le challenge se termine pour moi.