static byte[] Compute_NTLMv2(Type2Message type2, string username, string password) { var ntlm_hash = Compute_NTLM_Password(password); var ubytes = Encoding.Unicode.GetBytes(username.ToUpperInvariant()); var tbytes = Encoding.Unicode.GetBytes(type2.TargetName.ToUpperInvariant()); var bytes = new byte [ubytes.Length + tbytes.Length]; ubytes.CopyTo(bytes, 0); Array.Copy(tbytes, 0, bytes, ubytes.Length, tbytes.Length); var md5 = new HMACMD5(ntlm_hash); var ntlm_v2_hash = md5.ComputeHash(bytes); Array.Clear(ntlm_hash, 0, ntlm_hash.Length); md5.Clear(); var ntlm_v2_md5 = new HMACMD5(ntlm_v2_hash); var now = DateTime.Now; var timestamp = now.Ticks - 504911232000000000; var nonce = new byte [8]; var rng = RandomNumberGenerator.Create(); rng.GetBytes(nonce); byte[] blob = new byte [28 + type2.TargetInfo.Length]; blob[0] = 0x01; blob[1] = 0x01; Buffer.BlockCopy(BitConverterLE.GetBytes(timestamp), 0, blob, 8, 8); Buffer.BlockCopy(nonce, 0, blob, 16, 8); Buffer.BlockCopy(type2.TargetInfo, 0, blob, 28, type2.TargetInfo.Length); var challenge = type2.Nonce; var hashInput = new byte [challenge.Length + blob.Length]; challenge.CopyTo(hashInput, 0); blob.CopyTo(hashInput, challenge.Length); var blobHash = ntlm_v2_md5.ComputeHash(hashInput); var response = new byte [blob.Length + blobHash.Length]; blobHash.CopyTo(response, 0); blob.CopyTo(response, blobHash.Length); Array.Clear(ntlm_v2_hash, 0, ntlm_v2_hash.Length); ntlm_v2_md5.Clear(); Array.Clear(nonce, 0, nonce.Length); Array.Clear(blob, 0, blob.Length); Array.Clear(hashInput, 0, hashInput.Length); Array.Clear(blobHash, 0, blobHash.Length); return(response); }
/// <summary> /// Computes the hash. /// </summary> /// <param name="version">The version.</param> /// <param name="header">The header.</param> /// <param name="parameters">The parameters.</param> /// <param name="data">The scope data.</param> /// <param name="privacy">The privacy provider.</param> /// <param name="length">The length bytes.</param> /// <returns></returns> public OctetString ComputeHash(VersionCode version, ISegment header, SecurityParameters parameters, ISnmpData data, IPrivacyProvider privacy, byte[] length) { if (header == null) { throw new ArgumentNullException(nameof(header)); } if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } if (data == null) { throw new ArgumentNullException(nameof(data)); } if (privacy == null) { throw new ArgumentNullException(nameof(privacy)); } var key = PasswordToKey(_password, parameters.EngineId.GetRaw()); using (var md5 = new HMACMD5(key)) { var hash = md5.ComputeHash(ByteTool.PackMessage(length, version, header, parameters, data).ToBytes()); #if NET452 md5.Clear(); #endif var result = new byte[DigestLength]; Buffer.BlockCopy(hash, 0, result, 0, result.Length); return(new OctetString(result)); } }
/// <summary> /// Computes the hash. /// </summary> /// <param name="version">The version.</param> /// <param name="header">The header.</param> /// <param name="parameters">The parameters.</param> /// <param name="data">The scope data.</param> /// <param name="privacy">The privacy provider.</param> /// <returns></returns> public OctetString ComputeHash(VersionCode version, ISegment header, SecurityParameters parameters, ISnmpData data, IPrivacyProvider privacy) { if (header == null) { throw new ArgumentNullException("header"); } if (parameters == null) { throw new ArgumentNullException("parameters"); } if (data == null) { throw new ArgumentNullException("data"); } if (privacy == null) { throw new ArgumentNullException("privacy"); } byte[] key = PasswordToKey(_password, parameters.EngineId.GetRaw()); using (HMACMD5 md5 = new HMACMD5(key)) { byte[] hash = md5.ComputeHash(SnmpMessageExtension.PackMessage(version, header, parameters, data).ToBytes()); md5.Clear(); byte[] result = new byte[DigestLength]; Buffer.BlockCopy(hash, 0, result, 0, result.Length); return(new OctetString(result)); } }
public static string ComputeHMACHashByAlgorithm(string key, string plainText, string saltText = "", HashAlgorithms algorithm = HashAlgorithms.SHA1, Encoding encoding = null, bool useBase64String = false) { try { if (string.IsNullOrEmpty(plainText)) { return(plainText); } if (string.IsNullOrEmpty(key)) { key = Utility.GenerateRandomPassword(8); } if (encoding == null) { encoding = Encoding.ASCII; } var secretKeyBytes = encoding.GetBytes(key); HashAlgorithm hashProvider = null; switch (algorithm) { default: case HashAlgorithms.SHA1: hashProvider = new HMACSHA1(secretKeyBytes); break; case HashAlgorithms.SHA256: hashProvider = new HMACSHA256(secretKeyBytes); break; case HashAlgorithms.SHA384: hashProvider = new HMACSHA384(secretKeyBytes); break; case HashAlgorithms.SHA512: hashProvider = new HMACSHA512(secretKeyBytes); break; case HashAlgorithms.MD5: hashProvider = new HMACMD5(secretKeyBytes); break; } var dataText = plainText + saltText; var dataBytes = encoding.GetBytes(dataText); var hashedBytes = hashProvider.ComputeHash(dataBytes); hashProvider.Clear(); if (useBase64String) { return(Convert.ToBase64String(hashedBytes)); } return(string.Concat(Array.ConvertAll(hashedBytes, x => x.ToString("x2")))); } catch { return(plainText); } }
public static string HMACMD5(string sourceText, string key) { var keyByte = Encoding.UTF8.GetBytes(key); var sourceBytes = Encoding.UTF8.GetBytes(sourceText); using (var hmacMd5 = new HMACMD5(keyByte)) { var bytes = hmacMd5.ComputeHash(sourceBytes); hmacMd5.Clear(); return(BitConverter.ToString(bytes).Replace("-", "").ToLower()); } }
/// <summary> /// Computes a keyed hash for a source file, creates a target file with the keyed hash /// prepended to the contents of the source file, then decrypts the file and compares /// the source and the decrypted files. /// </summary> /// <param name="key">The key to use to encode the file</param> /// <param name="sourceFile">The file to encrypt complete path</param> /// <param name="destFile">Destination file complete path. If the file doesn't exist, it creates it</param> public void EncodeFile(string key, String sourceFile, String destFile) { if (sourceFile.IsNullOrWhiteSpace() || !File.Exists(sourceFile)) { throw new FileNotFoundException("Cannot find the specified source file", sourceFile ?? "null"); } if (destFile.IsNullOrWhiteSpace()) { throw new ArgumentException("Please specify the path of the output path", nameof(destFile)); } if (string.IsNullOrEmpty(key)) { throw new ArgumentException("Please specify the key", nameof(key)); } // Create a key using a random number generator. This would be the // secret key shared by sender and receiver. byte[] secretkey = key.ToByteArray(); // Initialize the keyed hash object. HMACMD5 myhmacMD5 = new HMACMD5(secretkey); FileStream inStream = new FileStream(sourceFile, FileMode.Open); FileStream outStream = new FileStream(destFile, FileMode.Create); // Compute the hash of the input file. byte[] hashValue = myhmacMD5.ComputeHash(inStream); // Reset inStream to the beginning of the file. inStream.Position = 0; // Write the computed hash value to the output file. outStream.Write(hashValue, 0, hashValue.Length); // Copy the contents of the sourceFile to the destFile. int bytesRead; // read 1K at a time byte[] buffer = new byte[1024]; do { // Read from the wrapping CryptoStream. bytesRead = inStream.Read(buffer, 0, 1024); outStream.Write(buffer, 0, bytesRead); } while (bytesRead > 0); myhmacMD5.Clear(); // Close the streams inStream.Close(); outStream.Close(); } // end EncodeFile
string HmacMD5(string source, string key) { HMACMD5 hmacmd = new HMACMD5(Encoding.Default.GetBytes(key)); byte[] inArray = hmacmd.ComputeHash(Encoding.Default.GetBytes(source)); StringBuilder sb = new StringBuilder(); for (int i = 0; i < inArray.Length; i++) { sb.Append(inArray[i].ToString("X2")); } hmacmd.Clear(); return(sb.ToString().ToLower()); }
/// <summary> /// Computes the hash. /// </summary> /// <param name="version">The version.</param> /// <param name="header">The header.</param> /// <param name="parameters">The parameters.</param> /// <param name="scopeBytes">The scope bytes.</param> /// <param name="privacy">The privacy provider.</param> /// <returns></returns> private OctetString ComputeHash(VersionCode version, ISegment header, SecurityParameters parameters, ISnmpData scopeBytes, IPrivacyProvider privacy) { if (scopeBytes == null) { throw new ArgumentNullException("scopeBytes"); } byte[] key = PasswordToKey(_password, parameters.EngineId.GetRaw()); #if !SILVERLIGHT //mc++ using (HMACMD5 md5 = new HMACMD5(key)) { byte[] hash = md5.ComputeHash(SnmpMessageExtension.PackMessage(version, header, parameters, scopeBytes, privacy).ToBytes()); md5.Clear(); byte[] result = new byte[DigestLength]; Array.Copy(hash, result, result.Length); return(new OctetString(result)); } #endif return(null); }
} //compute hash from arguments and return hash value as string private static string GetHMACMD5Hash(string text) { //create variables for computing hash and making it a string UnicodeEncoding UniCode = new UnicodeEncoding(); byte[] HashResult; byte[] msg = UniCode.GetBytes(text); HMACMD5 hashString = new HMACMD5(); string Str = ""; //compute hash with HMACMD5 module and format output as string //convert bytes in HashResult to string values HashResult = hashString.ComputeHash(msg); foreach (byte x in HashResult) { Str += String.Format("{0:x2}", x); } //clear excess resource usage hashString.Clear(); return(Str); } //compute hash from arguments and return hash value as string
/// <summary> /// Computes the hash. /// </summary> /// <returns></returns> public OctetString ComputeHash(byte[] buffer, OctetString engineId) { if (buffer == null) { throw new ArgumentNullException("buffer"); } if (engineId == null) { throw new ArgumentNullException("engineId"); } var key = PasswordToKey(_password, engineId.GetRaw()); using (var md5 = new HMACMD5(key)) { var hash = md5.ComputeHash(buffer); md5.Clear(); var result = new byte[DigestLength]; Buffer.BlockCopy(hash, 0, result, 0, result.Length); return(new OctetString(result)); } }