@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 90 lines 3.12 KB
Raw
1 import * as ACME from "@alchemy.run/acme";
2 import { describe, expect } from "@alchemy.run/test";
3 import * as Test from "@alchemy.run/test/Alchemy";
4 import * as Effect from "effect/Effect";
5 import * as ChildProcess from "effect/process/ChildProcess";
6 import * as Redacted from "effect/Redacted";
7 import * as Stream from "effect/Stream";
8 import { ROOT_CERTIFICATE } from "./fixtures/root-certificate.ts";
9
10 const { test } = Test.make({ providers: ACME.providers() });
11
12 /** `openssl req -text -verify` over a DER request. */
13 const inspectCsr = (der: Uint8Array) =>
14 Effect.gen(function* () {
15 const process = yield* ChildProcess.make(
16 "openssl",
17 ["req", "-inform", "DER", "-noout", "-text", "-verify"],
18 {
19 stdin: Stream.make(der),
20 stdout: "pipe",
21 stderr: "pipe",
22 },
23 );
24 const [stdout, stderr, code] = yield* Effect.all(
25 [
26 process.stdout.pipe(Stream.decodeText(), Stream.runCollect),
27 process.stderr.pipe(Stream.decodeText(), Stream.runCollect),
28 process.exitCode,
29 ],
30 { concurrency: "unbounded" },
31 );
32 expect(code).toBe(0);
33 return [...stdout, ...stderr].join("");
34 });
35
36 describe("ACME PKI", { tags: ["provider:acme", "local"] }, () => {
37 for (const algorithm of ["ES256", "RS256"] as const) {
38 test(
39 `${algorithm} CSR verifies and carries every identifier as a SAN`,
40 Effect.gen(function* () {
41 const key = yield* ACME.generateKey(algorithm);
42 expect(Redacted.value(key.privateKeyPem)).toContain("BEGIN PRIVATE KEY");
43 const csr = yield* ACME.createCsr({
44 key,
45 identifiers: ["*.example.test", "example.test"],
46 });
47 const text = yield* inspectCsr(csr);
48 expect(text).toMatch(/verify OK/i);
49 expect(text).toContain("CN=*.example.test");
50 expect(text).toContain("DNS:*.example.test");
51 expect(text).toContain("DNS:example.test");
52 expect(text).toContain(
53 algorithm === "ES256" ? "ecdsa-with-SHA256" : "sha256WithRSAEncryption",
54 );
55 }),
56 );
57 }
58
59 test(
60 "parses a certificate's serial, validity, issuer and SANs",
61 Effect.gen(function* () {
62 const parsed = yield* ACME.parseCertificate(ROOT_CERTIFICATE);
63 expect(parsed.issuer).toContain("CN=minica root ca");
64 expect(parsed.subject).toBe(parsed.issuer);
65 expect(parsed.serial).toMatch(/^[0-9a-f]+$/);
66 expect(parsed.notBefore.getUTCFullYear()).toBe(2025);
67 expect(parsed.notAfter.getUTCFullYear()).toBe(2125);
68 expect(parsed.dnsNames).toEqual([]);
69 }),
70 { tags: ["unit"] },
71 );
72
73 test(
74 "round-trips a PKCS#8 key through import and JWK export",
75 Effect.gen(function* () {
76 const key = yield* ACME.generateKey("ES256");
77 const imported = yield* ACME.importPrivateKey(key.privateKeyPem);
78 expect(imported.algorithm).toBe("ES256");
79 const jwk = JSON.parse(Redacted.value(yield* ACME.privateKeyToJwk(key.privateKeyPem))) as {
80 kty: string;
81 crv: string;
82 d?: string;
83 };
84 expect(jwk.kty).toBe("EC");
85 expect(jwk.crv).toBe("P-256");
86 expect(jwk.d).toBeDefined();
87 }),
88 { tags: ["unit"] },
89 );
90 });