Jeux Libres
       
           

» Les Tutoriels » Cryptage RSA en C++

Cryptage RSA en C++


RSA est un algorithme de cryptographie asymétrique permettant l'échange de données confidentielles. Nous allons découvrir le fonctionnement de l'algorithme et une façon simple d'implémenter l'algorithme RSA en C++ à l'aide de la bibliothèque RSA.




Principe de fonctionnement


Le plus simple pour comprendre est de prendre un exemple.

Transmission d'un message de Bob à Alice



Bob souhaite transmettre un message secret à Alice. Pour garantir que ce message ne soit lu par personne d'autre, le message doit être chiffré par Bob avant la transmission, puis déchiffré par Alice après réception.

Pour cela, Alice génère deux clés : une clé publique qu'elle envoie à Bob, puis une clé privé qu'elle conserve précieusement. Bob chiffre son message secret avec la clé publique, puis transmet le message chiffré à Alice. Après réception, Alice déchiffre le message grâce à sa clé privée.


Génération des clés et envoi de la clé publique à Bob.




Chiffrage du message secret avec la clé publique.
Déchiffrage du message secret avec la clé privée.

Important : Les clés fonctionnent toujours par paire. Un message chiffré avec une clé publique ne peut être déchiffré qu'avec une clé privée. Inversement, un message chiffré avec une clé privée ne peut être déchiffré qu'avec une clé publique. Il est par contre théoriquement possible de retrouver la clé publique à partir de la clé privée. Ne transmettez donc jamais la clé privée.


Sureté du chiffrage RSA



Si un écouteur externe parvient à intercepter le message chiffré, il lui serait impossible de déchiffrer le message car il ne possède pas la clé privée. Même s'il a également intercepté la clé publique, il ne lui est pas possible d'en déduire la clé privée nécessaire au déchiffrement du message.

En revanche, s'il a réussi à intercepter la clé publique, il lui est théoriquement possible de chiffrer lui même son propre message et l'envoyer à Alice qui saura le déchiffrer. S'il est important d'identifier l'expéditeur, un mécanisme d'authentification devra être mis en place.

Si un attaquant intercepte un message chiffré, celui-ci peut le modifier ou non, et le renvoyer à Alice. S'il est modifié, lorsqu'Alice l'aura déchiffré, le message reçu n?aura rien à voir avec le message envoyé à l'origine par Bob. L'envoi d'un mot clé en début de message peut suffire à vérifier que le message n'a pas été modifié. Pour se prémunir de la réémission d'un message, une numérotation des messages peut suffire à ignorer les messages réémis par un attaquant.

Choix de la longueur des clés



La fiabilité du protocole RSA repose sur le fait qu'il est très difficile de factoriser un grand nombre semi-premier. Pour que vos clés soient fiables, vous devez générer des clés suffisamment longues. Je recommande de générer des clés d'au moins 1024 bits. Nous verrons comment générer des clés un peu plus loin.


Implémentation du cryptage RSA en C++


Tout d'abord, commencez par télécharger la bibliothèque RSA : librsa.zip.

Il s'agit d'une bibliothèque créée par mes soins.


Installation de la bibliothèque RSA



Dans le *.zip, vous trouverez deux fichiers : rsa.h et librsa.a. Copiez le fichier librsa.a dans le dossier lib/, puis le fichier rsa.h dans le dossier include/ de votre compilateur.


Copie du fichier librsa.a dans le dossier lib/.


Copie du fichier rsa.h dans le dossier include/.

Votre bibliothèque RSA est maintenant installée. Voyons maintenant comment l'utiliser.

Utilisation de la bibliothèque RSA



Bien que l'algorithme RSA soit relativement complexe à mettre en ?uvre à cause de la taille conséquente des nombres qu'il nécessite (plusieurs centaines de bits), l'utilisation de la bibliothèque RSA nous fournie une interface très simple d'utilisation permettant de faire abstraction de tout ces mécanismes complexes. Jugez par vous même...

Création du projet



Pour faire simple, ici, nous allons créer un projet de type "Console" en C++. Le code minimal s'affiche :
1
2
3
4
5
6
7
8
9
#include <iostream>
 
using namespace std;
 
int main()
{
   cout << "Hello world!" << endl;
   return 0;
}

Pour utiliser RSA, vous devez inclure l'entête <rsa.h> :
1
#include <rsa.h>

Vous devez également linker la bibliothèque RSA. Ajoutez -lrsa à l'éditeur de liens.


