Retour sur le Hackathon de ce weekend !

Petit retour sur le Hackhathon organisé par le conseil général du Calvados pendant que c’est encore chaud.

L’équipe

Tout d’abord nous souhaiterions remercier toutes les personnes qui nous ont aidé à réaliser l’équipe et qui nous ont soutenu durant cette aventure incroyable.
L’équipe qui a participé et avec laquelle nous avons pris énormément de plaisir est la suivante :

  • Etienne Oriez – Communication/Marketing
  • Thomas Guesnon – Graphiste/designer d’interface
  • Paul Martin – Technicien SIG / Algorithmique
  • Pierre Leger – Développeur Android / Réseau
  • Julien Hatin – Développeur Android/ gestion de projet

Vous pouvez retrouver le site de Thomas Guesnon à cette adresse : http://www.uneverstealentour.com. Félicitation, tu as été magistral tout le week end.

Le but de ce hackathon était de créer un prototype d’application Android sur le thème du 70ème anniversaire du débarquement et en s’intégrant la problématique du tourisme numérique.

Déroulement du hackathon

Un petit résumé est disponible sur le blog du rond point du numérique : Rapport de l’opération 70thBDayHACKATHON

De notre point de vue (Pierre et Julien), cet évènement a été particulièrement réussi. Il faut dire que les M&ms gratuits et à volonté ont largement participé à la réussite de cet évènement. L’organisation avait vu les choses en grand puisque nous avons été chouchouté tout le week end. Après l’étape importante du choix du nom de l’équipe nous avons finalement retenu : « Bonjour Messieurs »

BFfQ1g7CAAIApUr

Du café aux plateaux repas, tout était apporté à notre table de travail. Ce qui nous a permis de travailler sans relâche durant ces deux jours. Le plus intéressant mais aussi le plus difficile a été de faire cohabiter les différents profils.

Le prototype

L’objectif de ce hackathon est de créer un prototype d’application android sur la thématique du 70 ème anniversaire du Débarquement et de la Bataille de Normandie. Plus d’information dans le PDF qui nous a été transmis Guide-Hackathon-2013.

Nous avons donc réalisé un prototype en 2 jours. Voici la vidéo (réalisé par Thomas) présentant notre prototype du weekend :

OVERSIMPLE : Hackathon du 70ème anniversaire du… par oversimple

On remercie l’ensemble de l’organisation car l’évènement était super !

Plus d’informations sur :
https://twitter.com/rondpointnum
Rapport de l’opération 70thBDayHACKATHON
Le journal du 70thBDayHACKATHON en tweets

Alarme de maison avec un raspberry pi

raspberry-ban

J’ai un ami qui souhaite vérifier que personne n’entre chez lui quand il n’est pas là. Ceci peut être intéressant pour Dexter mais aussi en cas de propriétaire invasif. Afin de contrôler les allers et venues dans son appartement, nous avons eu l’idée de prendre en photo avec une webcam toutes les personnes qui passent la porte. Les photos pourront ensuite être envoyées par mail ou bien sur une interface web.

Mise en place d’un système de sécurité

Un système de sécurité est composé de capteurs. L’ensemble des capteurs permet de détecter une présence. On va retrouver des capteurs sur les portes et fenêtres qui permettent de savoir si celles ci sont ouvertes. On peut aussi trouver des capteurs de mouvement. Dans notre cas, nous souhaitons utiliser un capteur permettant de détecter l’ouverture d’une porte. Celui ci a été récupéré dans le vieux carton d’un projet de technologie réalisé en 4ième.

capteur

Ce capteur va alors être relié à un GPIO du raspberry pi. Il faudra ensuite prendre une photographie en direction de la porte d’entrée sur laquelle le capteur sera placé. On aurait tout aussi bien pu activer un buzzer.

Partie hardware

le capteur fonctionne avec un commun et une sortie normalement ouvert et normalement fermé. L’idée est de relier ce capteur à un GPIO du raspberry pi afin que l’on détecte sur le GPIO :

  • Un état haut (3.3V) si la porte est fermé
  • Un état bas (0V) si la porte est ouverte

Nous obtenons le câblage suivant :

cablage

