Scanneur de port tcp en ligne de commande

0/5 (10 avis)

Snippet vu 9 749 fois - Téléchargée 36 fois

Commenter

Contenu du snippet

Voici un code documenté afin de donner un exemple simple d'utilisation des socket via Tcp. En fournissant un scanneur de port Tcp.

Le code, l'exe et surtout la documentation se trouvent à l'adresse suivante :

_SebF

http://www.frameip.com
Un site pour les spécialistes IP

Source / Exemple : 


// ********************************************
// Nom : ScanTcp.cpp
// Auteur : SebF AT frameIP.com
// Date de création : 01 octobre 2004
// version : 1.0
// Licence : Cette executable est libre de toute utilisation.
//           La seule condition existante est de faire référence
//           au site http://www.frameip.com afin de respecter le travail d'autrui.
// ********************************************

// ********************************************************
// Les includes
// ********************************************************
#include <C:\\RepPerso\\Personnel\\Developpement\\Projets\\LibrairieSocket\\LibrairieSocket.h>

// ********************************************************
// Les procédures
// ********************************************************
void initiation_des_variables(void);
void gestion_des_arguments(int argc, char* argv[]);
void Changement_aleatoire_des_valeurs(void);
void envoi_de_la_trame(void);
void reception_de_la_trame(void);
void sortie_avec_erreur(int);

// ********************************************************
// Les variables
// ********************************************************
struct ipv4 entete_ipv4;			// Entete IP
struct ipv4 *entete_ipv4_reception;	// Entete IP receptionnée
struct tcp entete_tcp;				// Entete TCP
struct tcp *entete_tcp_reception;	// Entete TCP receptionnée
char data_a_envoyer[65535];			// Data
size_t longueur_de_data_a_envoyer;	// Longueur du char *, je n'utilise pas strlen car il peux y avoir des 0
char trame_a_envoyer[65535];		// Entete IP + data
int nombre_de_caractere_emis;		// Variable récupérant le nombre de caractères émis
char ip_source_initiale[15];		// Adresse IP Source permettant d'initier entete_ipv4.ip_source
char ip_destination_initiale[15];	// Adresse IP Destination permettant d'initier entete_ipv4.ip_destination
bool port_source_aleatoire;			// Acive ou désactive le mode Port Source Aléatoire
unsigned short port_depart;			// Premier port à scanner
unsigned short port_fin;			// Dernier port à scanner
unsigned short port_en_cours;		// Port en cours de scan
unsigned int timeout;				// Temps d'attente maximum en cas de non réponse

LARGE_INTEGER cpu_frequence;
LARGE_INTEGER temps_de_reponse1;
LARGE_INTEGER temps_de_reponse2;

int main (int argc, char* argv[])
	{
	initiation_des_variables();
	gestion_des_arguments(argc,argv);
	printf("\n");
	for (port_en_cours=port_depart;port_en_cours<=port_fin;port_en_cours++)
		{
		entete_tcp.port_destination=htons(port_en_cours);
		Changement_aleatoire_des_valeurs();
		envoi_de_la_trame();
		reception_de_la_trame();
		}
	printf("\n");
	return(1);
	}

