Discussion :

[Davidlouiz]

Bonjour,

Je cherche à bloquer une application après une certaine date. Pour cela je compte m'appuyer sur un clé contenant une date d'expiration cryptée comme le fait Avast.

J'ai donc besoin de créer un générateur de clé qui prend une date d'expiration et qui retourne une clé à partir de cette date. Ce générateur doit être gardé secret, sur un site.

Du côté de l'application, un décodeur de clé prend en paramètre la clé entrée par l'utilisateur et en déduit la date d'expiration.

Le décodeur de clé n'est pas secret. Il est donc possible de calculer la date d'expiration à partir de la clé si on connait la fonction de décodage.

En revanche, je veux que le générateur de clé, gardé secret, ne soit pas reproductible, même en connaissant la fonction de décodage. Sinon, n'importe quel utilisateur peut calculer la clé à générer pour obtenir la date d'expiration voulue.

Le problème me paraît complexe à résoudre. Je n'ai pas trouvé de solution. J'aimerais donc avoir des pistes.

Merci.

[Acrim]

J'ai l'impression que tu tentes de réinventer la cryptographie asymétrique . Dans le cas asymétrique : une clef public est diffusée pour crypter/vérifier la signature et une clef privée est gardée par celui qui veut décrypter/signer.

Dans ton problème il s'agit d'un problème de signature afin d'authentifier le créateur de ta "clef-date". Tu devrais trouver ce dont tu as besoin en cherchant : signature numérique.

[Davidlouiz]

Le principe de la cryptographie asymétrique c'est qu'une clé publique non secrète est diffusée pour chiffrer un message. N'importe qui peut chiffrer un message. Ensuite, seul le possesseur de la clé privée peut déchiffrer le message.

Ce que je veux c'est le contraire. Je veux que personne ne soit en mesure de chiffrer un message (générer un clé) sauf le site. Mais que n'importe qui puisse être en mesure de déchiffrer le message (retrouver la date).

Merci.

[prgasp77]

Il suffirait de publier la clé privée et de conserver jalousement la publique. Mais il me semble que souvent la clé publique peut se déduire de la privée ou que la clé publique est avec la clé privée nécessaire au déchiffrement. C'est au moins le cas pour RSA.

Il va te falloir éplucher les listes des technologies existantes pour trouver celle qui te correspondrait. À moins qu'un expert passe par là.

[Acrim]

Je ne voudrais pas sembler lourd mais je continue de penser que la solution à ton problème se trouve dans la cryptographie asymétrique et plus précisément dans ce qu'on appelle la signature numérique.

[Davidlouiz]

Effectivement, je n'ai pas voulu le croire sur le coup mais c'est bien une signature numérique par cryptographie asymétrique que je doit faire.

Mon problème est résolu, merci.

Pour ceux que ça intéresse, voici mon code, très sale :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <gmp.h>
 
