Skip to content

Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.

27.1 KB
Raw Blame
//-----------------------------------------------------------------------
// <copyright file="KeyRotationController.cs" company="aliasvault">
// Copyright (c) aliasvault. All rights reserved.
// Licensed under the AGPLv3 license. See LICENSE.md file in the project root for full license information.
// </copyright>
//-----------------------------------------------------------------------

namespace AliasVault.Api.Controllers.V2;

using System.Security.Claims;
using AliasServerDb;
using AliasServerDb.Retention;
using AliasVault.Api.Controllers.Abstracts;
using AliasVault.Api.Headers;
using AliasVault.Api.Helpers;
using AliasVault.Api.Models;
using AliasVault.Api.Services;
using AliasVault.Auth;
using AliasVault.Cryptography;
using AliasVault.Shared.Models.Enums;
using AliasVault.Shared.Models.WebApi;
using AliasVault.Shared.Models.WebApi.V2.KeyRotation;
using AliasVault.Shared.Models.WebApi.V2.Vault;
using AliasVault.Shared.Server.Services;
using Asp.Versioning;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;

/// <summary>
/// Rotates an account's encryption keys: a new Account Key, personal VEK, account keypair and signing keypair, with the
/// personal vault re-encrypted and every grant rewrapped, applied in one transaction or not at all.
/// </summary>
/// <param name="logger">Logger.</param>
/// <param name="dbContextFactory">DbContext factory.</param>
/// <param name="userManager">UserManager.</param>
/// <param name="cache">IMemoryCache instance for persisting SRP values between the initiate and the rotation call.</param>
/// <param name="timeProvider">TimeProvider.</param>
/// <param name="authLoggingService">AuthLoggingService.</param>
[ApiVersion("2")]
public class KeyRotationController(ILogger<KeyRotationController> logger, IAliasServerDbContextFactory dbContextFactory, UserManager<AliasVaultUser> userManager, IMemoryCache cache, TimeProvider timeProvider, AuthLoggingService authLoggingService) : AuthenticatedRequestController(userManager)
{
    /// <summary>
    /// Starts a key rotation: the SRP challenge for the current password, plus the key generations the rotation starts from.
    /// </summary>
    /// <returns>The challenge.</returns>
    [HttpGet("initiate")]
    public async Task<IActionResult> Initiate()
    {
        var user = await GetCurrentUserAsync();
        if (user == null)
        {
            return ApiError.Result(ApiErrorCode.NOT_AUTHENTICATED, 401);
        }

        await using var context = await dbContextFactory.CreateDbContextAsync();
        var unlockMethod = await context.UserUnlockMethods.FirstOrDefaultAsync(x => x.UserId == user.Id && x.Type == UnlockMethodType.Password);
        var personalManifestId = await GroupHelper.GetPersonalManifestIdAsync(context, user.PersonalGroupId);
        if (unlockMethod == null || personalManifestId == null)
        {
            // Only an account on the key hierarchy has keys to rotate.
            return ApiError.Result(ApiErrorCode.VAULT_KEY_NOT_FOUND, 400);
        }

        var manifestKeyVersion = await context.VaultManifests.Where(x => x.ManifestId == personalManifestId.Value).Select(x => x.KeyVersion).FirstAsync();
        var credentials = await AuthHelper.GetUserLatestVaultEncryptionSettingsAsync(context, user);
        var serverEphemeral = AuthHelper.CreateSrpEphemeral(cache, user, SrpPurpose.KeyRotation, credentials);

        return Ok(new KeyRotationInitiateResponse
        {
            Salt = credentials.Salt,
            ServerEphemeral = serverEphemeral,
            EncryptionType = credentials.EncryptionType,
            EncryptionSettings = credentials.EncryptionSettings,
            SrpIdentity = AuthHelper.GetSrpIdentity(user),
            UserId = user.Id,
            AccountKeyVersion = unlockMethod.AccountKeyVersion,
            PersonalManifestId = personalManifestId.Value,
            ManifestKeyVersion = manifestKeyVersion,
        });
    }

