@reallyme/codec 0.1.22 → 0.2.1

package/dist/pem.d.ts

@@ -1,4 +1,3 @@
-import type { ReallyMeCodecProtoResult } from "./readOutput.js";
 export type ReallyMePemLabel = "PRIVATE KEY" | "EC PRIVATE KEY" | "PUBLIC KEY";
 export type ReallyMePemLineEnding = "lf" | "crlf";
 export type ReallyMePemDecodePolicy = Readonly<{
@@ -16,6 +15,4 @@ export type ReallyMePemDocument = Readonly<{
     der: Uint8Array;
 }>;
 export declare const decodePem: (input: Uint8Array, policy?: ReallyMePemDecodePolicy) => ReallyMePemDocument;
-export declare const decodePemProto: (input: Uint8Array, policy?: ReallyMePemDecodePolicy) => Uint8Array;
-export declare const decodePemProtoResult: (input: Uint8Array, policy?: ReallyMePemDecodePolicy) => ReallyMeCodecProtoResult;
 export declare const encodePem: (label: ReallyMePemLabel, der: Uint8Array, options?: ReallyMePemEncodeOptions) => Uint8Array;

package/dist/pem.js

@@ -2,12 +2,10 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 import { create } from "@bufbuild/protobuf";
-import { stringifyBoundaryJson } from "./boundary.js";
 import { ReallyMeCodecError } from "./errors.js";
-import { CodecOperationRequestSchema, CodecPemDecodeOptionsSchema, CodecPemDecodeRequestSchema, CodecPemLabel, } from "./proto/generated/reallyme/codec/v1/codec_pb.js";
-import { processGeneratedProtoRequest, protoPayloadOrThrow, } from "./protoProcess.js";
-import { ensureBytesInput, readBytesOutput, readBytesProperty, readObjectOutput, readStringProperty, } from "./readOutput.js";
-import { requireReallyMeCodecWasmProvider } from "./wasmProvider.js";
+import { CodecOperationRequestSchema, CodecPemDecodeOptionsSchema, CodecPemDecodeRequestSchema, CodecPemEncodeOptionsSchema, CodecPemEncodeRequestSchema, CodecPemLabel, CodecPemLineEnding, } from "./proto/generated/reallyme/codec/v1/codec_pb.js";
+import { clearGeneratedOperationResult, processGeneratedOperationRequest, } from "./operationContract.js";
+import { ensureBytesInput, snapshotBoundedBytesInput, } from "./readOutput.js";
 const validLabels = new Set([
     "PRIVATE KEY",
     "EC PRIVATE KEY",
@@ -50,6 +48,11 @@ const readPemLabel = (label) => {
             throw new ReallyMeCodecError("provider-failure");
     }
 };
+const requireNoProviderUnknownFields = (message) => {
+    if (message.$unknown !== undefined && message.$unknown.length !== 0) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+};
 const requirePositiveInteger = (value) => {
     if (value !== undefined &&
         (!Number.isSafeInteger(value) || value <= 0)) {
@@ -177,28 +180,40 @@ const protoPemLabel = (label) => {
             return CodecPemLabel.PUBLIC_KEY;
     }
 };
-const encodeOptions = (options) => {
-    if (options === undefined) {
-        return "";
+const readPemDocument = (result) => {
+    try {
+        requireNoProviderUnknownFields(result);
+        return {
+            label: readPemLabel(result.label),
+            der: result.der.slice(),
+        };
+    }
+    catch (error) {
+        if (error instanceof ReallyMeCodecError) {
+            throw error;
+        }
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    finally {
+        result.der.fill(0);
     }
-    return stringifyBoundaryJson(options);
-};
-const readPemDocument = (value) => {
-    const object = readObjectOutput(value);
-    return {
-        label: readPemLabel(readStringProperty(object, "label")),
-        der: readBytesProperty(object, "der"),
-    };
 };
 export const decodePem = (input, policy) => {
     ensureBytesInput(input);
-    const snapshot = snapshotDecodePolicy(policy);
-    return readPemDocument(requireReallyMeCodecWasmProvider().pemDecode(input, encodeOptions(snapshot)));
-};
-export const decodePemProto = (input, policy) => {
-    return protoPayloadOrThrow(decodePemProtoResult(input, policy));
+    const request = pemDecodeRequest(input, policy);
+    try {
+        const operationResult = processGeneratedOperationRequest(request);
+        if (operationResult.result.case !== "pemDecode") {
+            clearGeneratedOperationResult(operationResult);
+            throw new ReallyMeCodecError("provider-failure");
+        }
+        return readPemDocument(operationResult.result.value);
+    }
+    finally {
+        clearPemDecodeRequest(request);
+    }
 };
-export const decodePemProtoResult = (input, policy) => {
+const pemDecodeRequest = (input, policy) => {
     ensureBytesInput(input);
     const snapshot = snapshotDecodePolicy(policy);
     const allowedLabels = [];
@@ -207,29 +222,91 @@ export const decodePemProtoResult = (input, policy) => {
             allowedLabels.push(protoPemLabel(requirePemLabel(label)));
         }
     }
-    const request = create(CodecPemDecodeRequestSchema, { pem: input });
+    const options = snapshot === undefined
+        ? undefined
+        : create(CodecPemDecodeOptionsSchema, {
+            allowedLabels,
+            maxInputLen: requireProtoUint32(snapshot.maxInputLen),
+            maxDerLen: requireProtoUint32(snapshot.maxDerLen),
+        });
+    const pemSnapshot = snapshotBoundedBytesInput(input);
     try {
-        if (snapshot !== undefined) {
-            request.options = create(CodecPemDecodeOptionsSchema, {
-                allowedLabels,
-                maxInputLen: requireProtoUint32(snapshot.maxInputLen),
-                maxDerLen: requireProtoUint32(snapshot.maxDerLen),
-            });
+        const request = create(CodecPemDecodeRequestSchema, { pem: pemSnapshot });
+        if (options !== undefined) {
+            request.options = options;
         }
-        return processGeneratedProtoRequest(create(CodecOperationRequestSchema, {
+        return create(CodecOperationRequestSchema, {
             operation: {
                 case: "pemDecode",
                 value: request,
             },
-        }));
+        });
     }
-    finally {
-        request.pem = new Uint8Array(0);
+    catch (error) {
+        pemSnapshot.fill(0);
+        throw error;
+    }
+};
+const clearPemDecodeRequest = (request) => {
+    if (request.operation.case === "pemDecode") {
+        request.operation.value.pem.fill(0);
+        request.operation.value.pem = new Uint8Array(0);
     }
 };
 export const encodePem = (label, der, options) => {
     requirePemLabel(label);
     ensureBytesInput(der);
     const snapshot = snapshotEncodeOptions(options);
-    return readBytesOutput(requireReallyMeCodecWasmProvider().pemEncode(label, der, encodeOptions(snapshot)));
+    const protoOptions = snapshot === undefined
+        ? undefined
+        : create(CodecPemEncodeOptionsSchema, {
+            maxDerLen: requireProtoUint32(snapshot.maxDerLen),
+            lineWidth: requireProtoUint32(snapshot.lineWidth),
+            lineEnding: snapshot.lineEnding === "crlf"
+                ? CodecPemLineEnding.CRLF
+                : snapshot.lineEnding === "lf"
+                    ? CodecPemLineEnding.LF
+                    : CodecPemLineEnding.UNSPECIFIED,
+        });
+    const derSnapshot = snapshotBoundedBytesInput(der);
+    let request;
+    let operationRequest;
+    try {
+        request = create(CodecPemEncodeRequestSchema, {
+            label: protoPemLabel(label),
+            der: derSnapshot,
+        });
+        if (protoOptions !== undefined) {
+            request.options = protoOptions;
+        }
+        operationRequest = create(CodecOperationRequestSchema, {
+            operation: {
+                case: "pemEncode",
+                value: request,
+            },
+        });
+    }
+    catch (error) {
+        derSnapshot.fill(0);
+        throw error;
+    }
+    try {
+        const operationResult = processGeneratedOperationRequest(operationRequest);
+        if (operationResult.result.case !== "pemEncode") {
+            clearGeneratedOperationResult(operationResult);
+            throw new ReallyMeCodecError("provider-failure");
+        }
+        const result = operationResult.result.value;
+        try {
+            requireNoProviderUnknownFields(result);
+            return result.pem.slice();
+        }
+        finally {
+            result.pem.fill(0);
+        }
+    }
+    finally {
+        request.der.fill(0);
+        request.der = new Uint8Array(0);
+    }
 };