@sebastienrousseau/crypto-server 0.0.2 → 0.0.8

package/dist/routes/v2/password.js

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const route_helpers_1 = require("../../utils/route-helpers");
+exports.default = (app) => {
+    app.post("/v2/password/hash", {
+        config: { rateLimit: { max: 5, timeWindow: "1 minute" } },
+        schema: {
+            tags: ["Password"],
+            summary: "Hash a password with Argon2id",
+            body: {
+                type: "object",
+                required: ["password"],
+                additionalProperties: false,
+                properties: {
+                    password: { type: "string", minLength: 1, maxLength: 1024 },
+                    timeCost: { type: "integer", minimum: 1, maximum: 10 },
+                    memoryCost: { type: "integer", minimum: 1024, maximum: 262144 },
+                    parallelism: { type: "integer", minimum: 1, maximum: 8 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { hashPassword } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/modern/password")));
+            const body = request.body;
+            const result = hashPassword({
+                password: body.password,
+                ...(body.timeCost ? { timeCost: body.timeCost } : {}),
+                ...(body.memoryCost ? { memoryCost: body.memoryCost } : {}),
+                ...(body.parallelism ? { parallelism: body.parallelism } : {}),
+            });
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Password hashing");
+        }
+    });
+    app.post("/v2/password/verify", {
+        config: { rateLimit: { max: 5, timeWindow: "1 minute" } },
+        schema: {
+            tags: ["Password"],
+            summary: "Verify a password against an Argon2id hash",
+            body: {
+                type: "object",
+                required: ["password", "hash", "salt", "params"],
+                additionalProperties: false,
+                properties: {
+                    password: { type: "string", minLength: 1, maxLength: 1024 },
+                    hash: { type: "string", minLength: 1 },
+                    salt: { type: "string", minLength: 1 },
+                    params: {
+                        type: "object",
+                        required: ["t", "m", "p"],
+                        additionalProperties: false,
+                        properties: {
+                            t: { type: "integer", minimum: 1, maximum: 10 },
+                            m: { type: "integer", minimum: 8, maximum: 262144 },
+                            p: { type: "integer", minimum: 1, maximum: 8 },
+                        },
+                    },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { verifyPassword } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/modern/password")));
+            const body = request.body;
+            const result = verifyPassword(body);
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Password verification");
+        }
+    });
+};
+//# sourceMappingURL=password.js.map

package/dist/routes/v2/pq-hash-sign.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (app: FastifyInstance) => void;
+export default _default;
+//# sourceMappingURL=pq-hash-sign.d.ts.map

package/dist/routes/v2/pq-hash-sign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pq-hash-sign.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/pq-hash-sign.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAqB/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBAiHE"}

package/dist/routes/v2/pq-hash-sign.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const route_helpers_1 = require("../../utils/route-helpers");
+const SLH_DSA_VARIANTS = [
+    "sha2-128f",
+    "sha2-128s",
+    "sha2-192f",
+    "sha2-192s",
+    "sha2-256f",
+    "sha2-256s",
+    "shake-128f",
+    "shake-128s",
+    "shake-192f",
+    "shake-192s",
+    "shake-256f",
+    "shake-256s",
+];
+exports.default = (app) => {
+    app.post("/v2/pq/slh-dsa/keygen", {
+        schema: {
+            tags: ["Post-Quantum Hash-Based Signatures"],
+            summary: "Generate SLH-DSA key pair (FIPS 205)",
+            body: {
+                type: "object",
+                required: ["variant"],
+                additionalProperties: false,
+                properties: {
+                    variant: { type: "string", enum: SLH_DSA_VARIANTS },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { slhDsaKeygen } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/modern/pq-hash-sign")));
+            const { variant } = request.body;
+            return reply.send({ data: slhDsaKeygen(variant) });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Key generation");
+        }
+    });
+    app.post("/v2/pq/slh-dsa/sign", {
+        schema: {
+            tags: ["Post-Quantum Hash-Based Signatures"],
+            summary: "Sign with SLH-DSA (FIPS 205)",
+            body: {
+                type: "object",
+                required: ["variant", "secretKey", "message"],
+                additionalProperties: false,
+                properties: {
+                    variant: { type: "string", enum: SLH_DSA_VARIANTS },
+                    secretKey: { type: "string", minLength: 1 },
+                    message: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { slhDsaSign } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/modern/pq-hash-sign")));
+            const body = request.body;
+            return reply.send({
+                data: slhDsaSign(body.variant, body.secretKey, body.message),
+            });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Signing");
+        }
+    });
+    app.post("/v2/pq/slh-dsa/verify", {
+        schema: {
+            tags: ["Post-Quantum Hash-Based Signatures"],
+            summary: "Verify with SLH-DSA (FIPS 205)",
+            body: {
+                type: "object",
+                required: ["variant", "publicKey", "message", "signature"],
+                additionalProperties: false,
+                properties: {
+                    variant: { type: "string", enum: SLH_DSA_VARIANTS },
+                    publicKey: { type: "string", minLength: 1 },
+                    message: { type: "string", minLength: 1 },
+                    signature: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { slhDsaVerify } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/modern/pq-hash-sign")));
+            const body = request.body;
+            return reply.send({
+                data: slhDsaVerify(body.variant, body.publicKey, body.message, body.signature),
+            });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Verification");
+        }
+    });
+};
+//# sourceMappingURL=pq-hash-sign.js.map

package/dist/routes/v2/pq-sign.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (app: FastifyInstance) => void;
+export default _default;
+//# sourceMappingURL=pq-sign.d.ts.map

package/dist/routes/v2/pq-sign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pq-sign.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/pq-sign.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAI/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBA6GE"}

package/dist/routes/v2/pq-sign.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const route_helpers_1 = require("../../utils/route-helpers");
+exports.default = (app) => {
+    app.post("/v2/pq/dsa/keygen", {
+        schema: {
+            tags: ["Post-Quantum Signatures"],
+            summary: "Generate ML-DSA key pair (FIPS 204)",
+            body: {
+                type: "object",
+                required: ["level"],
+                additionalProperties: false,
+                properties: {
+                    level: { type: "number", enum: [44, 65, 87] },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { mlDsaKeygen } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/modern/pq-sign")));
+            const { level } = request.body;
+            return reply.send({ data: mlDsaKeygen(level) });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Key generation");
+        }
+    });
+    app.post("/v2/pq/dsa/sign", {
+        schema: {
+            tags: ["Post-Quantum Signatures"],
+            summary: "Sign with ML-DSA (FIPS 204)",
+            body: {
+                type: "object",
+                required: ["level", "secretKey", "message"],
+                additionalProperties: false,
+                properties: {
+                    level: { type: "number", enum: [44, 65, 87] },
+                    secretKey: { type: "string", minLength: 1 },
+                    message: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { mlDsaSign } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/modern/pq-sign")));
+            const body = request.body;
+            return reply.send({
+                data: mlDsaSign(body.level, body.secretKey, body.message),
+            });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Signing");
+        }
+    });
+    app.post("/v2/pq/dsa/verify", {
+        schema: {
+            tags: ["Post-Quantum Signatures"],
+            summary: "Verify with ML-DSA (FIPS 204)",
+            body: {
+                type: "object",
+                required: ["level", "publicKey", "message", "signature"],
+                additionalProperties: false,
+                properties: {
+                    level: { type: "number", enum: [44, 65, 87] },
+                    publicKey: { type: "string", minLength: 1 },
+                    message: { type: "string", minLength: 1 },
+                    signature: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { mlDsaVerify } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/modern/pq-sign")));
+            const body = request.body;
+            return reply.send({
+                data: mlDsaVerify(body.level, body.publicKey, body.message, body.signature),
+            });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Verification");
+        }
+    });
+};
+//# sourceMappingURL=pq-sign.js.map

package/dist/routes/v2/pq.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (app: FastifyInstance) => void;
+export default _default;
+//# sourceMappingURL=pq.d.ts.map

package/dist/routes/v2/pq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pq.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/pq.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAY/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBA4ME"}

package/dist/routes/v2/pq.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modern_1 = require("@sebastienrousseau/crypto-lib/dist/modern");
+const route_helpers_1 = require("../../utils/route-helpers");
+exports.default = (app) => {
+    app.post("/v2/pq/keygen", {
+        schema: {
+            tags: ["Post-Quantum"],
+            summary: "Generate ML-KEM-768 key pair",
+            description: "Generate a NIST FIPS 203 ML-KEM-768 key pair for quantum-resistant key encapsulation.",
+            body: { type: "object", additionalProperties: false, properties: {} },
+        },
+    }, async (request, reply) => {
+        try {
+            const keyPair = (0, modern_1.mlKemGenerateKeyPair)();
+            return reply.send({ data: keyPair });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Key generation");
+        }
+    });
+    app.post("/v2/pq/encapsulate", {
+        schema: {
+            tags: ["Post-Quantum"],
+            summary: "ML-KEM encapsulate",
+            description: "Encapsulate a shared secret using an ML-KEM-768 public key.",
+            body: {
+                type: "object",
+                required: ["publicKey"],
+                additionalProperties: false,
+                properties: {
+                    publicKey: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { publicKey } = request.body;
+            const result = (0, modern_1.mlKemEncapsulate)(publicKey);
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Encapsulation");
+        }
+    });
+    app.post("/v2/pq/decapsulate", {
+        schema: {
+            tags: ["Post-Quantum"],
+            summary: "ML-KEM decapsulate",
+            description: "Decapsulate and recover the shared secret using the ML-KEM secret key.",
+            body: {
+                type: "object",
+                required: ["secretKey", "ciphertext"],
+                additionalProperties: false,
+                properties: {
+                    secretKey: { type: "string", minLength: 1 },
+                    ciphertext: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { secretKey, ciphertext } = request.body;
+            const result = (0, modern_1.mlKemDecapsulate)(secretKey, ciphertext);
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Decapsulation");
+        }
+    });
+    app.post("/v2/pq/hybrid/keygen", {
+        schema: {
+            tags: ["Post-Quantum"],
+            summary: "Generate hybrid X25519 + ML-KEM-768 key pair",
+            description: "Generates both classical (X25519) and post-quantum (ML-KEM-768) key pairs for hybrid key exchange.",
+            body: { type: "object", additionalProperties: false, properties: {} },
+        },
+    }, async (request, reply) => {
+        try {
+            const keyPair = (0, modern_1.hybridGenerateKeyPair)();
+            return reply.send({ data: keyPair });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Key generation");
+        }
+    });
+    app.post("/v2/pq/hybrid/encapsulate", {
+        schema: {
+            tags: ["Post-Quantum"],
+            summary: "Hybrid encapsulate (X25519 + ML-KEM-768)",
+            description: "Performs X25519 ECDH + ML-KEM encapsulation, derives a combined shared secret via HKDF-SHA256.",
+            body: {
+                type: "object",
+                required: ["x25519PublicKey", "mlKemPublicKey"],
+                additionalProperties: false,
+                properties: {
+                    x25519PublicKey: { type: "string", minLength: 64, maxLength: 64 },
+                    mlKemPublicKey: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { x25519PublicKey, mlKemPublicKey } = request.body;
+            const result = (0, modern_1.hybridEncapsulate)(x25519PublicKey, mlKemPublicKey);
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Hybrid encapsulation");
+        }
+    });
+    app.post("/v2/pq/hybrid/decapsulate", {
+        schema: {
+            tags: ["Post-Quantum"],
+            summary: "Hybrid decapsulate (X25519 + ML-KEM-768)",
+            description: "Recovers the combined shared secret using private keys and sender's ephemeral data.",
+            body: {
+                type: "object",
+                required: [
+                    "x25519PrivateKey",
+                    "mlKemSecretKey",
+                    "x25519EphemeralPublic",
+                    "mlKemCiphertext",
+                ],
+                additionalProperties: false,
+                properties: {
+                    x25519PrivateKey: { type: "string", minLength: 64, maxLength: 64 },
+                    mlKemSecretKey: { type: "string", minLength: 1 },
+                    x25519EphemeralPublic: {
+                        type: "string",
+                        minLength: 64,
+                        maxLength: 64,
+                    },
+                    mlKemCiphertext: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const body = request.body;
+            const result = (0, modern_1.hybridDecapsulate)(body.x25519PrivateKey, body.mlKemSecretKey, body.x25519EphemeralPublic, body.mlKemCiphertext);
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Hybrid decapsulation");
+        }
+    });
+};
+//# sourceMappingURL=pq.js.map

package/dist/routes/v2/sealedbox.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (app: FastifyInstance) => void;
+export default _default;
+//# sourceMappingURL=sealedbox.d.ts.map

package/dist/routes/v2/sealedbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sealedbox.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/sealedbox.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAI/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBA6IE"}