HMAC-en fonction d'un mot de passe en C# (RFC 4226 - HOTP)

Je suis d'essayer d'envelopper mon cerveau autour de la génération d'un 6 chiffres/caractères non sensible à la casse expiration de mot de passe.

Ma source est http://tools.ietf.org/html/rfc4226#section-5

D'abord la définition des paramètres

C       8-byte counter value, the moving factor.  This counter
       MUST be synchronized between the HOTP generator (client)
       and the HOTP validator (server).

K       shared secret between client and server; each HOTP
       generator has a different and unique secret K.

T       throttling parameter: the server will refuse connections
       from a user after T unsuccessful authentication attempts.

Ensuite, nous avons l'algorithme pour générer les HOTP

As the output of the HMAC-SHA-1 calculation is 160 bits, we must
   truncate this value to something that can be easily entered by a
   user.

                   HOTP(K,C) = Truncate(HMAC-SHA-1(K,C))

Ensuite, nous avons Tronquer défini comme

String = String[0]...String[19]
 Let OffsetBits be the low-order 4 bits of String[19]
 Offset = StToNum(OffsetBits) //0 <= OffSet <= 15
 Let P = String[OffSet]...String[OffSet+3]
 Return the Last 31 bits of P

Et ensuite un exemple est proposé pour un 6 chiffres HOTP

The following code example describes the extraction of a dynamic
binary code given that hmac_result is a byte array with the HMAC-
SHA-1 result:

    int offset   =  hmac_result[19] & 0xf ;
    int bin_code = (hmac_result[offset]  & 0x7f) << 24
       | (hmac_result[offset+1] & 0xff) << 16
       | (hmac_result[offset+2] & 0xff) <<  8
       | (hmac_result[offset+3] & 0xff) ;

Je suis plutôt à une perte en tentant de convertir ce utile de code C# pour générer une seule fois les mots de passe. J'ai déjà le code pour la création d'une expirant HMAC comme suit:

byte[] hashBytes = alg.ComputeHash(Encoding.UTF8.GetBytes(input));
byte[] result = new byte[8 + hashBytes.Length];

hashBytes.CopyTo(result, 8);
BitConverter.GetBytes(expireDate.Ticks).CopyTo(result, 0);

Je ne suis pas sûr de savoir comment aller de cela, à 6 chiffres proposés dans les algorithmes ci-dessus.

Je crois que C est un DateTime timbre et K est le secret de la Clé que j'ai déjà attribué à chaque compte utilisateur. Comment j'ai correctement hachage et puis tronquer jusqu'à 6 chiffres est là que je suis confus.
L'annexe C fournit une implémentation de référence en Java qui doit être facilement traduisible en C#.
Il est, mais il ne génère un numérique HOTP. J'aimerais vraiment un alpha-numérique HOTP.

OriginalL'auteur Josh | 2010-11-29

c#hmac one-time-password

3

Vous avez deux questions se posent ici:
1. Si vous êtes à générer de l'alpha-numérique, vous ne sont pas conformes à la RFC - à ce stade, vous pouvez simplement prendre tous les N octets, et de les transformer en chaîne hexadécimale et obtenir de l'alpha-numérique. Ou, les convertir en base 36 si vous voulez a-z et 0-9. La Section 5.4 de la RFC est de vous donner la norme HOTP calc pour un ensemble Digit paramètre (notez que Digit est un paramètre avec C, K, et T). Si vous choisissez d'ignorer cette section, alors vous n'avez pas besoin de convertir le code - il suffit d'utiliser ce que vous voulez.
2. Votre "résultat" tableau d'octets a l'expiration du temps simplement en peluche dans les 8 premiers octets après le malaxage. Si votre troncature à 6 caractères alphanumériques ne recueille pas ces avec les pièces de la table de hachage, il peut aussi bien ne pas être calculée. Il est également très facile de "faux" ou de relecture de hachage le secret une fois, puis mettre tout ce que les tiques que vous souhaitez en face d'elle, pas vraiment un mot de passe. Notez que le paramètre C dans la RFC est destinée à répondre à l'expiration de la fenêtre et doit être ajouté à l'entrée avant de calcul le code de hachage.
Après avoir creusé en plus, j'ai dû abandonner l'idée d'une expirant OTP tout en un. L'algorithme utilise un compteur - qui est, il a été conçu pour fonctionner indépendamment sur un périphérique matériel (comme un dongle/téléphone portable) et un serveur de validation. De cette façon, si le compteur est le même, le même OTP est toujours générée - car il n'existe aucun moyen pour extraire les données de retour, comme il était dans mon expirant HMAC. Mais vous avez raison sur les deux points. Pour le faire expirer je dois faire plus que cet algorithme est mis en place, et si je veux avoir une alphanumérique OTP alors j'ai besoin d'un algorithme différent.

OriginalL'auteur Philip Rieck
2

Pour toute personne intéressée, je n'ai trouver un moyen de construire l'expiration de mon mot de passe. L'approche est d'utiliser la date de création jusqu'à la minute (en ignorant les secondes, millisecondes, etc). Une fois que vous avez de la valeur, utilisez les tiques de type DateTime comme le comptoir, ou variable C.

otpLifespan est mon HOTP durée de vie en quelques minutes.
```
DateTime current = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 
    DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute, 0);

for (int x = 0; x <= otpLifespan; x++)
{
    var result = NumericHOTP.Validate(hotp, key, 
        current.AddMinutes(-1 * x).Ticks);

    //return valid state if validation succeeded

    //return invalid state if the passed in value is invalid 
    // (length, non-numeric, checksum invalid)
}

//return expired state
```
Mon expirant HOTP s'étend à partir de mon numérique HOTP qui a une statique de la méthode de validation qui vérifie la longueur, assure qu'il est numérique, valide la somme de contrôle si elle est utilisée, et compare enfin, la hotp transmis avec un générés.

Le seul inconvénient, c'est que chaque fois que vous validez une expirant hotp, votre pire scénario est à vérifier n + 1 HOTP valeurs où n est la durée de vie en quelques minutes.

L'exemple de code java dans le document de présentation de la RFC 4226 était très simple de se déplacer en C#. La seule pièce que j'ai vraiment dû mettre tout effort en réécriture a été la méthode de hachage.
```
private static byte[] HashHMACSHA1(byte[] keyBytes, byte[] text)
{
    HMAC alg = new HMACSHA1(keyBytes);

    return alg.ComputeHash(text);
}
```
J'espère que cela aide quelqu'un d'autre de tenter de générer une seule fois les mots de passe.

OriginalL'auteur Josh

Cet extrait devrait faire ce que vous demandez:

  public class UniqueId
{
    public static string GetUniqueKey()
    {
        int maxSize = 6; //whatever length you want
        char[] chars = new char[62];
        string a;
        a = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
           char[] chars = new char[a.Length];
        chars = a.ToCharArray();
        int size = maxSize;
        byte[] data = new byte[1];
        RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider();
        crypto.GetNonZeroBytes(data);
        size = maxSize;
        data = new byte[size];
        crypto.GetNonZeroBytes(data);
        StringBuilder result = new StringBuilder(size);
        foreach (byte b in data)
        { result.Append(chars[b % (chars.Length - 1)]); }
        return result.ToString();
    }
}

Semble bon. Mais char[] chars = new char[a.Length]; donne une erreur que de caractères a été défini dans le cadre déjà.

OriginalL'auteur Peter Bromberg

Vous devez vous connecter pour publier un commentaire.