@intellectual-frontiers/grc 0.0.0-stage → 0.1.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +8 -2
- package/dist/assess.d.ts +247 -0
- package/dist/assess.js +289 -0
- package/dist/attest.d.ts +164 -0
- package/dist/attest.js +213 -0
- package/dist/evidence.d.ts +212 -0
- package/dist/evidence.js +453 -0
- package/dist/grc.d.ts +356 -0
- package/dist/grc.js +487 -0
- package/dist/host/grc.d.ts +159 -0
- package/dist/host/grc.js +358 -0
- package/dist/host/mod.d.ts +14 -0
- package/dist/host/mod.js +15 -0
- package/dist/host/sign.d.ts +141 -0
- package/dist/host/sign.js +282 -0
- package/dist/mod.d.ts +19 -0
- package/dist/mod.js +20 -0
- package/dist/ocsf-types.auto.d.ts +4374 -0
- package/dist/ocsf-types.auto.js +24 -0
- package/dist/ocsf.d.ts +160 -0
- package/dist/ocsf.js +257 -0
- package/dist/oscal.d.ts +356 -0
- package/dist/oscal.js +513 -0
- package/package.json +87 -4
- package/src/assess.ts +472 -0
- package/src/attest.ts +354 -0
- package/src/evidence.ts +551 -0
- package/src/grc.ts +771 -0
- package/src/host/grc.ts +435 -0
- package/src/host/mod.ts +15 -0
- package/src/host/sign.ts +364 -0
- package/src/mod.ts +20 -0
- package/src/ocsf-types.auto.ts +4680 -0
- package/src/ocsf.ts +471 -0
- package/src/oscal.ts +850 -0
|
@@ -0,0 +1,282 @@
|
|
|
1
|
+
// Spec: 0001-grc-engineering FR-020
|
|
2
|
+
/**
|
|
3
|
+
* Signing and verifying behind one interface (commons 0001-grc-engineering FR-020): a `Signer` turns bytes into a signature and the id of the key that
|
|
4
|
+
* made it, a `Verifier` says whether a signature over bytes holds. Two kinds stand behind it. `sshSigner` and `sshVerifier` run OpenSSH's
|
|
5
|
+
* `ssh-keygen -Y sign` and `ssh-keygen -Y verify` by their argument vector (the message on standard input, the signature an armored
|
|
6
|
+
* SSHSIG), with the namespace given, the private key a file the caller names and the allowed signers a file the caller names; nothing else
|
|
7
|
+
* is read, and the signature's temporary file is removed after use. `webCryptoSigner` and `webCryptoVerifier` sign with Web Crypto keys
|
|
8
|
+
* (Ed25519, ECDSA with DER signatures, RSA-PSS, RSASSA-PKCS1-v1_5) in the same form as `crypto/dsse`, so an envelope signed here
|
|
9
|
+
* verifies there and the other way round. `signEnvelopeWith` and `verifyEnvelopeWith` make and check DSSE envelopes with any of them, and
|
|
10
|
+
* `toSign` and `toVerifySignature` give the shapes `evidence.ts` takes for manifests and bundles.
|
|
11
|
+
*
|
|
12
|
+
* Failures expected in use (no `ssh-keygen`, a key that cannot sign) are `Result`s; a signature that does not hold is `ok(false)`.
|
|
13
|
+
*
|
|
14
|
+
* @example
|
|
15
|
+
* ```ts
|
|
16
|
+
* import { sshSigner, sshVerifier } from "./sign.ts";
|
|
17
|
+
* const message = new TextEncoder().encode("release 1.2.3");
|
|
18
|
+
* const signed = await sshSigner({ keyFile: "ci_ed25519", namespace: "file" }).sign(message);
|
|
19
|
+
* if (signed.kind === "ok") {
|
|
20
|
+
* const v = sshVerifier({ allowedSignersFile: "allowed_signers", identity: "ci@example.com", namespace: "file" });
|
|
21
|
+
* await v.verify(message, signed.value.sig); // { kind: "ok", value: true }
|
|
22
|
+
* }
|
|
23
|
+
* ```
|
|
24
|
+
*
|
|
25
|
+
* @module
|
|
26
|
+
*/
|
|
27
|
+
import { absurd, err, ok } from "@intellectual-frontiers/core";
|
|
28
|
+
import { fromBase64, toBase64 } from "@intellectual-frontiers/formats/base64";
|
|
29
|
+
import { children, integer, readTlv, sequence, TAG } from "@intellectual-frontiers/formats/der";
|
|
30
|
+
import { pae, signatureAlgorithm } from "@intellectual-frontiers/crypto/dsse";
|
|
31
|
+
import { fromHex } from "@intellectual-frontiers/formats/hex";
|
|
32
|
+
import { sha256 } from "@intellectual-frontiers/crypto/sha256";
|
|
33
|
+
import { NotFound } from "@intellectual-frontiers/system/errors";
|
|
34
|
+
import { exists, withTempDir, writeFile } from "@intellectual-frontiers/system/fs";
|
|
35
|
+
import { join } from "@intellectual-frontiers/system/path";
|
|
36
|
+
import { output } from "@intellectual-frontiers/system/proc";
|
|
37
|
+
/** A sign error as one sentence. */
|
|
38
|
+
export function formatSignError(e) {
|
|
39
|
+
switch (e.kind) {
|
|
40
|
+
case "missing-program":
|
|
41
|
+
return `${e.program} is not installed (or not on PATH)`;
|
|
42
|
+
case "key":
|
|
43
|
+
return `the key cannot be used: ${e.reason}`;
|
|
44
|
+
case "failed":
|
|
45
|
+
return `signing failed: ${e.reason}`;
|
|
46
|
+
default:
|
|
47
|
+
return absurd(e);
|
|
48
|
+
}
|
|
49
|
+
}
|
|
50
|
+
/** A signer as the `Sign` that `evidence.ts` takes; that shape has no error, so a failure rejects with an `Error` naming it. */
|
|
51
|
+
export function toSign(signer) {
|
|
52
|
+
return async (message) => {
|
|
53
|
+
const r = await signer.sign(message);
|
|
54
|
+
if (r.kind === "err")
|
|
55
|
+
throw new Error(formatSignError(r.error));
|
|
56
|
+
return r.value.sig;
|
|
57
|
+
};
|
|
58
|
+
}
|
|
59
|
+
/** A verifier as the `VerifySignature` that `evidence.ts` takes; a check that cannot be done rejects, which it reports as a bad signature with the reason. */
|
|
60
|
+
export function toVerifySignature(verifier) {
|
|
61
|
+
return async (message, signature) => {
|
|
62
|
+
const r = await verifier.verify(message, signature);
|
|
63
|
+
if (r.kind === "err")
|
|
64
|
+
throw new Error(formatSignError(r.error));
|
|
65
|
+
return r.value;
|
|
66
|
+
};
|
|
67
|
+
}
|
|
68
|
+
/** The payload of the type signed by every signer given, over DSSE's pre-authentication encoding, in an envelope with each key's id. */
|
|
69
|
+
export async function signEnvelopeWith(payloadType, payload, signers) {
|
|
70
|
+
const message = pae(payloadType, payload);
|
|
71
|
+
const signatures = [];
|
|
72
|
+
for (const [index, s] of signers.entries()) {
|
|
73
|
+
const r = await s.sign(message);
|
|
74
|
+
if (r.kind === "err")
|
|
75
|
+
return err({ kind: "signer", index, error: r.error });
|
|
76
|
+
signatures.push({ keyid: r.value.keyid, sig: toBase64(r.value.sig) });
|
|
77
|
+
}
|
|
78
|
+
return ok({ payload: toBase64(payload), payloadType, signatures });
|
|
79
|
+
}
|
|
80
|
+
/**
|
|
81
|
+
* The payload of an envelope of type `payloadType` of which at least `threshold` (1 by default) of the verifiers given each hold a
|
|
82
|
+
* signature. A signature naming a key id is tried only with verifiers of that id or of none.
|
|
83
|
+
*/
|
|
84
|
+
export async function verifyEnvelopeWith(envelope, payloadType, verifiers, threshold = 1) {
|
|
85
|
+
if (envelope.payloadType !== payloadType)
|
|
86
|
+
return err({ kind: "payload-type", expected: payloadType, found: envelope.payloadType });
|
|
87
|
+
const payload = fromBase64(envelope.payload);
|
|
88
|
+
if (payload.kind === "err")
|
|
89
|
+
return err({ kind: "malformed", reason: `the payload: ${payload.error}` });
|
|
90
|
+
const sigs = [];
|
|
91
|
+
for (const [i, s] of envelope.signatures.entries()) {
|
|
92
|
+
const b = fromBase64(s.sig);
|
|
93
|
+
if (b.kind === "err")
|
|
94
|
+
return err({ kind: "malformed", reason: `signature ${i}: ${b.error}` });
|
|
95
|
+
sigs.push(b.value);
|
|
96
|
+
}
|
|
97
|
+
const message = pae(envelope.payloadType, payload.value);
|
|
98
|
+
const held = [];
|
|
99
|
+
for (const [index, v] of verifiers.entries()) {
|
|
100
|
+
for (const [i, s] of envelope.signatures.entries()) {
|
|
101
|
+
const bytes = sigs[i];
|
|
102
|
+
if (bytes === undefined || (s.keyid !== undefined && v.keyid !== undefined && s.keyid !== v.keyid))
|
|
103
|
+
continue;
|
|
104
|
+
const r = await v.verify(message, bytes);
|
|
105
|
+
if (r.kind === "err")
|
|
106
|
+
return err({ kind: "verifier", index, error: r.error });
|
|
107
|
+
if (r.value) {
|
|
108
|
+
held.push(index);
|
|
109
|
+
break;
|
|
110
|
+
}
|
|
111
|
+
}
|
|
112
|
+
}
|
|
113
|
+
const needed = Math.max(1, threshold);
|
|
114
|
+
if (held.length < needed) {
|
|
115
|
+
return err({ kind: "no-valid-signature", signatures: envelope.signatures.length, verified: held.length, threshold: needed });
|
|
116
|
+
}
|
|
117
|
+
return ok({ payloadType: envelope.payloadType, payload: payload.value, verifiers: held });
|
|
118
|
+
}
|
|
119
|
+
const SSHSIG_MAGIC = "SSHSIG";
|
|
120
|
+
/** The bytes inside an armored SSH signature (`-----BEGIN SSH SIGNATURE-----`), or undefined where it is not one. */
|
|
121
|
+
function sshsigBlob(armored) {
|
|
122
|
+
const m = /-----BEGIN SSH SIGNATURE-----([\s\S]*?)-----END SSH SIGNATURE-----/.exec(armored);
|
|
123
|
+
if (m === null)
|
|
124
|
+
return undefined;
|
|
125
|
+
const b = fromBase64(m[1] ?? "");
|
|
126
|
+
return b.kind === "ok" ? b.value : undefined;
|
|
127
|
+
}
|
|
128
|
+
/** The public key blob of an SSHSIG (magic, version, then the key as an SSH string), or undefined where it is not one. */
|
|
129
|
+
function sshsigPublicKey(blob) {
|
|
130
|
+
const magic = new TextDecoder().decode(blob.subarray(0, SSHSIG_MAGIC.length));
|
|
131
|
+
if (magic !== SSHSIG_MAGIC || blob.length < 14)
|
|
132
|
+
return undefined;
|
|
133
|
+
const view = new DataView(blob.buffer, blob.byteOffset, blob.byteLength);
|
|
134
|
+
const len = view.getUint32(10);
|
|
135
|
+
if (14 + len > blob.length)
|
|
136
|
+
return undefined;
|
|
137
|
+
return blob.subarray(14, 14 + len);
|
|
138
|
+
}
|
|
139
|
+
/** The SHA-256 fingerprint of an SSH public key blob, as `ssh-keygen -l` writes it: `SHA256:` and unpadded base64. */
|
|
140
|
+
export async function sshFingerprint(publicKeyBlob) {
|
|
141
|
+
const digest = fromHex(await sha256(publicKeyBlob)) ?? new Uint8Array(0);
|
|
142
|
+
return `SHA256:${toBase64(digest).replace(/=+$/, "")}`;
|
|
143
|
+
}
|
|
144
|
+
/** What ssh-keygen said, trimmed, or its exit status where it said nothing. */
|
|
145
|
+
const said = (stderr, code) => new TextDecoder().decode(stderr).trim() || `exit status ${code}`;
|
|
146
|
+
/** A program run by its argument vector, or `missing-program` where it is not installed. */
|
|
147
|
+
async function runProgram(argv, input) {
|
|
148
|
+
try {
|
|
149
|
+
const r = await output(argv, { input, env: { LC_ALL: "C" } });
|
|
150
|
+
return ok(r);
|
|
151
|
+
}
|
|
152
|
+
catch (e) {
|
|
153
|
+
if (e instanceof NotFound)
|
|
154
|
+
return err({ kind: "missing-program", program: argv[0] });
|
|
155
|
+
return err({ kind: "failed", reason: e instanceof Error ? e.message : String(e) });
|
|
156
|
+
}
|
|
157
|
+
}
|
|
158
|
+
/** A signer by `ssh-keygen -Y sign -f KEY -n NAMESPACE`, the message on standard input; its signatures are armored SSHSIG text as bytes. */
|
|
159
|
+
export function sshSigner(options) {
|
|
160
|
+
const program = options.program ?? "ssh-keygen";
|
|
161
|
+
return {
|
|
162
|
+
kind: "ssh",
|
|
163
|
+
async sign(message) {
|
|
164
|
+
if (!(await exists(options.keyFile)))
|
|
165
|
+
return err({ kind: "key", reason: `no key file ${options.keyFile}` });
|
|
166
|
+
const r = await runProgram([program, "-Y", "sign", "-f", options.keyFile, "-n", options.namespace], message);
|
|
167
|
+
if (r.kind === "err")
|
|
168
|
+
return r;
|
|
169
|
+
if (r.value.code !== 0)
|
|
170
|
+
return err({ kind: "failed", reason: said(r.value.stderr, r.value.code) });
|
|
171
|
+
const armored = new TextDecoder().decode(r.value.stdout);
|
|
172
|
+
const blob = sshsigBlob(armored);
|
|
173
|
+
const key = blob === undefined ? undefined : sshsigPublicKey(blob);
|
|
174
|
+
if (key === undefined)
|
|
175
|
+
return err({ kind: "failed", reason: `${program} wrote no SSH signature` });
|
|
176
|
+
return ok({ keyid: options.keyid ?? (await sshFingerprint(key)), sig: r.value.stdout });
|
|
177
|
+
},
|
|
178
|
+
};
|
|
179
|
+
}
|
|
180
|
+
/**
|
|
181
|
+
* A verifier by `ssh-keygen -Y verify -f ALLOWED -I IDENTITY -n NAMESPACE -s SIGFILE`, the message on standard input; the signature is
|
|
182
|
+
* written to a private temporary folder removed afterwards. A signature that does not hold (or is not by that identity, or not in that
|
|
183
|
+
* namespace) is `ok(false)`; an allowed signers file that is not there is a `key` error.
|
|
184
|
+
*/
|
|
185
|
+
export function sshVerifier(options) {
|
|
186
|
+
const program = options.program ?? "ssh-keygen";
|
|
187
|
+
const verify = async (message, sig) => {
|
|
188
|
+
if (!(await exists(options.allowedSignersFile)))
|
|
189
|
+
return err({ kind: "key", reason: `no allowed signers file ${options.allowedSignersFile}` });
|
|
190
|
+
if (sshsigBlob(new TextDecoder().decode(sig)) === undefined)
|
|
191
|
+
return ok(false);
|
|
192
|
+
return withTempDir(async (dir) => {
|
|
193
|
+
const sigFile = join(dir, "message.sig");
|
|
194
|
+
await writeFile(sigFile, sig);
|
|
195
|
+
const f = options.allowedSignersFile;
|
|
196
|
+
const r = await runProgram([program, "-Y", "verify", "-f", f, "-I", options.identity, "-n", options.namespace, "-s", sigFile], message);
|
|
197
|
+
if (r.kind === "err")
|
|
198
|
+
return r;
|
|
199
|
+
return ok(r.value.code === 0);
|
|
200
|
+
}, { prefix: "ifc-sshsig-" });
|
|
201
|
+
};
|
|
202
|
+
return options.keyid === undefined ? { kind: "ssh", verify } : { kind: "ssh", keyid: options.keyid, verify };
|
|
203
|
+
}
|
|
204
|
+
// ---------------------------------------------------------------------------------------------------------------------------- Web Crypto
|
|
205
|
+
const CURVE_BYTES = { "P-256": 32, "P-384": 48, "P-521": 66 };
|
|
206
|
+
const CURVE_HASH = { "P-256": "SHA-256", "P-384": "SHA-384", "P-521": "SHA-512" };
|
|
207
|
+
const HASH_BYTES = { "SHA-256": 32, "SHA-384": 48, "SHA-512": 64 };
|
|
208
|
+
/** Web Crypto's parameters for an algorithm, as `crypto/dsse` signs with them. */
|
|
209
|
+
function params(a) {
|
|
210
|
+
switch (a.kind) {
|
|
211
|
+
case "ed25519":
|
|
212
|
+
return { name: "Ed25519" };
|
|
213
|
+
case "ecdsa":
|
|
214
|
+
return { name: "ECDSA", hash: CURVE_HASH[a.curve] };
|
|
215
|
+
case "rsa-pss":
|
|
216
|
+
return { name: "RSA-PSS", saltLength: HASH_BYTES[a.hash] };
|
|
217
|
+
case "rsassa-pkcs1-v1_5":
|
|
218
|
+
return { name: "RSASSA-PKCS1-v1_5" };
|
|
219
|
+
default:
|
|
220
|
+
return absurd(a);
|
|
221
|
+
}
|
|
222
|
+
}
|
|
223
|
+
/** An ASN.1 DER ECDSA signature as Web Crypto's r and s of `n` bytes each, or undefined where it is not one. */
|
|
224
|
+
function ecdsaFromDer(der, n) {
|
|
225
|
+
const t = readTlv(der);
|
|
226
|
+
if (t.kind === "err" || t.value.tag !== TAG.sequence || t.value.raw.length !== der.length)
|
|
227
|
+
return undefined;
|
|
228
|
+
const parts = children(t.value.content);
|
|
229
|
+
if (parts.kind === "err" || parts.value.length !== 2)
|
|
230
|
+
return undefined;
|
|
231
|
+
const out = new Uint8Array(2 * n);
|
|
232
|
+
for (const [i, part] of parts.value.entries()) {
|
|
233
|
+
if (part.tag !== TAG.integer || ((part.content[0] ?? 0x80) & 0x80) !== 0)
|
|
234
|
+
return undefined;
|
|
235
|
+
const magnitude = part.content[0] === 0 ? part.content.subarray(1) : part.content;
|
|
236
|
+
if (magnitude.length > n)
|
|
237
|
+
return undefined;
|
|
238
|
+
out.set(magnitude, (i + 1) * n - magnitude.length);
|
|
239
|
+
}
|
|
240
|
+
return out;
|
|
241
|
+
}
|
|
242
|
+
const reason = (e) => (e instanceof Error ? e.message : String(e));
|
|
243
|
+
/** A signer with a Web Crypto private key, its signatures in the form `crypto/dsse` writes (ECDSA as DER), each named by `keyid`. */
|
|
244
|
+
export function webCryptoSigner(privateKey, keyid) {
|
|
245
|
+
return {
|
|
246
|
+
kind: "web-crypto",
|
|
247
|
+
async sign(message) {
|
|
248
|
+
const a = signatureAlgorithm(privateKey);
|
|
249
|
+
if (a.kind === "err")
|
|
250
|
+
return err({ kind: "key", reason: a.error });
|
|
251
|
+
let raw;
|
|
252
|
+
try {
|
|
253
|
+
raw = new Uint8Array(await crypto.subtle.sign(params(a.value), privateKey, new Uint8Array(message)));
|
|
254
|
+
}
|
|
255
|
+
catch (e) {
|
|
256
|
+
return err({ kind: "key", reason: reason(e) });
|
|
257
|
+
}
|
|
258
|
+
if (a.value.kind !== "ecdsa")
|
|
259
|
+
return ok({ keyid, sig: raw });
|
|
260
|
+
const n = CURVE_BYTES[a.value.curve];
|
|
261
|
+
return ok({ keyid, sig: sequence(integer(raw.subarray(0, n)), integer(raw.subarray(n, 2 * n))) });
|
|
262
|
+
},
|
|
263
|
+
};
|
|
264
|
+
}
|
|
265
|
+
/** A verifier with a Web Crypto public key, of signatures in the form `crypto/dsse` writes; with `keyid`, matched by it in envelopes. */
|
|
266
|
+
export function webCryptoVerifier(publicKey, keyid) {
|
|
267
|
+
const verify = async (message, sig) => {
|
|
268
|
+
const a = signatureAlgorithm(publicKey);
|
|
269
|
+
if (a.kind === "err")
|
|
270
|
+
return err({ kind: "key", reason: a.error });
|
|
271
|
+
const bytes = a.value.kind === "ecdsa" ? ecdsaFromDer(sig, CURVE_BYTES[a.value.curve]) : new Uint8Array(sig);
|
|
272
|
+
if (bytes === undefined)
|
|
273
|
+
return ok(false);
|
|
274
|
+
try {
|
|
275
|
+
return ok(await crypto.subtle.verify(params(a.value), publicKey, bytes, new Uint8Array(message)));
|
|
276
|
+
}
|
|
277
|
+
catch (e) {
|
|
278
|
+
return err({ kind: "key", reason: reason(e) });
|
|
279
|
+
}
|
|
280
|
+
};
|
|
281
|
+
return keyid === undefined ? { kind: "web-crypto", verify } : { kind: "web-crypto", keyid, verify };
|
|
282
|
+
}
|
package/dist/mod.d.ts
ADDED
|
@@ -0,0 +1,19 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* GRC engineering as one typed library (commons 0007-grc, 0032-lifting-libraries): the pure modules as namespaces. `grc` gives catalogs, controls, verdicts, findings and waivers; `evidence` gives the canonical form of
|
|
3
|
+
* JSON, the hash-chained ledger and the manifests and bundles; `assess` gives coverage, freshness, drift, the change-impact gate and the risk register; `ocsf`, `oscal` and `attest` write the findings, the assessments and
|
|
4
|
+
* the attestations as the standards define them. The host (`@intellectual-frontiers/grc/host`) loads the settings of packs and runs them as signals, and signs.
|
|
5
|
+
*
|
|
6
|
+
* @example
|
|
7
|
+
* ```ts
|
|
8
|
+
* import { grc } from "@intellectual-frontiers/grc";
|
|
9
|
+
* grc.join("fail", "pass"); // "fail"
|
|
10
|
+
* ```
|
|
11
|
+
*
|
|
12
|
+
* @module
|
|
13
|
+
*/
|
|
14
|
+
export * as assess from "./assess.js";
|
|
15
|
+
export * as attest from "./attest.js";
|
|
16
|
+
export * as evidence from "./evidence.js";
|
|
17
|
+
export * as grc from "./grc.js";
|
|
18
|
+
export * as ocsf from "./ocsf.js";
|
|
19
|
+
export * as oscal from "./oscal.js";
|
package/dist/mod.js
ADDED
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
// Spec: 0001-grc-engineering FR-001
|
|
2
|
+
/**
|
|
3
|
+
* GRC engineering as one typed library (commons 0007-grc, 0032-lifting-libraries): the pure modules as namespaces. `grc` gives catalogs, controls, verdicts, findings and waivers; `evidence` gives the canonical form of
|
|
4
|
+
* JSON, the hash-chained ledger and the manifests and bundles; `assess` gives coverage, freshness, drift, the change-impact gate and the risk register; `ocsf`, `oscal` and `attest` write the findings, the assessments and
|
|
5
|
+
* the attestations as the standards define them. The host (`@intellectual-frontiers/grc/host`) loads the settings of packs and runs them as signals, and signs.
|
|
6
|
+
*
|
|
7
|
+
* @example
|
|
8
|
+
* ```ts
|
|
9
|
+
* import { grc } from "@intellectual-frontiers/grc";
|
|
10
|
+
* grc.join("fail", "pass"); // "fail"
|
|
11
|
+
* ```
|
|
12
|
+
*
|
|
13
|
+
* @module
|
|
14
|
+
*/
|
|
15
|
+
export * as assess from "./assess.js";
|
|
16
|
+
export * as attest from "./attest.js";
|
|
17
|
+
export * as evidence from "./evidence.js";
|
|
18
|
+
export * as grc from "./grc.js";
|
|
19
|
+
export * as ocsf from "./ocsf.js";
|
|
20
|
+
export * as oscal from "./oscal.js";
|