Estoy trabajando en la implementación de seguridad en una aplicación ASP.NET MVC 3, y estoy usando la implementación BCrypt encontrado aquí para manejar el cifrado y la verificación de contraseñas. La pantalla de registro de usuario cifra la contraseña que el usuario proporciona muy bien, y la contraseña cifrada se guarda en la base de datos. Sin embargo, tengo un problema con la verificación de contraseña en la página de inicio de sesión, y parece que no puedo entender por qué.

Mi acción de controlador de registro contiene lo siguiente:

[HttpPost]
[RequireHttps]
public ActionResult Register(Registration registration)
{
    // Validation logic...

    try
    {
        var user = new User
        {
            Username = registration.Username,
            Password = Password.Hash(HttpUtility.HtmlDecode(registration.Password)),
            EmailAddress = registration.EmailAddress,
            FirstName = registration.FirstName,
            MiddleInitial = registration.MiddleInitial,
            LastName = registration.LastName,
            DateCreated = DateTime.Now,
            DateModified = DateTime.Now,
            LastLogin = DateTime.Now
        };

        var userId = _repository.CreateUser(user);
    }
    catch (Exception ex)
    {
        ModelState.AddModelError("User", "Error creating user, please try again.");
        return View(registration);
    }

    // Do some other stuff...
}

Esta es Contraseña.Hash:

public static string Hash(string password)
{
    return BCrypt.HashPassword(password, BCrypt.GenerateSalt(12));
}

Así es como estoy manejando el inicio de sesión:

[HttpPost]
[RequireHttps]
public ActionResult Login(Credentials login)
{
    // Validation logic...

    var authorized = _repository.CredentialsAreValid(HttpUtility.HtmlDecode(login.username), login.password);
    if (authorized)
    {
        // log the user in...
    }
    else
    {
        ModelState.AddModelError("AuthFail", "Authentication failed, please try again");
        return View(login);
    }
}

CredentialsAreValid finaliza la llamada a BCrypt.CheckPassword:

public bool CredentialsAreValid(string username, string password)
{
    var user = GetUser(username);
    if (user == null)
        return false;

    return Password.Compare(password, user.Password);
}

Contraseña.Compare:

public static bool Compare(string password, string hash)
{
    return BCrypt.CheckPassword(password, hash);
}

Y finalmente, esto es lo que está haciendo BCrypt.CheckPassword:

public static bool CheckPassword(string plaintext, string hashed)
{
    return StringComparer.Ordinal.Compare(hashed, HashPassword(plaintext, hashed)) == 0;
}

Entonces, sí ... no sé lo que está pasando, pero lo que sí sé es que mi booleanoauthorized variable en mi acción de controlador de inicio de sesiónsiempr devuelve falso por alguna razón.

He usado esta misma clase de BCrypt en al menos un par de otros proyectos en el pasado, y nunca tuve ningún problema con ella. ¿ASP.NET MVC 3 está haciendo una codificación extraña y diferente a los datos publicados que me falta o que necesito manejar de manera diferente o algo así? ¿O eso, o SQL CE 4 lo está haciendo (ese es el almacén de datos que estoy usando actualmente)? Todo parece estar en orden en mi código por lo que puedo decir, pero por alguna razón, la verificación de contraseña falla cada vez. ¿Alguien tiene alguna idea

Gracias

UPDATE: Aquí están los comentarios de código incluidos con la clase BCrypt con ejemplos de cómo se usa y funciona.

/// <summary>BCrypt implements OpenBSD-style Blowfish password hashing
/// using the scheme described in "A Future-Adaptable Password Scheme"
/// by Niels Provos and David Mazieres.</summary>
/// <remarks>
/// <para>This password hashing system tries to thwart offline
/// password cracking using a computationally-intensive hashing
/// algorithm, based on Bruce Schneier's Blowfish cipher. The work
/// factor of the algorithm is parametized, so it can be increased as
/// computers get faster.</para>
/// <para>To hash a password for the first time, call the
/// <c>HashPassword</c> method with a random salt, like this:</para>
/// <code>
/// string hashed = BCrypt.HashPassword(plainPassword, BCrypt.GenerateSalt());
/// </code>
/// <para>To check whether a plaintext password matches one that has
/// been hashed previously, use the <c>CheckPassword</c> method:</para>
/// <code>
/// if (BCrypt.CheckPassword(candidatePassword, storedHash)) {
///     Console.WriteLine("It matches");
/// } else {
///     Console.WriteLine("It does not match");
/// }
/// </code>
/// <para>The <c>GenerateSalt</c> method takes an optional parameter
/// (logRounds) that determines the computational complexity of the
/// hashing:</para>
/// <code>
/// string strongSalt = BCrypt.GenerateSalt(10);
/// string strongerSalt = BCrypt.GenerateSalt(12);
/// </code>
/// <para>
/// The amount of work increases exponentially (2**log_rounds), so
/// each increment is twice as much work. The default log_rounds is
/// 10, and the valid range is 4 to 31.
/// </para>
/// </remarks>