Coder et décoder une clé d’activation maison

Version imprimable

22/01/2013, 11h24
alavoler

Coder et décoder une clé d’activation maison

Bonjour à tous!

J’ai besoin en C# 2.0, d’avoir une fonction de cryptage et décryptage de clés d’activation.

La clé doit être sur 18 caractères, AlphaMajuscule Numérique.
Elle doit contenir une fois décodée, 3 int et un tableau de 40 Byte.
Je ne fournis au public que la version de décryptage, bien évidement :)

Quelqu’un à de la littérature ou des conseils à me donner ?

Je sais que faire ça en .Net m’expose en termes de sécurité, quel est le moyen le plus fiable en .Net pour réaliser cela ? (l'obfuscation est il utile ?)

Merci
22/01/2013, 13h59
alavoler

Suffit il de construire mon message:
int int int Byte[40]

Puis de le crypter avec un système clé privée/publique ?

Comment obtenir à coup sur 18 caractères ?

merci
22/01/2013, 23h42
PatteDePoule

Le chiffrement ne compresse pas les données.

Ensuite, la valeur maximal d'un int est 2 147 483 647. En base 36 cela donne ZIK0ZJ, soit 6 caractères de long. Tu dois en avoir 3, alors 3 fois 6 égale 18. La longueur de ta clé est déjà atteinte.

Admettons que l'on continu, un Byte est une valeur de 0 à 255. En base 64 cela donne 74, soit 2 caractères de longueur. Il t'en faut 40 continue, pour une longueur total (40*2) de 80 caractères.

Ce qui donne au total une clé de (18+80) 98 caractères de long. :aie:
23/01/2013, 09h59
alavoler

PatteDePoule
Merci pour ta réponse ! C'est sympa d'avoir un avis

Donc il faut essayer de limiter les types, je peux me limiter fonctionnellement à:
- un entier de 0 à 99 999 999
- un entier de 0 à 9 999 999
- un entier de 0 à 999 999
- un tableau de 40 valeurs (de 0 ou de 1)

Comment obtenir de façon déterministe, une suite de 18 caractères (AlphaNum) ?
Quel est le cryptage que je dois utiliser ? (RSA n'a pas l'air de correspondre...)
Peut on utiliser une compression ?

merci
23/01/2013, 15h16
Babyneedle

J'aimerais surtout savoir pourquoi cette restriction sur les 18 caractères?

Quelles sont les raisons de l'obfuscation?

- Empêcher le sniffing de packets?
- Diffusion de clés publiques non séquentielles?
- Création d'une signature pour échange de données?
23/01/2013, 15h56
alavoler

Babyneedle
Pour des raison historique, nos produits on déja une clé 18 caractères, le cryptage actuel arrive à stocker ces infos, je veux juste faire une lib .net qui arrive à faire la même chose.

Oublions l'obfuscation dans cette discutions :), vu que je veux réaliser ca en .net, c'était pour protéger l'algo de cryptage (à l'origine cette DLL est fournit en C, donc le désassemblage est plus difficile qu'en C#). c'est tout
23/01/2013, 20h47
PatteDePoule

La seule solution que je vois présentement est de travailler directement en binaire.

Par exemple :
99 999 999 en base 10 devient 101111101011110000011111111 en base 2, 27 de long.
9 999 999 en base 10 devient 100110001001011001111111 en base 2, 24 de long.
999 999 en base 10 devient 11110100001000111111 en base 2, 20 de long.
Un tableau de 40 bit, à un longueur de 40bit.

En tout ta chaine en binaire va avoir une longueur maximal de 111 bit.

Ta valeur maximal est 101111101011110000011111111100110001001011001111111111101000010001111111111111111111111111111111111111111111111.

Une fois converti en base 36 cela donne

Code:

40P7O3TIIUWWG48O08WS8S

22 caractères de long.

Mais c'est encore trop long selon tes spécifications. :cry:

De plus, il n'y a rien de "crypté" encore. :aie:
23/01/2013, 21h38
alavoler

PatteDePoule
Tu te donnes du mal :), merci

