C’est hier, samedi 18 juin 2011 que se déroulait la Nuit du Hack 2011. 22 heures et 30 minutes de conférences et ateliers axés sur les techniques de hacking même non numériques tels que le crochetage de serrures…

Nuit du Hack 2011

Je vous invite à aller sur le site de la Nuit du Hack pour connaître le détail du programme et vous faire une idée des sujets de hacking du moment.

Personnellement j’ai du quitter cet évènement dimanche vers 1h00 du matin car je devais courir aux 10km L’Équipe à Paris (couru en 00:51:47, je visais 00:48:00)…

Les ateliers ainsi que le concours de hacking ont débuté avec des sujets très intéressants et passionnants :

• Concours de hacking de type capture de flag : attaques d’ennemis et défenses de son réseau
• Etude d’un test d’intrusion via Metasploit
• Electronique programmable et systèmes libres
• Atelier d’initiation à la cryptographie et l’utilisation des GPUs
• Initiation ARM pour plateforme mobile
• Crochetage basique, serrure haut sécurité, Impression
• etc…

Le motif de conception Singleton est l’un des plus simple a maîtriser. Mais lorsqu’il s’agit d’accès concurrentiel dans un programme, les implémentations classiques ne suffisent plus. Il faut garder à l’esprit que les architectures multiprocesseurs ont plusieurs caches souvent asynchrones « write-back » par opposition à « write-through » pour synchrone (rare car moins performant).

Un singleton moderne devrait implémenter les notions suivantes :

• Double-Checked Locking, double contrôle
• Mutex, accès exclusif
• Memory barrier, Clôture de mémoire à la compilation (intègre parfois la synchronisation au niveau du matériel)
• LFENCE/MFENCE/SFENCE, Synchronise la mémoire matériel

Qu’est ce qu’un Singleton ? En programmation un Singleton est un objet dont on veut garantir qu’une seule instance vit pendant l’exécution du programme. Imaginez un système d’exploitation qui aurait deux instances de son système de fichier !!! C’est le boxon assuré.

Voici mon implémentation en cplusplus (code source d’exemple) :

//singleton.h
#ifndef __SINGLETON_H_
#define __SINGLETON_H_

#include <cstdlib> //std::atexit()

#define MFENCE			"memory_fence"
#define MUTEX_LOCK		"lock"
#define MUTEX_UNLOCK	"unlock"
#define MEMORY_READWRITE_BARRIER	"memory_barrier"

template <typename T>
class Singleton
{
public:
	static T& instance()
	{
		return *get_instance();
	}

	static const T& const_instance()
	{
		return *get_instance();
	}

	static void destroy()
	{
		MFENCE; //On s'assure que tous les caches processeurs sont à niveau
		if (pInstance_ != 0)
			delete pInstance_;
	}

protected:
	Singleton(){}
	~Singleton()
	{
		pInstance_ = 0;
		created_ = false;
	}

private:
	static T* pInstance_;
	static volatile bool created_;
	Singleton(const Singleton &);
	Singleton& operator= (const Singleton &);

	static T* get_instance()
	{
		if (created_ == false)
		{
			MUTEX_LOCK; //On s'assure qu'un seul thread a la main
			if (pInstance_ == 0)
			{
				pInstance_ = new T();
				std::atexit(Singleton::destroy);
			}
			MUTEX_UNLOCK;
			MEMORY_READWRITE_BARRIER; //On s'assure que le compilateur ne change pas l'ordre de ces 2 instructions
			created_ = true;
			MFENCE; //On s'assure que tous les caches processeurs sont à niveau
		}
		return pInstance_;
	}
};

template<typename T> T* Singleton<T>::pInstance_ = 0;
template<typename T> volatile bool Singleton<T>::created_ = false;

#endif//!__SINGLETON_H_

Notons que pour les mutexes, les meilleures implémentations permettent aussi, en plus d’être dans une zone synchrone, de réaliser l’équilant de [SLM]FENCE (PIII : SFENCE – P4 : LFENCE, MFENCE). Pour ce qui est de l’annulation de l’ordre des instructions par le compilateur, je ne vois rien d’autres que d’utiliser une librairie qui fournit des MACROS adaptés aux différents compilateurs et plateformes.

Cette année 2010 est passée à une vitesse telle que je n’ai pas testé grand chose…

Néanmoins dans mes nouvelles résolutions pour 2011 :

• C++0X
• Go (Google)
• Ruby (Rails 3)
• Python 3
• Java (GWT 2)

