| Emulateur logiciel de télécartes

> > > > > Plan de l'article :

> > > > > I) Introduction au phreak de cartes à puces
> > > > > II) Lire le contenu d'une carte à puce
> > > > > III) L'émulation: principe, matériel & réalisation
> > > > > IV) Conclusion

I) Introduction

Hello tlm. Aujourd'hui on va faire un tour du côté des cartes à puces. Avertissement : cet article ne vous permettra pas de faire des fausses cartes FT. Le but de cet article est, de téléphoner gratos dans une cabine FT, nuance ! On va en effet "émuler" une carte France Télécom. Tout d'abord explication de ce qu'est une carte FT : C'est une carte à puce, qui contient une mémoire de 256 bits. En fait, les cartes France Télécom 1ère génération, (T1G) se composaient d'une en-tête comportant la date, le nombre d'unité, un numéro de série, etc... de 96 bits. Le reste de la carte était composé de.... 0. Puis au fur et à mesure que la carte est débitée, les 0 passe à 1. Voila. Il est seulement possible de faire passer des 0 en 1, avec une certaine tension mais bon, ce n'est pas le sujet, j'ai bricolé avec l'écriture et j'ai rempli 3 cartes avec des 1 :)
Les Télécartes de secondes génération (T2G), quand à elles, sont cryptées, too bad hu ... :( MAIS ! on peut toujours utiliser des cartes de première génération en France (pour le moment bien sur) alors si vous avez pas une vieille carte FT, c con pour vous ! Non, je déconnes, on va s'en sortir vous en faîtes pas ;p En fait, vous pourriez me demander "Mais, ducon, on s'en tappe qu'elle soit cryptée, puisqu'on fait que copier son contenu ! Il est con lui !". Et moi, je m'empresse de répondre, "Soyez poli tout de même, je suis pas sur du tout, mais il se pourrait que le lecteur vérifie si l'unité a bien été débitée, et ça je sais pas, donc on doit pouvoir rajouter des unités simplement, et m'emmerdez pas, c'est plus simple, vous allez pas faire l'articel à ma place non ?". Avant, il suffisait de cacher une broche de la carte pour pas que les unités soient débitées, mais FT a changé toutes ses cartes et ses lecteurs, de manière à ce que la carte réponde "Oui lecteur, il a taxé une unité !". Sinon, ça s'arrête !
Le principe de ce phreak est le suivant : On commence par lire une télécarte de première génération, dont on enregistre l'image dans un fichier. Ce fichier on le met dans un portable. Connaissant parfaitement le protocole Carte/Cabine (but de l'article je précise), on pourra alors, en raccordant le portable à la cabine, faire croire à la cabine qu'elle dialogue avec une carte FT alors qu'elle parle à un ordi ! En fait, il suffira de faire passer à 1 les bits de notre fausse carte quand la cabine enverra un signal qui correspondra à "nique lui une unité en plus". Voila pour le principe de base. Evidemment, un portable c'est pas la top mais bon, ça doit être possible d'émuler ça avec une calculette programmable de lycée non ? J'en sais rien personnellement sur les E/S des calculettes mais bon, si quelqu'un a des infos, hésitez pas hein ! Donc dans un premier temps on va enregistrer le contenu d'une carte à puce, et dans un deuxième temps on va coder un émulateur de carte pour dialoguer avec la cabine.
A oui, j'oubliais le DISCLAIMER :

Mr Obscurer n'est pas responsable de ce que vous faîtes. D'ailleurs, il est INTERDIT par les lois de tous les pays du monde (même le guatemela), de ne pas payer dans les cabines. Bien entendu, vous allez essayez ce système sur VOTRE cabine téléphonique chez vous, que vous avez acheté légalement. Il est interdit de fracasser le boîtier blanc des cabines FT (en bas) pour éteindre la lumière pour être plus discret (mais c'est plus pratique quand même). D'ailleurs si un schtroumpfe en képi vous voit faire ça, il risque de bien vous le faire comprendre, alors prennez des cours de course de vitesse avec matériel (400m, ça devrait suffire pour semer un flic). Si vous avez des problèmes vous êtes pas obligé de dire que c'est de ma faute, vous avez peut-être mal soudé ou mal lut ce que j'ai dit (Met pas les fils dans ton nez, hé connard !). Donc, si vous voulez bien, fini le blabla et on commence.

II) Lecture d'une carte