    /// <summary>
    /// Applies a key rotation. Everything is checked against the server state first; the rotation is refused as a whole when
    /// the account moved on since the client computed it, or when it does not cover every blob key and grant the account holds.
    /// </summary>
    /// <param name="model">The rotation.</param>
    /// <returns>The outcome.</returns>
    [HttpPost("")]
    public async Task<IActionResult> Rotate([FromBody] KeyRotationRequest model)
    {
        var user = await GetCurrentUserAsync();
        if (user == null)
        {
            return ApiError.Result(ApiErrorCode.NOT_AUTHENTICATED, 401);
        }

        await using var context = await dbContextFactory.CreateDbContextAsync();
        var unlockMethod = await context.UserUnlockMethods.FirstOrDefaultAsync(x => x.UserId == user.Id && x.Type == UnlockMethodType.Password);
        if (unlockMethod == null)
        {
            return ApiError.Result(ApiErrorCode.VAULT_KEY_NOT_FOUND, 400);
        }

        var shapeError = ValidateShape(user, model);
        if (shapeError != null)
        {
            return shapeError;
        }

        // The key rotation mechanism always expects a new salt (via combined mandatory password change): other devices detect the rotation by the changed salt to avoid outdated pushes.
        if (string.Equals(model.UnlockMethod.Salt, VaultKeyMetadata.Parse(unlockMethod.Metadata).Salt, StringComparison.Ordinal))
        {
            return ApiError.Result(ApiErrorCode.INVALID_REQUEST, 400);
        }

        // The current password, proven over SRP; failures count towards the lockout like a login.
        var srpResult = await AuthHelper.ValidateStepUpAsync(cache, context, GetUserManager(), user, SrpPurpose.KeyRotation, model.CurrentClientPublicEphemeral, model.CurrentClientSessionProof);
        if (srpResult.Session is null)
        {
            await authLoggingService.LogAuthEventFailAsync(user.UserName!, AuthEventType.KeyRotation, srpResult.FailureReason);
            return ApiError.Result(srpResult.LockedOut ? ApiErrorCode.ACCOUNT_LOCKED : ApiErrorCode.PASSWORD_MISMATCH, 400);
        }

        var now = timeProvider.GetUtcNow().UtcDateTime;
        var currentRefreshTokenId = Guid.TryParse(User.FindFirstValue(TokenService.RefreshTokenIdClaim), out var tokenId) ? tokenId : Guid.Empty;
        var client = ClientHeaderInfo.GetRawValue(Request);

        var strategy = context.Database.CreateExecutionStrategy();
        var result = await strategy.ExecuteAsync(async () =>
        {
            await using var writeContext = await dbContextFactory.CreateDbContextAsync();
            await using var tx = await writeContext.Database.BeginTransactionAsync();
            await GrantHelper.LockUserCertificationsAsync(writeContext, user.Id);

            var manifest = await writeContext.VaultManifests.FirstOrDefaultAsync(x => x.ManifestId == model.Expected.PersonalManifestId && x.OwnerGroupId == user.PersonalGroupId);
            if (manifest == null)
            {
                return ApiError.Result(ApiErrorCode.INVALID_REQUEST, 400);
            }

            // Claim the unlock method at the expected Account Key version. The row stays locked until commit, so a concurrent
            // rotation or password change waits here and then finds the version moved on.
            var claimed = await writeContext.UserUnlockMethods.Where(x => x.Id == unlockMethod.Id && x.AccountKeyVersion == model.Expected.AccountKeyVersion).ExecuteUpdateAsync(s => s.SetProperty(x => x.UpdatedAt, now));
            if (claimed == 0)
            {
                await tx.RollbackAsync();
                return Ok(await CurrentStateAsync(writeContext, user, KeyRotationStatus.Outdated, manifest.ManifestId));
            }

            var method = await writeContext.UserUnlockMethods.FirstAsync(x => x.Id == unlockMethod.Id);
            var buckets = await writeContext.VaultDataBuckets.Where(x => x.ManifestId == manifest.ManifestId).ToListAsync();
            var heldGrants = await writeContext.VaultManifestAccessKeys.Where(x => x.UserId == user.Id && x.Type == ManifestKeyType.GrantKey).ToListAsync();
            var certifications = await writeContext.UserKeyCertifications.Where(c => c.CertifierUserId == user.Id).ToListAsync();
            var personalAccessKeys = await writeContext.VaultManifestAccessKeys.Where(x => x.UserId == user.Id && x.Type == ManifestKeyType.AccountKey && x.VaultManifestId == manifest.ManifestId).ToListAsync();

            // Revision gate: the rotation was computed against exactly this vault state, or it is not applied.
            if (!ExpectedStateMatches(model.Expected, manifest, buckets))
            {
                await tx.RollbackAsync();
                return Ok(await CurrentStateAsync(writeContext, user, KeyRotationStatus.Outdated, manifest.ManifestId));
            }

            // Completeness gate: a blob key or grant left under the old keys would be unreadable from here on.
            var referencedHashes = (await writeContext.VaultBlobReferences.Where(r => r.ManifestId == manifest.ManifestId && r.RevisionNumber == manifest.RevisionNumber).Select(r => r.BlobHash).ToListAsync()).ToHashSet(StringComparer.Ordinal);
            var rewrappedHashes = model.BlobKeys.Select(b => b.Hash).ToHashSet(StringComparer.Ordinal);
            var writtenHashes = model.Manifest.BlobReferences.Select(b => b.Hash).ToHashSet(StringComparer.Ordinal);
            var heldGrantIds = heldGrants.Select(g => g.VaultManifestId).ToHashSet();
            var rewrappedGrantIds = model.Grants.Select(g => g.ManifestId).ToHashSet();
            var grantVersionsMatch = model.Grants.All(g => heldGrants.Any(h => h.VaultManifestId == g.ManifestId && h.KeyVersion == g.KeyVersion));
            var bucketsCovered = buckets.All(b => model.Buckets.Any(w => w.Category == b.Category));
            var certificationsCovered = certifications.All(c => model.Certifications.Any(w => w.SubjectUserId == c.SubjectUserId && w.SubjectSigningPublicKey == c.SubjectSigningPublicKey)) && model.Certifications.Count == certifications.Count;
            var blobsCovered = rewrappedHashes.SetEquals(referencedHashes) && writtenHashes.SetEquals(referencedHashes);
            var grantsCovered = rewrappedGrantIds.SetEquals(heldGrantIds) && grantVersionsMatch;
            if (!blobsCovered || !grantsCovered || !bucketsCovered || !certificationsCovered || personalAccessKeys.Count == 0)
            {
                await tx.RollbackAsync();
                return ApiError.Result(ApiErrorCode.KEY_ROTATION_INCOMPLETE, 400);
            }

            var newAccountKeyVersion = method.AccountKeyVersion + 1;
            var newKeyVersion = manifest.KeyVersion + 1;

            // 1) The master-password unlock method, rewritten for the new Account Key. Archived passwords open an older Account Key,
            // which no longer reaches any vault key, so the password history is dropped instead of extended.
            await writeContext.UserUnlockMethodsHistory.Where(x => x.UserId == user.Id).ExecuteDeleteAsync();
            var metadata = VaultKeyMetadata.Parse(method.Metadata);
            metadata.Salt = model.UnlockMethod.Salt;
            metadata.SrpVerifier = model.UnlockMethod.Verifier;
            metadata.EncryptionType = model.UnlockMethod.EncryptionType;
            metadata.EncryptionSettings = model.UnlockMethod.EncryptionSettings;
            method.Metadata = metadata.ToJson();
            method.EncryptedAccountKey = model.UnlockMethod.EncryptedAccountKey;
            method.Algorithm = VaultKeyAlgorithms.Parse(model.UnlockMethod.EncryptedAccountKeyAlgorithm);
            method.AccountKeyVersion = newAccountKeyVersion;
            method.UpdatedAt = now;

            // Other account unlock methods still hold the old Account Key, so they are deleted (none exist yet besides the password).
            // TODO: when more unlock methods are added, check this assumption again and update UI warnings if necessary.
            await writeContext.UserUnlockMethods.Where(x => x.UserId == user.Id && x.Id != method.Id).ExecuteDeleteAsync();

            // 2) The personal VEK: the new generation replaces every previous one, as nothing under an older one is kept (see 5).
            writeContext.VaultManifestAccessKeys.RemoveRange(personalAccessKeys);
            writeContext.VaultManifestAccessKeys.Add(new VaultManifestAccessKey
            {
                Id = Guid.NewGuid(),
                UserId = user.Id,
                VaultManifestId = manifest.ManifestId,
                Type = ManifestKeyType.AccountKey,
                Algorithm = VaultKeyAlgorithm.Aes256Gcm,
                EncryptedVek = model.AccountKeys.EncryptedVek,
                KeyVersion = newKeyVersion,
                AccountKeyVersion = newAccountKeyVersion,
                CreatedAt = now,
                UpdatedAt = now,
            });

            // 3) The account keypairs. Old encryption keypairs are deleted: every grant is rewrapped below and stale invitations are
            // emptied, so nothing references them. Old signing keys stay demoted, as their public halves chain to the new one.
            await writeContext.UserGrantKeys.Where(k => k.UserId == user.Id).ExecuteDeleteAsync();
            await writeContext.UserSigningKeys.Where(k => k.UserId == user.Id && k.IsPrimary).ExecuteUpdateAsync(s => s.SetProperty(k => k.IsPrimary, false).SetProperty(k => k.UpdatedAt, now));
            var grantKey = new UserGrantKey
            {
                Id = Guid.NewGuid(),
                UserId = user.Id,
                Algorithm = VaultKeyAlgorithm.RsaOaepSha256,
                PublicKey = model.AccountKeys.AccountPublicKey,
                EncryptedPrivateKey = model.AccountKeys.EncryptedAccountPrivateKey,
                PublicKeySignature = model.AccountKeys.AccountPublicKeySignature,
                IsPrimary = true,
                AccountKeyVersion = newAccountKeyVersion,
                CreatedAt = now,
                UpdatedAt = now,
            };
            writeContext.UserGrantKeys.Add(grantKey);
            writeContext.UserSigningKeys.Add(new UserSigningKey
            {
                Id = Guid.NewGuid(),
                UserId = user.Id,
                Algorithm = SigningKeyAlgorithm.Ed25519,
                PublicKey = model.AccountKeys.SigningPublicKey,
                Fingerprint = Signing.Fingerprint(model.AccountKeys.SigningPublicKey),
                EncryptedPrivateKey = model.AccountKeys.EncryptedSigningPrivateKey,
                IsPrimary = true,
                AccountKeyVersion = newAccountKeyVersion,
                CreatedAt = now,
                UpdatedAt = now,
            });

            // 4) Every grant this account holds, now encrypted for the new public key and signed by the new signing key.
            foreach (var grant in heldGrants)
            {
                var rewrap = model.Grants.First(g => g.ManifestId == grant.VaultManifestId);
                grant.EncryptedVek = rewrap.EncryptedVek;
                grant.Algorithm = VaultKeyAlgorithms.Parse(rewrap.Algorithm);
                grant.UserGrantKeyId = grantKey.Id;
                grant.GrantSignature = rewrap.Signature;
                grant.GrantSignerUserId = user.Id;
                grant.GrantSignerPublicKey = model.AccountKeys.SigningPublicKey;
                grant.UpdatedAt = now;
            }

            // 4b) Every key certification this account made, signed again with the new signing key, so the people it vouched for stay verified.
            foreach (var certification in certifications)
            {
                certification.Signature = model.Certifications.First(c => c.SubjectUserId == certification.SubjectUserId).Signature;
                certification.UpdatedAt = now;
            }

            // 5) The personal manifest, as a new revision under the new VEK, with the same blob set. Earlier revisions of the manifest
            // and its buckets are encrypted with the old VEK, which no client holds anymore, so they are deleted instead of archived.
            await writeContext.VaultBlobReferences.Where(r => r.ManifestId == manifest.ManifestId).ExecuteDeleteAsync();
            await writeContext.VaultManifestsHistory.Where(h => h.ManifestId == manifest.ManifestId).ExecuteDeleteAsync();
            await writeContext.VaultDataBucketsHistory.Where(h => h.ManifestId == manifest.ManifestId).ExecuteDeleteAsync();

            manifest.VaultBlob = null;
            manifest.StorageFormat = VaultManifestBase.ManifestStorageFormat;
            manifest.ManifestBlob = model.Manifest.Data;
            manifest.ManifestCiphertextHash = model.Manifest.ManifestCiphertextHash;
            manifest.Version = null;
            manifest.KeyVersion = newKeyVersion;
            manifest.RevisionNumber = model.Expected.ManifestRevision + 1;
            manifest.FileSize = FileHelper.BytesToKilobytes(manifest.ManifestBlob.Length);
            manifest.CredentialsCount = model.Manifest.CredentialsCount;
            manifest.Client = client;
            manifest.UpdatedByUserId = user.Id;
            manifest.UpdatedAt = now;
            foreach (var hash in referencedHashes)
            {
                writeContext.VaultBlobReferences.Add(new VaultBlobReference { ManifestId = manifest.ManifestId, RevisionNumber = manifest.RevisionNumber, BlobHash = hash });
            }

            if (!string.IsNullOrEmpty(model.Manifest.DeliveryPublicKey))
            {
                await VaultRevisionWriter.PublishManifestPublicKeyAsync(writeContext, now, manifest.ManifestId, model.Manifest.DeliveryPublicKey, VaultKeyAlgorithms.Parse(model.Manifest.DeliveryPublicKeyAlgorithm));
            }

            // 6) The data buckets and blob keys under the new VEK.
            var bucketRevisions = new List<BucketRevision>();
            foreach (var bucket in model.Buckets)
            {
                var revision = await VaultRevisionWriter.UpsertBucketAsync(writeContext, now, manifest.ManifestId, bucket.Category, bucket.Data, bucket.CiphertextHash, bucket.CurrentRevision, buckets.FirstOrDefault(b => b.Category == bucket.Category), newKeyVersion, archive: false);
                bucketRevisions.Add(new BucketRevision { ManifestId = manifest.ManifestId, Category = bucket.Category, Revision = revision });
            }

            var blobRows = await writeContext.VaultBlobObjects.Where(b => b.ManifestId == manifest.ManifestId && referencedHashes.Contains(b.Hash)).ToListAsync();
            var rewrappedKeys = model.BlobKeys.ToDictionary(b => b.Hash, b => b.EncryptedBlobKey, StringComparer.Ordinal);
            foreach (var blob in blobRows)
            {
                blob.EncryptedBlobKey = rewrappedKeys[blob.Hash];
                blob.KeyVersion = newKeyVersion;
            }

            // Blobs only older revisions referenced keep a key under the old VEK. Delete them now instead of at the next GC sweep: a
            // client re-adding the same content would find the hash present, skip the upload and reference a key nobody can open.
            await writeContext.VaultBlobObjects.Where(b => b.ManifestId == manifest.ManifestId && !referencedHashes.Contains(b.Hash)).ExecuteDeleteAsync();

            // 7) Invitations addressed to this account are encrypted for the old public key and cannot be opened anymore.
            var staleInvitations = await writeContext.VaultManifestInvitations.Where(i => i.InviteeUserId == user.Id && i.State == VaultManifestInvitationState.Pending).ToListAsync();
            foreach (var invitation in staleInvitations)
            {
                invitation.State = VaultManifestInvitationState.Stale;
                invitation.EncryptedVek = null;
                invitation.EncryptedName = null;
                invitation.EncryptedNameSignature = null;
                invitation.UserGrantKeyId = null;
                invitation.GrantSignature = null;
                invitation.GrantSignerPublicKey = null;
                invitation.RespondedAt = now;
                invitation.UpdatedAt = now;
            }

            // 8) Account bookkeeping, and every other session is signed out: their keys no longer open anything.
            await writeContext.AliasVaultUsers.Where(x => x.Id == user.Id).ExecuteUpdateAsync(s => s.SetProperty(x => x.PasswordChangedAt, now));
            await writeContext.AliasVaultUserRefreshTokens.Where(x => x.UserId == user.Id && x.Id != currentRefreshTokenId).ExecuteDeleteAsync();

            await writeContext.SaveChangesAsync();
            await tx.CommitAsync();

            return Ok(new KeyRotationResponse { Status = KeyRotationStatus.Ok, ManifestKeyVersion = newKeyVersion, ManifestRevision = manifest.RevisionNumber, BucketRevisions = bucketRevisions });
        });

        if (result is OkObjectResult { Value: KeyRotationResponse { Status: KeyRotationStatus.Ok } })
        {
            user.PasswordChangedAt = now;
            await authLoggingService.LogAuthEventSuccessAsync(user.UserName!, AuthEventType.KeyRotation);
            logger.LogInformation("Rotated the encryption keys of user {UserName} ({UserId}).", user.UserName, user.Id);
        }

        return result;
    }

