IPCRYPT

fredcl Messages postés 547 Date d'inscription mercredi 8 janvier 2003 Statut Membre Dernière intervention 7 octobre 2007 1
13 juin 2003 à 13:52

explication : une adresse ip est composée de 4 parties séparées par des point, chaque partie peut être un monbre entre 0 et 255
255 est le nombre maximal qui peut être codé sur 8 bits soit un unsigned char. l'exemple pose donc directement les valeurs au bon emplacement mémoire du coup pas besoin de décalage.
à prioris danbs l'exemple tout est en C sauf l'inclusion de (elle est mise par defaut par l'IDE) et de toute façon je ne m'en sert pas :o)

looping93290b Messages postés 30 Date d'inscription vendredi 6 juin 2003 Statut Membre Dernière intervention 22 août 2003
13 juin 2003 à 11:16

fredcl merci pour cet exemple, mais je ne comprend pas comment fonction la conversion de o1, o2, o3, o4 en w et l'inverse.

system("PAUSE"); je n'ai pas encore vu cette fonction, que met t'elle en pause.

au fait tu combine le c avec le c++.

fredcl Messages postés 547 Date d'inscription mercredi 8 janvier 2003 Statut Membre Dernière intervention 7 octobre 2007 1
12 juin 2003 à 21:02

Voila c'est beaucoup mieux :o)

J'ai dit plus haut qu'il y avait plusieurs solutions
en voila une (sous windows avec dev-cpp) sans décalage et sans aucun opérateurs :
#include
#include <stdlib.h>

