---------------------------------------------------------------------------------------
XI.		       Démarrer sshd à distance                             Jackniels
---------------------------------------------------------------------------------------


[ Introduction ]


Cet article va montrer comment on peut "cacher" sshd et l'activer à distance
à la demande. Cela permet d'éviter de laisser tourner ce daemon et donc de se
prémunir des attaques visant sshd. Son activation va se faire sur la réception
d'un segment TCP avec une IP source et un port source particuliers.

Il est possible d'envisager un tel programme pour administrer une machine aidant
à la détection d'intrusion. Il est alors possible de fermer tous les services sur
cette machine même le port 22/tcp. Pour réaliser ce programme, nous allons utiliser
la libpcap. La libpcap est une bibliothèque de fonctions qui sert d'interface à la
capture de paquets et est indépendante du système. En clair, la libpcap permet
d'écouter le réseau avec ses propres filtres puisqu'elle inclut un mécanisme de
filtrage basé sur le Berkeley Packet Filter (BPF).

La libpcap est téléchargeable ici : http://www.tcpdump.org





    I. Le Code :
    ____________



------------8<------------------------------------------------------------------

// startsshd.c by jackniels

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <pcap.h>
#include <arpa/inet.h>
#include <signal.h>
#include <unistd.h>
#include <net/bpf.h>
#include <net/if.h>

void callback(u_char *user,const struct pcap_pkthdr *h, const u_char *buff)
{
        printf ("sshd [OK]\n");
        system("/usr/sbin/sshd -d");
        exit(1);
}

int main() {
        char errbuf[PCAP_ERRBUF_SIZE];
        char *dev;
        char *buff;
        char filtre[]="tcp and src host 222.222.222.222 and src port 2222";
        pcap_t *des;
        bpf_u_int32 net,mask;
        struct bpf_program fp;


        if((dev=pcap_lookupdev(errbuf))==NULL) {
                fprintf(stderr,"unable de detect device : %s\n",errbuf);
                 exit(-1);
        }

        printf("using %s as device for sniffing\n",dev);

        if((des=pcap_open_live(dev,1514,IFF_PROMISC,1000,errbuf))==NULL) {
                fprintf(stderr,"unable to open descriptor : %s\n",errbuf);
                exit(-1);
        }

        if(pcap_lookupnet(dev,&net,&mask,errbuf)==-1) {
                fprintf(stderr,"unable to lookup net and mask :
%s\n",errbuf);
                exit(-1);
        }

        if(pcap_compile(des,&fp,filtre,0x100,mask)==-1) {
                fprintf(stderr,"error compiling filter :
%s\n",pcap_geterr(des));
                exit(-1);
        }

        if(pcap_setfilter(des,&fp)<0) {
                fprintf(stderr,"unable to apply filter :
%s\n",pcap_geterr(des));
                exit(-1);
        }

	if(pcap_loop(des,-1,callback,buff)<0) {
                fprintf(stderr,"unable to initialize loop :
%s\n",pcap_geterr(des));
                exit(-1);
        }

        return 1;
}

------------8<------------------------------------------------------------------




    II. Démonstration :
    ___________________



=> Machine "shinta" :

On compile le programme de cette manière puis on le lance :

jack@shinta:~# gcc -lpcap -o startsshd startsshd.c
/
root@shinta:~# ./startsshd
using ppp0 as device for sniffing




=> Machine "tomoe" :

On lance le serveur sshd en envoyant à la machine shinta un segment TCP avec
l'IP spoofée 222.222.222.222 depuis le port 2222. Pour cela, on utilise le
programme hping (http://www.hping.org/) :

root@tomoe:~# /usr/sbin/hping -c 1 -s 2222 -a 222.222.222.222 <ip shinta>
HPING <ip shinta> (ppp0 <ip shinta>): NO FLAGS are set, 40 headers + 0 data
bytes

--- <ip shinta> hping statistic ---
1 packets tramitted, 0 packets received, 100% packet loss
round-trip min/avg/max = 0.0/0.0/0.0 ms
root@tomoe:~#




=> Machine "shinta"

On obtient :

root@shinta:~# ./startsshd
using ppp0 as device for sniffing
sshd [OK]
debug1: sshd version OpenSSH_3.1p1
debug1: private host key: #0 type 0 RSA1
debug1: read PEM private key done: type RSA
debug1: private host key: #1 type 1 RSA
debug1: read PEM private key done: type DSA
debug1: private host key: #2 type 2 DSA
socket: Address family not supported by protocol
debug1: Bind to port 22 on 0.0.0.0.
Server listening on 0.0.0.0 port 22.
Generating 768 bit RSA key.
RSA key generation complete.



[ Remarque ]

On a utilisé l'option -d de sshd. Si on se reporte au man de sshd :

-d      Debug mode.  The server sends verbose debug output to the system
	log, and does not put itself in the background.  The server also
	will not fork and will only process one connection.  This option
	is only intended for debugging for the server.  Multiple -d
	options increase the debugging level.  Maximum is 3.

Autrement dit, une seule connexion à la fois au service sshd.






=> Machine "tomoe" :

A présent, on peut se connecter à shinta par ssh.

jack@tomoe:~# ssh jack@<ip shinta>





[ Conclusion ]

Le programme ci-dessus n'est qu'une illustration permettant de montrer ce
qui est faisable mais il est livré sans aucune garantie. On peut imaginer
de lancer sshd sur un autre port que 22 (option -p), de même qu'on aurait
pu augmenter la complexité du segment TCP à envoyer (numéro id, window size,
maximum segment size ... ).



[ Références ]

http://www.hsc.fr/ressources/breves/secretssh.html
http://5hdumat.samizdat.net/coding/c.rezo/sniffpcap.html