Est-il un algorithme de hachage qui produit une table de hachage de taille de 64 bits en C#?

J'ai besoin pour produire une valeur de Hachage à partir d'une chaîne de longueur variable que je peux stocker dans un champ de plus de 16 ans (en raison des exigences liées au vendeur).

Je suis la concaténation de plusieurs chaînes de caractères qui sont transmis par l'intermédiaire d'un C# script de transformation afin de calculer la valeur de Hachage. Je suis contraint par le fournisseur du fichier de spécification en ce que la sortie de la table de hachage ne peut pas être plus longue que 16.

Quelqu'un aurait-il des suggestions? Comme un exemple de la chaîne de conversion de l'algorithme MD5 a une longueur de 32.

16 quoi? Est-il binaire ou texte?
Idéalement, il serait de texte, car il sera écrit dans un fichier plat.
plat de fichiers n'ont pas à être de texte.
Les exigences pour le fichier que je dois produire un onglet ASCII délimité fichier plat.

InformationsquelleAutor Matt | 2010-12-02

c#hash ssis

7

La cryptographie a des fonctions sont conçues de telle sorte que vous pouvez tronquer la sortie d'une certaine taille et le tronc de la fonction de hachage reste un sûr fonction de hachage cryptographique. Par exemple, si vous prenez la première à 128 bits (16 octets) de la sortie de l'algorithme SHA-512 appliquée à une entrée, puis la première à 128 bits sont un hachage cryptographique aussi forte que toute autre de 128 bits de hachage cryptographique.

La solution est de choisir en fonction de hachage cryptographique - SHA-256, SHA-384 et SHA-512 sont de bons choix et tronquer la sortie à 128 bits (16 octets).

--EDIT--

Basé sur le commentaire que la valeur de hachage doit, lorsqu'ils sont encodés en ASCII, s'inscrivent dans 16 ASQUES personnages, la solution est
- d'abord, à choisir en fonction de hachage cryptographique (SHA-2 famille comprend SHA-256, SHA-384 et SHA-512)
- alors, pour tronquer la sortie de l'choisis en fonction de hachage à 96 bits (12 octets) - qui est, garder les 12 premiers octets de la fonction de hachage de sortie et de jeter les octets restants
- puis, à la base-64-encoder la sortie tronquée à 16 caractères ASCII (128 bits)
- rendement efficace de 96 bits-fort de hachage cryptographique.
- 16 octets converti à l'HEX est toujours de 32 caractères. Pourriez-vous également fournir un lien à l'arrière de votre affirmation à propos de tronquer une partie d'un hachage calculée est sûr que l'utilisation de la version la plus basse de la table de hachage? Cela peut être vrai pour SHA (je ne sais pas de toute façon), mais je ne pense pas que vous pouvez faire une déclaration à la porte vrai dans toutes les tables de hachage.
- Blanchie: je pense que @Justice de l'action est généralement considérée comme vraie. Il est difficile d'imaginer une attaque qui fonctionne sur le tronc de hachage, mais pas sur la totalité de la table de hachage, d'autres que la force brutale.
- Vous voulez dire que vous ne pouvez pas simplement stocker la valeur de hachage d'octets, comme une séquence d'octets? Qui vous sont nécessaires pour coder les octets dans, par exemple, codage hexadécimal ou de l'encodage base64? Si vous pouvez stocker les octets brutes, vous devez stocker les octets brutes, et de prendre toutes les 16 octets de l'espace.
- J'ai ajouté un lien à l'autre DONC, la question dont le titre est "Est-il acceptable pour tronquer un SHA256 de hachage de 128 bits?"
- Les exigences pour le fichier que je dois produire un onglet ASCII délimité fichier plat et puisque je ne suis pas trop familier avec les ramifications de outputing la séquence d'octets dans un fichier texte, j'ai été extrêmement intéressé par ces types de suggestions.
- Édité. La solution est une combinaison de choix d'un mot de hachage cryptographique, la troncation de la sortie de 12 octets, puis base64-encodage du résultat de 16 octets de l'ASCII.
- Je suis l'aide de la SHA256Managed pour créer la table de hachage, mais j'étais curieux de savoir ce que seront les conséquences de substringing la chaîne base64 à 16 vs troncature à 12 octets avant l'encodage. Est-ce principalement un problème de performance ou est-il un risque pour la sécurité ainsi?
- De manière générale, il est toujours instructif de réfléchir sur les valeurs de hachage que peu-ou séquences d'octets-séquences, avec des textes différents systèmes de codage (hex, base64) utilisé uniquement comme la dernière étape. Dans ce cas, soit de l'ordre sera à la même chose (troncature à 12 octets, puis en base64 encodage, ou base64-encodage et puis la tronquant à 16 octets). Noter que l'encodage puis-troncature va nécessiter de codage de l'ensemble de la valeur de hachage, alors que la troncation-puis-encodage ne sera pas.
- Merci de Justice, j'apprécie l'explication.
- Tronqué de hachages sont beaucoup plus faibles que les originaux. Vous pouvez plus facilement se casser le tronc de hachage, sans avoir une attaque sur la totalité de hachage: csrc.nist.gov/groups/ST/hash/documents/Kelsey_Truncation.pdf
InformationsquelleAutor yfeldblum
0