(Si vous avez déjà un lecteur de carte à puce, vous pouvez passer au point suivant.)

Schéma d'une carte FT

Au fait, ça c'est la norme ISO (international) avant, en France c'était AFNOR (Franco-français évidemment, faut s'adapter)

Correspondance :

# ISO | NORME ISO 7816 | USAGE
1 | Vcc | Tension d'Alimentation de la carte
2 | R/W | Read/Write
3 | CLK | Clock=horloge
4 | RST | Reset: Mis à 0 par la cabine pour arreter le dialogue Lecteur/Carte
5 | GND | Masse (no comment nécessaires je crois)
6 | Vpp | Tension de programmation (on s'en balance en fait là)
7 | I/O | Input/Output utilisé pour (l'"accusé de reception" notamment de la carte)
8 | FUS | Fusible, c'est pour empêcher qu'on écrive dans les 96 premiers bits après sa fabrication

Voila pour le schéma d'une carte. Maintenant, voyons le principe de fonctionnement de la lecture.
En fait la carte et le port parrallèle d'un PC utilisent la même norme TTL (0 = pas de courant, 1 = 5 volts) donc c'est parfais, pas besoin de montage entre le port parrallèle et la carte.

CLK (clock=horloge), avance un pointeur dans la mémoire de la télécarte. En fait, quand CLK = 1 puis 0, le pointeur avance d'un bit, et ce bit est retourné par I/O. Pour lire un bit, on envoi un signal sur clock (CLK à 1 puis 0) et on lit le bit qu'envoie I/O. C'est pas plus compliqué que ça.

Lecture :
-On met tout à 0 et Vcc à 1 afin d'alimenter la carte (5v d'alim pour une carte FT, c'est du TTL, c'est parfais :)
-Ensuite on fait un Reset en mettant CLK à 1 puis à 0
-On met RST à 1, signifiant que le dialogue comence
-Maintenant, on peut lire la carte, en mettant CLK à 1 puis à 0 et on récupère sur I/O, le bit 0 ou 1 selon la valeur du bit
Quand on veut plus lire...bein....On débranche non ? :p

Voila, passons au concret :]
On a donc besoin d'un lecteur qui se branche sur le port // de votre PC(pourquoi parrallèle ? Parce que compatibilité des signaux TTL). On va donc utiliser LPT1.
On a besoin d'ECRIRE sur RST, CLK, et VCC
et de LIRE sur I/O
+ la Masse GND

Munissez-vous donc :
-d'une prise LPT (parrallèle) Male (c pas dur à différencier avec femelle, c'est du bon sens)
-d'un lecteur de carte à puces (40 F environ, ou si vous êtes des bourrins, vous vous débrouillez avec ce que vous avez)
-d'un petit fer à souder et plein d'étain !

On va relier les bornes de la carte au bornes LPT suivantes (elle sont numérotées) :
VCC (ISO 1) reliée à LPT #2
CLK (ISO 3) reliée à LPT #4
RST (ISO 4) reliée à LPT #5
GND (ISO 5) reliée à LPT #25 (c'est la masse)
I/O (ISO 7) reliée à LPT #13

Pas de questions ? Si ! Pourquoi I/O est reliée à LPT #13 ? J'utilise pas LPT #3 car j'avais foutu R/W dessus pour écrire sur les cartes, et là on se fout de R/W.
En fait, un port parrallèle est accessible, soit en Lecture (port 0x378), soit en Ecriture (port 0x379), soit en Lecture/Ecriture (on s'en sert pas, c'est 0x37A il me semble)