Afin de s’assurer que la sortie est à l’état bas lorsque la porte est ouverte nous utiliserons une résistance de pulldown.
pour réaliser ce montage nous utilisons un connecteur au pas de 2.54 ainsi qu’un petit domino et nous obtenons le montage suivant, qui se fixe simplement sur le raspberry pi :

pontRasp

Il faut maintenant détecter le niveau de la pin GPIO22. Pour cela nous allons utiliser, une librairie C conçue pour piloter nos GPIO.

Librairie C pour le BCM 2835

La librairie que nous utilisons est disponible ici : librairie

Sur le raspberry pi, ouvrez un shell :

$ wget http://www.open.com.au/mikem/bcm2835/bcm2835-1.17.tar.gz
$ tar zxvf bcm2835-1.17.tar.gz
$ cd bcm2835-1.17
$ ./configure
$ make
$ sudo make check
$ sudo make install

La librairie est maintenant installée.
Les noms des GPIO sont ceux décrit en orange dans l’image ci dessus. Il sont nommés de RPI_GPIO_P1_01 à RPI_GPIO_P1_26. Et ils correspondent aux 26 broches de sorties. Cependant, ils ne correspondent pas aux sorties que vous pouvez utiliser via le système de fichier. Le GPIO22 que nous allons utiliser est ainsi appelé RPI_GPIO_P1_15.

Sur le site de la librairie nous trouvons directement un exemple que nous allons réutiliser dans notre projet. Si vous souhaitez repartir de la source originale, elle se trouve ici : source
Pour détecter le niveau de sortie du GPIO22, nous utilisons le code C suivant:

//input.c
#include <bcm2835.h>
#include <stdio.h>
// Input sur le GPIO22 qui est nommé 15 dans le système de la librairie
#define PIN RPI_GPIO_P1_15
 
int main(int argc, char ** argv) {
    if (!bcm2835_init()) {
        return 1;
   }
    // Fixe le GPIO en entrée
    bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_INPT);
    //  avec une résistance de pull down
    bcm2835_gpio_set_pud(PIN, BCM2835_GPIO_PUD_DOWN);
 
    while (1) {
        // lecture du niveau d'entrée
        uint8_t value = bcm2835_gpio_lev(PIN);
        printf("lecture GPIO22: %d\n", value);
 
        // attendre 2s
        delay(2000);
    }
    //Un brin de toilette
    bcm2835_close();
    return 0;
}

Compilons et lançons le programme et amusons nous à déplacer le capteur (équivalent à ouvrir et fermer la porte) :

$ gcc input.c -l rt -l bcm2835 -o input
$ sudo ./input
lecture GPIO22: 1
lecture GPIO22: 1
lecture GPIO22: 0
lecture GPIO22: 0
lecture GPIO22: 1

Photographie avec la webcam

Afin de photographier l’entrée, nous allons réutiliser la librairie openCV. Celle ci avez déjà été utilisé à Halloween pour réaliser un capteur de mouvement avec une webcam. Je vous invite à lire l’article suivant pour l’installation et la programmation : Halloween project

Pour ce qui est de l’installation, elle est faite directement depuis les dépôts.

$ sudo apt-get install libcv-dev libcvaux-dev libhighgui-dev

Le code complet est disponible en annexe.

Envoi par mail et interface graphique

L’envoi par mail et l’interface graphique sont codés en php. Les appels entre les deux langages se font soit via la commande system, soit via des pipes nommées.

Et l’interface web donne:

screenShot

Conclusion

Vous pouvez remplacer le capteur par un détecteur de mouvement. N’hésitez pas à nous contacter si vous souhaitez en savoir d’avantage ou avez d’autres idées saugrenues.

It’s oversimple isn’t it?

Espionner une transaction Monéo

La carte Monéo

La carte Monéo est un porte monnaie électronique. La spécificité d’un porte monnaie électronique est que l’argent n’est pas présent directement sur la carte.

Pour la Monéo, il est nécessaire de présenter votre carte bancaire. Une transaction est effectuée de la même manière que si vous retiriez de l’argent en liquide. Cet argent est alors inscrit sur la carte Monéo. Monéo propose un service de chargement en ligne. Nous allons en profiter pour observer la manière dont fonctionne le chargement d’une telle carte.

L’espion de carte à puce

L’espion fonctionne à partir d’un microprocesseur Microchip PIC32MX512L. Pour plus de détails sur le développement :

