@kokuin/crypto 0.0.0-stage → 0.7.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Paul Le Cam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,53 @@
-# Temporary Holding Version
+# @kokuin/crypto
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Strict asynchronous crypto operations implemented with noble.
+This package imports no React Native modules and requires no Rust toolchain.
+
+```ts
+import { nobleCrypto } from '@kokuin/crypto'
+import type { CryptoProvider } from '@kokuin/crypto'
+
+export async function signMessage(seed: Uint8Array, message: Uint8Array) {
+  return nobleCrypto.sign({ alg: 'EdDSA', privateKey: seed, message })
+}
+```
+
+`CryptoProvider` supplies `sign`, `signBatch`, `verify`, `verifyBatch`, `blake3` and `blake3Batch`.
+All methods return Promises. Noble computation still runs synchronously on the calling thread.
+Inputs are consumed before the Promise returns, preserving caller mutations after invocation.
+
+Ed25519 signing accepts 32-byte seeds. Verification rejects noncanonical encodings and small-order or mixed-order points.
+ES256 verification accepts compact 64-byte signatures and compressed or uncompressed SEC1 keys.
+It hashes raw messages exactly once with SHA-256 and rejects high-S signatures.
+Malformed signatures or keys resolve `false`. Unsupported algorithms reject with `TypeError`.
+Detached buffers and shared buffers reject with `TypeError`.
+
+blake3 output lengths must be integers from 1 through 65536. Invalid lengths reject with `RangeError`.
+Empty batches resolve empty arrays. Batch results preserve input order and own independent output storage.
+
+Identity, token, controller, records and vault APIs accept this provider through explicit options.
+Applications can use its standalone methods or pass the structural contract to their own code.
+Native route qualification still requires stored measurements and final physical-device retesting.
+
+## Provider adoption
+
+Identity, controller, record and vault APIs now accept this provider contract.
+The six methods remain asynchronous. Verification now takes a named object. Strict noble caches public-key validation in a bounded 256-entry cache.
+Every signature point still receives strict validation. Applications must keep provider behaviour immutable throughout its lifetime.
+
+See [provider adoption](../../docs/reference/crypto-provider.md) for selection, migration and verification policy.
+
+## Named params migration
+
+`CryptoProvider.verify` now accepts one `VerifyItem`: `{ alg, signature, message, publicKey }`.
+`sign`, `signBatch`, `blake3` and `blake3Batch` take flat params objects.
+`verifyBatch` retains its single array argument.
+
+These signature and typing changes preserve cryptographic results, error causes, ordering and storage behaviour.
+
+| API | Named params type | Previous positional form |
+| --- | --- | --- |
+| `CryptoProvider.sign` | `CryptoProviderSignParams` | `sign(alg, privateKey, message)` |
+| `CryptoProvider.signBatch` | `CryptoProviderSignBatchParams` | `signBatch(alg, items)` |
+| `CryptoProvider.blake3` | `CryptoProviderBlake3Params` | `blake3(input, dkLen)` |
+| `CryptoProvider.blake3Batch` | `CryptoProviderBlake3BatchParams` | `blake3Batch(inputs, dkLen)` |

package/lib/bytes.d.ts

@@ -0,0 +1,2 @@
+/** Accept byte views across realms while excluding shared and detached buffers. */
+export declare function assertUnsharedBytes(value: Uint8Array): asserts value is Uint8Array<ArrayBuffer>;

package/lib/bytes.js