Meilleurs vœux 2011 !!!

Vous avez sans doute entendu parler de la Google Dance (mécanisme d’indexation du moteur de recherche de Google) réalisé une ou deux fois par mois ? Et bien depuis MapReduce (août 2004), la Google Dance « Powered by MapReduce » est du quasi temps réel ; Google Maps, Microsoft Bing, Facebook, Twitter etc… C’est encore du « MapReduce Inside ».

MapReduce est un modèle de programmation vulgarisé par les ingénieurs de Google, Jeffrey Dean et Sanjay Ghemawat. L’idée de MapReduce est relativement simple, traiter d’énormes volumes de données sur une architecture distribuée, parallèle et/ou multiprocesseur.

Je ne vais pas, encore une fois, reproduire les multiples exemples qu’on trouve sur le sujet, mais je me devais de faire passer le message. Pour ceux que cela intéresse, voici quelques liens :

• Présentation des recherches de Google sur MapReduce
• Hadoop : implémentation open source de MapReduce.
• MapReduce.org

Il va de soi que nous sommes déjà dans une ère où le volume de donnée à traiter devient colossal pour nos systèmes d’informations. Les machines sont quasiment toutes multiprocesseurs, nous devons adapter nos programmes pour utiliser toutes la puissance du matériel. Cela nécessite une complexité supplémentaire dans les programmes qui doivent être concurrents tout en en étant fiable. Concrètement utiliser des modèles de programmation tels que MapReduce, Threadpool etc… sont une nécessité dès à présent.

Le créateur du langage C++, Bjarne Stroustrup, décrit depuis son site internet les nouvelles fonctions qui intégrerons la future version du langage actuellement encore en version draft.
Cette version est bien avancée, puisque disponible sur les compilateurs les plus importants (GCC, MSVC, etc…).

Parmi les fonctionnalités que j’attends le plus :

• Les threads
• Les opérations atomiques
• Les expressions lambdas
• Les listes d’initialisation
• Construction et destruction dynamiques, concurrentiels d’un objet
• Paramètres variables pour les « Template » (variadic templates)
• etc…

J’ai hâte d’y être, même si je test déjà pas mal des fonctionnalités avec GCC.

Lien : http://www2.research.att.com/~bs/C++0xFAQ.html
Ils en parlent : herbsutter, bertrandleclercq.blogspot.com, danielkitta.org, Visual C++ Team Blog

Si comme moi vous utilisez la librairie C++ Googletest, et que vous compilez vous-même cette librairie, sachez que sous linux (peut-être unix/posix aussi), il faut ajouter la librairie pthread (-lpthread).

J’utilisais la version 1.4.0 qui n’en avait pas besoin, mais depuis un svn update il y a quelques heures, j’ai du ajouter pthread.

Platform: Linux
scons: done reading SConscript files.
scons: Building targets ...
Copy("bin/test/README", "README")
g++ -o bin/test/fpm-test test/main.o src/ratp/fpmanager/fp_helper.o src/external/googletest/src/gtest.o src/external/googletest/src/gtest-death-test.o src/external/googletest/src/gtest-filepath.o src/external/googletest/src/gtest-port.o src/external/googletest/src/gtest-printers.o src/external/googletest/src/gtest-test-part.o src/external/googletest/src/gtest-typed-test.o
src/external/googletest/src/gtest.o: In function `testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::GetOrCreateValue() const':
/home/christian/workspace/fpmanager/src/external/googletest/include/gtest/internal/gtest-port.h:1300: undefined reference to `pthread_getspecific'
...

Avec Scons on peut ajouter quelquechose dans ce style :

if platform == 'linux':
	env.Append(LIBS = 'pthread')

Ça évite de chercher presqu’une heure, une anomalie dans son programme de test !!!

Logo Android

Pour ceux qui veulent se lancer dans la compilation d’Android sous Ubuntu Lucid Lynx, il faut savoir que cela nécessite de réaliser quelques manipulations supplémentaires.

Tous d’abord le lien du projet pour compiler les sources d’Android (très bien écrit) :

• http://source.android.com/source/download.html

Mais pour notre Ubuntu le problème est java5, qui n’est plus dispo dans les dépôts. Si vous tenter de compiler les sources avec le java6 sous une Ubuntu 32bits, vous tomberez sur un bug indiquant que des entêtes de fichiers C 64bits non trouvés. Dans tous les cas, des parties du code java d’Android ne sont pas supportés par java 6.

Donc la première des choses à faire est de récupérer java5 depuis le site d’Oracle :

