Quoi de plus rageant que de se retrouver avec un entier quand on à besoin d’une chaine de caractères? Et c’est encore plus vrai quand il s’agit d’un define qui est utiliser pour des fichiers .log.

Heureusement, les macros peuvent vous éviter une conversion lourde. Dans notre cas, il s’agit du préprocesseur __LINE__ qui indique le numéro de la ligne actuelle dans le fichier source, bref, exactement le type de valeur utile dans un fichier .log en cas de crash. Malheureusement, celle-ci est sous forme d’entier… Mais pas pour longtemps :

1
2
3
4

#define CONVSTR(x) #x
#define STRING(x)  CONVSTR(x)

#define WHERE_I_AM   __FILE__":"STRING(__LINE__)

Et voilà! Fini le méchant petit entier…

Avant de commencer quoi que ce soit, il vous faudra récupérer PyWin (http://sourceforge.net/projects/pywin32/files/pywin32/). PyWin est un package qui s’occupe d’installer toutes les extensions nécessaires. Faites attentions à prendre le package qui correspond à votre version de Python. Pour connaître la version que vous possédez, rendez vous dans votre explorer de fichiers et regarder le répertoire nommé PythonXX (XX représente la version)

Une fois PyWin téléchargé puis installé, ajoutez les répertoires suivants, s’ils n’y sont pas déjà, dans votre variable d’environnement PATH.

1
2

C:\Python27\
C:\Python27\Scripts

A ce point là, votre installation de Python est prête. Il ne vous reste plus qu’a installer l’outil easy_install. Pour ce faire, téléchargez le fichier setuptools-0.6c11.win32-pyX.Y.exe (http://pypi.python.org/pypi/setuptools#files) puis installez le.

Ouvrez une invite de commandes puis tapez la commandes suivantes :

1
2

C:\>  easy_install virtualenv
C:\>  easy_install django

1
2

C:\ django-admin.py --version
1.4

Bravo, vous venez d’installer avec succès Django sur Windows. Vous allez pouvoir commencer à construire votre site web avec sérénité.

Aujourd’hui, nous allons voir comment gagner environ 45% de performance en plus sur votre serveur utilisant PHP (constaté avec l’outil AB). Pour cela, nous utiliserons l’extension PHP nommée APC.

Pour commencer, faisons une petite présentation: Le “Alternative PHP Cache” (APC) est un cache d’opcode pour PHP. Son objectif est de fournir un framework libre, ouvert et robuste pour la mise en cache et l’optimisation de code intermédiaire PHP. Pour installer cette extension, vous aurez besoin de PECL et du package de développement PHP.

1

root@0xbaadf00d> apt-get install php5-dev php-pear dh-make-php

maintenant, que vous avez le minimum vitale, installons l’extension:

1

root@0xbaadf00d> pecl install apc

Lors du processus de configuration, APC vous posera plusieurs questions, vous pouvez si vous le souhaitez les réponses par défaut. Une fois l’installation terminée, éditez votre fichier php.ini et ajoutez la ligne suivante :

1

extension = apc.so

Redémarrez PHP (ou apache si vous utilisez encore cette m….). Si vous souhaitez monitorer ou videz le cache APC, vous pouvez le faire en utilisant le script apc.php qui se trouve dans le répertoire /usr/share/php/. Il faut juste pensez à l’éditer pour modifier les lignes suivantes :

1
2

defaults('ADMIN_USERNAME', 'corvus');
defaults('ADMIN_PASSWORD', 'my_fkg_secret_password');

Et voilà, votre serveur va beaucoup mieux se porter maintenant.

• Le MII (Major Industry Identifier) qui représente la catégorie dans laquelle se trouve le fournisseur de la carte.
• L’IIN (Issuer Identification Number) qui permet d’identifier l’institution qui a émise la carte.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#!/usr/bin/env ruby
##

#Check nb param
abort "Usage: #{$0} number" unless  ARGV.length > 0

#Check is numeric
card_num = ARGV[0].gsub ' ', ''
if /^[\d]+(\.[\d]+){0,1}$/.match card_num
  puts "Card Number: #{card_num}"

  #Get Card Type - http://en.wikipedia.org/wiki/Bank_card_number
  CARD_TYPE = [
               {:name => 'AMERICAN EXPRESS', :regex => /^3[4|7][0-9]{13}$/},
               {:name => 'VISA', :regex => /^4[0-9]{12}$|^4[0-9]{15}$/},
               {:name => 'MASTER CARD', :regex => /^5[1-5][0-9]{14}$/},
               {:name => 'UNKNOWN', :regex => /(.*)/}
              ]
  CARD_TYPE.each do |t|
    puts "Card Type  : #{t[:name]}" or break if t[:regex].match card_num
  end

  #Check Card Number - http://en.wikipedia.org/wiki/Luhn
  index = 1
  checksum = 0
  card_num.reverse.each_char do |c|
    if index % 2 == 0
      c = (c.to_i * 2)
      c.to_s.each_char {|n| checksum += n.to_i}
    else
      checksum += c.to_i
    end
    index += 1
  end
  puts "Checksum   : #{checksum}"
  puts "Card Check : " + (checksum % 10 == 0 ? "VALID" : "INVALID")
else
  puts 'Format error...'
  puts 'Please respect this format XXXXXXX... or XXXX XXXX XXXX...'
end

Vous êtes un fervent utilisateur de Ruby ou simplement un utilisateur occasionnel et vous souhaitez apporter votre contribution à l’annuaire d’extensions Ruby ? Ce billet est fait pour vous. Nous allons voir comment créer une gem sans utiliser de template. Pour commencer, mettez à jour rubygems avec la commande suivante :

1

root@0xbaadf00d.com> gem update --system

Une fois le processus de mise à jour effectué, créez le squelette de votre gem :

1
2
3
4

meyer_t@0xbaadf00d.com> mkdir ionisauthenticator
meyer_t@0xbaadf00d.com> mkdir ionisauthenticator/lib
meyer_t@0xbaadf00d.com> touch ionisauthenticator/lib/ionisauthenticator.rb
meyer_t@0xbaadf00d.com> cd ionisauthenticator

Attention: Le fichier d’entrée de votre gem doit avoir le même nom que la gem (ici: ionisauthentication).

Créez ensuite le fichier qui contiendra les informations sur votre gem. Le nom du fichier n’a pas d’importance, vous devez seulement respecter l’extension .gemspec. Parmi les informations contenues dans ce fichiers nous pouvons citez l’auteur, la description, le site internet, les dépendances, les fichiers à utiliser…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Gem::Specification.new do |s|
  s.name         = 'ionisauthentication'
  s.version      = '0.0.3'
  s.date         = '2012-03-13'
  s.summary      = "IONIS Authentication"
  s.description  = "A Ruby Class to get informations about students in Ionis group"
  s.authors      = ["Thibault MEYER"]
  s.email        = 'email@domain'
  s.files        = ["lib/ionisauthentication.rb", "lib/ionisexceptions.rb", "README.rdoc"]
  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Net-scp", "--main", "README.rdoc"]
  s.homepage     = 'https://github.com/corbeau-web/Ruby-IONIS-Info-Class'
  s.add_dependency('net-ssh', '>= 2.3.0')
  s.add_dependency('net-scp', '>= 1.0.4')
  s.add_dependency('bcrypt-ruby', '>= 3.0.1')
end

Dès à présent, vous pouvez coder votre gem dans le répertoire lib. Une fois cela fait, il suffit de générer la gem puis de l’installer.

1
2

meyer_t@0xbaadf00d> gem build my_own_gem.gemspec
meyer_t@0xbaadf00d> gem install ionisauthentication-0.0.3.gem

Et voilà, vous venez de créer votre première gem, il ne vous reste plus qu’à la tester et, si vous le souhaitez, la publier sur rubygems.

Quand vous possédez un ou plusieurs serveurs vous aimeriez bien être tenu au courant tout de suite quand quelque chose ne passe pas bien et non pas être pris au dépourvu le jour ou vous vous décidez enfin à lire les fichiers de log qui sont barbant à consulter.

Il existe un logiciel qui répond au nom de “logcheck” qui à pour rôle de vous prévenir par mail dès que quelque chose cloche sur le système: Comme par exemple, un programme qui plante, une tentative de connexion échouée, …

Logcheck est présent dans les dépôts de la plupart des distributions. Après l’avoir installé, éditez le fichier /etc/logcheck/logcheck.conf pour ajouter votre adresse mail au champ SENDMAILTO.

1

SENDMAILTO="thibault.meyer@0xbaadf00d.com"

Voici un exemple de mail que vous pouvez recevoir avec logcheck

1
2
3
4
5
6
7
8
9
10
11
12

This email is sent by logcheck. If you no longer wish to receive
such mail, you can either deinstall the logcheck package or modify
its configuration file (/etc/logcheck/logcheck.conf).

System Events
=-=-=-=-=-=-=
Mar  9 16:13:55 ks25076 krb5kdc[2620]: preauth (timestamp) verify failure: Decrypt integrity check failed
Mar  9 16:13:55 ks25076 krb5kdc[2620]: AS_REQ (7 etypes {18 17 16 23 1 3 2}) 163.5.141.29: PREAUTH_FAILED: 0xbaadf00d@CORBEAU-WEB.EU for krbtgt/CORBEAU-WEB.EU@CORBEAU-WEB.EU, Decrypt integrity check failed
Mar  9 16:14:00 ks25076 krb5kdc[2620]: preauth (timestamp) verify failure: Decrypt integrity check failed
Mar  9 16:14:00 ks25076 krb5kdc[2620]: AS_REQ (7 etypes {18 17 16 23 1 3 2}) 163.5.181.23: PREAUTH_FAILED: 0xbaadf00d@CORBEAU-WEB.EU for krbtgt/CORBEAU-WEB.EU@CORBEAU-WEB.EU, Decrypt integrity check failed
Mar  9 16:14:05 ks25076 krb5kdc[2620]: preauth (timestamp) verify failure: Decrypt integrity check failed
Mar  9 16:14:05 ks25076 krb5kdc[2620]: AS_REQ (7 etypes {18 17 16 23 1 3 2}) 163.5.141.16: PREAUTH_FAILED: 0xbaadf00d@CORBEAU-WEB.EU for krbtgt/CORBEAU-WEB.EU@CORBEAU-WEB.EU, Decrypt integrity check failed

Cette nuit je suis tombé sur un script super sympa en Python qui permet d’exporter l’affichage d’un émulateur de terminal sur HTTP. Le résultat est plutôt bluffant, je vous conseil de tester par vous même pour vous en faire une idée.

Le projet est hébergé sur github à l’adresse suivante : https://github.com/JulienPalard/ashttp

Qui ne s’est jamais posé la question de comment fait un trainer pour modifier les caractéristiques des votre personnage dans votre jeu préféré? Aujourd’hui, je vais essayer de vous montrer basiquement le processus de la conception d’un tel programme. Ce billet se découpera en 2 parties: dans la première, nous utiliserons Cheat Engine (http://www.cheatengine.org) pour fouiner un peu dans la mémoire du jeu et dans un second temps, nous coderons une petite application (C ou C++ avec API Windows) pour exploiter les résultats de la première étape. Comme il s’agit d’une introduction, nous utiliserons un jeu simple, nous utiliserons donc “Might and Magic VI : The Mandate of Heaven” disponible sur GoG en échange de quelques dollars.

0x01 - A la poursuite des adresses perdues

Might and Magic VI est parfait pour débuter car les adresses mémoire ne changent pas. J’entend par la que l’adresse d’un élément donnée ne change pas d’une partie à l’autre (contrairement à des jeux comme Killing Floor, où l’adresse mémoire des points de vie change à chaque partie). Avant de commencer quoi que ce soit, je vous conseil de suivre le tutorial de Cheat Engine histoire de vous familiariser à son maniement. Maintenant que vous maitrisez Cheat Engine, nous pouvons procédez à l’opération. Cette étape, bien que peu complexe, est relativement peu intéressante à faire. En fait, il faut trouver ou se trouve les éléments que l’on souhaite manipuler dans notre trainer. Might and Magic VI étant un RPG, nous rechercheront en priorité des éléments intéressants comme les points de vie des personnages et le nombre de pièce d’or du groupe.

1
2
3
4
5
6
7
8

================ MM6.EXE ================
MM6.exe+508D50    Pièces d.or du groupe
MM6.exe+508D54    Pièces d.or déposées à la Banque
MM6.exe+908D2C    Nourriture du groupe
MM6.exe+90A348    Points de vie du personnage #1
MM6.exe+90B964    Points de vie du personnage #2
MM6.exe+90CF80    Points de vie du personnage #3
MM6.exe+90E59C    Points de vie du personnage #4

0x02 - Développez un trainer basique

Bien, on a les adresses mémoire, il ne nous reste plus qu’a développez un petit programme qui va modifier les valeurs quand on le souhaite. Pour cela, voyons ce que propose l’API Windows comme fonctions qui sont bien de les connaître tellement elles envoient du poney sur la lune:

• FindWindow : Permet de récupérer un handle sur une application ouverte sur Windows
• GetWindowThreadProcessId : Permet de récupérer le PID d’une application a partir de son handle
• OpenProcess : Ouvre en lecture/écriture un processus en cours à partir de son PID
• ReadProcessMemory : Lire dans la mémoire
• WriteProcessMemory : Ecrire dans la mémoire
• CloseHandle : Fermer un handle
• GetAsyncKeyState : Pour savoir les touches clavier appuyées

Ces fonctions sont extrêmement bien documentés sur le MSDN, vous devriez y jeter un petit coup d’oeil pour vous familiariser avec. Pour commencer, nous allons récupérer le PID du jeu puis ouvrir le processus, pour cela il suffit d’utiliser FindWindow et GetWindowThreadProcessId.

1
2
3
4
5
6
7
8
9
10

m_hWindow = FindWindowA(NULL, "MM6.EXE");
if (m_hWindow) {
  retVal = GetWindowThreadProcessId(m_hWindow, (LPDWORD)&m_PID);
  if (retVal) {
    m_hProc = OpenProcess(PROCESS_ALL_ACCESS, NULL, m_PID);
    if (m_hProc) {
      // ok
    }
  }
}

Maintenant que le jeu est trouvé et que OpenProcess à retourné un handle valide, nous allons pouvoir commencer à lire et écrire dans la mémoire du programme. Voyons comment s’ajouter 2000 Pièces d’or en plus :

1
2
3
4
5
6
7

ULONG32  val = 0;
SIZE_T  nbReaded = 0;
SIZE_T   nbWritten = 0;

ReadProcessMemory(m_hProc, (LPCVOID) 0x908D50, (LPVOID)&val, 4, &nbReaded);
val += 2000;
WriteProcessMemory(m_hProc, (LPVOID) 0x908D50, (LPCVOID)&val, sizeof(ULONG32), &nbWritten);

Et voila, vous venez de gagner 2000 Pièces d’or en plus ! Utilisez GetAsyncKeyState pour ajouter la possibilité d’utiliser votre trainer in-game en ajouter de nouveaux bindkey : F2 pour de l’argent, F3 pour de la nourriture, …

Par pitié, n’oubliez pas de fermer les handles ouvert à la fin avec la fonction CloseHandle.

Aujourd’hui nous allons voir une façon simple de transformer une application Java en .jar vers un exécutable Windows. Le but n’est pas de se passer de JRE mais de fournir une jolie application avec un manifeste et une icône qui se chargera de lancer le .jar inclus dedans et de vérifier que l’utilisateur possède bien la bonne version de Java. Pour accomplir cette transformation, nous allons utilisez l’application nommée “Launch4j”. Elle est très simple à utiliser, il suffira de remplir quelques champs obligatoires comme par exemple l’emplacement où se trouve votre .jar, où se trouve le fichier Icone (.ico), la version minimum de Java requise par votre application et enfin où vous souhaitez que le .exe soit enregistré !

Aujourd’hui nous allons voir comment mettre en place un cluster sous LAM/MPI pour effectuer du calcul parallèle. LAM (Local Area Multicomputer) MPI (Message Passing Interface) est souvent considérer comme “cluster friendly”. Il est est basé sur un démon qui contrôle les processus et s’occupe de la communication inter-nodes. MPI peut utiliser le protocole TCP/IP, la mémoire partagée, Myrinet (GM), ou Infiniband (mVAPI) pour le passage de messages.

La mise en place de LAM/MPI est extrêmement facile, nous allons voir les étapes à suivre sous Debian 6. Pour commencer, nous allons créer l’utilisateur “lammpi” sur toute les machines de votre cluster (car travailler en root c’est über mal, et de toute façon, LAM/MPI refusera de fonctionner en root).

Le poste Tomahna est le serveur maître de la grappe que je possède.

1
2
3
4
5
6
7
8
9
10
11

root@tomahna ~ > useradd lammpi
root@tomahna ~ > mkdir /home/lammpi
root@tomahna ~ > chown lammpi:lammpi /home/lammpi

root@releeshahn ~ > useradd lammpi
root@releeshahn ~ > mkdir /home/lammpi
root@releeshahn ~ > chown lammpi:lammpi /home/lammpi

root@edanna ~ > useradd lammpi
root@edanna ~ > mkdir /home/lammpi
root@edanna ~ > chown lammpi:lammpi /home/lammpi

Une fois les comptes créés, nous allons configurer correctement l’authentification par clef pour ssh afin que vous ne soyez pas emmerdé toutes les 5 minutes par LAM/MPI. Sur le serveur maître, il suffit de générer une clef.

1
2
3
4
5
6
7
8
9
10

lammpi@tomahna ~ > ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/lammpi/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/lammpi/.ssh/id_rsa.
Your public key has been saved in /home/lammpi/.ssh/id_rsa.pub.
The key fingerprint is:
41:10:e8:9b:c8:52:0b:54:8a:75:32:2c:b6:be:dd:2f
lammpi@tomahna ~ >

Ensuite, il suffit d’ajouter le contenu de “id_rsa.pub” dans le fichier /home/lammpi/.ssh/authorized_keys2 sur les autres serveurs de la grappe.

1
2

lammpi@releeshahn ~ > cat id_rsa.pub >> /home/lammpi/.ssh/authorized_keys2
lammpi@edanna ~ > cat id_rsa.pub >> /home/lammpi/.ssh/authorized_keys2

Voila, maintenant, que le serveur maître (Tomahna) peut se connecter tranquillement aux nodes, nous allons installer LAM/MPI sur chacunes des machines. Un petit tour sur le site officiel de LAM/MPI ([www.lam-mpi.org|www.lam-mpi.org|en|www.lam-mpi.org]) s’impose, histoire de récupérer la dernière version du logiciel.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

lammpi@tomahna ~ > wget http://www.lam-mpi.org/download/files/lam-7.1.4.tar.gz
lammpi@tomahna ~ > tar xf lam-7.1.4.tar.gz
lammpi@tomahna ~ > cd lam-7.1.4
lammpi@tomahna ~ > ./configure
lammpi@tomahna ~ > make
lammpi@tomahna ~ > make install

lammpi@releeshahn ~ > wget http://www.lam-mpi.org/download/files/lam-7.1.4.tar.gz
lammpi@releeshahn ~ > tar xf lam-7.1.4.tar.gz
lammpi@releeshahn ~ > cd lam-7.1.4
lammpi@releeshahn ~ > ./configure
lammpi@releeshahn ~ > make
lammpi@releeshahn ~ > make install

lammpi@edanna ~ > wget http://www.lam-mpi.org/download/files/lam-7.1.4.tar.gz
lammpi@edanna ~ > tar xf lam-7.1.4.tar.gz
lammpi@edanna ~ > cd lam-7.1.4
lammpi@edanna ~ > ./configure
lammpi@edanna ~ > make
lammpi@edanna ~ > make install

Et voila, pour la dernière étape, nous allons éditer le fichier de configuration sur le serveur maître, il se trouve à /usr/local/etc/lam-bhost.def. Voilà le contenu du mien :

1
2
3
4

root@tomahna ~ > cat /usr/local/etc/lam-bhost.def
tomahna cpu=1 user=lammpi
releeshahn cpu=1 user=lammpi
edanna cpu=1 user=lammpi

Pour mettre en route votre cluster, il suffit de lancer la commande lamboot sur le serveur maître.

1
2
3

lammpi@tomahna ~ > lamboot

LAM 7.1.4/MPI 2 C++/ROMIO - Indiana University

Et pour avoir des informations sur les nodes

1
2
3
4

lammpi@tomahna ~ > lamnodes
n0 tomahna:1:origin,this_node
n1 releeshahn:1:
n2 edanna:1:

Bien, maintenant, que votre cluster est prêt, il serait peut être temps de le tester non ? Ci-joint, le fichier mpi_pi.c permet de calculer le chiffre pi en utilisant le calcul parallèle. Il suffit d’utiliser “mpicc” pour le compiler et scp pour l’envoyer sur les différentes nodes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

#include <stdio.h>
#include <stdlib.h>
#include "mpi.h"

int main(int argc, char *argv[])
{
  int    i, n;
  double h, pi, x;
  char        name[128] ={0};

  int    me, nprocs;
  double piece;

  gethostname(name, 128);
  /* --------------------------------------------------- */

  MPI_Init (&argc, &argv);

  MPI_Comm_size (MPI_COMM_WORLD, &nprocs);
  MPI_Comm_rank (MPI_COMM_WORLD, &me);

  /* --------------------------------------------------- */

  if (me == 0)
    {
      printf("%s", "Input number of intervals:\n");
      scanf ("%d", &n);
    }

  /* --------------------------------------------------- */

  MPI_Bcast (&n, 1, MPI_INT,
       0, MPI_COMM_WORLD);

  /* --------------------------------------------------- */

  h     = 1. / (double) n;

  piece = 0.;

  for (i=me+1; i <= n; i+=nprocs)
    {
      x     = (i-1)*h;

      piece = piece + (
             4/
             (1+(x)*(x))
             +
             4/
             (1+(x+h)*(x+h))
             ) / 2 * h;
      printf("[%s] \t x=%f, piece = %25.15f\n", name, x, piece);
    }
  printf("[%s] \t pi = %25.15f\n", name, piece);

  /* --------------------------------------------------- */

  MPI_Reduce (&piece, &pi, 1, MPI_DOUBLE,
        MPI_SUM, 0, MPI_COMM_WORLD);

  /* --------------------------------------------------- */

  if (me == 0)
    {
      printf("pi = %25.15f\n", pi);
    }

  /* --------------------------------------------------- */

  MPI_Finalize();

  return 0;
}

1
2
3

lammpi@tomahna ~ > mpiccc mpi_pi.c -o test_pi.bin
lammpi@tomahna ~ > scp test_pi.bin releeshahn:/home/lammpi/
lammpi@tomahna ~ > scp test_pi.bin edanna:/home/lammpi/

Pour l’exécuter, la commande “mpirun” est de rigueur :

1

lammpi@tomahna ~ > mpirun C ./test_pi.bin