Estou trabalhando na implementação da segurança em um aplicativo ASP.NET MVC 3 e estou usando a implementação BCrypt encontrada aqui para lidar com criptografia e verificação de senhas. A tela de registro do usuário criptografa a senha que o usuário fornece muito bem e a senha do hash é salva no banco de dados. No entanto, estou tendo um problema com a verificação de senha na página de login e não consigo entender por qu

ação do meu controlador de registro contém o seguinte:

[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...
}

This is Password.Hash:

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

É assim que eu estou lidando com o login:

[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 encerra a chamada para BCrypt.CheckPassword:

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

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

Password.Compare:

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

E finalmente, é isso que BCrypt.CheckPassword está fazendo:

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

Então, sim ... eu não sei o que está acontecendo, mas o que eu sei é que meu booleanoauthorized variável na minha ação do controlador de loginsempr retorna falso por algum motiv

Eu usei exatamente essa mesma classe BCrypt em pelo menos alguns outros projetos no passado e nunca tive nenhum problema com ela. O ASP.NET MVC 3 está fazendo uma codificação estranha e diferente para os dados postados que estão faltando ou que preciso manipular de maneira diferente ou algo assim? Ou isso, ou o SQL CE 4 está fazendo isso (esse é o armazenamento de dados que estou usando atualmente)? Tudo parece estar em ordem no meu código, pelo que sei, mas, por algum motivo, a verificação de senha está sempre falhando. Alguém tem alguma ideia

Obrigado

UPDATE: Aqui estão os comentários de código incluídos na classe BCrypt, com exemplos de como ele é usado e funcion

/// <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>