• http://java.sun.com/javase/downloads/index_jdk5.jsp

Installer manuellement le java5

chmod a+x jdk-1_5_0_22-linux-i586.bin
./jdk-1_5_0_22-linux-i586.bin
sudo mv jdk1.5.0_22 /usr/lib/jvm/java-5-sun-1.5.0.22
cd /usr/lib/jvm
sudo ln -s java-5-sun-1.5.0.22 java-5-sun

Je n’ai pas trouvé le moyen d’inclure mon install de java5 avec l’outil « update-java-alternatives » qui permet de switcher d’une jvm à l’autre en toute simplicité. Il est toujours possible de créer un fichier « .java-5-sun.jinfo » mais je manque de temps et il existe peut-être un outil pour le faire, n’hésitez pas à me faire signe. (trouvé : http://doc.ubuntu-fr.org/java)

Avant de lancer le make -j4 du tutoriel de google, faites la manip suivante dans le shell (non persistante) :

export JAVA_HOME=/usr/lib/jvm/java-5-sun
export ANDROID_JAVA_HOME=${JAVA_HOME}
export PATH=${JAVA_HOME}/bin:${PATH}

Tenter votre première compilation d’Android générique :

make -j4

Liens

• http://groups.google.com/group/android-building/browse_thread/thread/193332fd6850a2a
• http://source.android.com/source/download.html
• http://java.sun.com/javase/downloads/index_jdk5.jsp

Cela devient un classique pour moi ; appréhender un langage de programmation se concrétise souvent par l’écriture d’un client NetSoul. L’écriture d’un client NetSoul, nécessite de toucher aux sockets (IO), à la crypto, traitement de chaînes de caractères, gestion des exceptions et erreurs puis parfois aux évènements/notifications/signaux, processus concurrents (Lock/Unlock, Thread) etc… De quoi avoir un avis exhaustif sur le langage de manière assez large.

Globalement le langage GO se rapproche beaucoup des langages de scripting récents, mais le langage est bien dans la famille des langages compilés. La prise en main est assez rapide si l’on maîtrise déjà des langages tels que C/C++, Ruby, Python… Sans connaissance particulière en programmation c’est possible de commencer par le langage GO, mais je fais parti de ceux qui pense que la programmation s’apprend avec le « C« .

Exemple d’un client NetSoul écrit en GO

GOSOUL NetSoul client, par Christian KAKESA

GO lang

GO est un langage de programmation propulsé par Google. L’objectif premier de GO est de proposer un langage rapide à l’exécution et à la compilation, qui soit safe (multi-threading, multi-processus, gestion de la mémoire), facile à programmer et en même temps bas niveau. Est-ce possible ? Allez GO…

Préparer son environnement de développement

sudo aptitude install bison gcc libc6-dev ed gawk make
sudo aptitude install python-setuptools python-dev build-essential
sudo easy_install mercurial
mkdir $HOME/bin
mkdir $HOME/go

Ajouter les lignes suivantes dans le fichier « ~/.bashrc »

export GOBIN=${HOME}/bin # Obligatoire si le choix de l'emplacement est différent de ${HOME}/bin (pensez à ajouter ce chemin dans $PATH)
export GOROOT=${HOME}/go
export GOARCH=386 # Ou amd64, arm
export GOOS=linux
export PATH=${GOBIN}:${HOME}/bin:${PATH}

Récupérer et compiler GO

. ~/.bashrc
hg clone -r release https://go.googlecode.com/hg/ $GOROOT
cd $GOROOT/src
LANG=en_US ./all.bash

Écrire le fameux « Bonjour le monde »

cat > bonjour.go <<EOF
package main
import "fmt"
func main() {
	fmt.Printf("Bonjour le monde !!!\n")
}
EOF
8g bonjour.go
8l -o bonjour bonjour.8
./bonjour

Liens :

1. Tutoriel GO
2. En savoir plus sur les librairies du langage GO

Android developers

Signer une application Android n’est pas bien compliqué. Ces quelques vont vous guider dans la préparation du certificat. Il faut bien entendu avoir une plate forme Android fonctionelle.

mkdir -p ~/.local/share/keystore
cd ~/.local/share/keystore
keytool -genkey -v -keystore android-release-key.keystore -alias mon_alias -keyalg RSA -validity 10000

Il ne vous reste plus qu’à répondre aux questions…

Pour signer une application, le plus simple est d’utiliser ant. Il suffit de renseigner les deux lignes ci-dessous dans le fichier build.properties à la racine de votre projet :

# fichier : build.properties
key.store=/home/christian/.local/share/keystore/android-release-key.keystore
key.alias=mon_alias

Lorsque vous compiler votre projet avec la commande ant, il faut renseigner le ou les mots de passe de votre certificat, puis à la racine du projet tapez :

ant release

Il est aussi possible de réaliser la signature de vos applications à la main, je vous conseille dans ce cas le tutoriel android traitant directement du sujet. il ne reste plus qu’à déployer l’application.

Pour installer votre application sur l’émulateur ou votre device, il faut utiliser l’outil ADB ou passer par Eclipse/ADT.

Logo Android

Voici un petit tutoriel pour installer le SDK Android ainsi que l’IDE Eclipse et son plugin ADT permettant de réaliser ses premières lignes de code sous l’OS de Google. Je vous conseille de tester l’émulateur afin de vous familiariser avec Android. D’autres articles suivront sur la manière de réaliser ses premières applications.

Première étape installer java-6 et Ant

sudo aptitude install sun-java6-bin ant

Installer Eclipse et son plugin ADT

sudo aptitude install eclipse

Installer le plugin ADT pour eclipse

Ici l’installation d’Eclipse permet de faciliter vos futurs développements, je vous conseil, dans un premier temps, de privilégier les commandes shell pour mieux maîtriser le développement sous Android.

• Lancer eclipse
• Help > Install New Softare

• Cliquer sur « Add » ajouter les « Software sites » suivants :
• Selon le schéma [Name] – [Location]
  1. ADT – https://dl-ssl.google.com/android/eclipse/
  2. Eclipse GEF – http://download.eclipse.org/tools/gef/updates/releases/
  3. Eclipse EMF – http://download.eclipse.org/modeling/emf/updates/releases/
  4. Eclipse GMF – http://download.eclipse.org/modeling/gmf/updates/releases
  5. Eclipse Webtools – http://download.eclipse.org/webtools/updates/
  6. Google eclipse Plugin – http://dl.google.com/eclipse/plugin/3.5

• Sélectionner « Developer Tools » et assurez-vous que « Contact all update sites during install… » soit coché, puis suivez le guide…

Installer le SDK

mkdir -p ~/.local/opt
cd ~/.local/opt

Télécharger le SDK Android dans ~/.local/opt/

tar -zxvf android-sdk_r3-linux.tgz
cd android-sdk-linux/tools/
echo "export PATH=$(pwd):\${PATH}" >> ~/.bashrc
. ~/.bashrc

Mettre à jour le SDK

android update sdk

Faites connaissance avec l’émulateur Android

Lister les firmware disponible et identifier l’ID d’une version qui vous intéresse

android list targets

Créer un avd et lancer l’émulateur (-t : Id précédemment identifié)

mksdcard -l sdcard-avd2.0_API5 4096M ~/.android/sdcard-avd2.0_API5
android create avd -n avd2.0_API5 -t 7
emulator -avd avd2.0_API5 -sdcard ~/.android/sdcard-avd2.0_API5

Émulateur Android

StAX pour Streaming Api for Xml est une méthode performante pour parser un document XML. Voici un petit article qui montre les bien faits de cette méthode permettant de parcourir un fichier XML. On connaît bien les méthodes DOM (Document Object Model) et SAX (Simple Api for Xml), mais un peu moins sur le StAX méthode dite de pull parsing.

Logo XML 1.1

Pour rappel, la méthode DOM a pour fonctionnement le chargement en mémoire de l’ensemble d’un fichier XML sous forme d’arbre ou tableau etc… Cette méthode convient pour des fichiers de petite taille mais pour des fichiers de plusieurs centaines de mégaoctets voir quelques gigaoctets, ce mode est très lent. DOM a la particularité de pouvoir parcourir un fichier dans un sens comme dans l’autre et de permettre l’écriture et la modification de nœuds XML. Le mode de parcours SAX est un mode dit de push parsing (évènement implémenté/déclenché du côté de l’API) qui permet le parcours d’un fichier uniquement vers l’avant. SAX consomme très peu de mémoire, et reste très rapide mais ne permet pas la modification de nœuds XML.

La notion de pull parsing pour le StAX vient du fait que l’évènement est demandée du côté du code client (comprendre le code client en dehors de l’API XML). Le parseur est ce qu’on appelle « stream based », le code client soumet la portion de code a analyser par le parseur et récupère entre autre un évènement au quel on choisira de réaliser une action.
Le pull parsing oblige une analyse vers l’avant uniquement et permet l’écriture mais pas la modification de nœuds XML. Les performance sont très élevées pour le parcours de fichiers volumineux.

Parseur de type StAX :

• Expat (C)
• SPXML (C++)
• Plusieurs implémentations en JAVA basées sur la JSR-173 (JAVA)

Ci-dessous un exemple d’utilisation du parseur SPXML en mode StAX (supporte aussi DOM). On peut voir que le code utilisateur implémente les actions de traitement et non une redéfinition de méthodes de l’API comme en SAX. Notons que j’ai choisit de parcourir le fichier donné en paramètre, ligne à ligne, mais StAX étant stream based (basé sur des flots de données), il possible de parcourir selon un nombre d’octet définit.

int main( int argc, const char * argv[] )
{
	std::string filename;
	if( argc != 2 )
	{
		std::cout << "Usage:" << argv[0] << " <xml_file>" << std::endl;
		return (-1);
	}
	else
		filename = argv[1];

	SP_XmlPullParser parser;
	std::string line;
	std::ifstream myfile(filename.c_str());
	if (myfile.is_open())
	{
		while (!myfile.eof())
		{
			std::getline(myfile, line);
			parser.append( line.c_str(), line.length() );
			for( SP_XmlPullEvent * event = parser.getNext(); NULL != event; event = parser.getNext() )
			{
				switch( event->getEventType() )
				{
					case SP_XmlPullEvent::eStartDocument:
						std::cout << "start document" << std::endl;
						break;
					case SP_XmlPullEvent::eEndDocument:
						std::cout << "\nend document" << std::endl;
						break;
					case SP_XmlPullEvent::eDocDecl:
					{
						SP_XmlDocDeclEvent * declEvent = (SP_XmlDocDeclEvent*)event;
						std::cout << "<?xml";
						if( '\0' != *declEvent->getVersion() )
							std::cout << " version=\"" << declEvent->getVersion() << "\"";

						if( '\0' != *declEvent->getEncoding() )
							std::cout << " encoding=\"" << declEvent->getEncoding() << "\"";

						if( -1 != declEvent->getStandalone() )
							std::cout << " standalone=\""<< (declEvent->getStandalone() ? "yes" : "no") << "\"";

						std::cout << "?>" << std::endl;
						break;
					}
					case SP_XmlPullEvent::eDocType:
					{
						SP_XmlDocTypeEvent * typeEvent = (SP_XmlDocTypeEvent*)event;
						std::cout << "<!DOCTYPE " << typeEvent->getName() << " PUBLIC \"" << typeEvent->getPublicID() << "\" SYSTEM \"" << typeEvent->getSystemID() << "\" \"" << typeEvent->getDTD() << "\">" << std::endl;
						break;
					}
					case SP_XmlPullEvent::eStartTag:
					{
						SP_XmlStartTagEvent * stagEvent = (SP_XmlStartTagEvent*)event;
						std::cout << "<" << stagEvent->getName();
						for( int i = 0; i < stagEvent->getAttrCount(); i++ )
						{
							const char * name = NULL, * value = NULL;
							name = stagEvent->getAttr( i, &value );
							std::cout << " " << name << "=\"" << value << "\"";
						}
						std::cout << ">" << std::endl;
						break;
					}
					case SP_XmlPullEvent::eEndTag:
						std::cout << "</" << ((SP_XmlTextEvent*)event)->getText() << ">" << std::endl;
						break;
					case SP_XmlPullEvent::eCData:
					{
						SP_XmlStringBuffer buffer;
						SP_XmlStringCodec::encode( parser.getEncoding(),
						((SP_XmlTextEvent*)event)->getText(), &buffer );
						std::cout << buffer.getBuffer() << std::endl;
						break;
					}
					case SP_XmlPullEvent::eComment:
						std::cout << "<!--" << ((SP_XmlTextEvent*)event)->getText() << "-->" << std::endl;
						break;
					case SP_XmlPIEvent::ePI:
						std::cout << "<?" << ((SP_XmlPIEvent*)event)->getTarget() << " " << ((SP_XmlPIEvent*)event)->getData() << "?>" << std::endl;
						break;
				};
				delete event;
			}
		}
		myfile.close();
		if( NULL != parser.getError() )
			std::cerr << "\nerror: " << std::string(parser.getError()) << std::endl;
	}
	else
		std::cerr << "\nCan't open " << filename << " !!!" << std::endl;

	return 0;
}