    /// <summary>
    /// Whether the personal manifest and its buckets are exactly what the rotation was computed against.
    /// </summary>
    private static bool ExpectedStateMatches(KeyRotationExpectedState expected, VaultManifest manifest, List<VaultDataBucket> buckets)
    {
        if (manifest.RevisionNumber != expected.ManifestRevision || manifest.KeyVersion != expected.ManifestKeyVersion)
        {
            return false;
        }

        // Every bucket the server holds must be named at its current revision; a bucket the server does not hold yet is at 0.
        var expectedRevisions = expected.BucketRevisions.Where(b => b.ManifestId == manifest.ManifestId).ToDictionary(b => b.Category, b => b.Revision);
        return buckets.All(b => expectedRevisions.GetValueOrDefault(b.Category) == b.RevisionNumber) && expectedRevisions.All(e => e.Value == 0 || buckets.Any(b => b.Category == e.Key));
    }

    /// <summary>
    /// The account's current key generations and revisions, reported with a refusal.
    /// </summary>
    private static async Task<KeyRotationResponse> CurrentStateAsync(AliasServerDbContext context, AliasVaultUser user, KeyRotationStatus status, Guid manifestId)
    {
        var manifest = await context.VaultManifests.Where(x => x.ManifestId == manifestId).Select(x => new { x.KeyVersion, x.RevisionNumber }).FirstOrDefaultAsync();
        var bucketRevisions = await context.VaultDataBuckets.Where(x => x.ManifestId == manifestId).Select(x => new BucketRevision { ManifestId = x.ManifestId, Category = x.Category, Revision = x.RevisionNumber }).ToListAsync();
        return new KeyRotationResponse { Status = status, ManifestKeyVersion = manifest?.KeyVersion ?? 0, ManifestRevision = manifest?.RevisionNumber ?? 0, BucketRevisions = bucketRevisions };
    }