@@ -0,0 +1,7 @@
+/** Accept byte views across realms while excluding shared and detached buffers. */ export function assertUnsharedBytes(value) {
+    if (!ArrayBuffer.isView(value) || Object.prototype.toString.call(value) !== '[object Uint8Array]' || Object.prototype.toString.call(value.buffer) !== '[object ArrayBuffer]') {
+        throw new TypeError('Expected an unshared Uint8Array');
+    }
+    // Throws TypeError on a detached buffer.
+    new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export { assertUnsharedBytes } from './bytes.js';
+export { nobleCrypto } from './noble.js';
+export type { CryptoAlgorithm, CryptoProvider, CryptoProviderBlake3BatchParams, CryptoProviderBlake3Params, CryptoProviderSignBatchParams, CryptoProviderSignParams, SignItem, VerifyItem, } from './types.js';

package/lib/index.js

@@ -0,0 +1,2 @@
+export { assertUnsharedBytes } from './bytes.js';
+export { nobleCrypto } from './noble.js';

package/lib/noble.d.ts

@@ -0,0 +1,2 @@
+import type { CryptoProvider } from './types.js';
+export declare const nobleCrypto: CryptoProvider;

package/lib/noble.js

@@ -0,0 +1,104 @@
+import { ed25519 } from '@noble/curves/ed25519.js';
+import { p256 } from '@noble/curves/nist.js';
+import { blake3 } from '@noble/hashes/blake3.js';
+import { bytesToHex } from '@noble/hashes/utils.js';
+import { assertUnsharedBytes } from './bytes.js';
+function sign(alg, seed, message) {
+    if (alg !== 'EdDSA') throw new TypeError('Unsupported signing algorithm');
+    assertUnsharedBytes(seed);
+    assertUnsharedBytes(message);
+    if (seed.length !== 32) throw new TypeError('Expected a 32-byte Ed25519 seed');
+    return ed25519.sign(message, seed);
+}
+function strictPoint(bytes) {
+    const point = ed25519.Point.fromBytes(bytes, false);
+    return !point.isSmallOrder() && point.isTorsionFree();
+}
+const PUBLIC_KEY_CACHE_LIMIT = 256;
+const publicKeyValidation = new Map();
+function strictPublicKey(bytes) {
+    const key = bytesToHex(bytes);
+    const cached = publicKeyValidation.get(key);
+    if (cached !== undefined) return cached;
+    let valid = false;
+    try {
+        valid = strictPoint(bytes);
+    } catch  {
+    // Invalid encodings are stable refusals too.
+    }
+    if (publicKeyValidation.size === PUBLIC_KEY_CACHE_LIMIT) {
+        const oldest = publicKeyValidation.keys().next().value;
+        if (oldest !== undefined) publicKeyValidation.delete(oldest);
+    }
+    publicKeyValidation.set(key, valid);
+    return valid;
+}
+function verify({ alg, signature, message, publicKey }) {
+    if (alg !== 'EdDSA' && alg !== 'ES256') throw new TypeError('Unsupported verification algorithm');
+    for (const bytes of [
+        signature,
+        message,
+        publicKey
+    ])assertUnsharedBytes(bytes);
+    if (signature.length !== 64) return false;
+    try {
+        if (alg === 'EdDSA') {
+            return publicKey.length === 32 && strictPublicKey(publicKey) && strictPoint(signature.subarray(0, 32)) && ed25519.verify(signature, message, publicKey, {
+                zip215: false
+            });
+        }
+        if (!(publicKey.length === 33 && (publicKey[0] === 2 || publicKey[0] === 3) || publicKey.length === 65 && publicKey[0] === 4)) return false;
+        return p256.verify(signature, message, publicKey, {
+            lowS: true,
+            prehash: true,
+            format: 'compact'
+        });
+    } catch  {
+        return false;
+    }
+}
+function assertOutputLength(dkLen) {
+    if (!Number.isInteger(dkLen) || dkLen < 1 || dkLen > 65536) throw new RangeError('Invalid blake3 output length');
+}
+function hash(input, dkLen) {
+    assertUnsharedBytes(input);
+    assertOutputLength(dkLen);
+    return blake3(input, {
+        dkLen
+    });
+}
+// Inputs are consumed synchronously before the Promise is returned.
+export const nobleCrypto = {
+    async sign ({ alg, privateKey: seed, message }) {
+        return sign(alg, seed, message);
+    },
+    async signBatch ({ alg, items }) {
+        if (alg !== 'EdDSA') throw new TypeError('Unsupported signing algorithm');
+        return items.map((item)=>sign(alg, item.privateKey, item.message));
+    },
+    async verify ({ alg, signature, message, publicKey }) {
+        return verify({
+            alg,
+            signature,
+            message,
+            publicKey
+        });
+    },
+    async verifyBatch (items) {
+        return items.map((item)=>{
+            return verify({
+                alg: item.alg,
+                signature: item.signature,
+                message: item.message,
+                publicKey: item.publicKey
+            });
+        });
+    },
+    async blake3 ({ input, dkLen }) {
+        return hash(input, dkLen);
+    },
+    async blake3Batch ({ inputs, dkLen }) {
+        assertOutputLength(dkLen);
+        return inputs.map((input)=>hash(input, dkLen));
+    }
+};

package/lib/types.d.ts

@@ -0,0 +1,36 @@
+export type CryptoAlgorithm = 'EdDSA' | 'ES256';
+export type SignItem = {
+    privateKey: Uint8Array;
+    message: Uint8Array;
+};
+export type VerifyItem = {
+    alg: CryptoAlgorithm;
+    signature: Uint8Array;
+    message: Uint8Array;
+    publicKey: Uint8Array;
+};
+export type CryptoProviderSignParams = {
+    alg: 'EdDSA';
+    privateKey: Uint8Array;
+    message: Uint8Array;
+};
+export type CryptoProviderSignBatchParams = {
+    alg: 'EdDSA';
+    items: Array<SignItem>;
+};
+export type CryptoProviderBlake3Params = {
+    input: Uint8Array;
+    dkLen: number;
+};
+export type CryptoProviderBlake3BatchParams = {
+    inputs: Array<Uint8Array>;
+    dkLen: number;
+};
+export type CryptoProvider = {
+    sign(params: CryptoProviderSignParams): Promise<Uint8Array>;
+    signBatch(params: CryptoProviderSignBatchParams): Promise<Array<Uint8Array>>;
+    verify(params: VerifyItem): Promise<boolean>;
+    verifyBatch(items: Array<VerifyItem>): Promise<Array<boolean>>;
+    blake3(params: CryptoProviderBlake3Params): Promise<Uint8Array>;
+    blake3Batch(params: CryptoProviderBlake3BatchParams): Promise<Array<Uint8Array>>;
+};

package/lib/types.js

@@ -0,0 +1 @@
+export { };

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "@kokuin/crypto",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.7.1",
+  "description": "Strict asynchronous crypto providers",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TairuFramework/kokuin",
+    "directory": "packages/crypto"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/*",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@noble/curves": "^2.4.0",
+    "@noble/hashes": "^2.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "build:clean": "del-cli lib",
+    "build:js": "del-cli 'lib/**/*.js' && swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
+    "build:types": "del-cli 'lib/**/*.d.ts' 'lib/**/*.d.ts.map' && tsc --emitDeclarationOnly --skipLibCheck",
+    "test": "pnpm run test:types && pnpm run test:unit",
+    "test:types": "tsc --noEmit --skipLibCheck -p tsconfig.test.json",
+    "test:unit": "vitest run"
+  }
 }