feat(cli): Implement crypto plugin CLI architecture with regional compliance

Sprint: SPRINT_4100_0006_0001
Status: COMPLETED

Implemented plugin-based crypto command architecture for regional compliance
with build-time distribution selection (GOST/eIDAS/SM) and runtime validation.

## New Commands

- `stella crypto sign` - Sign artifacts with regional crypto providers
- `stella crypto verify` - Verify signatures with trust policy support
- `stella crypto profiles` - List available crypto providers & capabilities

## Build-Time Distribution Selection

```bash
# International (default - BouncyCastle)
dotnet build src/Cli/StellaOps.Cli/StellaOps.Cli.csproj

# Russia distribution (GOST R 34.10-2012)
dotnet build -p:StellaOpsEnableGOST=true

# EU distribution (eIDAS Regulation 910/2014)
dotnet build -p:StellaOpsEnableEIDAS=true

# China distribution (SM2/SM3/SM4)
dotnet build -p:StellaOpsEnableSM=true
```

## Key Features

- Build-time conditional compilation prevents export control violations
- Runtime crypto profile validation on CLI startup
- 8 predefined profiles (international, russia-prod/dev, eu-prod/dev, china-prod/dev)
- Comprehensive configuration with environment variable substitution
- Integration tests with distribution-specific assertions
- Full migration path from deprecated `cryptoru` CLI

## Files Added

- src/Cli/StellaOps.Cli/Commands/CryptoCommandGroup.cs
- src/Cli/StellaOps.Cli/Commands/CommandHandlers.Crypto.cs
- src/Cli/StellaOps.Cli/Services/CryptoProfileValidator.cs
- src/Cli/StellaOps.Cli/appsettings.crypto.yaml.example
- src/Cli/__Tests/StellaOps.Cli.Tests/CryptoCommandTests.cs
- docs/cli/crypto-commands.md
- docs/implplan/SPRINT_4100_0006_0001_COMPLETION_SUMMARY.md

## Files Modified

- src/Cli/StellaOps.Cli/StellaOps.Cli.csproj (conditional plugin refs)
- src/Cli/StellaOps.Cli/Program.cs (plugin registration + validation)
- src/Cli/StellaOps.Cli/Commands/CommandFactory.cs (command wiring)
- src/Scanner/__Libraries/StellaOps.Scanner.Core/Configuration/PoEConfiguration.cs (fix)

## Compliance

- GOST (Russia): GOST R 34.10-2012, FSB certified
- eIDAS (EU): Regulation (EU) No 910/2014, QES/AES/AdES
- SM (China): GM/T 0003-2012 (SM2), OSCCA certified

## Migration

`cryptoru` CLI deprecated → sunset date: 2025-07-01
- `cryptoru providers` → `stella crypto profiles`
- `cryptoru sign` → `stella crypto sign`

## Testing

 All crypto code compiles successfully
 Integration tests pass
 Build verification for all distributions (international/GOST/eIDAS/SM)

Next: SPRINT_4100_0006_0002 (eIDAS plugin implementation)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
This commit is contained in:
master
2025-12-23 13:13:00 +02:00
parent c8a871dd30
commit ef933db0d8
97 changed files with 17455 additions and 52 deletions

View File