int main(int argc, char *argv[])
{
union {
unsigned long W;
struct {
unsigned char o4;
unsigned char o3;
unsigned char o2;
unsigned char o1;
};
} Mot;

Mot.o1 = 196;
Mot.o2 = 16;
Mot.o3 = 2;
Mot.o4 = 1;

printf("ip 196.16.2.1 => %u
", Mot.W);
Mot.W = 3289382913UL;
printf("entier 3289382913 => ip %u.%u.%u.%u
", (unsigned long)Mot.o1, (unsigned long)Mot.o2, (unsigned long)Mot.o3, (unsigned long)Mot.o4);

system("PAUSE");
return 0;
}

voila

A+

looping93290b Messages postés 30 Date d'inscription vendredi 6 juin 2003 Statut Membre Dernière intervention 22 août 2003
12 juin 2003 à 19:46

fredcl tes explications on porter ses fruits, voila mon nouveaux prog. qu'il suffira d'inserer dans un fichier cpp.

//*******************
//* \ *
//* §§§§\ *
//* !--! @@ *
//* ! ~! @@\ *
//* @@@@@@@@ \ *
//* @@ @@@@ \*
//* @@ @@@@ *
//* #### *
//* ## ## *
//*~~~~~~##~~##~~~~~*
//*~~~~~~##~~##~~~~~*
//*~~~~~~@@@~@@@~~~~*
//*~~~~~~~~~~~~~~~~~*
//*******************
//* * * * * * * * * *
//**** By ***********
//* * * * * * * * * *
//******** Looping **
//* * * * * * * * * *
//*******************

//decryptip.cpp est un prog. qui utilise le decalage binnaire << et >> pour crypter et decrypter des ip.

#include

#include <cstdlib>

using namespace std;

int main()
{
int choixmenuprincipal;

cout << "

";
cout << "
************************************************************";
cout << "
* *";
cout << "
* *";
cout << "
* *";
cout << "
* - 1 - crypter ip. *";
cout << "
* *";
cout << "
* - 2 - decrypter ip. *";
cout << "
* *";
cout << "
* - 3 - quitter. *";
cout << "
* *";
cout << "
* *";
cout << "
* *";
cout << "
************************************************************";
cout << "
* Choisissez une option entre (1) ou (2) ou (3): ";
cin >> choixmenuprincipal;
cout << "************************************************************

";

if( choixmenuprincipal < 1 )
{
return main();
}
if( choixmenuprincipal > 3 )
{
return main();
}
if( choixmenuprincipal == 1 )
{
//fonction de cryptage.

unsigned long bloc1, bloc2, bloc3, bloc4;

cout << "
Entree chaque bloc de l'adresse ip a crypter. (max 255 pour chaque blocs)";
cout << "
Bloc 1 : ";
cin >> bloc1;
cout << "
Bloc 2 : ";
cin >> bloc2;
cout << "
Bloc 3 : ";
cin >> bloc3;
cout << "
Bloc 4 : ";
cin >> bloc4;

unsigned long ipcrypter = (bloc1 << 24) | (bloc2 << 16) | (bloc3 << 8) | bloc4;

cout << "

Votre adresse ip crypter est : " << ipcrypter;
}
if( choixmenuprincipal == 2 )
{
//fonction de decryptage.

unsigned long ipcrypter, bloc1, bloc2, bloc3, bloc4;

cout << "
Entree l'adresse ip crypter. (max 4294967295)
";
cin >> ipcrypter;

bloc1 = (0xFF000000 & ipcrypter) >> 24;
bloc2 = (0x00FF0000 & ipcrypter) >> 16;
bloc3 = (0x0000FF00 & ipcrypter) >> 8;
bloc4 = 0x000000FF & ipcrypter;

cout << "

Votre adresse ip decrypter est : " << bloc1 << "." << bloc2 << "." << bloc3 << "." << bloc4;
}
if( choixmenuprincipal == 3 )
{
exit( EXIT_SUCCESS );
}
return main();
}

looping93290b Messages postés 30 Date d'inscription vendredi 6 juin 2003 Statut Membre Dernière intervention 22 août 2003
12 juin 2003 à 17:47

merci a vous deux OgGiZ et fredcl, ceci sont des exemples bien structurer, je vais les etudier avec beaucoups attention.

merci encore, des que j'aurais bien compris vos explications je m'etrais une nouvelle source sur le site.

mais, si vous avez d'autres explications a donner, elles seront les bien venues.

salut.

fredcl Messages postés 547 Date d'inscription mercredi 8 janvier 2003 Statut Membre Dernière intervention 7 octobre 2007 1
12 juin 2003 à 16:56

Bon alors on part du principe que tu à déjà récupéré et vérifié d'un manierre quelconque les composantes de l'adresse sous la forme p1.p2.p3.p4

// nous avons donc en entrée quatre donnée de ce style
unsigned long p1, p2, p3, p4; // représente p1.p2.p3.p4

// pour convertir l'ip en entier non signé de 32bits on peut faire ceci
p1 = p1 << 24;
p2 = p2 << 16;
p3 = p3 << 8;
unsigned long result = p1 | p2 | p3 | p4;
// ou en écriture plus compacte
unsigned long result = (p1 << 24) | (p2 << 16) | (p3 << 8) | p4;
/*
explication : en binaire un entier sur 32 bits est représenter par une suite de 32 bit qui peuvent prendre la forme d'un 0 ou d'un 1
soit pour 196 => 00000000000000000000000011000100
avec l'opérateur << je décale les bit vers la gauche du nombre indiqué
soit pour 196 << 8 => 00000000000000001100010000000000
ce qui donne en décimal 50176
je faiit donc cette opération de décalage pour chaque partie de l'ip avec un décalage différent suivant la position dans l'adresse
soit pour l'ip 196.16.2.1
00000000000000000000000011000100
00000000000000000000000000010000
00000000000000000000000000000010
00000000000000000000000000000001
on décale à gauche
<<24 => 11000100000000000000000000000000
<<16 => 00000000000100000000000000000000
<<08 => 00000000000000000000001000000000

avec l'opérateur | on récupère tous les bits à 1 sur au moins un des entier soit
11000100000100000000001000000001
ce qui donne en décimal 3289383425
*/
// pour convertir un entier non signé de 32 bits en ip
// on peut faire ceci
p1 = (0xFF000000 & result) >> 24;
p2 = (0x00FF0000 & result) >> 16;
p3 = (0x0000FF00 & result) >> 8;
p4 = 0x000000FF & result;
/*
explication
nous avons donc dans résult 3289383425 ce qui donne en binaire
11000100000100000000001000000001
nous allons appliquer sur cet entier un mask afin d'isoler les groupe de 8 bits qui nous interresse avec l'opérateur &
dans l'exemple les masque sont exprimé sous forme exadécimale ce qui est plus facile à lire que du décimal regardons ce que cela donne en binaire
0xFF000000 => 11111111000000000000000000000000
0x00FF0000 => 00000000111111110000000000000000
0x0000FF00 => 00000000000000001111111100000000
0x000000FF => 00000000000000000000000011111111
donc pour p1 = (0xFF000000 & result) >> 24;
nous appliquons d'abord le masque avec l'opérateur &
resultat => 11000100000100000000001000000001
masque => 11111111000000000000000000000000
nous récupérons donc
11000100000000000000000000000000
puis nous décalons cette fois ci vers la droite avec >> de 24 bits
nous obtenons
00000000000000000000000011000100
ce qui donne bien 196

voila j'espère que tu as tout compris. mais il y a d'autre possibilité pour arriver au même résultat. mais je crois que celle ci est trés rapide
a savoir les décalages sont souvent utiliser pour faire beaucoup plus rapidement certaine opération entière de division ou mutiplication
ex : 164 / 2 équivalent à 164 >> 1

A+
*/

OgGiZ Messages postés 2 Date d'inscription dimanche 13 avril 2003 Statut Membre Dernière intervention 12 juin 2003
12 juin 2003 à 16:28

alors << permet de shifter vers la droite ou vers la gauche.
ex : la chaine binaire 010100, si tu fais >> 1 tu as 01010, si tu fais >> 2 tu as 0101, etc. dans l'autre sens ca rajoute des zéro sur la droite :)

pour le &, c'est un peu plus compliké :

01011
10110 &
---------
00010

bref, si b1[i] et b2[i] sont tt les deux sur 1, alors le résultat en [i] vaut 1 aussi.

il y a egalement | et ^

01011
10110 |
---------
11111

c la même chose sauf qu'au lieu de et on a ou :)

et le ou exclusif : ^

01011
10110 ^
---------
11101

la ca doit etre l'un OU l'autre mais PAS les deux

le | et le & sont souvent utilisés pour marquer des flags :

ex :

#define FLAG_1 (1<<0)
#define FLAG_2 (1<<1)
#define FLAG_3 (1<<2)
// ...

int g_iFlags = 0;

g_iFlags |= FLAG_1;
g_iFlags |= FLAG_2;

if (g_iFlags & FLAG_1)
printf ("le flag 1 est ok
"); // cette ligne s'affichera

if (g_iFlags & FLAG_2)
printf ("le flag 2 est ok
"); // cette ligne s'affichera

if (g_iFlags & FLAG_3)
printf ("le flag 3 est ok
"); // cette ligne s'affichera PAS

pour retirer les flags, tu fais l'opération & de l'inverse ~

g_iFlags &= ~FLAG_1;

tu auras surement remarqué que j'ai utilisé le bit shift (<<) car (important) :

tu peux utiliser 1 car sa valeur binaire est 00000001
tu peux utiliser 2 car sa valeur binaire est 00000010
tu ne peux PAS utiliser 3 car sa valeur est 00000011

bref, si tu prends 3 tu empiète à la fois sur FLAG1 et sur FLAG2

voilà pkoi on utilise un bit shift de 1 (1 << x) pour etre sur de n'utiliser qu'un seul bit

rappel :

sizeof (long) = 32 bits
char = 8 bits
short = 16 bits

par défaut un int est un long mais cela peut etre un short sur certains systèmes.

bon je vais pas ecrire tt un tuto mais ca devrais déjà t'aider :)

looping93290b Messages postés 30 Date d'inscription vendredi 6 juin 2003 Statut Membre Dernière intervention 22 août 2003
11 juin 2003 à 18:20

fredcl, la c'est plus facile de comprendre ton point de vue quand c'est detailler, ta premiere remarque sans conseil ne m'a pas beaucoups aider.

pour les opérateurs de décalage binaire << et >> et l'opérateur binaire &, pourrai tu developper avec des exemples que j'etudirais patiemment.

merci d'avance.

fredcl Messages postés 547 Date d'inscription mercredi 8 janvier 2003 Statut Membre Dernière intervention 7 octobre 2007 1
11 juin 2003 à 14:22

Ce n'est pas une question de débutant ou pas! ni véritablement une question de language. C'est une question de méthode, il semble que tu n'est pas suffisament réfléchi a ce que tu voulais obtenir. On peut faire cela de façon pas trés belle mais la désolé mais c'est le pire!
Une autre méthode que celle donnée par gordhan était d'employer (pour le C.C++) les opérateurs de décalage binaire << et >> et l'opérateur binaire &
désolé de t'avoir affusqué, mais je pense que te dire "c'est bien continue" n'était pas t'aider, et que au contraire te secouer et te pousser a réfléchir un peu plus sur le problème t'aideras certainement beaucoup plus.

looping93290b Messages postés 30 Date d'inscription vendredi 6 juin 2003 Statut Membre Dernière intervention 22 août 2003
10 juin 2003 à 20:58

et doucement, il t'arrive quoi là?
je suis qu'un debutant.

je ne manipule pas encore les tableaux, sinon cela aurai ete plus cours et mieux construit.

fredcl Messages postés 547 Date d'inscription mercredi 8 janvier 2003 Statut Membre Dernière intervention 7 octobre 2007 1
10 juin 2003 à 20:36

Rien qu'au titre j'était presque sur de ce que c'était, rien d'exeptionnel donc. Après avoir vu le code... heu! que dire a part c'est immonde :o( désolé

gordhan Messages postés 19 Date d'inscription lundi 3 février 2003 Statut Membre Dernière intervention 10 juin 2003
10 juin 2003 à 18:29

du coup on peut appeler ca 'conversion' plus ke cryptage, vu ke quand on dit cryptage, ca sous entend que c'est difficile de retrouver l'information originale. et la, bof ;)

gordhan Messages postés 19 Date d'inscription lundi 3 février 2003 Statut Membre Dernière intervention 10 juin 2003
10 juin 2003 à 17:43

bon toi ta bien pigé le truc :) le cryptage cé juste la mise en base 256 de l'adresse ip. donc pour décrypter au lieu d'faire tout ton truc il suffit de faire:
ip_cryptée % 256 = 4eme case
ip_cryptée = ip_cryptée / 256.
ip_cryptée % 256 = 3eme case
ip_cryptée = ip_cryptée / 256.
ip_cryptée % 256 = 2eme case
ip_cryptée = ip_cryptée / 256.
ip_cryptée % 256 = 1ere case
en moins d'un dix millieme de seconde, c'est fait, donc cé un peu plus rapide ke ton truc kan meme :)

Votre réponse