Ajout de la bibliothèque RSA à l'éditeur de liens

Création et affichage d'un paire de clés



Pour utiliser l'algorithme RSA, vous devez instancier un objet de type Rsa, à partir duquel vous pourrez appeler la méthode Rsa::genererCles() qui permet de générer les clés publique et privé.
1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <rsa.h>
 
using namespace std;
 
int main()
{
   Rsa rsa;
   rsa.genererCles(1024);
   
   return 0;
}

Ici, 1024 représente la taille de la clé en bits. Plus précisément, il s'agit de la taille en bits du nombre semi-premier généré. 1024 est un bon compromis entre la fiabilité et le temps de génération des clés.

Vos clés sont maintenant créées.

Les clés fonctionne par paire. Un appel à la méthode Rsa::genererCles() génère un paire de clés aléatoires compatibles entre elles. Vous ne devez appeler cette méthode qu'une seule fois.


Les clés générés sont stockées en mémoire dans l'objet rsa. Pour y accéder, faite appel aux méthodes clePrivee() et clePublique(). Ces méthodes retournent chacune une clé sous forme d'un string.

Nous pouvons les afficher ainsi :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
#include <rsa.h>
 
using namespace std;
 
int main()
{
   Rsa rsa;
 
   // Generation d'une paire de cles
   rsa.genererCles(1024);
 
   // Recuperation de chacune des cles
   string clePrivee = rsa.clePrivee();
   string clePublique = rsa.clePublique();
 
   // Affichage des cles
   cout << "Cle privee : " << endl;
   cout << clePrivee << endl;
   cout << "Cle publique : " << endl;
   cout << clePublique << endl;
 
   return 0;
}

Voici les deux clés, générées aléatoirement, affichées à l'écran :
Cle privee :
1a77ae29fa556dd62e031f2b112a3842d04d83ee92b60f1fe07f580308d9ed3ffcfbdfdf0d04611a
18692774a7e004ea98342472cf0a824cfdf9ca9c863f686214ad7cd28ca4706f3e06e53d0dbb56ae
b9ca9edd48e5b348fef8e89dc5d0a1e51db364b2d5d3bc4eaaeccf5c7a1a3726b643fb5700f68e44
24d5db0dc548d27-275cb581574b8ff711ea6a888288900dd9182ea4ab3d159ad701203c207d7075
05d2f77eb32b764d64c1fa1d0e902a6326c4007c2465c87de62f3ecd3652b8e1972e8d31e39317c1
784573b2d2e7585a93402a871e9655dd1ac27aef4006d4f851ed3c671d4e5aff9734eea596c8e74b
37ed941a704d7dce6ad1b477099067d
Cle publique :
1a77ae29fa556dd62e031f2b112a3842d04d83ee92b60f1fe07f580308d9ed3ffcfbdfdf0d04611a
18692774a7e004ea98342472cf0a824cfdf9ca9c863f686214ad7cd28ca4706f3e06e53d0dbb56ae
b9ca9edd48e5b348fef8e89dc5d0a1e51db364b2d5d3bc4eaaeccf5c7a1a3726b643fb5700f68e44
24d5db0dc548d27-9186d8de759f8d62d009a97479f8be466f9c9649ec5676f970b656d3245be5bc
4973d49567f4713a91df58bb0c97228313c0cfc4e98f04e8baf23bfbe4e306c5

Ces clés sont composées de deux grands nombres chacune, séparé par un '-'. Vous pouvez constater qu'elles ont une partie commune : le premier grand nombre. Il s'agit du fameux nombre à 1024 bits semi-premier affiché en base 16. Je vous met au défis de factoriser ce nombre, sur lequel repose toute la sécurité de l'algorithme RSA. En réalité, personne n'est, à ce jour, capable de factoriser un tel nombre dans un temps raisonnable, soyez rassuré.


Dans la pratique, il est rarement utile d'afficher les clés.

Cryptage d'un message secret



Comme je vous l'ai dit, il est possible de crypter un message avec les deux clés. Vous devrez choisir celle qui convient à votre application. Pour l'exemple, je choisi de crypter le message avec la clé publique.

Pour cela, c'est très simple, le code devrait vous suffire :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include <rsa.h>
 
using namespace std;
 