void initiation_des_variables(void)
	{
	structure_ip_local reception_des_ip_locales;

	// ********************************************************
	// Affichage de la banniere
	// ********************************************************
	printf("\nScanTcp -  Scan the Tcp ports - Version 1.0.3.8");
	printf("\nCreate on October 01, 2004, Last compilation on October 01, 2004");
	printf("\nCreated by _sebf@frameip.com - http://www.frameip.com");
	printf("\n");

	// ********************************************************
	// Initiation diverse
	// ********************************************************
	srand(GetTickCount());			// Initialise le Random
	QueryPerformanceFrequency((LARGE_INTEGER *)&cpu_frequence); // Initialisation de la fréquence pour le compteur
	timeout=1;
		
	// ********************************************************
	// Initiation des arguments
	// ********************************************************
	strcpy(ip_destination_initiale,"www.linux.org");
	port_source_aleatoire=TRUE;
	port_depart=135;
	port_fin=139;

	// ********************************************************
	// Initialisation des data
	// ********************************************************
	strcpy(data_a_envoyer,"- My Email is : SebF@FrameIP.com - The web site is  : www.frameip.com ");
	longueur_de_data_a_envoyer=strlen(data_a_envoyer);

	// ********************************************************
	// Initialisation de l'entete TCP
	// ********************************************************
	entete_tcp.port_source=0;			// Il est initialisé plutard
	entete_tcp.port_destination=htons(80);
	entete_tcp.sequence=0;				// Il est initialisé plutard
	entete_tcp.accuse=0;
	entete_tcp.reserved=0;
	entete_tcp.offset=5; // taille de l'entête Tcp
	entete_tcp.flag_fin=0;
	entete_tcp.flag_syn=1;
	entete_tcp.flag_rst=0;
	entete_tcp.flag_psh=0;
	entete_tcp.flag_ack=0;
	entete_tcp.flag_urg=0;
	entete_tcp.reserved2=0;
	entete_tcp.window=htons(16384);		// Valeur relevée dans un Netmon après un "Telnet IP port"
	entete_tcp.checksum=0;
	entete_tcp.pointeur=0;

	// ********************************************************
	// Initialisation de l'entete Ip
	// ********************************************************
	entete_ipv4.ihl=5;
	entete_ipv4.version=4;
	entete_ipv4.tos=0;
	entete_ipv4.length=0;
	entete_ipv4.id=0;					// Il est initialisé plutard
	entete_ipv4.offset=0;
	entete_ipv4.ttl=100;
	entete_ipv4.type=6;
	reception_des_ip_locales=recuperation_ip_local(false);
	strcpy(ip_source_initiale,reception_des_ip_locales.adresse_ip_local[0]);
	entete_ipv4.ip_source=resolution_de_nom(false,ip_source_initiale);
	entete_ipv4.ip_destination=resolution_de_nom(TRUE,ip_destination_initiale);
	}

void gestion_des_arguments(int argc,char* argv[])
	{
	char *caractere_non_convertit;
	int i;

	// ********************************************************
	// Affichage de l'aide
	// ********************************************************
	if ( (argc>1) && (strcmp(argv[1],"-?")==0) || (argc==1) )
		{
		printf("\n");
		printf("\n-?                This help");
		printf("\n-ip_destination   @IP destination                Default value: %s",ip_destination_initiale);
		printf("\n-ip_source        @IP source                     Default value: %s",ip_source_initiale);
		printf("\n-port_source      Port TCP source (0 to random)  Default value: %d",entete_tcp.port_source);
		printf("\n-port1            First Port                     Default value: %d",port_depart);
		printf("\n-port2            Last Port                      Default value: %d",port_fin);
		printf("\n-timeout          Maximum wait (s).              Default value: %d",timeout);
		printf("\n");
		printf("\nsample :\nscantcp -ip_destination www.google.fr -port1 79 -port2 81");
		printf("\n\n");
		exit(0);
		}

	// ********************************************************
	// Récupération des arguments
	// ********************************************************
	for (i=1;i<argc;i=i+1)
		{
		if (strcmp(strlwr(argv[i]),"-ip_source")==0)
			entete_ipv4.ip_source=(unsigned long)resolution_de_nom(FALSE,argv[i+1]);
		if (strcmp(strlwr(argv[i]),"-ip_destination")==0)
			entete_ipv4.ip_destination=(unsigned long)resolution_de_nom(FALSE,argv[i+1]);
		if (strcmp(strlwr(argv[i]),"-port_source")==0)
			if (argv[i+1]==0)
				port_source_aleatoire=TRUE;
			else
				{
				port_source_aleatoire=FALSE;
				entete_tcp.port_source=htons((unsigned short)strtod(argv[i+1],&caractere_non_convertit));
				}
		if (strcmp(strlwr(argv[i]),"-port1")==0)
			port_depart=(unsigned short)strtod(argv[i+1],&caractere_non_convertit);
		if (strcmp(strlwr(argv[i]),"-port2")==0)
			port_fin=(unsigned short)strtod(argv[i+1],&caractere_non_convertit);
		if (strcmp(strlwr(argv[i]),"-port_destination")==0)
			entete_tcp.port_destination=htons((unsigned short)strtod(argv[i+1],&caractere_non_convertit));
		if (strcmp(strlwr(argv[i]),"-timeout")==0)
			timeout=(unsigned int)strtod(argv[i+1],&caractere_non_convertit);
		}
	}