int main()
{
	// Creation du nombre p premier
	mpz_t p;
	mpz_init(p);
	mpz_set_str(p, "53148645465464655554531235415323541545473", 10);
 
	// Creation du nombre q premier
	mpz_t q;
	mpz_init(q);
	mpz_set_str(q, "186897845264145246545614561314355142325624673", 10);
 
 
	// Creation du nombre n = p x q
	mpz_t n;
	mpz_init(n);
	mpz_mul(n, p, q);
 
 
	// Creation du nombre m = (p-1)x(q-1)
	mpz_t m;
	mpz_init(m);
	mpz_t pMoinsUn;
	mpz_init(pMoinsUn);
	mpz_sub_ui(pMoinsUn, p, 1);
	mpz_t qMoinsUn;
	mpz_init(qMoinsUn);
	mpz_sub_ui(qMoinsUn, q, 1);
	mpz_mul(m, pMoinsUn, qMoinsUn);
 
 
    // Creation du nombre c premier avec m
    mpz_t c;
	mpz_init(c);
	mpz_set_str(c, "120915111914154564566564172654564654156154134434456145465514565645458829", 10);
 
	mpz_t pgcd;
	mpz_init(pgcd);
	mpz_gcd(pgcd, m, c); // Si c est bien premier avec m, pgcd = 1
 
    // Affichage de la cle public + controle du PGCD
    gmp_printf("PGCD(M,C) : %Zd\n", pgcd);
    gmp_printf("M : %Zd\n\n", m);
    gmp_printf("Cle publique (N,C) :\n%Zd %Zd\n", n,c);
 
 
    // Creation du nombre u tel que (c x u) + (m x v) = 1
    // On ne retien pas v
    // On s'aide de bezout
    mpz_t u;
	mpz_init(u);
	mpz_set_str(u, "2324476463418905151953140273072367204177423816843576844674726052247774901225667571013", 10);
 
 
    gmp_printf("Cle privee (U,N) :\n%Zd %Zd\n\n", u,n);
 
 
    // ================= //
    // TOUT EST PRET ICI //
    // ================= //
 
    mpz_t timestamp;
	mpz_init(timestamp);
	mpz_set_str(timestamp, "1300765747", 10);
	gmp_printf("Timestamp : %Zd\n\n", timestamp);
 
 
 
    // Cryptage avec la cle prive
    mpz_t timestampCrypte;
	mpz_init(timestampCrypte);
    mpz_powm(timestampCrypte, timestamp, u,n);
	gmp_printf("Timestamp crypte : %Zd\n\n", timestampCrypte);
 
    // Decryptage avec la cle public
    mpz_t timestampDecrypte;
	mpz_init(timestampDecrypte);
    mpz_powm(timestampDecrypte, timestampCrypte, c,n);
	gmp_printf("Timestamp decrypte : %Zd\n", timestampDecrypte);
 
 
 
	return 0;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
PGCD(M,C) : 1
M : 9933367316203328106849788710160258197193315070641299464366639342131262006646
693085184
 
Cle publique (N,C) :
99333673162033281068497887101602581971935020216352090750778405112238117771125602
55329 120915111914154564566564172654564654156154134434456145465514565645458829
Cle privee (U,N) :
23244764634189051519531402730723672041774238168435768446747260522477749012256675
71013 99333673162033281068497887101602581971935020216352090750778405112238117771
12560255329
 
Timestamp : 1300765747
 
Timestamp crypte : 4979187578714169842269615341495642144327992632873630565802988
306467746942551383388164
 
Timestamp decrypte : 1300765747

La bibliothèque GMP est ici.

[prgasp77]

?

[Davidlouiz]

Non, je vais sans doute avoir d'autres questions à poser.

Algorithme pour Bezout,
Clé minimum efficace,
Raccourcir la "clé" à rentrer
Récupérer la "clé" générée dans un string

Si je bloque, je poste à la suite si le sujet ne diffère pas trop. Et je posterais ma classe C++ RSA à la fin pour que d'autre puisse la réutiliser.

[Davidlouiz]

Pour chiffrer la clé d'activation du logiciel, je génère 2 nombre de 4096 bits chacun. Je me retrouve avec deux clé (publique et privé) chacune composée de 2 nombre (C-N et U-N). Après chiffrement de mon timestamp, je me retrouve avec une clé d'activation de 3Km. Je ne me vois pas l'envoyer comme tel par mail en disant à l'utilisateur : "Pour activer ton logiciel pour un an, tu dois entrer cette clé de 3Km".

Visiblement, la longueur de la clé est lié à la taille des nombre premiers C et N qui sont généré pour chiffrer.

Avez-vous une idée pour conserver une bonne sécurité, que personne ne puisse générer une clé d'activation qui, après déchiffrement, donne un timestamp d'une date qui n'expire que dans 50 ans tout en gardant une clé relativement courte ?

Je pourrais diminuer la taille de mes nombres premiers (au détriment de la sécurité), et fournir la clé en hexa-ascii mais ça reste quand même long.

Merci.

[Davidlouiz]

Si ça peut intéresser du monde, j'ai créé une bibliothèque RSA avec un tutoriel d'accompagnement.

Je considère le sujet comme étant résolu.