public static string Encode(string publicKey, int choice = 2) { byte[] hashMessage = null; byte[] messageBytes = m_encoding.GetBytes(publicKey); switch (choice%6) { case 0: var hmacmd5 = new HMACMD5(m_keyBytes); hashMessage = hmacmd5.ComputeHash(messageBytes); break; case 1: var hmacripedmd160 = new HMACRIPEMD160(m_keyBytes); hashMessage = hmacripedmd160.ComputeHash(messageBytes); break; case 2: var hmacsha1 = new HMACSHA1(m_keyBytes); hashMessage = hmacsha1.ComputeHash(messageBytes); break; case 3: var hmacsha256 = new HMACSHA256(m_keyBytes); hashMessage = hmacsha256.ComputeHash(messageBytes); break; case 4: var hmacsha384 = new HMACSHA384(m_keyBytes); hashMessage = hmacsha384.ComputeHash(messageBytes); break; case 5: var hmacsha512 = new HMACSHA512(m_keyBytes); hashMessage = hmacsha512.ComputeHash(messageBytes); break; } return Convert.ToBase64String(hashMessage); }
/// <summary> /// Creates a new HMAC instance /// </summary> /// <param name="theHash">The hash.</param> /// <returns>A <see cref="HMAC"/> instance</returns> /// <exception cref="NotSupportedException">If the given <paramref name="theHash"/> is not a supported HMAC</exception> public static System.Security.Cryptography.HMAC CreateInstance(HashType theHash) { System.Security.Cryptography.HMAC hmac = null; switch (theHash) { case HashType.MD5: { hmac = new HMACMD5(); break; } case HashType.RIPEMD160: { hmac = new HMACRIPEMD160(); break; } case HashType.SHA1: { hmac = new HMACSHA1(); break; } case HashType.SHA256: { hmac = new HMACSHA256(); break; } case HashType.SHA384: { hmac = new HMACSHA384(); break; } case HashType.SHA512: { hmac = new HMACSHA512(); break; } default: { throw new NotSupportedException(String.Format("The given hash :'{0}' is not a supported hmac", theHash)); } } return hmac; }
/// <summary> /// Computes the HMAC-RIPEMD-160 for the key and bytes. /// </summary> public static Byte[] ComputeHMAC(Byte[] key, Byte[] bytes) { HMACRIPEMD160 hmac = new HMACRIPEMD160(key); return hmac.ComputeHash(bytes); }
protected override void SetUp () { hmac = new HMACRIPEMD160 (); hmac.Key = new byte [8]; hash = hmac; }
public void HMACRIPEMD160_e (string testName, HMACRIPEMD160 hmac, byte[] input, byte[] result) { byte[] copy = new byte [input.Length]; for (int i=0; i < input.Length - 1; i++) hmac.TransformBlock (input, i, 1, copy, i); hmac.TransformFinalBlock (input, input.Length - 1, 1); Assert.AreEqual (result, hmac.Hash, testName + ".e"); // required or next operation will still return old hash hmac.Initialize (); }
public void HMACRIPEMD160_d (string testName, HMACRIPEMD160 hmac, byte[] input, byte[] result) { hmac.TransformFinalBlock (input, 0, input.Length); Assert.AreEqual (result, hmac.Hash, testName + ".d"); // required or next operation will still return old hash hmac.Initialize (); }
public void HMACRIPEMD160_c (string testName, HMACRIPEMD160 hmac, byte[] input, byte[] result) { MemoryStream ms = new MemoryStream (input); byte[] output = hmac.ComputeHash (ms); Assert.AreEqual (result, output, testName + ".c.1"); Assert.AreEqual (result, hmac.Hash, testName + ".c.2"); // required or next operation will still return old hash hmac.Initialize (); }
public void HMACRIPEMD160_b (string testName, HMACRIPEMD160 hmac, byte[] input, byte[] result) { byte[] output = hmac.ComputeHash (input, 0, input.Length); Assert.AreEqual (result, output, testName + ".b.1"); Assert.AreEqual (result, hmac.Hash, testName + ".b.2"); // required or next operation will still return old hash hmac.Initialize (); }
/// <summary> /// 获取加密方法 /// </summary> /// <param name="hmacFormat"></param> /// <param name="key"></param> /// <returns></returns> private static HMAC GetHmac(HmacFormat hmacFormat, byte[] key) { HMAC hmac = null; switch (hmacFormat) { case HmacFormat.HMACMD5: hmac = new HMACMD5(key); break; case HmacFormat.HMACRIPEMD160: hmac = new HMACRIPEMD160(key); break; case HmacFormat.HMACSHA1: hmac = new HMACSHA1(key); break; case HmacFormat.HMACSHA256: hmac = new HMACSHA256(key); break; case HmacFormat.HMACSHA384: hmac = new HMACSHA384(key); break; case HmacFormat.HMACSHA512: hmac = new HMACSHA512(key); break; } return hmac; }
public void SetUp () { hmac = new HMACRIPEMD160 (); }
public void HMACRIPEMD160_a (string testName, HMACRIPEMD160 hmac, byte[] input, byte[] result) { byte[] output = hmac.ComputeHash (input); AssertEquals (testName + ".a.1", result, output); AssertEquals (testName + ".a.2", result, hmac.Hash); // required or next operation will still return old hash hmac.Initialize (); }
/// <summary> /// Computes a keyed hash for a source file based on key provided and the HMAC algorithm selected by the user /// Defaults to HMACSHA1 /// </summary> /// <param name="file">file to get the HMAC of</param> /// <param name="hmacAlgo">HMAC algorithm to use</param> /// <param name="hmacKey">Key supplied by the user</param> public string CalculateHMAC(string file, string hmacAlgo, byte[] hmacKey) { string resultHmac = ""; byte[] hashOfInputFile; try { switch (hmacAlgo) { case "HMACMD5": using (HMACMD5 hmacSha1 = new HMACMD5(hmacKey)) { using (FileStream objFS = new FileStream(file, FileMode.Open)) { // Computing the hash of the input file hashOfInputFile = hmacSha1.ComputeHash(objFS); } } break; case "HMACSHA256": using (HMACSHA256 hmacSha1 = new HMACSHA256(hmacKey)) { using (FileStream objFS = new FileStream(file, FileMode.Open)) { // Computing the hash of the input file hashOfInputFile = hmacSha1.ComputeHash(objFS); } } break; case "HMACSHA384": using (HMACSHA384 hmacSha1 = new HMACSHA384(hmacKey)) { using (FileStream objFS = new FileStream(file, FileMode.Open)) { // Computing the hash of the input file hashOfInputFile = hmacSha1.ComputeHash(objFS); } } break; case "HMACSHA512": using (HMACSHA512 hmacSha1 = new HMACSHA512(hmacKey)) { using (FileStream objFS = new FileStream(file, FileMode.Open)) { // Computing the hash of the input file hashOfInputFile = hmacSha1.ComputeHash(objFS); } } break; case "HMACRIPEMD160": using (HMACRIPEMD160 hmacSha1 = new HMACRIPEMD160(hmacKey)) { using (FileStream objFS = new FileStream(file, FileMode.Open)) { // Computing the hash of the input file hashOfInputFile = hmacSha1.ComputeHash(objFS); } } break; default:// "HMACSHA1": using (HMACSHA1 hmacSha1 = new HMACSHA1(hmacKey)) { using(FileStream objFS = new FileStream(file, FileMode.Open)) { // Computing the hash of the input file hashOfInputFile = hmacSha1.ComputeHash(objFS); } } break; } resultHmac = BitConverter.ToString(hashOfInputFile).Replace("-", String.Empty).ToLower(); return resultHmac; } catch { resultHmac = HMAC_ERROR; return resultHmac; } finally { } }
public void Invariants () { var hmac = new HMACRIPEMD160 (); Assert.IsTrue (hmac.CanReuseTransform, "HMACRIPEMD160.CanReuseTransform"); Assert.IsTrue (hmac.CanTransformMultipleBlocks, "HMACRIPEMD160.CanTransformMultipleBlocks"); Assert.AreEqual ("RIPEMD160", hmac.HashName, "HMACRIPEMD160.HashName"); Assert.AreEqual (160, hmac.HashSize, "HMACRIPEMD160.HashSize"); Assert.AreEqual (1, hmac.InputBlockSize, "HMACRIPEMD160.InputBlockSize"); Assert.AreEqual (1, hmac.OutputBlockSize, "HMACRIPEMD160.OutputBlockSize"); Assert.AreEqual (64, hmac.Key.Length, "HMACRIPEMD160.Key.Length"); Assert.AreEqual ("System.Security.Cryptography.HMACRIPEMD160", hmac.ToString (), "HMACRIPEMD160.ToString()"); }