Conversion d'un byte[] en type decimal ?

Version imprimable

Créer une empreinte numérique d'un hash SHA256 ?

Bonjour,

J'ai codé la fonction ci-dessous qui me produit un hash SHA256 d'une chaine de caractères. Cependant je voudrais compléter cette fonction pour avoir comme résultat un nombre de 20 chiffres à partir du Hash.

Pour y arriver, je dois extraire les 64 bits ayant un poids fort et les convertir en numérique.

Comment puis-je procéder ? J'ai essayé plein de façon, lu plein de choses sur le net (conversion en binaire, tutoriel sur les bits ...) mais même avec tout ça je bloque. Pouvez-vous m'aider ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 private string calc_sha256(string graine) { SHA256 hash = SHA256.Create(); byte[] Tab = Encoding.UTF8.GetBytes(graine); byte[] hashResult = hash.ComputeHash(Tab); // conversion en numerique mais ne me donne pas ce que je veux decimal decvalue = BitConverter.ToUInt64(hashResult,0); // retourne le résultat sous forme de chaine return (decvalue.ToString()); }
Merci.

Pourquoi veux-tu un nombre de 20 chiffres ? Généralement le résultat du hash est mis sous forme d'une chaîne en hexadécimal, dont la longueur varie en fonction de l'algorithme de hachage (128 bits, 256 bits, ...).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private string HashWithSha256(string stringToHash)
{
    HashAlgorithm hashAlgorithm = SHA256.Create();
    byte[] hashData = Encoding.UTF8.GetBytes(stringToHash);
    byte[] hash = hashAlgorithm.ComputeHash(hashData);
 
    StringBuilder result = new StringBuilder();
    foreach (byte b in hash)
    {
        result.Append(b.ToString("X2"));
    }
 
    return result.ToString();
}

Si tu peux être amené à utiliser plusieurs algorithmes de hachage dans l'application

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private string HashWithSha256(string stringToHash)
{
    return HashWith(SHA256.Create(), stringToHash);
}
 
private string HashWithMD5(string stringToHash)
{
    return HashWith(MD5.Create(), stringToHash);
}
 
private string HashWith(HashAlgorithm hashAlgorithm, string stringToHash)
{
    byte[] hashData = Encoding.UTF8.GetBytes(stringToHash);
    byte[] hash = hashAlgorithm.ComputeHash(hashData);
 
    StringBuilder result = new StringBuilder();
    foreach (byte b in hash)
    {
        result.Append(b.ToString("X2"));
    }
 
    return result.ToString();
}

16/09/2009, 10h18
Shypster

Si tu veux, je dois créer un numéro d'identité composé de 20 chiffres issu d'un hash crypté en SHA256 (c'est une obligation).

Pour cela, je crée une chaine avec des informations spécifiques (texte en clair).
Ensuite, je crée mon hash en SHA256 sur cette chaine de caractères.
Jusque là tout va bien.

Ensuite, je bloque. Pour obtenir ce nombre de 20 chiffres, je dois procéder comme suit :

"Les 64 bits de poids fort de l’empreinte (hash SHA256 obtenu) sont convertis en base 10 afin d’obtenir une chaine composée de 20 chiffres. Si le nombre obtenu s’exprime sur moins de 20 chiffres, il est complété à gauche par des zéros. "

Je suis complètement perdu pour faire ça, d'où ma demande d'aide.
16/09/2009, 10h30
StormimOn

Tu aurais un exemple de chaîne d'entrée et la valeur attendue pour cette chaîne ?
16/09/2009, 10h51
Shypster

Pas vraiment c'est un algorithme nouveau que j'esssaye de mettre au point donc pas vraiment d'exemple désolé.

En revanche en entrée on a ce genre de chaine :
"SEBASTIEN 8006242849631257410"
longueur des champs : 10 + 6 + 13
* On ajoute des espaces si la valeur est + petite que la longueur du champ.

En sortie, à partir du hash SHA256 de cette chaine on veut obtenir :
2 051 784 603 417 425 461 1
* ce numéro ne correspond pas à la chaine citée mais sert d'exemple.

Essaye avec quelque chose comme

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
static string calc_sha256(string graine)
{
    SHA256 hash = SHA256.Create();
    byte[] Tab = Encoding.UTF8.GetBytes(graine);
    byte[] hashResult = hash.ComputeHash(Tab);
 
    // On prend les 8 premiers octets (64 bits de poids fort).
    byte[] buffer = new byte[8];
    Array.Copy(hashResult, buffer, 8);
    // On crée un BitArray d'après ce tableau
    BitArray bitArray = new BitArray(buffer);
    // On parcours les bits pour calculer la valeur entière.
    ulong value = 0;
    int i = 63;
    foreach (bool b in bitArray)
    {
        if (b)
        {
            value += (ulong)Math.Pow(2, i);
        }
        i--;
    }
 
    return value.ToString().PadLeft(20, '0');
}

Citation:

Envoyé par StormimOn

Essaye avec quelque chose comme

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
static string calc_sha256(string graine)
{
    SHA256 hash = SHA256.Create();
    byte[] Tab = Encoding.UTF8.GetBytes(graine);
    byte[] hashResult = hash.ComputeHash(Tab);
 
    // On prend les 8 premiers octets (64 bits de poids fort).
    byte[] buffer = new byte[8];
    Array.Copy(hashResult, buffer, 8);
    Comment sais-tu que tu récupères les bits à poids fort ?
    Pour moi tu prends seulemnt les 8 premiers octets, non ?
 
    // On crée un BitArray d'après ce tableau
    BitArray bitArray = new BitArray(buffer);
    // On parcours les bits pour calculer la valeur entière.
    ulong value = 0;
    int i = 63; A quoi correspond cette valeur, utilité ?
    foreach (bool b in bitArray)
    {
        if (b)
        {
            value += (ulong)Math.Pow(2, i);
        }
        i--;
    }
 
    return value.ToString().PadLeft(20, '0'); 
    En sortie on obtiendra pas tout le temps 20 chiffres, pourquoi ?
}

Merci pour tes éclaircissements.

16/09/2009, 18h34
StormimOn

Citation:

Comment sais-tu que tu récupères les bits à poids fort ? Pour moi tu prends seulement les 8 premiers octets, non ?

Je prends seulement les 8 premiers octets oui. C'est arbitraire car de toute façon le condensé (la valeur du hash) ne correspond pas à une valeur numérique, il n'y a donc pas de bits de poids fort. Par contre avec cet algorithme tu passes à la trappe les 3/4 du hash (8 octets utilisés sur les 32) ce qui fait que les collisions seront d'autant plus nombreuses.

Citation:

A quoi correspond cette valeur, utilité ?

Pour la calcul de la valeur numérique correspondant au 64 bits de poids fort en effectuant la somme 2^63 + 2^62 + 2^61 + ... + 2^0 en fonction des bits actifs. Par contre, d'une part le parcours commence par le bit de poids faible et donc il fallait partir de 0 et incrémenter i au lieu de partir de 63 et décrémenter. D'autre part, BitConverter fait ce calcul donc ce code est inutile et utiliser BitConverter suffit.

Citation:

En sortie on obtiendra pas tout le temps 20 chiffres, pourquoi ?

Bein parce que la somme précédente ne donnera pas forcément un nombre à 20 chiffres. C'est d'ailleurs ce que tu indiques

Citation:

Si le nombre obtenu s’exprime sur moins de 20 chiffres, il est complété à gauche par des zéros.
16/09/2009, 21h02
Shypster

Citation:

Pour la calcul de la valeur numérique correspondant au 64 bits de poids fort en effectuant la somme 2^63 + 2^62 + 2^61 + ... + 2^0 en fonction des bits actifs. Par contre, d'une part le parcours commence par le bit de poids faible et donc il fallait partir de 0 et incrémenter i au lieu de partir de 63 et décrémenter. D'autre part, BitConverter fait ce calcul donc ce code est inutile et utiliser BitConverter suffit.

Je dois donc rectifier ton code par bitconverter pour la conversion en numerique ?

A priori c'est ce que j'ai voulu dire ^^

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static string calc_sha256(string graine)
{
    SHA256 hash = SHA256.Create();
    byte[] Tab = Encoding.UTF8.GetBytes(graine);
    byte[] hashResult = hash.ComputeHash(Tab);
 
    // On prend les 8 premiers octets.
    byte[] buffer = new byte[8];
    Array.Copy(hashResult, buffer, 8);
 
    // On calcule la valeur entière de ces 8 octets
    ulong value = BitConverter.ToUInt64(buffer, 0);
 
    return value.ToString().PadLeft(20, '0'); 
}

Mais je le répète, comme tu ne travailles qu'avec 1/4 du condensé je vois mal l'intérêt de cet algorithme :aie:

17/09/2009, 10h46
Shypster

L'utilité principale de prendre les 1/4 du hash c'est d'avoir en résultat un nombre de 20 chiffres car l'objectif est d'avoir un numéro d'identification. Si on traitait tout le hash la longueur de ce numéro ne serait pas pratique à intégrer mais je suis tout à fait d'accord sur le risque aggrandi de collisions.

Merci pour ton aide.
19/09/2009, 10h07
smyley

Au fait ton numéro ne peux pas être un string ?