internal bool VerifySignature(DSA dsa) { if (signatureOID != "1.2.840.10040.4.3") { throw new CryptographicException("Unsupported hash algorithm: " + signatureOID); } DSASignatureDeformatter v = new DSASignatureDeformatter(dsa); // only SHA-1 is supported v.SetHashAlgorithm("SHA1"); ASN1 sign = new ASN1(signature); if ((sign == null) || (sign.Count != 2)) { return(false); } // parts may be less than 20 bytes (i.e. first bytes were 0x00) byte[] part1 = sign [0].Value; byte[] part2 = sign [1].Value; byte[] sig = new byte [40]; // parts may be less than 20 bytes (i.e. first bytes were 0x00) // parts may be more than 20 bytes (i.e. first byte > 0x80, negative) int s1 = System.Math.Max(0, part1.Length - 20); int e1 = System.Math.Max(0, 20 - part1.Length); Buffer.BlockCopy(part1, s1, sig, e1, part1.Length - s1); int s2 = System.Math.Max(0, part2.Length - 20); int e2 = System.Math.Max(20, 40 - part2.Length); Buffer.BlockCopy(part2, s2, sig, e2, part2.Length - s2); return(v.VerifySignature(Hash, sig)); }
internal bool VerifySignature(System.Security.Cryptography.DSA dsa) { DSASignatureDeformatter deformatter = new DSASignatureDeformatter(dsa); deformatter.SetHashAlgorithm("SHA1"); return(deformatter.VerifySignature(this.Hash, this.Signature)); }
internal bool VerifySignature(DSA dsa) { DSASignatureDeformatter dsasignatureDeformatter = new DSASignatureDeformatter(dsa); dsasignatureDeformatter.SetHashAlgorithm("SHA1"); return(dsasignatureDeformatter.VerifySignature(this.Hash, this.Signature)); }
public static bool Verify(byte[] hash, byte[] signedHash, string hashAlgo, AsymmetricEncryptionAlgorithm cryptoAlgo, string publicKey) { switch (cryptoAlgo) { case AsymmetricEncryptionAlgorithm.RSA: using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider()) { RSA.FromXmlString(publicKey); return(RSA.VerifyHash(hash, CryptoConfig.MapNameToOID(hashAlgo), signedHash)); } case AsymmetricEncryptionAlgorithm.DSA: using (DSACryptoServiceProvider DSA = new DSACryptoServiceProvider()) { DSA.FromXmlString(publicKey); DSASignatureDeformatter DSADeformatter = new DSASignatureDeformatter(DSA); DSADeformatter.SetHashAlgorithm(hashAlgo); return(DSADeformatter.VerifySignature(hash, signedHash)); } default: throw new NotImplementedException("Feature not implemented for specified algorithm."); } }
public static bool ValidatePathWithEncodedDSASignatureAndPublicDSAKey(string path, string base64Signature, string publicKey) { try { byte[] signature = Convert.FromBase64String(base64Signature); byte[] data = File.ReadAllBytes(path); SHA1CryptoServiceProvider cryptoTransformSHA1 = new SHA1CryptoServiceProvider(); byte[] sha1Hash = cryptoTransformSHA1.ComputeHash(data); string cleanKey = ""; string[] lines = publicKey.Split(new char[] { '\n', '\r' }); foreach (string line in lines) { cleanKey += line.Trim(); } byte[] publicKeyData = Convert.FromBase64String(cleanKey); DSACryptoServiceProvider provider = new DSACryptoServiceProvider(); provider.ImportCspBlob(publicKeyData); DSASignatureDeformatter formatter = new DSASignatureDeformatter(provider); formatter.SetHashAlgorithm("SHA1"); return(formatter.VerifySignature(sha1Hash, signature)); } catch (Exception ex) { Console.WriteLine(ex.Message); return(false); } }
internal bool VerifySignature(DSA dsa) { if (signatureOID != "1.2.840.10040.4.3") { throw new CryptographicException("Unsupported hash algorithm: " + signatureOID); } DSASignatureDeformatter dSASignatureDeformatter = new DSASignatureDeformatter(dsa); dSASignatureDeformatter.SetHashAlgorithm("SHA1"); ASN1 aSN = new ASN1(signature); if (aSN == null || aSN.Count != 2) { return(false); } byte[] value = aSN[0].Value; byte[] value2 = aSN[1].Value; byte[] array = new byte[40]; int num = System.Math.Max(0, value.Length - 20); int dstOffset = System.Math.Max(0, 20 - value.Length); Buffer.BlockCopy(value, num, array, dstOffset, value.Length - num); int num2 = System.Math.Max(0, value2.Length - 20); int dstOffset2 = System.Math.Max(20, 40 - value2.Length); Buffer.BlockCopy(value2, num2, array, dstOffset2, value2.Length - num2); return(dSASignatureDeformatter.VerifySignature(Hash, array)); }
/// <summary> /// 验证签名方法实现 /// </summary> /// <param name="valueToSign">被签名的原始数据</param> /// <param name="signedHashValue">签名值</param> /// <param name="dsaKeyInfo">私钥信息</param> /// <param name="hashAlg">Hash算法名称</param> /// <returns></returns> public static bool DsaVerifyHash(byte[] valueToSign, byte[] signedHashValue, DSAParameters dsaKeyInfo, string hashAlg) { if (string.IsNullOrEmpty(hashAlg)) { throw new ArgumentNullException(hashAlg); } bool verified; try { using (DSACryptoServiceProvider dsa = new DSACryptoServiceProvider()) { dsa.ImportParameters(dsaKeyInfo); DSASignatureDeformatter dsaFormatter = new DSASignatureDeformatter(dsa); dsaFormatter.SetHashAlgorithm(hashAlg); verified = dsaFormatter.VerifySignature(valueToSign, signedHashValue); } } catch (CryptographicException e) { throw new CryptographicException(e.Message); } catch (Exception ex) { throw new Exception(ex.Message); } return(verified); }
private void buttonVerify_Click(object sender, EventArgs e) { //为简化起见,此处假定接收方已经接收到发 //送方发送的hashValue、signedHashValue以及公钥 //同时保证接收方和签名方使用相同的哈希算法(均为“SHA1”) try { DSACryptoServiceProvider dsa = new DSACryptoServiceProvider(); dsa.ImportParameters(dsaKeyInfo); DSASignatureDeformatter DSADeformatter = new DSASignatureDeformatter(dsa); DSADeformatter.SetHashAlgorithm("SHA1"); if (DSADeformatter.VerifySignature(hashValue, signedHashValue)) { textBoxVerifyResult.Text = "验证成功"; } else { textBoxVerifyResult.Text = "验证失败"; } } catch (CryptographicException err) { MessageBox.Show(err.Message); } }
public static bool DSAVerifyHash(byte[] HashValue, byte[] SignedHashValue, DSAParameters DSAKeyInfo, string HashAlg) { bool verified = false; try { // Create a new instance of DSACryptoServiceProvider. using (DSACryptoServiceProvider DSA = new DSACryptoServiceProvider()) // BAD { // Import the key information. DSA.ImportParameters(DSAKeyInfo); // Create an DSASignatureDeformatter object and pass it the // DSACryptoServiceProvider to transfer the private key. DSASignatureDeformatter DSADeformatter = new DSASignatureDeformatter(DSA); // Set the hash algorithm to the passed value. DSADeformatter.SetHashAlgorithm(HashAlg); // Verify signature and return the result. verified = DSADeformatter.VerifySignature(HashValue, SignedHashValue); } } catch (CryptographicException e) { Console.WriteLine(e.Message); } return(verified); }
internal bool VerifySignature(DSA dsa) { if (this.signatureOID != "1.2.840.10040.4.3") { throw new CryptographicException("Unsupported hash algorithm: " + this.signatureOID); } DSASignatureDeformatter deformatter = new DSASignatureDeformatter(dsa); deformatter.SetHashAlgorithm("SHA1"); ASN1 asn = new ASN1(this.signature); if ((asn == null) || (asn.Count != 2)) { return(false); } byte[] src = asn[0].Value; byte[] buffer2 = asn[1].Value; byte[] dst = new byte[40]; int srcOffset = Math.Max(0, src.Length - 20); int dstOffset = Math.Max(0, 20 - src.Length); Buffer.BlockCopy(src, srcOffset, dst, dstOffset, src.Length - srcOffset); int num3 = Math.Max(0, buffer2.Length - 20); int num4 = Math.Max(20, 40 - buffer2.Length); Buffer.BlockCopy(buffer2, num3, dst, num4, buffer2.Length - num3); return(deformatter.VerifySignature(this.Hash, dst)); }
public static bool CheckSign(byte[] data, string xmlStringPubKey) { bool checkResult; DSACryptoServiceProvider dsa = new DSACryptoServiceProvider(); dsa.FromXmlString(xmlStringPubKey); DSASignatureDeformatter dSADeformatter = new DSASignatureDeformatter(dsa); dSADeformatter.SetHashAlgorithm("SHA1"); using (MemoryStream ms = new MemoryStream(data)) { byte[] signedHashLength = new byte[4]; ms.Seek(0, SeekOrigin.Begin); ms.Read(signedHashLength, 0, 3); byte[] signedHash = new byte[BitConverter.ToInt32(signedHashLength, 0)]; ms.Seek(4, SeekOrigin.Begin); ms.Read(signedHash, 0, signedHash.Length); byte[] dat = ReturnDataWithoutHash(data); byte[] hash = GetSha1Hash(dat); checkResult = dSADeformatter.VerifySignature(hash, signedHash); } return(checkResult); }
public static string Hash(string text) { try { byte[] Hash = Sha1Hash(text); DSACryptoServiceProvider dsa = new DSACryptoServiceProvider(); DSASignatureFormatter dSASignatureFormatter = new DSASignatureFormatter(dsa); dSASignatureFormatter.SetHashAlgorithm("SHA1"); byte[] SignedHash = dSASignatureFormatter.CreateSignature(Hash); string sign = Convert.ToBase64String(SignedHash); DSASignatureDeformatter dSASignatureDeformatter = new DSASignatureDeformatter(dsa); if (dSASignatureDeformatter.VerifySignature(Hash, SignedHash)) { return(sign); } else { return(null); } } catch (Exception ex) { throw new Exception("Error! During DSA Hash siganture generation."); } }
internal bool VerifySignature (DSA dsa) { // signatureOID is check by both this.Hash and this.Signature DSASignatureDeformatter v = new DSASignatureDeformatter (dsa); // only SHA-1 is supported v.SetHashAlgorithm ("SHA1"); return v.VerifySignature (this.Hash, this.Signature); }
public bool Verify(string message, byte[] signature) { DSASignatureDeformatter dsdfm = new DSASignatureDeformatter(_alg); dsdfm.SetHashAlgorithm(_hashfn); Byte[] messagebyte = new UnicodeEncoding().GetBytes(message); Byte[] hash = HashAlgorithm.Create(_hashfn).ComputeHash(messagebyte); return(dsdfm.VerifySignature(hash, signature)); }
public static bool VerifySign(string msg, string msgSign, string publicSignKey) { using (var provider = new DSACryptoServiceProvider()) { var signature = Convert.FromBase64String(msgSign); provider.ImportCspBlob(Convert.FromBase64String(publicSignKey)); var deformatter = new DSASignatureDeformatter(provider); deformatter.SetHashAlgorithm("SHA1"); return(deformatter.VerifySignature(UserSHA1.ComputeHashSHA1(msg), signature)); } }
/// <summary> /// Validates the signature that follows the Licence data /// </summary> /// <param name="hashValue">Hash value</param> /// <param name="signedHashValue">Signed hash value</param> /// <param name="xmlKeyInfo">Public Key</param> /// <param name="hashAlg">Hash Algorithm</param> /// <returns>True if signature is valid</returns> private static bool DSAVerifyHash(byte[] hashValue, byte[] signedHashValue, string xmlKeyInfo, string hashAlg) { DSACryptoServiceProvider.UseMachineKeyStore = false; using (DSACryptoServiceProvider DSA = new DSACryptoServiceProvider()) { DSA.FromXmlString(xmlKeyInfo); DSASignatureDeformatter DSAFormatter = new DSASignatureDeformatter(DSA); DSAFormatter.SetHashAlgorithm(hashAlg); return(DSAFormatter.VerifySignature(hashValue, signedHashValue)); } }
public static void VerifySignature_SHA1() { using (DSA dsa = DSAFactory.Create()) { var formatter = new DSASignatureFormatter(dsa); var deformatter = new DSASignatureDeformatter(dsa); using (SHA1 alg = SHA1.Create()) { VerifySignature(formatter, deformatter, alg, "SHA1"); VerifySignature(formatter, deformatter, alg, "sha1"); } } }
//--METHOD UNTUK VERIVIKASI SIGNATURE static bool VerifySignature(byte[] dataSign, byte[] SignData, string publicKey) { //--CREATE OBJEK DSACryptoServiceProvider using (DSACryptoServiceProvider dsa = new DSACryptoServiceProvider()) { //--SET PUBLIC KEY dsa.FromXmlString(publicKey); //--CREATE DEFORMATTER UNTUK MENTRANSFER KEY DSASignatureDeformatter deformatter = new DSASignatureDeformatter(dsa); //--SETTING HASH ALGORITHM UNTUK SHA1 deformatter.SetHashAlgorithm("SHA1"); //--VERIFY SIGNATURE return(deformatter.VerifySignature(dataSign, SignData)); } }
public static void VerifySignature_SHA1() { using (DSA dsa = DSAFactory.Create()) { dsa.ImportParameters(DSATestData.GetDSA1024Params()); var formatter = new DSASignatureFormatter(dsa); var deformatter = new DSASignatureDeformatter(dsa); using (SHA1 alg = SHA1.Create()) { VerifySignature(formatter, deformatter, alg, "SHA1"); VerifySignature(formatter, deformatter, alg, "sha1"); } } }
public bool Verify(byte[] hash, byte[] signedHash, string hashAlgo) { switch (_cryptoAlgo) { case AsymmetricEncryptionAlgorithm.RSA: return((_asymAlgo as RSACryptoServiceProvider).VerifyHash(hash, CryptoConfig.MapNameToOID(hashAlgo), signedHash)); case AsymmetricEncryptionAlgorithm.DSA: DSASignatureDeformatter DSADeformatter = new DSASignatureDeformatter(_asymAlgo); DSADeformatter.SetHashAlgorithm(hashAlgo); return(DSADeformatter.VerifySignature(hash, signedHash)); default: throw new NotImplementedException("Feature not implemented for specified algorithm."); } }
/// <summary> /// DSA验证 /// </summary> /// <param name="CypherText">签名后的Base64字符串</param> /// <param name="xmlString">密钥(至少含公钥)</param> /// <param name="signString">签名串</param> public static bool VerifyString(string CypherText, string xmlString, string signString) { DSACryptoServiceProvider dsa = new DSACryptoServiceProvider(); dsa.FromXmlString(xmlString); if (!string.IsNullOrEmpty(CypherText)) { byte[] bEnc = System.Convert.FromBase64String(CypherText); byte[] bText = System.Text.Encoding.UTF8.GetBytes(signString.ToCharArray()); DSASignatureDeformatter DSADeformatter = new DSASignatureDeformatter(dsa); DSADeformatter.SetHashAlgorithm("SHA1"); return(DSADeformatter.VerifySignature(bEnc, bText)); } return(false); }
/// <summary> /// 验证签名数据。 /// </summary> /// <param name="hashValue">哈希数据。</param> /// <param name="signedData">已签名的哈希数据。</param> /// <param name="hashAlg">哈希算法名称。</param> /// <param name="publicKeyXmlString">公钥数据。</param> /// <returns>验证通过返回True,否则返回False。</returns> private static bool DsaVerifyHash(byte[] hashValue, byte[] signedData, string hashAlg, string publicKeyXmlString) { try { var dsa = new DSACryptoServiceProvider(); dsa.FromXmlString(publicKeyXmlString); var signatureDeformatter = new DSASignatureDeformatter(dsa); signatureDeformatter.SetHashAlgorithm(hashAlg); return(signatureDeformatter.VerifySignature(hashValue, signedData)); } catch (CryptographicException) { return(false); } }
public static bool verifySignature(byte[] hashValue, byte[] signature) { if (JAM_dotnet_verification_use_machine_keys() == 0) { DSACryptoServiceProvider.UseMachineKeyStore = true; } else { DSACryptoServiceProvider.UseMachineKeyStore = false; } DSACryptoServiceProvider key = new DSACryptoServiceProvider(); key.ImportParameters(dsaParms); DSASignatureDeformatter deformatter = new DSASignatureDeformatter(key); deformatter.SetHashAlgorithm("SHA1"); return(deformatter.VerifySignature(hashValue, signature)); }
/// <summary> /// 校验签名是否正确 /// </summary> /// <param name="decryptString"></param> /// <param name="key"></param> /// <returns></returns> public static bool VerifySignature(string decryptString, string key = strKeys) { bool ret = false; byte[] hashValue = { 22, 45, 78, 53, 1, 2, 205, 98, 75, 123, 45, 76, 143, 189, 205, 65, 12, 193, 211, 255 }; DSACryptoServiceProvider signer = new DSACryptoServiceProvider(); DSASignatureFormatter formatter = new DSASignatureFormatter(signer); formatter.SetHashAlgorithm("SHA1"); byte[] signedHashValue = formatter.CreateSignature(hashValue); DSASignatureDeformatter deformatter = new DSASignatureDeformatter(signer); deformatter.SetHashAlgorithm("SHA1"); ret = deformatter.VerifySignature(hashValue, signedHashValue); signer.Clear(); return(ret); }
public bool VerifySignature(Stream stream, string signature) { try { using (var dsaCryptoProvider = new DSACryptoServiceProvider()) { byte[] hash = (new SHA1Managed()).ComputeHash(stream);//for file or text dsaCryptoProvider.ImportParameters(PublicKey); var dsaDeformatter = new DSASignatureDeformatter(dsaCryptoProvider); dsaDeformatter.SetHashAlgorithm("SHA1"); return(dsaDeformatter.VerifySignature(hash, StringToByteArray(signature))); } } catch (CryptographicException e) { return(false); } }
/// <summary> /// Verify a file using a signature file and a public key. /// </summary> /// <param name="filePath">The file whose contents will be hashed.</param> /// <param name="signatureFilePath">The path of the signature file.</param> /// <param name="publicBlob">The public key.</param> /// <returns> True if the file is verified, otherwise false.</returns> public static bool VerifyFile(string filePath, string signatureFilePath, byte[] publicBlob) { if (publicBlob.Length == 0) { return(false); } bool verified = false; byte[] hash = null; try { // Compute a hash of the installer using (Stream fileStream = File.Open(filePath, FileMode.Open)) { SHA1 sha1 = new SHA1CryptoServiceProvider(); hash = sha1.ComputeHash(fileStream); } // Import the public key var dsa = new DSACryptoServiceProvider(); dsa.ImportCspBlob(publicBlob); var dsaDeformatter = new DSASignatureDeformatter(dsa); dsaDeformatter.SetHashAlgorithm("SHA1"); // Read the signature file byte[] signature = File.ReadAllBytes(signatureFilePath); // Verify the signature against the hash of the installer verified = dsaDeformatter.VerifySignature(hash, signature); Console.WriteLine("File verified: {0}", verified); } catch (Exception e) { Debug.WriteLine(e); return(false); } return(verified); }
public static void InvalidHashAlgorithm() { using (DSA dsa = DSAFactory.Create()) { var formatter = new DSASignatureFormatter(dsa); var deformatter = new DSASignatureDeformatter(dsa); // Unlike RSA, DSA will throw during SetHashAlgorithm Assert.Throws<CryptographicUnexpectedOperationException>(() => formatter.SetHashAlgorithm("INVALIDVALUE")); Assert.Throws<CryptographicUnexpectedOperationException>(() => deformatter.SetHashAlgorithm("INVALIDVALUE")); // Currently anything other than SHA1 fails Assert.Throws<CryptographicUnexpectedOperationException>(() => formatter.SetHashAlgorithm("SHA256")); Assert.Throws<CryptographicUnexpectedOperationException>(() => deformatter.SetHashAlgorithm("SHA256")); } }
public static void VerifyKnownSignature() { using (DSA dsa = DSAFactory.Create()) { byte[] data; byte[] signature; DSAParameters dsaParameters; DSATestData.GetDSA1024_186_2(out dsaParameters, out signature, out data); byte[] hash = SHA1.HashData(data); dsa.ImportParameters(dsaParameters); var deformatter = new DSASignatureDeformatter(dsa); deformatter.VerifySignature(hash, signature); // Negative case signature[signature.Length - 1] ^= 0xff; Assert.False(deformatter.VerifySignature(hash, signature)); } }
public static void InvalidHashAlgorithm() { using (DSA dsa = DSAFactory.Create()) { var formatter = new DSASignatureFormatter(dsa); var deformatter = new DSASignatureDeformatter(dsa); // Unlike RSA, DSA will throw during SetHashAlgorithm Assert.Throws <CryptographicUnexpectedOperationException>(() => formatter.SetHashAlgorithm("INVALIDVALUE")); Assert.Throws <CryptographicUnexpectedOperationException>(() => deformatter.SetHashAlgorithm("INVALIDVALUE")); // Currently anything other than SHA1 fails Assert.Throws <CryptographicUnexpectedOperationException>(() => formatter.SetHashAlgorithm("SHA256")); Assert.Throws <CryptographicUnexpectedOperationException>(() => deformatter.SetHashAlgorithm("SHA256")); } }
private bool DsaVerifyHash(byte[] hashValue, byte[] signedHashValue, DSAParameters dsaKey, string hashAlg) { var verified = false; try { using (var dsa = new DSACryptoServiceProvider()) { dsa.ImportParameters(dsaKey); var dsaDeformatter = new DSASignatureDeformatter(dsa); dsaDeformatter.SetHashAlgorithm(hashAlg); verified = dsaDeformatter.VerifySignature(hashValue, signedHashValue); } } catch (CryptographicException e) { MessageBox.Show(e.Message); } return(verified); }
private void BtnVerify_Click(object sender, EventArgs e) { DSASignatureDeformatter DSADeformatter = new DSASignatureDeformatter(DSAC); DSADeformatter.SetHashAlgorithm("SHA1"); SHA1Managed SHhash = new SHA1Managed(); if (DSADeformatter.VerifySignature(SHhash.ComputeHash(new UnicodeEncoding().GetBytes(textboxplaintext.Text)), Convert.FromBase64String(textboxsigned.Text)) ) { MessageBox.Show("The signature is valid."); /// The signature is valid. } else { MessageBox.Show("The signature is not valid."); /// The signature is not valid. } }
public static void VerifyKnownSignature() { using (DSA dsa = DSAFactory.Create()) { byte[] data; byte[] signature; DSAParameters dsaParameters; DSATestData.GetDSA1024_186_2(out dsaParameters, out signature, out data); byte[] hash; using (SHA1 alg = SHA1.Create()) { hash = alg.ComputeHash(data); } dsa.ImportParameters(dsaParameters); var deformatter = new DSASignatureDeformatter(dsa); deformatter.VerifySignature(hash, signature); // Negative case signature[signature.Length - 1] ^= 0xff; Assert.False(deformatter.VerifySignature(hash, signature)); } }