public static string Compute(HashType type, bool format, string data, string salt)
{
HashAlgorithm hash;
string prefix;
switch (type)
{
case HashType.MD5:
prefix = "MD5";
hash = new MD5Cng();
break;
case HashType.SHA1:
prefix = "SHA1";
hash = new SHA1Cng();
break;
case HashType.SHA256:
prefix = "SHA256";
hash = new SHA256Cng();
break;
case HashType.SHA384:
prefix = "SHA384";
hash = new SHA384Cng();
break;
case HashType.SHA512:
prefix = "SHA512";
hash = new SHA512Cng();
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
byte[] inputBytes = System.Text.Encoding.UTF8.GetBytes(salt+data);
byte[] hashed = hash.ComputeHash(inputBytes);
return format ? $"{{{prefix}:{GetHashHex(hashed)}}}" : GetHashHex(hashed);
}
public byte[] Hash(string plainText, byte[] salt)
{
var hashFunc = new SHA512Cng();
var plainBytes = System.Text.Encoding.ASCII.GetBytes(plainText);
var toHash = new byte[plainBytes.Length + salt.Length];
plainBytes.CopyTo(toHash, 0);
salt.CopyTo(toHash, plainBytes.Length);
return hashFunc.ComputeHash(toHash);
}
internal static byte[] hash(string plaintext, byte[] salt)
{
SHA512Cng hashFunc = new SHA512Cng();
byte[] plainBytes = System.Text.Encoding.ASCII.GetBytes(plaintext);
byte[] toHash = new byte[plainBytes.Length + salt.Length];
plainBytes.CopyTo(toHash, 0);
salt.CopyTo(toHash, plainBytes.Length);
return hashFunc.ComputeHash(toHash);
}
private async Task <string> HashToken(string token)
{
byte[] byteArray = Convert.FromBase64String(token);
System.Security.Cryptography.SHA512Cng hasher = new System.Security.Cryptography.SHA512Cng();
hasher.ComputeHash(byteArray);
var output = Convert.ToBase64String(hasher.Hash);
var size = output.Length;
return(output);
}
private static HashAlgorithm Sha512Hash( )
{
SHA512 hash;
try
{
hash = new SHA512Cng( );
}
catch ( PlatformNotSupportedException )
{
hash = SHA512.Create( );
}
return hash;
}
public string ComputeHashUsingGivenSalt(string plain, string salt)
{
byte[] saltBytes = Convert.FromBase64String(salt);
byte[] passwordBytes = System.Text.UnicodeEncoding.Unicode.GetBytes(plain);
byte[] combinedBytes = new byte[passwordBytes.Length + saltBytes.Length];
//Array src , int srcOffset, Array dst, int dstOffset, int count
System.Buffer.BlockCopy(passwordBytes, 0, combinedBytes, 0, passwordBytes.Length);
System.Buffer.BlockCopy(saltBytes, 0, combinedBytes, passwordBytes.Length, saltBytes.Length);
HashAlgorithm hashAlgo = new SHA512Cng();
byte[] hashBytes = hashAlgo.ComputeHash(combinedBytes);
return Convert.ToBase64String(hashBytes);
}
/// <summary>
/// Compute UDF from binary data and content type with specified precision.
/// </summary>
/// <param name="ContentType">MIME media type. See
/// http://www.iana.org/assignments/media-types/media-types.xhtml for list.</param>
/// <param name="Data">Data to be fingerprinted.</param>
/// <param name="Bits">Precision, must be a multiple of 25 bits.</param>
/// <returns>The binary UDF fingerprint.</returns>
public static byte[] From(string ContentType, byte[] Data, int Bits) {
SHA512 SHA512 = new SHA512Cng();
byte[] HashData = SHA512.ComputeHash(Data);
SHA512.Initialize();
var Tag = Encoding.UTF8.GetBytes(ContentType);
byte[] Input = new byte[HashData.Length + Tag.Length + 1];
int i = 0;
foreach (var Byte in Tag) {
Input[i++] = Byte;
}
Input[i++] = (byte)':';
foreach (var Byte in HashData) {
Input[i++] = Byte;
}
SHA512.Initialize();
byte[] UDFData = SHA512.ComputeHash(Input);
var TotalBits = Bits;
var FullBytes = TotalBits / 8;
var ExtraBits = TotalBits % 8;
var TotalBytes = ExtraBits == 0 ? FullBytes : FullBytes + 1;
byte[] Output = new byte[TotalBytes];
Output[0] = (byte)UDFConstants.KeyIdentifierAlgSHA_2_512;
for (var j = 0; j < FullBytes - 1; j++) {
Output[j + 1] = UDFData[j];
}
if (ExtraBits > 0) {
Output[TotalBytes - 1] = (byte)(UDFData[FullBytes - 1] << (8 - ExtraBits) & 0xff);
}
return Output;
}
protected override void SetUp ()
{
hash = new SHA512Cng ();
}
/// <summary>
/// Genera un hash basado en SHA512 de largo definido a partir del contenido de una imagen.
/// Lo devuelve como un array de bits.
/// </summary>
/// <param name="image">Imagen fuente</param>
/// <param name="size">Largo en bits del hash</param>
public static BitArray GenerateBitHashFromImage(Image image, int size)
{
//Hash de salida (Vector del tamaño deseado inicializado en 0)
int sizeInBytes = (int) Math.Ceiling(size / 8f);
byte[] hash = Enumerable.Repeat((byte) 0x00, sizeInBytes).ToArray();
//Extrae el byteArray de la imagen
byte[] imageBytes = ByteArrayFromImage(image);
//Genera un hash de 192 bytes a base de aplicar el SHA512
byte[] SHAComposedHash = new byte[192];
using (var sha512 = new SHA512Cng())
{
//Hash de los bytes de la imagen
Buffer.BlockCopy(sha512.ComputeHash(imageBytes), 0, SHAComposedHash, 0, 64);
//Hash de los bytes invertidos de la imagen
byte[] notImageBytes = new byte[imageBytes.Length];
for (int i = 0; i < imageBytes.Length; i++)
notImageBytes[i] = (byte)~imageBytes[i];
Buffer.BlockCopy(sha512.ComputeHash(notImageBytes), 0, SHAComposedHash, 64, 64);
//Hash de los bytes del mismo hash
byte[] currentHash = new byte[128];
Buffer.BlockCopy(SHAComposedHash, 0, currentHash, 0, 128);
Buffer.BlockCopy(sha512.ComputeHash(currentHash), 0, SHAComposedHash, 128, 64);
}
//Completa en unidades de bytes el largo faltante
int iterations = 0;
while (sizeInBytes > iterations * 192)
{
int toCopy = sizeInBytes - iterations * 192;
Buffer.BlockCopy(SHAComposedHash, 0, hash, iterations++ * 192, Math.Min(192, toCopy));
}
//Recorta los bits sobrantes
BitArray allBits = new BitArray(hash);
BitArray finalBits = new BitArray(size);
for (int i = 0; i < size; i++)
{
finalBits.Set(i, allBits.Get(i));
}
return finalBits;
}
/// <summary>
/// Очистка конфиденциальных данных
/// </summary>
public void Clear()
{
// Указываем на деинициализацию
IsInitialized = false;
// Чистим массивы...
CryforceUtilities.ClearArray(_key);
CryforceUtilities.ClearArray(_IV);
// Чистим криптографические сущности...
if(_hash256 != null) _hash256.Clear();
if(_hash512 != null) _hash512.Clear();
if(_rijndael != null) _rijndael.Clear();
// Инициализируем криптографические сущности...
_hash256 = new SHA256Cng();
_hash512 = new SHA512Cng();
_rijndael = new RijndaelManaged();
}
/// <summary>
/// Очистка конфиденциальных данных
/// </summary>
public void Clear()
{
// Указываем на деинициализацию
IsInitialized = false;
if(_ECDiffieHellmanCng != null)
{
_ECDiffieHellmanCng.Clear();
}
_ECDiffieHellmanCng = new ECDiffieHellmanCng();
if(_ECDsaCng != null)
{
_ECDsaCng.Clear();
}
_ECDsaCng = new ECDsaCng();
if(_hash512 != null)
{
_hash512.Clear();
}
_hash512 = new SHA512Cng();
CryforceUtilities.ClearArray(Key512);
}
public override void SetUp ()
{
hash = new SHA512Cng ();
}
/// <summary>
/// Computes the SHA512 Salted Hash of a password.
/// </summary>
/// <param name="password">The password to hash.</param>
/// <param name="salt">The salt.</param>
/// <returns>A SHA512 hash of the password.</returns>
public byte[] ComputeHash_ShaSalt(string password, byte[] salt)
{
var sha = new SHA512Cng();
var concatStr = _stringHandler.GetBytes(String.Concat(password, salt));
return sha.ComputeHash(concatStr);
}