int main()
{
   Rsa rsa;
 
   // Generation d'une paire de cles
   rsa.genererCles(1024);
 
   // Recuperation de chacune des cles
   string clePrivee = rsa.clePrivee();
   string clePublique = rsa.clePublique();
 
   // Creation du message secret
   string messageSecret = "Je t'aime Alice";
 
   // Cryptage du message
   string messageCrypte;
   messageCrypte = rsa.chiffrerAvecClePublique(messageSecret);
 
   // Affichage du message crypte
   cout << "Message crypte : " << endl;
   cout << messageCrypte << endl;
 
   return 0;
}

Votre message crypté est illisible.
Message crypte :
17b0ce47754efe38b7988a875b9bcfcc9cacf3f60a685545d493b519f41c6b8b2e68cb2a8cd2c504
d0516a3949b6a19e0a1b8af1558ace072b36f4205876e9d65f7f44b635b627ed650a17d2ed559c19
8703f36a3e36fc03cf89296db05dce994a9c44b158f38493eeea1474b19211042d77d5f85a0176ca
b37e0ff6dfe28aaf

Pour le rendre lisible, vous devez le décrypter avec la clé privée.
1
2
3
4
5
6
7
    // Decryptage du message
   string messageDecrypte;
   messageDecrypte = rsa.dechiffrerAvecClePrivee(messageCrypte);
 
   // Affichage du message decrypte
   cout << "Message decrypte : " << endl;
   cout << messageDecrypte << endl;

Ainsi, vous retrouvez votre message d'origine
Message decrypte :
Je t'aime Alice

Utilisation d'une clé spécifique



Dans la pratique, on n'utilise pas le même objet pour crypter et décrypter un message. Généralement, l'algorithme RSA est utilisé pour crypter un message pendant le transfert d'un programme à un autre. Chacun de ces programmes doit posséder l'une des clés d'une même paire de clé.

Pour cela, l'un des programmes communiquant génère une paire de clé et en envoi la clé publique à l'autre programme. Ainsi ils pourront communiquer de façon crypté. L'envoi de la clé suppose un communication par un réseau. Pour vous expliquer les choses simplement, nous allons nous y prendre autrement.

Nous allons générer une paire de clés et implémenter chacune de ces clés dans des programmes différents. Ainsi, l'"envoi" de la clé publique sera fait.

Pour éviter de régénérer une paire de clé, je vous propose de reprendre les clés générés plus haut :
Cle privee :
1a77ae29fa556dd62e031f2b112a3842d04d83ee92b60f1fe07f580308d9ed3ffcfbdfdf0d04611a
18692774a7e004ea98342472cf0a824cfdf9ca9c863f686214ad7cd28ca4706f3e06e53d0dbb56ae
b9ca9edd48e5b348fef8e89dc5d0a1e51db364b2d5d3bc4eaaeccf5c7a1a3726b643fb5700f68e44
24d5db0dc548d27-275cb581574b8ff711ea6a888288900dd9182ea4ab3d159ad701203c207d7075
05d2f77eb32b764d64c1fa1d0e902a6326c4007c2465c87de62f3ecd3652b8e1972e8d31e39317c1
784573b2d2e7585a93402a871e9655dd1ac27aef4006d4f851ed3c671d4e5aff9734eea596c8e74b
37ed941a704d7dce6ad1b477099067d
Cle publique :
1a77ae29fa556dd62e031f2b112a3842d04d83ee92b60f1fe07f580308d9ed3ffcfbdfdf0d04611a
18692774a7e004ea98342472cf0a824cfdf9ca9c863f686214ad7cd28ca4706f3e06e53d0dbb56ae
b9ca9edd48e5b348fef8e89dc5d0a1e51db364b2d5d3bc4eaaeccf5c7a1a3726b643fb5700f68e44
24d5db0dc548d27-9186d8de759f8d62d009a97479f8be466f9c9649ec5676f970b656d3245be5bc
4973d49567f4713a91df58bb0c97228313c0cfc4e98f04e8baf23bfbe4e306c5

Programme de cryptage



Nous allons maintenant créer le programme qui va crypter le message avec la clé publique. Je ne régénère pas de clé, j'utilise celle qui m'est fournie. Portez une attention particulière à la façon dont j'importe la clé publique dans l'objet rsa.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
#include <rsa.h>
 
using namespace std;
 