OK donc pas de soucis je peux gratter un peu de données... (c est étrange car la librairie originale semble ajouter d'autres données genre une date... et ça tient sur 18 char)

Dernière question essentielle pour moi:
Une fois les 18 caractères générées, est il possible de crypter tout en gardant les 18 caractère en longueur ?
Par habitude j'ai l'impression que crypter, ajoute généralement des caractères... existe il un cryptage qui respect ça ?

merci
24/01/2013, 14h27
PatteDePoule

Crypter tes données ne modifie pas la longueur, elle reste exactement la même.

Mais lorsque les données sont crypté, elles peuvent prendre n'importe qu'elle valeur. Et c'est lors de la conversion en base 36 que tu vas gagner des caractères supplémentaires.

Peut-être que le format sur 18 caractères est hyper optimisé?
24/01/2013, 17h17
alavoler

Je ne sais pas ce que tu entends par hyper optimisé

chose marrante en faisant varier la clé (en tapant au hasard sur son clavier) on obtient aisément une clé valide ! (ça ajoute des postes/licenses, et des options ! ahha)
25/01/2013, 17h55
alavoler

PatteDePoule

Ok c'est normal que tu ne réussis pas à caser tout ! Il y a une donné en moins !
Cette donné (un int) est utilisé pour la génération de la clé, et le décodage !

999 + 999999999 + Tableau de 40
on arrive à:
11111001111110111001101011001001111111111111111111111111111111111111111111111111

ce qui donne 16 caractères en base 36 : 5C8HXNG277GFV30G

Sais tu Comment puis je obtenir toujours 18 caractères ?
Quel algo de cryptage puis je utiliser

merci du coup de main !
& bonne soirée
25/01/2013, 21h11
PatteDePoule

Et voilà! :mrgreen:

Pour tes 2 caractères manquant, tu pourrais insérer des données bidon dans ta chaine. Ou encore mieux, insérer deux caractères de contrôle. Cela rendrait plus difficile la "génération" de clé en tapant aléatoirement.

Par exemple, les deux derniers caractères peuvent être la somme des 16 premiers (1=1, F=16, Z=36).

Pour le chiffrement, si tu chiffres ta chaine tu vas obtenir d'autres valeurs que tu vas devoir retransformer en base 36. Et là ta longueur va varié. :aie:

Je ne vois pas trop où insérer le chiffrement dans cette procédure sans foutre en l'air les 18 caractères... :(
25/01/2013, 23h52
alavoler

PatteDePoule
Tu m'as bien aidé déja !

Question à 2 balle pour les autres : y a cryptage qui prend en compte ce qu'on lui demande en terme de caractere (en l occurrence de l'alphanumerique) ?
26/01/2013, 00h49
Graffito

80 bits = 10 byte (base 256) qu'on peut crypter sur 10 byte (base 256) = 80 bits codables sur 18 caractères (base 36).
26/01/2013, 12h52
alavoler

Graffito
Merci,
je crois comprendre un peu...
On peut utiliser de l'ascii extend par exemple (base 256)

mais comment je crypte y a pas un cryptage clé public/privée qui peut faire facilement ça ? je vais chercher, ou bien c est forcement du symétrique ?

L'idée (je ne sais pas si c'est la bonne), c'est d'utiliser un cryptage asymetrique, pour sa faculté à "signer" mais pas vraiment à crypter en fait...

Au fond j'ai pas besoin de crypter la clé, j'ai simplement besoin de signer ce que j'ai encodé (mais je peux me tromper dites le moi auquel cas :) )

J'ai un petit problème pour convertir en base 36 :

Avec ce code que j'ai pris sur le Net j'obtiens 5C8HXNG277GFV30F
pour 11111001111110111001101011001001111111111111111111111111111111111111111111111111
de base 2 à base 36