Les ports: Pour écrire dessus, faites un test avec le programme le plus convivial de tous, debug.exe, vous mettez un fil de votre voltmètre dans LPT 25 (masse) et l'autre dans les autres trous pour voir le courant qui sort, c'est fascinant.
Commande : o port val (met le port à une certaine valeur)
i port (retourne la valeur)
Note: tout est en hexadécimal.
Exemple: je met le un fil dans LPT 25 et un autre dans LPT 2, je fais "debug" sous DOS, puis "o 378 FF" et la il va vous claquer du 5V sur la prise LPT 2, ensuite "o 378 0", et là, il y a plus de tension :(

On doit écrire sur 4 bornes et lire sur 1.
Les prises LPT sont faites ainsi :
LPT # 2,3,4,5 sont accessible en écriture sur le port 0x378 pour LPT1
pour envoyer 1 sur LPT # 2 on fait en asm :
mov dx,378h
mov ax,00000001b
out dx,ax
pour envoyer 1 sur LPT #3 on fait donc :
mov dx,378h
mov ax,00000010b
out dx,ax
et ainsi de suite...

Pour recevoir, on utilise LPT #13 appellé "select" selon la norme je_sais_plus_quoi_et_on_s'en_fout (ha oui, norme TRISO :)
LPT #13, on y accède gràce au port 0x379, dont il est le bit 4 (donc le 5ème bits, suivez bon sang !!)

donc on va faire : mov dx,379h
in ax,dx

et ax contiendra le contenu (waou :), du port 379h, c'est pas beau ça ?

Schéma récapitulatif de tout ça ;p

> Port 0x378
> bit 7 6 5 4 3 2 1 0
> value - - - - RST CLK - Vcc

> Port 0x379
> bit 7 6 5 4 3 2 1 0
> value - - - I/O - - - -

Donc vous soudez tout ça correctement, sans vous brûler et vous obtenez un truc dans le genre de ça :
(faites pas attention à l'interrupteur et aux fils qui sortent en bas, c'est un module d'écriture, pour décharger les cartes en 1 seconde) :))

Voila, donc, je vous balance mon prog, il est en C/ASM codé en 10 minutes mais il est assez propre je trouve :]
(outp(...); me faisait chier alors j'utilise l'asm, na !)

------- SNIP SNIP -------------- SNIP SNIP -------------- SNIP SNIP -------------- SNIP SNIP -------
`/*++`
`Programme de Lecture de carte à puce ISO by obscurer`
`Requiert le super montage d'obscurer pour fonctionner ! hé ouais :)`
`Pour plus de simplicité je definie des valeur pour RST R/W etc...`
`Comme ça pour savoir si RST est à 1 on a qu'a faire un "AND" :`
`a=getvalue();`
`if(a&RST==RST) { RST est à 1 kewl :) }`
`else { RST est po à 1 :( }`
`Allez, here comes the prog :))`
`--*/```

`#include <stdlib.h>`
`#include <stdio.h>`
`#include <conio.h>```

`#define VCC 1 // = 00000001 en binaire`
`#define CLK 4 // = 00000100 en binaire`
`#define RST 8 // = 00001000 en binaire`
`#define IO 16 // = 00010000 en binaire```

`unsigned short getvalue()`
`{`
`unsigned short ret;`
`_asm {`
`mov dx,379h`
`in ax,dx`
`mov ret,ax`
`}`
`return ret; // retourne betement la valeur de 0x379`
`}```

`void setvalue(unsigned short value)`
`{`
`_asm {`
`mov dx,378h`
`mov ax,value`
`out dx,ax`
`}`
`}```

`int main()`
`{`
`unsigned int index; // un petit compteur`
`unsigned short getval;`
`unsigned char buffer[256];`
`FILE *output;```

`printf("Presser une touche pour commencer à lire la carte\n");`
`getch();```

`setvalue(0); // met toute les broches sortant du PC à 0```

`setvalue(VCC+CLK); // initialise`
`setvalue(VCC+0); // le dialogue```

`setvalue(VCC+RST); // on met reset à 1 pour toute la durée du programme```

`for(index=0;index<256;index++)`
`{`
`setvalue(VCC+RST+CLK); // RST toujours à 1, CLK à setvalue(VCC+RST); // RST toujours à 1, CLK à 0`
`// = incrémente le compteur de la carte`
`// donc elle va retourner une valeur sur I/O`
`getval=getvalue(); // et heureusement on est la pour la chopper`
`getval&=IO; // on AND getval et IO pour voir si I/O est à 1```

`if(getval==IO) { printf("1"); buffer[index]='1'; }`
`else { printf("0"); buffer[index]='0'; } // no comment```

`if(index%8==0) { printf(" "); } // ajoute un espace tout les 8`
`if(index%32==0) { printf("\n");} // va à la ligne tout les 32`
`}```

`printf("Presser une touche pour quitter\n");`
`getch();```

`output=fopen("carte.txt","w"); // Balance le buffer dans le fichier "carte.txt");`
`fputs(buffer,output);`
`fclose(output);```

`exit(0);`
`}`
------- SNIP SNIP -------------- SNIP SNIP -------------- SNIP SNIP -------------- SNIP SNIP -------

Voila, s'en est fini de la partie I): comment lire les cartes à puces.
La prochaine fois on fera un prog d'autentification avec carte à puce, car une carte à puce FT est unique, donc ça peut faire une clé de 256 bits, c'est pas rien et puis ça peut permettre de faire un peu de cryptage :)

