CRYPTO ENIGMA
cs_Kirua
Messages postés
3006
Date d'inscription
dimanche 14 avril 2002
Statut
Membre
Dernière intervention
31 décembre 2008
-
18 avril 2004 à 01:37
coucou747 Messages postés 12303 Date d'inscription mardi 10 février 2004 Statut Membre Dernière intervention 30 juillet 2012 - 31 juil. 2004 à 13:35
coucou747 Messages postés 12303 Date d'inscription mardi 10 février 2004 Statut Membre Dernière intervention 30 juillet 2012 - 31 juil. 2004 à 13:35
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
https://codes-sources.commentcamarche.net/source/22021-crypto-enigma
https://codes-sources.commentcamarche.net/source/22021-crypto-enigma
31 juil. 2004 à 13:35
a ^d % n
si je fais comme je faisais dans mon programme de crypto, je fais faire ramer mon beau 2.4 ghtz...
dnc, je sais pas, je vais voir avec la boucle, si c'ets trop lent, je vais voir en tentant de m'aprocher de puissances de deux, et finir a la main...
31 juil. 2004 à 08:58
En fait, faire une opération puissance sur deux grands nombres, ca donne des nombres énormissimes (mais vraiment énormissimes).
Alors si tu préfère tu peux faire la puissance modulaire (a^b mod c) car c'est plus simple et ca sert beaucoup plus si tu veux faire de l'arithmétique modulaire (crypto, etc...)
De quoi a tu besoin ? Je me renseigne sur les racines.
29 juil. 2004 à 18:57
Pour les racines, une source a été posté ici pour ça, je vais y jeter un oeil.
25 juil. 2004 à 15:16
echo 'a href="pagesuivant.html">OK'
}
Donc voila, c'est pas vraiment compliqué a faire
J'ai mis aucun accès a base de donnée, aucun apel au system, enfoin voila, juste un script pas très compliqué..
25 juil. 2004 à 15:10
Par contre, je sais ce que certains font, mais à mon avis ca nécessite de pas trop mauvaises connaissances en PHP:
-le site envoie au client une id de session.
-le client dispose de 3 éssais avec cet id de session.
- si qqun éssaie un id de session qui n'a pas été fournit par le serveur aors le passe est ignorer.
Certains web mails fonctionnent ainsi. À moins d'avoir beaucoup de chance et de tomber sur un id valide, c'est très sur.
Y'a pas une fonction random en PHP ?
25 juil. 2004 à 13:40
Sous linux, pour éviter les attaques de ce style, on fait en sorte que l'identification prenne trois secondes... pourais tu m'indiquer de quelle façon je pourais faire ceci en php ? (eh oui, je débutte aussi en php lol) je sais la faire en javascript, mais je n'arrives pas a lier les deux
25 juil. 2004 à 13:22
Au moins maintenant, c'est plus sur.
À part par force brute et ou avec des dicos on devrait pas pouvoir entrer.
24 juil. 2004 à 23:13
j'y ai pas mis du rsa, et c'est surement pas parfait, mais ça marche et ça me suffit...
17 juil. 2004 à 08:13
16 juil. 2004 à 22:47
Merci pour tout vos commentaires
16 juil. 2004 à 21:29
Mais ici, j'avais mis .exe pour faire comme sous windows même si l'extension n'a pas d'importance sous ces systèmes. Donc ici, c'est bien l'exe qu'il faut exécuter, mais j'aurais pu ne pas lui mettre d'extension.
16 juil. 2004 à 20:12
16 juil. 2004 à 16:45
complexe.o c'est normalement un fichier qui contient du code précompilé mais pas encore linké, donc qui n'a pas de raison de s'exécuter.
À la ligne 3, après -o pour le linkage, y'a le nom de sortie du prog (.exe) puis les .o à linker.
14 juil. 2004 à 20:43
Merci
au fait, c'est pas
./ complexe.exe
mais
./ complexe.o
14 juil. 2004 à 20:39
Je tente de me rappeler (en fait j'ai ca dans des fichiers texte et je cherche mais chut !! faut pas le dire)...
Bon, là j'ai un exemple très primaire, mais ca donne à peu près ça (et ca marche pour tout les modes consoles je pense):
Compilation de principal.c (ou cpp):
g++ -c principal.c
Idem complexe.c
g++ -c complexe.c
Linkage des fichiers objets et configuration de l'exe:
g++ -o complexe.exe principal.o complexe.o
Exécution du prog:
./ complexe.exe
Il n'y a pas besoin de compiler les Headers, ca ce fait tout seul grace au #include des .c(pp)
14 juil. 2004 à 19:17
On ne peut donc pas faire en sorte que les calculs se fassent automatiquement ? On devra faire obligatoirement
a=somme(b, c);
on ne pouras pas faire
a=b+c;
enfin, pas en C
C'est pas bien ça...
Sous linux, c'est quoi la ligne de commande pour compiler du c++ ?
14 juil. 2004 à 13:11
Le C++ est globalement mieux pour la réutilisation de code, la POO et la définition de types, mais c'est vrai que si on peux le faire en C c'est un peu mieux
D'une c'est plus clair,
de deux légèrement plus performant,
de trois, le désassemblage sera plus compréhensible car C est proche de l'ASM mais C++ bien trop complexe.
Tout ce qui est programmable en C++ l'est en C, même les objets qui n'existent qu'à un stade totalement primitif. Ce sont deux langages qui ont un pouvoir d'expression équivalent. De toute façon, ils sont complets vis à vis de la machine (ie: tout ce qu'une machine peut faire peut être programmé en C ou C++).
Seulement C++ est moins désordre que C pour les trucs comme les objets etc...
Le C se programme d'un façon plus complexe pour ces trucs.
Sinon, ben pour ce que tu veux faire, tu peux le faire assez simplement en C mais n'utilise jamais les opérateurs de résolution de portée ( le :: ) c'est seulement pour les classes.
Etapes pour programmer des objets en C:
faire une structure / union (pour plus de dynamisme de type) qui contient les données nécéssaire à l'objet (exemple, celle nécessaires pour définir un grandnombre).
Faire les fonctions suivantes: une fonction d'initialisation
puis des foncitons de modificatoins et de calcul.
Exemple:
struct complexe {
float real, img;
}
void initialise(complexe& in, float _real=0; float _img=0)
{
in.real= _real;
in.img= _img;
}
complexe somme(const complexe& op1, const complexe& op2)
{
complexe out;
out. real= op1.real + op2.real;
out. img= op1.img + op2.img;
return complexe;
}
Bon, moi je fais pas tellement de C, alors y'a certainement des erreurs: par exemple je crois que le passage par référence n'existe pas en C
De plus j'ai pas fait operator+ mais somme car je crois que operator n'existe pas non plus.
Ensuite si je faisais une fonction d'affichage je ferais:
ofstream& operator<<(ofstream& os, complexe a)
{
os << a.img << "i + " << a.real;
return os;
}
ca permettrait de faire cout << a; avec a un nombre complexe.
Par contre, c'est du C++ pur et en C ca n'a aucune valeur (cout c'est du C++, le << aussi, la redef d'op, les références, etc...).
Tout ca pour dire qu'on peux programmer du C en environnement C++, c'est à dire en programmant avec tout les outils de C++ mais en programmant façon C.
Je sais pas si c'est plus rapide à l'exécution.
Je ne sais pas trop de choses sur C.
14 juil. 2004 à 11:45
il y a un bug dans votre méthode :
On cherche a/b:
Na= nombre de bit de a;
r=0; q=0;
1) r += bit Na de a
2) tant que (r>b) faire sinon, aller a 4
3) q++; r -= b;
4) Si Na <= 0 alors FIN
5) Na--; q*=16; r*= 16; aller à 1)
Enfin, remplacer 16 par la base utilisée, maisc'est a peu près ça...
Merci
14 juil. 2004 à 11:29
grandnombre grandnombre::operator +(...
et pour faire cela, il faut que grandnombre soit le nom d'une classe. Dans ton code c'est le nom d'un type qui est en fait une structure. Il faut plutôt faire ca:
class grandnombre {
private:
// là tu met tout tes bidules comme char valeur[256]
// etc...
public:
// Ici, les fonctions comme operator+(grandnombre a);
// Plus une qui se nomme grandnombre() qui ne
// renvoie rien et qui construit l'objet (éventuellement
// vide)
};
Ensuite tu définis dans un .cpp les fonctions avec le grandnombre:: comme tu l'as fait.
Je crois que tu devrais lire des docs sur le net sur la POO et surtout sur l'utilisation de classes, parce que la je te sens un peu dans le brouillard (ce qui est normal pour commencer). Mais tenter de programmer en classe sans connaitre leurs manipulation relève du coup de génie (ou de chance).
14 juil. 2004 à 11:24
Je vais le remettre en gros:
Voila un algo pour la division (complète, donc avec quotient et modulo):
On cherche a/b:
Na= nombre de bit de a;
r=0; q=0;
1) r += bit Na de a
2) Si r < b alors aller à 4)
3) q++; r -= d;
4) Si Na <= 0 alors FIN
5) Na--; q <<=1; r <<= 1; aller à 1)
NOTE: on note le n-ième bit de a, le n-ième en partant de la droite. Ainsi, le bit 0 est celui de poid le plus faible.
En gros, ca revient une nouvelle fois à faire la division manuelle que l'on connait très bien (mais en binaire).
De plus le binaire est plus favorable, car on a pas besoin de se poser la question "en x combien de fois y" comme l'on fait d'habitude, car ici, si x>y, ben c'est une fois, sinon c'est 0.
Seul gros problème: pour que cet algo soit rapide, les opérations de shifts doivent être super optimisées parce qu'il y'en a pas mal.
Mais comme tu ne vas utiliser que 2 ou 4 mots, ca va être très rapide (2 ou 4 shifts normaux).
13 juil. 2004 à 14:55
typedef struct /*ceci est la ligne 1*/
{
char valeur[256];
int unsigned long taille;
}grandnombre;
/*ligne 6*/
grandnombre grandnombre::operator +(grandnombre a,grandnombre b){
grandnombre c;
int signed i, r=0;
for (i=0; i <256 ; i++) /*ligne 10*/
c.valeur[i]=0;
c.taille=0;
for (i=0; i<max( taille, taille );i++)
c.valeur[i]+=( a.valeur[i] + b.valeur[i] + r ) % 256;
if ( a.valeur[i] + b.valeur[i] > 255 ){
r=1; /*la retenue*/
}else{
r=0; /*pas de retenue*/
}
return c;
}
et j'ai toujours pas compris comment on pouvais faire les divisions...
Je tape dans une console
bash-2.05b$ gcc classe.c
classe.c:7: error: syntax error before ':' token
classe.c:10: error: syntax error before "for"
bash-2.05b$
alors voila, j'ai pas besoin de faire ./a.out pour comprendre que ça ne marchera pas...
je ne sais pas d'ou vient le bug, le c devrait pouvoir accepter les objets non ?
Voila, on en reviens toujours au même problème, le c est-il fait pour la poo ?
7 juil. 2004 à 20:05
un tableau non signé de 256 cases de chacune 4 bits
et la taille que je passerais par contre en char, ce qui me permetra de pouvoir gerer des nombres un peu plus grand (4*256 bits, c'est largement suffisant...lol), de pouvoir les enregistrer facilement dans un fichier, ect.
Mais je ne metrais pas de quoi gerer les nombres a virgules, ni les nombres négatifs, car en rsa, on ne s'en sert pas, alors ce sera peut-être pour dans quelques années quand je retoucherais mon programme, mais pas tout de suite.
7 juil. 2004 à 19:39
Par contre, faut voir comment ca marche pour des BigInt codés sur plusieurs mots. Parce que ma méthode marche et est performante à deux conditions:
- que le shift (décalage de bits) fonctionne et soit super rapide, ce qui n'est généralement pas le cas car il nécessite parfois un redimensionnement si la taille du BigInt est dynamique (en nbre de mots).
Demain je tacherais d'écrire ca.
7 juil. 2004 à 17:41
Hmmm, attend finalement je viens de réflechir au principe
En fait, il y'a peut être plus simple et plus rapide.
Je mettrais un message, pour linstant j'étudie comment fonctionne une division dans un process et je reviens
P.S: j'en ai peut être pour longtemps
7 juil. 2004 à 16:50
Comme languages oo, j'utilise le c, et le javascript, c'est tout, mais je n'ai jamais eu de cours d'informatque, et mon père ne m'a rien apris (sauf si on considère le html comme qqch lol) donc, j'ai tout apris dans des livres, des pages mùan en anglais, la touche f1 ou des sites... Donc, en 4 ans, utiliser 4 languages c'est pas mal.
Donc, ça marche ça...
Dans votre explication sur la division, a un moment, vous divisez c=c1 c2 c3 par b=b1 b2 et donc, vous êtes obligé de prendre b en entier a ce moment la, et donc, comme b devra être lui aussi énorme... l'ordi ne va pas savoir le faire, et moi, non plus... Vous aviez mis dans votre explication que vous détaillerez ceci plus tard, et vous ne l'avez pas fait...
(ou alors je suis aveugle)
7 juil. 2004 à 16:33
Ensuite, ce que tu as mis, c'est de la POO version C (et, oui, même si C n'est pas orienté objet, la POO existe).
Bref, en C++ avec les classes, c'est presque pareil, sauf que toutes les fontions (comme complexe operator+(comlpexe)) sont réunis directement dans la structure et non à côté.
7 juil. 2004 à 14:23
poo c surchagre d'opérateurs class
et j'ai trouvé un truc comme ça, je ne l'ai pas compilé, j'éspère que ça marche (je vais le modifier pour obtenir ma librairie)
je posterais ma librairie quand je l'aurais terminé
struct complexe {
float reel, imaginaire;
};
complexe operator +(complexe z1, complexe z2) {
complexe z;
z.reel = z1.reel+z2.reel;
z.imaginaire = z1.imaginaire+z2.imaginaire;
return z;
}
complexe operator *(complexe z1, complexe z2) {
complexe z;
z.reel = z1.reel*z2.reel-z1.imaginaire*z2.imaginiare;
z.imaginaire = z1.reel*z2.imaginaire+z1.imaginaire*z2.reel;
return z;
}
void main (void)
{
complexe z, z1={1., 1.}, z2={3., 2.};
// Addition avec l'opérateur + surchargé
z=z1+z2;
cout << "z=" << z.reel << "+" << z.imaginaire << "\n";
// Multiplication avec l'opérateur * surchargé
z=z1*z2;
cout << "z=" << z.reel << "+" << z.imaginaire << "\n";
}
7 juil. 2004 à 12:45
*(c+i+j-1)=*(a+i) * *(b+j);
niormalement, c'est ça.
7 juil. 2004 à 12:42
(ou alors je suis aveugle)
6 juil. 2004 à 15:17
T'imagines si t'applique ça à RSA ?
Avec des nombres de 1024 bits, tu vas faire des soustractions toute ta vie ! :-)
Nan, en fait, je rexplique vite fait le principe du truc:
en fait, tu codes tes nombres sur des mots (unsigned long ou short).
Le processeur, lui il sait faire les opérations sur des mots.
Alors par exemple, pour le +, ce que tu fais, c'est que t'additionne les mots un à un en commencant par les plus faibles (ceux qui sont le plus à droite du mot dans la notation std (BigEndian), bref, les mots de poids faible) et tu regarde s'il y'a une retenue. Ensuite tu additionne les deux mots suivant en prenant soin d'ajouter la retenue. Pour els additionner, c'est juste un plus puisque c'est des entiers machines.
Bon, ca c'est pour +, mais pour / c'est un peu différent. Même si bien sur c'est le même principe. Sauf qu'ici, tu procède comme pour diviser à la main: t'as a=A1 A2 A3 A4 et b= B1 B2 où Ai et Bj sont des mots.
Alors tu fais, soit c, un BigInt vide (=0). c= 0
alors tu fais:
c= A1 puis tu compares c avec b. Tant que c est plus petit que b, tu reprend un nouveau mot. Ici, supposons que A1 < B1 B2. Alors:
c= A1 A2
maintenant on compare, et !!! au magie, c >= b
En fait ca reviens à dire qu'on choisi c tel qu'il soit divisible (Euclidiennement) par b, parce que s'il est plus petit, on peux pas le diviser (du moins ca donnera 0 et c'est pas intéressant).
Alors mnt: c= A1 A2 et b= B1 B2
dans tout les cas, le nombre de mots de C sera soit égal à celui de b soit supérieur de 1
Cette divisoin est plus simple à réaliser, je le détaillerais après.
Donc tu fais cette division (c/b) et tu met le reste dans c et le quotient (qui ne fera pas plus d'un mot) tu l'ajoute à la suite d'un nombre qui sera ton résultat. Bon, la c'est la première itération, donc qQ1 où Q1 le résultat de c/b
Donc, mnt tu as c= C1 C2 le reste de la division.
Tu recommence le tout: c< b, donc on met A3 à la suite de c:
c= C1 C2 A3
Magie, c >= b, donc on fait la division c/b on met le reste dans c et on ajoute Q2 (= c/b) à la suite de q
Donc q= Q1 Q2
Ensuite on recommence pour A4 et après on aura fini car on aura fait tout les mots de a !!!!!!!!
En gros, à la fin de l'algo, c est le reste de la division Euclidienne et q le quotient. Voila.
Si tu réfléchi bien à ce principe tu verras que c'est exactement ce que tu fais en faisant une division à la main. Seulement dans ton cas, une division élémentaire ne fait pas 32 bits :-)
Et dans le process c'est comme ca que ca fonctionne: les chercheurs manquent d'imagination, ou alors c'est le seul algorithme pour la division que l'on connaisse, je ne sais pas. En ottu cas, il est pratique: on l'apprend aux touts petits.
6 juil. 2004 à 11:38
/* pour la / : a=b/c */
a=b;
while test(a;c)==1 /*tant que a > c */
{
a=moins(a;c);
}
enfin, un truc qui resemblerais àa ça en utilisant la librairie d'avant, sauf que dans les librairies d'avant, il n'y a pas les classes
j'avais déja laissé ça comme proposition dans une autre de mes sources (cryptro rsa 32 bits) mais on m'avait dis que ça prendrais bcp trop de temps de calculs
5 juil. 2004 à 19:39
Le TH de Fermat va pas t'aider ni pour les / ni pour les %
Il dit que si p est premier alors quleque soit a, a^p à même reste que a dans la division par p
Ce qui signifie concrêtement si p premier, alors x^p = x mod(p)
cela marche si p est premier mais la réciproque n'est pas vrai.
En fait, ca évite de faire une Exponentiation Modulaire si le module est premier et si la puissance est ce même nombre p.
Dans ce cas ca servirait à rien.
5 juil. 2004 à 18:25
merci pour l'explication des classes
5 juil. 2004 à 18:21
class BigInt
{
public:
BigInt(char*); // Constructeur à partir d'une chaine en hexadecimal
BigInt(int); // constructeur à partir d'un entier
~BigInt(); // Destructeur qui désalloue la mémoire pour donnees
// ICI, la liste des opérandes classiques:
BigInt operator+(BigInt);
/// Etc...
private:
WORD *donnees; // Tableau des données
unsigned long size; // longueur en bit du nombre
unsigned short nb_wrd; // Nombre de WORD utilisés.
bool positif; // Pour savoir s'il est positif ou négatif
};
Ensuite tu fais par exemple:
BigInt BigInt::operator+(BigInt a)
{
// ICI, le code de l'addition de deux nombres
};
/*
à partir d'une fonction membre d'une classe, on peux accéder au membres privés, donc ici, à donnees, mais aussi à a.donnees
*/
operator+ est défini avec BigInt:: pour dire qu'il appartient à la classe BigInt
il renvoie un BigInt (la somme de deux BigInt est un BigInt)
Mais pour le fonctionnement plus détailler des classes, faut lire des cours dans des bouqiuns ou sur le net, la c'est même pas une esquisse.
Sinon tu voulais dire quoi 'avec Fermat' pour la division ?
5 juil. 2004 à 17:32
et sinon, pour les divisions, et les modulos, j'y avait pensé, mais y a pas plus simple avec ferrmat ? parceque la, mon p4 fera vite une tête de céléron lol
5 juil. 2004 à 17:17
5 juil. 2004 à 17:16
Ben en gros, y'a la programmation classique, dite procédurale. En gros, t'as des procédures, (des fonctions quoi) et un environnement (ou encore état). L'état, c'est la valeur de tes variables/données ainsi que là où tu te trouve dans le programme. C'est comme une chaine de travail ou les fonctions sont des robots qui travaillent sur l'environnement: ils sortent leurs bras et agissent sur l'environnement.
Sinon y'a la programmation avec les classes: la POO ou programmation orienté objet. Un objet, c'est une sorte de petite bête à qui tu parles: tu lui envoie des message et en fonction de ces messages elle te répond. Tu peux lui envoyer tout pleins de type de messages différents. Elle ne travail que très peu sur l'environnement, car en fait elle en fait partie, c'est un objet comme les autres: y'a les entiers, les chars, et les objets plus complexes ("les bêtes"). Alors à l'intérieur de la bête y'a un 'mini environnement', mais ca personne le sait, ca reste invisible dans le reste du programme, c'est en quelque sorte ces organes, c'est ca qui lui permet de travailler. Ben une classe c'est un truc qui permet de décrire comment fonctionnent ces betes. Y'a une méthode qui permet de créer ce type de bête (constructeur, c'est ce qui l'initialise) et une autre pour la détruire en fin de vie.
Concrètement, ca sert apr exemple à définir de nouveaux types, avec tout pleins d'opérations dessus (par exemple BigInt, comme ca après, les BigInt se gèrent comme tout les types, avec les opérateurs: + / * -, etc...) En gros, c'est une structure struc sauf qu'elle contient des fonctions.
Les fonctions et les données sont contenues dans différentes partie: la partie privée, invisible pour le programmeur, la partie publique, accessible (par exemple un operator+) et encore un truc, maison va pas s'entérrer dans les détails.
Comme après on a juste un gros blocs et pas pleins de petites fonctions qui courent partout dans un .h ben ca permet de faire de la réutilisation de code. On donne (ou vend) des classes qui permettent de faire ca ou ca, et y'a plus qu'à mettre l'entête de la classe dans la liste des .h (puis aussi le précompilé) et voila.
Le meilleur exemple, c'est les flots par exemple le cout qui gèrent l'opération <<, le cin, et tout les tampons de lecture/écriture.
Tu vois peut être pas comme ça, mais c'est une avancée majeur en prog, car c'est super extensible et avec les méthodes de dérivation de classe, on peux spécialiser une classe dans telle ou telle chose, et des milliers de possibilitées encore.
A savoir que C++ est un des seuls langage qui gèrent la POO et la prog procédurale, car les deux sont incompatibles. Ce sont deux façons de réflechir totalement distinctes. Toutefois, en C++ c'est assez bien foutu, alors ca passe inapercu et les incompatibilités sont supprimées.
5 juil. 2004 à 16:56
a et b deux grands nombres et a/b ou a%b
1) Si a plus petit que b, alors reste= a et quotient= 0
(reste, c'est a%b, quotient, c'est a/b)
2) si a= b, reste= 0, quotient= 1
3) sinon tant que c b, alors on a deux cas:
a) c fait autant de mots que b,
b) c fait un mot de plus que b
donc le résultat de c/b fera un mot, c'est une division plus évidente. On a un nombre d. On le décale d'un mot vers la gauche et on lui ajoute le quotient de c/b. (en fait, on rajoute c/b en fin de d, cad en bits de poids faible). On réitère cette étape (3) jusqu'à ce que c soit plus petit que b.
c est le reste, donc a%b et d le quotient donc a/b.
Le mieux pour tout ca, c'est que t'étudie la source d'un gars ici qui a fait un classe BigInt, avec un générateur de clé RSA.
ici: http://www.cppfrance.com/code.aspx?ID=17583
5 juil. 2004 à 12:15
au fait, comment on fait des classes et a quoi ça sert ?
5 juil. 2004 à 12:09
unsigned long int c[256];
int initialiser(){
for (i=0;i<255;i++)
c[i]=0;
}
int plus(int *a,int *b){ /*adition + */
int short unsigned i;
for (i=1; i<max( *(a), *(b) );i++)
*(c+i)=*(a+i)+*(b+i);
*(c)=max( *(a) , *(b) );
remetre();
for (i=0;i<255;i++)
nombrec[i]=c[i];
}
int moins(int *a,int *b){ /*soustraction - */
int short unsigned i;
for (i=1; i<max( *(a), *(b) );i++)
*(c+i)=*(a+i)-*(b+i);
*(c)=max( *(a) , *(b) );
remetre();
for (i=0;i<255;i++)
nombrec[i]=c[i];
}
int fois(int *a,int *b){ /*multiplication x */
int short unsigned i, j ;
for (i=1; i < *(a); i++)
for (j=1; j< *(b); j++)
*( c + i ) = ( *( a + i ) ) * ( * ( b + j ) );
*(c)=max( *(a) , *(b) );
remetre();
for (i=0;i<255;i++)
nombrec[i]=c[i];
}
int short unsigned max (int short unsigned a, int short unsigned b){
/*plus grand nombre entre a et b*/
if ( a>b ){
return a;
}
else
{
return b;
}
}
int short unsigned min (int short unsigned a, int short unsigned b){
/*plus petit nombre entre a et b*/
if ( a>b ){
return b;
}
else
{
return a;
}
}
void remetre(){
/*des nombres faisant parti de c peuvent très bien être plus grand que 255 et, si c'est le cas, il y aura une erreur non déclarée, mais bien réelle (donc, vous ne verrez rien mais aurez un résultat faux)*/
while ( *(c + *(c) + 1 ) > 0 ){
*(c)++;
}
for (i=*(c);i>0;i--){
while(*(c+i)>255){
*(c+i)-=255;
*(c+i+1)++;
i+=2;
if ( i+1 > *(c)){
*(c)++;
if (i+1 ==255){
printf("\nERREUR, DEPASSEMENT DE CAPACITEE.\n");
exit(1);
}
}
}
while(*(c+i)<0){
*(c+i)+=255;
*(c+i+1)--;
i+=2;
if ( i+1 == *(c) && *(c+i+1)==0 ){
*(c)--;
if (i+1 == 255){
printf("\nERREUR, CALCUL D'UN NOMBRE NEGATIF.\n");
exit(1);
}
}
}
}
}
int test(int *a,int *b){ /*test < > != == quoi choisir
en fait, pour faire vos test, vous faites :
if (test(*a, *b)==1){ pour tester si c'est égal
if (test(*a, *b)!=1){ pour tester si c'est diférent
if (test(*a, *b)==2){ pour tester si a est plus petit que b
if (test(*a, *b)!=2){ pour tester si a n'est pas plus petit que b if (test(*a, *b)!=2){ si a est plus grand ou égal a b
if (test(*a, *b)==3){ pour tester si a est plus grand que b
if (test(*a, *b)!=3){ pour tester si a n'est pas plus grand que b
if (test(*a, *b)!=3){ si a est plus petit ou égal a b
*/
int short unsigned i;
if ( *(a)>*(b) ){
return 3;
}
else
{
if ( *(a)<*(b) ){
return 2;
}else{
for (i=*(a);i>0;i--){
if ( *( a + i ) < *( b + i ) )
return 2;
if ( *( a + i ) > *( b + i ) )
return 3;
}
return 1;
}
}
}
4 juil. 2004 à 19:33
En études de Mathématiques info, on nous a demandez d'implémenter RSA (ce qui est façile)... à condition de disposer de quelque chose pour gérer les grands nombres. En afit, c'est même 80% du travail si tu veux le faire toi même. C'est assez chaud en réalité.
Pour RSA: ce que tu as besoin:
- de nombres de taille non définit (tu proposes 256 bits, mais si tu sais faire ca, normalement tu sais faire n'importe quelle taille, et ca doit s'allnoger dynamiquement).
- des opérations courantes: + - / * %
- de l'exponentielle modulaire (a^x mod(n))
- des opérations bits à bits: ^ | & ~
- d'un générateur aléatoire de nombres (on trouve pas mal d'algos sur le net, suffit de bien chercher) et je crois que c'est tout.
A partir de ca, il te reste à faire l'algo de PGCD (il fait que des + - / * %), deux algos probabilistes de primalité (tests de Miller-Rabbin et test de je sais plus son nom) (ca c'est assez chaud, faut avoir de très bonnes notions en maths, les matrices, etc...) euh, d'un truc qui résoud: a*x=1 mod(n) connaissant n et a, puis enfin de trucs qui calculent la clé à partir de deux nombres premiers.
Bref, autant dire que c'est un projet sur long therme.
Bon si tu veux, il existe une bibliotheque GNU ici: ftp://ftp.gnu.org/pub/gnu/gmp/gmp-3.0.tar.gz qui gère les nombres: des très grands nombres, des nombres réels super précis etc... En plus ca gere pas mal de fonction mathématiques.
Mais si tu veux t'amuser, le principe, c'est de voir comment tu fais une division à la main et de faire pareil en binaire avec un algo sauf que là, ca marche par paquets de nombres.
Bref, c'est assez hot et tentable. Peut être que t'as pas encore le niveau, mais tu peux au moins commencer le travail et avancer jusqu'aux 50 premiers %.
Sinon pour la fabrication de clés, c'est le truc de Diffie Hellman que j'ai expliqué plus haut, mais il en existe plein d'autre (celui là est le plus bete et le meilleur certainement).
4 juil. 2004 à 18:30
sinon, c'est sur, tu est le premier a me dire que rsa n'est pas sur.
C'est possible de créer des clefs ensemble ? savais pas, merci pour les astuces
tu ne me fera quand même pas abandonner mon projet : faire un vrai algorytme de cryptographie en asymétrique.
Pouer mon projet, j'ai besoin de savoir comment créer un nombre premier énorme, et dans tout ce que tu as dis, je suis allé sur tes sites, mais il n'y a pas grand chose la dessus (même si j'ai pas fouillé en détails) alors je me demandais si vous ne conaissiez pas une technique pour pouvoir avoir un nombre premier énorme (sans passer par tout les caclus de diviseurs).
sinon, je cré une librairie qui permet d'utiliser des nombres de 255 chifres en base 256 donc, des nombres permettants largement de crypter (et si un jours, je trouve que ce n'est pas sufisant, je passerais mes int short en int long) j'ai un petit problème dans ma librairie, c'est que pou diviser ou pour faire un modulo, je ne sais pas vraiment comment m'y prendre (je rentre en première S, alors je n'ai jamais eu de prof d'informatique ni suivi d'études poussés en math) .
J'avais trouvé une solution, mais bien trop coutese en calculs :
si a=b/d
a=b
while (a>d)
a=a-d
et un truc du style pour les divisé mais en mettant un compteur pour voir le nombre de fois que l'on peut l'enlever, mais c'est bcp trop couteur en temps de calculs.
4 juil. 2004 à 18:08
Et le site que je met en liens n'a pas été mis a jours depuis plus d'un an svp comment on change ça
4 juil. 2004 à 17:54
Déjà, RSA nécéssite de rechercher de très grands nombres premiers, ce qui pose un gros problème: on ne sait pas en trouver !!! On connait bien les nombres de Mersennes de la forme (2^x)-1 mais on ne peux pas les utiliser pour RSA à cause de leur particularité.
En fait, ce qu'on fait, c'est qu'on prend un nombre au hasard et on fait des tests probabilistes de primalités qui fonctionnent grâces à certains principes mathématiques. Bon, sans rentrer dans les détails, on ne sait pas dire si tel nombre choisi au hasard est premier ou pas, mais on sait dire: il est peut être premier avec une probabilité de X%. On connait deux tests assez simple à mettre en oeuvre et qui sont utilisés aujourd'hui. Alors on les fait tourner tout les deux jusqu'à ce qu'ils nous disent tout les deux 'ce nombre est premier avec 99.9% de chance' ou mions (civil) ou plus (militaire). On peux s'assurer de la primalité d'un nombre avec un très fort pourcentage, mais plus il est fort, plus le temps de calcul est long. Dans tout els cas, le 100 % ne sera jamais atteind.
De plus, la loi n'interdit pas l'utilisation de très grande clés: elle dit cela:
on a le droit d'utiliser les clés que l'on veux, même très grande à condition qu'elles soient données par une autorité de certification qui pourrat les mettre à disposition de la justice si besoin est. Ce qu'on a pas le droit de faire, c'est par exemlpe utiliser un des logiciels de ce site pour les communications qui propose des clés de 1024bits très sures et qui ne seront pas mises à dispo de la justice. D'ailleurs, il y'a un prob avec PGP: il existe des serveurs sur lesquels on peux poser nos clés, mais comme on est pas obligé, le logiciel est interdit en France sauf de façon restreinte.
Bon, sinon, le prob de sécu de RSA: les détails ici: http://www.bibmath.net/crypto/chasseur/erreurrsa.php3
> alice veut parler a bob, elle lui donne une clée symétrique (qui est
> alors interceptée)
NON !!! Car l'échange de clés est aujorud'hui plus sûr qu'une communication avec RSA grâce au protocole de Diffie Helman qui ne s'appuie pas sur des algos asymétriques. En fait, on ne s'échange pas les clés, on la construit ensemble d'une façon qui rend impossible pour un espion de la construire dans le même temps.
http://www.bibmath.net/crypto/moderne/difhel.php3
En tout cas je te conseille ce site: http://www.bibmath.net/crypto/, tu y apprendra tout, même d'un point de vue maths, des algos sans clés, aux algos asym en passant par le hachage, la stégano, etc...
Il permet de comprendre que chaque type d'algo posssède une utilisation précise.
4 juil. 2004 à 17:38
J'aime bien le fond en forme de cahier :-)
4 juil. 2004 à 17:32
il est plus en ligne !!!
(j'ai eu un blem de formatage)
et la, t'as passé la première sécuritée, il y en a (eu) d'autres, mais de toute façon, je n'y avais rien d'interessant, juste des projets
4 juil. 2004 à 17:30
alice veut parler a bob, elle lui dit, bob cré une clée publique qu'il transmet, alice crypte avec, bob décrypte avec sa clée prvés, voila ce qui se passe avec un algo asymétrique comme rsa, la seule clée qui peut être volée est la clée publique, donc, une clée qui pourais seulement lui permetre de se faire passer pour alice mais qui ne lui permetrais pas de casser le code, enfin, pas sans se faire chier un bon moment a ataquer rsa a factoriser "n=p*q" alors le pauvre type va abandonner bien vite
alice veut parler a bob, elle lui donne une clée symétrique (qui est alors interceptée) bob la reçoit, elle lui transmet le message (qui est intercepté) que bob reçoit et lit. la, le craquer connait la clée, il ne lui reste plus qu'a "lire" le message !!!
RSA :
p premier
q premier
e premier
f=(p-1)(q-1)
i=1;
while ( i%e!=0 )
{
i=i+euler;
}
d= i / e ;
a, b, c chifre a crypter, ces chifres sont codés sur 8 bits
d=a+b*256+c*65536
d=d^d%n
ça, c'est pour crypter, mais je ne vois pas ou est le problème...
Je ne vois pas en quoi rsa est moins sécurisant, c'est vrai que je n'ai pas fait d'études pousées en math, mais je ne vois pas.
4 juil. 2004 à 17:28
Ce serait cool si t'implémentais un truc genre RSA ou plus simple (mais un algo asymétrique par contre :-) ) pour protéger ton mot de passe.
P.S: je suis pas un gros con de hacker, alors je suis l'autre...
4 juil. 2004 à 17:15
Quant à "croire à la sécurité" des algos sym, il n'y'en a pas besoin: la quasi totalité des algos asym se trouvent derrière les algos sym si on les classes par ordre de sécurité. Et de loin !
Croire que la sécurité d'un chiffre repose sur la longueur de sa clé est helas bien fou ! C'est comme croire que la vitesse des PC ne tient compte que des Ghz du processeur: c'est un argument de vente, rien d'autre. Derrière, il y'a l'architecture, la structure, le jeux d'instructions, si les unités collent bien à la norme en vigueur pour une meilleur adaptabilité aux autres composants, etc...
La longueur ne joue qu'un seul rôle: celui qui évite la force brute. Mais la longueur d'une clé ne rajoute en théorie aucune force au cryptage au chiffre. En clair, un bon algo est un algo qui chiffre avec la même puissance selon la taille de la clé. Bien sur, on a des clés plus longues pour éviter des attaques par force brute (facto plus simple, nombre de != clés trop petit, etc...)
Les codes ne se cassent plus et depuis longtemps par force brute: le cassage est le fruit de la cryptanalyse qui s'appuie sur des fréquences de lettres, des schémas, etc...
Enfin, tu dis: 'intercepeter la clé' mais algo sym ou asym, c'est pareil: on a autant de chance de l'intercepter, donc de décrypter ce qui ne devait pas l'être. Les algos sym ne sont pas dépendants des algos asym la preuve, ils éxistaient bien avant (2 millénaires) !!
D'ailleurs, tu savais que RSA souffrait d'un énorme problème de sécurité ? C'est peut être ce problème qui un jour fera du tort à RSA.
Crois moi, Diffie Helman + AES, ca vaut tout les algos asym, seulement ca n'est pas utilisable pour les communications en différées (ex: envoie de mails) pour l'authentification, la non répudiation, ca ne permet que de l'échange en temps réel entre deux machines. Mais c'est très puissant, et tout les étâts utilisent ce genre de crypto-systèmes pour leurs communications (téléphone rouge, etc...).
4 juil. 2004 à 16:25
mais seulement du fait que aes n'a pas de taille de clée limitée, aes et rsa sont incassables si on prends une clée énorme, et rsa aura l'avantage d'être asymétrique
enfin, c'est la théorie, moi, je ne crois pas a la sécuritée avec les algorithmes symétriques, ils sont utiles seulement grace a leur vitesse d'execution, mais une cle interceptée permetrais de tout casser, alors, ils ne peuvent être efficaces seuls, ils sont donc dépendant d'un algorythme asymétrique.
4 juil. 2004 à 16:18
un algo symétrique est hyper rapide et peux coder des millions de données à la volée, exemple: téléphone rouge ou bien encore vidéoconférence. De plus, leur sécurité est certainement beaucoup plus grande que la plupart des algos asymétriques qui reposent plus sur des difficultés à résoudre un problème mathématique de façon discrete (factorisation de nombre, ou résolution du logarithme discret(1))
Ensuite les algos asym, sont utiliser pour l'intégrité de données, la non répudiation (prouve qu'un mail à été envoyé), la certification d'identité (prouve l'identité d'une personne) etc... Seulement ils sont beaucoup trop gourmands en ressource. De plus la plupart d'entre eux nécéssitent des clés spéciales: soit le produit d'un nombre premier, soit un nombre non totalement arbitraire. Actuellement le meilleur algo est certainement AES, mais il est symétrique: pas de problème:
pour échanger la clé on peux utiliser le protocole Diffie-Hellman(2) (bien plus sur que RSA) ou même l'envoyer dans un conteneur RSA.
De plus, trouver des clés de plusieurs millions de bits pour RSA, c'est à peu près aussi dur (voir plus) que de casser une clé de 512 bits.
(1) & (2): protocole de Diffie Hellman pour échange de clés totalement arbitraires: A et B veulent utiliser un algo sym (ex: AES) alors ils choisissent en commun un très grand nombre (1024bits par exemple) n ainsi qu'une base de calcul commune: a (aussi un très grand nombre, mais < n).
Ensuite, A choisi x et B choisi y, A envoie à B X=a^x mod(n) et B envoie à A X= a^y mod(n). Alors A peut calculer K= Y^x mod(n) et B peut calculer K= X^y mod(n). K devient la clé de même longeur que n ou lègerement inférieur.
Qd à C ? il écoute attentivement et dispose donc de a, de X, de Y, de n. Connaissant cela, il ne peux retrouver K. C'est le problème du logarithme discret qui arrive avec les modules: connaissant a, n et X= a^x mod(n), on ne peux retrouver x, du moins c'est très difficile (beaucoup plus que factoriser un nombre, car ici la force brute ne peux pas s'approximer, la suite parait aléatoire).
avec les modulos, la formule x= log(a^x) / log(a) ne fonctionne pas.
4 juil. 2004 à 12:54
De plus, le des a une taille limite de clef, (pour ça, c'est vrai qu'il a un successeur) mais le rsa lui, n'a pas de limitte dans la taille de la clef (sauf légale, mais en théorie, on pourait utiliser des clef de plusieurs millions de bits)
4 juil. 2004 à 12:54
De plus, le des a une taille limite de clef, (pour ça, c'est vrai qu'il a un successeur) mais le rsa lui, n'a pas de limitte dans la taille de la clef (sauf légale, mais en théorie, on pourait utiliser des clef de plusieurs millions de bits)
20 avril 2004 à 22:16
Une clé est privée et non réutilisable: si on fait un XOR sur deux messages cryptés avec la même clée on voit en qque sorte les deux messages. La où l'on vois le mieux ce phénomène, c'est pour des bmp 1bit.
J'ai vu ca une fois sur France5 :-)
19 avril 2004 à 23:05
avec des supers ordinateurs ça se casse un xor... et hop que tu brutes. comme tu dis, c'est cyclique, donc un mot, ou même deux ça passe en qq jours de brute force (enfin, évidemment ça dépend des caractères utlisés, tu peux aussi utiliser un dictionnaire etc...) C vrai qu'avec 15-20 caractères ça evient franchement dur, mais au pire en qq mois tu t'en sors! le plus dur reste à mon avis la façon dont tu détermines que tu as trouvé qq ch de bon ^^
19 avril 2004 à 22:46
Zarb' !!
En fait, ta fonction main doit être la dernière à être écrite.
Chaque fonction f1 qui appele f2 nécessite que f2 soit tapée avant ou bien soit déclarée:
exemple:
int max(int,int);
int main()
{
cout << max(5,9) << endl;
return 0;
}
int max (int a, int b)
{
return (a > b ? a : b);
}
19 avril 2004 à 21:28
Comment dois-je déclarer les fonctions avant main (ou alors je met main(){} à la fin ???)???
19 avril 2004 à 20:08
En plus ca permettrait de pas voir ce qui est écrit à oeil nu.
D'ailleurs, il est prouvé que le ou-exclusif est la meilleure façon actuelle de protéger des données (seul inconvénient: la clé est symétrique, donc c'est une clé privée, et donc, il faut garder ce code secret très très secret).
19 avril 2004 à 13:23
18 avril 2004 à 10:38
18 avril 2004 à 01:37
obtenu[i] = *(car + i ) + mot[ i % max ];
càd pointeur[...] et *(pointeur + ...)
tu t'es embrouillé, c'est volontaire, ça a une logique, ou tu ne savais pas? je soulève ce point uniquement parce que tu m'as dit que tu faisais du C depuis 3 mois, donc pê qu'il y a matière à mettre au point, c'es tout.