@sebastienrousseau/crypto-server 0.0.1 → 0.0.8

package/dist/lib/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/lib/auth.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAO7E,eAAO,MAAM,MAAM,2IAST,CAAC;AAGX,MAAM,MAAM,KAAK,GAAG,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAG5C,MAAM,WAAW,WAAW;IAE1B,GAAG,EAAE,MAAM,CAAC;IAEZ,MAAM,EAAE,KAAK,EAAE,CAAC;IAEhB,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAKD,wBAAsB,YAAY,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAYtE;AAUD,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAqD7B;AAKD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,KAAK,GAAG,OAAO,CAIvE;AAKD,wBAAgB,YAAY,CAC1B,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,YAAY,GAClB,OAAO,CAST"}

package/dist/lib/auth.js

@@ -0,0 +1,120 @@
+"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 });
+exports.SCOPES = void 0;
+exports.registerAuth = registerAuth;
+exports.authenticate = authenticate;
+exports.hasScope = hasScope;
+exports.requireScope = requireScope;
+const crypto_1 = require("crypto");
+const validation_1 = require("../utils/validation");
+exports.SCOPES = [
+    "crypto:encrypt",
+    "crypto:decrypt",
+    "crypto:sign",
+    "crypto:verify",
+    "crypto:hash",
+    "crypto:kdf",
+    "crypto:keys",
+    "crypto:admin",
+];
+async function registerAuth(app) {
+    const jwtSecret = process.env["JWT_SECRET"];
+    if (jwtSecret) {
+        const fastifyJwt = await Promise.resolve().then(() => __importStar(require("@fastify/jwt")));
+        await app.register(fastifyJwt.default, {
+            secret: jwtSecret,
+            verify: { algorithms: ["HS256"] },
+        });
+    }
+}
+async function authenticate(request, reply) {
+    const jwtSecret = process.env["JWT_SECRET"];
+    const apiKey = process.env["CRYPTO_API_KEY"];
+    if (!jwtSecret && !apiKey) {
+        if ((0, validation_1.anonymousAllowed)()) {
+            return { sub: "anonymous", scopes: ["crypto:admin"] };
+        }
+        reply
+            .status(401)
+            .send({ error: "Unauthorized: authentication is not configured" });
+        return null;
+    }
+    const authHeader = request.headers["authorization"];
+    if (authHeader?.startsWith("Bearer ") && jwtSecret) {
+        try {
+            const decoded = await request.jwtVerify();
+            return decoded;
+        }
+        catch {
+            reply.status(401).send({ error: "Invalid or expired JWT token" });
+            return null;
+        }
+    }
+    if (apiKey) {
+        const providedKey = request.headers["x-api-key"];
+        if (!providedKey || typeof providedKey !== "string") {
+            reply
+                .status(401)
+                .send({ error: "Unauthorized: Missing API key or Bearer token" });
+            return null;
+        }
+        const a = Buffer.from(providedKey);
+        const b = Buffer.from(apiKey);
+        if (a.length !== b.length || !(0, crypto_1.timingSafeEqual)(a, b)) {
+            reply.status(401).send({ error: "Unauthorized: Invalid API key" });
+            return null;
+        }
+        return { sub: "api-key", scopes: ["crypto:admin"] };
+    }
+    reply
+        .status(401)
+        .send({ error: "Unauthorized: No valid credentials provided" });
+    return null;
+}
+function hasScope(payload, required) {
+    return (payload.scopes.includes("crypto:admin") || payload.scopes.includes(required));
+}
+function requireScope(payload, scope, reply) {
+    if (!hasScope(payload, scope)) {
+        reply.status(403).send({
+            error: "Forbidden",
+            message: `Missing required scope: ${scope}`,
+        });
+        return false;
+    }
+    return true;
+}
+//# sourceMappingURL=auth.js.map

package/dist/lib/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/lib/logger.ts"],"names":[],"mappings":"AAIA,QAAA,MAAM,MAAM,0BAmBV,CAAC;AAEH,eAAe,MAAM,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/lib/logger.ts"],"names":[],"mappings":"AAsCA,QAAA,MAAM,MAAM,0BAQV,CAAC;AAGH,eAAe,MAAM,CAAC"}

