From e3be112bf81f9e5fcf87e63bcc6148d5171b31bf Mon Sep 17 00:00:00 2001 From: appergb <192432815+appergb@users.noreply.github.com> Date: Thu, 19 Nov 2026 12:15:52 +0800 Subject: [PATCH 1/2] Add independently versioned encrypted service Usage sync --- deploy/sync.env.example | 3 + docs/client-integration.md | 2 + docs/deployment.md | 12 + docs/encryption-protocol.md | 2 + docs/http-api.md | 2 + docs/index.md | 2 + docs/openapi.yaml | 571 +++++++++++++++++++++++++ docs/requirements.md | 2 + docs/server-acceptance.md | 4 + docs/service-usage.md | 50 +++ migrations/002_service_usage.sql | 16 + scripts/check_contract.py | 4 + scripts/interop_vectors.py | 52 ++- src/config.rs | 13 + src/lib.rs | 1 + src/server.rs | 138 ++++-- src/store.rs | 367 ++++++++++++---- src/store/usage.rs | 263 ++++++++++++ src/usage.rs | 172 ++++++++ tests/common/mod.rs | 117 +++++- tests/crypto_vectors.rs | 101 +++++ tests/openapi_samples.rs | 52 ++- tests/store_contract.rs | 68 +++ tests/usage_contract.rs | 626 ++++++++++++++++++++++++++++ tests/vectors/service-usage-v1.json | 43 ++ 25 files changed, 2562 insertions(+), 121 deletions(-) create mode 100644 docs/service-usage.md create mode 100644 migrations/002_service_usage.sql create mode 100644 src/store/usage.rs create mode 100644 src/usage.rs create mode 100644 tests/usage_contract.rs create mode 100644 tests/vectors/service-usage-v1.json diff --git a/deploy/sync.env.example b/deploy/sync.env.example index 388fe96..8ad51b9 100644 --- a/deploy/sync.env.example +++ b/deploy/sync.env.example @@ -9,3 +9,6 @@ SYNC_ACCESS_MODE=restricted SYNC_ALLOWED_GITHUB_IDS= # Native clients have no Origin. Add exact HTTPS origins only when needed. SYNC_ALLOWED_ORIGINS= +# Default rescue preserves existing opaque Usage while pausing new ordinary Usage snapshots. +# Use enabled only in an authorized, independently verified environment. +SYNC_SERVICE_USAGE_MODE=rescue diff --git a/docs/client-integration.md b/docs/client-integration.md index fa4106d..c55dbeb 100644 --- a/docs/client-integration.md +++ b/docs/client-integration.md @@ -1,5 +1,7 @@ # 应用接入与代码接口交接 +Unreleased additive contract: [Encrypted service Usage sidecar](service-usage.md). Consent, ledger merge, durable restore and the legacy-safe settings representation are client-side release gates. + 状态:待实现接口清单;版本 `1.0-draft.1`。这里定义接手者需要新增或修改的接口,不提供实现代码或架构设计。应用源码路径均相对于 `1-app/openless-all/app/`;本次核对基线为本地 2.0 整合分支的 `f37125da`。 ## 1. 现状与替代边界 diff --git a/docs/deployment.md b/docs/deployment.md index ba787cb..3e520bf 100644 --- a/docs/deployment.md +++ b/docs/deployment.md @@ -85,3 +85,15 @@ sudo -u openless-sync python3 /opt/openless-cloud-sync/current/backup.py --prune 沿用现有 OpenLess OAuth App(Client ID 见连接信息),服务器凭据已经配置并经 GitHub 核验;没有创建第二个 OAuth App。当前 `restricted` 名单只包含 `appergb`,等待客户端完成后进行真实账号及加密同步联调。 主服务、每日备份和每小时清理定时器均已启用,首次备份与清理执行成功。配置和数据库权限为 0600;备份目录为 0700。官网及市场的既有 nginx 配置摘要与部署前一致,官网 HTTPS 仍返回 200。源码归档、许可证及 `/revision` 已经从公网访问验证。 + +## Unreleased service Usage: isolated staging and preservation-first rescue + +The live integration endpoint above is **not** a staging target for this change. No authorized isolated cloud staging target is identified. Before staging, obtain a separately approved host or isolated service account/unit, DNS/HTTPS route and certificate, non-production OAuth application and secrets, restricted synthetic GitHub numeric test IDs, storage and backup paths, operator access and an authorized review window. Do not reuse live identities, secrets, DBs, backup paths, virtual-host files or systemd units. Do not create billable resources or copy production data to obtain a test baseline. `scripts/install_server.sh` uses fixed paths and unit names: do not run it on a shared or live host as an isolation mechanism. + +1. Review the exact PR head independently, including release CI and advisory audit. From a clean checkout of the reviewed SHA run `cargo build --release --locked`. Package with the matching source archive, upstream proxy template, license, and third-party notices. Keep both an `enabled` package/config and a tested schema-v2-capable `rescue` artifact/config for the same platform. Record the SHA, config mode, hostname and package identity (not env contents). +2. On the authorized isolated target, stage a synthetic schema-v1 copy first. Build a separate restricted service with the loopback bind and proxy-bound HTTPS policy; set `SYNC_SERVICE_USAGE_MODE=enabled` **only in the isolated environment**. The Usage mode defaults to `rescue`, which supports the public probe, Usage reads, existing exact replays/receipts, paired rotations, V1 settings/history sync and delete, but returns `503 service_unavailable` for new ordinary Usage PUTs. A validated probe does not mean writes are enabled. +3. Verify the actual process and local `/healthz`, externally verify TLS, `/revision`, unchanged `/v1/capabilities`, the exact Usage probe, and absence of a public `/healthz`. Execute old V1 restore/snapshot, exact upgraded end-to-end Usage from two authenticated synthetic devices, legacy rotation with and without Usage, paired rekey + lost acknowledgement, tombstone/recreate, independent numeric IDs, durable local restore, history/privacy/consent behavior, retention/overflow and the acceptance totals in the [Usage contract](service-usage.md). Preserve only sanitized outcomes and response codes (never secrets or identifying data). +4. After both V1 and Usage writes are committed on staging, capture the two opaque heads, receipts and schema version; restart against the **same database** using the checked v2 rescue candidate and `SYNC_SERVICE_USAGE_MODE=rescue`. Check no revision or ciphertext hash changed, old and Usage reads/receipts work, an exact lost-ack retry still replays, a fresh ordinary Usage write is refused, and a guarded legacy rotation cannot erase Usage. Confirm paired rotation and legacy delete still work with synthetic fixtures, including accepted V1 writes while paused. Restart `enabled` against that same DB and verify all accepted writes/tombstones are visible. Record the comparison and rehearse restarting using the retained artifact before any cutover. +5. Schema 2 is additive and migration failure rolls back. The original schema-1 binary intentionally refuses to open a schema-2 DB. A reverse binary switch or pre-cutover backup restore is **not** a safe default: it can drop accepted writes, receipts, changed keys or tombstones. Before any exposure, if operators prove no new mutations were accepted, a quiesced, verified pre-migration copy may be used for a rollback under explicit approval. After writes are accepted, pause the new write path with a v2-capable rescue and use a reviewed forward fix on the current DB; if integrity or schema is in doubt, pause public writes rather than reset the schema or restore stale state. Maintain independent recall procedures if the rescue itself is affected. Preserve secure delete and the published backup-retention policy. + +Production cutover remains a separate operator decision. Require a reviewed SHA, release CI/independent security and logic review, approved staging results with real older/newer clients, capacity/consent approval, and an explicitly verified content-preserving rescue before activating any new Usage writes. Keep the currently served instance live while these prerequisites are missing. diff --git a/docs/encryption-protocol.md b/docs/encryption-protocol.md index 1230e91..042a227 100644 --- a/docs/encryption-protocol.md +++ b/docs/encryption-protocol.md @@ -1,5 +1,7 @@ # 加密数据协议 v1 +Unreleased additive contract: [Usage framing and domain-separated AAD](service-usage.md#cryptography-and-bounds). The existing V1 crypto header and AAD do not change. + 状态:合同版本 `1.0-draft.1`;[固定测试向量](../tests/vectors/v1.json) 已由 RustCrypto 与 reference Argon2/libsodium 验证。客户端接入与跨设备验收仍待完成。本文定义字节级互操作要求。HTTP 字段见 [API](http-api.md);机器定义见 [OpenAPI](openapi.yaml)。 ## 1. 固定密码学配置 diff --git a/docs/http-api.md b/docs/http-api.md index ddcd30e..b163b25 100644 --- a/docs/http-api.md +++ b/docs/http-api.md @@ -1,5 +1,7 @@ # 云同步 HTTP API v1 +Unreleased additive contract: [Encrypted service Usage sidecar](service-usage.md). An existing opaque Usage snapshot blocks a V1-only password change with the existing `409 key_epoch_changed`; ordinary V1 writes and delete remain compatible. + 状态:服务端 `0.1.0` 已上线指定账号联调环境,真实账号与完整客户端验收待完成;当前地址见 [连接信息](connection.md)。合同版本 `1.0-draft.1`;字段定义以 [openapi.yaml](openapi.yaml) 为机器来源,加密字节格式以 [加密协议](encryption-protocol.md) 为准。 示例基地址为保留域名 `https://sync.openless.example`,**不是已部署地址**。正式域名与 GitHub OAuth client ID 必须在接入前配置、核验;不沿用旧服务 `https://apic.openless.top:9443/me/sync` 的明文合同。 diff --git a/docs/index.md b/docs/index.md index 3abaa64..c92b76d 100644 --- a/docs/index.md +++ b/docs/index.md @@ -1,5 +1,7 @@ # 文档入口 +[Encrypted service Usage sidecar](service-usage.md) (additive, unreleased) specifies the separate probe, Usage wire contract, and mixed-version gates. + 更新:2026-09-26。协议 `1.0-draft.1`;服务端 `0.1.0` 已通过本地与三平台验证,以 AGPL-3.0-only 开源并上线指定账号联调环境;客户端完成后继续真实账号和完整加密同步验收。 | 阅读顺序 | 文档 | 用途 | diff --git a/docs/openapi.yaml b/docs/openapi.yaml index 4c8fec7..a178675 100644 --- a/docs/openapi.yaml +++ b/docs/openapi.yaml @@ -269,6 +269,7 @@ paths: $ref: '#/components/schemas/ErrorEnvelope' delete: operationId: deleteVault + description: Deletion also atomically purges any opaque Usage snapshot in this vault. summary: 按版本删除密文并保留墓碑,防止旧设备自动复活 parameters: - name: If-Match @@ -547,6 +548,7 @@ paths: $ref: '#/components/schemas/ErrorEnvelope' put: operationId: uploadSnapshot + description: A valid V1-only password change returns the existing 409 key_epoch_changed if an encrypted Usage snapshot exists. Ordinary writes and successful response shapes are unchanged. summary: 创建、更新或改密码;前置版本与幂等回执原子提交 parameters: - name: If-Match @@ -807,7 +809,435 @@ paths: application/json: schema: $ref: '#/components/schemas/ErrorEnvelope' + /v1/features/service-usage: + get: + operationId: getServiceUsageFeature + summary: Probe the optional service Usage wire protocol on the existing HTTPS origin + security: [] + responses: + '200': + description: Exact service Usage protocol and limits + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/UsageFeature' + '400': + $ref: '#/components/responses/UsageErrorInvalid' + '404': + description: An older server returns the expected invalid_request envelope for the unsupported probe path. + headers: + Cache-Control: + schema: {type: string, const: no-store} + content: + application/json: + schema: + $ref: '#/components/schemas/ErrorEnvelope' + '413': + $ref: '#/components/responses/UsageErrorTooLarge' + '415': + $ref: '#/components/responses/UsageErrorMediaType' + '429': + $ref: '#/components/responses/UsageErrorRateLimited' + '503': + $ref: '#/components/responses/UsageErrorUnavailable' + /v1/me/vault/usage: + get: + operationId: getServiceUsageMetadata + summary: Read opaque Usage metadata for the active vault and key epoch + parameters: + - name: If-None-Match + in: header + required: false + schema: + $ref: '#/components/schemas/UsageETag' + responses: + '200': + description: Usage metadata, empty or active + headers: + Cache-Control: + schema: + type: string + const: no-store + ETag: + schema: + $ref: '#/components/schemas/UsageETag' + content: + application/json: + schema: + $ref: '#/components/schemas/UsageMetadata' + '304': + description: Usage metadata unchanged + headers: + Cache-Control: + schema: + type: string + const: no-store + ETag: + schema: + $ref: '#/components/schemas/UsageETag' + '400': + $ref: '#/components/responses/UsageErrorInvalid' + '401': + $ref: '#/components/responses/UsageErrorUnauthorized' + '404': + $ref: '#/components/responses/UsageErrorNotFound' + '413': + $ref: '#/components/responses/UsageErrorTooLarge' + '415': + $ref: '#/components/responses/UsageErrorMediaType' + '429': + $ref: '#/components/responses/UsageErrorRateLimited' + '503': + $ref: '#/components/responses/UsageErrorUnavailable' + /v1/me/vault/usage/snapshot: + get: + operationId: downloadServiceUsageSnapshot + summary: Download the exact opaque Usage snapshot selected by the strong Usage ETag + parameters: + - name: If-Match + in: header + required: true + schema: + $ref: '#/components/schemas/UsageETag' + responses: + '200': + description: Opaque Usage snapshot + headers: + Cache-Control: + schema: + type: string + const: no-store + ETag: + schema: + $ref: '#/components/schemas/UsageETag' + content: + application/json: + schema: + $ref: '#/components/schemas/UsageSnapshot' + '400': + $ref: '#/components/responses/UsageErrorInvalid' + '401': + $ref: '#/components/responses/UsageErrorUnauthorized' + '404': + $ref: '#/components/responses/UsageErrorUsageNotFound' + '412': + $ref: '#/components/responses/UsageErrorCasConflict' + '413': + $ref: '#/components/responses/UsageErrorTooLarge' + '415': + $ref: '#/components/responses/UsageErrorMediaType' + '428': + $ref: '#/components/responses/UsageErrorPreconditionRequired' + '429': + $ref: '#/components/responses/UsageErrorRateLimited' + '503': + $ref: '#/components/responses/UsageErrorUnavailable' + put: + operationId: uploadServiceUsageSnapshot + summary: Replace the Usage snapshot independently of the V1 snapshot using Usage CAS + description: The authenticated active vault and epoch must match. Standalone HTTP body maximum is 1572864 bytes. Replay is byte-exact and precedes CAS. + parameters: + - name: If-Match + in: header + required: true + schema: + $ref: '#/components/schemas/UsageETag' + - name: Idempotency-Key + in: header + required: true + schema: + $ref: '#/components/schemas/UuidV4' + requestBody: + required: true + content: + application/json: + schema: + $ref: '#/components/schemas/UsageSnapshot' + responses: + '200': + description: Committed Usage receipt, possibly replayed + headers: + Cache-Control: + schema: + type: string + const: no-store + Idempotency-Replayed: + schema: + type: string + enum: ["true", "false"] + content: + application/json: + schema: + $ref: '#/components/schemas/UsageReceipt' + '400': + $ref: '#/components/responses/UsageErrorInvalid' + '401': + $ref: '#/components/responses/UsageErrorUnauthorized' + '403': + $ref: '#/components/responses/UsageErrorOwnerMismatch' + '409': + $ref: '#/components/responses/UsageErrorConflict' + '412': + $ref: '#/components/responses/UsageErrorCasConflict' + '413': + $ref: '#/components/responses/UsageErrorTooLarge' + '415': + $ref: '#/components/responses/UsageErrorMediaType' + '428': + $ref: '#/components/responses/UsageErrorPreconditionRequired' + '429': + $ref: '#/components/responses/UsageErrorRateLimited' + '503': + $ref: '#/components/responses/UsageErrorUnavailable' + /v1/me/vault/usage/operations/{operationId}: + get: + operationId: getServiceUsageOperation + summary: Read a committed Usage-only or dual-rotation receipt for up to seven days + parameters: + - name: operationId + in: path + required: true + schema: + $ref: '#/components/schemas/UuidV4' + responses: + '200': + description: Committed Usage receipt + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/UsageReceipt' + '400': + $ref: '#/components/responses/UsageErrorInvalid' + '401': + $ref: '#/components/responses/UsageErrorUnauthorized' + '404': + $ref: '#/components/responses/UsageErrorNotFound' + '413': + $ref: '#/components/responses/UsageErrorTooLarge' + '415': + $ref: '#/components/responses/UsageErrorMediaType' + '429': + $ref: '#/components/responses/UsageErrorRateLimited' + '503': + $ref: '#/components/responses/UsageErrorUnavailable' + /v1/me/vault/usage/password-change: + put: + operationId: rotateVaultPasswordWithServiceUsage + summary: Atomically re-encrypt the V1 snapshot and an existing Usage snapshot in a new key epoch + description: The If-Match header is the V1 vault ETag. The shared operation ID matches both envelopes. The HTTP body maximum is 25165824 bytes. Both CAS conditions and ciphertext replacements commit together. + parameters: + - name: If-Match + in: header + required: true + schema: + $ref: '#/components/schemas/StrongETag' + - name: Idempotency-Key + in: header + required: true + schema: + $ref: '#/components/schemas/UuidV4' + requestBody: + required: true + content: + application/json: + schema: + $ref: '#/components/schemas/UsageRotationRequest' + responses: + '200': + description: Committed paired receipts, possibly replayed + headers: + Cache-Control: + schema: + type: string + const: no-store + Idempotency-Replayed: + schema: + type: string + enum: ["true", "false"] + content: + application/json: + schema: + $ref: '#/components/schemas/UsageRotationReceipt' + '400': + $ref: '#/components/responses/UsageErrorInvalid' + '401': + $ref: '#/components/responses/UsageErrorUnauthorized' + '403': + $ref: '#/components/responses/UsageErrorOwnerMismatch' + '409': + $ref: '#/components/responses/UsageErrorUsageConflict' + '412': + $ref: '#/components/responses/UsageErrorCasConflict' + '413': + $ref: '#/components/responses/UsageErrorTooLarge' + '415': + $ref: '#/components/responses/UsageErrorMediaType' + '428': + $ref: '#/components/responses/UsageErrorPreconditionRequired' + '429': + $ref: '#/components/responses/UsageErrorRateLimited' + '503': + $ref: '#/components/responses/UsageErrorUnavailable' components: + responses: + UsageErrorInvalid: + description: invalid_request, invalid_crypto_header or unsupported_protocol as applicable + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/ErrorEnvelope' + UsageErrorTooLarge: + description: Payload exceeds the applicable HTTP or ciphertext limit + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/ErrorEnvelope' + UsageErrorMediaType: + description: Unsupported media type or content encoding + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/ErrorEnvelope' + UsageErrorRateLimited: + description: Request limit reached + headers: + Cache-Control: + schema: + type: string + const: no-store + Retry-After: + schema: + type: integer + minimum: 1 + maximum: 86400 + content: + application/json: + schema: + $ref: '#/components/schemas/ErrorEnvelope' + UsageErrorUnavailable: + description: Service unavailable; ordinary Usage writes may be paused in rescue mode + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/ErrorEnvelope' + UsageErrorUnauthorized: + description: Authentication required or session expired + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/ErrorEnvelope' + UsageErrorNotFound: + description: The requested resource is absent + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/ErrorEnvelope' + UsageErrorUsageNotFound: + description: The requested resource is absent + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/UsageErrorEnvelope' + UsageErrorCasConflict: + description: Revision or strong ETag conflict + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/ErrorEnvelope' + UsageErrorPreconditionRequired: + description: If-Match is required + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/ErrorEnvelope' + UsageErrorOwnerMismatch: + description: The envelope account differs from the authenticated numeric GitHub ID + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/ErrorEnvelope' + UsageErrorConflict: + description: Operation ID collision, vault state, key epoch, revision exhaustion or empty Usage as applicable + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/ErrorEnvelope' + UsageErrorUsageConflict: + description: Operation ID collision, vault state, key epoch, revision exhaustion or empty Usage as applicable + headers: + Cache-Control: + schema: + type: string + const: no-store + content: + application/json: + schema: + $ref: '#/components/schemas/UsageErrorEnvelope' securitySchemes: GithubBearer: type: http @@ -1269,8 +1699,149 @@ components: $ref: '#/components/schemas/UuidV4' currentRevision: $ref: '#/components/schemas/Revision' + UsageETag: + type: string + pattern: '^"usage-v1-[0-9a-f]{64}"$' + description: Strong Usage tag including the quotes; opaque and distinct from V1. + UsageFeature: + type: object + additionalProperties: false + required: [protocolVersion, maxCiphertextBytes, maxBodyBytes] + properties: + protocolVersion: {type: integer, const: 1} + maxCiphertextBytes: {type: integer, const: 1048592} + maxBodyBytes: {type: integer, const: 1572864} + UsageMetadata: + type: object + additionalProperties: false + required: [protocolVersion, state, ownerGithubId, vaultId, keyId, revision, updatedAt, lastOperationId, ciphertextSha256, ciphertextBytes] + properties: + protocolVersion: {type: integer, const: 1} + state: {type: string, enum: [empty, active]} + ownerGithubId: + $ref: '#/components/schemas/GithubId' + vaultId: + $ref: '#/components/schemas/UuidV4' + keyId: + $ref: '#/components/schemas/UuidV4' + revision: + $ref: '#/components/schemas/Revision' + updatedAt: {type: [string, 'null'], format: date-time} + lastOperationId: + oneOf: + - $ref: '#/components/schemas/UuidV4' + - type: 'null' + ciphertextSha256: + oneOf: + - $ref: '#/components/schemas/Sha256' + - type: 'null' + ciphertextBytes: {type: integer} + oneOf: + - properties: + state: {const: empty} + revision: {const: '0'} + updatedAt: {type: 'null'} + lastOperationId: {type: 'null'} + ciphertextSha256: {type: 'null'} + ciphertextBytes: {const: 0} + - properties: + state: {const: active} + revision: + $ref: '#/components/schemas/PositiveRevision' + updatedAt: {type: string} + lastOperationId: {type: string} + ciphertextSha256: {type: string} + ciphertextBytes: {minimum: 65552, maximum: 1048592} + UsageSnapshot: + type: object + additionalProperties: false + required: [protocolVersion, payloadSchemaVersion, ownerGithubId, vaultId, keyId, baseRevision, revision, operationId, aead, codec, nonce, ciphertextSha256, ciphertext] + description: Revision must be baseRevision + 1. The authenticated numeric owner, active vault and key epoch are bound to the request. See service-usage.md for exact AAD, canonical decoding and padding. + properties: + protocolVersion: {type: integer, const: 1} + payloadSchemaVersion: {type: integer, const: 1} + ownerGithubId: + $ref: '#/components/schemas/GithubId' + vaultId: + $ref: '#/components/schemas/UuidV4' + keyId: + $ref: '#/components/schemas/UuidV4' + baseRevision: + $ref: '#/components/schemas/Revision' + revision: + $ref: '#/components/schemas/PositiveRevision' + operationId: + $ref: '#/components/schemas/UuidV4' + aead: {type: string, const: xchacha20poly1305-ietf} + codec: {type: string, const: json-pad64k-v1} + nonce: + type: string + pattern: ^[A-Za-z0-9_-]{32}$ + description: CSPRNG 24-byte nonce, canonical unpadded base64url. + ciphertextSha256: + $ref: '#/components/schemas/Sha256' + ciphertext: + type: string + pattern: ^[A-Za-z0-9_-]+$ + minLength: 87403 + maxLength: 1398123 + description: Canonical unpadded base64url of 1 to 16 padded 65536-byte blocks plus 16-byte AEAD tag. + UsageReceipt: + allOf: + - $ref: '#/components/schemas/OperationReceipt' + - properties: + kind: {enum: [snapshot, password_change]} + ciphertextSha256: + $ref: '#/components/schemas/Sha256' + UsageRotationRequest: + type: object + additionalProperties: false + required: [vaultSnapshot, usageIfMatch, usageSnapshot] + properties: + vaultSnapshot: + allOf: + - $ref: '#/components/schemas/SnapshotUpload' + - properties: + kind: {const: password_change} + usageIfMatch: + $ref: '#/components/schemas/UsageETag' + usageSnapshot: + $ref: '#/components/schemas/UsageSnapshot' + UsageRotationReceipt: + type: object + additionalProperties: false + required: [vaultReceipt, usageReceipt] + properties: + vaultReceipt: + allOf: + - $ref: '#/components/schemas/OperationReceipt' + - properties: + kind: {const: password_change} + usageReceipt: + allOf: + - $ref: '#/components/schemas/UsageReceipt' + - properties: + kind: {const: password_change} + UsageErrorEnvelope: + oneOf: + - $ref: '#/components/schemas/ErrorEnvelope' + - type: object + additionalProperties: false + required: [error] + properties: + error: + type: object + additionalProperties: false + required: [code, message, requestId] + properties: + code: {const: usage_empty} + message: {type: string, minLength: 1, maxLength: 200} + requestId: + $ref: '#/components/schemas/UuidV4' + currentRevision: {const: '0'} x-contract-files: - requirements.md - http-api.md - encryption-protocol.md - client-integration.md +- service-usage.md diff --git a/docs/requirements.md b/docs/requirements.md index 31e44eb..e36f92c 100644 --- a/docs/requirements.md +++ b/docs/requirements.md @@ -1,5 +1,7 @@ # 加密云同步需求 +Unreleased additive scope and release gates: [Encrypted service Usage sidecar](service-usage.md). Service Usage is not V1 Activity; neither server aggregation nor plaintext upload is allowed. + 状态:产品需求合同;版本 `1.0-draft.1`;更新:2026-09-23。服务端 `0.1.0` 已实现,验证及未完成事项见 [服务端验收](server-acceptance.md);客户端要求仍需应用实现。接口见 [文档入口](index.md)。 ## 1. 目标与不可混淆的概念 diff --git a/docs/server-acceptance.md b/docs/server-acceptance.md index 391c8bc..b155cb8 100644 --- a/docs/server-acceptance.md +++ b/docs/server-acceptance.md @@ -54,3 +54,7 @@ 8. 灾备:隔离环境验证恢复与版本/墓碑核对;定时清理和供应商快照不超过公开的 7 天。 之后再进入应用 A01–A13:默认关闭与首次提示、完整导出和排除项、凭据/文件恢复失败、崩溃恢复、三方合并、Windows/macOS 差异。它们属于 `1-app/`,本次没有修改应用。项目许可证已确认为 AGPL-3.0-only;公开启用还需需求指定的独立安全审查。 + +## Unreleased service Usage gates + +The repository tests use synthetic IDs, test-only keys, an isolated SQLite database, and the real HTTP router. They cover a standalone feature probe, unchanged settings and history transport, encrypted Usage joins and no echo (10+7=17; +4/+2=23), CAS races, exact replay and cross-route collisions, paired rotation, transaction failure, migrated database continuity and write-preserving rescue. The fixed Usage AAD fixture is independently checked with RustCrypto and libsodium. These are not two shipped-app or cloud-staging results. Capacity/overflow with representative data, actual release-to-release device restore, privacy and consent, and the operator's staging/rescue rehearsal are still gates; see [service Usage](service-usage.md) and [isolated staging](deployment.md#unreleased-service-usage-isolated-staging-and-preservation-first-rescue). diff --git a/docs/service-usage.md b/docs/service-usage.md new file mode 100644 index 0000000..a08ee97 --- /dev/null +++ b/docs/service-usage.md @@ -0,0 +1,50 @@ +# Encrypted service Usage sidecar — protocol 1 + +This is a separate resource on the same HTTPS origin as encrypted V1 sync. The existing V1 capabilities, vault, snapshot and receipt response shapes and limits do not change. An old client can continue to restore and replace its V1 settings/history snapshot without seeing or touching Usage. V1 `activity` (`sourceDeviceId` / date / `count`, `chars`, `durationMs`) is not service Usage. Do not place unsupported values (including Beta `pipelineMode=deepseek`) into a V1 snapshot; legacy-safe preferences are a client responsibility. `voiceActivationHotkeyLinked` is device-local. + +## Discovery, requests and recovery + +| Method and path | Request | Success | +| --- | --- | --- | +| `GET /v1/features/service-usage` | Public, no credentials or redirect | Exactly `{"protocolVersion":1,"maxCiphertextBytes":1048592,"maxBodyBytes":1572864}` | +| `GET /v1/me/vault/usage` | Sync bearer; optional Usage `If-None-Match` | `UsageMetadata` and `ETag`, or `304` and `ETag` with no body | +| `GET /v1/me/vault/usage/snapshot` | Sync bearer; Usage `If-Match` | `UsageSnapshot` and the matching `ETag` | +| `PUT /v1/me/vault/usage/snapshot` | Sync bearer; Usage `If-Match`; `Idempotency-Key`; `UsageSnapshot` | `UsageReceipt` and `Idempotency-Replayed: true\|false` | +| `GET /v1/me/vault/usage/operations/{operationId}` | Sync bearer; UUIDv4 path | `UsageReceipt` | +| `PUT /v1/me/vault/usage/password-change` | Sync bearer; **V1 vault** `If-Match`; `Idempotency-Key`; `UsageRotationRequest` | `{"vaultReceipt":,"usageReceipt":}` and `Idempotency-Replayed: true\|false` | + +`GET` uses an empty request body. `PUT` uses `application/json` without compression. JSON objects are strict: unknown or duplicate fields are not accepted on upload. Interpret only a validated same-origin feature `200` as support, or the legacy service's expected same-origin `404 invalid_request` error envelope as unsupported; TLS, transport, redirect, auth, throttling or malformed responses must be distinguishable from unsupported. Never probe or fall back to a legacy plaintext endpoint. The feature probe describes protocol support, not consent or permission to write. + +`UsageMetadata` has exactly `protocolVersion:1`, `state:"empty"|"active"`, `ownerGithubId` (canonical positive decimal string), `vaultId` and `keyId` (canonical lower-case UUIDv4), `revision` (canonical uint64 decimal string), `updatedAt` (UTC timestamp), `lastOperationId` (UUIDv4), `ciphertextSha256` (lower-case hex SHA-256), and `ciphertextBytes` (integer). Active means positive revision, all three optional values populated, and at least 65,552 ciphertext bytes. Empty inside an active V1 vault has revision `"0"`, those three values are `null`, and `ciphertextBytes:0`. There is no Usage metadata for an absent or deleted vault. The strong Usage tag matches exactly `^"usage-v1-[0-9a-f]{64}"$` (quotes included); treat it as opaque. It binds both numeric owner and vault/key IDs even when empty. It is distinct from the V1 tag. Wildcards, lists, weak and wrong-namespace Usage tags are invalid. + +The strict `UsageSnapshot` has exactly `protocolVersion:1`, `payloadSchemaVersion:1`, `ownerGithubId`, `vaultId`, `keyId`, `baseRevision`, `revision`, `operationId`, `aead:"xchacha20poly1305-ietf"`, `codec:"json-pad64k-v1"`, `nonce`, `ciphertextSha256` and `ciphertext`. The `operationId` uses the same UUID grammar as the V1 protocol. `revision = baseRevision + 1` with no wrap; the server compares **both** the fetched Usage ETag and base revision. V1 and Usage revisions advance independently on ordinary writes. New Usage after vault recreation begins at `"0"` with a different vault/epoch/ETag; do not automatically re-upload a deleted vault's imported records to a new vault. A password change in an empty Usage epoch retains revision `"0"` and changes its ETag. + +The exact `UsageReceipt` is `{"operationId":,"status":"committed","kind":"snapshot"|"password_change","committedRevision":,"committedAt":,"vaultId":,"ciphertextSha256":}`. A receipt is an immutable commitment, not evidence that those bytes are still the active snapshot. Receipts, with only the hash and no ciphertext, are retained for 604,800 seconds even after rotation or delete. A numeric account's operation IDs are shared across route families during retention: reusing an ID with a different path, method, `If-Match`, or body bytes is `409 idempotency_key_reused`. Exact same-route replay precedes CAS and returns the original receipt without advancing a revision. Usage-only operations are available only in the Usage lookup; V1-only operations only in the V1 lookup; dual rotation appears in both. Client retries must retain the original request bytes, preconditions and ID until the outcome is confirmed. After receipt expiry, re-read and authenticate current state before deciding whether a new write is needed; never blindly replay an expired operation. + +Absent/deleted vaults produce `404 vault_empty`/`vault_deleted` on Usage reads and `409 vault_empty`/`vault_deleted` for new writes. A valid snapshot read at an empty Usage head is `404 usage_empty`; a dual rotation on an empty Usage head is `409 usage_empty`. Stale CAS is `412 revision_conflict`; a valid write to the current vault from a stale key is `409 key_epoch_changed`. Error `currentRevision` is that of the resource whose precondition failed (for the dual route, V1 validation/CAS is evaluated before Usage CAS; callers should re-read both on conflict). Authentication, size, malformed-input, media-type, precondition, rate-limit and service errors keep the V1 conventions. A failed write never authorizes overwriting local data. No endpoint exposes record counts, types or any plaintext content. + +## Key epochs, rotation and deletion + +An old V1 password change is unchanged if no Usage snapshot exists. If one exists, a valid V1-only rotation returns the existing `409 key_epoch_changed` without changing either resource; do not tell the user the password has changed. Upgrade the client rather than deleting or retaining the old cloud key. The upgraded client downloads/authenticates both heads, decrypts both using the current key, makes a fresh V1 `password_change` with new key ID and salt, and re-encrypts the Usage records with that new vault key. The dual request is exactly `{"vaultSnapshot":,"usageIfMatch":,"usageSnapshot":}`. The snapshots and `Idempotency-Key` share the same operation ID; the owner, vault and new key match; the two nonces must differ. The committed Usage revision advances by one; it does not reset on rotation within a vault. Both replacements, both nonce reservations and both receipts are atomic. After lost acknowledgement, retain both protected key states, check the receipt endpoints or retry the identical dual request, then authenticate current metadata. A competing V1 or Usage write makes the rotation fail without consuming key, salt, nonce or operation ID. When Usage is empty the upgraded client uses the original V1 password-change route; if a first Usage write wins the race the guard requires re-reading both. + +A legacy DELETE of a vault atomically removes **both** snapshots when the V1 CAS succeeds. Another device must not apply a stale Usage response from a previous vault/key, upload to a different account, or recreate a vault without explicit user action. A client deleting a vault should clear or quarantine imported records associated with that vault only after resolving the operation; local-origin records remain distinct. Backups remain subject to the service's deletion retention policy. + +## Cryptography and bounds + +Use the V1-derived 32-byte vault key of the matching key epoch, the same V1 KDF parameters, CSPRNG and framing: `uint32_be(jsonByteLength) || UTF-8 JSON || random padding` to a multiple of 65,536 bytes with at least one block. Use an independent fresh 24-byte XChaCha20-Poly1305 nonce for **every** fresh encryption, including settings/Usage and after rejected writes; the server also reserves nonces across both resources for a numeric owner/key. Do not re-encrypt on exact retry. Use canonical base64url without `=` for nonce and combined ciphertext (last 16 bytes are the AEAD tag); hash the decoded combined ciphertext, not plaintext. The maximum ciphertext is 1,048,592 bytes (16 blocks plus tag), maximum plaintext JSON is 1,048,572 bytes, and standalone Usage PUT is at most 1,572,864 HTTP body bytes. Dual rotation's whole wrapper uses the unchanged 25,165,824-byte V1 HTTP ceiling, enough for both maximal ciphertexts in canonical envelopes. Never put a password, key, plaintext hash or record metadata in the HTTP envelope or logs. + +AAD bytes are compact UTF-8 JSON of this ordered array (no spaces, BOM or terminal newline): + +```json +["openless-cloud-sync",1,"service-usage","OWNER_GITHUB_ID","VAULT_ID","KEY_ID","BASE_REVISION","REVISION","OPERATION_ID",1,"xchacha20poly1305-ietf","json-pad64k-v1"] +``` + +Positions 2 and 10 (one-based) are `protocolVersion` and `payloadSchemaVersion`. Use the canonical ASCII wire strings for IDs/revisions. The raw decoded nonce is the AEAD nonce, not part of the array. Independently validate the numeric owner, origin binding, vault, key, revision and metadata hash against the authenticated request and persisted high-water state. A 200/304 response is not proof of valid decryption or of freshness to a brand-new device. The different AAD domain prevents substituting a V1 snapshot for Usage even under the same key. See the [fixed public test vector](../tests/vectors/service-usage-v1.json). + +## Encrypted payload and client release gates + +The plaintext document is `{ "version": 1, "records": [...] }`. Each record has `id` (stable operation UUIDv4), `occurredAtMs` (i64 UTC Unix milliseconds), `kind` (`asr|llm|tts|multimodal`), `purpose` (`dictation|dictationPostprocess|translation|question|selection|quickNote|voiceEdit|cloudNote|other`), `outcome` (`succeeded|failed|cancelled|unknown`), optional sanitized categorical labels `provider`, `service`, `protocol`, `channel`, `model`, optional `inputAccounting` (`inclusive|excludesCache`), and optional u64 `audioMs`, `inputTokens`, `outputTokens`, `cachedInputTokens`, `cacheWriteInputTokens`, `reasoningTokens`, `synthesizedCharacters`. Do not put prompts, transcripts, audio, URLs, credentials, headers, or raw provider responses in Usage. Optional fields may be null or absent; compare typed records after normalization. Preserve provider-reported quantities; absent values do not equal observed zeros. Counts and totals are projections, never uploadable operations. These plaintext fields are enforced by clients, not the opaque server. + +Keep imported records bound to service origin, numeric owner and vault and separate from locally attributed records. Union by stable UUID; identical duplicates are a no-op; different records for the same UUID fail visibly and preserve both inputs for recovery rather than choosing silently. On CAS conflict download, verify and merge before attempting a fresh write. Compare the canonical merged set to the authenticated remote set **before** re-encrypting; equal sets do not upload. Retain the current encrypted snapshot until an authorized replacement/delete. There is no server-side record TTL or per-record eviction. Initially do not silently window the union or imply a partial projection is complete. If the proposed authenticated set exceeds the client bounds (10,000 records, 8 MiB local input) or the smaller cloud envelope, leave the last valid remote snapshot and the unsynced local records intact and display overflow/unsynced state. Any retention revision is a separate product decision that must account for independent devices returning online and prove that pruned records do not reappear unexpectedly. + +Client consent and Usage transport default off; a working feature probe is not consent. No deployment or production enablement before a separate authorized staging target, actual pinned old/new client run, durable restore, explicit history/privacy/consent verification and representative-capacity assessment. The synthetic HTTP/interop tests do not validate shipped UI, production deployment, or those independent gates. For operations and rollback, see [deployment](deployment.md). diff --git a/migrations/002_service_usage.sql b/migrations/002_service_usage.sql new file mode 100644 index 0000000..3e789be --- /dev/null +++ b/migrations/002_service_usage.sql @@ -0,0 +1,16 @@ +CREATE TABLE service_usage ( + owner TEXT PRIMARY KEY REFERENCES vaults(owner), + metadata TEXT NOT NULL, + snapshot BLOB NOT NULL, + CHECK (json_extract(metadata, '$.ownerGithubId') = owner) +) STRICT; +CREATE TABLE service_usage_operations ( + owner TEXT NOT NULL, + operation_id TEXT NOT NULL, + fingerprint TEXT NOT NULL, + receipt TEXT NOT NULL, + committed_at INTEGER NOT NULL, + PRIMARY KEY (owner, operation_id) +) STRICT; +CREATE INDEX service_usage_operations_expiry ON service_usage_operations(committed_at); +PRAGMA user_version = 2; diff --git a/scripts/check_contract.py b/scripts/check_contract.py index dff1d91..7be78b4 100644 --- a/scripts/check_contract.py +++ b/scripts/check_contract.py @@ -18,6 +18,10 @@ samples = json.loads(path.read_text(encoding="utf-8")) for sample in samples: response = spec["paths"][sample["path"]][sample["method"]]["responses"][sample["status"]] + if "$ref" in response: + prefix = "#/components/responses/" + assert response["$ref"].startswith(prefix) + response = spec["components"]["responses"][response["$ref"][len(prefix):]] if "content" in response: schema = {"components": spec["components"], **response["content"]["application/json"]["schema"]} jsonschema.Draft202012Validator(schema, format_checker=jsonschema.FormatChecker()).validate(sample["body"]) diff --git a/scripts/interop_vectors.py b/scripts/interop_vectors.py index 9df150b..c922b88 100755 --- a/scripts/interop_vectors.py +++ b/scripts/interop_vectors.py @@ -70,18 +70,56 @@ def vector(password: str, index: int) -> dict: } +def usage_vector() -> dict: + password = "云同步Cafe\u0301-Vector2026!" + normalized = unicodedata.normalize("NFC", password) + salt = bytes(range(16)) + nonce = bytes(range(32, 56)) + key = hash_secret_raw(normalized.encode(), salt, 3, 65536, 4, 32, Type.ID, 19) + snapshot = { + "protocolVersion": 1, "payloadSchemaVersion": 1, "ownerGithubId": "12345", + "vaultId": "be406ca5-37fa-4b26-9a9a-74c1aad48eae", + "keyId": "7250d1bd-5a3e-42b0-91dc-df0cb0608221", + "baseRevision": "9007199254740992", "revision": "9007199254740993", + "operationId": "6141fa7e-d06f-47b4-9b16-ec92f4083685", + "aead": "xchacha20poly1305-ietf", "codec": "json-pad64k-v1", "nonce": b64(nonce), + } + aad = compact([ + "openless-cloud-sync", 1, "service-usage", snapshot["ownerGithubId"], snapshot["vaultId"], + snapshot["keyId"], snapshot["baseRevision"], snapshot["revision"], snapshot["operationId"], + 1, snapshot["aead"], snapshot["codec"], + ]) + document = {"version": 1, "records": [{ + "id": "d7823e4d-19fa-4780-b605-f9abf2d3d5e3", "occurredAtMs": 1795104000000, + "kind": "llm", "purpose": "translation", "outcome": "succeeded", + "provider": "fixture-provider", "inputAccounting": "inclusive", "inputTokens": 10, + }]} + plaintext = compact(document) + padding_length = 65536 - 4 - len(plaintext) + frame = struct.pack(">I", len(plaintext)) + plaintext + bytes(i % 251 for i in range(padding_length)) + ciphertext = encrypt(frame, aad, nonce, key) + assert decrypt(ciphertext, aad, nonce, key) == frame + snapshot["ciphertext"] = b64(ciphertext) + snapshot["ciphertextSha256"] = hashlib.sha256(ciphertext).hexdigest() + return {"formatVersion": 1, "testOnly": True, "passwordInput": password, "salt": b64(salt), + "derivedKeyHex": key.hex(), "aadUtf8Hex": aad.hex(), "plaintextJsonUtf8Hex": plaintext.hex(), + "recoveredJson": document, "padding": {"pattern": "index-mod-251", "length": padding_length}, + "snapshot": snapshot} + + def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--write", action="store_true", help="Regenerate fixed public TEST fixtures") args = parser.parse_args() expected = {"formatVersion": 1, "vectors": [vector("云同步Cafe\u0301-Vector2026!", 0), vector("测试A9-Interoperability!", 1)]} - path = ROOT / "tests/vectors/v1.json" - if args.write: - path.parent.mkdir(parents=True, exist_ok=True) - path.write_text(json.dumps(expected, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") - else: - assert json.loads(path.read_text(encoding="utf-8")) == expected, "Independent implementation disagrees with fixture" - print("PASS: reference Argon2 + libsodium; 2 fixed v1 vectors") + for name, value in [("v1.json", expected), ("service-usage-v1.json", usage_vector())]: + path = ROOT / "tests/vectors" / name + if args.write: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + else: + assert json.loads(path.read_text(encoding="utf-8")) == value, f"Independent implementation disagrees with {name}" + print("PASS: reference Argon2 + libsodium; 2 fixed V1 vectors and 1 fixed service Usage vector") if __name__ == "__main__": diff --git a/src/config.rs b/src/config.rs index d01fa1e..98e61a1 100644 --- a/src/config.rs +++ b/src/config.rs @@ -1,6 +1,12 @@ use std::{collections::HashSet, env, net::SocketAddr, path::PathBuf}; use zeroize::Zeroizing; +#[derive(Clone, Copy, PartialEq, Eq)] +pub enum UsageMode { + Enabled, + Rescue, +} + // Deliberately no Debug: configuration contains an OAuth client secret. pub struct Config { pub bind: SocketAddr, @@ -11,6 +17,7 @@ pub struct Config { pub allowed_github_ids: HashSet, pub public_access: bool, pub require_https_proxy: bool, + pub usage_mode: UsageMode, } impl Config { @@ -64,6 +71,11 @@ impl Config { return Err("Origin must be an exact HTTPS origin"); } } + let usage_mode = match env::var("SYNC_SERVICE_USAGE_MODE").as_deref() { + Ok("enabled") => UsageMode::Enabled, + Ok("rescue") | Err(env::VarError::NotPresent) => UsageMode::Rescue, + _ => return Err("invalid SYNC_SERVICE_USAGE_MODE"), + }; Ok(Self { bind, database: env::var("SYNC_DATABASE") @@ -75,6 +87,7 @@ impl Config { allowed_github_ids, public_access: mode == "public", require_https_proxy: development != "true", + usage_mode, }) } } diff --git a/src/lib.rs b/src/lib.rs index e67de74..57a0176 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -4,3 +4,4 @@ pub mod error; pub mod protocol; pub mod server; pub mod store; +pub mod usage; diff --git a/src/server.rs b/src/server.rs index 2832064..11d3e7f 100644 --- a/src/server.rs +++ b/src/server.rs @@ -4,6 +4,7 @@ use crate::{ error::{ApiError, Result}, protocol, store::{Mutation, Store}, + usage, }; use axum::{ Json, Router, @@ -175,7 +176,7 @@ async fn handle(state: &AppState, request: Request) -> Result { ); return Ok(response); } - if path == "/v1/capabilities" && method == Method::GET { + if matches!(path.as_str(), "/v1/capabilities" | usage::FEATURE) && method == Method::GET { state .store .rate( @@ -186,6 +187,11 @@ async fn handle(state: &AppState, request: Request) -> Result { ) .await?; read_body(request, protocol::MAX_CONTROL, false).await?; + if path == usage::FEATURE { + return Ok(Json(serde_json::json!({"protocolVersion":1, + "maxCiphertextBytes":usage::MAX_CIPHERTEXT,"maxBodyBytes":usage::MAX_BODY})) + .into_response()); + } return Ok(Json(serde_json::json!({"protocolVersion":1,"cryptoProfile":protocol::PROFILE, "githubClientId":state.config.github_client_id,"maxHttpBodyBytes":protocol::MAX_BODY, "maxCiphertextBytes":protocol::MAX_CIPHERTEXT,"maxPlaintextJsonBytes":protocol::MAX_JSON, @@ -214,7 +220,11 @@ async fn handle(state: &AppState, request: Request) -> Result { let known_route = (path == "/v1/auth/session" && method == Method::DELETE) || (path == "/v1/me/vault" && matches!(method, Method::GET | Method::DELETE)) || (path == "/v1/me/vault/snapshot" && matches!(method, Method::GET | Method::PUT)) - || (path.starts_with("/v1/me/operations/") && method == Method::GET); + || (path.starts_with("/v1/me/operations/") && method == Method::GET) + || (path == usage::RESOURCE && method == Method::GET) + || (path == usage::SNAPSHOT && matches!(method, Method::GET | Method::PUT)) + || (path == usage::ROTATE && method == Method::PUT) + || (path.starts_with(usage::OPERATIONS) && method == Method::GET); if !known_route { return Err(ApiError::new(StatusCode::NOT_FOUND, "invalid_request")); } @@ -254,28 +264,42 @@ async fn handle(state: &AppState, request: Request) -> Result { state.store.revoke(token_hash).await?; Ok(StatusCode::NO_CONTENT.into_response()) } - ("GET", "/v1/me/vault") => { + ("GET", "/v1/me/vault" | usage::RESOURCE) => { + let is_usage = path == usage::RESOURCE; let condition = one_header(headers, "if-none-match")?.map(str::to_owned); if let Some(tag) = &condition { - protocol::etag(Some(tag))?; + if is_usage { + usage::etag(Some(tag))?; + } else { + protocol::etag(Some(tag))?; + } } read_body(request, protocol::MAX_CONTROL, false).await?; - let metadata = state.store.metadata(owner).await?; - let tag = metadata.etag(); - let mut response = if condition.as_ref() == Some(&tag) { - StatusCode::NOT_MODIFIED.into_response() + if is_usage { + let metadata = state.store.usage_metadata(owner).await?; + let tag = metadata.etag(); + Ok(conditional_json(metadata, tag, condition)) } else { - Json(metadata).into_response() - }; - response - .headers_mut() - .insert("etag", tag.parse().expect("generated ETag")); - Ok(response) + let metadata = state.store.metadata(owner).await?; + let tag = metadata.etag(); + Ok(conditional_json(metadata, tag, condition)) + } } - ("GET", "/v1/me/vault/snapshot") => { - let tag = protocol::etag(one_header(headers, "if-match")?)?.to_owned(); + ("GET", "/v1/me/vault/snapshot" | usage::SNAPSHOT) => { + let is_usage = path == usage::SNAPSHOT; + let header = one_header(headers, "if-match")?; + let tag = if is_usage { + usage::etag(header)? + } else { + protocol::etag(header)? + } + .to_owned(); read_body(request, protocol::MAX_CONTROL, false).await?; - let bytes = state.store.download(owner, tag.clone()).await?; + let bytes = if is_usage { + state.store.usage_download(owner, tag.clone()).await? + } else { + state.store.download(owner, tag.clone()).await? + }; let mut response = Body::from(bytes).into_response(); response .headers_mut() @@ -285,32 +309,45 @@ async fn handle(state: &AppState, request: Request) -> Result { .insert("etag", tag.parse().expect("validated ETag")); Ok(response) } - ("PUT", "/v1/me/vault/snapshot") | ("DELETE", "/v1/me/vault") => { + ("PUT", "/v1/me/vault/snapshot" | usage::SNAPSHOT | usage::ROTATE) + | ("DELETE", "/v1/me/vault") => { let tag = one_header(headers, "if-match")?.map(str::to_owned); let id = one_header(headers, "idempotency-key")? .ok_or_else(ApiError::invalid)? .to_owned(); protocol::uuid(&id)?; - let bytes = read_body( - request, - if method == Method::PUT { - protocol::MAX_BODY - } else { - protocol::MAX_CONTROL - }, - true, - ) - .await?; - let (receipt, replayed) = state - .store - .mutate(Mutation::new(owner, method.as_str(), &path, tag, id, bytes)) - .await?; - let mut response = Json(receipt).into_response(); - response.headers_mut().insert( - "idempotency-replayed", - HeaderValue::from_static(if replayed { "true" } else { "false" }), - ); - Ok(response) + let limit = if path == usage::SNAPSHOT { + usage::MAX_BODY + } else if method == Method::PUT { + protocol::MAX_BODY + } else { + protocol::MAX_CONTROL + }; + let bytes = read_body(request, limit, true).await?; + let mutation = Mutation::new(owner, method.as_str(), &path, tag, id, bytes); + match path.as_str() { + usage::SNAPSHOT => { + let (receipt, replayed) = state + .store + .usage_mutate(mutation, state.config.usage_mode) + .await?; + Ok(receipt_json(receipt, replayed)) + } + usage::ROTATE => { + let (receipt, replayed) = state.store.rotate_usage(mutation).await?; + Ok(receipt_json(receipt, replayed)) + } + _ => { + let (receipt, replayed) = state.store.mutate(mutation).await?; + Ok(receipt_json(receipt, replayed)) + } + } + } + ("GET", _) if path.starts_with(usage::OPERATIONS) => { + let id = path[usage::OPERATIONS.len()..].to_owned(); + protocol::uuid(&id)?; + read_body(request, protocol::MAX_CONTROL, false).await?; + Ok(Json(state.store.usage_operation(owner, id).await?).into_response()) } _ => { let id = path @@ -324,6 +361,31 @@ async fn handle(state: &AppState, request: Request) -> Result { } } +fn conditional_json( + value: impl serde::Serialize, + tag: String, + condition: Option, +) -> Response { + let mut response = if condition.as_ref() == Some(&tag) { + StatusCode::NOT_MODIFIED.into_response() + } else { + Json(value).into_response() + }; + response + .headers_mut() + .insert("etag", tag.parse().expect("generated ETag")); + response +} + +fn receipt_json(receipt: impl serde::Serialize, replayed: bool) -> Response { + let mut response = Json(receipt).into_response(); + response.headers_mut().insert( + "idempotency-replayed", + HeaderValue::from_static(if replayed { "true" } else { "false" }), + ); + response +} + fn one_header<'a>(headers: &'a HeaderMap, name: &str) -> Result> { let mut values = headers.get_all(name).iter(); let first = values.next(); diff --git a/src/store.rs b/src/store.rs index ad71e00..e6c73c5 100644 --- a/src/store.rs +++ b/src/store.rs @@ -1,3 +1,5 @@ +mod usage; + use crate::{ error::{ApiError, Result}, protocol::{self, DeleteRequest, Metadata, Receipt, Snapshot, UploadKind}, @@ -61,15 +63,18 @@ impl Store { db.busy_timeout(Duration::from_secs(10))?; // DELETE journal and secure_delete avoid retaining old ciphertext in WAL/free pages. db.execute_batch("PRAGMA journal_mode=DELETE; PRAGMA synchronous=FULL; PRAGMA secure_delete=ON; PRAGMA foreign_keys=ON;")?; - let version: i64 = db.query_row("PRAGMA user_version", [], |r| r.get(0))?; - if version > 1 { + let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; + let version: i64 = tx.query_row("PRAGMA user_version", [], |r| r.get(0))?; + if !(0..=2).contains(&version) { return Err(ApiError::unavailable()); } if version == 0 { - let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; tx.execute_batch(include_str!("../migrations/001_initial.sql"))?; - tx.commit()?; } + if version < 2 { + tx.execute_batch(include_str!("../migrations/002_service_usage.sql"))?; + } + tx.commit()?; Ok(Self(Arc::new(Mutex::new(db)))) } @@ -128,100 +133,104 @@ impl Store { } pub async fn operation(&self, owner: String, id: String) -> Result { - self.run(move |db| { - let receipt: Option = db.query_row("SELECT receipt FROM operations WHERE owner=?1 AND operation_id=?2 AND committed_at>=?3", - params![owner, id, Utc::now().timestamp()-protocol::RETENTION], |r| r.get(0)).optional()?; - receipt.map(|r| from_db(&r)).unwrap_or_else(|| Err(ApiError::new(StatusCode::NOT_FOUND, "operation_not_found"))) - }).await + self.run(move |db| operation(db, OperationRoute::Vault, &owner, &id)) + .await } pub async fn mutate(&self, request: Mutation) -> Result<(Receipt, bool)> { self.run(move |db| { - let limit = if request.method == "PUT" { protocol::MAX_BODY } else { protocol::MAX_CONTROL }; - if request.body.len() > limit { return Err(ApiError::too_large()); } + let limit = if request.method == "PUT" { + protocol::MAX_BODY + } else { + protocol::MAX_CONTROL + }; + if request.body.len() > limit { + return Err(ApiError::too_large()); + } protocol::uuid(&request.operation_id)?; let fingerprint = request.fingerprint(); let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; let now = Utc::now(); - let prior: Option<(String, String)> = tx.query_row( - "SELECT fingerprint, receipt FROM operations WHERE owner=?1 AND operation_id=?2 AND committed_at>=?3", - params![request.owner, request.operation_id, now.timestamp()-protocol::RETENTION], |r| Ok((r.get(0)?, r.get(1)?))).optional()?; - if let Some((original, receipt)) = prior { - if fingerprint != original { return Err(ApiError::new(StatusCode::CONFLICT, "idempotency_key_reused")); } - return Ok((from_db(&receipt)?, true)); + if let Some(prior) = replay(&tx, &request, &fingerprint, now.timestamp())? { + return Ok((prior.vault.ok_or_else(ApiError::unavailable)?, true)); } let tag = protocol::etag(request.if_match.as_deref())?; let old = read_metadata(&tx, &request.owner)?; let timestamp = now.to_rfc3339_opts(SecondsFormat::Secs, true); let (meta, receipt, snapshot) = match (request.method.as_str(), request.path.as_str()) { ("PUT", "/v1/me/vault/snapshot") => { - let upload: Snapshot = serde_json::from_slice(&request.body).map_err(|_| ApiError::invalid())?; - let size = upload.validate(&request.owner)?; - if upload.operation_id != request.operation_id { return Err(ApiError::invalid()); } - if old.state == "active" && upload.kind == UploadKind::Snapshot && old.key_id.as_ref() != Some(&upload.key_id) { - return Err(ApiError::conflict("key_epoch_changed", &old.revision)); - } - check_cas(&old, tag, &upload.base_revision)?; - match upload.kind { - UploadKind::Create => { - if old.state == "active" { return Err(ApiError::conflict("vault_exists", &old.revision)); } - remember(&tx, &request.owner, "vault", &upload.vault_id, "invalid_crypto_header")?; - remember_epoch(&tx, &request.owner, &upload)?; - } - UploadKind::Snapshot | UploadKind::PasswordChange => { - if old.state != "active" { return Err(state_conflict(&old)); } - if old.vault_id.as_ref() != Some(&upload.vault_id) { return Err(ApiError::conflict("revision_conflict", &old.revision)); } - let prior: Vec = tx.query_row("SELECT snapshot FROM vaults WHERE owner=?1", [&request.owner], |r| r.get(0))?; - let prior: Snapshot = serde_json::from_slice(&prior).map_err(|_| ApiError::unavailable())?; - if upload.kind == UploadKind::Snapshot { - if upload.kdf.salt != prior.kdf.salt { return Err(ApiError::conflict("key_epoch_changed", &old.revision)); } - } else { - if upload.key_id == prior.key_id || upload.kdf.salt == prior.kdf.salt { - return Err(ApiError::new(StatusCode::BAD_REQUEST, "invalid_crypto_header")); - } - remember_epoch(&tx, &request.owner, &upload)?; - } - } - } - remember(&tx, &request.owner, &format!("nonce:{}", upload.key_id), &upload.nonce, "invalid_crypto_header")?; - let meta = Metadata { - protocol_version: 1, state: "active".into(), owner_github_id: request.owner.clone(), revision: upload.revision.clone(), - vault_id: Some(upload.vault_id.clone()), key_id: Some(upload.key_id), updated_at: Some(timestamp.clone()), - payload_schema_version: Some(1), ciphertext_bytes: size, ciphertext_sha256: Some(upload.ciphertext_sha256.clone()), - last_operation_id: Some(request.operation_id.clone()), - }; - let receipt = Receipt { operation_id: request.operation_id.clone(), status: "committed".into(), kind: upload.kind.as_str().into(), - committed_revision: upload.revision, committed_at: timestamp, vault_id: upload.vault_id, - ciphertext_sha256: Some(upload.ciphertext_sha256) }; - (meta, receipt, Some(request.body)) + let upload: Snapshot = + serde_json::from_slice(&request.body).map_err(|_| ApiError::invalid())?; + let (meta, receipt) = + prepare_vault_upload(&tx, &request, &old, tag, &upload, ×tamp, false)?; + (meta, receipt, Some(&request.body[..])) } ("DELETE", "/v1/me/vault") => { - let delete: DeleteRequest = serde_json::from_slice(&request.body).map_err(|_| ApiError::invalid())?; - if delete.protocol_version != 1 { return Err(ApiError::new(StatusCode::BAD_REQUEST, "unsupported_protocol")); } + let delete: DeleteRequest = + serde_json::from_slice(&request.body).map_err(|_| ApiError::invalid())?; + if delete.protocol_version != 1 { + return Err(ApiError::new( + StatusCode::BAD_REQUEST, + "unsupported_protocol", + )); + } protocol::uuid(&delete.expected_vault_id)?; protocol::uuid(&delete.operation_id)?; protocol::revision(&delete.base_revision)?; - if delete.operation_id != request.operation_id { return Err(ApiError::invalid()); } + if delete.operation_id != request.operation_id { + return Err(ApiError::invalid()); + } check_cas(&old, tag, &delete.base_revision)?; - if old.state != "active" { return Err(state_conflict(&old)); } - if old.vault_id.as_ref() != Some(&delete.expected_vault_id) { return Err(ApiError::conflict("revision_conflict", &old.revision)); } - let next = protocol::revision(&old.revision)?.checked_add(1).ok_or_else(|| ApiError::conflict("revision_exhausted", &old.revision))?.to_string(); - let meta = Metadata { protocol_version: 1, state: "deleted".into(), owner_github_id: request.owner.clone(), revision: next.clone(), - vault_id: old.vault_id, key_id: None, updated_at: Some(timestamp.clone()), payload_schema_version: None, - ciphertext_bytes: 0, ciphertext_sha256: None, last_operation_id: Some(request.operation_id.clone()) }; - let receipt = Receipt { operation_id: request.operation_id.clone(), status: "committed".into(), kind: "delete".into(), - committed_revision: next, committed_at: timestamp, vault_id: delete.expected_vault_id, ciphertext_sha256: None }; + if old.state != "active" { + return Err(state_conflict(&old)); + } + if old.vault_id.as_ref() != Some(&delete.expected_vault_id) { + return Err(ApiError::conflict("revision_conflict", &old.revision)); + } + tx.execute("DELETE FROM service_usage WHERE owner=?1", [&request.owner])?; + let next = protocol::revision(&old.revision)? + .checked_add(1) + .ok_or_else(|| ApiError::conflict("revision_exhausted", &old.revision))? + .to_string(); + let meta = Metadata { + protocol_version: 1, + state: "deleted".into(), + owner_github_id: request.owner.clone(), + revision: next.clone(), + vault_id: old.vault_id, + key_id: None, + updated_at: Some(timestamp.clone()), + payload_schema_version: None, + ciphertext_bytes: 0, + ciphertext_sha256: None, + last_operation_id: Some(request.operation_id.clone()), + }; + let receipt = Receipt { + operation_id: request.operation_id.clone(), + status: "committed".into(), + kind: "delete".into(), + committed_revision: next, + committed_at: timestamp, + vault_id: delete.expected_vault_id, + ciphertext_sha256: None, + }; (meta, receipt, None) } _ => return Err(ApiError::invalid()), }; - tx.execute("INSERT INTO vaults(owner, metadata, snapshot) VALUES(?1,?2,?3) ON CONFLICT(owner) DO UPDATE SET metadata=excluded.metadata,snapshot=excluded.snapshot", - params![request.owner, serde_json::to_string(&meta).map_err(|_| ApiError::unavailable())?, snapshot])?; - tx.execute("INSERT INTO operations(owner,operation_id,fingerprint,receipt,committed_at) VALUES(?1,?2,?3,?4,?5) ON CONFLICT(owner,operation_id) DO UPDATE SET fingerprint=excluded.fingerprint,receipt=excluded.receipt,committed_at=excluded.committed_at", - params![request.owner, request.operation_id, fingerprint, serde_json::to_string(&receipt).map_err(|_| ApiError::unavailable())?, now.timestamp()])?; + write_vault(&tx, &meta, snapshot)?; + write_operation( + &tx, + OperationRoute::Vault, + &request.owner, + &fingerprint, + &receipt, + now.timestamp(), + )?; tx.commit()?; Ok((receipt, false)) - }).await + }) + .await } pub async fn issue_session( @@ -310,6 +319,10 @@ impl Store { "DELETE FROM operations WHERE committed_at Result<()> remember(db, owner, "key", &upload.key_id, "invalid_crypto_header")?; remember(db, owner, "salt", &upload.kdf.salt, "invalid_crypto_header") } + +fn remember_nonce(db: &Connection, owner: &str, key_id: &str, nonce: &str) -> Result<()> { + remember( + db, + owner, + &format!("nonce:{key_id}"), + nonce, + "invalid_crypto_header", + ) +} + +// Call within the same write transaction that will persist the snapshots and receipts. +fn prepare_vault_upload( + tx: &Connection, + request: &Mutation, + old: &Metadata, + tag: &str, + upload: &Snapshot, + timestamp: &str, + rekeys_usage: bool, +) -> Result<(Metadata, Receipt)> { + let size = upload.validate(&request.owner)?; + if upload.operation_id != request.operation_id { + return Err(ApiError::invalid()); + } + if old.state == "active" + && upload.kind == UploadKind::Snapshot + && old.key_id.as_ref() != Some(&upload.key_id) + { + return Err(ApiError::conflict("key_epoch_changed", &old.revision)); + } + check_cas(old, tag, &upload.base_revision)?; + match upload.kind { + UploadKind::Create => { + if old.state == "active" { + return Err(ApiError::conflict("vault_exists", &old.revision)); + } + remember( + tx, + &request.owner, + "vault", + &upload.vault_id, + "invalid_crypto_header", + )?; + remember_epoch(tx, &request.owner, upload)?; + } + UploadKind::Snapshot | UploadKind::PasswordChange => { + if old.state != "active" { + return Err(state_conflict(old)); + } + if old.vault_id.as_ref() != Some(&upload.vault_id) { + return Err(ApiError::conflict("revision_conflict", &old.revision)); + } + let prior: Vec = tx.query_row( + "SELECT snapshot FROM vaults WHERE owner=?1", + [&request.owner], + |r| r.get(0), + )?; + let prior: Snapshot = + serde_json::from_slice(&prior).map_err(|_| ApiError::unavailable())?; + if upload.kind == UploadKind::Snapshot { + if upload.kdf.salt != prior.kdf.salt { + return Err(ApiError::conflict("key_epoch_changed", &old.revision)); + } + } else { + if upload.key_id == prior.key_id || upload.kdf.salt == prior.kdf.salt { + return Err(ApiError::new( + StatusCode::BAD_REQUEST, + "invalid_crypto_header", + )); + } + if !rekeys_usage && usage::has_snapshot(tx, &request.owner)? { + return Err(ApiError::conflict("key_epoch_changed", &old.revision)); + } + remember_epoch(tx, &request.owner, upload)?; + } + } + } + remember_nonce(tx, &request.owner, &upload.key_id, &upload.nonce)?; + let meta = Metadata { + protocol_version: 1, + state: "active".into(), + owner_github_id: request.owner.clone(), + revision: upload.revision.clone(), + vault_id: Some(upload.vault_id.clone()), + key_id: Some(upload.key_id.clone()), + updated_at: Some(timestamp.into()), + payload_schema_version: Some(1), + ciphertext_bytes: size, + ciphertext_sha256: Some(upload.ciphertext_sha256.clone()), + last_operation_id: Some(request.operation_id.clone()), + }; + let receipt = Receipt { + operation_id: request.operation_id.clone(), + status: "committed".into(), + kind: upload.kind.as_str().into(), + committed_revision: upload.revision.clone(), + committed_at: timestamp.into(), + vault_id: upload.vault_id.clone(), + ciphertext_sha256: Some(upload.ciphertext_sha256.clone()), + }; + Ok((meta, receipt)) +} + +fn write_vault(db: &Connection, meta: &Metadata, snapshot: Option<&[u8]>) -> Result<()> { + db.execute("INSERT INTO vaults(owner, metadata, snapshot) VALUES(?1,?2,?3) ON CONFLICT(owner) DO UPDATE SET metadata=excluded.metadata,snapshot=excluded.snapshot", + params![meta.owner_github_id, to_db(meta)?, snapshot])?; + Ok(()) +} + +fn to_db(value: &impl serde::Serialize) -> Result { + serde_json::to_string(value).map_err(|_| ApiError::unavailable()) +} + +#[derive(Clone, Copy)] +enum OperationRoute { + Vault, + Usage, +} + +impl OperationRoute { + fn table(self) -> &'static str { + match self { + Self::Vault => "operations", + Self::Usage => "service_usage_operations", + } + } +} + +fn read_operation( + db: &Connection, + route: OperationRoute, + owner: &str, + id: &str, + now: i64, +) -> Result> { + let query = format!( + "SELECT fingerprint, receipt FROM {} WHERE owner=?1 AND operation_id=?2 AND committed_at>=?3", + route.table() + ); + Ok(db + .query_row( + &query, + params![owner, id, now - protocol::RETENTION], + |row| Ok((row.get(0)?, row.get(1)?)), + ) + .optional()?) +} + +fn operation(db: &Connection, route: OperationRoute, owner: &str, id: &str) -> Result { + match read_operation(db, route, owner, id, Utc::now().timestamp())? { + Some((_, receipt)) => from_db(&receipt), + None => Err(ApiError::new(StatusCode::NOT_FOUND, "operation_not_found")), + } +} + +struct PriorReceipts { + vault: Option, + usage: Option, +} + +fn replay( + db: &Connection, + request: &Mutation, + fingerprint: &str, + now: i64, +) -> Result> { + let prior = |route| -> Result> { + match read_operation(db, route, &request.owner, &request.operation_id, now)? { + Some((original, receipt)) if original == fingerprint => Ok(Some(from_db(&receipt)?)), + Some(_) => Err(ApiError::new( + StatusCode::CONFLICT, + "idempotency_key_reused", + )), + None => Ok(None), + } + }; + let vault = prior(OperationRoute::Vault)?; + let usage = prior(OperationRoute::Usage)?; + Ok(if vault.is_some() || usage.is_some() { + Some(PriorReceipts { vault, usage }) + } else { + None + }) +} + +fn write_operation( + db: &Connection, + route: OperationRoute, + owner: &str, + fingerprint: &str, + receipt: &Receipt, + now: i64, +) -> Result<()> { + let query = format!( + "INSERT INTO {}(owner,operation_id,fingerprint,receipt,committed_at) VALUES(?1,?2,?3,?4,?5) ON CONFLICT(owner,operation_id) DO UPDATE SET fingerprint=excluded.fingerprint,receipt=excluded.receipt,committed_at=excluded.committed_at", + route.table() + ); + db.execute( + &query, + params![ + owner, + receipt.operation_id, + fingerprint, + to_db(receipt)?, + now + ], + )?; + Ok(()) +} diff --git a/src/store/usage.rs b/src/store/usage.rs new file mode 100644 index 0000000..b1d5a33 --- /dev/null +++ b/src/store/usage.rs @@ -0,0 +1,263 @@ +use super::{ + Mutation, OperationRoute, Store, from_db, operation, prepare_vault_upload, read_metadata, + remember_nonce, replay, state_conflict, to_db, write_operation, write_vault, +}; +use crate::{ + config::UsageMode, + error::{ApiError, Result}, + protocol::{self, Metadata, Receipt, UploadKind}, + usage::{self, Rotation, RotationReceipt, UsageMetadata, UsageSnapshot, UsageState}, +}; +use axum::http::StatusCode; +use chrono::{SecondsFormat, Utc}; +use rusqlite::{Connection, OptionalExtension, TransactionBehavior, params}; + +impl Store { + pub(crate) async fn usage_metadata(&self, owner: String) -> Result { + self.run(move |db| { + let tx = db.transaction()?; + read_usage(&tx, &read_metadata(&tx, &owner)?) + }) + .await + } + + pub(crate) async fn usage_download(&self, owner: String, tag: String) -> Result> { + self.run(move |db| { + let tx = db.transaction()?; + let meta = read_usage(&tx, &read_metadata(&tx, &owner)?)?; + check_usage_cas(&meta, &tag, &meta.revision)?; + if meta.state == UsageState::Empty { + return Err(ApiError::new(StatusCode::NOT_FOUND, "usage_empty")); + } + Ok(tx.query_row( + "SELECT snapshot FROM service_usage WHERE owner=?1", + [&owner], + |r| r.get(0), + )?) + }) + .await + } + + pub(crate) async fn usage_operation(&self, owner: String, id: String) -> Result { + self.run(move |db| operation(db, OperationRoute::Usage, &owner, &id)) + .await + } + + pub(crate) async fn usage_mutate( + &self, + request: Mutation, + mode: UsageMode, + ) -> Result<(Receipt, bool)> { + self.run(move |db| { + if request.body.len() > usage::MAX_BODY { + return Err(ApiError::too_large()); + } + let fingerprint = request.fingerprint(); + let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; + let now = Utc::now(); + if let Some(prior) = replay(&tx, &request, &fingerprint, now.timestamp())? { + return Ok((prior.usage.ok_or_else(ApiError::unavailable)?, true)); + } + if mode == UsageMode::Rescue { + return Err(ApiError::unavailable()); + } + let tag = usage::etag(request.if_match.as_deref())?; + let upload: UsageSnapshot = + serde_json::from_slice(&request.body).map_err(|_| ApiError::invalid())?; + let size = upload.validate(&request.owner)?; + if upload.operation_id != request.operation_id { + return Err(ApiError::invalid()); + } + let vault = read_metadata(&tx, &request.owner)?; + if vault.state != "active" { + return Err(state_conflict(&vault)); + } + let old = read_usage(&tx, &vault)?; + if upload.vault_id != old.vault_id { + return Err(ApiError::conflict("revision_conflict", &old.revision)); + } + if upload.key_id != old.key_id { + return Err(ApiError::conflict("key_epoch_changed", &old.revision)); + } + check_usage_cas(&old, tag, &upload.base_revision)?; + let timestamp = now.to_rfc3339_opts(SecondsFormat::Secs, true); + let receipt = write_usage( + &tx, + &upload, + size, + &request.body, + ×tamp, + UploadKind::Snapshot, + )?; + write_operation( + &tx, + OperationRoute::Usage, + &request.owner, + &fingerprint, + &receipt, + now.timestamp(), + )?; + tx.commit()?; + Ok((receipt, false)) + }) + .await + } + + pub(crate) async fn rotate_usage(&self, request: Mutation) -> Result<(RotationReceipt, bool)> { + self.run(move |db| { + if request.body.len() > protocol::MAX_BODY { + return Err(ApiError::too_large()); + } + let fingerprint = request.fingerprint(); + let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; + let now = Utc::now(); + if let Some(prior) = replay(&tx, &request, &fingerprint, now.timestamp())? { + let vault_receipt = prior.vault.ok_or_else(ApiError::unavailable)?; + let usage_receipt = prior.usage.ok_or_else(ApiError::unavailable)?; + return Ok(( + RotationReceipt { + vault_receipt, + usage_receipt, + }, + true, + )); + } + let tag = protocol::etag(request.if_match.as_deref())?; + let rotation: Rotation = + serde_json::from_slice(&request.body).map_err(|_| ApiError::invalid())?; + let usage_tag = usage::etag(Some(&rotation.usage_if_match))?; + let upload = rotation.vault_snapshot; + let usage_upload = rotation.usage_snapshot; + if upload.kind != UploadKind::PasswordChange + || upload.vault_id != usage_upload.vault_id + || upload.key_id != usage_upload.key_id + || usage_upload.operation_id != request.operation_id + { + return Err(ApiError::invalid()); + } + let size = usage_upload.validate(&request.owner)?; + let old = read_metadata(&tx, &request.owner)?; + let timestamp = now.to_rfc3339_opts(SecondsFormat::Secs, true); + // V1 validation and nonce reservation share a transaction with Usage CAS and data. + let (meta, vault_receipt) = + prepare_vault_upload(&tx, &request, &old, tag, &upload, ×tamp, true)?; + let old_usage = read_usage(&tx, &old)?; + check_usage_cas(&old_usage, usage_tag, &usage_upload.base_revision)?; + if old_usage.state == UsageState::Empty { + return Err(ApiError::conflict("usage_empty", &old_usage.revision)); + } + write_vault(&tx, &meta, Some(to_db(&upload)?.as_bytes()))?; + let usage_receipt = write_usage( + &tx, + &usage_upload, + size, + to_db(&usage_upload)?.as_bytes(), + ×tamp, + UploadKind::PasswordChange, + )?; + write_operation( + &tx, + OperationRoute::Vault, + &request.owner, + &fingerprint, + &vault_receipt, + now.timestamp(), + )?; + write_operation( + &tx, + OperationRoute::Usage, + &request.owner, + &fingerprint, + &usage_receipt, + now.timestamp(), + )?; + tx.commit()?; + Ok(( + RotationReceipt { + vault_receipt, + usage_receipt, + }, + false, + )) + }) + .await + } +} + +pub(super) fn has_snapshot(db: &Connection, owner: &str) -> Result { + Ok(db.query_row( + "SELECT EXISTS(SELECT 1 FROM service_usage WHERE owner=?1)", + [owner], + |r| r.get(0), + )?) +} + +fn read_usage(db: &Connection, vault: &Metadata) -> Result { + if vault.state != "active" { + let error = state_conflict(vault); + return Err(ApiError::new(StatusCode::NOT_FOUND, error.code)); + } + let stored: Option = db + .query_row( + "SELECT metadata FROM service_usage WHERE owner=?1", + [&vault.owner_github_id], + |r| r.get(0), + ) + .optional()?; + let empty = UsageMetadata::empty(vault)?; + let Some(stored) = stored else { + return Ok(empty); + }; + let meta: UsageMetadata = from_db(&stored)?; + if meta.vault_id != empty.vault_id + || meta.key_id != empty.key_id + || meta.state != UsageState::Active + { + return Err(ApiError::unavailable()); + } + Ok(meta) +} + +fn check_usage_cas(meta: &UsageMetadata, tag: &str, base: &str) -> Result<()> { + if tag != meta.etag() || base != meta.revision { + return Err(ApiError::conflict("revision_conflict", &meta.revision)); + } + Ok(()) +} + +fn write_usage( + db: &Connection, + upload: &UsageSnapshot, + size: usize, + body: &[u8], + timestamp: &str, + kind: UploadKind, +) -> Result { + remember_nonce(db, &upload.owner_github_id, &upload.key_id, &upload.nonce)?; + let meta = UsageMetadata { + protocol_version: 1, + state: UsageState::Active, + owner_github_id: upload.owner_github_id.clone(), + vault_id: upload.vault_id.clone(), + key_id: upload.key_id.clone(), + revision: upload.revision.clone(), + updated_at: Some(timestamp.into()), + last_operation_id: Some(upload.operation_id.clone()), + ciphertext_sha256: Some(upload.ciphertext_sha256.clone()), + ciphertext_bytes: size, + }; + let receipt = Receipt { + operation_id: upload.operation_id.clone(), + status: "committed".into(), + kind: kind.as_str().into(), + committed_revision: upload.revision.clone(), + committed_at: timestamp.into(), + vault_id: upload.vault_id.clone(), + ciphertext_sha256: Some(upload.ciphertext_sha256.clone()), + }; + db.execute( + "INSERT INTO service_usage(owner,metadata,snapshot) VALUES(?1,?2,?3) ON CONFLICT(owner) DO UPDATE SET metadata=excluded.metadata,snapshot=excluded.snapshot", + params![upload.owner_github_id, to_db(&meta)?, body], + )?; + Ok(receipt) +} diff --git a/src/usage.rs b/src/usage.rs new file mode 100644 index 0000000..dfe9f49 --- /dev/null +++ b/src/usage.rs @@ -0,0 +1,172 @@ +use crate::{ + error::{ApiError, Result}, + protocol::{self, Metadata, Receipt, Snapshot}, +}; +use axum::http::StatusCode; +use serde::{Deserialize, Serialize}; + +pub(crate) const FEATURE: &str = "/v1/features/service-usage"; +pub(crate) const RESOURCE: &str = "/v1/me/vault/usage"; +pub(crate) const SNAPSHOT: &str = "/v1/me/vault/usage/snapshot"; +pub(crate) const ROTATE: &str = "/v1/me/vault/usage/password-change"; +pub(crate) const OPERATIONS: &str = "/v1/me/vault/usage/operations/"; +pub const MAX_CIPHERTEXT: usize = 1_048_592; +pub const MAX_BODY: usize = 1_572_864; +const ETAG_PREFIX: &str = "usage-v1-"; + +#[derive(Clone, Debug, Deserialize, Serialize)] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +pub struct UsageMetadata { + pub protocol_version: u32, + pub state: UsageState, + pub owner_github_id: String, + pub vault_id: String, + pub key_id: String, + pub revision: String, + pub updated_at: Option, + pub last_operation_id: Option, + pub ciphertext_sha256: Option, + pub ciphertext_bytes: usize, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum UsageState { + Empty, + Active, +} + +impl UsageMetadata { + pub(crate) fn empty(vault: &Metadata) -> Result { + Ok(Self { + protocol_version: 1, + state: UsageState::Empty, + owner_github_id: vault.owner_github_id.clone(), + vault_id: vault.vault_id.clone().ok_or_else(ApiError::unavailable)?, + key_id: vault.key_id.clone().ok_or_else(ApiError::unavailable)?, + revision: "0".into(), + updated_at: None, + last_operation_id: None, + ciphertext_sha256: None, + ciphertext_bytes: 0, + }) + } + + pub fn etag(&self) -> String { + let bytes = serde_json::to_vec(self).expect("usage metadata serialization"); + format!("\"{ETAG_PREFIX}{}\"", protocol::hash(&bytes)) + } +} + +pub(crate) fn etag(value: Option<&str>) -> Result<&str> { + let value = protocol::etag(value)?; + let digest = value[1..value.len() - 1] + .strip_prefix(ETAG_PREFIX) + .ok_or_else(ApiError::invalid)?; + if digest.len() != 64 + || !digest + .bytes() + .all(|b| matches!(b, b'0'..=b'9' | b'a'..=b'f')) + { + return Err(ApiError::invalid()); + } + Ok(value) +} + +#[derive(Deserialize, Serialize)] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +pub struct UsageSnapshot { + pub protocol_version: u32, + pub payload_schema_version: u32, + pub owner_github_id: String, + pub vault_id: String, + pub key_id: String, + pub base_revision: String, + pub revision: String, + pub operation_id: String, + pub aead: String, + pub codec: String, + pub nonce: String, + pub ciphertext_sha256: String, + pub ciphertext: String, +} + +impl UsageSnapshot { + pub fn validate(&self, owner: &str) -> Result { + if self.protocol_version != 1 || self.payload_schema_version != 1 { + return Err(ApiError::new( + StatusCode::BAD_REQUEST, + "unsupported_protocol", + )); + } + if protocol::revision(&self.owner_github_id)? == 0 { + return Err(ApiError::invalid()); + } + if self.owner_github_id != owner { + return Err(ApiError::new(StatusCode::FORBIDDEN, "owner_mismatch")); + } + for id in [&self.vault_id, &self.key_id, &self.operation_id] { + protocol::uuid(id)?; + } + let base = protocol::revision(&self.base_revision)?; + let next = base + .checked_add(1) + .ok_or_else(|| ApiError::conflict("revision_exhausted", &self.base_revision))?; + if protocol::revision(&self.revision)? != next { + return Err(ApiError::invalid()); + } + let crypto_error = || ApiError::new(StatusCode::BAD_REQUEST, "invalid_crypto_header"); + if self.aead != "xchacha20poly1305-ietf" || self.codec != "json-pad64k-v1" { + return Err(crypto_error()); + } + protocol::decode(&self.nonce, Some(24))?; + if self.ciphertext.len() > (MAX_CIPHERTEXT * 4).div_ceil(3) { + return Err(ApiError::too_large()); + } + let ciphertext = protocol::decode(&self.ciphertext, None)?; + if ciphertext.len() > MAX_CIPHERTEXT { + return Err(ApiError::too_large()); + } + if ciphertext.len() < 65_552 + || (ciphertext.len() - 16) % 65_536 != 0 + || protocol::hash(&ciphertext) != self.ciphertext_sha256 + { + return Err(crypto_error()); + } + Ok(ciphertext.len()) + } + + /// The server never decrypts. This is used by client interop fixtures. + pub fn aad(&self) -> Vec { + serde_json::to_vec(&serde_json::json!([ + "openless-cloud-sync", + 1, + "service-usage", + self.owner_github_id, + self.vault_id, + self.key_id, + self.base_revision, + self.revision, + self.operation_id, + self.payload_schema_version, + self.aead, + self.codec + ])) + .expect("AAD serialization") + } +} + +#[derive(Deserialize)] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +pub(crate) struct Rotation { + pub vault_snapshot: Snapshot, + pub usage_if_match: String, + pub usage_snapshot: UsageSnapshot, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct RotationReceipt { + pub vault_receipt: Receipt, + pub usage_receipt: Receipt, +} diff --git a/tests/common/mod.rs b/tests/common/mod.rs index 37b07a1..aa94542 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -9,7 +9,7 @@ use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; use http_body_util::BodyExt; use openless_cloud_sync::{ auth::{Account, IdentityVerifier, VerifyFuture}, - config::Config, + config::{Config, UsageMode}, error::ApiError, protocol::{Snapshot, hash}, server::{AppState, router}, @@ -47,7 +47,18 @@ impl Fixture { Self::https(false) } pub fn https(require_https_proxy: bool) -> Self { - let dir = tempfile::tempdir().unwrap(); + Self::open( + tempfile::tempdir().unwrap(), + require_https_proxy, + UsageMode::Enabled, + ) + } + pub fn reopen(self, usage_mode: UsageMode) -> Self { + let Self { app, store, dir } = self; + drop((app, store)); + Self::open(dir, false, usage_mode) + } + fn open(dir: tempfile::TempDir, require_https_proxy: bool, usage_mode: UsageMode) -> Self { let path = dir.path().join("sync.db"); let store = Store::open(&path).unwrap(); let config = Config { @@ -59,6 +70,7 @@ impl Fixture { allowed_github_ids: HashSet::from(["11".into(), "22".into()]), public_access: false, require_https_proxy, + usage_mode, }; let app = router(Arc::new(AppState::new( config, @@ -184,3 +196,104 @@ pub fn next(previous: &Value, nonce: u8, kind: &str) -> Value { pub fn typed(value: &Value) -> Snapshot { serde_json::from_value(value.clone()).unwrap() } + +pub const FEATURE: &str = "/v1/features/service-usage"; +pub const USAGE: &str = "/v1/me/vault/usage"; +pub const USAGE_SNAPSHOT: &str = "/v1/me/vault/usage/snapshot"; +pub const ROTATE: &str = "/v1/me/vault/usage/password-change"; +pub const VAULT_SNAPSHOT: &str = "/v1/me/vault/snapshot"; + +impl Fixture { + pub async fn usage_meta(&self, token: &str) -> Reply { + self.request("GET", USAGE, Some(token), &[], vec![]).await + } + pub async fn usage_download(&self, token: &str, tag: &str) -> Reply { + self.request( + "GET", + USAGE_SNAPSHOT, + Some(token), + &[("if-match", tag)], + vec![], + ) + .await + } + pub async fn usage_put(&self, token: &str, tag: &str, body: &Value) -> Reply { + self.json_mutation( + "PUT", + USAGE_SNAPSHOT, + token, + tag, + body["operationId"].as_str().unwrap(), + body, + ) + .await + } + pub async fn rotate(&self, token: &str, tag: &str, body: &Value) -> Reply { + self.json_mutation( + "PUT", + ROTATE, + token, + tag, + body["vaultSnapshot"]["operationId"].as_str().unwrap(), + body, + ) + .await + } + pub async fn operation(&self, token: &str, usage: bool, id: &Value) -> Reply { + let prefix = if usage { USAGE } else { "/v1/me" }; + self.request( + "GET", + &format!("{prefix}/operations/{}", id.as_str().unwrap()), + Some(token), + &[], + vec![], + ) + .await + } + pub async fn json_mutation( + &self, + method: &str, + path: &str, + token: &str, + tag: &str, + id: &str, + body: &Value, + ) -> Reply { + self.request( + method, + path, + Some(token), + &[ + ("if-match", tag), + ("idempotency-key", id), + ("content-type", "application/json"), + ], + serde_json::to_vec(body).unwrap(), + ) + .await + } +} + +pub fn usage_upload(vault: &Value, base: u64, nonce: u8) -> Value { + let ciphertext = vec![87; 65_552]; + json!({"protocolVersion":1,"payloadSchemaVersion":1,"ownerGithubId":vault["ownerGithubId"], + "vaultId":vault["vaultId"],"keyId":vault["keyId"],"baseRevision":base.to_string(), + "revision":(base+1).to_string(),"operationId":uuid::Uuid::new_v4().to_string(), + "aead":"xchacha20poly1305-ietf","codec":"json-pad64k-v1","nonce":URL_SAFE_NO_PAD.encode([nonce;24]), + "ciphertextSha256":hash(&ciphertext),"ciphertext":URL_SAFE_NO_PAD.encode(ciphertext)}) +} + +pub fn rekey(previous: &Value, nonce: u8) -> Value { + let mut vault = next(previous, nonce, "password_change"); + vault["keyId"] = uuid::Uuid::new_v4().to_string().into(); + vault["kdf"]["salt"] = URL_SAFE_NO_PAD + .encode(uuid::Uuid::new_v4().as_bytes()) + .into(); + vault +} + +pub fn dual(vault: &Value, usage_tag: &str, base: u64, nonce: u8) -> Value { + let mut usage = usage_upload(vault, base, nonce); + usage["operationId"] = vault["operationId"].clone(); + json!({"vaultSnapshot":vault,"usageIfMatch":usage_tag,"usageSnapshot":usage}) +} diff --git a/tests/crypto_vectors.rs b/tests/crypto_vectors.rs index 8396e52..136f32d 100644 --- a/tests/crypto_vectors.rs +++ b/tests/crypto_vectors.rs @@ -208,3 +208,104 @@ fn rustcrypto_matches_independent_argon2_and_libsodium_vectors() { assert!(decode(&snapshot.nonce, Some(12)).is_err()); } } + +#[test] +fn service_usage_aad_and_ciphertext_match_independent_vector() { + let vector: Value = + serde_json::from_str(include_str!("vectors/service-usage-v1.json")).unwrap(); + let snapshot: openless_cloud_sync::usage::UsageSnapshot = + serde_json::from_value(vector["snapshot"].clone()).unwrap(); + assert_eq!(snapshot.validate("12345").unwrap(), 65_552); + let normalized = vector["passwordInput"] + .as_str() + .unwrap() + .nfc() + .collect::(); + let argon = Argon2::new( + Algorithm::Argon2id, + Version::V0x13, + Params::new(65536, 3, 4, Some(32)).unwrap(), + ); + let mut key = [0; 32]; + let salt = decode(vector["salt"].as_str().unwrap(), Some(16)).unwrap(); + argon + .hash_password_into(normalized.as_bytes(), &salt, &mut key) + .unwrap(); + assert_eq!( + key.to_vec(), + unhex(vector["derivedKeyHex"].as_str().unwrap()) + ); + let aad = snapshot.aad(); + assert_eq!(aad, unhex(vector["aadUtf8Hex"].as_str().unwrap())); + let nonce = decode(&snapshot.nonce, Some(24)).unwrap(); + let nonce = XNonce::from_slice(&nonce); + let ciphertext = decode(&snapshot.ciphertext, None).unwrap(); + let cipher = XChaCha20Poly1305::new_from_slice(&key).unwrap(); + let plaintext = cipher + .decrypt( + nonce, + Payload { + msg: &ciphertext, + aad: &aad, + }, + ) + .unwrap(); + assert_eq!(framed_json(&plaintext).unwrap(), vector["recoveredJson"]); + let json = unhex(vector["plaintextJsonUtf8Hex"].as_str().unwrap()); + let mut expected = (json.len() as u32).to_be_bytes().to_vec(); + expected.extend_from_slice(&json); + expected.extend((0..vector["padding"]["length"].as_u64().unwrap()).map(|i| (i % 251) as u8)); + assert_eq!(plaintext, expected); + assert_eq!( + cipher + .encrypt( + nonce, + Payload { + msg: &expected, + aad: &aad + } + ) + .unwrap(), + ciphertext + ); + // A valid ciphertext cannot move to another account, scope, key epoch, or revision. + for (field, replacement) in [ + ("ownerGithubId", "54321"), + ("vaultId", "ad8940b8-854c-4e37-9d74-77d01c5877e2"), + ("keyId", "ad8940b8-854c-4e37-9d74-77d01c5877e2"), + ("revision", "9007199254740994"), + ("baseRevision", "9007199254740993"), + ("operationId", "ad8940b8-854c-4e37-9d74-77d01c5877e2"), + ] { + let mut altered = vector["snapshot"].clone(); + altered[field] = replacement.into(); + let altered: openless_cloud_sync::usage::UsageSnapshot = + serde_json::from_value(altered).unwrap(); + assert!( + cipher + .decrypt( + nonce, + Payload { + msg: &ciphertext, + aad: &altered.aad() + } + ) + .is_err(), + "AAD failed to bind {field}" + ); + } + let mut other_domain: Value = serde_json::from_slice(&aad).unwrap(); + other_domain[2] = "snapshot".into(); + let other_domain = serde_json::to_vec(&other_domain).unwrap(); + assert!( + cipher + .decrypt( + nonce, + Payload { + msg: &ciphertext, + aad: &other_domain + } + ) + .is_err() + ); +} diff --git a/tests/openapi_samples.rs b/tests/openapi_samples.rs index 96ef61a..e6ee9f8 100644 --- a/tests/openapi_samples.rs +++ b/tests/openapi_samples.rs @@ -86,7 +86,55 @@ async fn export_contract_samples() { ) .await, ); - let delete = json!({"protocolVersion":1,"baseRevision":"1","operationId":uuid::Uuid::new_v4().to_string(),"expectedVaultId":create["vaultId"]}); + record( + FEATURE, + "get", + &f.request("GET", FEATURE, None, &[], vec![]).await, + ); + let empty_usage = f.usage_meta(token).await; + record(USAGE, "get", &empty_usage); + record( + USAGE_SNAPSHOT, + "get", + &f.usage_download(token, empty_usage.tag()).await, + ); + let usage = usage_upload(&create, 0, 3); + record( + USAGE_SNAPSHOT, + "put", + &f.usage_put(token, empty_usage.tag(), &usage).await, + ); + let current_usage = f.usage_meta(token).await; + record(USAGE, "get", ¤t_usage); + record( + USAGE, + "get", + &f.request( + "GET", + USAGE, + Some(token), + &[("if-none-match", current_usage.tag())], + vec![], + ) + .await, + ); + record( + USAGE_SNAPSHOT, + "get", + &f.usage_download(token, current_usage.tag()).await, + ); + record( + "/v1/me/vault/usage/operations/{operationId}", + "get", + &f.operation(token, true, &usage["operationId"]).await, + ); + let new = rekey(&create, 4); + record(VAULT_SNAPSHOT, "put", &f.put(token, meta.tag(), &new).await); + let rotate = dual(&new, current_usage.tag(), 1, 5); + record(ROTATE, "put", &f.rotate(token, meta.tag(), &rotate).await); + record(ROTATE, "put", &f.rotate(token, meta.tag(), &rotate).await); + let meta = f.meta(token).await; + let delete = json!({"protocolVersion":1,"baseRevision":"2","operationId":uuid::Uuid::new_v4().to_string(),"expectedVaultId":create["vaultId"]}); record( "/v1/me/vault", "delete", @@ -114,5 +162,5 @@ async fn export_contract_samples() { if let Ok(path) = std::env::var("SYNC_CONTRACT_SAMPLES") { std::fs::write(path, serde_json::to_vec(&samples).unwrap()).unwrap(); } - assert_eq!(samples.len(), 13); + assert_eq!(samples.len(), 24); } diff --git a/tests/store_contract.rs b/tests/store_contract.rs index 546f7ad..9a420a4 100644 --- a/tests/store_contract.rs +++ b/tests/store_contract.rs @@ -293,3 +293,71 @@ async fn rolling_rate_limit_and_retention_survive_restart() { ); assert_eq!(store.metadata("11".into()).await.unwrap().revision, "1"); } + +#[tokio::test] +async fn v1_upgrade_is_atomic_and_keeps_live_snapshot_and_receipt() { + let temp = tempfile::tempdir().unwrap(); + let path = temp.path().join("v1.db"); + let db = rusqlite::Connection::open(&path).unwrap(); + db.execute_batch(include_str!("../migrations/001_initial.sql")) + .unwrap(); + let old_body = sample("11"); + let upload: Snapshot = serde_json::from_slice(&old_body).unwrap(); + let metadata = Metadata { + protocol_version: 1, + state: "active".into(), + owner_github_id: "11".into(), + revision: "1".into(), + vault_id: Some(upload.vault_id.clone()), + key_id: Some(upload.key_id.clone()), + updated_at: Some("2026-09-23T00:00:00Z".into()), + payload_schema_version: Some(1), + ciphertext_bytes: 65_552, + ciphertext_sha256: Some(upload.ciphertext_sha256.clone()), + last_operation_id: Some(upload.operation_id.clone()), + }; + db.execute( + "INSERT INTO vaults VALUES('11',?1,?2)", + rusqlite::params![serde_json::to_string(&metadata).unwrap(), old_body], + ) + .unwrap(); + let receipt = json!({"operationId":upload.operation_id,"status":"committed","kind":"create","committedRevision":"1","committedAt":"2026-09-23T00:00:00Z","vaultId":upload.vault_id,"ciphertextSha256":upload.ciphertext_sha256}); + db.execute( + "INSERT INTO operations VALUES('11',?1,'fixture',?2,?3)", + rusqlite::params![ + upload.operation_id, + receipt.to_string(), + chrono::Utc::now().timestamp() + ], + ) + .unwrap(); + db.execute_batch("CREATE INDEX service_usage_operations_expiry ON operations(owner);") + .unwrap(); + assert!(Store::open(&path).is_err()); + assert_eq!( + db.query_row("PRAGMA user_version", [], |row| row.get::<_, i64>(0)) + .unwrap(), + 1 + ); + assert_eq!(db.query_row("SELECT count(*) FROM sqlite_master WHERE name IN ('service_usage','service_usage_operations')", [], |row| row.get::<_, i64>(0)).unwrap(), 0); + db.execute_batch("DROP INDEX service_usage_operations_expiry;") + .unwrap(); + let migrated = Store::open(&path).unwrap(); + assert_eq!( + db.query_row("PRAGMA user_version", [], |row| row.get::<_, i64>(0)) + .unwrap(), + 2 + ); + assert_eq!( + migrated + .download("11".into(), metadata.etag()) + .await + .unwrap(), + old_body + ); + let after = migrated + .operation("11".into(), upload.operation_id) + .await + .unwrap(); + assert_eq!(serde_json::to_value(after).unwrap(), receipt); +} diff --git a/tests/usage_contract.rs b/tests/usage_contract.rs new file mode 100644 index 0000000..11139d6 --- /dev/null +++ b/tests/usage_contract.rs @@ -0,0 +1,626 @@ +mod common; + +use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; +use common::*; +use openless_cloud_sync::{ + config::UsageMode, + protocol::{MAX_BODY, MAX_CIPHERTEXT, hash}, + usage, +}; +use rusqlite::Connection; +use serde_json::{Value, json}; +use uuid::Uuid; + +async fn create(f: &Fixture, token: &str) -> Value { + let v1 = sample("11"); + assert_eq!( + f.put(token, f.meta(token).await.tag(), &v1).await.status, + 200 + ); + v1 +} + +#[tokio::test] +async fn probe_legacy_reads_writes_and_numeric_account_isolation() { + let f = Fixture::https(true); + let probe = f.request("GET", FEATURE, None, &[], vec![]).await; + assert_eq!(probe.status, 400); + let proxy = [("x-forwarded-proto", "https"), ("x-real-ip", "192.0.2.1")]; + let probe = f.request("GET", FEATURE, None, &proxy, vec![]).await; + assert_eq!( + probe.json, + json!({"protocolVersion":1,"maxCiphertextBytes":1048592,"maxBodyBytes":1572864}) + ); + + let f = Fixture::new(); + let capabilities = f + .request("GET", "/v1/capabilities", None, &[], vec![]) + .await + .json; + assert_eq!(capabilities.as_object().unwrap().len(), 8); + assert_eq!(capabilities["maxHttpBodyBytes"], MAX_BODY); + let token = f.login("github-alice").await; + let renamed = f.login("github-alice-renamed").await; + let other = f.login("github-bob").await; + assert_eq!(f.request("GET", USAGE, None, &[], vec![]).await.status, 401); + assert_eq!(f.usage_meta(&token).await.code(), "vault_empty"); + let initial = create(&f, &token).await; + let empty = f.usage_meta(&token).await; + assert_eq!(empty.json["revision"], "0"); + assert_eq!(empty.json["state"], "empty"); + assert_eq!( + f.usage_download(&token, empty.tag()).await.code(), + "usage_empty" + ); + let v1 = f.meta(&token).await; + assert_ne!(v1.tag(), empty.tag()); + assert_eq!(f.usage_download(&token, v1.tag()).await.status, 400); + assert_eq!( + f.request( + "GET", + USAGE, + Some(&token), + &[("if-none-match", empty.tag())], + vec![] + ) + .await + .status, + 304 + ); + + let usage = usage_upload(&initial, 0, 3); + let committed = f.usage_put(&token, empty.tag(), &usage).await; + assert_eq!(committed.status, 200); + assert_eq!(committed.headers["idempotency-replayed"], "false"); + assert_eq!(f.meta(&token).await.tag(), v1.tag()); + let old_write = next(&initial, 4, "snapshot"); + assert_eq!(f.put(&token, v1.tag(), &old_write).await.status, 200); + let old_meta = f.meta(&token).await; + let download_legacy = f + .request( + "GET", + VAULT_SNAPSHOT, + Some(&token), + &[("if-match", old_meta.tag())], + vec![], + ) + .await; + assert_eq!( + download_legacy.body, + serde_json::to_vec(&old_write).unwrap() + ); + let active = f.usage_meta(&renamed).await; + assert_eq!(active.json["revision"], "1"); + assert_eq!(f.usage_download(&renamed, active.tag()).await.json, usage); + assert_eq!(f.usage_meta(&other).await.code(), "vault_empty"); + assert_eq!(f.usage_put(&other, empty.tag(), &usage).await.status, 403); + assert_eq!( + f.operation(&other, true, &usage["operationId"]) + .await + .code(), + "operation_not_found" + ); + assert_eq!( + f.operation(&token, false, &usage["operationId"]) + .await + .code(), + "operation_not_found" + ); + assert_eq!( + f.operation(&token, true, &usage["operationId"]).await.json, + committed.json + ); +} + +#[tokio::test] +async fn competing_usage_writers_and_lost_ack_are_not_double_commits() { + let f = Fixture::new(); + let token = f.login("github-alice").await; + let vault = create(&f, &token).await; + let empty = f.usage_meta(&token).await; + let a = usage_upload(&vault, 0, 5); + let b = usage_upload(&vault, 0, 6); + let (aa, bb) = tokio::join!( + f.usage_put(&token, empty.tag(), &a), + f.usage_put(&token, empty.tag(), &b) + ); + let (winner, lost_ack, loser) = if aa.status == 200 { + (a, aa, bb) + } else { + (b, bb, aa) + }; + assert_eq!(lost_ack.status, 200); + assert_eq!(loser.status, 412); + assert_eq!(loser.json["error"]["currentRevision"], "1"); + let op = &winner["operationId"]; + assert_eq!(f.operation(&token, true, op).await.json, lost_ack.json); + let replay = f.usage_put(&token, empty.tag(), &winner).await; + assert_eq!(replay.headers["idempotency-replayed"], "true"); + assert_eq!(replay.json, lost_ack.json); + let active = f.usage_meta(&token).await; + assert_eq!(active.json["revision"], "1"); + assert_eq!(f.usage_download(&token, empty.tag()).await.status, 412); + assert_eq!( + f.usage_put(&token, active.tag(), &winner).await.code(), + "idempotency_key_reused" + ); + let mut legacy = next(&vault, 7, "snapshot"); + legacy["operationId"] = op.clone(); + assert_eq!( + f.put(&token, f.meta(&token).await.tag(), &legacy) + .await + .code(), + "idempotency_key_reused" + ); + let mut reused_by_usage = usage_upload(&vault, 1, 8); + reused_by_usage["operationId"] = vault["operationId"].clone(); + assert_eq!( + f.usage_put(&token, active.tag(), &reused_by_usage) + .await + .code(), + "idempotency_key_reused" + ); + let db = Connection::open(f.dir.path().join("sync.db")).unwrap(); + db.execute( + "UPDATE service_usage_operations SET committed_at=?1", + [chrono::Utc::now().timestamp() - 604801], + ) + .unwrap(); + f.store.maintain().await.unwrap(); + assert_eq!( + f.operation(&token, true, op).await.code(), + "operation_not_found" + ); + assert_eq!(f.usage_download(&token, active.tag()).await.json, winner); +} + +#[tokio::test] +async fn legacy_rotation_is_guarded_only_for_present_usage_and_dual_recovers_atomically() { + let f = Fixture::new(); + let token = f.login("github-alice").await; + let first = create(&f, &token).await; + let before = f.usage_meta(&token).await; + let vault = rekey(&first, 9); + let empty_rotation = dual(&vault, before.tag(), 0, 10); + let first_meta = f.meta(&token).await; + assert_eq!( + f.rotate(&token, first_meta.tag(), &empty_rotation) + .await + .code(), + "usage_empty" + ); + assert_eq!(f.put(&token, first_meta.tag(), &vault).await.status, 200); + let empty = f.usage_meta(&token).await; + assert_ne!(before.tag(), empty.tag()); + assert_eq!(empty.json["revision"], "0"); + assert_eq!( + f.usage_put(&token, before.tag(), &usage_upload(&first, 0, 10)) + .await + .code(), + "key_epoch_changed" + ); + let usage_1 = usage_upload(&vault, 0, 10); + assert_eq!(f.usage_put(&token, empty.tag(), &usage_1).await.status, 200); + let old_usage = f.usage_meta(&token).await; + let old_vault = f.meta(&token).await; + let new_vault = rekey(&vault, 11); + assert_eq!( + f.put(&token, old_vault.tag(), &new_vault).await.code(), + "key_epoch_changed" + ); + assert_eq!(f.meta(&token).await.tag(), old_vault.tag()); + assert_eq!(f.usage_meta(&token).await.tag(), old_usage.tag()); + + let usage_2 = usage_upload(&vault, 1, 12); + assert_eq!( + f.usage_put(&token, old_usage.tag(), &usage_2).await.status, + 200 + ); + let stale = dual(&new_vault, old_usage.tag(), 1, 13); + assert_eq!(f.rotate(&token, old_vault.tag(), &stale).await.status, 412); + assert_eq!(f.meta(&token).await.tag(), old_vault.tag()); + let new_head = f.usage_meta(&token).await; + let racing_vault = next(&vault, 14, "snapshot"); + assert_eq!( + f.put(&token, old_vault.tag(), &racing_vault).await.status, + 200 + ); + let superseded = dual(&new_vault, new_head.tag(), 2, 13); + assert_eq!( + f.rotate(&token, old_vault.tag(), &superseded).await.status, + 412 + ); + let vault_meta = f.meta(&token).await; + let mut new_vault = new_vault; + new_vault["baseRevision"] = "3".into(); + new_vault["revision"] = "4".into(); + let nonce_collision = dual(&new_vault, new_head.tag(), 2, 11); + assert_eq!( + f.rotate(&token, vault_meta.tag(), &nonce_collision) + .await + .code(), + "invalid_crypto_header" + ); + assert_eq!(f.meta(&token).await.tag(), vault_meta.tag()); + + let dual = dual(&new_vault, new_head.tag(), 2, 13); + let op = &new_vault["operationId"]; + let db = Connection::open(f.dir.path().join("sync.db")).unwrap(); + db.execute_batch("CREATE TRIGGER fail_usage_receipt BEFORE INSERT ON service_usage_operations BEGIN SELECT RAISE(ABORT, 'fixture'); END;").unwrap(); + assert_eq!(f.rotate(&token, vault_meta.tag(), &dual).await.status, 503); + assert_eq!(f.meta(&token).await.tag(), vault_meta.tag()); + assert_eq!(f.usage_meta(&token).await.tag(), new_head.tag()); + assert_eq!(f.operation(&token, false, op).await.status, 404); + assert_eq!(f.operation(&token, true, op).await.status, 404); + db.execute_batch("DROP TRIGGER fail_usage_receipt;") + .unwrap(); + let result = f.rotate(&token, vault_meta.tag(), &dual).await; + assert_eq!(result.status, 200); + assert_eq!(result.json["vaultReceipt"]["committedRevision"], "4"); + assert_eq!(result.json["usageReceipt"]["committedRevision"], "3"); + assert_eq!( + f.operation(&token, false, op).await.json, + result.json["vaultReceipt"] + ); + assert_eq!( + f.operation(&token, true, op).await.json, + result.json["usageReceipt"] + ); + assert_eq!( + f.put(&token, vault_meta.tag(), &new_vault).await.code(), + "idempotency_key_reused" + ); + let replay = f.rotate(&token, vault_meta.tag(), &dual).await; + assert_eq!(replay.json, result.json); + assert_eq!(replay.headers["idempotency-replayed"], "true"); + let after = f.usage_meta(&token).await; + assert_eq!(after.json["keyId"], new_vault["keyId"]); + assert_eq!( + f.usage_download(&token, after.tag()).await.json, + dual["usageSnapshot"] + ); + assert_eq!( + f.usage_put(&token, new_head.tag(), &usage_upload(&vault, 2, 15)) + .await + .code(), + "key_epoch_changed" + ); +} + +#[tokio::test] +async fn forward_rescue_preserves_accepted_writes_and_legacy_delete_cannot_resurrect_usage() { + let f = Fixture::new(); + let token = f.login("github-alice").await; + let vault = create(&f, &token).await; + let empty = f.usage_meta(&token).await; + let usage = usage_upload(&vault, 0, 15); + let receipt = f.usage_put(&token, empty.tag(), &usage).await.json; + let old = f.usage_meta(&token).await; + let f = f.reopen(UsageMode::Rescue); + assert_eq!(f.usage_meta(&token).await.tag(), old.tag()); + assert_eq!(f.usage_download(&token, old.tag()).await.json, usage); + assert_eq!(f.usage_put(&token, empty.tag(), &usage).await.json, receipt); + assert_eq!( + f.usage_put(&token, old.tag(), &usage_upload(&vault, 1, 16)) + .await + .status, + 503 + ); + let prior = f.meta(&token).await; + let legacy = next(&vault, 16, "snapshot"); + assert_eq!(f.put(&token, prior.tag(), &legacy).await.status, 200); + let before = f.meta(&token).await; + let rotated = rekey(&legacy, 17); + let dual = dual(&rotated, old.tag(), 1, 18); + assert_eq!( + f.put(&token, before.tag(), &rotated).await.code(), + "key_epoch_changed" + ); + assert_eq!(f.rotate(&token, before.tag(), &dual).await.status, 200); + let f = f.reopen(UsageMode::Enabled); + let active = f.usage_meta(&token).await; + assert_eq!( + f.usage_download(&token, active.tag()).await.json, + dual["usageSnapshot"] + ); + let before_deleted = f.meta(&token).await; + let delete = json!({"protocolVersion":1,"baseRevision":"3","operationId":Uuid::new_v4().to_string(),"expectedVaultId":vault["vaultId"]}); + let delete_id = delete["operationId"].as_str().unwrap(); + let response = f + .json_mutation( + "DELETE", + "/v1/me/vault", + &token, + before_deleted.tag(), + delete_id, + &delete, + ) + .await; + assert_eq!(response.status, 200); + assert_eq!(f.usage_meta(&token).await.code(), "vault_deleted"); + assert_eq!( + f.usage_download(&token, active.tag()).await.code(), + "vault_deleted" + ); + let db = Connection::open(f.dir.path().join("sync.db")).unwrap(); + assert_eq!( + db.query_row("SELECT count(*) FROM service_usage", [], |r| r + .get::<_, i64>(0)) + .unwrap(), + 0 + ); + let mut recreate = sample("11"); + recreate["baseRevision"] = "4".into(); + recreate["revision"] = "5".into(); + assert_eq!( + f.put(&token, f.meta(&token).await.tag(), &recreate) + .await + .status, + 200 + ); + let fresh = f.usage_meta(&token).await; + assert_eq!(fresh.json["revision"], "0"); + assert_ne!(fresh.tag(), empty.tag()); + assert_eq!( + f.usage_put(&token, active.tag(), &usage_upload(&rotated, 2, 19)) + .await + .status, + 412 + ); + assert_eq!(f.usage_put(&token, empty.tag(), &usage).await.json, receipt); + let replay = f + .json_mutation( + "DELETE", + "/v1/me/vault", + &token, + before_deleted.tag(), + delete_id, + &delete, + ) + .await; + assert_eq!(replay.headers["idempotency-replayed"], "true"); + assert_eq!(f.usage_meta(&token).await.tag(), fresh.tag()); +} + +#[tokio::test] +async fn sizes_headers_strict_json_and_shared_nonces_are_enforced() { + let f = Fixture::new(); + let token = f.login("github-alice").await; + let vault = create(&f, &token).await; + let empty = f.usage_meta(&token).await; + let bad = usage_upload(&vault, 0, 2); + assert_eq!( + f.usage_put(&token, empty.tag(), &bad).await.code(), + "invalid_crypto_header" + ); + let mut valid = usage_upload(&vault, 0, 20); + let mut extra = valid.clone(); + extra["records"] = json!([]); + assert_eq!( + f.usage_put(&token, empty.tag(), &extra).await.code(), + "invalid_request" + ); + let id = valid["operationId"].as_str().unwrap().to_owned(); + let ct = [ + ("content-type", "application/json"), + ("idempotency-key", id.as_str()), + ]; + let body = serde_json::to_vec(&valid).unwrap(); + assert_eq!( + f.request("PUT", USAGE_SNAPSHOT, Some(&token), &ct, body) + .await + .status, + 428 + ); + let tag = empty.tag(); + let headers = [ct[0], ct[1], ("if-match", tag)]; + let mut duplicate = serde_json::to_string(&valid).unwrap(); + duplicate.insert_str(1, "\"protocolVersion\":1,"); + assert_eq!( + f.request( + "PUT", + USAGE_SNAPSHOT, + Some(&token), + &headers, + duplicate.into_bytes() + ) + .await + .status, + 400 + ); + assert_eq!( + f.request( + "PUT", + USAGE_SNAPSHOT, + Some(&token), + &headers, + vec![b' '; usage::MAX_BODY + 1] + ) + .await + .status, + 413 + ); + let mut padded = valid.clone(); + padded["ciphertext"] = format!("{}=", padded["ciphertext"].as_str().unwrap()).into(); + assert_eq!( + f.usage_put(&token, empty.tag(), &padded).await.code(), + "invalid_crypto_header" + ); + set_ciphertext_size(&mut valid, usage::MAX_CIPHERTEXT + 65_536); + assert_eq!(f.usage_put(&token, empty.tag(), &valid).await.status, 413); + set_ciphertext_size(&mut valid, usage::MAX_CIPHERTEXT); + assert_eq!(f.usage_put(&token, empty.tag(), &valid).await.status, 200); + let old = f.meta(&token).await; + assert_eq!( + f.put(&token, old.tag(), &next(&vault, 20, "snapshot")) + .await + .code(), + "invalid_crypto_header" + ); + let mut rotation = dual(&rekey(&vault, 21), f.usage_meta(&token).await.tag(), 1, 22); + set_ciphertext_size(&mut rotation["vaultSnapshot"], MAX_CIPHERTEXT); + set_ciphertext_size(&mut rotation["usageSnapshot"], usage::MAX_CIPHERTEXT); + assert_eq!(f.rotate(&token, old.tag(), &rotation).await.status, 200); +} + +fn set_ciphertext_size(snapshot: &mut Value, bytes: usize) { + let ciphertext = vec![47; bytes]; + snapshot["ciphertextSha256"] = hash(&ciphertext).into(); + snapshot["ciphertext"] = URL_SAFE_NO_PAD.encode(ciphertext).into(); +} + +// This synthetic peer fixture exercises the real HTTP and AEAD boundary, not shipped clients. +#[tokio::test] +async fn encrypted_two_peer_join_has_no_echo_and_rotates_under_new_key() { + let f = Fixture::new(); + let a = f.login("github-alice").await; + let b = f.login("github-alice-renamed").await; + let vault = create(&f, &a).await; + let key = [54; 32]; + let old = f.usage_meta(&a).await; + let record = |n| { + json!({"id": Uuid::new_v4().to_string(), "occurredAtMs": 1795104000000i64, + "kind":"llm", "purpose":"dictationPostprocess", "outcome":"succeeded", "inputTokens": n}) + }; + let mut a_local = vec![record(10)]; + let mut b_local = vec![record(7)]; + let b_pending = encrypted_usage(usage_upload(&vault, 0, 30), &key, &b_local); + let a_pending = encrypted_usage(usage_upload(&vault, 0, 31), &key, &a_local); + let a_commit = f.usage_put(&a, old.tag(), &a_pending).await; + assert_eq!(a_commit.status, 200); + assert_eq!(f.usage_put(&b, old.tag(), &b_pending).await.status, 412); + let (_, b_commit) = sync_test_peer(&f, &b, &vault, &key, &b_local, 32).await; + assert_eq!(b_commit.as_ref().unwrap().status, 200); + let (reverse, no_write) = sync_test_peer(&f, &a, &vault, &key, &a_local, 33).await; + assert_eq!(sum(&reverse), 17); + assert!(no_write.is_none()); + assert_eq!( + f.usage_put(&a, old.tag(), &a_pending).await.json, + a_commit.json + ); + assert_eq!(f.usage_meta(&b).await.json["revision"], "2"); + a_local.push(record(4)); + b_local.push(record(2)); + assert_eq!( + sync_test_peer(&f, &a, &vault, &key, &a_local, 34) + .await + .1 + .unwrap() + .status, + 200 + ); + let (merged, write) = sync_test_peer(&f, &b, &vault, &key, &b_local, 35).await; + assert_eq!(sum(&merged), 23); + assert_eq!(write.unwrap().status, 200); + let (a_restored, no_write) = sync_test_peer(&f, &a, &vault, &key, &a_local, 36).await; + assert_eq!(sum(&a_restored), 23); + assert!(no_write.is_none()); + assert_eq!(f.usage_meta(&a).await.json["revision"], "4"); + + let mut conflict = merged[0].clone(); + conflict["inputTokens"] = 0.into(); + assert!(merge_test_records(&merged, &[conflict]).is_err()); + let new_key = [55; 32]; + let new_vault = rekey(&vault, 37); + let head = f.usage_meta(&a).await; + let mut rotation = dual(&new_vault, head.tag(), 4, 38); + rotation["usageSnapshot"] = + encrypted_usage(rotation["usageSnapshot"].clone(), &new_key, &merged); + let legacy_head = f.meta(&a).await; + assert_eq!(f.rotate(&a, legacy_head.tag(), &rotation).await.status, 200); + let f = f.reopen(UsageMode::Enabled); + let head = f.usage_meta(&b).await; + let downloaded = f.usage_download(&b, head.tag()).await; + assert!(open_usage(downloaded.json.clone(), &key).is_err()); + assert_eq!(sum(&open_usage(downloaded.json, &new_key).unwrap()), 23); +} + +fn encrypted_usage(mut value: Value, key: &[u8; 32], records: &[Value]) -> Value { + use chacha20poly1305::{ + XChaCha20Poly1305, XNonce, + aead::{Aead, KeyInit, Payload}, + }; + let snapshot: usage::UsageSnapshot = serde_json::from_value(value.clone()).unwrap(); + let json = serde_json::to_vec(&json!({"version":1,"records": records})).unwrap(); + let mut frame = (json.len() as u32).to_be_bytes().to_vec(); + frame.extend_from_slice(&json); + frame.resize(65_536, 0); + getrandom::fill(&mut frame[json.len() + 4..]).unwrap(); + let nonce = URL_SAFE_NO_PAD.decode(&snapshot.nonce).unwrap(); + let ciphertext = XChaCha20Poly1305::new(key.into()) + .encrypt( + XNonce::from_slice(&nonce), + Payload { + msg: &frame, + aad: &snapshot.aad(), + }, + ) + .unwrap(); + value["ciphertextSha256"] = hash(&ciphertext).into(); + value["ciphertext"] = URL_SAFE_NO_PAD.encode(ciphertext).into(); + value +} + +fn open_usage(value: Value, key: &[u8; 32]) -> Result, chacha20poly1305::Error> { + use chacha20poly1305::{ + XChaCha20Poly1305, XNonce, + aead::{Aead, KeyInit, Payload}, + }; + let snapshot: usage::UsageSnapshot = serde_json::from_value(value).unwrap(); + snapshot.validate("11").unwrap(); + let nonce = URL_SAFE_NO_PAD.decode(&snapshot.nonce).unwrap(); + let ciphertext = URL_SAFE_NO_PAD.decode(&snapshot.ciphertext).unwrap(); + let plaintext = XChaCha20Poly1305::new(key.into()).decrypt( + XNonce::from_slice(&nonce), + Payload { + msg: &ciphertext, + aad: &snapshot.aad(), + }, + )?; + let len = u32::from_be_bytes(plaintext[..4].try_into().unwrap()) as usize; + let payload: Value = serde_json::from_slice(&plaintext[4..4 + len]).unwrap(); + assert_eq!(payload["version"], 1); + Ok(payload["records"].as_array().unwrap().clone()) +} + +async fn sync_test_peer( + f: &Fixture, + token: &str, + vault: &Value, + key: &[u8; 32], + local: &[Value], + nonce: u8, +) -> (Vec, Option) { + let head = f.usage_meta(token).await; + let remote = open_usage(f.usage_download(token, head.tag()).await.json, key).unwrap(); + let merged = merge_test_records(&remote, local).unwrap(); + if merged == remote { + return (merged, None); + } + let base = head.json["revision"].as_str().unwrap().parse().unwrap(); + let wire = encrypted_usage(usage_upload(vault, base, nonce), key, &merged); + let result = f.usage_put(token, head.tag(), &wire).await; + (merged, Some(result)) +} + +fn merge_test_records(remote: &[Value], local: &[Value]) -> Result, ()> { + use std::collections::{BTreeMap, btree_map::Entry}; + let mut records = BTreeMap::new(); + for value in remote.iter().chain(local) { + match records.entry(value["id"].as_str().unwrap()) { + Entry::Vacant(slot) => { + slot.insert(value.clone()); + } + Entry::Occupied(slot) if slot.get() == value => {} + Entry::Occupied(_) => return Err(()), + } + } + Ok(records.into_values().collect()) +} + +fn sum(records: &[Value]) -> u64 { + records + .iter() + .map(|item| item["inputTokens"].as_u64().unwrap()) + .sum() +} diff --git a/tests/vectors/service-usage-v1.json b/tests/vectors/service-usage-v1.json new file mode 100644 index 0000000..ea6cfd0 --- /dev/null +++ b/tests/vectors/service-usage-v1.json @@ -0,0 +1,43 @@ +{ + "formatVersion": 1, + "testOnly": true, + "passwordInput": "云同步Café-Vector2026!", + "salt": "AAECAwQFBgcICQoLDA0ODw", + "derivedKeyHex": "c96ca4c352b1f4812e6e79f31a0b47ad10de613cf9a31bfc54c0d31a2fd32c4a", + "aadUtf8Hex": "5b226f70656e6c6573732d636c6f75642d73796e63222c312c22736572766963652d7573616765222c223132333435222c2262653430366361352d333766612d346232362d396139612d373463316161643438656165222c2237323530643162642d356133652d343262302d393164632d646630636230363038323231222c2239303037313939323534373430393932222c2239303037313939323534373430393933222c2236313431666137652d643036662d343762342d396231362d656339326634303833363835222c312c22786368616368613230706f6c79313330352d69657466222c226a736f6e2d70616436346b2d7631225d", + "plaintextJsonUtf8Hex": "7b2276657273696f6e223a312c227265636f726473223a5b7b226964223a2264373832336534642d313966612d343738302d623630352d663961626632643364356533222c226f6363757272656441744d73223a313739353130343030303030302c226b696e64223a226c6c6d222c22707572706f7365223a227472616e736c6174696f6e222c226f7574636f6d65223a22737563636565646564222c2270726f7669646572223a22666978747572652d70726f7669646572222c22696e7075744163636f756e74696e67223a22696e636c7573697665222c22696e707574546f6b656e73223a31307d5d7d", + "recoveredJson": { + "version": 1, + "records": [ + { + "id": "d7823e4d-19fa-4780-b605-f9abf2d3d5e3", + "occurredAtMs": 1795104000000, + "kind": "llm", + "purpose": "translation", + "outcome": "succeeded", + "provider": "fixture-provider", + "inputAccounting": "inclusive", + "inputTokens": 10 + } + ] + }, + "padding": { + "pattern": "index-mod-251", + "length": 65296 + }, + "snapshot": { + "protocolVersion": 1, + "payloadSchemaVersion": 1, + "ownerGithubId": "12345", + "vaultId": "be406ca5-37fa-4b26-9a9a-74c1aad48eae", + "keyId": "7250d1bd-5a3e-42b0-91dc-df0cb0608221", + "baseRevision": "9007199254740992", + "revision": "9007199254740993", + "operationId": "6141fa7e-d06f-47b4-9b16-ec92f4083685", + "aead": "xchacha20poly1305-ietf", + "codec": "json-pad64k-v1", + "nonce": "ICEiIyQlJicoKSorLC0uLzAxMjM0NTY3", + "ciphertext": "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", + "ciphertextSha256": "aa92b4c8a94548d046ba226e67aed7243540fd9d14bfccf27551f77e938c9d07" + } +} From e4fc98dda0ed9efc5a3ab2a065c319adc7ed280c Mon Sep 17 00:00:00 2001 From: appergb <192432815+appergb@users.noreply.github.com> Date: Thu, 19 Nov 2026 12:27:00 +0800 Subject: [PATCH 2/2] Refresh audited dependencies and require Rust 1.89 Update bundled SQLite and the affected Quinn and rustix lock entries without broad updates. Replace unmaintained chrono with a UTC RFC3339 adapter that preserves persisted and on-the-wire timestamps. --- .github/workflows/check.yml | 2 +- Cargo.lock | 177 ++++++++++++------------------------ Cargo.toml | 6 +- README.md | 2 +- THIRD_PARTY_NOTICES.md | 41 ++++----- docs/deployment.md | 2 +- src/auth.rs | 8 +- src/clock.rs | 38 ++++++++ src/lib.rs | 1 + src/server.rs | 3 +- src/store.rs | 18 ++-- src/store/usage.rs | 20 ++-- tests/http_contract.rs | 2 +- tests/store_contract.rs | 4 +- tests/usage_contract.rs | 2 +- 15 files changed, 148 insertions(+), 178 deletions(-) create mode 100644 src/clock.rs diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index 994bf77..c431a9e 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -65,5 +65,5 @@ jobs: - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 - uses: dtolnay/rust-toolchain@6bed0761d98439e5a578e2877258200ad565ba87 with: - toolchain: '1.88.0' + toolchain: '1.89.0' - run: cargo check --locked --lib --bin openless-cloud-sync diff --git a/Cargo.lock b/Cargo.lock index ef8949f..939ae37 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -12,15 +12,6 @@ dependencies = [ "generic-array", ] -[[package]] -name = "android_system_properties" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc" -dependencies = [ - "libc", -] - [[package]] name = "argon2" version = "0.5.3" @@ -39,12 +30,6 @@ version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" -[[package]] -name = "autocfg" -version = "1.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" - [[package]] name = "aws-lc-rs" version = "1.18.1" @@ -233,18 +218,6 @@ dependencies = [ "zeroize", ] -[[package]] -name = "chrono" -version = "0.4.45" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327" -dependencies = [ - "iana-time-zone", - "num-traits", - "serde", - "windows-link", -] - [[package]] name = "cipher" version = "0.4.4" @@ -320,6 +293,12 @@ dependencies = [ "typenum", ] +[[package]] +name = "deranged" +version = "0.5.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e9de72ce2ad1f90dc62fa25f0f430ef85eb4b0d8fa0be4f30373bc40a21d28e" + [[package]] name = "digest" version = "0.10.7" @@ -604,30 +583,6 @@ dependencies = [ "tracing", ] -[[package]] -name = "iana-time-zone" -version = "0.1.65" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" -dependencies = [ - "android_system_properties", - "core-foundation-sys", - "iana-time-zone-haiku", - "js-sys", - "log", - "wasm-bindgen", - "windows-core", -] - -[[package]] -name = "iana-time-zone-haiku" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" -dependencies = [ - "cc", -] - [[package]] name = "icu_collections" version = "2.3.0" @@ -837,9 +792,9 @@ checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2" [[package]] name = "libsqlite3-sys" -version = "0.38.2" +version = "0.39.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1d20bef17f513b9b3004532233187769cd072d790971f4e4da0e346eb6401e8" +checksum = "14a5f01b87b92705d07b433c06f96cbc764637d81a0bffb5734ce17cf0f9a2b3" dependencies = [ "cc", "pkg-config", @@ -909,13 +864,10 @@ dependencies = [ ] [[package]] -name = "num-traits" -version = "0.2.19" +name = "num-conv" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" -dependencies = [ - "autocfg", -] +checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441" [[package]] name = "once_cell" @@ -937,7 +889,6 @@ dependencies = [ "axum", "base64 0.22.1", "chacha20poly1305", - "chrono", "getrandom 0.4.3", "http-body-util", "reqwest", @@ -946,6 +897,7 @@ dependencies = [ "serde_json", "sha2", "tempfile", + "time", "tokio", "tower", "tracing", @@ -1010,6 +962,12 @@ dependencies = [ "zerovec", ] +[[package]] +name = "powerfmt" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a6394b9e965e73d0a289ee54f589087e2c676aedf60885baf52c76b771e4958" + [[package]] name = "proc-macro2" version = "1.0.107" @@ -1041,9 +999,9 @@ dependencies = [ [[package]] name = "quinn-proto" -version = "0.11.18" +version = "0.11.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a9746dbde176634f4f2f1faf2404e30a31b2bc1e9cafb5329c95d8177a18c9fc" +checksum = "0e750cca55fe4f0439a15d0bb529da9651e79993e8e72c61a899a36d462befbe" dependencies = [ "aws-lc-rs", "bytes", @@ -1064,9 +1022,9 @@ dependencies = [ [[package]] name = "quinn-udp" -version = "0.5.15" +version = "0.5.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35a133f956daabe89a61a685c2649f13d82d5aa4bd5d12d1277e1072a21c0694" +checksum = "af66907df18639dcf4db56ca65490cabc4b27a97dbadd96f2926cca73298f016" dependencies = [ "cfg_aliases", "libc", @@ -1189,9 +1147,9 @@ dependencies = [ [[package]] name = "rusqlite" -version = "0.40.2" +version = "0.41.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "23f2a97da3e3873c73cb2a2e71b35c40ff95e0b1eefa8d72d8499a6928c3b5b3" +checksum = "da9bba6f3506135e120a6586df05be18b48d18896600646a4bec8f993d91a594" dependencies = [ "bitflags", "fallible-iterator", @@ -1219,9 +1177,9 @@ dependencies = [ [[package]] name = "rustix" -version = "1.1.5" +version = "1.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "891efababe418670775f199f0d233d84843c227a0949a883ce15b37c78d6629d" +checksum = "e5e76742e5294153d4dde1207dbec5bdd81eef6fabdc0d2118babadabfd858aa" dependencies = [ "bitflags", "errno", @@ -1612,6 +1570,36 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "time" +version = "0.3.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134" +dependencies = [ + "deranged", + "num-conv", + "powerfmt", + "serde_core", + "time-core", + "time-macros", +] + +[[package]] +name = "time-core" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109" + +[[package]] +name = "time-macros" +version = "0.2.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85" +dependencies = [ + "num-conv", + "time-core", +] + [[package]] name = "tinystr" version = "0.8.4" @@ -1990,65 +1978,12 @@ dependencies = [ "windows-sys 0.61.2", ] -[[package]] -name = "windows-core" -version = "0.62.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" -dependencies = [ - "windows-implement", - "windows-interface", - "windows-link", - "windows-result", - "windows-strings", -] - -[[package]] -name = "windows-implement" -version = "0.60.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.119", -] - -[[package]] -name = "windows-interface" -version = "0.59.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.119", -] - [[package]] name = "windows-link" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" -[[package]] -name = "windows-result" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" -dependencies = [ - "windows-link", -] - -[[package]] -name = "windows-strings" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" -dependencies = [ - "windows-link", -] - [[package]] name = "windows-sys" version = "0.52.0" diff --git a/Cargo.toml b/Cargo.toml index 99480ad..3290453 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,7 +2,7 @@ name = "openless-cloud-sync" version = "0.1.0" edition = "2024" -rust-version = "1.88" +rust-version = "1.89" description = "OpenLess encrypted snapshot sync service" license = "AGPL-3.0-only" repository = "https://github.com/Open-Less/openless-cloud-sync" @@ -11,13 +11,13 @@ publish = false [dependencies] axum = "0.8.9" base64 = "0.22" -chrono = { version = "0.4", default-features = false, features = ["clock", "serde"] } getrandom = "0.4" reqwest = { version = "0.13.5", default-features = false, features = ["json", "rustls"] } -rusqlite = { version = "0.40.2", features = ["bundled", "backup"] } +rusqlite = { version = "0.41.0", features = ["bundled", "backup"] } serde = { version = "1", features = ["derive"] } serde_json = "1" sha2 = "0.10" +time = { version = "0.3.55", features = ["formatting", "parsing"] } tokio = { version = "1", features = ["macros", "rt-multi-thread", "net", "signal", "sync", "time"] } tracing = "0.1" tracing-subscriber = { version = "0.3", features = ["json"] } diff --git a/README.md b/README.md index d4a78b9..9b0bf8c 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ cargo build --release --locked ## 开发与验证 -需要 Rust ≥ 1.88、C 编译器和 CMake。Python 验证环境建议 3.14;生产备份脚本只需系统 Python 3.9+。 +需要 Rust ≥ 1.89、C 编译器和 CMake。Python 验证环境建议 3.14;生产备份脚本只需系统 Python 3.9+。 ```bash cargo fmt --check diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md index b09696c..4219cee 100644 --- a/THIRD_PARTY_NOTICES.md +++ b/THIRD_PARTY_NOTICES.md @@ -1,14 +1,12 @@ # 第三方依赖许可清单 -根据 Cargo.lock 及锁定版本的 crate 元数据生成,更新:2026-09-25。包含运行和测试依赖,不替代上游许可正文。项目自身使用 AGPL-3.0-only;第三方代码保留各自许可证。所有锁定版本已下载并核对声明,分发二进制时须同时保留上游版权和许可文本。可用 `cargo vendor --locked` 收集上游源码及许可。 +根据 Cargo.lock 及锁定版本的 crate 元数据生成,更新:2026-11-19。包含运行和测试依赖,不替代上游许可正文。项目自身使用 AGPL-3.0-only;第三方代码保留各自许可证。所有锁定版本已下载并核对声明,分发二进制时须同时保留上游版权和许可文本。可用 `cargo vendor --locked` 收集上游源码及许可。 | Dependency | Version | Declared license | | --- | --- | --- | | aead | 0.5.2 | MIT OR Apache-2.0 | -| android_system_properties | 0.1.6 | MIT OR Apache-2.0 | | argon2 | 0.5.3 | MIT OR Apache-2.0 | | atomic-waker | 1.1.2 | Apache-2.0 OR MIT | -| autocfg | 1.5.1 | Apache-2.0 OR MIT | | aws-lc-rs | 1.18.1 | ISC AND (Apache-2.0 OR ISC) | | aws-lc-sys | 0.45.0 | ISC AND (Apache-2.0 OR ISC) AND Apache-2.0 AND MIT AND BSD-3-Clause AND (Apache-2.0 OR ISC OR MIT) AND (Apache-2.0 OR ISC OR MIT-0) | | axum | 0.8.9 | MIT | @@ -27,7 +25,6 @@ | chacha20 | 0.10.2 | MIT OR Apache-2.0 | | chacha20 | 0.9.1 | Apache-2.0 OR MIT | | chacha20poly1305 | 0.10.1 | Apache-2.0 OR MIT | -| chrono | 0.4.45 | MIT OR Apache-2.0 | | cipher | 0.4.4 | MIT OR Apache-2.0 | | cmake | 0.1.58 | MIT OR Apache-2.0 | | combine | 4.6.8 | MIT | @@ -36,6 +33,7 @@ | cpufeatures | 0.2.17 | MIT OR Apache-2.0 | | cpufeatures | 0.3.1 | MIT OR Apache-2.0 | | crypto-common | 0.1.7 | MIT OR Apache-2.0 | +| deranged | 0.5.9 | MIT OR Apache-2.0 | | digest | 0.10.7 | MIT OR Apache-2.0 | | displaydoc | 0.2.7 | MIT OR Apache-2.0 | | dunce | 1.0.5 | CC0-1.0 OR MIT-0 OR Apache-2.0 | @@ -65,8 +63,6 @@ | hyper | 1.11.1 | MIT | | hyper-rustls | 0.27.10 | Apache-2.0 OR ISC OR MIT | | hyper-util | 0.1.20 | MIT | -| iana-time-zone | 0.1.65 | MIT OR Apache-2.0 | -| iana-time-zone-haiku | 0.1.2 | MIT OR Apache-2.0 | | icu_collections | 2.3.0 | Unicode-3.0 | | icu_locale_core | 2.3.0 | Unicode-3.0 | | icu_normalizer | 2.3.0 | Unicode-3.0 | @@ -87,7 +83,7 @@ | js-sys | 0.3.105 | MIT OR Apache-2.0 | | lazy_static | 1.5.0 | MIT OR Apache-2.0 | | libc | 0.2.189 | MIT OR Apache-2.0 | -| libsqlite3-sys | 0.38.2 | MIT | +| libsqlite3-sys | 0.39.1 | MIT | | linux-raw-sys | 0.12.1 | Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT | | litemap | 0.8.3 | Unicode-3.0 | | log | 0.4.34 | MIT OR Apache-2.0 | @@ -97,7 +93,7 @@ | mime | 0.3.17 | MIT OR Apache-2.0 | | mio | 1.2.3 | MIT | | nu-ansi-term | 0.50.3 | MIT | -| num-traits | 0.2.19 | MIT OR Apache-2.0 | +| num-conv | 0.2.2 | MIT OR Apache-2.0 | | once_cell | 1.21.4 | MIT OR Apache-2.0 | | opaque-debug | 0.3.1 | MIT OR Apache-2.0 | | openssl-probe | 0.2.1 | MIT OR Apache-2.0 | @@ -107,10 +103,11 @@ | pkg-config | 0.3.34 | MIT OR Apache-2.0 | | poly1305 | 0.8.0 | Apache-2.0 OR MIT | | potential_utf | 0.1.6 | Unicode-3.0 | +| powerfmt | 0.2.1 | MIT OR Apache-2.0 | | proc-macro2 | 1.0.107 | MIT OR Apache-2.0 | | quinn | 0.11.12 | MIT OR Apache-2.0 | -| quinn-proto | 0.11.18 | MIT OR Apache-2.0 | -| quinn-udp | 0.5.15 | MIT OR Apache-2.0 | +| quinn-proto | 0.11.19 | MIT OR Apache-2.0 | +| quinn-udp | 0.5.16 | MIT OR Apache-2.0 | | quote | 1.0.47 | MIT OR Apache-2.0 | | r-efi | 6.0.0 | MIT OR Apache-2.0 OR LGPL-2.1-or-later | | rand | 0.10.3 | MIT OR Apache-2.0 | @@ -120,16 +117,16 @@ | reqwest | 0.13.5 | MIT OR Apache-2.0 | | ring | 0.17.14 | Apache-2.0 AND ISC | | rsqlite-vfs | 0.1.1 | MIT | -| rusqlite | 0.40.2 | MIT | +| rusqlite | 0.41.1 | MIT | | rustc-hash | 2.1.3 | Apache-2.0 OR MIT | | rustc_version | 0.4.1 | MIT OR Apache-2.0 | -| rustix | 1.1.5 | Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT | -| rustls | 0.23.45 | Apache-2.0 OR ISC OR MIT | +| rustix | 1.1.6 | Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT | +| rustls | 0.23.46 | Apache-2.0 OR ISC OR MIT | | rustls-native-certs | 0.8.4 | Apache-2.0 OR ISC OR MIT | | rustls-pki-types | 1.15.1 | MIT OR Apache-2.0 | | rustls-platform-verifier | 0.7.0 | MIT OR Apache-2.0 | | rustls-platform-verifier-android | 0.1.1 | MIT OR Apache-2.0 | -| rustls-webpki | 0.103.15 | ISC | +| rustls-webpki | 0.103.16 | ISC | | rustversion | 1.0.23 | MIT OR Apache-2.0 | | ryu | 1.0.23 | Apache-2.0 OR BSL-1.0 | | same-file | 1.0.6 | Unlicense/MIT | @@ -163,9 +160,12 @@ | thiserror | 2.0.20 | MIT OR Apache-2.0 | | thiserror-impl | 2.0.20 | MIT OR Apache-2.0 | | thread_local | 1.1.10 | MIT OR Apache-2.0 | +| time | 0.3.55 | MIT OR Apache-2.0 | +| time-core | 0.1.9 | MIT OR Apache-2.0 | +| time-macros | 0.2.32 | MIT OR Apache-2.0 | | tinystr | 0.8.4 | Unicode-3.0 | | tinyvec | 1.13.3 | Zlib OR Apache-2.0 OR MIT | -| tokio | 1.53.1 | MIT | +| tokio | 1.54.1 | MIT | | tokio-macros | 2.7.2 | MIT | | tokio-rustls | 0.26.5 | MIT OR Apache-2.0 | | tower | 0.5.3 | MIT | @@ -200,14 +200,9 @@ | wasm-bindgen-shared | 0.2.128 | MIT OR Apache-2.0 | | web-sys | 0.3.105 | MIT OR Apache-2.0 | | web-time | 1.1.0 | MIT OR Apache-2.0 | -| webpki-root-certs | 1.0.9 | CDLA-Permissive-2.0 | +| webpki-root-certs | 1.0.10 | CDLA-Permissive-2.0 | | winapi-util | 0.1.11 | Unlicense OR MIT | -| windows-core | 0.62.2 | MIT OR Apache-2.0 | -| windows-implement | 0.60.2 | MIT OR Apache-2.0 | -| windows-interface | 0.59.3 | MIT OR Apache-2.0 | | windows-link | 0.2.1 | MIT OR Apache-2.0 | -| windows-result | 0.4.1 | MIT OR Apache-2.0 | -| windows-strings | 0.5.1 | MIT OR Apache-2.0 | | windows-sys | 0.52.0 | MIT OR Apache-2.0 | | windows-sys | 0.61.2 | MIT OR Apache-2.0 | | windows-targets | 0.52.6 | MIT OR Apache-2.0 | @@ -220,8 +215,8 @@ | windows_x86_64_gnullvm | 0.52.6 | MIT OR Apache-2.0 | | windows_x86_64_msvc | 0.52.6 | MIT OR Apache-2.0 | | writeable | 0.6.4 | Unicode-3.0 | -| yoke | 0.8.3 | Unicode-3.0 | -| yoke-derive | 0.8.3 | Unicode-3.0 | +| yoke | 0.8.4 | Unicode-3.0 | +| yoke-derive | 0.8.4 | Unicode-3.0 | | zerofrom | 0.1.8 | Unicode-3.0 | | zerofrom-derive | 0.1.8 | Unicode-3.0 | | zeroize | 1.9.0 | Apache-2.0 OR MIT | diff --git a/docs/deployment.md b/docs/deployment.md index 3e520bf..330349d 100644 --- a/docs/deployment.md +++ b/docs/deployment.md @@ -4,7 +4,7 @@ ## 部署输入 -- Ubuntu/Debian 主机,root 或有等效安装权限的 SSH 账号;已安装 Git、Rust ≥ 1.88、C 编译器、CMake、nginx、Python 3、CA 证书。 +- Ubuntu/Debian 主机,root 或有等效安装权限的 SSH 账号;已安装 Git、Rust ≥ 1.89、C 编译器、CMake、nginx、Python 3、CA 证书。 - 独立同步 HTTPS origin 及其有效 TLS 证书、私钥路径;可以是独立子域名,或现有域名的独立 HTTPS 端口。DNS 指向目标主机,配置的 TLS 端口可达。客户端使用 HTTPS origin,不带旧服务的 `/me/sync` 路径。 - 复用现有 OpenLess GitHub OAuth App 和设备登录态,仅使用身份 scope;client secret 仅进入服务器配置,客户端凭据库继续保存已有 GitHub 登录令牌。 - 用于逐项测试的 GitHub numeric ID。默认 restricted 模式;空白名单关闭登录。 diff --git a/src/auth.rs b/src/auth.rs index 9571e15..0a6c9a5 100644 --- a/src/auth.rs +++ b/src/auth.rs @@ -1,4 +1,5 @@ use crate::{ + clock, error::{ApiError, Result}, protocol, store::Store, @@ -85,9 +86,8 @@ impl GithubVerifier { return Err(ApiError::unavailable()); } if let Some(expires) = checked.expires_at { - let expires = chrono::DateTime::parse_from_rfc3339(&expires) - .map_err(|_| ApiError::unavailable())?; - if expires.timestamp() <= chrono::Utc::now().timestamp() { + let expires = clock::parse_rfc3339(&expires)?; + if expires <= clock::now() { return Err(ApiError::new(StatusCode::UNAUTHORIZED, "unauthenticated")); } } @@ -128,7 +128,7 @@ pub async fn session(store: &Store, account: Account) -> Result i64 { + OffsetDateTime::now_utc().unix_timestamp() +} + +pub(crate) fn wire_timestamp(seconds: i64) -> Result { + OffsetDateTime::from_unix_timestamp(seconds) + .map_err(|_| ApiError::unavailable())? + .format(&Rfc3339) + .map_err(|_| ApiError::unavailable()) +} + +pub(crate) fn parse_rfc3339(value: &str) -> Result { + OffsetDateTime::parse(value, &Rfc3339) + .map(OffsetDateTime::unix_timestamp) + .map_err(|_| ApiError::unavailable()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn preserves_v1_utc_seconds_encoding_and_numeric_offset_expiry() { + let legacy = "2026-09-23T00:00:00Z"; + let seconds = parse_rfc3339(legacy).unwrap(); + assert_eq!(wire_timestamp(seconds).unwrap(), legacy); + assert_eq!( + parse_rfc3339("2026-09-23T03:00:00.999999999+03:00").unwrap(), + seconds + ); + assert_eq!(parse_rfc3339("1970-01-01T00:00:00Z").unwrap(), 0); + assert_eq!(wire_timestamp(-1).unwrap(), "1969-12-31T23:59:59Z"); + assert!(parse_rfc3339("2026-09-23T00:00:00").is_err()); + } +} diff --git a/src/lib.rs b/src/lib.rs index 57a0176..bba6152 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,4 +1,5 @@ pub mod auth; +mod clock; pub mod config; pub mod error; pub mod protocol; diff --git a/src/server.rs b/src/server.rs index 11d3e7f..e119d28 100644 --- a/src/server.rs +++ b/src/server.rs @@ -1,5 +1,6 @@ use crate::{ auth::{self, IdentityVerifier}, + clock, config::Config, error::{ApiError, Result}, protocol, @@ -138,7 +139,7 @@ async fn handle(state: &AppState, request: Request) -> Result { } else { peer }; - let now = chrono::Utc::now().timestamp(); + let now = clock::now(); if method == Method::OPTIONS { if origin.is_none() { return Err(ApiError::invalid()); diff --git a/src/store.rs b/src/store.rs index e6c73c5..18322d4 100644 --- a/src/store.rs +++ b/src/store.rs @@ -1,11 +1,11 @@ mod usage; use crate::{ + clock, error::{ApiError, Result}, protocol::{self, DeleteRequest, Metadata, Receipt, Snapshot, UploadKind}, }; use axum::http::StatusCode; -use chrono::{SecondsFormat, Utc}; use rusqlite::{Connection, OptionalExtension, TransactionBehavior, params}; use std::{ path::Path, @@ -150,13 +150,13 @@ impl Store { protocol::uuid(&request.operation_id)?; let fingerprint = request.fingerprint(); let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; - let now = Utc::now(); - if let Some(prior) = replay(&tx, &request, &fingerprint, now.timestamp())? { + let now = clock::now(); + if let Some(prior) = replay(&tx, &request, &fingerprint, now)? { return Ok((prior.vault.ok_or_else(ApiError::unavailable)?, true)); } let tag = protocol::etag(request.if_match.as_deref())?; let old = read_metadata(&tx, &request.owner)?; - let timestamp = now.to_rfc3339_opts(SecondsFormat::Secs, true); + let timestamp = clock::wire_timestamp(now)?; let (meta, receipt, snapshot) = match (request.method.as_str(), request.path.as_str()) { ("PUT", "/v1/me/vault/snapshot") => { let upload: Snapshot = @@ -225,7 +225,7 @@ impl Store { &request.owner, &fingerprint, &receipt, - now.timestamp(), + now, )?; tx.commit()?; Ok((receipt, false)) @@ -259,7 +259,7 @@ impl Store { ) .optional()?; match row { - Some((owner, expires)) if expires > Utc::now().timestamp() => Ok(owner), + Some((owner, expires)) if expires > clock::now() => Ok(owner), Some(_) => Err(ApiError::new(StatusCode::UNAUTHORIZED, "session_expired")), None => Err(ApiError::new(StatusCode::UNAUTHORIZED, "unauthenticated")), } @@ -271,7 +271,7 @@ impl Store { self.run(move |db| { let changed = db.execute( "DELETE FROM sessions WHERE token_hash=?1 AND expires_at>?2", - params![token_hash, Utc::now().timestamp()], + params![token_hash, clock::now()], )?; if changed != 1 { return Err(ApiError::new(StatusCode::UNAUTHORIZED, "unauthenticated")); @@ -314,7 +314,7 @@ impl Store { pub async fn maintain(&self) -> Result<()> { self.run(|db| { let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; - let now = Utc::now().timestamp(); + let now = clock::now(); tx.execute( "DELETE FROM operations WHERE committed_at Result { - match read_operation(db, route, owner, id, Utc::now().timestamp())? { + match read_operation(db, route, owner, id, clock::now())? { Some((_, receipt)) => from_db(&receipt), None => Err(ApiError::new(StatusCode::NOT_FOUND, "operation_not_found")), } diff --git a/src/store/usage.rs b/src/store/usage.rs index b1d5a33..3b4fa4a 100644 --- a/src/store/usage.rs +++ b/src/store/usage.rs @@ -3,13 +3,13 @@ use super::{ remember_nonce, replay, state_conflict, to_db, write_operation, write_vault, }; use crate::{ + clock, config::UsageMode, error::{ApiError, Result}, protocol::{self, Metadata, Receipt, UploadKind}, usage::{self, Rotation, RotationReceipt, UsageMetadata, UsageSnapshot, UsageState}, }; use axum::http::StatusCode; -use chrono::{SecondsFormat, Utc}; use rusqlite::{Connection, OptionalExtension, TransactionBehavior, params}; impl Store { @@ -54,8 +54,8 @@ impl Store { } let fingerprint = request.fingerprint(); let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; - let now = Utc::now(); - if let Some(prior) = replay(&tx, &request, &fingerprint, now.timestamp())? { + let now = clock::now(); + if let Some(prior) = replay(&tx, &request, &fingerprint, now)? { return Ok((prior.usage.ok_or_else(ApiError::unavailable)?, true)); } if mode == UsageMode::Rescue { @@ -80,7 +80,7 @@ impl Store { return Err(ApiError::conflict("key_epoch_changed", &old.revision)); } check_usage_cas(&old, tag, &upload.base_revision)?; - let timestamp = now.to_rfc3339_opts(SecondsFormat::Secs, true); + let timestamp = clock::wire_timestamp(now)?; let receipt = write_usage( &tx, &upload, @@ -95,7 +95,7 @@ impl Store { &request.owner, &fingerprint, &receipt, - now.timestamp(), + now, )?; tx.commit()?; Ok((receipt, false)) @@ -110,8 +110,8 @@ impl Store { } let fingerprint = request.fingerprint(); let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; - let now = Utc::now(); - if let Some(prior) = replay(&tx, &request, &fingerprint, now.timestamp())? { + let now = clock::now(); + if let Some(prior) = replay(&tx, &request, &fingerprint, now)? { let vault_receipt = prior.vault.ok_or_else(ApiError::unavailable)?; let usage_receipt = prior.usage.ok_or_else(ApiError::unavailable)?; return Ok(( @@ -137,7 +137,7 @@ impl Store { } let size = usage_upload.validate(&request.owner)?; let old = read_metadata(&tx, &request.owner)?; - let timestamp = now.to_rfc3339_opts(SecondsFormat::Secs, true); + let timestamp = clock::wire_timestamp(now)?; // V1 validation and nonce reservation share a transaction with Usage CAS and data. let (meta, vault_receipt) = prepare_vault_upload(&tx, &request, &old, tag, &upload, ×tamp, true)?; @@ -161,7 +161,7 @@ impl Store { &request.owner, &fingerprint, &vault_receipt, - now.timestamp(), + now, )?; write_operation( &tx, @@ -169,7 +169,7 @@ impl Store { &request.owner, &fingerprint, &usage_receipt, - now.timestamp(), + now, )?; tx.commit()?; Ok(( diff --git a/tests/http_contract.rs b/tests/http_contract.rs index ac39a01..ef5300e 100644 --- a/tests/http_contract.rs +++ b/tests/http_contract.rs @@ -440,7 +440,7 @@ async fn limits_expiry_and_auth_exchange_are_real() { let db = rusqlite::Connection::open(f.dir.path().join("sync.db")).unwrap(); db.execute( "UPDATE sessions SET expires_at=?1", - [chrono::Utc::now().timestamp() - 1], + [time::OffsetDateTime::now_utc().unix_timestamp() - 1], ) .unwrap(); assert_eq!(f.meta(&token).await.code(), "session_expired"); diff --git a/tests/store_contract.rs b/tests/store_contract.rs index 9a420a4..6e4bce9 100644 --- a/tests/store_contract.rs +++ b/tests/store_contract.rs @@ -273,7 +273,7 @@ async fn rolling_rate_limit_and_retention_survive_restart() { let db = rusqlite::Connection::open(&path).unwrap(); db.execute( "UPDATE operations SET committed_at=?1", - [chrono::Utc::now().timestamp() - 604801], + [time::OffsetDateTime::now_utc().unix_timestamp() - 604801], ) .unwrap(); assert_eq!( @@ -327,7 +327,7 @@ async fn v1_upgrade_is_atomic_and_keeps_live_snapshot_and_receipt() { rusqlite::params![ upload.operation_id, receipt.to_string(), - chrono::Utc::now().timestamp() + time::OffsetDateTime::now_utc().unix_timestamp() ], ) .unwrap(); diff --git a/tests/usage_contract.rs b/tests/usage_contract.rs index 11139d6..5976362 100644 --- a/tests/usage_contract.rs +++ b/tests/usage_contract.rs @@ -163,7 +163,7 @@ async fn competing_usage_writers_and_lost_ack_are_not_double_commits() { let db = Connection::open(f.dir.path().join("sync.db")).unwrap(); db.execute( "UPDATE service_usage_operations SET committed_at=?1", - [chrono::Utc::now().timestamp() - 604801], + [time::OffsetDateTime::now_utc().unix_timestamp() - 604801], ) .unwrap(); f.store.maintain().await.unwrap();