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;
}