package/dist/lib/logger.js

@@ -3,14 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const winston_1 = require("winston");
 const uuid_1 = require("uuid");
 const correlationId = (0, uuid_1.v4)();
+const isProduction = process.env["NODE_ENV"] === "production";
+const structuredFormat = winston_1.format.combine(winston_1.format.timestamp({ format: "YYYY-MM-DDTHH:mm:ss.SSSZ" }), winston_1.format.errors({ stack: true }), winston_1.format.json());
+const devFormat = winston_1.format.combine(winston_1.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), winston_1.format.colorize(), winston_1.format.printf((info) => `${correlationId} | ${info.timestamp} | ${info.level}: ${info.message}`));
 const logger = (0, winston_1.createLogger)({
-    format: winston_1.format.combine(winston_1.format.timestamp({
-        format: "YYYY-MM-DD HH:mm:ss",
-    }), winston_1.format.json()),
+    defaultMeta: { service: "crypto-server", correlationId },
+    format: isProduction ? structuredFormat : devFormat,
     transports: [
         new winston_1.transports.Console({
-            level: "info",
-            format: winston_1.format.combine(winston_1.format.colorize(), winston_1.format.printf((info) => `${correlationId} | ${info.timestamp} | ${info.level}: ${info.message}`)),
+            level: process.env["LOG_LEVEL"] ?? "info",
         }),
     ],
 });

package/dist/lib/telemetry.d.ts

@@ -0,0 +1,4 @@
+export declare function initTelemetry(): void;
+export declare function shutdownTelemetry(): Promise<void>;
+export declare function traceCryptoOperation<T>(operationName: string, attributes: Record<string, string | number>, fn: () => Promise<T> | T): Promise<T>;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/lib/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../../src/lib/telemetry.ts"],"names":[],"mappings":"AA2CA,wBAAgB,aAAa,IAAI,IAAI,CA2BpC;AAKD,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAIvD;AA8BD,wBAAsB,oBAAoB,CAAC,CAAC,EAC1C,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAC3C,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GACvB,OAAO,CAAC,CAAC,CAAC,CAmCZ"}

package/dist/lib/telemetry.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTelemetry = initTelemetry;
+exports.shutdownTelemetry = shutdownTelemetry;
+exports.traceCryptoOperation = traceCryptoOperation;
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const instrumentation_http_1 = require("@opentelemetry/instrumentation-http");
+const instrumentation_fastify_1 = require("@opentelemetry/instrumentation-fastify");
+const resources_1 = require("@opentelemetry/resources");
+const version_1 = require("./version");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const api_1 = require("@opentelemetry/api");
+const SERVICE_NAME = "crypto-server";
+const SERVICE_VERSION = version_1.PACKAGE_VERSION;
+let sdk;
+function initTelemetry() {
+    const endpoint = process.env["OTEL_EXPORTER_OTLP_ENDPOINT"];
+    if (!endpoint && process.env["NODE_ENV"] !== "production") {
+        return;
+    }
+    const resource = (0, resources_1.resourceFromAttributes)({
+        [semantic_conventions_1.ATTR_SERVICE_NAME]: SERVICE_NAME,
+        [semantic_conventions_1.ATTR_SERVICE_VERSION]: SERVICE_VERSION,
+    });
+    const traceExporterOpts = endpoint ? { url: `${endpoint}/v1/traces` } : {};
+    const metricExporterOpts = endpoint ? { url: `${endpoint}/v1/metrics` } : {};
+    sdk = new sdk_node_1.NodeSDK({
+        resource,
+        traceExporter: new exporter_trace_otlp_http_1.OTLPTraceExporter(traceExporterOpts),
+        metricReader: new sdk_metrics_1.PeriodicExportingMetricReader({
+            exporter: new exporter_metrics_otlp_http_1.OTLPMetricExporter(metricExporterOpts),
+            exportIntervalMillis: 30000,
+        }),
+        instrumentations: [new instrumentation_http_1.HttpInstrumentation(), new instrumentation_fastify_1.FastifyInstrumentation()],
+    });
+    sdk.start();
+}
+async function shutdownTelemetry() {
+    if (sdk) {
+        await sdk.shutdown();
+    }
+}
+const tracer = api_1.trace.getTracer(SERVICE_NAME, SERVICE_VERSION);
+const meter = api_1.metrics.getMeter(SERVICE_NAME, SERVICE_VERSION);
+const operationCounter = meter.createCounter("crypto.operations.total", {
+    description: "Total number of cryptographic operations performed",
+});
+const operationDuration = meter.createHistogram("crypto.operations.duration_ms", {
+    description: "Duration of cryptographic operations in milliseconds",
+    unit: "ms",
+});
+async function traceCryptoOperation(operationName, attributes, fn) {
+    return tracer.startActiveSpan(`crypto.${operationName}`, async (span) => {
+        const start = performance.now();
+        span.setAttributes(attributes);
+        try {
+            const result = await fn();
+            span.setStatus({ code: api_1.SpanStatusCode.OK });
+            operationCounter.add(1, {
+                operation: operationName,
+                status: "success",
+                ...attributes,
+            });
+            return result;
+        }
+        catch (error) {
+            span.setStatus({
+                code: api_1.SpanStatusCode.ERROR,
+                message: error.message,
+            });
+            span.recordException(error);
+            operationCounter.add(1, {
+                operation: operationName,
+                status: "error",
+                ...attributes,
+            });
+            throw error;
+        }
+        finally {
+            const duration = performance.now() - start;
+            operationDuration.record(duration, {
+                operation: operationName,
+                ...attributes,
+            });
+            span.end();
+        }
+    });
+}
+//# sourceMappingURL=telemetry.js.map

