@push.rocks/smartsecret 1.0.1 → 1.1.0

package/dist_ts/smartsecret.keyring.protocol.d.ts

@@ -0,0 +1,57 @@
+import * as plugins from './smartsecret.plugins.js';
+export declare const SMARTSECRET_KEYRING_SCHEMA_VERSION: 1;
+export declare const SMARTSECRET_KEYRING_PROFILE: "smartsecret-aes-256-gcm-dek-kek-v1";
+export type TSmartSecretKeyringProfile = typeof SMARTSECRET_KEYRING_PROFILE;
+export declare const SMARTSECRET_KEYRING_MAX_PAYLOAD_BYTES = 524288;
+export declare const SMARTSECRET_KEYRING_MIN_CONTEXT_BYTES = 1;
+export declare const SMARTSECRET_KEYRING_MAX_CONTEXT_BYTES = 65536;
+export declare const SMARTSECRET_KEYRING_MAX_IDENTIFIER_BYTES = 200;
+export declare const SMARTSECRET_KEYRING_MAX_KEK_VERSION = 2147483647;
+export interface ISmartSecretEnvelopeCiphertext {
+    nonce: string;
+    ciphertext: string;
+    tag: string;
+}
+export interface ISmartSecretEnvelopeV1 {
+    schemaVersion: 1;
+    profile: TSmartSecretKeyringProfile;
+    envelopeId: string;
+    createdAt: number;
+    contextDigest: string;
+    kek: {
+        keyringId: string;
+        version: number;
+        fingerprint: `sha256:${string}`;
+    };
+    payload: ISmartSecretEnvelopeCiphertext;
+    wrappedDek: ISmartSecretEnvelopeCiphertext;
+}
+export interface IParsedSmartSecretEnvelopeV1 {
+    envelope: ISmartSecretEnvelopeV1;
+    contextDigest: Uint8Array;
+    kekFingerprint: Uint8Array;
+    payload: plugins.smartcrypto.IAesGcmCiphertext;
+    wrappedDek: plugins.smartcrypto.IAesGcmCiphertext;
+}
+export interface ISmartSecretWrapAadFields {
+    envelopeId: string;
+    createdAt: number;
+    contextDigest: Uint8Array;
+    payloadDigest: Uint8Array;
+    keyringId: string;
+    kekVersion: number;
+    kekFingerprint: Uint8Array;
+}
+export declare const requireSmartSecretIdentifier: (valueArg: unknown) => string;
+export declare const requireEnvelopeIdentifier: (valueArg: unknown) => string;
+export declare const requireKekVersion: (valueArg: unknown, envelopeArg?: boolean) => number;
+export declare const requireEpochMilliseconds: (valueArg: unknown, envelopeArg?: boolean) => number;
+export declare const requireFingerprint: (valueArg: unknown, envelopeArg?: boolean) => `sha256:${string}`;
+export declare const fingerprintToBytes: (valueArg: `sha256:${string}`) => Uint8Array;
+export declare const encodeCanonicalBase64Url: (valueArg: Uint8Array) => string;
+export declare const parseSmartSecretEnvelope: (valueArg: unknown) => IParsedSmartSecretEnvelopeV1;
+export declare const sha256Bytes: (...valuesArg: Uint8Array[]) => Uint8Array;
+export declare const createSmartSecretPayloadDigest: (payloadArg: plugins.smartcrypto.IAesGcmCiphertext) => Uint8Array;
+export declare const createSmartSecretWrapAad: (fieldsArg: ISmartSecretWrapAadFields) => Uint8Array;
+export declare const wipeCiphertext: (valueArg: plugins.smartcrypto.IAesGcmCiphertext | undefined) => void;
+export declare const timingSafeEqual: (leftArg: Uint8Array, rightArg: Uint8Array) => boolean;

package/dist_ts/smartsecret.keyring.protocol.js