Donc, on a donc l'image d'une carte à Puce, c'est déjà ça, vous pourrez épater tout vos amis ! :)))
Maintenant, il nous reste à faire passer un ordinateur portable pour une carte grâce à l'image de la carte qu'on a.
L'affaire se corse, car il va nous falloir pas mal de renseignements précis sur le fonctionnement du dialogue Lecteur/Carte.
Mais ne vous affolez pas, je suis là pour vous les donner, j'ai cherché et j'ai pas mal bidouillé mais je les ai plus ou moins =)

III) L'émulation : principe, matériel & réalisation

Voila :) On a une belle image de carte FT :) Vous pourrez faire des progs pour dire combien il y a d'unités sur vos cartes maintenant mais ce n'était pas vraiment le but de mon tutorial en fait, hé hé ;))
Alors, résumons la situation, il faut maintenant se placer de l'autre côté du problème (non, bougez pas, c'est juste une image !)
En fait, après avoir émulé un LECTEUR, on va émuler la CARTE.

DONC, il faut du matériel :) hé oui :)
Tout d'abord, il vous faudra une fausse carte, c'est à dire un typon EXACTEMENT comme une carte FT, même épaisseur, même distance entre les plots, etc... auquel on va souder des fils qui vont aller ou ? Non, pas dans la prise 220V les gars, dans votre port LPT 1 et oui :)
Donc, on cours acheter une seconde prise parrallèle (toujours male) et une fausse carte FT au boulanger du coin.
Bon, d'accord, un petit mot sur la fausse carte. J'ai pas vraiment le matos pour en faire alors j'ai chopper un dessin très précis que voici :

/*ICI DESSIN DU TYPON*/

