Nel corso di uno dei precedenti script (https://www.aspitalia.com/script/1184/Scadenza-Password-ASP.NET-Identity.aspx) abbiamo personalizzato ASP.NET Identity per sottoporre a scadenza periodica la password utente. Tipicamente, a questo requisito si accompagna quello di vietare il riutilizzo di una delle password precedenti. Vediamo come possiamo supportare anche questo scenario.

Identity model

public class ApplicationUser : IdentityUser
{
  public virtual ICollection<PasswordHistoryEntry> PasswordHistory { get; set; }

  // altro codice qui
}

public class PasswordHistoryEntry
{
    public int Id { get; set; }

    public ApplicationUser User { get; set; }

    public string Hash { get; set; }

    public DateTime ChangeDate { get; set; }
}

Ovviamente, visto che non è corretto tenere traccia delle password in chiaro, l'oggetto PasswordHistoryEntry conterrà solo l'hash di quelle impostate dall'utente, unitamente alla data in cui è stata fatta la modifica, così che possiamo eventualmente supportare policy meno restrittive (es. non riutilizzare le ultime 5 password).

Modifiche su ApplicationUserManager

public override async Task<IdentityResult> 
  ChangePasswordAsync(string userId, string currentPassword, string newPassword)
{
  if (await this.CheckPasswordAlreadyUsedAsync(userId, newPassword))
  {
    return new IdentityResult(
      "Password già utilizzata in passato, sceglierne un'altra");
  }

  var result = 
    await base.ChangePasswordAsync(userId, currentPassword, newPassword);

  if (result.Succeeded)
  {
    await this.Store.StorePasswordChangedAsync(userId);
  }

  return result;
}

public override async Task<IdentityResult> CreateAsync(ApplicationUser user)
{
  var result = await base.CreateAsync(user);

  if (result.Succeeded)
  {
    await this.Store.StorePasswordChangedAsync(user.Id);
  }

  return result;
}

Il primo passo è quello di invocare il metodo CheckPasswordAlreadyUsedAsync (lo vedremo nel dettaglio tra un attimo), che effettua la verifica di corrispondenza con lo storico password dell'utente. Nel caso questa abbia successo, possiamo procedere alla modifica e, successivamente, ad aggiornare lo storico delle password con il metodo StorePasswordChangedAsync.

Lo stesso metodo viene invocato dal metodo CreateAsync, in maniera del tutto analoga, per memorizzare la prima password scelta dall'utente in fase di registrazione.

CheckPasswordAlreadyUsedAsync è molto semplice, visto che si limita a verificare se la password proposta rientri già nell'history dell'utente:

public async Task<bool> CheckPasswordAlreadyUsedAsync(
  string userId, string password)
{
  var user = await this.Store.FindByIdAsync(userId);
  if (user == null)
    return false;

  return user.PasswordHistory
    .OrderByDescending(x => x.ChangeDate)
    .Take(5)
    .ToList()
    .Any(x => this.PasswordHasher.VerifyHashedPassword(x.Hash, password) 
                != PasswordVerificationResult.Failed);
}

Nell'esempio in alto, abbiamo preso in considerazione le ultime 5 password utilizzate, ma ovviamente possiamo modificare a piacimento questo vincolo, configurarlo o addirittura rimuoverlo, secondo le esigenze. Una nota importante riguarda il fatto che non controlliamo direttamente l'hash della password, ma sfruttiamo il metodo VerifyHashedPassword del password hasher, così siamo sicuri che stiamo controllandone l'uguaglianza in maniera coerente con l'algoritmo di hashing utilizzato.

L'ultimo passaggio riguarda la memorizzazione della password nello storico. Viene effettuata dall'extension method StorePasswordChangedAsync che abbiamo già introdotto nello script precedente:

internal static async Task StorePasswordChangedAsync(
  this IUserStore<ApplicationUser, string> store, string userId)
{
  if (string.IsNullOrWhiteSpace(userId))
    throw new ArgumentNullException("userId");

  var passwordStore = (IUserPasswordStore<ApplicationUser, string>)store;

  var user = await store.FindByIdAsync(userId);

  if (user == null)
    return;

  var changeDate = DateTime.UtcNow;
  var passwordHash = await passwordStore.GetPasswordHashAsync(user);

  user.PasswordHistory.Add(new PasswordHistoryEntry() 
  {
    User = user,
    Hash = passwordHash,
    ChangeDate = changeDate
  });

  await store.UpdateAsync(user);
}

Anche qui, la logica è molto semplice: viene intanto fatto un tentativo di recupero dell'utente, che in caso di mancato successo non provoca alcun errore per non svelare dettagli del nostro sistema di security. In seguito, non facciamo altro che inserire una nuova entry all'interno dell'history, contenente l'hash della password dell'utente, che recuperiamo tramite il metodo GetPasswordHashAsync. L'ultima riga esegue l'aggiornamento sullo storage, così che i nuovi dati vengano persistiti.