Vous pouvez facilement utiliser un hachage MD5 pour cela, mais vous allez avoir à modifier la façon dont il est stocké. Un MD5 est de 128 bits, ce qui est généralement affiché 32 4 bits (en hexadécimal) de valeurs. Un char standard est de 8 bits, cependant, jusqu'à 16 caractères est suffisante pour stocker la valeur d'un hachage MD5.

Pour le convertir, essayez les solutions suivantes:
```
String hash32 = "d41d8cd98f00b204e9800998ecf8427e"
String hash16 = ""

for(int i = 0; i < 32; i+=2)
{
  uint high = Convert.ToUInt32(hash32[i], 16);
  uint low = Convert.ToUInt32(hash32[i+1], 16);
  char c = (char) ((high << 4) | low);

  hash16 += c;
}
```
- À l'aide de OU, XOR, ou de toute autre fonction binaire à augmenter les chances de collisions. Si vous êtes juste en utilisant ce pour une somme de contrôle, cela peut fonctionner, mais vous auriez probablement être plus en sécurité avec XOR. Sinon, vous pourriez tout aussi bien utiliser un contrôle de parité.
- Si vous remarquez, je vais concentrer un certain nombre qui sera toujours 4 octets ou moins à la gauche de 4 octets, de sorte que le bas et le haut bits n'entrent jamais en collision.
InformationsquelleAutor Wade Tandy

Si vous avez de 16 octets de stockage d'un 128bit nombre n'est pas un problème. Magasin de la 128 bits de la valeur en tant que 16 bits de la valeur au lieu de 32 chaîne de caractères qui est stocké le 16 octets valeur HEX.

Comme une note, j'ai utilisé GUID/UUID champs dans les bases de données pour stocker les hachages MD5. Tout n'est plus cryptographique sécurisé, 128bit hachages MD5 sont très bien pour les Sommes de contrôle (et c'est beaucoup mieux que 64 bits.)

var result = MD5.Create().ComputeHash(new byte[] { 0 });

Console.WriteLine(result.Length);
Console.WriteLine(Convert.ToBase64String(result));
Console.WriteLine(result.Aggregate(new StringBuilder(),
                                    (sb, v) => sb.Append(v.ToString("x2"))));

//16
//k7iFrf4NoInN9jSQT9WfcQ==
//93b885adfe0da089cdf634904fd59f71

File.WriteAllBytes("tempfile.dat", result);

var input = File.ReadAllBytes("tempfile.dat");

Console.WriteLine(input.Length);
Console.WriteLine(Convert.ToBase64String(input));
Console.WriteLine(input.Aggregate(new StringBuilder(), 
                                    (sb, v) => sb.Append(v.ToString("x2"))));

//16
//k7iFrf4NoInN9jSQT9WfcQ==
//93b885adfe0da089cdf634904fd59f71

Noter que je ne montre pas le contenu du fichier, car il ya une bonne chance qu'il contient "non imprimables" caractères.

InformationsquelleAutor Matthew Whited

Des commentaires au sujet de ce code? Semble fonctionne bien...

var p = new MD5CryptoServiceProvider();
var dic = new Dictionary<long, string>();

for (var i = 0; i < 10000000; i++)
{
    if (i%25000 == 0)
        Console.WriteLine("{0:n0}", i);

    var h = p.ComputeHash(Encoding.UTF8.GetBytes(Guid.NewGuid().ToString()));
    var b = BitConverter.ToInt64(h, 0);

    //"b" is hashed Int64

    if (!dic.ContainsKey(b))
        dic.Add(i, null);
    else
        throw new Exception("Oops!");
}

InformationsquelleAutor Efe Erdoğru

J'ai remarqué cette question est relativement vieux, mais je suis sûr que quelqu'un va trouver cette réponse précieuse.

Ma suggestion serait d'utiliser Blake2b qui a la capacité d'utiliser 8 bits par le biais de 512 bits. Si aucune taille de la clé est utilisée, la valeur par défaut est utilisé "512" dans ce cas. Blake2s valeur par défaut de 256 bits.

        //BLAKE2b
        //using System.Data.HashFunction;
        //
        //String message to use.
        string str = "The quick brown fox jumps over the lazy dog";
        //Initialize
        System.Data.HashFunction.Blake2B Blake2B = new System.Data.HashFunction.Blake2B();
        //Get string hash bytes; create 64 bit hash.
        var HashBytes = Blake2B.ComputeHash(str, 64);
        //Convert bytes to string and remove the dashes.
        string hexString = BitConverter.ToString(HashBytes).Replace("-", string.Empty);
        //Display results.
        MessageBox.Show(hexString);
        /*
         * "The quick brown fox jumps over the lazy dog" produces a hash value of
         * "A8ADD4BDDDFD93E4877D2746E62817B116364A1FA7BC148D95090BC7333B3673F82401CF7AA2E4CB1ECD90296E3F14CB5413F8ED77BE73045B13914CDCD6A918"
         * and "2FD0F3FB3BD58455" hash for 64 bits.
         */

Espérons que cette aide!

InformationsquelleAutor DemarcPoint

Vous devez vous connecter pour publier un commentaire.