Le protocole ISO7816 a été implémenté afin de pouvoir obtenir des traces qui ressemblent à ceci :

T=1:

ATR : 3BE800008131FE454A434F505632343194
Term (S-block):
00C101 FC 3C
Card (S-block):
00E101 FC 1C
Term (I-block):
00000C 00A4040007A0000000041010 0F
Card (I-block):
000025 6F218407A0000000041010A516500A4F56455253494D504C45BF0C07636172647370799000 C3
Term (I-block):
004005 00C0000041 C4

T=0:

ATR : 3B 66 00 00 90 D1 02 01 20 B1 
Term (CLA INS P1 P2 P3):
00 A4 04 0C 06 
Card (Ack):
A4 
Term (UDC):
A00000006900
Card (SW): 
9000
Term (CLA INS P1 P2 P3):
00 B2 01 BC 16
Card (ACK UDR SW): 
B2 9250003840106021502D15091207010250455552011C 9000

Le chargement Monéo

A l’aide de l’espion, nous observons un chargement de Monéo de dix euros effectué sur internet.

Celui ci se décompose en deux parties, la première partie est une lecture des informations de la carte, numéro de PAN, solde etc…

Ensuite un série de commandes est exécutée de cla E0 et d’instructions 30.
La classe E0 nous indique alors qu’il s’agit d’une carte supportant jusqu’à 16 canaux logiques (16 pointeurs de fichier) et que la commande inclus du Secure Messaging.

Edition après le commentaire de SV :

Une petite remarque en passant: CLA = E0 signifie surtout que le bit de poids fort est à 1 donc l’instruction (et la classe) sont propriétaires. La norme ISO/IEC 7816 ne s’applique donc pas pour interpréter l’octet CLA (en particulier les 16 canaux).

Autrement dit, le chargement est protégé par un calcul de MAC. Le mac faisant 8 octets de long, on peut vraisemblablement penser à du 3-DES.

Term (CLA INS P1 P2 P3):
E0 30 00 00 1C 
Card (ACK):
30 
Term (UDC):
00000000001000000000000000007001070600018820121121192244
Card (SW)
6139 
Term (CLA INS P1 P2 P3):
00 C0 00 00 39 
Card (ACK UDR SW):
C0 010005010010000021108888866666001000315D110004010010000100000030000000000000000000000000000000000DCE86FF2230D6A91B 9000
Term (CLA INS P1 P2 P3):
E0 30 80 00 35
Card (ACK):
30 
Term (UDC):
10000501001000250001700107060000000000018820121121192244010000003000000000000000000000000DAE7D69BE5F4394EA 
Card (UDR):
610D 
Term (CLA INS P1 P2 P3):
00 C0 00 00 0D 
Card (ACK UDR SW):
C0 11000501001000003110000000 9000

Conclusion

On retrouve dans la dernière UDC la date de la transaction ainsi que le montant. La sécurité du mécanisme repose la génération des macs par le serveur. Ceci est un système sécurisé à condition que les algorithmes cryptographiques soient correctement implémentés.

Désassembler une application Android (complément)

android

Cet article est un complément de celui de Julien.

Partons d’un APK Crackme01.apk. Le fichier est disponible ici.

Voici à quoi ressemble le Crack Me :
capture1Presentation

Deux methodes existent pour reverser une application android :

  1. La première avec dex2jar et jd-gui, cette méthode permet d’obtenir quasiment le code original, facile à analyser du code java et simple d’utilisation.Cependant avec cette méthode on ne peut pas modifier le code java (.class), nos ressources sont présentes sous la forme numérique uniquement dans les findviewbyid, par exemple.
  2. La seconde avec smali(assembleur) et baksmali(desassembleur), on retrouve ces outils dans apktool (d pour desassembler, b pour assembler).Lorsque l’on désassemble on obtient un code source smali, et on peut le réassembler. Une bible pour le code smali est présente ici : http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html

 

Le but de ce crackme est de trouver le mot de passe pour la méthode 1.
Dans la seconde méthode, on ajoute un message rapide (Toasts) « Simple, non ? »

Methode 1 : Dex2jar et JD-GUI

On décompresse notre archive ZIP :