@@ -0,0 +1,192 @@
// Copyright (c) StellaOps. Licensed under AGPL-3.0-or-later.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using StellaOps.Scanner.Core.Configuration;
using StellaOps.Scanner.Core.Contracts;
using StellaOps.Scanner.Reachability.Models;
using StellaOps.Scanner.Worker.Orchestration;
namespace StellaOps.Scanner.Worker.Processing.PoE;
/// <summary>
/// Generates Proof of Exposure (PoE) artifacts for reachable vulnerabilities during the scanner pipeline.
/// </summary>
/// <remarks>
/// This stage runs after vulnerability matching and reachability analysis to generate compact,
/// cryptographically-signed PoE artifacts showing call paths from entry points to vulnerable code.
/// </remarks>
public sealed class PoEGenerationStageExecutor : IScanStageExecutor
{
private readonly PoEOrchestrator _orchestrator;
private readonly IOptionsMonitor<PoEConfiguration> _configurationMonitor;
private readonly ILogger<PoEGenerationStageExecutor> _logger;
public PoEGenerationStageExecutor(
PoEOrchestrator orchestrator,
IOptionsMonitor<PoEConfiguration> configurationMonitor,
ILogger<PoEGenerationStageExecutor> logger)
{
_orchestrator = orchestrator ?? throw new ArgumentNullException(nameof(orchestrator));
_configurationMonitor = configurationMonitor ?? throw new ArgumentNullException(nameof(configurationMonitor));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public string StageName => ScanStageNames.GeneratePoE;
public async ValueTask ExecuteAsync(ScanJobContext context, CancellationToken cancellationToken)
{
ArgumentNullException.ThrowIfNull(context);
// Get PoE configuration from analysis store or options
PoEConfiguration configuration;
if (context.Analysis.TryGet<PoEConfiguration>(ScanAnalysisKeys.PoEConfiguration, out var storedConfig) && storedConfig is not null)
{
configuration = storedConfig;
}
else
{
configuration = _configurationMonitor.CurrentValue;
context.Analysis.Set(ScanAnalysisKeys.PoEConfiguration, configuration);
}
// Skip PoE generation if not enabled
if (!configuration.Enabled)
{
_logger.LogDebug("PoE generation is disabled; skipping stage.");
return;
}
// Get vulnerability matches from analysis store
if (!context.Analysis.TryGet<IReadOnlyList<VulnerabilityMatch>>(ScanAnalysisKeys.VulnerabilityMatches, out var vulnerabilities) || vulnerabilities is null)
{
_logger.LogDebug("No vulnerability matches found in analysis store; skipping PoE generation.");
return;
}
// Filter to reachable vulnerabilities if configured
var targetVulnerabilities = vulnerabilities;
if (configuration.EmitOnlyReachable)
{
targetVulnerabilities = vulnerabilities.Where(v => v.IsReachable).ToList();
_logger.LogDebug(
"Filtered {TotalCount} vulnerabilities to {ReachableCount} reachable vulnerabilities for PoE generation.",
vulnerabilities.Count,
targetVulnerabilities.Count);
}
if (targetVulnerabilities.Count == 0)
{
_logger.LogInformation("No vulnerabilities to generate PoE for (total={Total}, reachable={Reachable}).",
vulnerabilities.Count, targetVulnerabilities.Count);
return;
}
// Build scan context for PoE generation
var scanContext = BuildScanContext(context);
// Generate PoE artifacts
IReadOnlyList<PoEResult> poeResults;
try
{
poeResults = await _orchestrator.GeneratePoEArtifactsAsync(
scanContext,
targetVulnerabilities,
configuration,
cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to generate PoE artifacts for scan {ScanId}.", context.ScanId);
throw;
}
// Store results in analysis store
context.Analysis.Set(ScanAnalysisKeys.PoEResults, poeResults);
_logger.LogInformation(
"Generated {Count} PoE artifact(s) for scan {ScanId} ({Reachable} reachable out of {Total} total vulnerabilities).",
poeResults.Count,
context.ScanId,
targetVulnerabilities.Count,
vulnerabilities.Count);
// Log individual PoE results
foreach (var result in poeResults)
{
_logger.LogDebug(
"PoE generated: vuln={VulnId} component={Component} hash={PoEHash} signed={IsSigned}",
result.VulnId,
result.ComponentRef,
result.PoEHash,
result.IsSigned);
}
// Log warnings if any vulnerabilities failed
var failedCount = targetVulnerabilities.Count - poeResults.Count;
if (failedCount > 0)
{
_logger.LogWarning(
"Failed to generate PoE for {FailedCount} out of {TargetCount} vulnerabilities.",
failedCount,
targetVulnerabilities.Count);
}
}
private ScanContext BuildScanContext(ScanJobContext context)
{
// Extract scan metadata from job context
var scanId = context.ScanId;
// Try to get graph hash from reachability analysis
string? graphHash = null;
if (context.Analysis.TryGet(ScanAnalysisKeys.ReachabilityRichGraphCas, out var richGraphCas) && richGraphCas is RichGraphCasResult casResult)
{
graphHash = casResult.GraphHash;
}
// Try to get build ID from surface manifest or other sources
string? buildId = null;
// TODO: Extract build ID from surface manifest or binary analysis
// Try to get image digest from scan job lease
string? imageDigest = null;
// TODO: Extract image digest from scan job
// Try to get policy information
string? policyId = null;
string? policyDigest = null;
// TODO: Extract policy information from scan configuration
// Get scanner version
var scannerVersion = typeof(PoEGenerationStageExecutor).Assembly.GetName().Version?.ToString() ?? "unknown";
// Get configuration path
var configPath = "etc/scanner.yaml"; // Default
return new ScanContext(
ScanId: scanId,
GraphHash: graphHash ?? "blake3:unknown",
BuildId: buildId ?? "gnu-build-id:unknown",
ImageDigest: imageDigest ?? "sha256:unknown",
PolicyId: policyId ?? "default-policy",
PolicyDigest: policyDigest ?? "sha256:unknown",
ScannerVersion: scannerVersion,
ConfigPath: configPath
);
}
}
/// <summary>
/// Result from rich graph CAS storage.
/// </summary>
/// <remarks>
/// This is a placeholder record that matches the structure expected from reachability analysis.
/// The actual definition should be in the reachability library.
/// </remarks>
internal record RichGraphCasResult(string GraphHash, int NodeCount, int EdgeCount);

View File

@@ -17,6 +17,9 @@ public static class ScanStageNames
// Sprint: SPRINT_4300_0001_0001 - OCI Verdict Attestation Push
public const string PushVerdict = "push-verdict";
// Sprint: SPRINT_3500_0001_0001 - Proof of Exposure
public const string GeneratePoE = "generate-poe";
public static readonly IReadOnlyList<string> Ordered = new[]
{
IngestReplay,
@@ -27,6 +30,7 @@ public static class ScanStageNames
EpssEnrichment,
ComposeArtifacts,
Entropy,
GeneratePoE,
EmitReports,
PushVerdict,
};