Et je l'ai fait faire par une société spécialisée, le problème, c'est que quand on en demande 1 ou 2 c'est assez cher.
Moi, j'ai payé environ 150 balles pour 2. Enfin, sinon, vous trifouillez avec des trucs et des machins mais c'est à vos risque et périls. (Waou, l'Xplication du siècle là :)

Bref. Pour émuler la carte réfléchissons un peu plus le principe du dialogue (protocole) Carte/Lecteur.
Suivez mon résonnement, c'est pas très simple, lisez, relisez, et encore une troisième fois, pour pas dire après, "m'sieur, ça marche même pas qu'est ce que tu nous dis !". On sait déjà que quand RST est mis à 1 par la cabine, alors l'émulation commence. A chaque fois que CLK est à 1 puis à 0, on doit incrémenter un pointeur qui se déplace sur l'offset d'après du fichier image, puis retourner la valeur du bit qui s'y trouve sur I/O. Ca c'est pour la lecture, quand le lecteur voudra lire la carte, on saura quoi lui répondre.
Maintenant, quand le lecteur écrit sur la carte, c'est différent. Pour écrire, le Lecteur met Vpp et R/W à 1. (R/W ne sert à rien d'autre, son état est toujours le même que Vpp, tant mieux pour nous car Vpp c'est du 21V, et R/W c'est du ...... TTL ! Parfais, parfais ;) Une fois que Vpp & R/W sont à 1, la seule chose qu'on ait à faire, c'est de dire au lecteur que l'écriture s'est bien passée (la carte répond 1 sur I/O quand l'écriture a réussie) juste quand CLK est passée à 1 par le lecteur. Il faut cependant prévoir un laps de temps de 10à50 ms, donc on va prendre 35ms pour les essais :), entre le moment où R/W est à 1 et le moment où on renvoi 1 sur I/O. Et on oublie pas de changer un 0 en 1, là ou l'écriture a eu lieu !

Donc, fonctionnement du programme :
PROG

1. Chargement du fichier image de la carte dans un quelconque buffer
2. si RST == 1 alors GOTO 3, sinon reste là

3. Attend que CLK passe à l'état 5volts....
Si CLK passe à haut :vérifie si R/W est à haut (écriture),
si oui, on attend un peu, on envoi l'état du bit pointé sur I/O, puis on le change dans le buffer, GOTO 3
si non, on attend un peu, incrémente le pointeur d'1 bit, et on retourne la variable pointée sur I/O GOTO 3

On a donc besoin de quelle entrée/sortie ? Grande question, veuillez répondre sur papier libre à l'adresse suivante :
Bref, il nous faut envoyer une seule valeur : I/O. Par contre, on doit recevoir R/W, CLK, RST. Et en plus, il faut s'occuper des tensions Vcc et Vpp. Donc, on va utiliser un bit de sortie pour I/O, 3 bits d'entrée pour R/W, CLK & RST, et on va tout simplement relier Vcc & Vpp & GND (masse), à la prise 25 de notre port parrallèle (hop).
Notre PC s'occupera pas du courant entrant Vpp et Vcc. Tant que vous y êtes, reliez aussi la borne FUS non utilisée à la masse, on sait jamais.

On va donc souder nos fils comme ça :

GND (ISO 5), Vpp (ISO 6), Vcc (ISO 1) et FUS (ISO 8) relié à LPT 25 (masse)
I/O (ISO 7) relié à LPT 2
R/W (ISO 2) relié à LPT 11 (BUSY)
CLK (ISO 3) relié à LPT 10 (ACK)
RST (ISO 4) relié à LPT 12 (PE)

Voila, vous reliez tout simplement votre prise LPT à votre fausse carte selon ce shéma.
Ce qui devrait vous donner un truc comme ça :

Donc, notre programme devra importer sur 3 bornes, et exporter sur 1 borne.
Pour envoyer sur I/O on aura qu'à envoyer 255 ou 0 sur 0x378
Pour recevoir, on devra traité l'arrivée comme suit :

> Port 0x379
> bit 7 6 5 4 3 2 1 0
> value R/W CLK RST - - - - -

Voila, donc je déclarerai au début de mon prog :

> #define RW 128
> #define CLK 64
> #define RST 32

Mais il y a un petit hic. Les bits 3,4,5 et 6 du port 0x379 fonctionnent à l'envers (c'est un mystère du port parrallèle que je n'ai pas encore résolu), ce n'est rien, en fait quand aucun signal ne parvient sur RST par exemple, il est à 1. Et quand un signal parvient, il est à 0. Voila. Quand aucun signal ne vient sur CLK, il est à 1, et quand on a un signal, il passe à 0. R/W fonctionne normalement. On doit juste inverser les tests d'égalité de RST et de CLK, c'est tout.

Here is the prog :

------- SNIP SNIP -------------- SNIP SNIP -------------- SNIP SNIP -------------- SNIP SNIP -------
`/*++`
`Programme d'émulation de cartes à puces FT`
`The phone_for_free_with_a_portable technik !`
`by obscurer`
`--*/```

`#include <stdlib.h>`
`#include <stdio.h>`
`#include <conio.h>`
`#include <windows.h> // J'utilise windows.h pour "VOID Sleep(DWORD dwMilliseconds);"```

`#define TIME 35 // valeur d'attente, il faut tatonner ;)`
`#define RW 128`
`#define CLK 64`
`#define RST 32`
`#define IO_UN 255`
`#define IO_ZERO 0```

`unsigned short getvalue()`
`{`
`unsigned short ret;```

`_asm {`
`mov dx,379h`
`in ax,dx`
`mov ret,ax`
`}`
`return ret;`
`}```

`void setvalue(unsigned short value)`
`{`
`_asm {`
`mov dx,378h`
`mov ax,value`
`out dx,ax`
`}`
`}```

`int main()`
`{`
`unsigned int index=0;`
`unsigned short getval;`
`unsigned char buffer[256];`
`FILE *input;```

`setvalue(IO_ZERO); // met I/O à 0```

`input=fopen("carte.txt","r"); // ouvre le fichier`
`rewind(input);`
`fgets(buffer,256,input); // remplit le buffer avec l'image de la carte`
`fclose(input); // ferme le fichier```

`printf("Appuyez sur une touche pour commencer\n");`
`getch();`
`printf("Attente d'un RESET de la cabine...\n");```

`getval=getvalue();`
`while ((getval&RST)==RST) { // attend un RST de la cabine`
`getval=getvalue();`
`}`
`printf("RESET détecté ! Emulation commencée...\n"); // go !```

`wait_for_CLK:`
`getval=getvalue();`
`while ((getval&CLK)==CLK) { // attend CLK=1`
`getval=getvalue();`
`}```

`getval=getvalue(); // on chopppe le signal entrant`
`getval&=RW; // on regarde l'état de R/W`
`if(getval==RW) { goto RW_1; } // va écrire si R/W est à 1```

`/*ICI, LA CABINE VEUT LIRE LE BIT SUIVANT DE LA CARTE*/`
`index++; // notre pointeur augmente d'1`
`Sleep(TIME); // attend qque ms`
`if(buffer[index]=='1') { setvalue(IO_UN); }`
`else { setvalue(IO_ZERO); }```

`getval=getvalue(); // vérification, veut elle encore écrire ?`
`getval&=RW; // on chopppe la valeur de RW`
`if(getval==RW) { goto RW_1; } // il va écrire ou non`
`goto wait_for_CLK; // retourne à l'attente de CLK```

`RW_1:`
`/*ICI LA CABINE VEUT ECRIRE SUR LE BIT DE LA CARTE POINTÉ PAR index */`
`buffer[index]='1'; // On change ce bit dans notre buffer`
`Sleep(TIME); // attend TIME ms`
`setvalue(IO_UN); // On envoi un signal sur I/O = "ok"`
`goto wait_for_CLK; // retourne à l'attente de CLK```

`exit(0);`
`}`
------- SNIP SNIP -------------- SNIP SNIP -------------- SNIP SNIP -------------- SNIP SNIP -------

Voila. Normalement tout est parfais, je pense pas avoir oublié des explications.

IV) Conclusion