int main()
{
   Rsa rsa;
 
   // Recopie de la cle publique dans le programme
   string clePublique =
   "1a77ae29fa556dd62e031f2b112a3842d04d83ee92b60f1fe07f580308d9ed3ffcfbdfdf0d04611a"
   "18692774a7e004ea98342472cf0a824cfdf9ca9c863f686214ad7cd28ca4706f3e06e53d0dbb56ae"
   "b9ca9edd48e5b348fef8e89dc5d0a1e51db364b2d5d3bc4eaaeccf5c7a1a3726b643fb5700f68e44"
   "24d5db0dc548d27-9186d8de759f8d62d009a97479f8be466f9c9649ec5676f970b656d3245be5bc"
   "4973d49567f4713a91df58bb0c97228313c0cfc4e98f04e8baf23bfbe4e306c5";
 
   // Import de la cle publique dans l'objet RSA
   rsa.clePublique(clePublique);
 
 
   return 0;
}

Il ne reste maintenant plus qu'à crypter notre message secret et à le transmettre à l'autre programme.
1
2
3
4
5
6
7
8
    // Cryptage du message secret
   string messageSecret = "Mon premier numero de telephone etait : ** ** ** ** **";
   string messageCrypte;
   messageCrypte = rsa.chiffrerAvecClePublique(messageSecret);
 
   // Affichage du message crypte a transmettre
   cout << "Message crypte : " << endl;
   cout << messageCrypte << endl;

Ce qui donne, avec mon premier numéro de téléphone, le message crypté suivant.
Message crypte :
5f4eaa0321fcfe7b87499115b180f04fa9328ea3592e260acc033d677beca854179357d0063e1bed
e8724cc1637e514ed319f4c75f9f716ac20e579e80a40e7ce5f3774a5ddbbd2dbf7a16438e7021e6
106b72cb499825b0ac68966061f1529a913ec163983c33334ed9c9afc4bb4debb6b3015489fb3cf1
538645329143a6

Pour retrouver mon premier numéro de téléphone, vous allez devoir créer le programme de décryptage.

Programme de décryptage



Sur le même principe que le programme de cryptage, le programme de décryptage se construit ainsi :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <iostream>
#include <rsa.h>
 
using namespace std;
 
int main()
{
   Rsa rsa;
 
   // Recopie de la cle privee dans le programme
   string clePrivee =
   "1a77ae29fa556dd62e031f2b112a3842d04d83ee92b60f1fe07f580308d9ed3ffcfbdfdf0d04611a"
   "18692774a7e004ea98342472cf0a824cfdf9ca9c863f686214ad7cd28ca4706f3e06e53d0dbb56ae"
   "b9ca9edd48e5b348fef8e89dc5d0a1e51db364b2d5d3bc4eaaeccf5c7a1a3726b643fb5700f68e44"
   "24d5db0dc548d27-275cb581574b8ff711ea6a888288900dd9182ea4ab3d159ad701203c207d7075"
   "05d2f77eb32b764d64c1fa1d0e902a6326c4007c2465c87de62f3ecd3652b8e1972e8d31e39317c1"
   "784573b2d2e7585a93402a871e9655dd1ac27aef4006d4f851ed3c671d4e5aff9734eea596c8e74b"
   "37ed941a704d7dce6ad1b477099067d";
 
   // Import de la cle privee dans l'objet RSA
   rsa.clePrivee(clePrivee);
 
   // Decryptage du message secret
   string messageCrypte =
   "5f4eaa0321fcfe7b87499115b180f04fa9328ea3592e260acc033d677beca854179357d0063e1bed"
   "e8724cc1637e514ed319f4c75f9f716ac20e579e80a40e7ce5f3774a5ddbbd2dbf7a16438e7021e6"
   "106b72cb499825b0ac68966061f1529a913ec163983c33334ed9c9afc4bb4debb6b3015489fb3cf1"
   "538645329143a6";
   string messageDecrypte;
   messageDecrypte = rsa.dechiffrerAvecClePrivee(messageCrypte);
 
   // Affichage du message decrypte
   cout << "Message decrypte : " << endl;
   cout << messageDecrypte << endl;
 
   return 0;
}

Il ne reste plus qu'à exécuter ce programme et le numéro de téléphone apparait.
Message decrypte :
Mon premier numero de telephone etait : ** ** ** ** **


Limitations et attaques possibles de l'algorithme RSA


Limitations en taille du message



L'algorithme de cryptage RSA n'est pas prévu pour crypter de grosse quantités de données. La taille de la donnée maximale cryptable est donnée en nombre de caractères par la méthode Rsa::tailleMaxChiffrable() après avoir généré ou spécifié au moins une clé.