package/dist/lib/version.d.ts

@@ -0,0 +1,2 @@
+export declare const PACKAGE_VERSION: string;
+//# sourceMappingURL=version.d.ts.map

package/dist/lib/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/lib/version.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,eAAe,QAInB,CAAC"}

package/dist/lib/version.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACKAGE_VERSION = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+exports.PACKAGE_VERSION = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, "..", "..", "package.json"), "utf8")).version;
+//# sourceMappingURL=version.js.map

package/dist/routes/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/routes/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;8BAOd,QAAQ,eAAe;AAA5C,wBAKE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/routes/index.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;yBAWnB,KAAK,OAAO,CAAC,eAAe,KAAG,IAAI;AAAnD,wBAuBE"}

package/dist/routes/index.js

@@ -3,14 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const generate_1 = __importDefault(require("./v1/generate"));
-const encrypt_1 = __importDefault(require("./v1/encrypt"));
 const decrypt_1 = __importDefault(require("./v1/decrypt"));
+const encrypt_1 = __importDefault(require("./v1/encrypt"));
+const generate_1 = __importDefault(require("./v1/generate"));
+const index_1 = __importDefault(require("./v1/index"));
 const revoke_1 = __importDefault(require("./v1/revoke"));
+const verify_1 = __importDefault(require("./v1/verify"));
+const v2_1 = __importDefault(require("./v2"));
+const probes_1 = __importDefault(require("./probes"));
 exports.default = (app) => {
-    (0, generate_1.default)(app);
-    (0, encrypt_1.default)(app);
+    app.addHook("onSend", async (request, reply) => {
+        if (request.url.startsWith("/v1/")) {
+            reply.header("Deprecation", "true");
+            reply.header("Sunset", "2027-01-01T00:00:00Z");
+            reply.header("Link", '</v2>; rel="successor-version"');
+        }
+    });
     (0, decrypt_1.default)(app);
+    (0, encrypt_1.default)(app);
+    (0, generate_1.default)(app);
+    (0, index_1.default)(app);
     (0, revoke_1.default)(app);
+    (0, verify_1.default)(app);
+    (0, v2_1.default)(app);
+    (0, probes_1.default)(app);
 };
 //# sourceMappingURL=index.js.map

package/dist/routes/probes.d.ts

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

package/dist/routes/probes.d.ts.map

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

