< Summary

Information
Class: AsiBackbone.Core.Signing.VerificationPolicyOutcome
Assembly: AsiBackbone.Core
File(s): /home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.Core/Signing/VerificationPolicyOutcome.cs
Line coverage
95%
Covered lines: 114
Uncovered lines: 5
Coverable lines: 119
Total lines: 276
Line coverage: 95.7%
Branch coverage
84%
Covered branches: 27
Total branches: 32
Branch coverage: 84.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%210%
.ctor(...)50%4495.12%
get_ShouldAllow()100%11100%
Create(...)100%11100%
CreateCore(...)100%22100%
BuildSafeMetadata(...)75%1212100%
AddIfPresent(...)100%22100%
IsSafeSigningMetadataKey(...)100%1010100%
NormalizeOptional(...)100%22100%

File(s)

/home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.Core/Signing/VerificationPolicyOutcome.cs

#LineLine coverage
 1using System.Collections.ObjectModel;
 2
 3namespace AsiBackbone.Core.Signing;
 4
 5/// <summary>
 6/// Represents the host-facing outcome of signature verification policy evaluation.
 7/// </summary>
 8public sealed class VerificationPolicyOutcome
 9{
 010    private static readonly IReadOnlyDictionary<string, string> EmptyMetadata =
 011        new ReadOnlyDictionary<string, string>(
 012            new Dictionary<string, string>(StringComparer.Ordinal));
 13
 12214    private VerificationPolicyOutcome(
 12215        bool isVerified,
 12216        SignatureVerificationCategory category,
 12217        VerificationPolicyAction action,
 12218        string status,
 12219        string? failureCode,
 12220        string? failureMessage,
 12221        string artifactType,
 12222        string artifactId,
 12223        string signingHash,
 12224        string hashAlgorithm,
 12225        string? keyId,
 12226        string? keyVersion,
 12227        string? signatureAlgorithm,
 12228        string? provider,
 12229        IReadOnlyDictionary<string, string> safeMetadata)
 30    {
 12231        ArgumentException.ThrowIfNullOrWhiteSpace(status);
 12232        ArgumentException.ThrowIfNullOrWhiteSpace(artifactType);
 12233        ArgumentException.ThrowIfNullOrWhiteSpace(artifactId);
 12234        ArgumentException.ThrowIfNullOrWhiteSpace(signingHash);
 12235        ArgumentException.ThrowIfNullOrWhiteSpace(hashAlgorithm);
 36
 12237        if (!Enum.IsDefined(category))
 38        {
 039            throw new ArgumentOutOfRangeException(nameof(category), category, "Verification category must be defined.");
 40        }
 41
 12242        if (!Enum.IsDefined(action))
 43        {
 044            throw new ArgumentOutOfRangeException(nameof(action), action, "Verification policy action must be defined.")
 45        }
 46
 12247        IsVerified = isVerified;
 12248        Category = category;
 12249        Action = action;
 12250        Status = status.Trim();
 12251        FailureCode = NormalizeOptional(failureCode);
 12252        FailureMessage = NormalizeOptional(failureMessage);
 12253        ArtifactType = artifactType.Trim();
 12254        ArtifactId = artifactId.Trim();
 12255        SigningHash = signingHash.Trim();
 12256        HashAlgorithm = hashAlgorithm.Trim();
 12257        KeyId = NormalizeOptional(keyId);
 12258        KeyVersion = NormalizeOptional(keyVersion);
 12259        SignatureAlgorithm = NormalizeOptional(signatureAlgorithm);
 12260        Provider = NormalizeOptional(provider);
 12261        SafeMetadata = safeMetadata;
 12262    }
 63
 64    /// <summary>
 65    /// Gets a value indicating whether verification succeeded.
 66    /// </summary>
 67    public bool IsVerified { get; }
 68
 69    /// <summary>
 70    /// Gets the provider-neutral verification category.
 71    /// </summary>
 72    public SignatureVerificationCategory Category { get; }
 73
 74    /// <summary>
 75    /// Gets the host-facing action selected by verification policy.
 76    /// </summary>
 77    public VerificationPolicyAction Action { get; }
 78
 79    /// <summary>
 80    /// Gets a value indicating whether the policy selected the allow action.
 81    /// </summary>
 10382    public bool ShouldAllow => Action is VerificationPolicyAction.Allow;
 83
 84    /// <summary>
 85    /// Gets the provider-neutral verification status.
 86    /// </summary>
 87    public string Status { get; }
 88
 89    /// <summary>
 90    /// Gets the provider-neutral failure code, when verification did not succeed.
 91    /// </summary>
 92    public string? FailureCode { get; }
 93
 94    /// <summary>
 95    /// Gets the provider-neutral failure message, when verification did not succeed.
 96    /// </summary>
 97    public string? FailureMessage { get; }
 98
 99    /// <summary>
 100    /// Gets the artifact type that was verified or evaluated.
 101    /// </summary>
 102    public string ArtifactType { get; }
 103
 104    /// <summary>
 105    /// Gets the artifact identifier that was verified or evaluated.
 106    /// </summary>
 107    public string ArtifactId { get; }
 108
 109    /// <summary>
 110    /// Gets the signing hash expected for verification.
 111    /// </summary>
 112    public string SigningHash { get; }
 113
 114    /// <summary>
 115    /// Gets the hash algorithm expected for verification.
 116    /// </summary>
 117    public string HashAlgorithm { get; }
 118
 119    /// <summary>
 120    /// Gets the signing key identifier, when supplied.
 121    /// </summary>
 122    public string? KeyId { get; }
 123
 124    /// <summary>
 125    /// Gets the signing key version, when supplied.
 126    /// </summary>
 127    public string? KeyVersion { get; }
 128
 129    /// <summary>
 130    /// Gets the signature algorithm descriptor, when supplied.
 131    /// </summary>
 132    public string? SignatureAlgorithm { get; }
 133
 134    /// <summary>
 135    /// Gets the signing provider descriptor, when supplied.
 136    /// </summary>
 137    public string? Provider { get; }
 138
 139    /// <summary>
 140    /// Gets safe-to-log verification metadata. Signature values and secrets are never included.
 141    /// </summary>
 142    public IReadOnlyDictionary<string, string> SafeMetadata { get; }
 143
 144    /// <summary>
 145    /// Creates a verification policy outcome.
 146    /// </summary>
 147    public static VerificationPolicyOutcome Create<TArtifact>(
 148        SignedGovernanceArtifact<TArtifact> artifact,
 149        SignatureVerificationResult verificationResult,
 150        VerificationPolicyOptions? options = null)
 151    {
 2152        ArgumentNullException.ThrowIfNull(artifact);
 153
 2154        return CreateCore(
 2155            artifact.ArtifactType,
 2156            artifact.ArtifactId,
 2157            artifact.SigningHash,
 2158            artifact.HashAlgorithm,
 2159            artifact.SigningMetadata,
 2160            verificationResult,
 2161            options);
 162    }
 163
 164    internal static VerificationPolicyOutcome CreateCore(
 165        string artifactType,
 166        string artifactId,
 167        string signingHash,
 168        string hashAlgorithm,
 169        SigningMetadata signingMetadata,
 170        SignatureVerificationResult verificationResult,
 171        VerificationPolicyOptions? options = null)
 172    {
 122173        ArgumentNullException.ThrowIfNull(signingMetadata);
 122174        ArgumentNullException.ThrowIfNull(verificationResult);
 175
 122176        VerificationPolicyOptions effectiveOptions = options ?? VerificationPolicyOptions.Default;
 122177        SignatureVerificationCategory category = VerificationPolicyEvaluator.Categorize(verificationResult);
 122178        VerificationPolicyAction action = effectiveOptions.GetAction(category);
 122179        IReadOnlyDictionary<string, string> safeMetadata = BuildSafeMetadata(
 122180            artifactType,
 122181            artifactId,
 122182            signingHash,
 122183            hashAlgorithm,
 122184            signingMetadata,
 122185            verificationResult,
 122186            category,
 122187            action);
 188
 122189        return new VerificationPolicyOutcome(
 122190            verificationResult.IsValid,
 122191            category,
 122192            action,
 122193            verificationResult.Status,
 122194            verificationResult.FailureCode,
 122195            verificationResult.FailureMessage,
 122196            artifactType,
 122197            artifactId,
 122198            signingHash,
 122199            hashAlgorithm,
 122200            signingMetadata.KeyId,
 122201            signingMetadata.KeyVersion,
 122202            signingMetadata.SignatureAlgorithm,
 122203            signingMetadata.Provider,
 122204            safeMetadata);
 205    }
 206
 207    private static IReadOnlyDictionary<string, string> BuildSafeMetadata(
 208        string artifactType,
 209        string artifactId,
 210        string signingHash,
 211        string hashAlgorithm,
 212        SigningMetadata signingMetadata,
 213        SignatureVerificationResult verificationResult,
 214        SignatureVerificationCategory category,
 215        VerificationPolicyAction action)
 216    {
 122217        Dictionary<string, string> metadata = new(StringComparer.Ordinal)
 122218        {
 122219            ["artifact_id"] = artifactId,
 122220            ["artifact_type"] = artifactType,
 122221            ["category"] = category.ToString(),
 122222            ["hash_algorithm"] = hashAlgorithm,
 122223            ["policy_action"] = action.ToString(),
 122224            ["signing_hash"] = signingHash,
 122225            ["status"] = verificationResult.Status
 122226        };
 227
 122228        AddIfPresent(metadata, "failure_code", verificationResult.FailureCode);
 122229        AddIfPresent(metadata, "key_id", signingMetadata.KeyId);
 122230        AddIfPresent(metadata, "key_version", signingMetadata.KeyVersion);
 122231        AddIfPresent(metadata, "provider", signingMetadata.Provider);
 122232        AddIfPresent(metadata, "signature_algorithm", signingMetadata.SignatureAlgorithm);
 233
 122234        if (signingMetadata.SignedUtc.HasValue)
 235        {
 118236            metadata["signed_utc"] = signingMetadata.SignedUtc.Value.ToString("O", System.Globalization.CultureInfo.Inva
 237        }
 238
 1378239        foreach (KeyValuePair<string, string> item in signingMetadata.Metadata)
 240        {
 567241            if (IsSafeSigningMetadataKey(item.Key))
 242            {
 562243                metadata[item.Key.Trim()] = item.Value?.Trim() ?? string.Empty;
 244            }
 245        }
 246
 122247        return metadata.Count == 0
 122248            ? EmptyMetadata
 122249            : new ReadOnlyDictionary<string, string>(metadata);
 250    }
 251
 252    private static void AddIfPresent(Dictionary<string, string> metadata, string key, string? value)
 253    {
 610254        if (!string.IsNullOrWhiteSpace(value))
 255        {
 536256            metadata[key] = value.Trim();
 257        }
 610258    }
 259
 260    private static bool IsSafeSigningMetadataKey(string key)
 261    {
 567262        return !string.IsNullOrWhiteSpace(key)
 567263            && !key.Contains("signature", StringComparison.OrdinalIgnoreCase)
 567264            && !key.Contains("secret", StringComparison.OrdinalIgnoreCase)
 567265            && !key.Contains("token", StringComparison.OrdinalIgnoreCase)
 567266            && !key.Contains("credential", StringComparison.OrdinalIgnoreCase)
 567267            && !key.Contains("private", StringComparison.OrdinalIgnoreCase);
 268    }
 269
 270    private static string? NormalizeOptional(string? value)
 271    {
 732272        return string.IsNullOrWhiteSpace(value)
 732273            ? null
 732274            : value.Trim();
 275    }
 276}