Il est préférable d'effectuer le teste suivant avant de crypter un message :
1
2
3
4
5
6
7
8
if (messageSecret.size() > rsa.tailleMaxChiffrable())
{
   // Le message est trop long pour etre cryptable avec cette cle
}
else
{
   // Le message est suffisamment court pour tre cryptable avec cette cle
}

La longueur maximale du message cryptable est liée à la longueur de la clé. Généralement, elle est à peine plus petite qu'un huitième de la taille de la longueur de la la clé. Pour une clé de 1024 bits, la longueur maximale du message cryptable avoisinera les 127 caractères.

Attaque pour message trop court



Il est possible de créer une attaque permettant de décrypter un message dont l?inconnue est trop courte si on connait la clé publique qui a permis de le crypter. Par exemple, mon année de naissance.

Je rappel qu'il ne devrait théoriquement pas être possible de décrypter, avec une clé publique, un message crypté avec une clé publique.


Prenons un exemple



Un programme crypte une année de naissance avec une clé publique.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
#include <rsa.h>
 
using namespace std;
 
int main()
{
   Rsa rsa;
 
   // Generation des cles
   rsa.genererCles(1024);
 
   // Affichage de la cle publique generee
   cout << "Cle publique : " << endl;
   cout << rsa.clePublique() << endl;
 
   // Cryptage de l'annee de laissance avec la cle publique
   string anneeDeNaissance = "****";
   string anneeCryptee;
   anneeCryptee = rsa.chiffrerAvecClePublique(anneeDeNaissance);
 
   // Affichage du message crypte a transmettre
   cout << "Annee crypte : " << endl;
   cout << anneeCryptee << endl;
 
   return 0;
}

Vous, le méchant, avez réussi à intercepter la clé publique et le message crypté :
Cle publique :
2ca1ce768c6de3cf0016cd1c1ada234431caa6f70c48a0a45da38678e6c871491d8fb15d9e518cea
d1779b8e73921feb39c1fa6fef1b170fc36641a6da8c6348f642d549c9e3b6f2d0a84ba99ee15ed1
b9a462f1b2b8c7fc917fbc81f6350cc757ac7f1dfe0ab01e74f9d7477e1f8da380a496714ef860cf
99b075a4f7832655-84985794f26452ca4673d0c04e6116d271ab7ee0cc67eb2ebe328bfb56247a9
923d850faefd571a49a587f5c1d2a9e82552627d7cd36ec278586f49af5d159ef
Annee crypte :
1162c4f022e99b5a4a4f0ed22434e900bf074b7e1b56ad855888d0e4ae655c51eca034aa0563e484
cf6f3e898520bbfccd6696f0a9bf82eb2d2909addd82fc7d54cafe431b61e53bd85256f1c1ff88e6
79f1eeae351654114a901ac2a07cf539645dcf6958d3a789e745b5c23972a6c752e7f85b5b15d974
61a2dd45234a74b2

Ne possédant pas la clé privée, vous ne pouvez théoriquement pas décrypter le message. N'est ce pas ? Et pourtant, sachant qu'il s'agit d'une année de naissance, il vous est tout à fait possible de retrouver de quelle année de naissance il s'agit. Vous ne voyez pas comment ?

L'attaque



L'attaque consiste à essayer de crypter toutes les années de naissance possibles avec la clé publique interceptée et de retrouver pour quelle année nous obtenons ce message crypté. Lorsque nous aurons réussi à recréer ce message crypté, nous seront en possession de l'année de naissance qui a été cryptée.

A l'attaque !
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <iostream>
#include <sstream>
#include <rsa.h>
 
using namespace std;
 
