public async Task <bool> VerifyAsync(byte[] digest, string signature, string algorithm, CancellationToken token) { this.EnsureNotDisposed(); if (digest == null || !digest.Any()) { throw new ArgumentException("digest"); } BasicHasher.ValidateDigestLength(algorithm, digest); var verifier = new Signing.Verifier(_rsa); var hex = digest.ToHexString(); var res = await Task.FromResult(verifier.VerifyHash(hex, signature, algorithm)); //var res = await Task.FromResult(verifier.VerifyHash(digest, signature, algorithm)); if (!res) { // legacy code used a double digest hash, so hash once more and check var hashBytesLegacy = BasicHasher.GetHashBytes(digest, algorithm); res = await Task.FromResult(verifier.VerifyHash(digest, signature, algorithm)); return(res); } return(res); }
public async Task <bool> VerifyAsync(string hex, string signature, CancellationToken token) { this.EnsureNotDisposed(); string algorithm = BasicHasher.GetNormalAlgorithm(hex); var verifier = new Signing.Verifier(_rsa); var res = await Task.FromResult(verifier.VerifyHash(hex, signature, algorithm)); if (!res) { // legacy code used a double digest hash, so hash once more and check var hashHexLegacy = BasicHasher.GetHash(hex, algorithm); res = await Task.FromResult(verifier.VerifyHash(hashHexLegacy, signature, algorithm)); return(res); } return(res); }
/// <summary> /// Verifies the byte array against a signature. /// </summary> /// <param name="digest"></param> /// <param name="signature"></param> /// <param name="algorithm"></param> /// <param name="token"></param> /// <returns></returns> public async Task <bool> VerifyAsync(byte[] digest, byte[] signature, string algorithm, CancellationToken token) { this.EnsureNotDisposed(); if (digest == null || !digest.Any()) { throw new ArgumentException("digest"); } if (algorithm == null) { throw new ArgumentNullException("algorithm"); } var verifier = new Signing.Verifier(_rsa); //var hash = BasicHasher.GetHash(digest, algorithm); return(await Task.FromResult(verifier.VerifyHash(digest, signature, algorithm))); }
/// <summary> /// Verifies the byte array against a signature. /// </summary> /// <param name="digest"></param> /// <param name="signature"></param> /// <param name="algorithm"></param> /// <param name="token"></param> /// <returns></returns> public async Task<bool> VerifyAsync(byte[] digest, byte[] signature, string algorithm, CancellationToken token) { this.EnsureNotDisposed(); if (digest == null || !digest.Any()) { throw new ArgumentException("digest"); } if (algorithm == null) { throw new ArgumentNullException("algorithm"); } var verifier = new Signing.Verifier(_rsa); //var hash = BasicHasher.GetHash(digest, algorithm); return await Task.FromResult(verifier.VerifyHash(digest, signature, algorithm)); }
public async Task<bool> VerifyAsync(string hex, string signature, CancellationToken token) { this.EnsureNotDisposed(); string algorithm = BasicHasher.GetNormalAlgorithm(hex); var verifier = new Signing.Verifier(_rsa); var res = await Task.FromResult(verifier.VerifyHash(hex, signature, algorithm)); if (!res) { // legacy code used a double digest hash, so hash once more and check var hashHexLegacy = BasicHasher.GetHash(hex, algorithm); res = await Task.FromResult(verifier.VerifyHash(hashHexLegacy, signature, algorithm)); return res; } return res; }
public async Task<bool> VerifyAsync(byte[] digest, string signature, string algorithm, CancellationToken token) { this.EnsureNotDisposed(); if (digest == null || !digest.Any()) { throw new ArgumentException("digest"); } BasicHasher.ValidateDigestLength(algorithm, digest); var verifier = new Signing.Verifier(_rsa); var hex = digest.ToHexString(); var res = await Task.FromResult(verifier.VerifyHash(hex, signature, algorithm)); //var res = await Task.FromResult(verifier.VerifyHash(digest, signature, algorithm)); if (!res) { // legacy code used a double digest hash, so hash once more and check var hashBytesLegacy = BasicHasher.GetHashBytes(digest, algorithm); res = await Task.FromResult(verifier.VerifyHash(digest, signature, algorithm)); return res; } return res; }