Code:

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
87
88
89
90
91
92
93
94
95
96
        public static String ConvertBase(int from, int to, String s)
        {
            //Return error if input is empty
            if (String.IsNullOrEmpty(s))
            {
                return ("Error: Nothing in Input String");
            }
            //only allow uppercase input characters in string
            s = s.ToUpper();
 
            //only do base 2 to base 36 (digit represented by characters 0-Z)"
            if (from < 2 || from > 36 || to < 2 || to > 36)
            { return ("Base requested outside range"); }
 
            //convert string to an array of integer digits representing number in base:from
            int il = s.Length;
            int[] fs = new int[il];
            int k = 0;
            for (int i = s.Length - 1; i >= 0; i--)
            {
                if (s[i] >= '0' && s[i] <= '9') { fs[k++] = (int)(s[i] - '0'); }
                else
                {
                    if (s[i] >= 'A' && s[i] <= 'Z') { fs[k++] = 10 + (int)(s[i] - 'A'); }
                    else
                    { return ("Error: Input string must only contain any of 0-9 or A-Z"); } //only allow 0-9 A-Z characters
                }
            }
 
            //check the input for digits that exceed the allowable for base:from
            foreach (int i in fs)
            {
                if (i >= from) { return ("Error: Not a valid number for this input base"); }
            }
 
            //find how many digits the output needs
            int ol = il * (from / to + 1);
            int[] ts = new int[ol + 10]; //assign accumulation array
            int[] cums = new int[ol + 10]; //assign the result array
            ts[0] = 1; //initialize array with number 1 
 
            //evaluate the output
            for (int i = 0; i < il; i++) //for each input digit
            {
                for (int j = 0; j < ol; j++) //add the input digit 
                // times (base:to from^i) to the output cumulator
                {
                    cums[j] += ts[j] * fs[i];
                    int temp = cums[j];
                    int rem = 0;
                    int ip = j;
                    do // fix up any remainders in base:to
                    {
                        rem = temp / to;
                        cums[ip] = temp - rem * to; ip++;
                        cums[ip] += rem;
                        temp = cums[ip];
                    }
                    while (temp >= to);
                }
 
                //calculate the next power from^i) in base:to format
                for (int j = 0; j < ol; j++)
                {
                    ts[j] = ts[j] * from;
                }
                for (int j = 0; j < ol; j++) //check for any remainders
                {
                    int temp = ts[j];
                    int rem = 0;
                    int ip = j;
                    do  //fix up any remainders
                    {
                        rem = temp / to;
                        ts[ip] = temp - rem * to; ip++;
                        ts[ip] += rem;
                        temp = ts[ip];
                    }
                    while (temp >= to);
                }
            }
 
            //convert the output to string format (digits 0,to-1 converted to 0-Z characters) 
            String sout = String.Empty; //initialize output string
            bool first = false; //leading zero flag
            for (int i = ol; i >= 0; i--)
            {
                if (cums[i] != 0) { first = true; }
                if (!first) { continue; }
                if (cums[i] < 10) { sout += (char)(cums[i] + '0'); }
                else { sout += (char)(cums[i] + 'A' - 10); }
            }
            if (String.IsNullOrEmpty(sout)) { return "0"; } //input was zero, return 0
            //return the converted string
            return sout;
        }

source:
http://www.codeproject.com/Articles/...itive-Integers

Alors que d'après le site http://www.kaagaard.dk/service/convert.htm il faut plutot obtenir 5C8HXNG277GFV30G !

C'est balo à une lettre près

Y a une méthode qui marche bien en 2.0 ?

28/01/2013, 02h30
PatteDePoule

J'ai mis 5C8HXNG277GFV30G pour l'avoir en base 2 sur le site que tu as mentionné, et je n'obtiens pas le résultat escompté...

Il est surement en erreur!
28/01/2013, 08h09
alavoler

PatteDePoule
Héhé,
Ce qui est marrant c'est que je n'ai pas trouvé d'autre convertisseur Online, ni de meilleurs code .Net qui gère le base 36...
pourtant j'ai essayé de chercher...
28/01/2013, 10h00
Graffito

Voir : http://www.codeproject.com/Articles/...ion-class-in-C
28/01/2013, 10h43
alavoler

Salut Graffito !
j'ai essayé aussi ce code mais j'obtiens une erreur :

Citation:

L'opération arithmétique a provoqué un dépassement de capacité.