using Grpc.Core; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Options; using ZB.MOM.WW.Secrets.Abstractions; using ZB.MOM.WW.Secrets.Replicator.Grpc.V1; using ZB.MOM.WW.Secrets.Replicator.Grpc.Wire; namespace ZB.MOM.WW.Secrets.Replicator.Grpc; /// /// The central-hosted secrets hub: adapts the node's own onto the /// secrets_hub.v1 contract so site nodes can pull from it. /// /// /// /// Read-only by construction. It touches exactly two store members — /// and — mirroring /// the read half of ISecretReplicationHub. The proto exposes no write RPC, so there is no /// path by which a follower can put a row into central, whatever its credentials allow. /// /// /// Everything it returns is ciphertext or metadata about ciphertext. The KEK never travels: a row /// carries the KEK's identifier and the DEK wrapped by it, and every node in a replicating /// deployment is configured with the same KEK out of band. /// /// public sealed class SecretsHubService : SecretsHub.SecretsHubBase { private readonly ISecretStore _store; private readonly ILogger _logger; private readonly int _maxNamesPerRequest; /// Creates the hub service over the node's secret store. /// The store to serve. Only its read members are used. /// The hub options, read for the per-request name cap. /// Diagnostics sink. public SecretsHubService( ISecretStore store, IOptions options, ILogger logger) { ArgumentNullException.ThrowIfNull(options); _store = store ?? throw new ArgumentNullException(nameof(store)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); // The registration extension validates the cap, so a non-positive value here means the // options were built some other way. Falling back to the default is the safe direction: the // alternative reading of "0" is a hub with no cap at all, which is the thing the cap exists // to prevent. int configured = options.Value.MaxNamesPerRequest; _maxNamesPerRequest = configured > 0 ? configured : SecretsGrpcHubServerOptions.DefaultMaxNamesPerRequest; } /// /// Returns the hub's full manifest, tombstones included — a follower converges on a /// delete by seeing the tombstone, so omitting them would make deletes unpropagatable. /// /// The (empty) manifest request. /// The call context. /// Every manifest entry the store holds. public override async Task GetManifest( GetManifestRequest request, ServerCallContext context) { ArgumentNullException.ThrowIfNull(context); IReadOnlyList entries = await _store.GetManifestAsync(context.CancellationToken).ConfigureAwait(false); var response = new GetManifestResponse(); foreach (SecretManifestEntry entry in entries) { response.Entries.Add(DomainToWire.ToWire(entry)); } _logger.LogDebug("Secrets hub served a manifest of {EntryCount} entries.", response.Entries.Count); return response; } /// /// Fetches the named encrypted rows in bulk. /// /// /// /// A requested name the hub does not hold is omitted from the response, and an unparseable /// name is skipped — neither is an error. Both describe the same ordinary situation: the /// follower is acting on a manifest that was true a moment ago. Failing the whole call would turn /// a routine race into a stalled sweep, and would let one bad name deny the follower every other /// row in the batch. /// /// /// A request carrying more than /// names is refused, before any read runs. That is not the stale-manifest case: it is a /// caller asking the hub to walk its store an unbounded number of times inside one call, and the /// server declines independently of whatever chunking the client believes it is doing. /// /// /// The names to fetch. /// The call context. /// One row per distinct name the hub holds. /// The request carries more names than the configured cap. public override async Task GetSecrets( GetSecretsRequest request, ServerCallContext context) { ArgumentNullException.ThrowIfNull(request); ArgumentNullException.ThrowIfNull(context); if (request.Names.Count > _maxNamesPerRequest) { // The cap and the count are both safe to state — neither is secret, and an operator // cannot fix a batch that is too large without knowing by how much. The names are NOT // stated: they are the one part of this request that identifies secrets. _logger.LogWarning( "Secrets hub refused a GetSecrets request of {RequestedCount} name(s); the cap is " + "{MaxNamesPerRequest}.", request.Names.Count, _maxNamesPerRequest); throw new RpcException(new Status( StatusCode.ResourceExhausted, $"GetSecrets accepts at most {_maxNamesPerRequest} names per request; this one " + $"carried {request.Names.Count}. Split the fetch into smaller batches.")); } var response = new GetSecretsResponse(); var seen = new HashSet(StringComparer.Ordinal); int skipped = 0; foreach (string requested in request.Names) { SecretName name; try { // Re-validated server-side: the wire type is a plain string, so this is where a // path-traversing or otherwise malformed name is stopped — before it reaches a store // that may treat the name as a path segment. name = new SecretName(requested); } catch (ArgumentException) { skipped++; continue; } // Normalization happens in the SecretName constructor, so de-duplication has to key off // the normalized value — otherwise "Db/Central" and "db/central" would each cost a read // and each return the same row. if (!seen.Add(name.Value)) { continue; } StoredSecret? row = await _store.GetAsync(name, context.CancellationToken).ConfigureAwait(false); if (row is null) { continue; } response.Secrets.Add(DomainToWire.ToWire(row)); } if (skipped > 0) { // The count, never the values: the names are caller-supplied text and this is a log. _logger.LogWarning( "Secrets hub skipped {SkippedCount} unparseable name(s) in a GetSecrets request.", skipped); } _logger.LogDebug("Secrets hub served {RowCount} row(s).", response.Secrets.Count); return response; } }