@@ -0,0 +1,290 @@
+import * as plugins from './smartsecret.plugins.js';
+import { SmartSecretKeyringError, createSmartSecretKeyringError, } from './smartsecret.keyring.error.js';
+export const SMARTSECRET_KEYRING_SCHEMA_VERSION = 1;
+export const SMARTSECRET_KEYRING_PROFILE = 'smartsecret-aes-256-gcm-dek-kek-v1';
+export const SMARTSECRET_KEYRING_MAX_PAYLOAD_BYTES = 524_288;
+export const SMARTSECRET_KEYRING_MIN_CONTEXT_BYTES = 1;
+export const SMARTSECRET_KEYRING_MAX_CONTEXT_BYTES = 65_536;
+export const SMARTSECRET_KEYRING_MAX_IDENTIFIER_BYTES = 200;
+export const SMARTSECRET_KEYRING_MAX_KEK_VERSION = 2_147_483_647;
+const identifierPattern = /^[A-Za-z0-9][A-Za-z0-9:._-]{0,199}$/;
+const fingerprintPattern = /^sha256:[0-9a-f]{64}$/;
+const base64UrlPattern = /^[A-Za-z0-9_-]*$/;
+const wrapAadMagic = Buffer.from('smartsecret-envelope-wrap-aad-v1', 'ascii');
+const payloadDigestMagic = Buffer.from('smartsecret-envelope-payload-digest-v1', 'ascii');
+const requirePlainObject = (valueArg, expectedKeysArg) => {
+    try {
+        if (valueArg === null || typeof valueArg !== 'object' || Array.isArray(valueArg)) {
+            throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+        }
+        const prototype = Object.getPrototypeOf(valueArg);
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+        }
+        const ownKeys = Reflect.ownKeys(valueArg);
+        if (ownKeys.length !== expectedKeysArg.length
+            || ownKeys.some((keyArg) => typeof keyArg !== 'string')) {
+            throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+        }
+        const actualKeys = ownKeys;
+        if (expectedKeysArg.some((keyArg) => !actualKeys.includes(keyArg))) {
+            throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+        }
+        const result = Object.create(null);
+        for (const key of actualKeys) {
+            const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+            if (!descriptor?.enumerable || !('value' in descriptor)) {
+                throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+            }
+            result[key] = descriptor.value;
+        }
+        return result;
+    }
+    catch (error) {
+        if (error instanceof SmartSecretKeyringError) {
+            throw error;
+        }
+        throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+    }
+};
+export const requireSmartSecretIdentifier = (valueArg) => {
+    if (typeof valueArg !== 'string'
+        || !identifierPattern.test(valueArg)
+        || Buffer.byteLength(valueArg, 'utf8') < 1
+        || Buffer.byteLength(valueArg, 'utf8') > SMARTSECRET_KEYRING_MAX_IDENTIFIER_BYTES) {
+        throw createSmartSecretKeyringError('CONFIG_INVALID');
+    }
+    return valueArg;
+};
+export const requireEnvelopeIdentifier = (valueArg) => {
+    try {
+        return requireSmartSecretIdentifier(valueArg);
+    }
+    catch {
+        throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+    }
+};
+export const requireKekVersion = (valueArg, envelopeArg = false) => {
+    if (!Number.isSafeInteger(valueArg)
+        || valueArg < 1
+        || valueArg > SMARTSECRET_KEYRING_MAX_KEK_VERSION) {
+        throw createSmartSecretKeyringError(envelopeArg ? 'ENVELOPE_INVALID' : 'CONFIG_INVALID');
+    }
+    return valueArg;
+};
+export const requireEpochMilliseconds = (valueArg, envelopeArg = false) => {
+    if (!Number.isSafeInteger(valueArg) || valueArg < 0) {
+        throw createSmartSecretKeyringError(envelopeArg ? 'ENVELOPE_INVALID' : 'CONFIG_INVALID');
+    }
+    return valueArg;
+};
+export const requireFingerprint = (valueArg, envelopeArg = false) => {
+    if (typeof valueArg !== 'string' || !fingerprintPattern.test(valueArg)) {
+        throw createSmartSecretKeyringError(envelopeArg ? 'ENVELOPE_INVALID' : 'CONFIG_INVALID');
+    }
+    return valueArg;
+};
+export const fingerprintToBytes = (valueArg) => new Uint8Array(Buffer.from(valueArg.slice('sha256:'.length), 'hex'));
+export const encodeCanonicalBase64Url = (valueArg) => Buffer.from(valueArg).toString('base64url');
+const decodeCanonicalBase64Url = (valueArg, maximumBytesArg, exactBytesArg) => {
+    if (typeof valueArg !== 'string') {
+        throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+    }
+    const maximumEncodedLength = Math.ceil(maximumBytesArg * 4 / 3);
+    if (valueArg.length > maximumEncodedLength) {
+        throw createSmartSecretKeyringError('SIZE_LIMIT_EXCEEDED');
+    }
+    if (!base64UrlPattern.test(valueArg) || valueArg.length % 4 === 1) {
+        throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+    }
+    let result;
+    let decodedBuffer;
+    let didSucceed = false;
+    try {
+        decodedBuffer = Buffer.from(valueArg, 'base64url');
+        result = new Uint8Array(decodedBuffer);
+        if (result.byteLength > maximumBytesArg) {
+            throw createSmartSecretKeyringError('SIZE_LIMIT_EXCEEDED');
+        }
+        if (exactBytesArg !== undefined && result.byteLength !== exactBytesArg) {
+            throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+        }
+        if (encodeCanonicalBase64Url(result) !== valueArg) {
+            throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+        }
+        didSucceed = true;
+        return result;
+    }
+    catch (error) {
+        if (error instanceof SmartSecretKeyringError) {
+            throw error;
+        }
+        throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+    }
+    finally {
+        decodedBuffer?.fill(0);
+        if (!didSucceed) {
+            result?.fill(0);
+        }
+    }
+};
+const parseCiphertext = (valueArg, maximumCiphertextBytesArg, exactCiphertextBytesArg) => {
+    const value = requirePlainObject(valueArg, ['nonce', 'ciphertext', 'tag']);
+    let nonce;
+    let ciphertext;
+    let tag;
+    let didSucceed = false;
+    try {
+        nonce = decodeCanonicalBase64Url(value.nonce, 12, 12);
+        ciphertext = decodeCanonicalBase64Url(value.ciphertext, maximumCiphertextBytesArg, exactCiphertextBytesArg);
+        tag = decodeCanonicalBase64Url(value.tag, 16, 16);
+        const result = {
+            encoded: {
+                nonce: value.nonce,
+                ciphertext: value.ciphertext,
+                tag: value.tag,
+            },
+            raw: { nonce, ciphertext, tag },
+        };
+        didSucceed = true;
+        return result;
+    }
+    finally {
+        if (!didSucceed) {
+            nonce?.fill(0);
+            ciphertext?.fill(0);
+            tag?.fill(0);
+        }
+    }
+};
+export const parseSmartSecretEnvelope = (valueArg) => {
+    const value = requirePlainObject(valueArg, [
+        'schemaVersion',
+        'profile',
+        'envelopeId',
+        'createdAt',
+        'contextDigest',
+        'kek',
+        'payload',
+        'wrappedDek',
+    ]);
+    if (value.schemaVersion !== SMARTSECRET_KEYRING_SCHEMA_VERSION) {
+        throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+    }
+    if (value.profile !== SMARTSECRET_KEYRING_PROFILE) {
+        throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+    }
+    let contextDigest;
+    let kekFingerprint;
+    let payload;
+    let wrappedDek;
+    let didSucceed = false;
+    try {
+        const envelopeId = requireEnvelopeIdentifier(value.envelopeId);
+        const createdAt = requireEpochMilliseconds(value.createdAt, true);
+        contextDigest = decodeCanonicalBase64Url(value.contextDigest, 32, 32);
+        const kekValue = requirePlainObject(value.kek, ['keyringId', 'version', 'fingerprint']);
+        const keyringId = requireEnvelopeIdentifier(kekValue.keyringId);
+        const version = requireKekVersion(kekValue.version, true);
+        const fingerprint = requireFingerprint(kekValue.fingerprint, true);
+        kekFingerprint = fingerprintToBytes(fingerprint);
+        payload = parseCiphertext(value.payload, SMARTSECRET_KEYRING_MAX_PAYLOAD_BYTES);
+        wrappedDek = parseCiphertext(value.wrappedDek, 32, 32);
+        const result = {
+            envelope: {
+                schemaVersion: SMARTSECRET_KEYRING_SCHEMA_VERSION,
+                profile: SMARTSECRET_KEYRING_PROFILE,
+                envelopeId,
+                createdAt,
+                contextDigest: value.contextDigest,
+                kek: { keyringId, version, fingerprint },
+                payload: payload.encoded,
+                wrappedDek: wrappedDek.encoded,
+            },
+            contextDigest,
+            kekFingerprint,
+            payload: payload.raw,
+            wrappedDek: wrappedDek.raw,
+        };
+        didSucceed = true;
+        return result;
+    }
+    finally {
+        if (!didSucceed) {
+            contextDigest?.fill(0);
+            kekFingerprint?.fill(0);
+            wipeCiphertext(payload?.raw);
+            wipeCiphertext(wrappedDek?.raw);
+        }
+    }
+};
+export const sha256Bytes = (...valuesArg) => {
+    const hash = plugins.crypto.createHash('sha256');
+    for (const value of valuesArg) {
+        hash.update(value);
+    }
+    return new Uint8Array(hash.digest());
+};
+const uint32Bytes = (valueArg) => {
+    const result = Buffer.allocUnsafe(4);
+    result.writeUInt32BE(valueArg, 0);
+    return result;
+};
+const uint64Bytes = (valueArg) => {
+    const result = Buffer.allocUnsafe(8);
+    result.writeBigUInt64BE(BigInt(valueArg), 0);
+    return result;
+};
+const lengthPrefixed = (valueArg) => {
+    if (valueArg.byteLength > 0xffff_ffff) {
+        throw createSmartSecretKeyringError('SIZE_LIMIT_EXCEEDED');
+    }
+    return Buffer.concat([uint32Bytes(valueArg.byteLength), valueArg]);
+};
+export const createSmartSecretPayloadDigest = (payloadArg) => {
+    const hash = plugins.crypto.createHash('sha256');
+    hash.update(payloadDigestMagic);
+    for (const value of [payloadArg.nonce, payloadArg.ciphertext, payloadArg.tag]) {
+        const length = uint32Bytes(value.byteLength);
+        try {
+            hash.update(length);
+            hash.update(value);
+        }
+        finally {
+            length.fill(0);
+        }
+    }
+    return new Uint8Array(hash.digest());
+};
+export const createSmartSecretWrapAad = (fieldsArg) => {
+    if (fieldsArg.contextDigest.byteLength !== 32
+        || fieldsArg.payloadDigest.byteLength !== 32
+        || fieldsArg.kekFingerprint.byteLength !== 32) {
+        throw createSmartSecretKeyringError('ENVELOPE_INVALID');
+    }
+    const profile = Buffer.from(SMARTSECRET_KEYRING_PROFILE, 'utf8');
+    const envelopeId = Buffer.from(requireEnvelopeIdentifier(fieldsArg.envelopeId), 'utf8');
+    const keyringId = Buffer.from(requireEnvelopeIdentifier(fieldsArg.keyringId), 'utf8');
+    const createdAt = requireEpochMilliseconds(fieldsArg.createdAt, true);
+    const kekVersion = requireKekVersion(fieldsArg.kekVersion, true);
+    return Buffer.concat([
+        wrapAadMagic,
+        uint64Bytes(SMARTSECRET_KEYRING_SCHEMA_VERSION),
+        lengthPrefixed(profile),
+        lengthPrefixed(envelopeId),
+        uint64Bytes(createdAt),
+        fieldsArg.contextDigest,
+        fieldsArg.payloadDigest,
+        lengthPrefixed(keyringId),
+        uint64Bytes(kekVersion),
+        fieldsArg.kekFingerprint,
+    ]);
+};
+export const wipeCiphertext = (valueArg) => {
+    valueArg?.nonce.fill(0);
+    valueArg?.ciphertext.fill(0);
+    valueArg?.tag.fill(0);
+};
+export const timingSafeEqual = (leftArg, rightArg) => leftArg.byteLength === rightArg.byteLength
+    && plugins.crypto.timingSafeEqual(leftArg, rightArg);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartsecret.keyring.protocol.js","sourceRoot":"","sources":["../ts/smartsecret.keyring.protocol.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartsecret.plugins.d.ts