void Changement_aleatoire_des_valeurs()
	{
	// ********************************************************
	// Random de l'ID IP
	// ********************************************************
	entete_ipv4.id=(unsigned short)(rand()%65536);					// Tire entre 0 et 65535
                 
	// ********************************************************
	// Random du Port Source
	// ************************************************* *******
	if (port_source_aleatoire==TRUE)
		entete_tcp.port_source=(unsigned short)(rand()%64511+1+1024);	// Tire entre 1025 et 65535

	// ********************************************************
	// Random de la séquence TCP
	// ********************************************************
	entete_tcp.sequence=(unsigned short)(rand()%65536);				// Tire entre 0 et 65535
	}

void envoi_de_la_trame(void)
	{
	WSADATA initialisation_win32;
	SOCKADDR_IN information_sur_la_destination;
	SOCKET id_de_la_socket_envoi;
	int tampon;
	int error;

	// ********************************************************
	// Initialisation de la Socket
	// ********************************************************
	error=WSAStartup(MAKEWORD(2,2),&initialisation_win32);
	if (error!=0)
		sortie_avec_erreur(1);
	id_de_la_socket_envoi=socket(AF_INET,SOCK_RAW,IPPROTO_RAW);
	if (id_de_la_socket_envoi==INVALID_SOCKET)
		sortie_avec_erreur(2);

	// ********************************************************
	// Activation de l'envoi de l'entete IP
	// ********************************************************
	tampon=1;
	error=setsockopt(id_de_la_socket_envoi,IPPROTO_IP,IP_HDRINCL,(char *)&tampon,sizeof(tampon));
	if (error!=0)
		sortie_avec_erreur(3);

	// ********************************************************
	// Calcul du checksum TCP
	// ********************************************************
	entete_tcp.checksum=calcul_du_checksum_tcp(FALSE,entete_ipv4.ip_source,entete_ipv4.ip_destination,entete_tcp,data_a_envoyer);

	// ********************************************************
	// Préparation de la trame à envoyé
	// ********************************************************
	memcpy(trame_a_envoyer,(unsigned short *)&entete_ipv4,sizeof(struct ipv4));
	memcpy(trame_a_envoyer+sizeof(struct ipv4),(unsigned short *)&entete_tcp,sizeof(struct tcp));
	memcpy(trame_a_envoyer+sizeof(struct ipv4)+sizeof(struct tcp),data_a_envoyer,longueur_de_data_a_envoyer);

	// ********************************************************
	// Paramètre nécessaire au sendto
	// ********************************************************
	information_sur_la_destination.sin_family=AF_INET;
	information_sur_la_destination.sin_addr.s_addr=entete_ipv4.ip_destination;

	// ********************************************************
	// Démarrage du chrono
	// ********************************************************
	QueryPerformanceCounter((LARGE_INTEGER *) &temps_de_reponse1);

	// ********************************************************
	// Envoi de la trame
	// ********************************************************
	nombre_de_caractere_emis=sendto(id_de_la_socket_envoi,trame_a_envoyer,sizeof(struct ipv4)+sizeof(struct tcp)+longueur_de_data_a_envoyer,0,(struct sockaddr*)&information_sur_la_destination,sizeof(information_sur_la_destination));
	if (nombre_de_caractere_emis<1)
		sortie_avec_erreur(4);
	
	// ********************************************************
	// Fermeture de la socket correspondant à la commande socket()
	// ********************************************************
	closesocket(id_de_la_socket_envoi);

	// ********************************************************
	// quite propement le winsock ouvert avec la commande WSAStartup
	// ********************************************************
	WSACleanup(); //  (A appeller autant de fois qu'il a été ouvert)
	}