package/dist/routes/probes.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const startTime = Date.now();
+exports.default = (app) => {
+    app.get("/live", { schema: { hide: true } }, async () => {
+        return {
+            status: "alive",
+            uptime: Math.floor((Date.now() - startTime) / 1000),
+        };
+    });
+    app.get("/ready", { schema: { hide: true } }, async (_request, reply) => {
+        const checks = {
+            configLoaded: true,
+            serverListening: true,
+        };
+        const allReady = Object.values(checks).every(Boolean);
+        const status = allReady ? 200 : 503;
+        return reply.status(status).send({
+            status: allReady ? "ready" : "not_ready",
+            checks,
+        });
+    });
+    app.get("/metrics", { schema: { hide: true } }, async (_request, reply) => {
+        const uptime = Math.floor((Date.now() - startTime) / 1000);
+        const memUsage = process.memoryUsage();
+        const lines = [
+            "# HELP process_uptime_seconds Process uptime in seconds",
+            "# TYPE process_uptime_seconds gauge",
+            `process_uptime_seconds ${uptime}`,
+            "",
+            "# HELP process_resident_memory_bytes Resident memory size in bytes",
+            "# TYPE process_resident_memory_bytes gauge",
+            `process_resident_memory_bytes ${memUsage.rss}`,
+            "",
+            "# HELP process_heap_used_bytes Heap used in bytes",
+            "# TYPE process_heap_used_bytes gauge",
+            `process_heap_used_bytes ${memUsage.heapUsed}`,
+            "",
+            "# HELP process_heap_total_bytes Heap total in bytes",
+            "# TYPE process_heap_total_bytes gauge",
+            `process_heap_total_bytes ${memUsage.heapTotal}`,
+            "",
+            "# HELP nodejs_version_info Node.js version",
+            "# TYPE nodejs_version_info gauge",
+            `nodejs_version_info{version="${process.version}"} 1`,
+            "",
+        ];
+        reply.header("content-type", "text/plain; version=0.0.4; charset=utf-8");
+        return reply.send(lines.join("\n"));
+    });
+};
+//# sourceMappingURL=probes.js.map

package/dist/routes/v1/decrypt.d.ts

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