@@ -3,4 +3,5 @@ import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-export { childProcess, crypto, fs, os, path };
+import * as smartcrypto from '@push.rocks/smartcrypto';
+export { childProcess, crypto, fs, os, path, smartcrypto };

package/dist_ts/smartsecret.plugins.js

@@ -4,5 +4,7 @@ import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-export { childProcess, crypto, fs, os, path };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzZWNyZXQucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c2VjcmV0LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxZQUFZLE1BQU0sZUFBZSxDQUFDO0FBQzlDLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBQ2pDLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLENBQUMifQ==
+// @push.rocks scope
+import * as smartcrypto from '@push.rocks/smartcrypto';
+export { childProcess, crypto, fs, os, path, smartcrypto };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzZWNyZXQucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c2VjcmV0LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxZQUFZLE1BQU0sZUFBZSxDQUFDO0FBQzlDLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBQ2pDLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBRXZELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLFdBQVcsRUFBRSxDQUFDIn0=

package/package.json

@@ -1,16 +1,11 @@
 {
   "name": "@push.rocks/smartsecret",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "private": false,
   "description": "OS keychain-based secret storage with encrypted-file fallback for Node.js.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
-  "scripts": {
-    "test": "(tstest test/ --verbose)",
-    "build": "(tsbuild)",
-    "buildDocs": "tsdoc"
-  },
   "repository": {
     "type": "git",
     "url": "https://code.foss.global/push.rocks/smartsecret.git"
@@ -34,11 +29,10 @@
   },
   "homepage": "https://code.foss.global/push.rocks/smartsecret",
   "devDependencies": {
-    "@git.zone/tsbuild": "^4.1.2",
-    "@git.zone/tsrun": "^2.0.1",
-    "@git.zone/tstest": "^3.1.8",
-    "@push.rocks/tapbundle": "^6.0.3",
-    "@types/node": "^22.15.0"
+    "@git.zone/tsbuild": "^4.4.2",
+    "@git.zone/tsrun": "^2.0.6",
+    "@git.zone/tstest": "^3.6.7",
+    "@types/node": "^22.20.1"
   },
   "files": [
     "ts/**/*",
@@ -49,10 +43,18 @@
     "dist_ts_web/**/*",
     "assets/**/*",
     "cli.js",
-    "npmextra.json",
+    ".smartconfig.json",
     "readme.md"
   ],
   "browserslist": [
     "last 1 chrome versions"
-  ]
-}
+  ],
+  "dependencies": {
+    "@push.rocks/smartcrypto": "^2.2.0"
+  },
+  "scripts": {
+    "test": "(tstest test/ --verbose)",
+    "build": "(tsbuild)",
+    "buildDocs": "tsdoc"
+  }
+}