int main()
{
   Rsa rsa;
 
   // Recopie de la cle publique
   string clePublique =
   "2ca1ce768c6de3cf0016cd1c1ada234431caa6f70c48a0a45da38678e6c871491d8fb15d9e518cea"
   "d1779b8e73921feb39c1fa6fef1b170fc36641a6da8c6348f642d549c9e3b6f2d0a84ba99ee15ed1"
   "b9a462f1b2b8c7fc917fbc81f6350cc757ac7f1dfe0ab01e74f9d7477e1f8da380a496714ef860cf"
   "99b075a4f7832655-84985794f26452ca4673d0c04e6116d271ab7ee0cc67eb2ebe328bfb56247a9"
   "923d850faefd571a49a587f5c1d2a9e82552627d7cd36ec278586f49af5d159ef";
 
   // Import de la cle publique dans l'objet rsa
   rsa.clePublique(clePublique);
 
   // Recopie du message crypte intercepte
   string messageCrypte =
   "1162c4f022e99b5a4a4f0ed22434e900bf074b7e1b56ad855888d0e4ae655c51eca034aa0563e484"
   "cf6f3e898520bbfccd6696f0a9bf82eb2d2909addd82fc7d54cafe431b61e53bd85256f1c1ff88e6"
   "79f1eeae351654114a901ac2a07cf539645dcf6958d3a789e745b5c23972a6c752e7f85b5b15d974"
   "61a2dd45234a74b2";
 
   // On essaie pour toutes les annees possibles
   for (unsigned long i = 0; i < 2015; i++)
   {
       // Creation du message a tester
       stringstream annee;
       annee << i;
 
       // Cryptage du message a tester
       string anneeCryptee;
       anneeCryptee = rsa.chiffrerAvecClePublique(annee.str());
 
       // Si l'annee crypte correspond au message crypte intercepte
       if (anneeCryptee == messageCrypte)
       {
           // Nous avons retrouve l'annee qui a ete crypte
           // Affichage de l'annee retrouvee
           cout << "Annee de naissance : " << annee.str() << endl;
 
           // Arrete de chercher
           break;
       }
   }
 
   return 0;
}

Après quelques secondes, l'année de naissance apparaît à l'écran :
Annee de naissance : ****

Se prémunir de l'attaque



Une façon simple de se prémunir de cette attaque consiste à concaténer à l'année de naissance un mot de plusieurs dizaine de caractères généré aléatoirement. Ainsi, il existera de trop nombreux messages cryptés différents possibles, pour une année de naissance donnée, pour que chaque message possible ne puisse être testé.


Applications de l'algorithme RSA


Transfert d'informations confidentiels



Comme nous venons de le voir, le cryptage RSA peut être utilisé pour transmettre des informations confidentiels.

Générer des licences d'utilisation



L'algorithme RSA peut être utilisé pour envoyer des licences d'utilisation de 30 jours par mail. En effet, vous pouvez vous créer un programme permettant de crypter une date de péremption avec une clé privée que vous gardez précieusement. Dans l'application à utilisation limité, vous laissez à l'utilisateur la possibilité d'entrer une clé de déverrouillage de 30 jours. Dans ce programme, vous aurez recopié la clé publique associée à votre clé privée afin de pouvoir décrypter la date de péremption et la tester avec la date actuelle.

L'utilisateur ne possédant pas le programme de cryptage à clé privé, il ne lui sera pas possible de générer une licence d'utilisation qui lui permettrait de débloquer son programme pour 10 ans. En entrant de fausses licences de façon aléatoire, les dates de péremption décryptés seront, à coup sur, des dates invalides et illisible. L'algorithme RSA permet donc de générer des licences d'utilisation assez facilement, qui peuvent être envoyé par mail sans soucis.

Connaissant la clé publique, n'importe qui pourra décrypter la clé de licence envoyé par mail et en déduire la date qui se cache derrière. Mais la sécurité n'est pas là ; elle réside dans le fait qu'il est impossible, à partir de la clé publique de générer de telle licence.


Si le message peut être décrypter par Bob, alors seule Alice peut avoir écrit ce message.




Vous voici prêt à mettre en place l'algorithme RSA dans vos applications et à pour prémunir des différentes attaques. J'espère que vous saurez faire bon usage de ce puissant algorithme de cryptage et que ce cours vous a plu.



Rédigé par David
Consulté 24787 fois



Hébergeur du site : David
Version PHP : 5.4.45-0+deb7u2
Uptime : 24 jours 21 heures 47 minutes
Espace libre : 1593 Mo
Dernière sauvegarde : 18/12/2018
Taille de la sauvegarde : 1109 Mo


4969965 pages ont été consultées sur le site !
Dont 1472 pages pendant les 24 dernières heures.

Page générée en 0.982 secondes


Nos sites préférés
- Création d'un jeu de plateforme de A à Z avec SDL
- Zelda ROTH : Jeux amateurs sur le thème de Zelda
- Zeste de Savoir : la connaissance pour tous et sans pépins
- YunoHost : s'héberger soi-même en toute simplicité
- Site de Fvirtman : recueil de projets et de codes en C et C++
- Par ici la sortie : le site des idées de sorties


  © 2005-2018 linor.fr - Toute reproduction totale ou partielle du contenu de ce site est strictement interdite.