    /// <summary>
    /// Checks everything about the request that needs no transaction: sizes, algorithms, ciphertext hashes and signatures.
    /// Every signature is checked against the new signing key, which the rotation stores in the same transaction.
    /// </summary>
    /// <returns>Null when the request is well-formed, else the error to answer with.</returns>
    private static IActionResult? ValidateShape(AliasVaultUser user, KeyRotationRequest model)
    {
        var unlock = model.UnlockMethod;
        var keys = model.AccountKeys;
        var accountKeyFits = !string.IsNullOrEmpty(unlock.EncryptedAccountKey) && unlock.EncryptedAccountKey.Length <= AccountKeysUpload.MaxWrappedKeyLength;
        if (!UnlockMethodParameterValidator.IsValidKekDerivationParams(unlock.EncryptionType, unlock.EncryptionSettings) || !UnlockMethodParameterValidator.WithinSrpCredentialLimits(unlock.Salt, unlock.Verifier) || !accountKeyFits)
        {
            return ApiError.Result(ApiErrorCode.INVALID_ENCRYPTION_PARAMETERS, 400);
        }

        if (!VaultKeyAlgorithms.TryParse(unlock.EncryptedAccountKeyAlgorithm, out var accountKeyAlgorithm) || VaultKeyAlgorithms.IsAsymmetric(accountKeyAlgorithm))
        {
            return ApiError.Result(ApiErrorCode.INVALID_ALGORITHM, 400);
        }

        if (!keys.FitsStorageLimits || !RsaPublicKeyValidator.IsValid(keys.AccountPublicKey))
        {
            return ApiError.Result(ApiErrorCode.INVALID_REQUEST, 400);
        }

        // Manifest and buckets: one manifest, the personal one, with buckets of its own, each ciphertext matching its hash.
        if (model.Manifest.ManifestId != model.Expected.PersonalManifestId || !CiphertextHelper.IsCiphertext(model.Manifest.Data) || !CiphertextHelper.MatchesHash(model.Manifest.Data, model.Manifest.ManifestCiphertextHash))
        {
            return ApiError.Result(ApiErrorCode.INVALID_REQUEST, 400);
        }

        if (model.Buckets.Select(b => b.Category).Distinct().Count() != model.Buckets.Count || model.Buckets.Any(b => b.ManifestId != model.Manifest.ManifestId || !CiphertextHelper.IsCiphertext(b.Data) || !CiphertextHelper.MatchesHash(b.Data, b.CiphertextHash)))
        {
            return ApiError.Result(ApiErrorCode.INVALID_REQUEST, 400);
        }

        if (model.BlobKeys.Select(b => b.Hash).Distinct(StringComparer.Ordinal).Count() != model.BlobKeys.Count || model.Grants.Select(g => g.ManifestId).Distinct().Count() != model.Grants.Count || model.Certifications.Select(c => c.SubjectUserId).Distinct(StringComparer.Ordinal).Count() != model.Certifications.Count)
        {
            return ApiError.Result(ApiErrorCode.INVALID_REQUEST, 400);
        }

        if (model.Grants.Any(g => !VaultKeyAlgorithms.TryParse(g.Algorithm, out var grantAlgorithm) || !VaultKeyAlgorithms.IsAsymmetric(grantAlgorithm)))
        {
            return ApiError.Result(ApiErrorCode.INVALID_ALGORITHM, 400);
        }

        var deliveryKey = model.Manifest.DeliveryPublicKey;
        if (!string.IsNullOrEmpty(deliveryKey) && (!VaultKeyAlgorithms.TryParse(model.Manifest.DeliveryPublicKeyAlgorithm, out var deliveryAlgorithm) || !VaultKeyAlgorithms.IsAsymmetric(deliveryAlgorithm) || !RsaPublicKeyValidator.IsValid(deliveryKey)))
        {
            return ApiError.Result(ApiErrorCode.INVALID_REQUEST, 400);
        }

        // Signatures: the new signing key vouches for the new account public key, every grant, the delivery key and every key certification.
        var accountKeyIsSigned = Signing.VerifyAccountPublicKey(keys.SigningPublicKey, keys.AccountPublicKey, keys.AccountPublicKeySignature);
        var grantsAreSigned = model.Grants.All(g => Signing.Verify(keys.SigningPublicKey, Signing.GrantMessage(g.ManifestId, g.KeyVersion, user.Id, keys.AccountPublicKey, g.Algorithm, g.EncryptedVek), g.Signature));
        var deliveryKeyIsSigned = string.IsNullOrEmpty(deliveryKey) || Signing.Verify(keys.SigningPublicKey, Signing.DeliveryKeyMessage(model.Manifest.ManifestId, deliveryKey, model.Manifest.CurrentRevision), model.Manifest.DeliveryPublicKeySignature);
        var certificationsAreSigned = model.Certifications.All(c => Signing.Verify(keys.SigningPublicKey, Signing.KeyCertificationMessage(user.Id, c.SubjectUserId, c.SubjectSigningPublicKey), c.Signature));
        if (!accountKeyIsSigned || !grantsAreSigned || !deliveryKeyIsSigned || !certificationsAreSigned)
        {
            return ApiError.Result(ApiErrorCode.SIGNATURE_INVALID, 400);
        }

        return null;
    }
}