package/readme.hints.md

@@ -2,7 +2,7 @@
 
 ## Architecture
 - 3-tier backend: macOS Keychain → Linux secret-tool → encrypted file vault
-- Zero runtime dependencies (Node.js built-ins only)
+- The legacy SmartSecret backends use Node.js built-ins only
 - All OS interactions via child_process.execFile (no shell injection)
 
 ## File Backend
@@ -10,3 +10,10 @@
 - Keyfile: auto-generated 32 random bytes at ~/.config/smartsecret/.keyfile (mode 0600)
 - Key derivation: PBKDF2 (SHA-512, 100k iterations, service-name salt)
 - Atomic writes: write .tmp then rename()
+
+## SmartSecret Keyring
+- Separate Linux-only API; it does not alter legacy SmartSecret backend selection or behavior
+- Uses @push.rocks/smartcrypto for AES-GCM payload encryption and DEK wrap/unwrap/rewrap
+- Loads exact 32-byte KEKs from validated absolute credential paths into immutable per-instance snapshots
+- Consumers own envelope persistence and compare-and-swap coordination
+- JavaScript key and plaintext zeroization is best effort

package/readme.md

@@ -2,6 +2,10 @@
 
 OS keychain-based secret storage with encrypted-file fallback for Node.js.
 
+## Issue Reporting and Security
+
+For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
+
 ## Install
 
 To install `@push.rocks/smartsecret`, use pnpm:
@@ -23,7 +27,7 @@ import { SmartSecret } from '@push.rocks/smartsecret';
 const secretStore = new SmartSecret();
 
 // Or specify a custom service name and vault path
-const secretStore = new SmartSecret({
+const customSecretStore = new SmartSecret({
   service: 'my-application',
   vaultPath: '/path/to/custom/vault.json',
 });
@@ -98,6 +102,76 @@ const appToken = await appSecrets.getSecret('token');  // 'app-token-value'
 const ciToken = await ciSecrets.getSecret('token');     // 'ci-token-value'
 ```
 
+## SmartSecret Keyring
+
+`SmartSecretKeyring` is a separate Node.js API for DEK/KEK envelopes. It does not change `SmartSecret` or any backend API. The keyring is intentionally Linux-only and fails closed on other platforms.
+
+The consumer supplies an ordered key configuration containing exactly one active KEK. Active and retired KEKs are read from absolute credential paths. Each credential must be a regular, non-symlinked, exact 32-byte file without group or world write permissions. Every path component is checked for symlinks, and the loaded key must match its configured SHA-256 fingerprint. Revoked descriptors never contain credential paths or fingerprints.
+
+```typescript
+import { SmartSecretKeyring } from '@push.rocks/smartsecret';
+
+const keyring = await SmartSecretKeyring.create({
+  keyringId: 'billing.production',
+  keys: [
+    {
+      version: 1,
+      status: 'retired',
+      credentialPath: '/run/credentials/billing-kek-v1',
+      expectedFingerprint: 'sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+      createdAt: 1_700_000_000_000,
+      activatedAt: 1_700_000_100_000,
+      retiredAt: 1_710_000_000_000,
+      escrowReference: 'escrow.billing-v1',
+      escrowedAt: 1_700_000_050_000,
+      recoveryTestedAt: 1_700_000_075_000,
+    },
+    {
+      version: 2,
+      status: 'active',
+      credentialPath: '/run/credentials/billing-kek-v2',
+      expectedFingerprint: 'sha256:abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789',
+      createdAt: 1_709_000_000_000,
+      activatedAt: 1_710_000_000_000,
+    },
+  ],
+});
+
+const context = new TextEncoder().encode('tenant:acme/secret:database-password');
+const plaintext = new TextEncoder().encode('secret value');
+
+const envelope = await keyring.encryptEnvelope({
+  envelopeId: 'secret.database-password',
+  plaintext,
+  context,
+});
+
+const decrypted = await keyring.decryptEnvelope({
+  envelope,
+  expectedEnvelopeId: 'secret.database-password',
+  context,
+});
+
+const rewrapped = await keyring.rewrapEnvelope({
+  envelope,
+  expectedEnvelopeId: 'secret.database-password',
+  context,
+  targetVersion: 2,
+});
+
+const recoveryResult = await keyring.recoverySelfTest(2);
+const inspection = keyring.inspect();
+keyring.destroy();
+```
+
+`encryptEnvelope()` always uses the sole active KEK. `decryptEnvelope()` permits active and retired KEKs, but rejects revoked and unknown versions. `rewrapEnvelope()` authenticates the current wrapper and context, then calls SmartCrypto's DEK rewrap operation without decrypting the payload. It preserves the payload nonce, ciphertext, and tag exactly.
+
+The profile is fixed to `smartsecret-aes-256-gcm-dek-kek-v1`. Payloads may contain 0 through 524,288 bytes. Context is mandatory and may contain 1 through 65,536 bytes. Identifiers use the pattern `^[A-Za-z0-9][A-Za-z0-9:._-]{0,199}$` and are limited to 200 UTF-8 bytes.
+
+Key loading is an immutable per-instance snapshot. Replacing a credential file does not reload an existing keyring; create a new instance and swap it at the application boundary. `destroy()` marks an instance unusable and best-effort wipes retained key arrays. Operation-owned key, plaintext, and context copies are also wiped in `finally` blocks. JavaScript runtimes, garbage collectors, and native cryptographic implementations can retain copies outside package control, so zeroization is best effort rather than a hard memory-erasure guarantee.
+
+The package never persists envelopes. The consumer owns durable envelope storage, compare-and-swap coordination during rewrap, and any metadata updates after recovery testing.
+
 ## API Reference
 
 ### `SmartSecret`
@@ -125,6 +199,25 @@ new SmartSecret(options?: ISmartSecretOptions)
 | `listAccounts` | `() => Promise<string[]>` | List all account names for the configured service |
 | `getBackendType` | `() => Promise<TBackendType>` | Returns the active backend identifier |
 
+### `SmartSecretKeyring`
+
+Create keyrings through the asynchronous factory. The constructor is not public.
+
+```typescript
+SmartSecretKeyring.create(config: ISmartSecretKeyringConfig): Promise<SmartSecretKeyring>
+```
+
+| Method | Signature | Description |
+| --- | --- | --- |
+| `encryptEnvelope` | `(options: IEncryptSmartSecretEnvelopeOptions) => Promise<ISmartSecretEnvelopeV1>` | Encrypt with a random DEK and wrap it under the active KEK |
+| `decryptEnvelope` | `(options: IDecryptSmartSecretEnvelopeOptions) => Promise<Uint8Array>` | Strictly parse, authenticate, and decrypt an envelope |
+| `rewrapEnvelope` | `(options: IRewrapSmartSecretEnvelopeOptions) => Promise<ISmartSecretEnvelopeV1>` | Rewrap only the DEK under the active KEK |
+| `recoverySelfTest` | `(version: number) => Promise<ISmartSecretRecoverySelfTestResult>` | Wrap and unwrap a synthetic random DEK for an active or retired version |
+| `inspect` | `() => ISmartSecretKeyringInspection` | Return cloned, value-free metadata without credential paths or key bytes |
+| `destroy` | `() => void` | Mark the instance unusable and best-effort wipe retained key arrays |
+
+All keyring failures are `SmartSecretKeyringError` instances with a stable `TSmartSecretKeyringErrorCode`. Their message, JSON representation, Node.js inspection output, and stack contain only the code and fixed package boilerplate. Filesystem and SmartCrypto causes are not retained.
+
 ### Types
 
 ```typescript
@@ -188,6 +281,21 @@ Both paths can be influenced by providing a custom `vaultPath` in the constructo
 
 ## License and Legal Information
 
-This project is licensed under the MIT license. For more details, see the `license` file in the repository.
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the repository license file.
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH or third parties, and are not included within the scope of the MIT license granted herein.
+
+Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.
+
+### Company Information
+
+Task Venture Capital GmbH<br>
+Registered at District Court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or further information, please contact us via email at hello@task.vc.
 
-By using this package, you agree to the licensing terms.
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartsecret',
-  version: '1.0.1',
+  version: '1.1.0',
   description: 'OS keychain-based secret storage with encrypted-file fallback for Node.js.'
 }

package/ts/index.ts

@@ -3,3 +3,13 @@ export type { ISecretBackend, TBackendType } from './smartsecret.backends.base.j
 export { MacosKeychainBackend } from './smartsecret.backends.macos.js';
 export { LinuxSecretServiceBackend } from './smartsecret.backends.linux.js';
 export { FileEncryptedBackend } from './smartsecret.backends.file.js';
+export * from './smartsecret.keyring.js';
+export { SmartSecretKeyringError } from './smartsecret.keyring.error.js';
+export type {
+  ISmartSecretKeyringErrorJson,
+  TSmartSecretKeyringErrorCode,
+} from './smartsecret.keyring.error.js';
+export type {
+  ISmartSecretEnvelopeV1,
+  TSmartSecretKeyringProfile,
+} from './smartsecret.keyring.protocol.js';