$ unzip Crackme01.apk 
Archive:  Crackme01.apk
  inflating: res/layout/activity_crack_me01.xml  
  inflating: res/menu/activity_crack_me01.xml  
  inflating: AndroidManifest.xml     
 extracting: resources.arsc          
 extracting: res/drawable-hdpi/ic_launcher.png  
 extracting: res/drawable-ldpi/ic_launcher.png  
 extracting: res/drawable-mdpi/ic_launcher.png  
 extracting: res/drawable-xhdpi/ic_launcher.png  
  inflating: classes.dex             
  inflating: META-INF/MANIFEST.MF    
  inflating: META-INF/CERT.SF        
  inflating: META-INF/CERT.RSA

Avant de continuer, on est obligé de vous parler de la machine Dalvik. Cette machine dalvik est une machine virtuelle utilisée par Android. Elle a été développée par Google pour ne pas utiliser la JVM. La différence notable avec la JVM est la gestion du registre. Pour la JVM, la gestion est basée sur la pile contrairement à la machine Dalvik qui est illimitée. Cette machine utilise un fichier .dex qui est le regroupement de l’ensemble des classes JAVA compilées.

Obtenons un jar de notre fichier .dex :
$ dex2jar classes.dex
dex2jar classes.dex -> classes-dex2jar.jar

Utilisons JD-GUI, afin de voir nos fichiers .class qui sont présents dans l’archive .JAR
jd-gui classes-dex2jar.jarjd-gui

Dans le fichier Crackme01.class on peut voir la ligne suivante :
final EditText localEditText = (EditText)findViewById(2131165185);

Cette ligne fait référence a un id, qui a pour intitulé motDePasse comme on peut le voir dans le fichier R.class :
public static final int motDePasse = 2131165185;

C’est l’EditText qui est utilisé pour saisir notre mot de passe.

On retourne dans le fichier Crackme01.class :

if ((localEditText.getText().toString() != null) &amp;&amp; (localEditText.getText().toString().equals("oversimple")))
          localToast.setText(2130968580);

On voit que l’on compare notre EditText avec une chaîne de caractère « oversimple ». Cette chaine de caractère « oversimple » est notre mot de passe.

Méthode 2 : Smali & backsmali

Pour la deuxieme méthode avec smali et backsmali, on utilisera apktool qui contient un ensemble d’outils. De plus, celui ci est simple d’utilisation alors pourquoi s’en priver ?

On décompile notre APK.

