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;
}
}