Présentation
Le 4 mars 2011 SCRT a organisé la 4ème édition du concours de Ethical Hacking de Suisse romande à l’HEPIA, haute école du paysage d’ingénierie et d’architecture de Genève.. Le concours est maintenant terminé.
Environ 200 participants se sont affrontés sur différentes épreuves touchant à divers domaines de la sécurité des systèmes d'information.
Les épreuves
La suite des corrections arrivera prochainement.
Reverse - Windows
Le but de cette épreuve était de reverser un binaire Windows (windows.exe) afin de retrouver la clef validant le challenge.
*********************
En suivant l'exécution du processus à l'aide d'un debugger tel qu'immDBG, on retrouve la fonction main() à l'adresse 0x401000. La première action est de vérifier que le nombre d'arguments est bien égal à 2.
00401000 $ 55 PUSH EBP
00401001 . 8BEC MOV EBP,ESP
00401003 . 837D 08 02 CMP DWORD PTR SS:[EBP+8],2
00401007 . 74 08 JE SHORT windows.00401011
00401009 > 6A 01 PUSH 1 ; /status = 1
0040100B . FF15 A0204000 CALL DWORD PTR DS:[<&MSVCR90.exit>] ; \exit
Dans le cas où le nombre d'arguments est correct, la longueur d'une chaine stockée en 0x4020F4 est calculée (on notera au passage, une erreur de décompilation par le moteur d'immDBG qui masque le mov eax, 4020F4):
00401023 > 15 B8F42040 ADC EAX,4020F4B8
00401028 ? 008D 50018D64 ADD BYTE PTR SS:[EBP+648D0150],CL
0040102E ? 24 00 AND AL,0
00401030 > 8A08 MOV CL,BYTE PTR DS:[EAX]
00401032 . 40 INC EAX
00401033 . 84C9 TEST CL,CL
00401035 .^75 F9 JNZ SHORT windows.00401030
00401037 . 56 PUSH ESI
00401038 . 2BC2 SUB EAX,EDX
La longueur de la chaine passée en argument est ensuite calculée en 0x40103B:
0040103B . 8B7D 0C MOV EDI,DWORD PTR SS:[EBP+C]
0040103E . 8BD0 MOV EDX,EAX
00401040 . 8B47 04 MOV EAX,DWORD PTR DS:[EDI+4]
00401043 . 8D70 01 LEA ESI,DWORD PTR DS:[EAX+1]
00401046 > 8A08 MOV CL,BYTE PTR DS:[EAX]
00401048 . 40 INC EAX
00401049 . 84C9 TEST CL,CL
0040104B .^75 F9 JNZ SHORT windows.00401046
0040104D . 2BC6 SUB EAX,ESI
Dans le cas où les deux longueurs correspondent, l'argument est parcouru 4 octets par 4 octets et pour chaque bloc, un décalage à gauche de 2 est effectué et le résultat est comparé aux 4 octets correspondant du blob situé en 0x4020F4:
00401075 > 8B47 04 MOV EAX,DWORD PTR DS:[EDI+4]
00401078 . 8B0C90 MOV ECX,DWORD PTR DS:[EAX+EDX*4]
0040107B . 894D 08 MOV DWORD PTR SS:[EBP+8],ECX
0040107E . 8B45 08 MOV EAX,DWORD PTR SS:[EBP+8]
00401081 . 0FC8 BSWAP EAX
00401083 . C1C0 02 ROL EAX,2
00401086 . 8945 08 MOV DWORD PTR SS:[EBP+8],EAX
00401089 . 8B45 08 MOV EAX,DWORD PTR SS:[EBP+8]
0040108C . 3B0495 F420400>CMP EAX,DWORD PTR DS:[EDX*4+4020F4]
00401093 .^0F85 70FFFFFF JNZ windows.00401009
00401099 . B8 F4204000 MOV EAX,windows.004020F4
0040109E . 42 INC EDX
0040109F . 8D70 01 LEA ESI,DWORD PTR DS:[EAX+1]
004010A2 > 8A08 MOV CL,BYTE PTR DS:[EAX]
004010A4 . 40 INC EAX
004010A5 . 84C9 TEST CL,CL
004010A7 .^75 F9 JNZ SHORT windows.004010A2
004010A9 . 2BC6 SUB EAX,ESI
004010AB . C1E8 02 SHR EAX,2
004010AE . 3BD0 CMP EDX,EAX
004010B0 .^72 C3 JB SHORT windows.00401075
On peut donc extraire les 12 octets situés en 0x4020F4 et effectuer une opération de décalage à droite de 2 afin de retrouver la clef. Ce qui se résume par le script immDBG suivant:
import struct
import immlib
bufferAddr = 0x4020F4
def ror(val, count):
for i in range(0, count):
val = (val >> 1) | ((val & 0x1) << 31)
return val
def main():
imm = immlib.Debugger()
block = struct.unpack("<L", imm.readMemory(bufferAddr, 4))[0]
data = "%08x" % ror(block, 2)
imm.log(data.decode("hex"))
block = struct.unpack("<L", imm.readMemory(bufferAddr + 4, 4))[0]
data = "%08x" % ror(block, 2)
imm.log(data.decode("hex"))
block = struct.unpack("<L", imm.readMemory(bufferAddr + 8, 4))[0]
data = "%08x" % ror(block, 2)
imm.log(data.decode("hex"))
return "Data decrypted"
Reverse - GPGPU
Cette épreuve avait pour but de reverser un algorithme compilé pour GPGPU nvidia (kernel.bin) afin de pouvoir développer une application réalisant l'opération inverse et donnant ainsi au clair correspondant au chiffré "ohv'c~f3ehnw4byzzky"
*********************
Concernant les bases sur le reverse de binaires PTX, vous pouvez vous référez à l'article posté sur notre blog. Ici, nul besoin d'extraire le code PTX vu que c'est ce dernier qui était fourni.
$ head kernel.bin
bplist00?^clBinaryDriver\clBinaryData_clBinaryVersionWCLH 1.0OH.version 1.5
.target sm_42
.target texm0de_independ3nt
On s'aperçoit que le header a été modifié a plusieurs endroit dans l'idée de forcer à reverser statiquement le code plutôt que de le charger sur un GPU. Des lignes 26 à 54 un tableau contenant les valeurs suivantes est copié dans la stack:
{0x16, 0x7, 0x3, 0x7, 0x4, 0x11, 0x12, 0x13, 0x16, 0x7, 0x3, 0x12, 0x14, 0x11, 0x12, 0x13, 0x16, 0x7, 0x3}
Les paramètres de la fonction exécutée sur le GPGPU sont ensuite copiés dans les registres r1 à r3 et la valeur de length est comparée à 0:
ld.param.u32 r1, [decode_2 + 0];
ld.param.u32 r2, [decode_1 + 0];
ld.param.u32 r3, [decode_0 + 0];
LBB1_1:
setp.hs.u32 p0, r0, r3;
@p0 ret;
Dans le cas où la longueur n'est pas égale à 0, les tableaux input et celui crée plus tôt sont parcourus (respectivement avec r5 et r4) afin de réaliser l'opération xor entre chacun des octets des deux tableaux.
LBB1_2:
add.u32 r4, 4, sp;
add.u32 r4, r4, r0;
ld.local.u8 r4, [r4+0];
add.u32 r5, r2, r0;
ld.global.u8 r5, [r5+0];
xor.b32 r4, r5, r4;
add.u32 r5, r1, r0;
st.global.u8 [r5+0], r4;
add.u32 r0, r0, 1;
bra LBB1_1;
En utilisant le tableau crée pour xorer la chaine fournie dans l'énoncé, on obtient la clef de validation suivante:
"you got some skillz"
Follow the line
Le but de cette épreuve était de trouver une phrase cachée dans une image.
*********************
On commence par regarder les sources de la page pour s'apercevoir que l'image est au format SVG.
src="follow_the_line.svg"
Il faut récupérer l'image et ouvrir le code source avec un simple éditeur de texte.
...
line
x1="225" y1="155"
x2="235" y2="135"
stroke="red" />
<line
x1="225" y1="135"
x2="235" y2="155"
stroke="red" />
<line
x1="70" y1="45"
x2="80" y2="25"
stroke="red" />
<line
x1="70" y1="45"
x2="60" y2="25"
stroke="red" />
<line
x1="10" y1="25"
x2="267" y2="415"
stroke="green"
stroke-width="6"/>
<line
x1="185" y1="125"
x2="195" y2="105"
stroke="red" />
<line
x1="185" y1="105"
x2="195" y2="125"
stroke="red" />
<line
x1="85" y1="105"
x2="85" y2="85"
stroke="red" />
<line
x1="85" y1="95"
x2="92" y2="105"
stroke="red" />
<path d = "M 120 25 q -20 15 5 20" stroke = "red" stroke-width = "1" fill = "none"/>
<circle
cx = "135" cy = "100"
r = "10"
fill = "white"
stroke = "red"
stroke-width = "1"/>
<g stroke = "black" stroke-width = "3" fill = "black">
circle id = "pointA" cx = "100" cy = "350" r = "7"/>
circle id = "pointB" cx = "250" cy = "50" r = "3"/>
circle id = "pointC" cx = "400" cy = "350" r = "3"/>
circle id = "pointD" cx = "175" cy = "200" r = "6"/>
circle id = "pointE" cx = "325" cy = "200" r = "3"/>
circle id = "pointF" cx = "250" cy = "200" r = "2"/>
/g>
<rect x = "100" y = "100" width = "200" height = "100" fill = "yellow" stroke = "black" stroke-width = "3"/>
<circle
cx = "135" cy = "180"
r = "70"
fill = "yellow"
stroke = "blue"
stroke-width = "5"/>
<rect x = "90" y = "100" rx = "100" ry = "50" width = "200" height = "100" fill = "green" stroke = "black" stroke-width = "3"/>
<line
x1="125" y1="45"
x2="125" y2="35"
stroke="red" />
<polygon id = "s1" points = "60,0 120,0 180,60 180,120 120,180 60,180 0,120 0,60" fill = "none" stroke = "black" stroke-width = "3"/>
<polygon id = "s2" points = "60,0 120,0 180,60 180,120 120,180 60,180 0,120 0,60" fill = "rgb(240, 200, 255)" stroke = "black" stroke-width = "3"/>
<circle id = "s3" cx = "100" cy = "100" r = "75"/>
<circle id = "s4" cx = "100" cy = "100" r = "75"/>
<rect x = "30" y = "200" rx = "100" ry = "50" width = "400" height = "200" fill = "salmon" stroke = "black" stroke-width = "3"/>
<circle
cx = "335" cy = "380"
r = "70"
fill = "white"
stroke = "orange"
stroke-width = "5"/>
<line
x1="125" y1="35"
x2="120" y2="35"
stroke="red" />
<line
x1="25" y1="435"
x2="370" y2="35"
stroke="violet"
<stroke-width="4" />
<circle
cx = "260" cy = "170"
r = "2"
fill = "white"
stroke = "red"
stroke-width = "1"/>
<text x = "140" y = "275" fill = "pink" font-size = "35">
Follow the line
/text>
<circle
cx = "270" cy = "170"
r = "2"
fill = "white"
stroke = "red"
stroke-width = "1"/>
<circle
cx = "280" cy = "170"
r = "2"
fill = "white"
stroke = "red"
stroke-width = "1"/>
<path d = "M 85 85 q 15 0 0 12" stroke = "red" stroke-width = "1" fill = "none"/>
<path d = "M 25 37 q 12 0 0 12" stroke = "red" stroke-width = "1" fill = "none"/>
<path d = "M 25 25 q -12 10 0 12" stroke = "red" stroke-width = "1" fill = "none"/>
<line
x1="260" y1="145"
x2="260" y2="165"
stroke="red" />
<line
x1="270" y1="145"
x2="270" y2="165"
stroke="red" />
<circle
cx = "280" cy = "160"
r = "50"
fill = "orange"
stroke = "blue"
stroke-width = "5"/>
<line
x1="280" y1="145"
x2="280" y2="165"
stroke="red" />
...
On constate qu'il y a beaucoup d'élément de couleur red alors que l'image en contient assez peu. Essayons de supprimer tous les éléments qui ne sont pas de cette couleur.
...
<line
x1="225" y1="155"
x2="235" y2="135"
stroke="red" />
<line
x1="225" y1="135"
x2="235" y2="155"
stroke="red" />
<line
x1="70" y1="45"
x2="80" y2="25"
stroke="red" />
<line
x1="70" y1="45"
x2="60" y2="25"
stroke="red" />
<line
x1="185" y1="125"
x2="195" y2="105"
stroke="red" />
<line
x1="185" y1="105"
x2="195" y2="125"
stroke="red" />
<line
x1="85" y1="105"
x2="85" y2="85"
stroke="red" />
<line
x1="85" y1="95"
x2="92" y2="105"
stroke="red" />
<path d = "M 120 25 q -20 15 5 20" stroke = "red" stroke-width = "1" fill = "none"/>
<circle
cx = "135" cy = "100"
r = "10"
fill = "white"
stroke = "red"
stroke-width = "1"/>
<line
x1="125" y1="45"
x2="125" y2="35"
stroke="red" />
<line
x1="125" y1="35"
x2="120" y2="35"
stroke="red" />
<circle
cx = "260" cy = "170"
r = "2"
fill = "white"
stroke = "red"
stroke-width = "1"/>
<circle
cx = "270" cy = "170"
r = "2"
fill = "white"
stroke = "red"
stroke-width = "1"/>
<circle
cx = "280" cy = "170"
r = "2"
fill = "white"
stroke = "red"
stroke-width = "1"/>
<path d = "M 85 85 q 15 0 0 12" stroke = "red" stroke-width = "1" fill = "none"/>
<path d = "M 25 37 q 12 0 0 12" stroke = "red" stroke-width = "1" fill = "none"/>
<path d = "M 25 25 q -12 10 0 12" stroke = "red" stroke-width = "1" fill = "none"/>
<line
x1="260" y1="145"
x2="260" y2="165"
stroke="red" />
<line
x1="270" y1="145"
x2="270" y2="165"
stroke="red" />
<line
x1="280" y1="145"
x2="280" y2="165"
stroke="red" />
...
On sauve cette nouvelle image et le text SVG ROXX!!! apparaît.
Pioneer One
Cette épreuve avait pour but de corriger un sous-titre qui ne voulait rien dire dans une vidéo en flash.
*********************
Après lecture de la vidéo, on remarque tout de suite que le sous-titre posant problème est le premier. Il faut récupérer l'animation movie.swf et la décompiler à l'aide de Trillix. Voici les 2 parties du code qui nous intéressent.
this.videoPlayer.cuePoints = ["t", 10000, "n", 16, "t", 2, "d", 0, "p", 1, "srt", "A6,9ZY Or3TKert", "t", 25833, "n", 13, "t", 2, "d", 0, "p", 1, "srt", "G97h927l\'6btdnuu\'xmgAekonAzslFzNHNrLLGMTTyLRBNP02Y2 L", "t", 29000, "n", 12, "t", 2, "d", 0, "p", 1, "srt", "CZSdcf0.\'n0d6ke5pec9pbuwagEdBqohInFHmNwpzDCERw", "t", 32041, "n", 11, "t", 2, "d", 0, "p", 1, "srt", "k 8i 3sjq7fdas.sitvsmfDlxxkprFMMqODFLFSxDHJTXLE2RPI9O6", "t", 34000, "n", 10, "t", 2, "d", 0, "p", 1, "srt", "CQHBZOMF6Z3YRLQW,X,Rb42Vi1f1", "t", 37000, "n", 9, "t", 2, "d", 0, "p", 1, "srt", "Tig\'ekzlzfDsqjKpHnOHLGztGRwCQURBU11FYQIU81Q4O,\'.c34 4X2c718ko\'hqw,", "t", 42000, "n", 8, "t", 2, "d", 0, "p", 1, "srt", "TqpiyotmBgEtrFtmrJxqzRBLSSxDRVSCV22GZRJV92R5P2821,f8gmZ4e93 jqo.fe.", "t", 44958, "n", 7, "t", 2, "d", 0, "p", 1, "srt", "HFIDwEKVGT1LZRXRISW6UO", "t", 46958, "n", 6, "t", 2, "d", 0, "p", 1, "srt", ".cW9bk8elbhb6qfd JpwiwtlBggzDjKpBBAGArKKuSHFyPSTTF", "t", 51000, "n", 3, "t", 2, "d", 0, "p", 1, "srt", "kVUN3TYR6LY R,QVS86ef.6Ze 28iod9", "t", 54000, "n", 2, "t", 2, "d", 0, "p", 1, "srt", "7qjvptnFHqDzByvWICWA1GZEPYTZTK84NZT9 0 U\'dXk 4k2p.5sbpd hqlrlcAwfnzinpDKKoBNt", "t", 58041, "n", 4, "t", 2, "d", 0, "p", 1, "srt", ".0RL.VO0UYS .V84630k\',4knfad xgchbvhGh", "t", 62966, "n", 5, "t", 2, "d", 0, "p", 1, "srt", ",AyMAtUzSxPRAURHVH", "t", 65000, "n", 1, "t", 2, "d", 0, "p", 1, "srt", "H 8i 3q\'nb8mo,nrjyEdBqyFsuHHmrtHOOszFzNHKQKBZOMF6Z3YRN", "t", 69000, "n", 15, "t", 2, "d", 0, "p", 1, "srt", "G3W ihj19b,5se.s xg\'xmuBoqDhInGlHzyANrwQuSHFyWMRKF", "t", 72000, "n", 14, "t", 2, "d", 0, "p", 1, "srt", "th.6F8vovngaiudqCglxykpwrAGrrASCMwLPR0NTNE2RPIP228V8\'Y8Y1cX"];
Cette ligne nous indique les sous-titre sont chiffrés dans les sources et que l'animation les déchiffre avant de les afficher.
public function showSubtitles(arg1:*):*
{
var loc1:*="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ,.\'";
var loc2:*=arg1.info.parameters.srt.length;
var loc3:*="";
var loc4:*="";
var loc5:*="";
var loc6:*=0;
var loc7:*=0;
while (loc7 < loc2)
{
loc3 = arg1.info.parameters.srt.charAt(loc7);
loc6 = loc1.indexOf(loc3) - loc2 - loc7;
while (loc6 < 0)
{
loc6 = loc6 + loc1.length;
}
loc5 = loc1.charAt(loc6);
loc4 = loc4 + loc5;
++loc7;
}
arg1.target.parent.srtText.text = loc4;
return;
}
Cette partie nous montre l'algorithme utilisé pour déchiffrer les sous-titre. Il faut commencer par comprendre les tâches effectuées.
loc1:*="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ,.\
loc1 contient une chaîne de caractère.
loc2:*=arg1.info.parameters.srt.length;
loc2 est égal à la longueur du sous-titre en cours.
var loc7:*=0;
while (loc7 < loc2)
Loc7 est égal à 0 pour commencer. Il s'incrémentera de 1 jusqu'à ce qu'il soit égal à la longueur du sous-titre en cours.
loc3 = arg1.info.parameters.srt.charAt(loc7);
loc3 est égal au caractère de la position loc7 dans le sous-titre en cours
loc6 = loc1.indexOf(loc3) - loc2 - loc7;
loc6 est égal à la position du caractère dans la chaîne - la longueur du sous-titre en cours (loc2) - la position du caractère en cours (loc7)
while (loc6 < 0)
{
loc6 = loc6 + loc1.length;
}
On ajoute la longueur de la chaîne loc1 jusqu'à ce que loc6 soit supérieur à 0
loc5 = loc1.charAt(loc6);
loc5 est égal au caractère à la position loc6 dans la chaîne loc1.
loc4 = loc4 + loc5;
++loc7;
On place le caractère dans loc4 et on passe au caractère suivant du sous-titre en cours.
Maintenant qu'on a compris l'algorithme, on peut s'attaquer à la résolution du problème. La description nous dit qu'il y a eu un problème lors du chiffrement / déchiffrement du sous-titre. Vu que le déchiffrement du sous-titre ne donne rien, on peut imagine qu'il y a eu un problème lors du chiffrement. Il faut donc modifier l'algorithme pour effectuer l'opération inverse. On utilise ensuite cet algorithme sur le premier sous-titre que l'on trouve dans les sources (A6,9ZY Or3TKert) et on obtient la valeur Pioneer One FTW.
Exemple du script en ActionScript 3
for (var currentPos:Number = 0; currentPos<lnLength; currentPos++){
charAtPos=evtObj.info.parameters.srt.charAt(currentPos);
newPos = charRpl.indexOf(charAtPos) + lnLength + currentPos;
while (newPos >= charRpl.length){
newPos = newPos - charRpl.length;
}
newChar = charRpl.charAt(newPos);
cryptValue+= newChar;
}
Portes ouvertes
Le but de cette épreuve est de retrouver les paramètres d'un scan de ports un peu particulier.
*********************
L'énoncé de l'épreuve demande de retrouver l'adresse IP du scanneur, l'adresse IP de la machine scannée et le ou les ports ouverts sur la machine. On commence donc par ouvrir Wireshark et à retrouver les hôtes présents dans ce fichier. Pour cela, rendez-vous dans le menu Statistics -> Endpoints :
Comme on peut le voir, nous avons quatre hôtes à disposition. Analysons maintenant les flux TCP contenus dans la capture. Pour cela, menu Statistics -> Flow Graph :
Comme on peut le voir ici, seules trois IPs communiquent entre elles. La plupart des sessions TCP sont directement fermées après ouverture, il semble donc que le port est seulement "testé" sans être réellement utilisé. Cependant, les connexions s'établissent toujours entre 158.210.207.187 <-> 158.210.207.253 <-> 158.210.207.27, mais jamais directement entre 158.210.207.187 <-> 158.210.207.27. L'hôte du milieu sert donc d'intermédiaire entre ces deux hôtes.
En recherchant dans la documentation de Nmap, on peut trouver une référence à un scan mettant en scène trois hôtes : le Idle scan.
Le fonctionnement basique du Idle (ou Zombie) scan est le suivant :
- Nmap sonde le zombie pour vérifier que l'IP ID est bien incrémentiel.
- Nmap envoie un paquet SYN sur la machine à scanner en utilisant l'adresse IP du zombie
- Si le port est ouvert, la machine scannée envoie un SYN-ACK au zombie. Ce dernier envoie alors un RST avec un IP ID incrémenté
- Si le port est fermé, la machine scannée envoie un paquet RST.
- Nmap ouvre alors une nouvelle session sur le zombie et vérifie l'IP ID.
- S'il est incrémenté de un par rapport au précédent check, le port est fermé
- S'il est ouvert, l'IP ID aura incrémenté de deux, le port sera alors considéré comme ouvert
Il suffit alors de trouver les ports scannés et qui ont répondu par un SYN-ACK sur la machine scannée après les vérifications de Nmap. Un seul paquet correspond à cela : le paquet N° 28 :
La réponse est donc : 158.210.207.187 scanne 158.210.207.27. Le seul port ouvert est le 48922.
Paranoïa
Le but de cette épreuve est de retrouver un mot de passe disséminé au travers de plusieurs protocoles réseau.
*********************
Après avoir ouvert le fichier pcap, une grande série de paquets est affichée. Le challenge consiste ici à décoder correctement chaque communication pour en extraire le contenu. La difficulté provient du fait que les ports ont été mélangés afin que Wireshark ne décode pas automatiquement les paquets
Premier caractère : Telnet
Les paquets N° 312 à 328 contiennent une session Telnet. Il n'est pas nécessaire de décoder le protocole, un simple clic droit -> Follow TCP stream donne la réponse :
Deuxième caractère : DNS
Les paquets N° 1 et 2 contiennent une requête et une réponse DNS. Bien qu'il soit possible de lire la réponse dans le paquet, son décodage nous indique la réponse correcte :
Troisième caractère : TFTP
Les paquets 355 à 357 contiennent un échange de fichier par TFTP. Le fichier envoyé par le serveur est contenu dans les deux derniers paquets. Un follow UDP stream permet d'afficher la communication, d'en sélectionner une partie et d'enregistrer le payload permettant de récupérer le fichier zip.
Quatrième caractère : HTTP
Les paquets 293 à 304 contiennent un échange HTTP, reconnaissable à la requête envoyée. A nouveau, il est possible d'extraire l'image à l'aide d'un Show TCP Stream -> Save as et de supprimer l'en-tête HTTP de la réponse
Cinquième caractère : RTP
Les paquets 7 à 291 contiennent une conversation VoIP. la session SIP à volontairement été laissée dans la capture pour déterminer le protocole de transport utilisé. Il suffit alors de faire un clic droit -> Decode as sur un paquet et de sélectionner RTP pour avoir la conversation correctement vue par Wireshark. Un petit tour dans le menu Telephony -> RTP -> Stream analysis permet alors de sauvegarder la conversation sous forme de fichier audio pouvant être écouté
Sixième caractère : MySQL
Les paquets 329 à 354 contiennent Une transaction MySQL. En décodant la dernière réponse à la requête SELECT SUBSTR(password,6,1) FROM users du paquet N° 353, il est possible de lire la réponse :
La réponse finale est donc Tpp58i
Suisse (HQ)
SCRT Information Security
Le Trési 6C
1028 Préverenges (Lausanne)
Plan d'accès
T +41 21 802 64 01
F +41 21 802 64 02
France
SCRT Information Security
20 bis, rue Louis Philippe
92200 Neuilly-sur-Seine
T +33 1 77 69 64 40