package/dist/routes/v1/decrypt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decrypt.d.ts","sourceRoot":"","sources":["../../../src/routes/v1/decrypt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;8BAId,QAAQ,eAAe;AAA5C,wBAUE"}
+{"version":3,"file":"decrypt.d.ts","sourceRoot":"","sources":["../../../src/routes/v1/decrypt.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAkC/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBAgCE"}

package/dist/routes/v1/decrypt.js

@@ -4,13 +4,56 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const decrypt_1 = __importDefault(require("@sebastienrousseau/crypto-lib/dist/lib/decrypt"));
+const validation_1 = require("../../utils/validation");
+const route_helpers_1 = require("../../utils/route-helpers");
+const decryptSchema = {
+    tags: ["Encryption"],
+    summary: "Decrypt a message",
+    description: "Decrypts a PGP-encrypted message using private/public key pair and passphrase.",
+    response: {
+        200: { type: "object", properties: { data: { type: "string" } } },
+        400: {
+            type: "object",
+            properties: { error: { type: "string" }, details: { type: "array" } },
+        },
+        401: { type: "object", properties: { error: { type: "string" } } },
+    },
+    body: {
+        type: "object",
+        required: ["passphrase", "message", "publicKey", "privateKey"],
+        additionalProperties: false,
+        properties: {
+            passphrase: { type: "string", minLength: 1, maxLength: 1024 },
+            message: { type: "string", minLength: 1, maxLength: 1024 * 1024 },
+            publicKey: { type: "string", minLength: 1, maxLength: 64 * 1024 },
+            privateKey: { type: "string", minLength: 1, maxLength: 64 * 1024 },
+        },
+    },
+};
 exports.default = (app) => {
-    app.get("/v1/decrypt", async (request, reply) => {
-        const encryptedData = await (0, decrypt_1.default)({
-            message: request.headers["message"],
-            passphrase: request.headers["passphrase"],
-        });
-        reply.send({ data: encryptedData });
+    app.post("/v1/decrypt", { schema: decryptSchema }, async (request, reply) => {
+        try {
+            const body = request.body;
+            const v = (0, route_helpers_1.collectValidation)({
+                passphrase: (0, validation_1.validateRequiredString)(body.passphrase, "passphrase"),
+                message: (0, validation_1.validateBase64)(body.message, "message"),
+                publicKey: (0, validation_1.validateBase64)(body.publicKey, "publicKey"),
+                privateKey: (0, validation_1.validateBase64)(body.privateKey, "privateKey"),
+            }, reply);
+            if (!v)
+                return;
+            const decryptedData = await (0, decrypt_1.default)({
+                passphrase: v.passphrase,
+                message: v.message,
+                publicKey: v.publicKey,
+                privateKey: v.privateKey,
+            });
+            return reply.send({ data: decryptedData });
+        }
+        catch (error) {
+            request.log.error(error, "Decryption operation failed");
+            return reply.status(500).send({ error: "Decryption failed" });
+        }
     });
 };
 //# sourceMappingURL=decrypt.js.map

package/dist/routes/v1/encrypt.d.ts

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

package/dist/routes/v1/encrypt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encrypt.d.ts","sourceRoot":"","sources":["../../../src/routes/v1/encrypt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;8BAId,QAAQ,eAAe;AAA5C,wBAUE"}
+{"version":3,"file":"encrypt.d.ts","sourceRoot":"","sources":["../../../src/routes/v1/encrypt.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAkC/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBA+BE"}

package/dist/routes/v1/encrypt.js

@@ -4,13 +4,55 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const encrypt_1 = __importDefault(require("@sebastienrousseau/crypto-lib/dist/lib/encrypt"));
+const validation_1 = require("../../utils/validation");
+const route_helpers_1 = require("../../utils/route-helpers");
+const encryptSchema = {
+    tags: ["Encryption"],
+    summary: "Encrypt a message",
+    description: "Encrypts a plaintext message using the supplied PGP public key and passphrase.",
+    response: {
+        200: { type: "object", properties: { data: { type: "string" } } },
+        400: {
+            type: "object",
+            properties: { error: { type: "string" }, details: { type: "array" } },
+        },
+        401: { type: "object", properties: { error: { type: "string" } } },
+    },
+    body: {
+        type: "object",
+        required: ["passphrase", "message", "publicKey"],
+        additionalProperties: false,
+        properties: {
+            passphrase: { type: "string", minLength: 1, maxLength: 1024 },
+            message: { type: "string", minLength: 1, maxLength: 1024 * 1024 },
+            publicKey: { type: "string", minLength: 1, maxLength: 64 * 1024 },
+            privateKey: { type: "string", minLength: 1, maxLength: 64 * 1024 },
+        },
+    },
+};
 exports.default = (app) => {
-    app.get("/v1/encrypt", async (request, reply) => {
-        const encryptedData = await (0, encrypt_1.default)({
-            message: request.headers["message"],
-            passphrase: request.headers["passphrase"],
-        });
-        reply.send({ data: encryptedData });
+    app.post("/v1/encrypt", { schema: encryptSchema }, async (request, reply) => {
+        try {
+            const body = request.body;
+            const v = (0, route_helpers_1.collectValidation)({
+                passphrase: (0, validation_1.validateRequiredString)(body.passphrase, "passphrase"),
+                message: (0, validation_1.validateRequiredString)(body.message, "message"),
+                publicKey: (0, validation_1.validateBase64)(body.publicKey, "publicKey"),
+            }, reply);
+            if (!v)
+                return;
+            const encryptedData = await (0, encrypt_1.default)({
+                passphrase: v.passphrase,
+                message: v.message,
+                publicKey: v.publicKey,
+                ...(body.privateKey ? { privateKey: body.privateKey } : {}),
+            });
+            return reply.send({ data: encryptedData });
+        }
+        catch (error) {
+            request.log.error(error, "Encryption operation failed");
+            return reply.status(500).send({ error: "Encryption failed" });
+        }
     });
 };
 //# sourceMappingURL=encrypt.js.map

package/dist/routes/v1/generate.d.ts

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

package/dist/routes/v1/generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/routes/v1/generate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;8BAId,QAAQ,eAAe;AAA5C,wBAiBE"}
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/routes/v1/generate.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBA+D/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBAkEE"}

package/dist/routes/v1/generate.js

@@ -4,20 +4,92 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const generate_1 = __importDefault(require("@sebastienrousseau/crypto-lib/dist/lib/generate"));
+const types_1 = require("../../@types/types");
+const validation_1 = require("../../utils/validation");
+const route_helpers_1 = require("../../utils/route-helpers");
+const generateSchema = {
+    tags: ["Key Management"],
+    summary: "Generate a key pair",
+    description: "Generates an OpenPGP key pair (RSA or ECC). The private key is NOT returned for security.",
+    response: {
+        200: {
+            type: "object",
+            properties: {
+                data: {
+                    type: "object",
+                    properties: {
+                        publicKey: { type: "string" },
+                        revocationCertificate: { type: "string" },
+                    },
+                },
+                warning: { type: "string" },
+            },
+        },
+        400: {
+            type: "object",
+            properties: { error: { type: "string" }, details: { type: "array" } },
+        },
+        401: { type: "object", properties: { error: { type: "string" } } },
+    },
+    body: {
+        type: "object",
+        required: ["name", "email", "type", "passphrase", "curve", "format"],
+        additionalProperties: false,
+        properties: {
+            name: { type: "string", minLength: 1, maxLength: 256 },
+            email: { type: "string", minLength: 3, maxLength: 256 },
+            type: { type: "string", enum: [...types_1.KEY_TYPES] },
+            passphrase: { type: "string", minLength: 1, maxLength: 1024 },
+            curve: { type: "string", enum: [...types_1.CURVE_TYPES] },
+            format: { type: "string", enum: [...types_1.FORMAT_TYPES] },
+            rsaBits: { type: "number", minimum: 2048, maximum: 4096 },
+            keyExpirationTime: { type: "number", minimum: 0 },
+        },
+    },
+};
 exports.default = (app) => {
-    app.get("/v1/generate", async (request, reply) => {
-        const generateKeyPair = await (0, generate_1.default)({
-            type: request.headers["type"],
-            bits: Number(request.headers["bits"]),
-            name: request.headers["name"],
-            email: request.headers["email"],
-            passphrase: request.headers["passphrase"],
-            curve: request.headers["curve"],
-            expiration: Number(request.headers["expiration"]),
-            format: request.headers["format"],
-            sign: Boolean(request.headers["sign"]),
-        });
-        reply.send({ data: generateKeyPair });
+    app.post("/v1/generate", { schema: generateSchema }, async (request, reply) => {
+        try {
+            const body = request.body;
+            const v = (0, route_helpers_1.collectValidation)({
+                name: (0, validation_1.validateRequiredString)(body.name, "name"),
+                email: (0, validation_1.validateEmail)(body.email, "email"),
+                type: (0, validation_1.validateEnum)(body.type, "type", types_1.KEY_TYPES),
+                passphrase: (0, validation_1.validateRequiredString)(body.passphrase, "passphrase"),
+                curve: (0, validation_1.validateEnum)(body.curve, "curve", types_1.CURVE_TYPES),
+                format: (0, validation_1.validateEnum)(body.format, "format", types_1.FORMAT_TYPES),
+                rsaBits: (0, validation_1.validateOptionalNumber)(body.rsaBits, 2048, "rsaBits", {
+                    min: 2048,
+                    max: 4096,
+                }),
+                keyExpirationTime: (0, validation_1.validateOptionalNumber)(body.keyExpirationTime, 0, "keyExpirationTime", { min: 0 }),
+            }, reply);
+            if (!v)
+                return;
+            const generated = (await (0, generate_1.default)({
+                date: new Date(),
+                name: v.name,
+                email: v.email,
+                userIDs: [{ name: v.name, email: v.email }],
+                type: v.type,
+                passphrase: v.passphrase,
+                rsaBits: v.rsaBits,
+                curve: v.curve,
+                keyExpirationTime: v.keyExpirationTime,
+                format: v.format,
+            }));
+            return reply.send({
+                data: {
+                    publicKey: generated.publicKey,
+                    revocationCertificate: generated.revocationCertificate,
+                },
+                warning: "Private key not included in response for security. Configure secure key delivery for production use.",
+            });
+        }
+        catch (error) {
+            request.log.error(error, "Key pair generation failed");
+            return reply.status(500).send({ error: "Key pair generation failed" });
+        }
     });
 };
 //# sourceMappingURL=generate.js.map