@push.rocks/smartsecret 1.0.2 → 1.2.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,8 @@ 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 url from 'url';
+import * as smartcrypto from '@push.rocks/smartcrypto';
+import * as smartipc from '@push.rocks/smartipc';
+import * as smartrust from '@push.rocks/smartrust';
+export { childProcess, crypto, fs, os, path, url, smartcrypto, smartipc, smartrust };

package/dist_ts/smartsecret.plugins.js

@@ -4,5 +4,10 @@ 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==
+import * as url from 'url';
+// @push.rocks scope
+import * as smartcrypto from '@push.rocks/smartcrypto';
+import * as smartipc from '@push.rocks/smartipc';
+import * as smartrust from '@push.rocks/smartrust';
+export { childProcess, crypto, fs, os, path, url, smartcrypto, smartipc, smartrust };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzZWNyZXQucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c2VjcmV0LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxZQUFZLE1BQU0sZUFBZSxDQUFDO0FBQzlDLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBQ2pDLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBRTNCLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUVuRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsRUFBRSxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUUsV0FBVyxFQUFFLFFBQVEsRUFBRSxTQUFTLEVBQUUsQ0FBQyJ9

package/package.json

@@ -1,16 +1,11 @@
 {
   "name": "@push.rocks/smartsecret",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "private": false,
-  "description": "OS keychain-based secret storage with encrypted-file fallback for Node.js.",
+  "description": "OS-backed secret storage plus strict Linux kernel-keyring and envelope APIs 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,10 +29,11 @@
   },
   "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",
-    "@types/node": "^22.15.0"
+    "@git.zone/tsbuild": "^4.4.2",
+    "@git.zone/tsrun": "^2.0.6",
+    "@git.zone/tsrust": "^1.7.0",
+    "@git.zone/tstest": "^3.6.7",
+    "@types/node": "^25.9.5"
   },
   "files": [
     "ts/**/*",
@@ -48,10 +44,22 @@
     "dist_ts_web/**/*",
     "assets/**/*",
     "cli.js",
-    "npmextra.json",
-    "readme.md"
+    ".smartconfig.json",
+    "readme.md",
+    "third-party-notices.md"
   ],
   "browserslist": [
     "last 1 chrome versions"
-  ]
-}
+  ],
+  "dependencies": {
+    "@push.rocks/smartcrypto": "^2.2.0",
+    "@push.rocks/smartipc": "^2.4.0",
+    "@push.rocks/smartrust": "^1.6.0"
+  },
+  "scripts": {
+    "test": "(tstest test/ --verbose)",
+    "test:before": "(tsrust) && (cargo test --manifest-path rust/Cargo.toml --target-dir .nogit/cargo-test-target)",
+    "build": "(tsbuild) && (tsrust)",
+    "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,21 @@
 - 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
+
+## SmartSecret Kernel Store
+- Additive strict API; legacy SmartSecret backend selection remains unchanged
+- Requires Node.js 25, Linux x64, Linux keyutils, and the exact package-owned static Rust worker
+- No shell, PATH lookup, environment override, Secret Service, or filesystem secret fallback
+- Generic values are framed and limited to 0..1024 bytes; service/account names are valid scalar UTF-8 strings of 1..1024 bytes
+- Persistent-root service rings are revalidated on every operation; process keyring ownership is staging-only
+- Service-wide SmartIPC NamedMutex plus a single monotonic 1..60000 ms deadline bounds cooperating cross-process access
+- Any post-dispatch mutation ambiguity or worker integrity failure terminates and poisons the store
+- DevIdP v1 migration is opaque, receipt-bound, keyutils-only, and requires a quiescent legacy writer
+- Same-UID readability and kernel expiry/reboot behavior are part of the security model