void reception_de_la_trame()
	{
	WSADATA initialisation_win32;
	SOCKADDR_IN information_sur_la_source;
	SOCKET id_de_la_socket_ecoute;
	DWORD  lpcbBytesReturned;
	int tampon; // Variable temporaire
	int error; // Permet de récuupérer le numéro d'erreur des fonctions
	int duree_de_la_boucle;
	unsigned int sortie_de_la_boucle; // 0="ne pas sortir" 1="sortir avec port ouvert" 2="sortir avec port fermé"
	int nombre_de_caractere_recu;
	char buffer_de_reception[65535];
	double temps_de_reponse; // Variable indiquant le temps écoulé entre l'envoi et la reception

	// ********************************************************
	// Initialisation de la Socket
	// ********************************************************
	error=WSAStartup(MAKEWORD(2,2),&initialisation_win32);
	if (error!=0)
		sortie_avec_erreur(1);
	id_de_la_socket_ecoute=socket(AF_INET,SOCK_RAW,IPPROTO_IP);
	if (id_de_la_socket_ecoute==INVALID_SOCKET)
		sortie_avec_erreur(5);

	// ********************************************************
	// Lien entre la socket et l'IP d'écoute
	// ********************************************************
	information_sur_la_source.sin_family=AF_INET;
	information_sur_la_source.sin_addr.S_un.S_addr=entete_ipv4.ip_source;
	error=bind(id_de_la_socket_ecoute,(SOCKADDR *)&information_sur_la_source, sizeof(information_sur_la_source));
	if (error==SOCKET_ERROR)
		sortie_avec_erreur(6);

	// ********************************************************
	// Choix du mode de la socket
	// ********************************************************
	tampon=1;
	error=WSAIoctl(id_de_la_socket_ecoute,SIO_RCVALL,&tampon,sizeof(tampon),NULL,0,&lpcbBytesReturned,NULL,NULL);
	if (error==SOCKET_ERROR)
		sortie_avec_erreur(7);

	// ********************************************************
	// Passage de la socket en mode non bloquant
	// ********************************************************
	tampon=1;
	error=setsockopt(id_de_la_socket_ecoute,SOL_SOCKET,SO_RCVTIMEO,(char *)&tampon,sizeof(tampon)); // La commande recv attend 1 (on) ms avant de rendre la main
	if (error!=0)
		sortie_avec_erreur(8);

	// ********************************************************
	// Création de la boucle d'attente
	// ********************************************************
	QueryPerformanceFrequency((LARGE_INTEGER *)&cpu_frequence);
	duree_de_la_boucle=GetTickCount();
	sortie_de_la_boucle=0;
	while (sortie_de_la_boucle==0)
		{
		nombre_de_caractere_recu=recv(id_de_la_socket_ecoute,buffer_de_reception,65535,0);
		if (GetTickCount()-duree_de_la_boucle>(unsigned)(timeout*1000))
			sortie_de_la_boucle=2;
		else if (nombre_de_caractere_recu!=-1)
			{
			// ********************************************************
			// Extraction et  des valeurs recues
			// ********************************************************
			entete_ipv4_reception=(struct ipv4 *)buffer_de_reception;
			entete_tcp_reception=(struct tcp *)(buffer_de_reception+20);
						
			// ********************************************************
			// Validation de la conformité de la reception
			// ********************************************************
			if (entete_ipv4_reception->ip_source==entete_ipv4.ip_destination)
			if (entete_ipv4_reception->ip_destination==entete_ipv4.ip_source)
			if (entete_ipv4_reception->type==6)
			if (entete_tcp_reception->port_source==entete_tcp.port_destination)
			if (entete_tcp_reception->port_destination==entete_tcp.port_source)
			if (entete_tcp_reception->flag_syn==1)
			if (entete_tcp_reception->flag_ack==1)
				sortie_de_la_boucle=1;
			}
		}

	// ********************************************************
	// Affichage du résultat
	// ********************************************************
	if (sortie_de_la_boucle==1)
		printf("Le port Tcp %d pour l'Ip %s est ouvert.\n",port_en_cours,convertion_ip(entete_ipv4.ip_destination));
	else
		printf("Le port Tcp %d pour l'Ip %s est ferme.\n",port_en_cours,convertion_ip(entete_ipv4.ip_destination));
	}

