public void TestReusability(HashAlgorithm hashAlgorithm) { using (hashAlgorithm) { byte[] input = { 8, 6, 7, 5, 3, 0, 9, }; byte[] hash1 = hashAlgorithm.ComputeHash(input); byte[] hash2 = hashAlgorithm.ComputeHash(input); Assert.Equal(hash1, hash2); } }
static void Test(HashAlgorithm digest) { byte[] result1, result2, result3; if (digest is SHA1) { Console.WriteLine ("Testing results wrt FIPS 180-1 test vectors"); result1 = new byte [] { 0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a, 0xba, 0x3e, 0x25, 0x71, 0x78, 0x50, 0xc2, 0x6c, 0x9c, 0xd0, 0xd8, 0x9d }; result2 = new byte [] { 0x84, 0x98, 0x3e, 0x44, 0x1c, 0x3b, 0xd2, 0x6e, 0xba, 0xae, 0x4a, 0xa1, 0xf9, 0x51, 0x29, 0xe5, 0xe5, 0x46, 0x70, 0xf1 }; result3 = new byte [] { 0x34, 0xaa, 0x97, 0x3c, 0xd4, 0xc4, 0xda, 0xa4, 0xf6, 0x1e, 0xeb, 0x2b, 0xdb, 0xad, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6f }; } else if (digest is SHA256) { Console.WriteLine ("Testing results wrt FIPS 180-2 test vectors"); result1 = new byte [] { 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad }; result2 = new byte [] { 0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8, 0xe5, 0xc0, 0x26, 0x93, 0x0c, 0x3e, 0x60, 0x39, 0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67, 0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1 }; result3 = new byte [] { 0xcd, 0xc7, 0x6e, 0x5c, 0x99, 0x14, 0xfb, 0x92, 0x81, 0xa1, 0xc7, 0xe2, 0x84, 0xd7, 0x3e, 0x67, 0xf1, 0x80, 0x9a, 0x48, 0xa4, 0x97, 0x20, 0x0e, 0x04, 0x6d, 0x39, 0xcc, 0xc7, 0x11, 0x2c, 0xd0 }; } else { Console.WriteLine ("No test vectors were found."); return; } string input1 = "abc"; string input2 = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"; byte[] input = Encoding.Default.GetBytes (input1); byte[] output = digest.ComputeHash (input); Console.WriteLine ("FIPS 180 Test 1: {0}", BitConverter.ToString (result1) != BitConverter.ToString (output) ? "FAIL" : "PASS"); input = Encoding.Default.GetBytes (input2); output = digest.ComputeHash (input); Console.WriteLine ("FIPS 180 Test 2: {0}", BitConverter.ToString (result2) != BitConverter.ToString (output) ? "FAIL" : "PASS"); input = new byte [1000000]; for (int i = 0; i < 1000000; i++) input[i] = 0x61; // a output = digest.ComputeHash (input); Console.WriteLine ("FIPS 180 Test 3: {0}", BitConverter.ToString (result3) != BitConverter.ToString (output) ? "FAIL" : "PASS"); }
private static void VerifyIncrementalResult(HashAlgorithm referenceAlgorithm, IncrementalHash incrementalHash) { byte[] referenceHash = referenceAlgorithm.ComputeHash(s_inputBytes); const int StepA = 13; const int StepB = 7; int position = 0; while (position < s_inputBytes.Length - StepA) { incrementalHash.AppendData(s_inputBytes, position, StepA); position += StepA; } incrementalHash.AppendData(s_inputBytes, position, s_inputBytes.Length - position); byte[] incrementalA = incrementalHash.GetHashAndReset(); Assert.Equal(referenceHash, incrementalA); // Now try again, verifying both immune to step size behaviors, and that GetHashAndReset resets. position = 0; while (position < s_inputBytes.Length - StepB) { incrementalHash.AppendData(s_inputBytes, position, StepA); position += StepA; } incrementalHash.AppendData(s_inputBytes, position, s_inputBytes.Length - position); byte[] incrementalB = incrementalHash.GetHashAndReset(); Assert.Equal(referenceHash, incrementalB); }
/// <summary> /// 从文件流获取Hash描述表 /// </summary> /// <param name="objFile">源文件</param> /// <returns>Hash描述表</returns> public static string GetHashString(this FileStream objFile) { //从文件中取得Hash描述 HashAlgorithm md5 = HashAlgorithm.Create("MD5"); var hashData = md5?.ComputeHash(objFile); return(Convert.ToBase64String(hashData)); }
//获取Hash描述表 /// <summary> /// 获取Hash描述表 /// </summary> /// <param name="mStrSource">源数据</param> /// <returns>Hash描述表</returns> public static byte[] GetHashBytes(this string mStrSource) { //从字符串中取得Hash描述 HashAlgorithm md5 = HashAlgorithm.Create("MD5"); var buffer = Encoding.UTF8.GetBytes(mStrSource); return(md5?.ComputeHash(buffer)); }
//获取Hash描述表 /// <summary> /// 从文件流获取Hash描述表 /// </summary> /// <param name="objFile">源文件</param> /// <returns>Hash描述表</returns> public static byte[] GetHashBytes(this FileStream objFile) { //从文件中取得Hash描述 using (objFile) { HashAlgorithm md5 = HashAlgorithm.Create("MD5"); return(md5?.ComputeHash(objFile)); } }
// prints the hash of a specified input to the console public static void PrintHash(string name, HashAlgorithm algo, byte[] data) { // compute the hash of the input data.. byte[] hash = algo.ComputeHash(data); // ..and write the hash to the console Console.WriteLine(name + BytesToHex(hash)); // dispose of the hash algorithm; we do not need to hash more data with it algo.Clear(); }
//获取Hash描述表 /// <summary> /// 获取Hash描述表 /// </summary> /// <param name="mStrSource">源数据</param> /// <returns>Hash描述表</returns> public static string GetHashString(this string mStrSource) { //从字符串中取得Hash描述 HashAlgorithm md5 = HashAlgorithm.Create("MD5"); var buffer = Encoding.UTF8.GetBytes(mStrSource); var hashData = md5?.ComputeHash(buffer); return(Convert.ToBase64String(hashData)); }
protected static void VerifySignature(AsymmetricSignatureFormatter formatter, AsymmetricSignatureDeformatter deformatter, HashAlgorithm hashAlgorithm, string hashAlgorithmName) { formatter.SetHashAlgorithm(hashAlgorithmName); deformatter.SetHashAlgorithm(hashAlgorithmName); byte[] hash = hashAlgorithm.ComputeHash(HelloBytes); VerifySignatureWithHashBytes(formatter, deformatter, hash); VerifySignatureWithHashAlgorithm(formatter, deformatter, hashAlgorithm); }
public static string GetHash(string input, HashAlgorithm hash) { byte[] data = hash.ComputeHash(Encoding.UTF8.GetBytes(input)); StringBuilder sBuilder = new StringBuilder(); for (int i = 0; i < data.Length; i++) { sBuilder.Append(data[i].ToString("x2")); } return sBuilder.ToString(); }
public ARC4Crypt(HashAlgorithm hash, bool isServer) { Contract.Requires(hash != null); var encKey = isServer ? _serverEncClientDec : _serverDecClientEnc; var decKey = isServer ? _serverDecClientEnc : _serverEncClientDec; _encrypt = new ARC4Managed(); _decrypt = new ARC4Managed(); _encrypt.Key = hash.ComputeHash(encKey); _decrypt.Key = hash.ComputeHash(decKey); var buffer = new byte[DropN]; var length = buffer.Length; // Drop the first N bytes in the stream, to prevent the FMS attack. _encrypt.TransformFinalBlock(buffer, 0, length); _decrypt.TransformFinalBlock(buffer, 0, length); }
private static byte[] GetEmptyHash (HashAlgorithm hash) { if (hash is SHA1) return emptySHA1; else if (hash is SHA256) return emptySHA256; else if (hash is SHA384) return emptySHA384; else if (hash is SHA512) return emptySHA512; else return hash.ComputeHash ((byte[])null); }
public static string ComputeHash(string input, HashAlgorithm algorithm) { byte[] salt = Convert.FromBase64String(DEFAULT_SALT); byte[] inputBytes = Encoding.UTF8.GetBytes(input); // Combine salt and input bytes byte[] saltedInput = new Byte[salt.Length + inputBytes.Length]; salt.CopyTo(saltedInput, 0); inputBytes.CopyTo(saltedInput, salt.Length); byte[] hashedBytes = algorithm.ComputeHash(saltedInput); return Convert.ToBase64String(hashedBytes); }
private static byte[] ComputeHash(this HashAlgorithmEnum hashHashAlgo, byte[] input) { HashAlgorithm hashAlgorithm = null; switch (hashHashAlgo) { case HashAlgorithmEnum.Md5: hashAlgorithm = MD5.Create(); break; case HashAlgorithmEnum.Sha1: hashAlgorithm = SHA1.Create(); break; case HashAlgorithmEnum.Sha2256: hashAlgorithm = SHA256.Create(); break; case HashAlgorithmEnum.Sha2384: hashAlgorithm = SHA384.Create(); break; case HashAlgorithmEnum.Sha2512: hashAlgorithm = SHA512.Create(); break; } return(hashAlgorithm?.ComputeHash(input)); }
/// <summary> /// 各哈希算法下的消息摘要算法 /// </summary> /// <param name="text">原串</param> /// <param name="hash">哈希算法</param> /// <returns></returns> private static string Hash(string text, HashAlgorithm hash) { byte[] vs = hash.ComputeHash(Encoding.UTF8.GetBytes(text)); return(BitConverter.ToString(vs).Replace("-", "")); }
private byte[] ComputeHash(byte[] data) { return(_hasher.ComputeHash(data)); }
public string ComputeHash(string input, HashAlgorithm algorithm) { Byte[] inputBytes = Encoding.UTF8.GetBytes(input); Byte[] hashedBytes = algorithm.ComputeHash(inputBytes); return BitConverter.ToString(hashedBytes); }
private bool CheckSignature(string fileName) { filename = fileName; Open(filename); entry = GetSecurityEntry(); if (entry == null) { // no signature is present reason = 1; Close(); return(false); } PKCS7.ContentInfo ci = new PKCS7.ContentInfo(entry); if (ci.ContentType != PKCS7.Oid.signedData) { Close(); return(false); } PKCS7.SignedData sd = new PKCS7.SignedData(ci.Content); if (sd.ContentInfo.ContentType != spcIndirectDataContext) { Close(); return(false); } coll = sd.Certificates; ASN1 spc = sd.ContentInfo.Content; signedHash = spc [0][1][1]; HashAlgorithm ha = null; switch (signedHash.Length) { case 16: ha = HashAlgorithm.Create("MD5"); hash = GetHash(ha); break; case 20: ha = HashAlgorithm.Create("SHA1"); hash = GetHash(ha); break; default: reason = 5; Close(); return(false); } Close(); if (!signedHash.CompareValue(hash)) { reason = 2; } // messageDigest is a hash of spcIndirectDataContext (which includes the file hash) byte[] spcIDC = spc [0].Value; ha.Initialize(); // re-using hash instance byte[] messageDigest = ha.ComputeHash(spcIDC); bool sign = VerifySignature(sd, messageDigest, ha); return(sign && (reason == 0)); }
/// <summary> /// Decrypts data using the provided RSA key(s) to decrypt an AES key, which decrypts the cookie. /// </summary> /// <param name="encoded">The encoded data</param> /// <returns>The decoded data</returns> /// <exception cref="ArgumentNullException">The argument 'encoded' is null.</exception> /// <exception cref="ArgumentException">The argument 'encoded' contains zero bytes.</exception> /// <exception cref="NotSupportedException">The platform does not support the requested algorithm.</exception> /// <exception cref="InvalidOperationException">There are no decryption keys or none of the keys match.</exception> public override byte[] Decode(byte[] encoded) { if (null == encoded) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("encoded"); } if (0 == encoded.Length) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("encoded", SR.GetString(SR.ID6045)); } ReadOnlyCollection <RSA> decryptionKeys = DecryptionKeys; if (0 == decryptionKeys.Count) { throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID6039)); } byte[] encryptedKeyAndIV; byte[] encryptedData; byte[] rsaHash; RSA rsaDecryptionKey = null; using (HashAlgorithm hash = CryptoHelper.CreateHashAlgorithm(_hashName)) { int hashSizeInBytes = hash.HashSize / 8; using (BinaryReader br = new BinaryReader(new MemoryStream(encoded))) { rsaHash = br.ReadBytes(hashSizeInBytes); int encryptedKeyAndIVSize = br.ReadInt32(); if (encryptedKeyAndIVSize < 0) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(SR.GetString(SR.ID1006, encryptedKeyAndIVSize))); } // // Enforce upper limit on key size to prevent large buffer allocation in br.ReadBytes() // if (encryptedKeyAndIVSize > encoded.Length) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(SR.GetString(SR.ID1007))); } encryptedKeyAndIV = br.ReadBytes(encryptedKeyAndIVSize); int encryptedDataSize = br.ReadInt32(); if (encryptedDataSize < 0) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(SR.GetString(SR.ID1008, encryptedDataSize))); } // // Enforce upper limit on data size to prevent large buffer allocation in br.ReadBytes() // if (encryptedDataSize > encoded.Length) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(SR.GetString(SR.ID1009))); } encryptedData = br.ReadBytes(encryptedDataSize); } // // Find the decryption key matching the one in XML // foreach (RSA key in decryptionKeys) { byte[] hashedKey = hash.ComputeHash(Encoding.UTF8.GetBytes(key.ToXmlString(false))); if (CryptoHelper.IsEqual(hashedKey, rsaHash)) { rsaDecryptionKey = key; break; } } } if (rsaDecryptionKey == null) { throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID6040)); } byte[] decryptedKeyAndIV = CngLightup.OaepSha1Decrypt(rsaDecryptionKey, encryptedKeyAndIV); using (SymmetricAlgorithm symmetricAlgorithm = CryptoHelper.NewDefaultEncryption()) { byte[] decryptionKey = new byte[symmetricAlgorithm.KeySize / 8]; // // Ensure there is sufficient length in the descrypted key and IV buffer for an IV. // if (decryptedKeyAndIV.Length < decryptionKey.Length) { throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID6047, decryptedKeyAndIV.Length, decryptionKey.Length)); } byte[] decryptionIV = new byte[decryptedKeyAndIV.Length - decryptionKey.Length]; // // Copy key into its own buffer. // The remaining bytes are the IV copy those into a buffer as well. // Array.Copy(decryptedKeyAndIV, decryptionKey, decryptionKey.Length); Array.Copy(decryptedKeyAndIV, decryptionKey.Length, decryptionIV, 0, decryptionIV.Length); using (ICryptoTransform decryptor = symmetricAlgorithm.CreateDecryptor(decryptionKey, decryptionIV)) { return(decryptor.TransformFinalBlock(encryptedData, 0, encryptedData.Length)); } } }
private static byte[] GetHash(string inputString) { HashAlgorithm algorithm = SHA256.Create(); return(algorithm.ComputeHash(Encoding.UTF8.GetBytes(inputString))); }
internal override ImmutableArray<byte> ComputeHash(HashAlgorithm algorithm) { try { using (var stream = _resource.DataProvider()) { if (stream == null) { throw new InvalidOperationException(CodeAnalysisResources.ResourceDataProviderShouldReturnNonNullStream); } return ImmutableArray.CreateRange(algorithm.ComputeHash(stream)); } } catch (Exception ex) { throw new ResourceException(_resource.FileName, ex); } }
public static string GetChecksum(string path) { using (FileStream fs = File.OpenRead(path)) return(ChecksumHasher.ComputeHash(fs).ToHexadecimalString()); }
public virtual byte[] GetDigestedOutput(HashAlgorithm hash) { return hash.ComputeHash((Stream) GetOutput(typeof(Stream))); }
private void ProtocolV4(Stream stream, CertificateStore serverCredentials, Certificate[] trustedRootCertificates, ISecureChannelSecurityManager manager, string preSharedKey, SecureChannelCryptoOptionFlags supportedOptions) { #region 1. hello handshake //read client hello SecureChannelPacket.Hello clientHello = (new SecureChannelPacket(stream)).GetHello(); //select crypto option _selectedCryptoOption = supportedOptions & clientHello.CryptoOptions; if (_selectedCryptoOption == SecureChannelCryptoOptionFlags.None) { throw new SecureChannelException(SecureChannelCode.NoMatchingCryptoAvailable, _remotePeerEP, _remotePeerCert); } else if ((_selectedCryptoOption & SecureChannelCryptoOptionFlags.ECDHE256_RSA_WITH_AES256_CBC_HMAC_SHA256) > 0) { _selectedCryptoOption = SecureChannelCryptoOptionFlags.ECDHE256_RSA_WITH_AES256_CBC_HMAC_SHA256; } else if ((_selectedCryptoOption & SecureChannelCryptoOptionFlags.DHE2048_RSA_WITH_AES256_CBC_HMAC_SHA256) > 0) { _selectedCryptoOption = SecureChannelCryptoOptionFlags.DHE2048_RSA_WITH_AES256_CBC_HMAC_SHA256; } else { throw new SecureChannelException(SecureChannelCode.NoMatchingCryptoAvailable, _remotePeerEP, _remotePeerCert); } //send server hello SecureChannelPacket.Hello serverHello = new SecureChannelPacket.Hello(BinaryID.GenerateRandomID256(), _selectedCryptoOption); SecureChannelPacket.WritePacket(stream, serverHello); #endregion #region 2. key exchange SymmetricEncryptionAlgorithm encAlgo; string hashAlgo; KeyAgreement keyAgreement; switch (_selectedCryptoOption) { case SecureChannelCryptoOptionFlags.DHE2048_RSA_WITH_AES256_CBC_HMAC_SHA256: encAlgo = SymmetricEncryptionAlgorithm.Rijndael; hashAlgo = "SHA256"; keyAgreement = new DiffieHellman(DiffieHellmanGroupType.RFC3526, 2048, KeyAgreementKeyDerivationFunction.Hmac, KeyAgreementKeyDerivationHashAlgorithm.SHA256); break; case SecureChannelCryptoOptionFlags.ECDHE256_RSA_WITH_AES256_CBC_HMAC_SHA256: encAlgo = SymmetricEncryptionAlgorithm.Rijndael; hashAlgo = "SHA256"; keyAgreement = new TechnitiumLibrary.Security.Cryptography.ECDiffieHellman(256, KeyAgreementKeyDerivationFunction.Hmac, KeyAgreementKeyDerivationHashAlgorithm.SHA256); break; default: throw new SecureChannelException(SecureChannelCode.NoMatchingCryptoAvailable, _remotePeerEP, _remotePeerCert); } //send server key exchange data SecureChannelPacket.KeyExchange serverKeyExchange = new SecureChannelPacket.KeyExchange(keyAgreement.GetPublicKeyXML(), serverCredentials.PrivateKey, hashAlgo); SecureChannelPacket.WritePacket(stream, serverKeyExchange); //read client key exchange data SecureChannelPacket.KeyExchange clientKeyExchange = (new SecureChannelPacket(stream)).GetKeyExchange(); //generate master key byte[] masterKey = GenerateMasterKey(clientHello, serverHello, _preSharedKey, keyAgreement, clientKeyExchange.PublicKeyXML); //verify master key using HMAC authentication { SecureChannelPacket.Authentication clientAuthentication = (new SecureChannelPacket(stream)).GetAuthentication(); if (!clientAuthentication.IsValid(serverHello, masterKey)) { throw new SecureChannelException(SecureChannelCode.ProtocolAuthenticationFailed, _remotePeerEP, _remotePeerCert); } SecureChannelPacket.Authentication serverAuthentication = new SecureChannelPacket.Authentication(clientHello, masterKey); SecureChannelPacket.WritePacket(stream, serverAuthentication); } //enable channel encryption switch (encAlgo) { case SymmetricEncryptionAlgorithm.Rijndael: //using MD5 for generating AES IV of 128bit block size HashAlgorithm md5Hash = HashAlgorithm.Create("MD5"); byte[] eIV = md5Hash.ComputeHash(serverHello.Nonce.ID); byte[] dIV = md5Hash.ComputeHash(clientHello.Nonce.ID); //create encryption and decryption objects SymmetricCryptoKey encryptionKey = new SymmetricCryptoKey(SymmetricEncryptionAlgorithm.Rijndael, masterKey, eIV, PaddingMode.None); SymmetricCryptoKey decryptionKey = new SymmetricCryptoKey(SymmetricEncryptionAlgorithm.Rijndael, masterKey, dIV, PaddingMode.None); //enable encryption EnableEncryption(stream, encryptionKey, decryptionKey, new HMACSHA256(masterKey), new HMACSHA256(masterKey)); break; default: throw new SecureChannelException(SecureChannelCode.NoMatchingCryptoAvailable, _remotePeerEP, _remotePeerCert); } //channel encryption is ON! #endregion #region 3. exchange & verify certificates & signatures if (!_reNegotiating) { //read client certificate _remotePeerCert = (new SecureChannelPacket(this)).GetCertificate(); //verify client certificate try { _remotePeerCert.Verify(trustedRootCertificates); } catch (Exception ex) { throw new SecureChannelException(SecureChannelCode.InvalidRemoteCertificate, _remotePeerEP, _remotePeerCert, "Invalid remote certificate.", ex); } } //verify key exchange signature switch (_selectedCryptoOption) { case SecureChannelCryptoOptionFlags.DHE2048_RSA_WITH_AES256_CBC_HMAC_SHA256: case SecureChannelCryptoOptionFlags.ECDHE256_RSA_WITH_AES256_CBC_HMAC_SHA256: if (_remotePeerCert.PublicKeyEncryptionAlgorithm != AsymmetricEncryptionAlgorithm.RSA) { throw new SecureChannelException(SecureChannelCode.InvalidRemoteCertificateAlgorithm, _remotePeerEP, _remotePeerCert); } if (!clientKeyExchange.IsSignatureValid(_remotePeerCert, "SHA256")) { throw new SecureChannelException(SecureChannelCode.InvalidRemoteKeyExchangeSignature, _remotePeerEP, _remotePeerCert); } break; default: throw new SecureChannelException(SecureChannelCode.NoMatchingCryptoAvailable, _remotePeerEP, _remotePeerCert); } if ((manager != null) && !manager.ProceedConnection(_remotePeerCert)) { throw new SecureChannelException(SecureChannelCode.SecurityManagerDeclinedAccess, _remotePeerEP, _remotePeerCert, "Security manager declined access."); } //send server certificate if (!_reNegotiating) { SecureChannelPacket.WritePacket(this, serverCredentials.Certificate); } #endregion }
/// <summary> /// Unix-like Crypt-MD5 function /// </summary> /// <param name="password">The user password</param> /// <param name="salt">The salt or the pepper of the password</param> /// <returns>a human readable string</returns> public static String crypt(String password, String salt) { int saltEnd; int len; int value; int i; byte[] final; byte[] passwordBytes; byte[] saltBytes; byte[] ctx; StringBuilder result; HashAlgorithm x_hash_alg = HashAlgorithm.Create("MD5"); // Skip magic if it exists if (salt.StartsWith(magic)) { salt = salt.Substring(magic.Length); } // Remove password hash if present if ((saltEnd = salt.LastIndexOf('$')) != -1) { salt = salt.Substring(0, saltEnd); } // Shorten salt to 8 characters if it is longer if (salt.Length > 8) { salt = salt.Substring(0, 8); } ctx = Encoding.ASCII.GetBytes(password + magic + salt); final = x_hash_alg.ComputeHash(Encoding.ASCII.GetBytes(password + salt + password)); // Add as many characters of ctx1 to ctx for (len = password.Length; len > 0; len -= 16) { if (len > 16) { ctx = Concat(ctx, final); } else { ctx = Concat(ctx, final, len); } } // Then something really weird... passwordBytes = Encoding.ASCII.GetBytes(password); for (i = password.Length; i > 0; i >>= 1) { if ((i & 1) == 1) { ctx = Concat(ctx, new byte[] { 0 }); } else { ctx = Concat(ctx, new byte[] { passwordBytes[0] }); } } final = x_hash_alg.ComputeHash(ctx); // Do additional mutations saltBytes = Encoding.ASCII.GetBytes(salt); for (i = 0; i < 1000; i++) { var ctx1 = new byte[] { }; if ((i & 1) == 1) { ctx1 = Concat(ctx1, passwordBytes); } else { ctx1 = Concat(ctx1, final); } if (i % 3 != 0) { ctx1 = Concat(ctx1, saltBytes); } if (i % 7 != 0) { ctx1 = Concat(ctx1, passwordBytes); } if ((i & 1) != 0) { ctx1 = Concat(ctx1, final); } else { ctx1 = Concat(ctx1, passwordBytes); } final = x_hash_alg.ComputeHash(ctx1); } result = new StringBuilder(); // Add the password hash to the result string value = ((final[0] & 0xff) << 16) | ((final[6] & 0xff) << 8) | (final[12] & 0xff); result.Append(to64(value, 4)); value = ((final[1] & 0xff) << 16) | ((final[7] & 0xff) << 8) | (final[13] & 0xff); result.Append(to64(value, 4)); value = ((final[2] & 0xff) << 16) | ((final[8] & 0xff) << 8) | (final[14] & 0xff); result.Append(to64(value, 4)); value = ((final[3] & 0xff) << 16) | ((final[9] & 0xff) << 8) | (final[15] & 0xff); result.Append(to64(value, 4)); value = ((final[4] & 0xff) << 16) | ((final[10] & 0xff) << 8) | (final[5] & 0xff); result.Append(to64(value, 4)); value = final[11] & 0xff; result.Append(to64(value, 2)); // Return result string return(magic + salt + "$" + result); }
private string CalculateVer(DiscoNode n) { if (m_hash == null) return null; // 1. Initialize an empty string S. StringBuilder S = new StringBuilder(); // 2. Sort the service discovery identities [16] by category and then by type // (if it exists) and then by xml:lang (if it exists), formatted as // CATEGORY '/' [TYPE] '/' [LANG] '/' [NAME]. Note that each slash is // included even if the TYPE, LANG, or NAME is not included. Ident[] ids = n.GetIdentities(); Array.Sort(ids); // 3. For each identity, append the 'category/type/lang/name' to S, followed by // the '<' character. foreach (Ident id in ids) { S.Append(id.Key); S.Append(SEP); } // 4. Sort the supported service discovery features. string[] features = n.FeatureNames; Array.Sort(features); // 5. For each feature, append the feature to S, followed by the '<' character. foreach (string feature in features) { S.Append(feature); S.Append(SEP); } // 6. If the service discovery information response includes XEP-0128 data forms, // sort the forms by the FORM_TYPE (i.e., by the XML character // data of the <value/> element). Data[] ext = n.Extensions; if (ext != null) { Array.Sort(ext, new FormTypeComparer()); foreach (Data x in ext) { // For each extended service discovery information form: // 1. Append the XML character data of the FORM_TYPE field's <value/> // element, followed by the '<' character. S.Append(x.FormType); S.Append(SEP); // 2. Sort the fields by the value of the "var" attribute. bedrock.collections.Tree fields = new bedrock.collections.Tree(); foreach (Field f in x.GetFields()) fields[f.Var] = f; // 3. For each field: foreach (System.Collections.DictionaryEntry entry in fields) { Field f = (Field)entry.Value; if (f.Var == "FORM_TYPE") continue; // 1. Append the value of the "var" attribute, followed by the '<' character. S.Append(f.Var); S.Append(SEP); // 2. Sort values by the XML character data of the <value/> element. string[] values = f.Vals; Array.Sort(values); foreach (string v in values) { // 3. For each <value/> element, append the XML character data, followed by the '<' character. S.Append(v); S.Append(SEP); } } } } // Ensure that S is encoded according to the UTF-8 encoding (RFC 3269 [16]). byte[] input = Encoding.UTF8.GetBytes(S.ToString()); // Compute the verification string by hashing S using the algorithm specified // in the 'hash' attribute (e.g., SHA-1 as defined in RFC 3174 [17]). The hashed // data MUST be generated with binary output and encoded using Base64 as specified // in Section 4 of RFC 4648 [18] (note: the Base64 output MUST NOT include // whitespace and MUST set padding bits to zero). [19] HashAlgorithm hasher = GetHasher(m_hash); byte[] hash = hasher.ComputeHash(input, 0, input.Length); return Convert.ToBase64String(hash); }
private bool VerifyCounterSignature(PKCS7.SignerInfo cs, byte[] signature) { // SEQUENCE { // INTEGER 1 if (cs.Version != 1) { return(false); } // SEQUENCE { // SEQUENCE { string contentType = null; ASN1 messageDigest = null; for (int i = 0; i < cs.AuthenticatedAttributes.Count; i++) { // SEQUENCE { // OBJECT IDENTIFIER ASN1 attr = (ASN1)cs.AuthenticatedAttributes [i]; string oid = ASN1Convert.ToOid(attr[0]); switch (oid) { case "1.2.840.113549.1.9.3": // contentType contentType = ASN1Convert.ToOid(attr[1][0]); break; case "1.2.840.113549.1.9.4": // messageDigest messageDigest = attr[1][0]; break; case "1.2.840.113549.1.9.5": // SEQUENCE { // OBJECT IDENTIFIER // signingTime (1 2 840 113549 1 9 5) // SET { // UTCTime '030124013651Z' // } // } timestamp = ASN1Convert.ToDateTime(attr[1][0]); break; default: break; } } if (contentType != PKCS7.Oid.data) { return(false); } // verify message digest if (messageDigest == null) { return(false); } // TODO: must be read from the ASN.1 structure string hashName = null; switch (messageDigest.Length) { case 16: hashName = "MD5"; break; case 20: hashName = "SHA1"; break; } HashAlgorithm ha = HashAlgorithm.Create(hashName); if (!messageDigest.CompareValue(ha.ComputeHash(signature))) { return(false); } // verify signature byte[] counterSignature = cs.Signature; // change to SET OF (not [0]) as per PKCS #7 1.5 ASN1 aa = new ASN1(0x31); foreach (ASN1 a in cs.AuthenticatedAttributes) { aa.Add(a); } byte[] p7hash = ha.ComputeHash(aa.GetBytes()); // we need to try all certificates string issuer = cs.IssuerName; byte[] serial = cs.SerialNumber; foreach (X509Certificate x509 in coll) { if (CompareIssuerSerial(issuer, serial, x509)) { if (x509.PublicKey.Length > counterSignature.Length) { RSACryptoServiceProvider rsa = (RSACryptoServiceProvider)x509.RSA; // we need to HACK around bad (PKCS#1 1.5) signatures made by Verisign Timestamp Service // and this means copying stuff into our own RSAManaged to get the required flexibility RSAManaged rsam = new RSAManaged(); rsam.ImportParameters(rsa.ExportParameters(false)); if (PKCS1.Verify_v15(rsam, ha, p7hash, counterSignature, true)) { timestampChain.LoadCertificates(coll); return(timestampChain.Build(x509)); } } } } // no certificate can verify this signature! return(false); }
//private bool VerifySignature (ASN1 cs, byte[] calculatedMessageDigest, string hashName) private bool VerifySignature(PKCS7.SignedData sd, byte[] calculatedMessageDigest, HashAlgorithm ha) { string contentType = null; ASN1 messageDigest = null; // string spcStatementType = null; // string spcSpOpusInfo = null; for (int i = 0; i < sd.SignerInfo.AuthenticatedAttributes.Count; i++) { ASN1 attr = (ASN1)sd.SignerInfo.AuthenticatedAttributes [i]; string oid = ASN1Convert.ToOid(attr[0]); switch (oid) { case "1.2.840.113549.1.9.3": // contentType contentType = ASN1Convert.ToOid(attr[1][0]); break; case "1.2.840.113549.1.9.4": // messageDigest messageDigest = attr[1][0]; break; case "1.3.6.1.4.1.311.2.1.11": // spcStatementType (Microsoft code signing) // possible values // - individualCodeSigning (1 3 6 1 4 1 311 2 1 21) // - commercialCodeSigning (1 3 6 1 4 1 311 2 1 22) // spcStatementType = ASN1Convert.ToOid (attr[1][0][0]); break; case "1.3.6.1.4.1.311.2.1.12": // spcSpOpusInfo (Microsoft code signing) /* try { * spcSpOpusInfo = System.Text.Encoding.UTF8.GetString (attr[1][0][0][0].Value); * } * catch (NullReferenceException) { * spcSpOpusInfo = null; * }*/ break; default: break; } } if (contentType != spcIndirectDataContext) { return(false); } // verify message digest if (messageDigest == null) { return(false); } if (!messageDigest.CompareValue(calculatedMessageDigest)) { return(false); } // verify signature string hashOID = CryptoConfig.MapNameToOID(ha.ToString()); // change to SET OF (not [0]) as per PKCS #7 1.5 ASN1 aa = new ASN1(0x31); foreach (ASN1 a in sd.SignerInfo.AuthenticatedAttributes) { aa.Add(a); } ha.Initialize(); byte[] p7hash = ha.ComputeHash(aa.GetBytes()); byte[] signature = sd.SignerInfo.Signature; // we need to find the specified certificate string issuer = sd.SignerInfo.IssuerName; byte[] serial = sd.SignerInfo.SerialNumber; foreach (X509Certificate x509 in coll) { if (CompareIssuerSerial(issuer, serial, x509)) { // don't verify is key size don't match if (x509.PublicKey.Length > (signature.Length >> 3)) { // return the signing certificate even if the signature isn't correct // (required behaviour for 2.0 support) signingCertificate = x509; RSACryptoServiceProvider rsa = (RSACryptoServiceProvider)x509.RSA; if (rsa.VerifyHash(p7hash, hashOID, signature)) { signerChain.LoadCertificates(coll); trustedRoot = signerChain.Build(x509); break; } } } } // timestamp signature is optional if (sd.SignerInfo.UnauthenticatedAttributes.Count == 0) { trustedTimestampRoot = true; } else { for (int i = 0; i < sd.SignerInfo.UnauthenticatedAttributes.Count; i++) { ASN1 attr = (ASN1)sd.SignerInfo.UnauthenticatedAttributes[i]; string oid = ASN1Convert.ToOid(attr[0]); switch (oid) { case PKCS7.Oid.countersignature: // SEQUENCE { // OBJECT IDENTIFIER // countersignature (1 2 840 113549 1 9 6) // SET { PKCS7.SignerInfo cs = new PKCS7.SignerInfo(attr[1]); trustedTimestampRoot = VerifyCounterSignature(cs, signature); break; default: // we don't support other unauthenticated attributes break; } } } return(trustedRoot && trustedTimestampRoot); }
public static byte[] ComputeHash(this byte[] data) { return(hashProvider.ComputeHash(data)); }
/// <summary> /// 加密方法 /// </summary> /// <param name="Source">待加密的串</param> /// <returns>经过加密的串</returns> public string Encrypto(string Source) { byte[] bytIn = UTF8Encoding.UTF8.GetBytes(Source); byte[] bytOut = HashCryptoService.ComputeHash(bytIn); return(Convert.ToBase64String(bytOut)); }
public static string StringToHash(this string data, string salt, HashAlgorithm algorithm) { byte[] saltedBytes = Encoding.UTF8.GetBytes(data + salt); // Combine the data with the salt byte[] hashedBytes = algorithm.ComputeHash(saltedBytes); // Compute the hash value of our input return(BitConverter.ToString(hashedBytes)); }
public static bool ExerciseHash(HashAlgorithm hash, int size) { // Exercise the properties // if (hash.CanReuseTransform != true) { Console.WriteLine("CanReuseTransform != true"); return false; } if (hash.CanTransformMultipleBlocks != true) { Console.WriteLine("CanTransformMultipleBlocks != true"); return false; } if (hash.HashSize != size) { Console.WriteLine("HashSize, expected={0} actual={1}", size, hash.HashSize); return false; } if (hash.InputBlockSize != 1) { Console.WriteLine("InputBlockSize != 1"); return false; } if (hash.OutputBlockSize != 1) { Console.WriteLine("OutputBlockSize != 1"); return false; } // Exercise the Initialize method. Test proper behavior both when it is and is not called. // byte[] bytesHalf1 = {0x00, 0x01, 0x02, 0x03}; byte[] bytesHalf2 = {0xfc, 0xfd, 0xfe, 0xff}; byte[] bytesFull = {0x00, 0x01, 0x02, 0x03, 0xfc, 0xfd, 0xfe, 0xff}; byte[] bytesExpected; byte[] bytesActual; // Initialize is called between partial hashes // hash.Initialize(); bytesExpected = hash.ComputeHash(bytesHalf1); hash.Initialize(); hash.TransformBlock(bytesHalf2, 0, bytesHalf2.Length, bytesHalf2, 0); hash.Initialize(); hash.TransformFinalBlock(bytesHalf1, 0, bytesHalf1.Length); bytesActual = hash.Hash; if (!CompareBytes(bytesExpected, bytesActual)) { Console.WriteLine("\nInitialize test failed"); return false; } // Initialize is not called between partial hashes // hash.Initialize(); bytesExpected = hash.ComputeHash(bytesFull); hash.Initialize(); hash.TransformBlock(bytesHalf1, 0, bytesHalf1.Length, bytesHalf1, 0); hash.TransformFinalBlock(bytesHalf2, 0, bytesHalf2.Length); bytesActual = hash.Hash; if (!CompareBytes(bytesExpected, bytesActual)) { Console.WriteLine("\nNo Initialize test failed"); return false; } // Exercise the Clear method -- ensure object disposed // hash.Initialize(); hash.Clear(); try { hash.ComputeHash(bytesFull); Console.WriteLine("Clear test failed -- no exception thrown"); return false; } catch (ObjectDisposedException) { } return true; }
private static string Hash(HashAlgorithm alg, string input) => BitConverter.ToString(alg.ComputeHash(Encoding.UTF8.GetBytes(input))).ToLower().Replace("-", "");
/// <summary> /// Encode the data. The data is encrypted using the default encryption algorithm (AES-256), /// then the AES key is encrypted using RSA and the RSA public key is appended. /// </summary> /// <param name="value">The data to encode</param> /// <exception cref="ArgumentNullException">The argument 'value' is null.</exception> /// <exception cref="ArgumentException">The argument 'value' contains zero bytes.</exception> /// <exception cref="InvalidOperationException">The EncryptionKey is null.</exception> /// <returns>Encoded data</returns> public override byte[] Encode(byte[] value) { if (null == value) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value"); } if (0 == value.Length) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("value", SR.GetString(SR.ID6044)); } RSA encryptionKey = EncryptionKey; if (null == encryptionKey) { throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID6043)); } byte[] rsaHash; byte[] encryptedKeyAndIV; byte[] encryptedData; using (HashAlgorithm hash = CryptoHelper.CreateHashAlgorithm(_hashName)) { rsaHash = hash.ComputeHash(Encoding.UTF8.GetBytes(encryptionKey.ToXmlString(false))); } using (SymmetricAlgorithm encryptionAlgorithm = CryptoHelper.NewDefaultEncryption()) { encryptionAlgorithm.GenerateIV(); encryptionAlgorithm.GenerateKey(); using (ICryptoTransform encryptor = encryptionAlgorithm.CreateEncryptor()) { encryptedData = encryptor.TransformFinalBlock(value, 0, value.Length); } RSACryptoServiceProvider provider = encryptionKey as RSACryptoServiceProvider; if (provider == null) { throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID6041)); } // // Concatenate the Key and IV in an attempt to avoid two minimum block lengths in the cookie // byte[] keyAndIV = new byte[encryptionAlgorithm.Key.Length + encryptionAlgorithm.IV.Length]; Array.Copy(encryptionAlgorithm.Key, keyAndIV, encryptionAlgorithm.Key.Length); Array.Copy(encryptionAlgorithm.IV, 0, keyAndIV, encryptionAlgorithm.Key.Length, encryptionAlgorithm.IV.Length); encryptedKeyAndIV = CngLightup.OaepSha1Encrypt(encryptionKey, keyAndIV); } using (MemoryStream ms = new MemoryStream()) { using (BinaryWriter bw = new BinaryWriter(ms)) { bw.Write(rsaHash); bw.Write(encryptedKeyAndIV.Length); bw.Write(encryptedKeyAndIV); bw.Write(encryptedData.Length); bw.Write(encryptedData); bw.Flush(); } return(ms.ToArray()); } }
public byte[] method_10(byte[] byte_2, HashAlgorithm hashAlgorithm_0) { Class1.Class13.Enum1 enum1_ = this.method_16(hashAlgorithm_0); byte[] byte_3 = hashAlgorithm_0.ComputeHash(byte_2); return this.method_7(byte_3, enum1_); }
public static byte[] GetHash(this string inputString) { using (HashAlgorithm algorithm = SHA256.Create()) return(algorithm.ComputeHash(Encoding.UTF8.GetBytes(inputString))); }
public virtual byte[] GetDigestedOutput (HashAlgorithm hash) { // no null check, MS throws a NullReferenceException here return hash.ComputeHash ((Stream) GetOutput (typeof (Stream))); }
public static void VerifyEmptyHash(HashAlgorithm referenceAlgorithm, HashAlgorithmName hashAlgorithm) { using (referenceAlgorithm) using (IncrementalHash incrementalHash = IncrementalHash.CreateHash(hashAlgorithm)) { for (int i = 0; i < 10; i++) { incrementalHash.AppendData(Array.Empty<byte>()); } byte[] referenceHash = referenceAlgorithm.ComputeHash(Array.Empty<byte>()); byte[] incrementalResult = incrementalHash.GetHashAndReset(); Assert.Equal(referenceHash, incrementalResult); } }
// PKCS #1 v.2.1, Section B.2.1 public static byte[] MGF1 (HashAlgorithm hash, byte[] mgfSeed, int maskLen) { // 1. If maskLen > 2^32 hLen, output "mask too long" and stop. // easy - this is impossible by using a int (31bits) as parameter ;-) // BUT with a signed int we do have to check for negative values! if (maskLen < 0) throw new OverflowException(); int mgfSeedLength = mgfSeed.Length; int hLen = (hash.HashSize >> 3); // from bits to bytes int iterations = (maskLen / hLen); if (maskLen % hLen != 0) iterations++; // 2. Let T be the empty octet string. byte[] T = new byte [iterations * hLen]; byte[] toBeHashed = new byte [mgfSeedLength + 4]; int pos = 0; // 3. For counter from 0 to \ceil (maskLen / hLen) - 1, do the following: for (int counter = 0; counter < iterations; counter++) { // a. Convert counter to an octet string C of length 4 octets byte[] C = I2OSP (counter, 4); // b. Concatenate the hash of the seed mgfSeed and C to the octet string T: // T = T || Hash (mgfSeed || C) Buffer.BlockCopy (mgfSeed, 0, toBeHashed, 0, mgfSeedLength); Buffer.BlockCopy (C, 0, toBeHashed, mgfSeedLength, 4); byte[] output = hash.ComputeHash (toBeHashed); Buffer.BlockCopy (output, 0, T, pos, hLen); pos += hLen; } // 4. Output the leading maskLen octets of T as the octet string mask. byte[] mask = new byte [maskLen]; Buffer.BlockCopy (T, 0, mask, 0, maskLen); return mask; }
// Run a hash algorithm test. protected void RunHash(HashAlgorithm alg, String value, byte[] expected) { // Make sure that the hash size is what we expect. AssertEquals("hash size is incorrect", alg.HashSize, expected.Length * 8); // Convert the string form of the input into a byte array. byte[] input = Encoding.ASCII.GetBytes(value); // Get the hash value over the input. byte[] hash = alg.ComputeHash(input); // Compare the hash with the expected value. AssertNotNull("returned hash was null", hash); AssertEquals("hash length is wrong", hash.Length, expected.Length); if(!IdenticalBlock(hash, 0, expected, 0, expected.Length)) { Fail("incorrect hash value produced"); } // Get the hash value over the input in a sub-buffer. byte[] input2 = new byte [input.Length + 20]; Array.Copy(input, 0, input2, 10, input.Length); hash = alg.ComputeHash(input2, 10, input.Length); // Compare the hash with the expected value. AssertNotNull("returned hash was null", hash); AssertEquals("hash length is wrong", hash.Length, expected.Length); if(!IdenticalBlock(hash, 0, expected, 0, expected.Length)) { Fail("incorrect hash value produced"); } // Get the hash value over the input via a stream. MemoryStream stream = new MemoryStream(input, false); hash = alg.ComputeHash(stream); // Compare the hash with the expected value. AssertNotNull("returned hash was null", hash); AssertEquals("hash length is wrong", hash.Length, expected.Length); if(!IdenticalBlock(hash, 0, expected, 0, expected.Length)) { Fail("incorrect hash value produced"); } }
/// <summary> /// Compute the hash of the full key string using the given hash algorithm /// </summary> /// <param name="fullKeyString">The full key return by call FullKeyAsString</param> /// <param name="hashAlgorithm">The hash algorithm used to hash the key</param> /// <returns>The hashed key as a string</returns> private static string ComputeHash(string fullKeyString, HashAlgorithm hashAlgorithm) { byte[] bytes = Encoding.ASCII.GetBytes(fullKeyString); byte[] computedHash = hashAlgorithm.ComputeHash(bytes); return(Convert.ToBase64String(computedHash)); }
private static byte[] GetEmptyHash (HashAlgorithm hash) { if (hash is SHA1) return emptySHA1; else if (hash is SHA256) return emptySHA256; #if !NET_2_1 || MONOTOUCH else if (hash is SHA384) return emptySHA384; else if (hash is SHA512) return emptySHA512; #endif else return hash.ComputeHash ((byte[])null); }
/// <summary> /// Construct the strong assembly name from metadata /// </summary> internal static string GetAssemblyStrongName(MetadataReader metadataReader) { AssemblyDefinition assemblyDefinition = metadataReader.GetAssemblyDefinition(); string asmName = metadataReader.GetString(assemblyDefinition.Name); string asmVersion = assemblyDefinition.Version.ToString(); string asmCulture = metadataReader.GetString(assemblyDefinition.Culture); asmCulture = (asmCulture == string.Empty) ? "neutral" : asmCulture; AssemblyHashAlgorithm hashAlgorithm = assemblyDefinition.HashAlgorithm; BlobHandle blobHandle = assemblyDefinition.PublicKey; BlobReader blobReader = metadataReader.GetBlobReader(blobHandle); string publicKeyTokenString = "null"; // Extract public key token only if PublicKey exists in the metadata if (blobReader.Length > 0) { byte[] publickey = blobReader.ReadBytes(blobReader.Length); HashAlgorithm hashImpl = null; switch (hashAlgorithm) { case AssemblyHashAlgorithm.Sha1: hashImpl = SHA1.Create(); break; case AssemblyHashAlgorithm.MD5: hashImpl = MD5.Create(); break; case AssemblyHashAlgorithm.Sha256: hashImpl = SHA256.Create(); break; case AssemblyHashAlgorithm.Sha384: hashImpl = SHA384.Create(); break; case AssemblyHashAlgorithm.Sha512: hashImpl = SHA512.Create(); break; default: throw new NotSupportedException(); } byte[] publicKeyHash = hashImpl.ComputeHash(publickey); byte[] publicKeyTokenBytes = new byte[8]; // Note that, the low 8 bytes of the hash of public key in reverse order is the public key tokens. for (int i = 1; i <= 8; i++) { publicKeyTokenBytes[i - 1] = publicKeyHash[publicKeyHash.Length - i]; } // Convert bytes to hex format strings in lower case. publicKeyTokenString = BitConverter.ToString(publicKeyTokenBytes).Replace("-", string.Empty).ToLowerInvariant(); } string strongAssemblyName = string.Format(CultureInfo.InvariantCulture, "{0}, Version={1}, Culture={2}, PublicKeyToken={3}", asmName, asmVersion, asmCulture, publicKeyTokenString); return(strongAssemblyName); }
internal StrongNameSignature StrongHash(Stream stream, StrongNameOptions options) { StrongNameSignature signature = new StrongNameSignature(); HashAlgorithm transform = HashAlgorithm.Create(this.TokenAlgorithm); CryptoStream stream2 = new CryptoStream(Stream.Null, transform, CryptoStreamMode.Write); byte[] buffer = new byte[0x80]; stream.Read(buffer, 0, 0x80); if (BitConverterLE.ToUInt16(buffer, 0) != 0x5a4d) { return(null); } uint num = BitConverterLE.ToUInt32(buffer, 60); stream2.Write(buffer, 0, 0x80); if (num != 0x80) { byte[] buffer2 = new byte[num - 0x80]; stream.Read(buffer2, 0, buffer2.Length); stream2.Write(buffer2, 0, buffer2.Length); } byte[] buffer3 = new byte[0xf8]; stream.Read(buffer3, 0, 0xf8); if (BitConverterLE.ToUInt32(buffer3, 0) != 0x4550) { return(null); } if (BitConverterLE.ToUInt16(buffer3, 4) != 0x14c) { return(null); } byte[] src = new byte[8]; Buffer.BlockCopy(src, 0, buffer3, 0x58, 4); Buffer.BlockCopy(src, 0, buffer3, 0x98, 8); stream2.Write(buffer3, 0, 0xf8); ushort sections = BitConverterLE.ToUInt16(buffer3, 6); int count = sections * 40; byte[] buffer5 = new byte[count]; stream.Read(buffer5, 0, count); stream2.Write(buffer5, 0, count); uint r = BitConverterLE.ToUInt32(buffer3, 0xe8); uint num5 = this.RVAtoPosition(r, sections, buffer5); int num6 = (int)BitConverterLE.ToUInt32(buffer3, 0xec); byte[] buffer6 = new byte[num6]; stream.Position = num5; stream.Read(buffer6, 0, num6); uint num7 = BitConverterLE.ToUInt32(buffer6, 0x20); signature.SignaturePosition = this.RVAtoPosition(num7, sections, buffer5); signature.SignatureLength = BitConverterLE.ToUInt32(buffer6, 0x24); uint num8 = BitConverterLE.ToUInt32(buffer6, 8); signature.MetadataPosition = this.RVAtoPosition(num8, sections, buffer5); signature.MetadataLength = BitConverterLE.ToUInt32(buffer6, 12); if (options == StrongNameOptions.Metadata) { stream2.Close(); transform.Initialize(); byte[] buffer7 = new byte[signature.MetadataLength]; stream.Position = signature.MetadataPosition; stream.Read(buffer7, 0, buffer7.Length); signature.Hash = transform.ComputeHash(buffer7); return(signature); } for (int i = 0; i < sections; i++) { uint num10 = BitConverterLE.ToUInt32(buffer5, (i * 40) + 20); int num11 = (int)BitConverterLE.ToUInt32(buffer5, (i * 40) + 0x10); byte[] buffer8 = new byte[num11]; stream.Position = num10; stream.Read(buffer8, 0, num11); if ((num10 <= signature.SignaturePosition) && (signature.SignaturePosition < (num10 + num11))) { int num12 = (int)(signature.SignaturePosition - num10); if (num12 > 0) { stream2.Write(buffer8, 0, num12); } signature.Signature = new byte[signature.SignatureLength]; Buffer.BlockCopy(buffer8, num12, signature.Signature, 0, (int)signature.SignatureLength); Array.Reverse(signature.Signature); int offset = num12 + ((int)signature.SignatureLength); int num14 = num11 - offset; if (num14 > 0) { stream2.Write(buffer8, offset, num14); } } else { stream2.Write(buffer8, 0, num11); } } stream2.Close(); signature.Hash = transform.Hash; return(signature); }
public bool method_11(byte[] byte_2, HashAlgorithm hashAlgorithm_0, byte[] byte_3) { Class1.Class13.Enum1 enum1_ = this.method_16(hashAlgorithm_0); byte[] byte_4 = hashAlgorithm_0.ComputeHash(byte_2); return this.method_9(byte_4, byte_3, enum1_); }
///***************************************************/ private static byte[] SHA256_byte(byte[] inputObj) { HashAlgorithm algorithm = System.Security.Cryptography.SHA256.Create(); return(algorithm.ComputeHash(inputObj)); }
public static void VerifyTrivialHash(HashAlgorithm referenceAlgorithm, HashAlgorithmName hashAlgorithm) { using (referenceAlgorithm) using (IncrementalHash incrementalHash = IncrementalHash.CreateHash(hashAlgorithm)) { byte[] referenceHash = referenceAlgorithm.ComputeHash(Array.Empty<byte>()); byte[] incrementalResult = incrementalHash.GetHashAndReset(); Assert.Equal(referenceHash, incrementalResult); } }
public static byte[] GetHash(string inputString) { HashAlgorithm algorithm = MD5.Create(); //or use SHA1.Create(); return(algorithm.ComputeHash(Encoding.UTF8.GetBytes(inputString))); }
//private bool VerifySignature (ASN1 cs, byte[] calculatedMessageDigest, string hashName) private bool VerifySignature (PKCS7.SignedData sd, byte[] calculatedMessageDigest, HashAlgorithm ha) { string contentType = null; ASN1 messageDigest = null; // string spcStatementType = null; // string spcSpOpusInfo = null; for (int i=0; i < sd.SignerInfo.AuthenticatedAttributes.Count; i++) { ASN1 attr = (ASN1) sd.SignerInfo.AuthenticatedAttributes [i]; string oid = ASN1Convert.ToOid (attr[0]); switch (oid) { case "1.2.840.113549.1.9.3": // contentType contentType = ASN1Convert.ToOid (attr[1][0]); break; case "1.2.840.113549.1.9.4": // messageDigest messageDigest = attr[1][0]; break; case "1.3.6.1.4.1.311.2.1.11": // spcStatementType (Microsoft code signing) // possible values // - individualCodeSigning (1 3 6 1 4 1 311 2 1 21) // - commercialCodeSigning (1 3 6 1 4 1 311 2 1 22) // spcStatementType = ASN1Convert.ToOid (attr[1][0][0]); break; case "1.3.6.1.4.1.311.2.1.12": // spcSpOpusInfo (Microsoft code signing) /* try { spcSpOpusInfo = System.Text.Encoding.UTF8.GetString (attr[1][0][0][0].Value); } catch (NullReferenceException) { spcSpOpusInfo = null; }*/ break; default: break; } } if (contentType != spcIndirectDataContext) return false; // verify message digest if (messageDigest == null) return false; if (!messageDigest.CompareValue (calculatedMessageDigest)) return false; // verify signature string hashOID = CryptoConfig.MapNameToOID (ha.ToString ()); // change to SET OF (not [0]) as per PKCS #7 1.5 ASN1 aa = new ASN1 (0x31); foreach (ASN1 a in sd.SignerInfo.AuthenticatedAttributes) aa.Add (a); ha.Initialize (); byte[] p7hash = ha.ComputeHash (aa.GetBytes ()); byte[] signature = sd.SignerInfo.Signature; // we need to find the specified certificate string issuer = sd.SignerInfo.IssuerName; byte[] serial = sd.SignerInfo.SerialNumber; foreach (X509Certificate x509 in coll) { if (CompareIssuerSerial (issuer, serial, x509)) { // don't verify is key size don't match if (x509.PublicKey.Length > (signature.Length >> 3)) { // return the signing certificate even if the signature isn't correct // (required behaviour for 2.0 support) signingCertificate = x509; RSACryptoServiceProvider rsa = (RSACryptoServiceProvider) x509.RSA; if (rsa.VerifyHash (p7hash, hashOID, signature)) { signerChain.LoadCertificates (coll); trustedRoot = signerChain.Build (x509); break; } } } } // timestamp signature is optional if (sd.SignerInfo.UnauthenticatedAttributes.Count == 0) { trustedTimestampRoot = true; } else { for (int i = 0; i < sd.SignerInfo.UnauthenticatedAttributes.Count; i++) { ASN1 attr = (ASN1) sd.SignerInfo.UnauthenticatedAttributes[i]; string oid = ASN1Convert.ToOid (attr[0]); switch (oid) { case PKCS7.Oid.countersignature: // SEQUENCE { // OBJECT IDENTIFIER // countersignature (1 2 840 113549 1 9 6) // SET { PKCS7.SignerInfo cs = new PKCS7.SignerInfo (attr[1]); trustedTimestampRoot = VerifyCounterSignature (cs, signature); break; default: // we don't support other unauthenticated attributes break; } } } return (trustedRoot && trustedTimestampRoot); }
/// <summary> /// HashAlgorithm 加密统一方法 /// </summary> private static string HashAlgorithmBase(HashAlgorithm hashAlgorithmObj, string source, Encoding encoding) { byte[] btStr = encoding.GetBytes(source); byte[] hashStr = hashAlgorithmObj.ComputeHash(btStr); return(hashStr.Bytes2Str()); }
public override byte[] GetDigestedOutput (HashAlgorithm hash) { // no null check, MS throws a NullReferenceException here return hash.ComputeHash ((Stream) GetOutput ()); }
protected static string ComputeHash(string input, HashAlgorithm algorithm) { Byte[] inputBytes = Encoding.UTF8.GetBytes(input); Byte[] hashedBytes = algorithm.ComputeHash(inputBytes); return(BitConverter.ToString(hashedBytes).Replace("-", "")); }
public override byte[] GetDigestedOutput (HashAlgorithm hash) { return hash.ComputeHash ((Stream) GetOutput ()); }
/// <summary> /// Returns a pseudo-random key from a password, salt and iteration count. /// </summary> /// <param name="cb">The number of pseudo-random key bytes to generate.</param> /// <returns>A byte array filled with pseudo-random key bytes.</returns> public override byte[] GetBytes(int cb) { if (cb <= 0) { throw new ArgumentOutOfRangeException("cb", cb, "cb is out of range. Positive number required."); } if (_currentHash == null) { _hashList = new List <byte>(); _currentHash = new byte[0]; _hashListReadIndex = 0; int preHashLength = _data.Length + ((_salt != null) ? _salt.Length : 0); var preHash = new byte[preHashLength]; Buffer.BlockCopy(_data, 0, preHash, 0, _data.Length); if (_salt != null) { Buffer.BlockCopy(_salt, 0, preHash, _data.Length, _salt.Length); } _currentHash = _hash.ComputeHash(preHash); for (int i = 1; i < _iterations; i++) { _currentHash = _hash.ComputeHash(_currentHash); } _hashList.AddRange(_currentHash); } while (_hashList.Count < (cb + _hashListReadIndex)) { int preHashLength = _currentHash.Length + _data.Length + ((_salt != null) ? _salt.Length : 0); var preHash = new byte[preHashLength]; Buffer.BlockCopy(_currentHash, 0, preHash, 0, _currentHash.Length); Buffer.BlockCopy(_data, 0, preHash, _currentHash.Length, _data.Length); if (_salt != null) { Buffer.BlockCopy(_salt, 0, preHash, _currentHash.Length + _data.Length, _salt.Length); } _currentHash = _hash.ComputeHash(preHash); for (int i = 1; i < _iterations; i++) { _currentHash = _hash.ComputeHash(_currentHash); } _hashList.AddRange(_currentHash); } byte[] dst = new byte[cb]; _hashList.CopyTo(_hashListReadIndex, dst, 0, cb); _hashListReadIndex += cb; return(dst); }
public HMAC(string hashName, byte[] rgbKey) { // Create the hash if (hashName == null || hashName.Length == 0) { hashName = "MD5"; } hash = HashAlgorithm.Create(hashName); // Set HashSizeValue HashSizeValue = hash.HashSize; /* if key is longer than 64 bytes reset it to rgbKey = Hash(rgbKey) */ if (rgbKey.Length > 64) { KeyValue = hash.ComputeHash(rgbKey); } else { KeyValue = (byte[])rgbKey.Clone(); } this.Initialize(); }
public HMAC (HashAlgorithm ha, byte[] rgbKey) { hash = ha; // Set HashSizeValue HashSizeValue = hash.HashSize; /* if key is longer than 64 bytes reset it to rgbKey = Hash(rgbKey) */ if (rgbKey.Length > 64) { KeyValue = hash.ComputeHash(rgbKey); } else { KeyValue = (byte[])rgbKey.Clone(); } this.Initialize(); }