Voila, l'article est quasiment terminé. Merci d'avoir eu le courage de lire jusqu'ici. Je voudrais juste dire certaines choses en conclusion. Tout d'abord, la lecture de carte marche sans problème, mais mailez moi si vous avez des difficultés. Ensuite, je voudrais ajouter que j'ai écrit cet article un peu trop rapidemment donc je n'ai pas encore testé l'émulation. Quand je l'aurais fait j'écrirai un article si certain détails sont à changer. Cependant, vous avez ici les bases (même plus je pense) pour réussir une émulation. Un petit conseil, avant de vous attaquer à une cabine FT, testez le système avec votre PC et le portable. Le portable run le programme d'émulation et le PC run le programme de lecture de carte. Si vous arrivez à lire la carte, c'est que votre fausse carte sera au moins reconnue par la cabine. Ensuite vous verrez si le reste marche en téléphonant.
Si quelqu'un se sert de cet article pour un autre Zine, je n'ai rien contre, vous pouvez :

> -Prendre des parties du tutorial, images ou textes, je m'en tappe
> -Prendre les codes sources des programmes, je m'en tappe
> -Changer ce que vous voulez sur ce que vous prennez, je m'en tappe
> -Copier les montages pour d'autres utilisations, je m'en tappe

MAIS ! VOUS METTEZ L'ORIGINE, VOUS METTEZ MON NOM ! Sinon, c'est un peu batard tout de même (je trouve) de s'approprier les articles des autres. Voici mes sources :
"PC & Cartes à Puces" Patrick GUEULLE éditions ETSF (faîtes gaffe, page 91, les numéros correspondent pas au bonnes bornes, la 4 est bien RST, et la 2 n'est pas RST mais R/W, dites pas que je me gourre après), Pirat'Mag (c'est vraiment le seul article de bien qu'ils ont pondus, désolé de donner mon avis mais c'est pour le bien de la communauté underground), et pour le fonctionnement du port LPT : Nofutur1 (article de bLoRP). Voila, vous savez tout ! Petite idée pour si vous vous ennuyez, faîtes vos devoirs et le ménage. Quand vous avez fait tout ça, vous pouvez imaginer un système d'encryption avec la clé qui se trouverait sur la carte à puce, ça peut être amusant :) Mais bien sur, vous devrez demander l'autorisation à Mr Jospin pour utiliser des clés de 256 bits pour crypter vos fichiers qui ne contiennent que des données licites hé, hé ;)
Si vous voulez des conseils particuliers, m'insulter ou me dire quoi que ce soit : Vous me mailez !, ou vous me choppez sur Undernet (nick: obscurer, sur #tipiak ou #securiweb).
Nota Bene: Le beige boxing, c'est bien moins laborieux pour pas payer le phone mais c'était surtout pour apprendre les principes des cartes FT ! ;)

La phrase du jour : "I like to move it move it, I like to... move it"

Retourner au début du document