void sortie_avec_erreur(int error)
	{
	if (error==1)
		printf("\nSorry, I can't initialize WSAStartup - www.frameip.com.");
	if (error==2)
		printf("\nSorry, I can't initialize Socket - www.frameip.com.");
	if (error==3)
		printf("\nSorry, I can't initialize SetSockOpt - www.frameip.com.");
	if (error==4)
		printf("\nSorry, I can't send the frame - www.frameip.com.");
	if (error==5)
		printf("\nSorry, I can't initialize the Socket to listen the answer - www.frameip.com.");
	if (error==6)
		printf("\nSorry, I can't bind the Socket - www.frameip.com.");
	if (error==7)
		printf("\nSorry, I can't set the Socket's mode - www.frameip.com.");
	if (error==8)
		printf("\nSorry, I can't initialize SetSockOpt - www.frameip.com.");

	printf("\nError code      : %d",error);
	printf("\nWSAGetLastError : %d",WSAGetLastError());
	printf("\n\n");
	exit(0);
	}

A voir également

Ajouter un commentaire Commentaires
uxtobirza Messages postés 16 Date d'inscription dimanche 2 février 2003 Statut Membre Dernière intervention 3 juin 2008
13 juin 2008 à 11:46
bonjour,

serait-il possible de voir le header, ou sinon là où sont déclarés les includes et la structure ipv4 ?

<C:\\RepPerso\\Personnel\\Developpement\\Projets\\LibrairieSocket\\LibrairieSocket.h>
<> c'est par défaut pour le répertoire include du compilateur
"" c'est par défaut pour le répertoire courant du projet, l'endroit le plus recommandé pour mettre les fichiers à inclure. (défaut, c.a.d si aucun chemin n'est précisé)
Il vaut mieux éviter au maximum d'utiliser des chemins.
C:\RepPerso\Personnel\Developpement\Projets\LibrairieSocket\
ne sera pas portable.

Sinon, je serai curieux de pouvoir compiler cette source.
_sebf Messages postés 42 Date d'inscription jeudi 1 avril 2004 Statut Membre Dernière intervention 7 octobre 2006
2 nov. 2004 à 17:25
Hi,

Oui, je préférais utiliser le mode raw en basculant au niveau 3, ceci afin d'outrepasser la gestion Tcp de l'Os. Cela permet comme le dit aardman, ca me permet de n'envoyer qu'un datagramme Syn.

Pour la remarque sur l'initialisation de WSAStartup, tu as raison :)

En ce qui concerne les if, je les ai mis à suite pour être plus pédagogique :) et aussi parceque je ne suis pas un pro du dev :)

_SebF

http://www.frameip.com
Un site pour les spécialistes IP
cs_Urgo Messages postés 780 Date d'inscription lundi 16 décembre 2002 Statut Membre Dernière intervention 16 avril 2009 1
2 nov. 2004 à 16:56
lol aardman je me disais aussi :)
cs_aardman Messages postés 1905 Date d'inscription mercredi 22 janvier 2003 Statut Membre Dernière intervention 17 septembre 2012 3
1 nov. 2004 à 21:43
Salut,
Non c'est moi qui suit a l'ouest, je regardais pas le meme bloc d'if que toi ;)
En effet pour la fonction qui gere les erreurs un swicth est mieux.
cs_AlexMAN Messages postés 1536 Date d'inscription samedi 21 décembre 2002 Statut Membre Dernière intervention 24 mai 2009 1
1 nov. 2004 à 21:02
Jdois etre carrement a l'ouest ce soir ! dsl
Mais il ne peut pas etre egal a 1, a 2, 3, 4... etc ??
S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (_sebf)