public void SetPasswords()
{
var hashOptions = new HashOptions();
Configuration.GetSection("HashOptions").Bind(hashOptions);
var optionsList = Options.Create(hashOptions);
var hashService = new HashService(optionsList);
var pathToFile = Directory.GetCurrentDirectory()
+ Path.DirectorySeparatorChar
+ "conturi.txt";
using (var newfile = File.Create("conturi-cu-parole.txt"))
{
using (var logWriter = new StreamWriter(newfile))
using (var reader = File.OpenText(pathToFile))
{
while (reader.Peek() >= 0)
{
var fileContent = reader.ReadLine();
var data = fileContent.Split('\t');
var hashed = hashService.GetHash(data[1]);
logWriter.WriteLine(fileContent + '\t' + hashed);
}
}
}
}
public async Task ThrowIfNotValidAsync(HashOptions item)
{
var validationContext = await _validator.ValidateAsync(item);
if (!validationContext.IsValid)
{
throw new ValidationException(validationContext.Errors.AsString());
}
}
private static Argon2id GetArgon2id(byte[] passphrase, byte[] salt, HashOptions options = null)
{
return(new Argon2id(passphrase)
{
DegreeOfParallelism = options?.DoP ?? Constants.Argon.DoP,
MemorySize = options?.MemorySize ?? Constants.Argon.MemorySize,
Salt = salt,
Iterations = options?.Iterations ?? Constants.Argon.Iterations
});
}
public async Task <string> Authentication(string email, string senha)
{
const string methodName = nameof(Authentication);
string header = $"METHOD | {email} | {serviceName}: {methodName}";
try
{
logger.LogInformation((int)LogEventEnum.Events.GetItem,
$"{header} - {MessageLog.Getting.Value}");
Revendedor revendedor = await context.Revendedores.SingleOrDefaultAsync(item => item.Email.Equals(email));
if (revendedor is null)
{
logger.LogWarning((int)LogEventEnum.Events.GetItem,
$"{header} - {MessageError.NotFoundSingle.Value}");
return(string.Empty);
}
if (!HashOptions.VerifyPasswordHash(senha, revendedor.Senha))
{
logger.LogWarning((int)LogEventEnum.Events.GetItem,
$"{header} - {MessageError.NotFoundSingle.Value}");
return(string.Empty);
}
List <Claim> claims = new List <Claim>();
claims.Add(new Claim(ClaimTypes.Name, revendedor.Email));
claims.Add(new Claim(ClaimTypes.Role, "all"));
JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();
byte[] key = Encoding.ASCII.GetBytes(settingsOptions.Secret);
SecurityTokenDescriptor tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.UtcNow.AddDays(1),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
SecurityToken stringToken = tokenHandler.CreateToken(tokenDescriptor);
logger.LogInformation((int)LogEventEnum.Events.GetItem,
$"{header} - {MessageLog.Getted.Value}");
return(tokenHandler.WriteToken(stringToken));
}
catch (Exception)
{
throw;
}
}
public async Task <Revendedor> Register(Revendedor entity)
{
const string methodName = nameof(Register);
string header = $"METHOD | {entity.Email} | {serviceName}: {methodName}";
try
{
logger.LogInformation((int)LogEventEnum.Events.InsertItem,
$"{header} - {MessageLog.Saving.Value}");
if (string.IsNullOrEmpty(entity.Senha))
{
logger.LogWarning((int)LogEventEnum.Events.GetItemNotFound,
$"{header} - {MessageError.PasswordNullorEmpty.Value}");
throw new Exception(MessageError.PasswordNullorEmpty.Value);
}
entity.Senha = HashOptions.CreatePasswordHash(entity.Senha);
entity.Cpf = entity.Cpf.Replace(".", string.Empty).Replace("-", string.Empty)
.Replace(";", string.Empty).Replace(",", string.Empty).Replace("/", string.Empty);
context.Revendedores.Add(entity);
await context.SaveChangesAsync();
logger.LogInformation((int)LogEventEnum.Events.InsertItem,
$"{header} - {MessageLog.Saved.Value} | ID: {entity.Id}");
string json = JsonConvert.SerializeObject(entity);
await historicoService.Create(new Historico
{
ChaveTabela = entity.Id,
NomeTabela = typeof(Revendedor).Name,
JsonAntes = string.Empty,
JsonDepois = json,
Usuario = entity.Email,
IdTipoHistorico = (int)TipoHistoricoEnum.Action.Register
});
return(entity);
}
catch (Exception)
{
throw;
}
}
private void ConfigureHash(IApplicationBuilder app)
{
_container.RegisterSingleton(() => app.ApplicationServices.GetService <IOptions <HashOptions> >());
var hashOptions = new HashOptions();
Configuration.GetSection(nameof(HashOptions)).Bind(hashOptions);
if (hashOptions.ServiceType == nameof(HashServiceType.ClearText))
{
_container.RegisterSingleton <IHashService, ClearTextService>();
}
else
{
_container.RegisterSingleton <IHashService, HashService>();
}
}
public virtual async Task HashFileAsync(HashOptions opts)
{
await ThrowIfNotValidAsync(opts);
var outputPath = BuildOutputPath(opts);
var tasks = new List <Task>();
var slimCount = opts.ProgramMode == ProgramMode.Sync ? 1 : Environment.ProcessorCount;
using (var sempahore = new SemaphoreSlim(slimCount))
using (var ifs = new FileStream(opts.InputPath, FileMode.Open, FileAccess.Read, FileShare.Read, opts.BlockSize))
using (var ofs = new FileStream(outputPath, FileMode.Create, FileAccess.Write, FileShare.Write, opts.BlockSize))
{
for (var offset = 0; offset < ifs.Length; offset += opts.BlockSize)
{
await sempahore.WaitAsync();
tasks.Add(Task.Run(async() =>
{
try
{
var chunk = await ReadBytesAsync(ifs, opts.BlockSize);
var hash = GetHash(chunk);
await WriteBytesAsync(ofs, hash);
}
finally
{
sempahore.Release();
}
}));
}
await Task.WhenAll(tasks);
ifs.Close();
ofs.Close();
}
}
protected virtual string BuildOutputPath(HashOptions opts)
=> $"{opts.InputPath}.hashes_{opts.HashAlgorithm}";
/// <summary>
/// Create a Hash byte array using Argon2id.
/// </summary>
/// <param name="passphrase"></param>
/// <param name="salt"></param>
/// <param name="size"></param>
public static async Task <byte[]> GetHashKeyAsync(byte[] passphrase, byte[] salt, int size, HashOptions options = null)
{
using var argon2 = GetArgon2id(passphrase, salt);
return(await argon2.GetBytesAsync(size).ConfigureAwait(false));
}
/// <summary>
/// Create a Hash byte array using Argon2id.
/// </summary>
/// <param name="passphrase"></param>
/// <param name="salt"></param>
/// <param name="size"></param>
public static async Task <byte[]> GetHashKeyAsync(string passphrase, string salt, int size, HashOptions options = null)
{
using var argon2 = GetArgon2id(Encoding.UTF8.GetBytes(passphrase), Encoding.UTF8.GetBytes(salt), options);
return(await argon2.GetBytesAsync(size).ConfigureAwait(false));
}
private static ExitCode RunHashOptionsAndReturnExitCode(HashOptions hashOptions)
{
GenericHashResult hashResult = null;
switch (hashOptions.InputType.ToLower())
{
case "string":
{
hashResult = (hashOptions.Algorithm.ToLower()) switch
{
"md5" => new MD5().ComputeHash(hashOptions.InputToComputeHash),
"sha1" => new SHA1().ComputeHash(hashOptions.InputToComputeHash),
"sha256" => new SHA256().ComputeHash(hashOptions.InputToComputeHash),
"sha384" => new SHA384().ComputeHash(hashOptions.InputToComputeHash),
"sha512" => new SHA512().ComputeHash(hashOptions.InputToComputeHash),
"pbkdf2" => new PBKDF2_HMAC_SHA_1().ComputeHash(hashOptions.InputToComputeHash),
"bcrypt" => new Hash.BCrypt().ComputeHash(hashOptions.InputToComputeHash),
_ => new GenericHashResult()
{
Success = false, Message = $"Unknown algorithm \"{hashOptions.Algorithm}\"."
},
};
}
break;
case "file":
{
switch (hashOptions.Algorithm.ToLower())
{
case "md5":
{
using (var progressBar = new ProgressBar())
{
var md5 = new MD5();
md5.OnHashProgress += (percentageDone, message) => { progressBar.Report((double)percentageDone / 100); };
hashResult = md5.ComputeFileHash(hashOptions.InputToComputeHash);
}
}
break;
case "sha1":
{
using (var progressBar = new ProgressBar())
{
var sha1 = new SHA1();
sha1.OnHashProgress += (percentageDone, message) => { progressBar.Report((double)percentageDone / 100); };
hashResult = sha1.ComputeFileHash(hashOptions.InputToComputeHash);
}
}
break;
case "sha256":
{
using (var progressBar = new ProgressBar())
{
var sha256 = new SHA256();
sha256.OnHashProgress += (percentageDone, message) => { progressBar.Report((double)percentageDone / 100); };
hashResult = sha256.ComputeFileHash(hashOptions.InputToComputeHash);
}
}
break;
case "sha384":
{
using (var progressBar = new ProgressBar())
{
var sha384 = new SHA384();
sha384.OnHashProgress += (percentageDone, message) => { progressBar.Report((double)percentageDone / 100); };
hashResult = sha384.ComputeFileHash(hashOptions.InputToComputeHash);
}
}
break;
case "sha512":
{
using (var progressBar = new ProgressBar())
{
var sha512 = new SHA512();
sha512.OnHashProgress += (percentageDone, message) => { progressBar.Report((double)percentageDone / 100); };
hashResult = sha512.ComputeFileHash(hashOptions.InputToComputeHash);
}
}
break;
case "pbkdf2":
case "bcrypt":
hashResult = new GenericHashResult()
{
Success = false, Message = $"Algorithm \"{hashOptions.Algorithm}\" currently not available for file hashing."
};
break;
default:
hashResult = new GenericHashResult()
{
Success = false, Message = $"Unknown algorithm \"{hashOptions.Algorithm}\"."
};
break;
}
}
break;
default:
hashResult = new GenericHashResult()
{
Success = false, Message = $"Unknown input type \"{hashOptions.InputType}\"."
};
break;
}
if (hashResult.Success && !string.IsNullOrWhiteSpace(hashOptions.CompareHash))
{
var hashesMatch = (
hashOptions.Algorithm.ToLower() != "bcrypt" && hashOptions.Algorithm.ToLower() != "pbkdf2"
? (hashResult.HashString).Equals(hashOptions.CompareHash, StringComparison.InvariantCultureIgnoreCase)
: (hashOptions.Algorithm.ToLower() == "bcrypt"
? new Hash.BCrypt().VerifyHash(hashOptions.InputToComputeHash, hashOptions.CompareHash).Success
: new Hash.PBKDF2_HMAC_SHA_1().VerifyHash(hashOptions.InputToComputeHash, hashOptions.CompareHash).Success
)
);
var outputMessage = (
hashesMatch
? $"Computed hash MATCH with given hash: {(hashOptions.Algorithm.ToLower() != "bcrypt" ? hashResult.HashString : hashOptions.CompareHash)}"
: $"Computed hash DOES NOT MATCH with given hash." +
(
hashOptions.Algorithm.ToLower() != "bcrypt"
? $"\nComputed hash: {hashResult.HashString}\nGiven hash: {hashOptions.CompareHash}"
: ""
)
);
Console.WriteLine(outputMessage);
return(hashesMatch ? ExitCode.Sucess : ExitCode.Error);
}
else if (hashResult.Success && string.IsNullOrWhiteSpace(hashOptions.CompareHash))
{
Console.WriteLine(hashResult.HashString);
return(ExitCode.Sucess);
}
else
{
Console.WriteLine(hashResult.Message);
return(ExitCode.Error);
}
}
public HashService(HashOptions hashOptions)
{
_hashOptions = hashOptions ?? throw new ArgumentNullException(nameof(hashOptions));
}
public HashService(IOptions <HashOptions> options)
{
this.options = options.Value;
}
private static ExitCode RunHashOptionsAndReturnExitCode(HashOptions hashOptions)
{
GenericHashResult hashResult = null;
switch (hashOptions.InputType.ToLower())
{
case "string":
{
switch (hashOptions.Algorithm.ToLower())
{
case "md5":
hashResult = new MD5().HashString(hashOptions.InputToBeHashed);
break;
case "sha1":
hashResult = new SHA1().HashString(hashOptions.InputToBeHashed);
break;
case "sha256":
hashResult = new SHA256().HashString(hashOptions.InputToBeHashed);
break;
case "sha384":
hashResult = new SHA384().HashString(hashOptions.InputToBeHashed);
break;
case "sha512":
hashResult = new SHA512().HashString(hashOptions.InputToBeHashed);
break;
case "bcrypt":
hashResult = new Hash.BCrypt().HashString(hashOptions.InputToBeHashed);
break;
default:
hashResult = new GenericHashResult()
{
Success = false, Message = $"Unknown algorithm \"{hashOptions.Algorithm}\"."
};
break;
}
}
break;
case "file":
{
switch (hashOptions.Algorithm.ToLower())
{
case "md5":
hashResult = new MD5().HashFile(hashOptions.InputToBeHashed, hashOptions.Verbose);
break;
case "sha1":
hashResult = new SHA1().HashFile(hashOptions.InputToBeHashed, hashOptions.Verbose);
break;
case "sha256":
hashResult = new SHA256().HashFile(hashOptions.InputToBeHashed, hashOptions.Verbose);
break;
case "sha384":
hashResult = new SHA384().HashFile(hashOptions.InputToBeHashed, hashOptions.Verbose);
break;
case "sha512":
hashResult = new SHA512().HashFile(hashOptions.InputToBeHashed, hashOptions.Verbose);
break;
case "bcrypt":
hashResult = new GenericHashResult()
{
Success = false, Message = $"Algorithm \"{hashOptions.Algorithm}\" currently not available for file hashing."
};
break;
default:
hashResult = new GenericHashResult()
{
Success = false, Message = $"Unknown algorithm \"{hashOptions.Algorithm}\"."
};
break;
}
}
break;
default:
hashResult = new GenericHashResult()
{
Success = false, Message = $"Unknown input type \"{hashOptions.InputType}\"."
};
break;
}
if (hashResult.Success && !string.IsNullOrWhiteSpace(hashOptions.CompareHash))
{
bool hashesMatch = (
hashOptions.Algorithm.ToLower() != "bcrypt"
? (hashResult.Hash).Equals(hashOptions.CompareHash, StringComparison.InvariantCultureIgnoreCase)
: new Hash.BCrypt().Verify(hashOptions.InputToBeHashed, hashOptions.CompareHash).Success
);
var outputMessage = (
hashesMatch
? $"Computed hash MATCH with given hash: {(hashOptions.Algorithm.ToLower() != "bcrypt" ? hashResult.Hash : hashOptions.CompareHash)}"
: $"Computed hash DOES NOT MATCH with given hash." +
(
hashOptions.Algorithm.ToLower() != "bcrypt"
? $"\nComputed hash: {hashResult.Hash}\nGiven hash: {hashOptions.CompareHash}"
: ""
)
);
Console.WriteLine(outputMessage);
return(hashesMatch ? ExitCode.Sucess : ExitCode.Error);
}
else if (hashResult.Success && string.IsNullOrWhiteSpace(hashOptions.CompareHash))
{
Console.WriteLine(hashResult.Hash);
return(ExitCode.Sucess);
}
else
{
Console.WriteLine(hashResult.Message);
return(ExitCode.Error);
}
}
private static void Hash(HashOptions obj)
{
using var fileStream = new FileStream(obj.Source, FileMode.Open);
Console.WriteLine(Hashing.ToString(xxHash64.ComputeHash(fileStream)));
}