$ apktool d Crackme01.apk reverseCrackme01/
I: Baksmaling...
I: Loading resource table...
I: Loaded.
I: Decoding AndroidManifest.xml with resources...
I: Loading resource table from file: /home/pierre/apktool/framework/1.apk
I: Loaded.
I: Regular manifest package...
I: Decoding file-resources...
I: Decoding values */* XMLs...
I: Done.
I: Copying assets and libs...

On obtient un répertoire reverseCrackme01 :

$ cd reverseCrackme01/
$ ls   
AndroidManifest.xml  apktool.yml  res  smali

La premiere chose a regarder est le Manifest :

$ cat AndroidManifest.xml 
<!--?xml version="1.0" encoding="utf-8"?-->

On peut voir que notre main est le fichier CrackMe01 car celui-ci possède les intents nécessaires (MAIN et LAUNCHER)

Regardons maintenant les fichiers avec le code source smali :

$ ls smali/fr/oversimple/crackme01/
BuildConfig.smali  CrackMe01$1.smali  CrackMe01.smali  R$attr.smali  R$drawable.smali  R$id.smali  R$layout.smali  R$menu.smali  R$string.smali  R$style.smali  R.smali

Si on regarde dans le fichier CrackMe01\$1.smali, on peut voir la méthode onClick. Cette méthode correspond à un clic sur le bouton « Valider ». Voici un bref aperçu du code smali :

invoke-interface {v0}, Landroid/text/Editable;-&gt;toString()Ljava/lang/String;
move-result-object v0
const-string v1, "oversimple"
invoke-virtual {v0, v1}, Ljava/lang/String;-&gt;equals(Ljava/lang/Object;)Z
move-result v0

Ce bout de code permet de comparer notre mot de passe « oversimple » avec notre EditText(dans le but de simplifier, on affiche uniquement le retour du toString)

Et le test de comparaison final :

if-eqz v0, :cond_0
 
.line 29
iget-object v0, p0, Lfr/oversimple/crackme01/CrackMe01$1;-&gt;val$toast:Landroid/widget/Toast;
const v1, 0x7f040004
invoke-virtual {v0, v1}, Landroid/widget/Toast;-&gt;setText(I)V
 
.line 33
:goto_0
iget-object v0, p0, Lfr/oversimple/crackme01/CrackMe01$1;-&gt;val$toast:Landroid/widget/Toast;
invoke-virtual {v0}, Landroid/widget/Toast;-&gt;show()V
 
.line 34
return-void
 
.line 31
:cond_0
iget-object v0, p0, Lfr/oversimple/crackme01/CrackMe01$1;-&gt;val$toast:Landroid/widget/Toast;
const v1, 0x7f040005
invoke-virtual {v0, v1}, Landroid/widget/Toast;-&gt;setText(I)V
goto :goto_0

Si l’instruction if-eqz est égale à 0 alors nous allons à la condition cond_0. sinon on continue la suite donc .line 29.
Pour information, les valeurs qui nous intéressent se trouvent dans le fichier R$string.smali :
.field public static final ok:I = 0x7f040004
.field public static final ko:I = 0x7f040005

Le but de la deuxième méthode n’étant pas forcement de voir le mot de passe mais d’ajouter un message au démarrage de l’application.

Dans le fichier CrackMe01.smali, ligne 37 et après nous avons :

const-string v4, ""
 
const/4 v5, 0x1
 
invoke-static {v3, v4, v5}, Landroid/widget/Toast;-&gt;makeText(Landroid/content/Context;Ljava/lang/CharSequence;I)Landroid/widget/Toast;
 
move-result-object v1

Nous souhaitons juste ajouter notre message, donc à la place de «  » mettons : « Simple, non ? » et appelons la méthode afin de le rendre visible :
invoke-virtual {v1}, Landroid/widget/Toast;->show()V

Ce qui donne :

const-string v4, "Simple, non ?"
 
const/4 v5, 0x1
 
invoke-static {v3, v4, v5}, Landroid/widget/Toast;-&gt;makeText(Landroid/content/Context;Ljava/lang/CharSequence;I)Landroid/widget/Toast;
 
move-result-object v1
 
invoke-virtual {v1}, Landroid/widget/Toast;-&gt;show()V

On reconstruit l’application avec apktool b, il faut se placer dans le répertoire racineCrackme01 (ou ce trouve le fichier apktool.yml)

$ apktool b 
I: Checking whether sources has changed...
I: Smaling...
I: Checking whether resources has changed...
I: Building resources...
I: Building apk file...

Un nouveau repertoire apparait dist/

On crée une clé afin de signer notre application :
keytool -genkey -v -keystore oversimple.keystore -alias oversimple -keyalg RSA -validity 25000

Une fois la clé créée, on signe notre application :
jarsigner -digestalg SHA1 -sigalg MD5withRSA -verbose -keystore oversimple.keystore dist/Crackme01.apk oversimple

Notre apk est signée de source inconnu.

On envoie notre apk :

adb install dist/Crackme01.apk 
978 KB/s (184902 bytes in 0.184s)
	pkg: /data/local/tmp/Crackme01.apk
Success

Un article suivant présentera les commandes utiles de ADB.

Résultat au démarrage de notre APK :

resultatFinal

Conclusion

Pour cette introduction au reverse d’application Android, rien de bien difficile, plusieurs articles en tête, notammennt un article sur les commandes adb et les pouvoirs de cette commande 😉

Sources

dex2jar : http://code.google.com/p/dex2jar/
jd-gui : http://java.decompiler.free.fr/?q=jdgui
apktool : http://code.google.com/p/android-apktool/

It’s oversimple isn’t it?

Cross compilation avec un raspberry pi

raspberry-ban

Qu’est ce qu’un cross compiler?

Un cross compiler est une chaîne de compilation qui tourne sur une architecture mais qui génère un exécutable binaire pour une autre plate forme.

Avec notre raspberry pi, s’il est assez simple de compiler un code de petite taille,il devient très difficile de compiler de gros programmes.

Enfin, il est beaucoup plus agréable de compiler sur votre machine de guerre vos fichiers en une fraction de seconde que d’attendre une minute entre chaque retouche du code compilé par le petit processeur du raspeberry pi.

NOTE : Afin de fonctionner correctement, il est nécessaire d’utiliser une distribution utilisant le hard-float ABI. Ceci est le cas de la raspian et de la dernière version de d’arch pour le raspberry.

Le jeu d’instruction

Chaque processeur utilise son propre jeu d’instructions. Celui ci correspond au jeu d’instructions assembleur. Ce jeu d’instructions est dépendant de l’architecture du microprocesseur. Il dépend directement de la manière dont sont gravé les circuits en silicium.
L’article suivant en anglais explique le fonctionnement des portes logiques que l’on peut trouver dans un microcprocesseur : Article

247x180xQuiz-Silicon-ARM-247x180.jpg.pagespeed.ic.0dZq6IhOZ8

Le jeu d’instructions supporté par les pc et qui est bien connu des reverser est le x86 qui correspond aux architectures Intel. Pour les AMD, c’est assez simple, c’est le même jeu d’instructions. Donc lorsqu’un code, par exemple du C, est compilé pour votre PC, il génère un assembleur x86 qui correspond à des instructions propres aux processeurs Intel et AMD.
Le problème c’est que le processeur présent sur le raspberry pi est un processeur ARM : 700 MHz ARM11 ARM1176JZF-S

Nous allons donc utiliser une chaîne de compilation qui générera un binaire pour le ARM1176JZF-S. Pour cela nous allons utiliser l’outil crosstool-ng.

Installation de crosstool-ng

Crosstool-ng est un outil permettant de construire des chaînes de compilation pour des plate-formes données.
Pour installer crosstool :

$ wget http://crosstool-ng.org/download/crosstool-ng/crosstool-ng-1.17.0.tar.bz2
$ tar xjf crosstool-ng-1.17.0.tar.bz2
$ cd crosstool-ng-1.17.0/
$ sudo ./configure --prefix=/opt/crosstool
$ make
$ sudo make install

J’ai du installer quelques programmes supplémentaires. Le script configuré indique ce qu’il manque. Dans tous les cas, n’hésitez pas à poster dans les commentaires si vous avez besoin de plus d’informations.

Réaliser la chaîne de compilation pour le raspberry pi

Il va falloir créer un répertoire dans lequel crosstool-ng va enregistrer votre chaîne de configuration.

  • Créer un répertoire pour héberger votre chaîne de compilation
  • Lancer /opt/crosstool/bin/ct-ng menuconfig

Le menu suivant apparaît:
menuconfig

  • Dans Path and misc options cocher Try features marked as EXPERIMENTAL (touche Y)
  • Toujours dans Path and misc options Changer Shell to use as CONFIG SHELL et choisir sh
  • Revenir au menu principal et sélectionner Target options
    • Target architecture : ARM
    • Endianess : little endian
    • Bitness : 32 bits
  • Revenir au menu principal et sélectionner Operating system
  • Choisir Target OS linux
  • Revenir au menu principal et sélectionner Binary utilities
  • Changer binutils version pour la 2.21.1a
  • Revenir au menu principal et sélectionner C compiler
  • Cocher Show Linaro versions (EXPERIMENTAL) (touche Y)
  • Choisir linaro-4.6-2012.04 (EXPERIMENTAL)
  • Quitter et sauvegarder les changements

Cross compilons

La compilation s’effectue alors de la manière suivante :

$ ~/x-tools/arm-unknown-linux-gnueabi/bin/arm-unknown-linux-gnueabi-gcc helloWorld.c -o helloWord
$ ls
helloWord  helloWorld.c
$ scp helloWorld pi@192.168.1.107:helloWorld
pi@192.168.1.107's password: 
helloWord                                     100% 4985     4.9KB/s   00:00

On l’execute maintenant sur le raspeberry pi :

$ ssh pi@192.168.1.107
pi@192.168.1.107's password: 
Linux raspberrypi 3.2.27+ #250 PREEMPT Thu Oct 18 19:03:02 BST 2012 armv6l
 
The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.
 
Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Sun Jan 13 13:33:49 2013 from 192.168.1.100
pi@raspberrypi ~ $ ./helloWorld 
Oversimple says hello!

Conclusion

On remarque qu’il est relativement difficile de monter une chaîne de compilation pour un processeur ARM et surtout assez long. La réalisation de la chaîne à pris presque une heure chez moi. Cependant, il devient très vite quasi indispensable de le faire si vous souhaitez développer sur le raspberry.
La conception et la compilation de gros projets devient donc plus simple. A titre d’information, les kernels que l’on récupère sur le site du projet raspberry sont compilé de cette manière.

Source :
helloWorld.c

Décompiler une application android

android

On trouve de nombreux malwares sous android. Ceux ci utilisent généralement des applications payantes crackées pour se diffuser.

Nous allons aujourd’hui voir comment décompiler et visualiser une apk.
Pour cela nous allons utiliser deux outils :

  • JD-GUI
  • dex2jar

La machine de Dalvik

La machine de Dalvik est une machine virtuelle présente sur les téléphones android. Elle est très proche d’une JVM.
D’après Wikipédia, « Un outil appelé dx est utilisé pour convertir quelques .class Java en .dex ».
Si on ouvre un apk avec gestionnaire d’archive on obtient quelque chose comme ça :

archiveAPK

Le fichier classe.dex est celui que nous allons décompiler.

dex2jar

Le logiciel dex2jar est téléchargeable à l’adresse suivante : http://code.google.com/p/dex2jar/downloads/list

Pour l’utiliser il suffit de décompresser le fichier et pour l’utiliser :

$ ./dex2jar.sh classes.dex

On obtient alors un fichier jar. Pour visualiser le .jar, utilisons le logiciel JD-GUI.

JD-GUI

Le logiciel JD-GUI permet d’afficher les fichiers d’un .jar. Les fichiers .class sont alors affichés d’une manière user friendly.

DecompAPK

Conclusion

Il est tellement simple d’observer le contenu d’un apk qu’il serait stupide de s’en passer. Si vous souhaitez en savoir plus sur le langage utilisé par la machine de Dalvik, je vous recommande l’article suivant de Virtualabs :
http://virtualabs.fr/Reversing-d-applications-Android

It’s oversimple isn’t it?

Eclipse et le plugin git (egit) pour Linux et Windows

Dans les articles précédents je vous avais parlé de git et afin de le securiser avec gitolite.

Installation du plugin EGIT

Si on désire utiliser git avec eclipse, il nous faut le plugin EGIT présent ici : Site d’information sur egit

Si on regarde sur ce site, on peut avoir le répertoire afin de télécharger egit via Eclipse :
On ajoute le lien puis on sélectionne EGIT (http://download.eclipse.org/egit/updates).


On clique sur suivant et on lance l’installation.
Une fois l’installation terminée, on rédémarre et nous voila avec le plugin EGIT.

Configuration du plugin

La configuration du fichier pour ssh est utile uniquement si vous souhaitez avec votre clé privée (notamment pour utiliser avec gitolite)

Pour rappel des articles précédents, j’ai configuré dans mon fichier de configuration ssh (~/.ssh/config) de la manière suivante :

host gitolite
    user git 
    hostname monServeur
    port 22
    identityfile ~/.ssh/pierre

Pour Windows, c’est le même principe dans mon cas : C:\Users\pierre\.ssh (pierre étant mon utilisateur)

De plus, On peut aussi configurer le fichier .gitconfig (windows : C:\Users\pierre\.gitconfig, linux : ~/.gitconfig) :

$ cat ~/.gitconfig
[color]
        diff = auto
        status = auto
        branch = auto
[user]
        name = Pierre
        email = pierre@oversimple.fr

Plus d’informations sur les configurations ssh et gitconfig dans la catégorie git ici

Importer un projet

Importons un projet GIT avec notre plugin EGIT.

Pour cela File > Import > Projects from Git :

On sélectionne URI car notre répertoire est distant.

Explication de la configuration :
URI : On ne saisit rien par défaut.
Host : On saisit gitolite car cela fait référence à ma configuration du .ssh/config
Repository path : le nom de notre répertoire sur git.
Protocol SSH.

De cette manière la ligne est automatiquement créée pour le champ URI.

Après on choisit la branche sur lequel on doit travailler. Dans mon cas je n’ai qu’une branche Master. Je clique sur Next, afin de configurer mon répertoire Local.

Maintenant au travail…

De cette manière, nous avons les outils nécessaires pour travailler en équipe lorsque l’on fait un clic droit sur notre projet où un fichier de notre projet on obtient Team.

Voici les informations disponibles :

It’s oversimple isn’t it?