< Summary

Information
Class: AsiBackbone.Signing.ManagedKey.PublicKeySignatureVerificationService
Assembly: AsiBackbone.Signing.ManagedKey
File(s): /home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.Signing.ManagedKey/PublicKeySignatureVerificationService.cs
Line coverage
67%
Covered lines: 51
Uncovered lines: 25
Coverable lines: 76
Total lines: 166
Line coverage: 67.1%
Branch coverage
68%
Covered branches: 22
Total branches: 32
Branch coverage: 68.7%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
VerifyAsync()67.86%1062853.7%
Verify(...)100%22100%
FixedTimeEquals(...)50%22100%
Fail(...)100%11100%

File(s)

/home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.Signing.ManagedKey/PublicKeySignatureVerificationService.cs

#LineLine coverage
 1using System.Security.Cryptography;
 2using System.Text;
 3using AsiBackbone.Core.Signing;
 4
 5namespace AsiBackbone.Signing.ManagedKey;
 6
 7/// <summary>Verifies governance signatures with trusted public keys only.</summary>
 8public sealed class PublicKeySignatureVerificationService : IGovernanceSignatureVerificationService
 9{
 10    private readonly KeySignatureVerificationOptions options;
 11    private readonly IGovernanceVerificationKeyResolver resolver;
 12
 13    /// <summary>Initializes a public-key verifier.</summary>
 514    public PublicKeySignatureVerificationService(
 515        KeySignatureVerificationOptions options,
 516        IGovernanceVerificationKeyResolver resolver)
 17    {
 518        ArgumentNullException.ThrowIfNull(options);
 519        ArgumentNullException.ThrowIfNull(resolver);
 520        options.Validate();
 521        this.options = options;
 522        this.resolver = resolver;
 523    }
 24
 25    /// <inheritdoc />
 26    public async ValueTask<SignatureVerificationResult> VerifyAsync(
 27        SignatureVerificationRequest request,
 28        CancellationToken cancellationToken = default)
 29    {
 830        ArgumentNullException.ThrowIfNull(request);
 831        cancellationToken.ThrowIfCancellationRequested();
 32
 833        SigningMetadata metadata = request.SigningMetadata;
 834        if (!metadata.HasSignature)
 35        {
 036            return SignatureVerificationResult.MissingSignature();
 37        }
 38
 839        if (metadata.SigningHash is null || !FixedTimeEquals(request.SigningHash, metadata.SigningHash))
 40        {
 041            return Fail("signature.hash-mismatch", SignatureVerificationCategory.HashMismatch);
 42        }
 43
 844        if (request.UsesLegacySignatureInput && !options.AllowLegacySignatureInput)
 45        {
 046            return Fail("signature.legacy-input-not-allowed", SignatureVerificationCategory.UntrustedSigningContext);
 47        }
 48
 849        if (metadata.SignatureAlgorithm is null || !options.AllowedAlgorithms.Contains(metadata.SignatureAlgorithm))
 50        {
 151            return Fail("signature.algorithm-unsupported", SignatureVerificationCategory.UnsupportedAlgorithm);
 52        }
 53
 754        if (metadata.KeyId is null)
 55        {
 056            return Fail("signature.key-unknown", SignatureVerificationCategory.UnknownKeyVersion);
 57        }
 58
 759        if (metadata.KeyVersion is null)
 60        {
 061            return Fail("signature.key-version-unknown", SignatureVerificationCategory.UnknownKeyVersion);
 62        }
 63
 64        GovernanceVerificationKey? key;
 65        try
 66        {
 767            key = await resolver.ResolveAsync(metadata.KeyId, metadata.KeyVersion, cancellationToken).ConfigureAwait(fal
 768        }
 069        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
 70        {
 071            throw;
 72        }
 073        catch (Exception exception) when (exception is InvalidOperationException or TimeoutException)
 74        {
 075            return SignatureVerificationResult.Failed(
 076                "signature.key-provider-unavailable",
 077                SignatureVerificationCategory.ProviderUnavailable,
 078                "The verification key resolver could not answer the request.");
 79        }
 80
 781        if (key is null)
 82        {
 83            bool knownKey;
 84            try
 85            {
 286                knownKey = await resolver.IsKnownKeyAsync(metadata.KeyId, cancellationToken).ConfigureAwait(false);
 287            }
 088            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
 89            {
 090                throw;
 91            }
 092            catch (Exception exception) when (exception is InvalidOperationException or TimeoutException)
 93            {
 094                return SignatureVerificationResult.Failed(
 095                    "signature.key-provider-unavailable",
 096                    SignatureVerificationCategory.ProviderUnavailable,
 097                    "The verification key resolver could not answer the request.");
 98            }
 99
 2100            return Fail(
 2101                knownKey ? "signature.key-version-unknown" : "signature.key-unknown",
 2102                SignatureVerificationCategory.UnknownKeyVersion);
 103        }
 104
 5105        if (key.IsRevoked)
 106        {
 1107            return Fail("signature.key-revoked", SignatureVerificationCategory.RevokedKey);
 108        }
 109
 4110        if (!string.Equals(key.SignatureAlgorithm, metadata.SignatureAlgorithm, StringComparison.Ordinal))
 111        {
 0112            return Fail("signature.algorithm-unsupported", SignatureVerificationCategory.UnsupportedAlgorithm);
 113        }
 114
 115        byte[] signature;
 116        try
 117        {
 4118            signature = Convert.FromBase64String(metadata.Signature!);
 4119        }
 0120        catch (FormatException)
 121        {
 0122            return Fail("signature.invalid", SignatureVerificationCategory.InvalidSignature);
 123        }
 124
 125        bool verified;
 126        try
 127        {
 4128            verified = Verify(key, request.SignatureInput.Span, signature);
 4129        }
 0130        catch (CryptographicException)
 131        {
 0132            verified = false;
 0133        }
 134
 4135        return verified
 4136            ? SignatureVerificationResult.Verified()
 4137            : Fail("signature.invalid", SignatureVerificationCategory.InvalidSignature);
 8138    }
 139
 140    private static bool Verify(GovernanceVerificationKey key, ReadOnlySpan<byte> input, ReadOnlySpan<byte> signature)
 141    {
 4142        if (key.SignatureAlgorithm == ManagedKeySignatureAlgorithms.RsaPssSha256)
 143        {
 3144            using var rsa = RSA.Create();
 3145            rsa.ImportSubjectPublicKeyInfo(key.SubjectPublicKeyInfo, out _);
 3146            return rsa.VerifyData(input, signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pss);
 147        }
 148
 1149        using var ecdsa = ECDsa.Create();
 1150        ecdsa.ImportSubjectPublicKeyInfo(key.SubjectPublicKeyInfo, out _);
 1151        return ecdsa.VerifyData(input, signature, HashAlgorithmName.SHA256);
 4152    }
 153
 154    private static bool FixedTimeEquals(string left, string right)
 155    {
 8156        byte[] leftBytes = Encoding.UTF8.GetBytes(left);
 8157        byte[] rightBytes = Encoding.UTF8.GetBytes(right);
 8158        return leftBytes.Length == rightBytes.Length
 8159            && CryptographicOperations.FixedTimeEquals(leftBytes, rightBytes);
 160    }
 161
 162    private static SignatureVerificationResult Fail(string code, SignatureVerificationCategory category)
 163    {
 4164        return SignatureVerificationResult.Failed(code, category);
 165    }
 166}