Bah tiens un article sur le C en réso c'est poa mal non? ;-)
Ok ici on va donc voir comment on se connecte à une bécane pour y faire
plein de truc plus tard!
Allez go! :-)

O dieu C language suprême parmis les languages laisse moi montrer ta force
quand on veux hacker une box! :-)) Bon trêve de c... passons aux choses
sérieuses: j'suppose pour cette rubrique que vous connaissez bien le C de
base (unix évidemment hehe :-))

Ok alors go...
Bon j'résume pour ceux qui connaissent vraiment que dalle au net: pour
communiquer avec une bécane, y faut une adresse IP, un port distant & bien
sur un protocole (ici le TCP/IP). Bon!
Donc pour faire un prog qui se log sur un becane y faut d'abord gérer l'host
(DNS ou IP) et ensuite y faut gérer le port qu'on veut entrer en contact
avec (???):

Donc dans un premier temps on appelle les librairies qui vont nous fournir
tout ça (standards):
sys/types.h
sys/socket.h
unistd.h
netinet/in.h
netdb.h
Ces libs contiennet les fonctions spéciales de connexion (connect(),
socket(), et les defs des structures utilisees entre autres...)

Bon ensuite y faut definir une structure sockaddr_in pour la gestion de
l'host, qui contient les champs:
sin_family (domaine)
sin_addr (adresse de l'host)
sin_port (port)

Ensuite faut une aut' structure pour la gestion du port, qui s'apelle
hostent (attention c'est un pointeur vers structure qui faut definir!!!);
celle la a les champs:
h_addrtype (domaine)
h_addr (adresse du port)

Voilà. Maintenant faut remplir les structures:
On fait un gethostbyname(host) pour remplir hostent avec les renseignements
de host: ainsi les champs h_addrtype et h_addr sont remplis automatiquement;
on a donc le domaine dans h_addrtype et l'adresse de l'host dans h_addr.

Ensuite faut mettre l'host et le port en relation (ben ouais y'a pas de
raison qu'le compilo pige que le port appelé est sur l'host qui traîne 10
lignes au-dessus! ;-))
sin_family prend la valeur de h_addrtype pour mettre en relation le domaine.
sin_addr prend la valeur de h_addr pour la relation avec l'adresse de l'host.
enfin, sin_port prend la valeur de htons(port) où port est le port à appeler
: on utilise htons() pour pas qu'y est de problèmes au niveau des ENDIANS,
pac'que un sparc et un pentium c'est pas la même organisation de bits
(organisation des poids faibles et forts pas pareil dans la mem)...

Vla; maintnant y reste plus qu'à interconnecter le tout ce qu'on fait à
l'aide d'un socket:
en gros un socket ç'est une espèce de protocole de communication entre deux 
trucs. Ici ca sert pour établir une sorte de channel entre ta bécane et
l'host distant (c'est surtout utilisé dans la communication inter-processus).
Y'a principalement deux types de socket: les STREAM et les RAW; ici on
utilise un STREAM mais faut un RAW si on veut avoir accès à plein de trucs
internes à la bécane (ba tiens ca sert pour un snifffffer ça ;-))

Bon en gros les fonctions marche comme ça:
descripteur=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
                     /\         /\         /\
                      |          |          |
                unix protocol   deja vu    tcp protocol

descripteur=connect(sok,&adrs,sizeof(adrs));
                     /\   /\          /\
                      |    |           |
                   socket struct      taille de la struct sockaddr_in
                          sockaddr_in

Bon allez on voit tout d'suite un exemple bidon histoire de concrétiser tout
 ça...

-==========================================================================-

/* connexion sur le port 25 de victim.com */

#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <netinet/in.h>
#include <netdb.h>

main()
{
char *host="www.victim.com";
int sok, port=25;
struct sockaddr_in adrs;
struct hostent *hst;

        /* on recup les infos de l'host dans hst et on verifie qu'il est
atteignable */

        if (!(hst=gethostbyname(host))) exit(0);

        /** on met les relations en place **/
        /* d'abord le domaine */
        adrs.sin_family=hst->h_addrtype;

        /* puis l'adress */
        adrs.sin_addr=*(struct in_addr *)hst->h_addr;

        /* enfin on remplit le port */
        adrs.sin_port=htons(port);

        /* la on cree un socket: faut toujours mettre les
           même champs c'est pour dire que c'est une connexion unix sur ip
	  en stream*/
        sok=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

        /* on etablit la connec */
        connect(sok,&adrs,sizeof(adrs));
}

-==========================================================================-

Boilà en gros comment on fait du networking sous sys unix! :-))

Bref; ben avec ça y faut lire les man, potasser le tout, (matter les
fonctions avoisinantes style  recv() et send() pour gerer du data...) Et
après y'a plus qu'à ecrire des outils! ;-))

Allez un chtit scanner de port livré avec; j'explik rapide comment ca marche
:
* on demande un port de fin en parametre (pas plus que 65635 sinon c plus
  code! :-))
* on fait une boucle sur tous les ports de 0 à port_max (en parametre donc)
  en faisant c'qu'on a vu plus haut: remplissage champs, creation socket,
  connexion au port.
  Si ca echoue c'est que le port est ferme sinon il est ouvert! ;-)
* Bon et pis c'est assez commente dans le prog; donc c du tout cuit...


-==========================================================================-
-==========================================================================-

Bon les greetz y'a poa grand chose à dire pac'que j'ai la flemme (hehe); bon
allez greetz aux PsYkO cOrP en particulier! Et pis greetz à tous les
developpers sous sys UNIX, à tous les hackers et viiiiive linux/a mort
microsoft et pis vive la prog tiens... ;-))

Hep dont forget d'aller sur not page <www.altern.org/psyko>! :-))

Bah oui si t'as un pb ou des remarks pas de probs si c'est bien
mail hackira@hotbot.com < ckeTAaDIR sinon ckeTAaDIR > /dev/null; bon allez
maintnant HACKira > /dev/lit... |-()