internal static SHA512 CreateSHA512()
{
return(SHA512.Create());
}
public static string GetSHA512FileSystemSafeHash(this string input) => GetFileSystemSafeHash(input, SHA512.Create());
public void TestHMAC(byte[] k, byte[] d)
{
Assert.Equal(new HMACMD5(k).ComputeHash(d).AsEnumerable(), new GenericHMAC <MD5>(MD5.Create(), 64, k).ComputeHash(d));
Assert.Equal(new HMACSHA1(k).ComputeHash(d).AsEnumerable(), new GenericHMAC <SHA1>(SHA1.Create(), 64, k).ComputeHash(d));
Assert.Equal(new HMACSHA256(k).ComputeHash(d).AsEnumerable(), new GenericHMAC <SHA256>(SHA256.Create(), 64, k).ComputeHash(d));
Assert.Equal(new HMACSHA512(k).ComputeHash(d).AsEnumerable(), new GenericHMAC <SHA512>(SHA512.Create(), 128, k).ComputeHash(d));
}
public HashService()
{
hasher = SHA512.Create();
}
public static string GetSHA512Hash(this string input) => GetHash(input, SHA512.Create());
public static void Main(string[] args)
{
DateTime startTime = DateTime.Now;
Console.WriteLine("Findup.exe v2.0 - By James Gentile - [email protected] - 2012.");
Console.WriteLine("Findup.exe matches sizes, then SHA512 hashes to identify duplicate files.");
Console.WriteLine(" ");
string optionskey = "-paths";
List <FileInfo> files = new List <FileInfo>();
int i = 0;
for (i = 0; i < args.Length; i++)
{
string argitem = args[i].ToLower();
if ((System.String.Compare(argitem, "-help", true) == 0) || (System.String.Compare(argitem, "-h", true) == 0))
{
Console.WriteLine("Usage: findup.exe <file/directory #1..#N> [-recurse] [-noerr] [-x/-i/-xd/-id/-xf/-if] <files/directories/regex> [-regex] [-delete]");
Console.WriteLine(" ");
Console.WriteLine("Options: -help - displays this help message.");
Console.WriteLine(" -recurse - recurses through subdirectories when directories or file specifications (e.g. *.txt) are specified.");
Console.WriteLine(" -noerr - discards error messages.");
Console.WriteLine(" -delete - delete each duplicate file with confirmation.");
Console.WriteLine(" -x - eXcludes if full file path starts with (or RegEx matches if -xr) one of the items following this switch until another switch is used.");
Console.WriteLine(" -i - include if full file path starts with (or Regex matches if -ir) one of the items following this switch until another switch is used.");
Console.WriteLine(" -xd - eXcludes all directories (using RegEx if -xdr) including subdirs following this switch until another switch is used.");
Console.WriteLine(" -id - Include only directories (using RegEx if -idr) including subdirs following this switch until another switch is used.");
Console.WriteLine(" -xf - eXcludes all files (using RegEx if -xfr) following this switch until another switch is used.");
Console.WriteLine(" -if - Include only files (using RegEx if -ifr) following this switch until another switch is used.");
Console.WriteLine(" [r] - Use regex for include/exclude by appending an 'r' to the option, e.g. -ir, -ifr, -idr, -xr, -xfr, -xdr.");
Console.WriteLine(" -paths - not needed unless you want to specify files/dirs after an include/exclude without using another non-exclude/non-include option.");
Console.WriteLine(" ");
Console.WriteLine("Examples: findup.exe c:\\finances -recurse -noerr");
Console.WriteLine(" - Find dupes in c:\\finance.");
Console.WriteLine(" - recurse all subdirs of c:\\finance.");
Console.WriteLine(" - suppress error messages.");
Console.WriteLine(" findup.exe c:\\users\\alice\\plan.txt d:\\data -recurse -x d:\\data\\webpics");
Console.WriteLine(" - Find dupes in c:\\users\\alice\\plan.txt, d:\\data");
Console.WriteLine(" - recurse subdirs in d:\\data.");
Console.WriteLine(" - exclude any files in d:\\data\\webpics and subdirs.");
Console.WriteLine(" findup.exe c:\\data *.txt c:\\reports\\quarter.doc -xr \"(jim)\" -regex");
Console.WriteLine(" - Find dupes in c:\\data, *.txt in current directory and c:\\reports\\quarter.doc");
Console.WriteLine(" - exclude any file with 'jim' in the name as specified by the Regex item \"(jim)\"");
Console.WriteLine(" findup.exe c:\\data *.txt c:\\reports\\*quarter.doc -xr \"[bf]\" -ir \"(smith)\" -regex");
Console.WriteLine(" - Find dupes in c:\\data, *.txt in current directory and c:\\reports\\*quarter.doc");
Console.WriteLine(" - Include only files with 'smith' and exclude any file with letters b or f in the name as specified by the Regex items \"[bf]\",\"(smith)\"");
Console.WriteLine("Note: Exclude takes precedence over Include.");
Console.WriteLine(" -xdr,-idr,-xfr,-ifr are useful if for instance you want to apply a RegEx to only file names but not directory names or vice versa.");
Console.WriteLine(" if for instance you wanted all files that contained the letter \"d\" on your D: drive but didn't want the d:\\ to cause all files on the d:\\ ");
Console.WriteLine(" drive to be included, you would specify:");
Console.WriteLine(" findup.exe d:\\ -recurse -noerr -regex -ifr \"[d]\" ");
return;
}
if (optionsbools.ContainsKey(argitem))
{
optionsbools[argitem] = true;
optionskey = "-paths";
continue;
}
if (optionspaths.ContainsKey(argitem) || optionsregex.ContainsKey(argitem))
{
optionskey = argitem;
continue;
}
if (optionspaths.ContainsKey(optionskey))
{
optionspaths[optionskey].Add(argitem);
}
else
{
try {
Regex rgx = new Regex(argitem, RegexOptions.Compiled);
optionsregex[optionskey].Add(rgx);
}
catch (Exception e) { WriteErr("Regex compilation failed: " + e.Message); }
}
}
if (optionspaths["-paths"].Count == 0)
{
WriteErr("No files, file specifications, or directories specified. Try findup.exe -help. Assuming current directory.");
optionspaths["-paths"].Add(".");
}
Console.Write("Getting file info and sorting file list...");
getFiles(optionspaths["-paths"], "*.*", optionsbools["-recurse"], files);
if (files.Count < 2)
{
WriteErr("\nFindup.exe needs at least 2 files to compare. Try findup.exe -help");
return;
}
files.Sort(new FileLengthComparer());
Console.WriteLine("Completed!");
Console.Write("Building dictionary of file sizes, SHA512 hashes and full paths...");
var SizeHashName = new Dictionary <long, Dictionary <string, List <FileInfo> > >();
for (i = 0; i < (files.Count - 1); i++)
{
if (files[i].Length != files[i + 1].Length)
{
continue;
}
var breakout = false;
while (true)
{
try
{
var _SHA512 = SHA512.Create();
using (var fstream = File.OpenRead(files[i].FullName))
{
_SHA512.ComputeHash(fstream);
}
string SHA512string = "";
foreach (var c in _SHA512.Hash)
{
SHA512string += String.Format("{0:x2}", c);
}
if (!SizeHashName.ContainsKey(files[i].Length))
{
SizeHashName.Add(files[i].Length, new Dictionary <string, List <FileInfo> >());
}
if (!SizeHashName[files[i].Length].ContainsKey(SHA512string))
{
SizeHashName[files[i].Length][SHA512string] = new List <FileInfo>()
{
}
}
;
SizeHashName[files[i].Length][SHA512string].Add(files[i]);
}
catch (Exception e) { WriteErr("Hash error: " + e.Message); }
if (breakout == true)
{
break;
}
i++;
if (i == (files.Count - 1))
{
breakout = true; continue;
}
breakout = (files[i].Length != files[i + 1].Length);
}
}
Console.WriteLine("Completed!");
foreach (var SizeGroup in SizeHashName)
{
foreach (var HashGroup in SizeGroup.Value)
{
var SGK = (long)SizeGroup.Key;
var HGVC = (long)HashGroup.Value.Count;
if (HGVC > 1)
{
Console.WriteLine("{0:N0} Duplicate files. {1:N0} Bytes each. {2:N0} Bytes total : ", HGVC, SGK, SGK * HGVC);
foreach (var Filenfo in HashGroup.Value)
{
Console.WriteLine(Filenfo.FullName);
numOfDupes++;
dupeBytes += Filenfo.Length;
if (optionsbools["-delete"])
{
if (DeleteDupe(Filenfo))
{
bytesrecovered += Filenfo.Length;
}
}
}
}
}
}
Console.WriteLine("\n ");
Console.WriteLine("Files checked : {0:N0}", files.Count); // display statistics and return to OS.
Console.WriteLine("Duplicate files : {0:N0}", numOfDupes);
Console.WriteLine("Duplicate bytes : {0:N0}", dupeBytes);
Console.WriteLine("Deleted duplicates : {0:N0}", deletedfiles);
Console.WriteLine("Bytes recovered : {0:N0}", bytesrecovered);
Console.WriteLine("Execution time : " + (DateTime.Now - startTime));
}
/*------------------------ FIELDS REGION ------------------------*/
/*------------------------ METHODS REGION ------------------------*/
public string ComputeHashFromStringToString(string valueToHash)
{
return(Encoding.UTF8.GetString(
SHA512.Create().ComputeHash(Encoding.UTF8.GetBytes(valueToHash))
));
}
public Criptografia()
{
_algoritmo = SHA512.Create();
}
public void SignVerify_InteroperableSameKeys_RoundTripsUnlessTampered(ECDsa ecdsa, HashAlgorithmName hashAlgorithm)
{
byte[] data = Encoding.UTF8.GetBytes("something to repeat and sign");
// large enough to make hashing work though multiple iterations and not a multiple of 4KB it uses.
byte[] dataArray = new byte[33333];
MemoryStream dataStream = new MemoryStream(dataArray, true);
while (dataStream.Position < dataArray.Length - data.Length)
{
dataStream.Write(data, 0, data.Length);
}
dataStream.Position = 0;
byte[] dataArray2 = new byte[dataArray.Length + 2];
dataArray.CopyTo(dataArray2, 1);
ArraySegment <byte> dataSpan = new ArraySegment <byte>(dataArray2, 1, dataArray.Length);
HashAlgorithm halg;
if (hashAlgorithm == HashAlgorithmName.MD5)
{
halg = MD5.Create();
}
else if (hashAlgorithm == HashAlgorithmName.SHA1)
{
halg = SHA1.Create();
}
else if (hashAlgorithm == HashAlgorithmName.SHA256)
{
halg = SHA256.Create();
}
else if (hashAlgorithm == HashAlgorithmName.SHA384)
{
halg = SHA384.Create();
}
else if (hashAlgorithm == HashAlgorithmName.SHA512)
{
halg = SHA512.Create();
}
else
{
throw new Exception("Hash algorithm not supported.");
}
List <byte[]> signatures = new List <byte[]>(6);
// Compute a signature using each of the SignData overloads. Then, verify it using each
// of the VerifyData overloads, and VerifyHash overloads.
//
// Then, verify that VerifyHash fails if the data is tampered with.
signatures.Add(ecdsa.SignData(dataArray, hashAlgorithm));
signatures.Add(ecdsa.SignData(dataSpan.Array, dataSpan.Offset, dataSpan.Count, hashAlgorithm));
signatures.Add(ecdsa.SignData(dataStream, hashAlgorithm));
dataStream.Position = 0;
signatures.Add(ecdsa.SignHash(halg.ComputeHash(dataArray)));
signatures.Add(ecdsa.SignHash(halg.ComputeHash(dataSpan.Array, dataSpan.Offset, dataSpan.Count)));
signatures.Add(ecdsa.SignHash(halg.ComputeHash(dataStream)));
dataStream.Position = 0;
foreach (byte[] signature in signatures)
{
Assert.True(ecdsa.VerifyData(dataArray, signature, hashAlgorithm), "Verify 1");
Assert.True(ecdsa.VerifyData(dataSpan.Array, dataSpan.Offset, dataSpan.Count, signature, hashAlgorithm), "Verify 2");
Assert.True(ecdsa.VerifyData(dataStream, signature, hashAlgorithm), "Verify 3");
Assert.True(dataStream.Position == dataArray.Length, "Check stream read 3A");
dataStream.Position = 0;
Assert.True(ecdsa.VerifyHash(halg.ComputeHash(dataArray), signature), "Verify 4");
Assert.True(ecdsa.VerifyHash(halg.ComputeHash(dataSpan.Array, dataSpan.Offset, dataSpan.Count), signature), "Verify 5");
Assert.True(ecdsa.VerifyHash(halg.ComputeHash(dataStream), signature), "Verify 6");
Assert.True(dataStream.Position == dataArray.Length, "Check stream read 6A");
dataStream.Position = 0;
}
int distinctSignatures = signatures.Distinct(new ByteArrayComparer()).Count();
Assert.True(distinctSignatures == signatures.Count, "Signing should be randomized");
foreach (byte[] signature in signatures)
{
signature[signature.Length - 1] ^= 0xFF; // flip some bits
Assert.False(ecdsa.VerifyData(dataArray, signature, hashAlgorithm), "Verify Tampered 1");
Assert.False(ecdsa.VerifyData(dataSpan.Array, dataSpan.Offset, dataSpan.Count, signature, hashAlgorithm), "Verify Tampered 2");
Assert.False(ecdsa.VerifyData(dataStream, signature, hashAlgorithm), "Verify Tampered 3");
Assert.True(dataStream.Position == dataArray.Length, "Check stream read 3B");
dataStream.Position = 0;
Assert.False(ecdsa.VerifyHash(halg.ComputeHash(dataArray), signature), "Verify Tampered 4");
Assert.False(ecdsa.VerifyHash(halg.ComputeHash(dataSpan.Array, dataSpan.Offset, dataSpan.Count), signature), "Verify Tampered 5");
Assert.False(ecdsa.VerifyHash(halg.ComputeHash(dataStream), signature), "Verify Tampered 6");
Assert.True(dataStream.Position == dataArray.Length, "Check stream read 6B");
dataStream.Position = 0;
}
}
/// <summary>
/// Computes the SHA-512 hash of the given string using UTF8 byte encoding.
/// </summary>
/// <param name="value">The input string.</param>
/// <param name="createHasher">if set to <c>true</c> [create hasher].</param>
/// <returns>
/// The computes a Hash-based Message Authentication Code (HMAC)
/// using the SHA512 hash function.
/// </returns>
public static byte[] ComputeSha512(string value, bool createHasher = false)
{
var inputBytes = Encoding.UTF8.GetBytes(value);
return((createHasher ? SHA512.Create() : SHA512Hasher.Value).ComputeHash(inputBytes));
}
public static byte[] GetCheckSum(byte[] file)
{
var sha = SHA512.Create();
return(sha.ComputeHash(file));
}
/// <summary>
/// Initialise the CPRNG with the given key material, and default cypher (AES 256) and hash algorithm (SHA512), zero counter and supplied additional entropy source.
/// </summary>
public CypherBasedPrngGenerator(byte[] key, Func <byte[]> additionalEntropyGetter)
: this(key, BlockCypherCryptoPrimitive.Aes256(), SHA512.Create(), new CypherCounter(16), 1024, additionalEntropyGetter)
{
}
/// <summary>
/// Initialise the CPRNG with the given key material, and default cypher (AES 256) and hash algorithm (SHA512), and zero counter.
/// </summary>
public CypherBasedPrngGenerator(byte[] key)
: this(key, BlockCypherCryptoPrimitive.Aes256(), SHA512.Create(), new CypherCounter(16), 1024, null)
{
}
public static RootCommand WireUpSha512Commands(this RootCommand rootCommand)
{
var sha512Command = new Command("sha512", "SHA512");
var sha512HashCommand = new Command("hash", "Hash");
sha512HashCommand.AddOption(new Option(new string[] { "--text", "-t" }, "Input Text")
{
Argument = new Argument <string>("text")
});
sha512HashCommand.AddOption(new Option(new string[] { "--input", "-i" }, "Input file path")
{
Argument = new Argument <FileInfo>("input")
});
sha512HashCommand.AddOption(new Option(new string[] { "--output", "-o" }, "Output file path")
{
Argument = new Argument <FileInfo>("output")
});
sha512HashCommand.Handler = CommandHandler.Create <string, FileInfo, FileInfo, IConsole>(async(text, input, output, console) =>
{
Stream outputStream = null;
Stream inputStream = null;
try
{
if (output == null)
{
outputStream = new MemoryStream();
}
else
{
outputStream = output.OpenWrite();
}
if (text != null)
{
inputStream = new MemoryStream(Encoding.UTF8.GetBytes(text));
}
if (input != null)
{
inputStream = input.OpenRead();
}
using var sha512 = SHA512.Create();
var hashBytes = sha512.ComputeHash(inputStream);
if (output == null)
{
console.Out.WriteLine(hashBytes.ToHexString());
}
else
{
await outputStream.WriteAsync(hashBytes);
}
}
catch (Exception ex)
{
console.Out.WriteLine(ex.Message);
}
finally
{
if (inputStream != null)
{
await inputStream.DisposeAsync();
}
if (outputStream != null)
{
await outputStream.DisposeAsync();
}
}
});
sha512Command.Add(sha512HashCommand);
rootCommand.AddCommand(sha512Command);
return(rootCommand);
}
/// <summary>
/// 验证 SHA512 值
/// </summary>
/// <param name="input"> 未加密的字符串 </param>
/// <param name="encoding"> 字符编码 </param>
/// <returns></returns>
public static bool VerifySha512Value(string input, Encoding encoding)
{
return(VerifyHashValue(SHA512.Create(), input, Sha512Encrypt(input, encoding), encoding));
}
/// <summary>
/// SHA512 加密
/// </summary>
/// <param name="input"> 要加密的字符串 </param>
/// <param name="encoding"> 字符编码 </param>
/// <returns></returns>
public static string Sha512Encrypt(string input, Encoding encoding)
{
return(HashEncrypt(SHA512.Create(), input, encoding));
}
