using System.Globalization; using System.Text.Json; using Spectre.Console; using ZB.MOM.WW.Secrets.Abstractions; using ZB.MOM.WW.Secrets.MasterKey; namespace ZB.MOM.WW.Secrets.Cli.Interactive.Flows; /// /// Imports a ciphertext-only into the session's store. The bundle is read and /// parsed before any write so its can be inspected: when it /// differs from the session KEK the operator is asked to supply the source key (paste / env var / key /// file) so the rows can be re-wrapped under the session KEK on import — otherwise foreign-KEK rows are /// skipped and reported. The operator may opt into a per-conflict prompt (default off = pure /// last-writer-wins); when on, each name collision renders both rows' timestamp/revision and asks whether /// to take the bundle row. A tally table (Imported / Skipped / Conflicts) closes the flow. Requires a /// KEK-capable session (the shell upgrades a degraded session before dispatch); a pasted key is masked. /// public sealed class BundleImportFlow : IInteractiveFlow { private const string PasteKeyLabel = "Paste base64 key"; private const string EnvVarLabel = "Environment variable"; private const string KeyFileLabel = "Key file path"; private const string CancelLabel = "Cancel"; /// public string Title => "Import bundle"; /// public bool RequiresKek => true; /// public async Task RunAsync(IAnsiConsole console, SecretsSession session, CancellationToken ct) { ArgumentNullException.ThrowIfNull(console); ArgumentNullException.ThrowIfNull(session); string sessionKekId = session.MasterKey?.KekId ?? throw new InvalidOperationException("flow requires an unlocked KEK session"); string path = console.Prompt(new TextPrompt("Bundle [green]path[/]:")); if (!File.Exists(path)) { console.MarkupLineInterpolated($"[red]No bundle found at '{path}'.[/]"); return; } // Read + parse FIRST so the format version and source KEK can be inspected before any write — // or any prompting — is attempted. SecretBundle bundle; try { string json = await File.ReadAllTextAsync(path, ct).ConfigureAwait(false); bundle = SecretBundleCodec.Deserialize(json); } catch (Exception ex) when (ex is InvalidOperationException or JsonException or IOException or UnauthorizedAccessException) { console.MarkupLineInterpolated($"[red]Could not read bundle '{path}': {ex.Message}[/]"); return; } // Format gate up front: reject an unreadable version before consuming any operator input. The // service applies the same gate as defense-in-depth, but failing here keeps the flow honest. if (bundle.FormatVersion != SecretBundle.CurrentFormatVersion) { console.MarkupLineInterpolated( $"[red]Bundle '{path}' has unsupported format version {bundle.FormatVersion}; this build supports version {SecretBundle.CurrentFormatVersion}.[/]"); return; } // Foreign-KEK detection: a bundle exported under another KEK must be re-wrapped, which needs the // source key. Prompt for it up front; without it every row would be skipped as foreign-KEK. IMasterKeyProvider? sourceKek = null; if (!string.Equals(bundle.SourceKekId, sessionKekId, StringComparison.Ordinal)) { console.MarkupLineInterpolated( $"[yellow]This bundle was exported under KEK '{bundle.SourceKekId}', but this session uses '{sessionKekId}'.[/]"); console.MarkupLine( "Supply the bundle's source key so its rows can be re-wrapped under this session's KEK."); sourceKek = PromptSourceKey(console); if (sourceKek is null) { console.MarkupLine("[yellow]Import cancelled.[/]"); return; } // The first KekId read is where an env/file source actually resolves the key: it lazily throws // MasterKeyUnavailableException (an unset var, a missing file) or, for a file source, a raw // IOException/UnauthorizedAccessException straight out of File.ReadAllBytes (e.g. a // permission-denied key file), since FileMasterKeyProvider does not wrap those. All must render // a friendly line and return here — not escape to the shell. string sourceKekId; try { sourceKekId = sourceKek.KekId; } catch (Exception ex) when (ex is MasterKeyUnavailableException or IOException or UnauthorizedAccessException) { console.MarkupLineInterpolated($"[red]Source KEK unavailable:[/] {ex.Message}"); return; } // A valid-but-wrong key would otherwise silently land every row in SkippedForeignKek. Verify // the supplied key actually derives the bundle's source KEK id before importing. if (!string.Equals(sourceKekId, bundle.SourceKekId, StringComparison.Ordinal)) { console.MarkupLineInterpolated( $"[red]That key does not match this bundle's source KEK ('{bundle.SourceKekId}' expected, got '{sourceKekId}').[/]"); return; } } bool perConflict = console.Prompt( new ConfirmationPrompt("Prompt per conflict? [grey](otherwise last-writer-wins)[/]") { DefaultValue = false, }); Func? conflictOverride = perConflict ? (existing, incoming) => PromptConflict(console, existing, incoming) : null; BundleImportReport report; try { report = await new BundleService() .ImportAsync(session, path, sourceKek, conflictOverride, ct).ConfigureAwait(false); } catch (InvalidOperationException ex) { console.MarkupLineInterpolated($"[red]Import failed: {ex.Message}[/]"); return; } RenderReport(console, report, bundle.SourceKekId); } // Builds the source-KEK provider the operator selects: a pasted base64 key (masked), an environment // variable, or a key file. Cancel (or a bad key) returns null and the caller aborts the import. private static IMasterKeyProvider? PromptSourceKey(IAnsiConsole console) { string choice; try { choice = console.Prompt(new SelectionPrompt() .Title("Provide the bundle's source key") .AddChoices(PasteKeyLabel, EnvVarLabel, KeyFileLabel, CancelLabel)); } catch (OperationCanceledException) { return null; } if (choice == CancelLabel) { return null; } try { switch (choice) { case PasteKeyLabel: string base64 = console.Prompt(new TextPrompt("Paste base64 source KEK:").Secret()); return new LiteralMasterKeyProvider(base64); case EnvVarLabel: string envVar = console.Prompt(new TextPrompt("Source-key environment variable name:")); return MasterKeyProviderFactory.Create(new MasterKeyOptions { Source = MasterKeySource.Environment, EnvVarName = envVar, }); default: string filePath = console.Prompt(new TextPrompt("Source-key file path:")); return MasterKeyProviderFactory.Create(new MasterKeyOptions { Source = MasterKeySource.File, FilePath = filePath, }); } } catch (ArgumentException ex) { // LiteralMasterKeyProvider rejects a bad paste eagerly; name the problem and abort. console.MarkupLineInterpolated($"[red]Invalid source key: {ex.Message}[/]"); return null; } } // Renders a name collision — both rows' last-update timestamp and revision — and asks the operator // whether to take the incoming bundle row (true) or keep the local one (false). private static bool PromptConflict(IAnsiConsole console, StoredSecret existing, StoredSecret incoming) { console.MarkupLineInterpolated($"[yellow]Conflict on '{incoming.Name.Value}':[/]"); console.MarkupLineInterpolated( $" local: updated {existing.UpdatedUtc.ToString("O", CultureInfo.InvariantCulture)} revision {existing.Revision}"); console.MarkupLineInterpolated( $" bundle: updated {incoming.UpdatedUtc.ToString("O", CultureInfo.InvariantCulture)} revision {incoming.Revision}"); return console.Prompt(new ConfirmationPrompt(" Take the bundle row?") { DefaultValue = false }); } // A compact tally table of the import outcome. When rows were skipped as foreign-KEK, the bundle's // source KEK id is appended so a wrong-key paste is self-diagnosable from the report alone. private static void RenderReport(IAnsiConsole console, BundleImportReport report, string sourceKekId) { var table = new Table() .AddColumn("Result") .AddColumn("Rows"); string foreign = report.SkippedForeignKek.ToString(CultureInfo.InvariantCulture); if (report.SkippedForeignKek > 0) { foreign += $" (source KEK {Markup.Escape(sourceKekId)})"; } table.AddRow("Imported", report.Imported.ToString(CultureInfo.InvariantCulture)); table.AddRow("Skipped (older)", report.SkippedOlder.ToString(CultureInfo.InvariantCulture)); table.AddRow("Skipped (foreign KEK)", foreign); table.AddRow("Conflicts", report.Conflicts.ToString(CultureInfo.InvariantCulture)); console.Write(table); } }