@intellectual-frontiers/ergonex 0.3.0 → 0.3.2
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/dist/desired.d.ts +1 -1
- package/dist/mod.js +2029 -2461
- package/dist/modules/external.d.ts +1 -1
- package/dist/modules/registry.d.ts +1 -1
- package/dist/modules/types.d.ts +6 -6
- package/dist/plan.d.ts +1 -1
- package/dist/platform/k-args.d.ts +3 -24
- package/dist/render.d.ts +2 -2
- package/dist/state-record.d.ts +2 -2
- package/dist/tools/catalog.d.ts +1 -1
- package/dist/vendor/ts/runtime/http-client.d.ts +1 -1
- package/ergonex.mjs +3484 -3769
- package/package.json +5 -2
- package/dist/vendor/ts/kernel/archive.d.ts +0 -147
- package/dist/vendor/ts/kernel/args.d.ts +0 -240
- package/dist/vendor/ts/kernel/assess.d.ts +0 -247
- package/dist/vendor/ts/kernel/attest.d.ts +0 -164
- package/dist/vendor/ts/kernel/base64.d.ts +0 -24
- package/dist/vendor/ts/kernel/cbor.d.ts +0 -39
- package/dist/vendor/ts/kernel/cms.d.ts +0 -106
- package/dist/vendor/ts/kernel/commands.d.ts +0 -103
- package/dist/vendor/ts/kernel/cose.d.ts +0 -34
- package/dist/vendor/ts/kernel/crypt.d.ts +0 -30
- package/dist/vendor/ts/kernel/csv.d.ts +0 -38
- package/dist/vendor/ts/kernel/der.d.ts +0 -67
- package/dist/vendor/ts/kernel/documentation.d.ts +0 -118
- package/dist/vendor/ts/kernel/dsse.d.ts +0 -137
- package/dist/vendor/ts/kernel/evidence.d.ts +0 -212
- package/dist/vendor/ts/kernel/glob.d.ts +0 -64
- package/dist/vendor/ts/kernel/grc.d.ts +0 -356
- package/dist/vendor/ts/kernel/http.d.ts +0 -46
- package/dist/vendor/ts/kernel/json5.d.ts +0 -46
- package/dist/vendor/ts/kernel/layers.d.ts +0 -35
- package/dist/vendor/ts/kernel/md5.d.ts +0 -19
- package/dist/vendor/ts/kernel/media-types.d.ts +0 -28
- package/dist/vendor/ts/kernel/mod.d.ts +0 -95
- package/dist/vendor/ts/kernel/ocsf-types.auto.d.ts +0 -4374
- package/dist/vendor/ts/kernel/ocsf.d.ts +0 -160
- package/dist/vendor/ts/kernel/oscal.d.ts +0 -356
- package/dist/vendor/ts/kernel/otel.d.ts +0 -365
- package/dist/vendor/ts/kernel/otlp.d.ts +0 -83
- package/dist/vendor/ts/kernel/palette.d.ts +0 -44
- package/dist/vendor/ts/kernel/png.d.ts +0 -124
- package/dist/vendor/ts/kernel/rdf-schema.d.ts +0 -190
- package/dist/vendor/ts/kernel/rdf-term.d.ts +0 -162
- package/dist/vendor/ts/kernel/rdf-vocabularies.d.ts +0 -148
- package/dist/vendor/ts/kernel/rdf-write.d.ts +0 -25
- package/dist/vendor/ts/kernel/rdf.d.ts +0 -35
- package/dist/vendor/ts/kernel/render.d.ts +0 -111
- package/dist/vendor/ts/kernel/schedule.d.ts +0 -207
- package/dist/vendor/ts/kernel/semver.d.ts +0 -94
- package/dist/vendor/ts/kernel/sha256.d.ts +0 -29
- package/dist/vendor/ts/kernel/signals.d.ts +0 -371
- package/dist/vendor/ts/kernel/sigv4.d.ts +0 -67
- package/dist/vendor/ts/kernel/test-record.d.ts +0 -222
- package/dist/vendor/ts/kernel/test-report.d.ts +0 -294
- package/dist/vendor/ts/kernel/toml.d.ts +0 -51
- package/dist/vendor/ts/kernel/trace.d.ts +0 -169
- package/dist/vendor/ts/kernel/ts-literal.d.ts +0 -62
- package/dist/vendor/ts/kernel/uuid.d.ts +0 -53
- package/dist/vendor/ts/kernel/vt.d.ts +0 -78
- package/dist/vendor/ts/kernel/webauthn.d.ts +0 -212
- package/dist/vendor/ts/kernel/width.d.ts +0 -63
- package/dist/vendor/ts/kernel/xml.d.ts +0 -73
- package/dist/vendor/ts/kernel/yaml.d.ts +0 -44
|
@@ -1,164 +0,0 @@
|
|
|
1
|
-
import { type ResourceDescriptor, type Statement } from "./dsse.js";
|
|
2
|
-
import { type Assessment, type Instant } from "./grc.js";
|
|
3
|
-
import { type Sha256 } from "./sha256.js";
|
|
4
|
-
import { type Uuid } from "./uuid.js";
|
|
5
|
-
/** A CycloneDX 1.6 component type. */
|
|
6
|
-
export type CdxComponentType = "application" | "framework" | "library" | "container" | "platform" | "operating-system" | "device" | "device-driver" | "firmware" | "file" | "machine-learning-model" | "data" | "cryptographic-asset";
|
|
7
|
-
/** A requirement of a standard. */
|
|
8
|
-
export type CdxRequirement = {
|
|
9
|
-
readonly "bom-ref": string;
|
|
10
|
-
readonly identifier: string;
|
|
11
|
-
readonly title?: string;
|
|
12
|
-
readonly text?: string;
|
|
13
|
-
};
|
|
14
|
-
/** A standard (`definitions.standards`): its requirements, and what is known of it. */
|
|
15
|
-
export type CdxStandard = {
|
|
16
|
-
readonly "bom-ref": string;
|
|
17
|
-
readonly name: string;
|
|
18
|
-
readonly version?: string;
|
|
19
|
-
readonly description?: string;
|
|
20
|
-
readonly owner?: string;
|
|
21
|
-
readonly requirements: readonly CdxRequirement[];
|
|
22
|
-
};
|
|
23
|
-
/** An assessor. */
|
|
24
|
-
export type CdxAssessor = {
|
|
25
|
-
readonly "bom-ref": string;
|
|
26
|
-
readonly thirdParty: boolean;
|
|
27
|
-
readonly organization: {
|
|
28
|
-
readonly name: string;
|
|
29
|
-
};
|
|
30
|
-
};
|
|
31
|
-
/** How far a requirement is met: a score from 0 to 1 and why. */
|
|
32
|
-
export type CdxConformance = {
|
|
33
|
-
readonly score: number;
|
|
34
|
-
readonly rationale: string;
|
|
35
|
-
};
|
|
36
|
-
/** One requirement of an attestation, with the claims and counter-claims that bear on it. */
|
|
37
|
-
export type CdxAttestationMapItem = {
|
|
38
|
-
readonly requirement: string;
|
|
39
|
-
readonly claims: readonly string[];
|
|
40
|
-
readonly counterClaims?: readonly string[];
|
|
41
|
-
readonly conformance: CdxConformance;
|
|
42
|
-
};
|
|
43
|
-
/** An attestation: an assessor's map of requirements to claims. */
|
|
44
|
-
export type CdxAttestation = {
|
|
45
|
-
readonly summary: string;
|
|
46
|
-
readonly assessor: string;
|
|
47
|
-
readonly map: readonly CdxAttestationMapItem[];
|
|
48
|
-
};
|
|
49
|
-
/** A claim about a target, with the evidence for it and against it. */
|
|
50
|
-
export type CdxClaim = {
|
|
51
|
-
readonly "bom-ref": string;
|
|
52
|
-
readonly target: string;
|
|
53
|
-
readonly predicate: string;
|
|
54
|
-
readonly reasoning: string;
|
|
55
|
-
readonly evidence?: readonly string[];
|
|
56
|
-
readonly counterEvidence?: readonly string[];
|
|
57
|
-
};
|
|
58
|
-
/** A piece of evidence: what it is, when it was made, and where its data is. */
|
|
59
|
-
export type CdxEvidence = {
|
|
60
|
-
readonly "bom-ref": string;
|
|
61
|
-
readonly description: string;
|
|
62
|
-
readonly data?: readonly {
|
|
63
|
-
readonly name: string;
|
|
64
|
-
readonly contents: {
|
|
65
|
-
readonly url: string;
|
|
66
|
-
};
|
|
67
|
-
}[];
|
|
68
|
-
readonly created: Instant;
|
|
69
|
-
};
|
|
70
|
-
/** A component claims are about. */
|
|
71
|
-
export type CdxTargetComponent = {
|
|
72
|
-
readonly "bom-ref": string;
|
|
73
|
-
readonly type: CdxComponentType;
|
|
74
|
-
readonly name: string;
|
|
75
|
-
readonly version?: string;
|
|
76
|
-
};
|
|
77
|
-
/** CycloneDX 1.6 declarations. */
|
|
78
|
-
export type CdxDeclarations = {
|
|
79
|
-
readonly assessors: readonly CdxAssessor[];
|
|
80
|
-
readonly attestations: readonly CdxAttestation[];
|
|
81
|
-
readonly claims: readonly CdxClaim[];
|
|
82
|
-
readonly evidence: readonly CdxEvidence[];
|
|
83
|
-
readonly targets: {
|
|
84
|
-
readonly components: readonly CdxTargetComponent[];
|
|
85
|
-
};
|
|
86
|
-
};
|
|
87
|
-
/** A tool that made a BOM. */
|
|
88
|
-
export type CdxTool = {
|
|
89
|
-
readonly type: "application";
|
|
90
|
-
readonly name: string;
|
|
91
|
-
readonly version: string;
|
|
92
|
-
};
|
|
93
|
-
/** A minimal CycloneDX 1.6 BOM that carries declarations. */
|
|
94
|
-
export type CdxBom = {
|
|
95
|
-
readonly bomFormat: "CycloneDX";
|
|
96
|
-
readonly specVersion: "1.6";
|
|
97
|
-
readonly serialNumber: `urn:uuid:${string}`;
|
|
98
|
-
readonly version: 1;
|
|
99
|
-
readonly metadata: {
|
|
100
|
-
readonly timestamp: Instant;
|
|
101
|
-
readonly tools?: {
|
|
102
|
-
readonly components: readonly CdxTool[];
|
|
103
|
-
};
|
|
104
|
-
};
|
|
105
|
-
readonly definitions: {
|
|
106
|
-
readonly standards: readonly CdxStandard[];
|
|
107
|
-
};
|
|
108
|
-
readonly declarations: CdxDeclarations;
|
|
109
|
-
};
|
|
110
|
-
/** What an attestation needs beyond the assessment. */
|
|
111
|
-
export type AttestOptions = {
|
|
112
|
-
/** The namespace of the BOM's serial number and of its evidence's UUIDs. */
|
|
113
|
-
readonly namespace: Uuid;
|
|
114
|
-
readonly assessor: {
|
|
115
|
-
readonly name: string;
|
|
116
|
-
readonly thirdParty: boolean;
|
|
117
|
-
};
|
|
118
|
-
/** What the claims are about. */
|
|
119
|
-
readonly target: {
|
|
120
|
-
readonly name: string;
|
|
121
|
-
readonly type?: CdxComponentType;
|
|
122
|
-
readonly version?: string;
|
|
123
|
-
};
|
|
124
|
-
readonly tool?: {
|
|
125
|
-
readonly name: string;
|
|
126
|
-
readonly version: string;
|
|
127
|
-
};
|
|
128
|
-
/** What is known of each catalog, by its id. */
|
|
129
|
-
readonly standards?: Readonly<Record<string, {
|
|
130
|
-
readonly name?: string;
|
|
131
|
-
readonly version?: string;
|
|
132
|
-
readonly owner?: string;
|
|
133
|
-
readonly description?: string;
|
|
134
|
-
}>>;
|
|
135
|
-
readonly summary?: string;
|
|
136
|
-
};
|
|
137
|
-
/** An RFC 6920 Named Information URI of a SHA-256: `ni:///sha-256;` and the digest in base64url without padding. */
|
|
138
|
-
export declare function niUri(digest: Sha256): string;
|
|
139
|
-
/** An assessment's declarations, and the standards their requirements are of. */
|
|
140
|
-
export declare function declarations(a: Assessment, o: AttestOptions): Promise<{
|
|
141
|
-
readonly standards: readonly CdxStandard[];
|
|
142
|
-
readonly declarations: CdxDeclarations;
|
|
143
|
-
}>;
|
|
144
|
-
/** An assessment as a CycloneDX 1.6 BOM of its declarations: the serial number a version 5 UUID of the pack and time in the namespace. */
|
|
145
|
-
export declare function cyclonedxBom(a: Assessment, o: AttestOptions): Promise<CdxBom>;
|
|
146
|
-
/** The in-toto predicate type of a CycloneDX BOM. */
|
|
147
|
-
export declare const CYCLONEDX_PREDICATE_TYPE = "https://cyclonedx.org/bom";
|
|
148
|
-
/** A statement's subject named by its SHA-256. */
|
|
149
|
-
export type DigestSubject = ResourceDescriptor & {
|
|
150
|
-
readonly digest: {
|
|
151
|
-
readonly sha256: Sha256;
|
|
152
|
-
};
|
|
153
|
-
};
|
|
154
|
-
/** An in-toto Statement v1 whose predicate type is `T` and predicate `P`, its subjects named by their SHA-256: a `Statement<P>` for DSSE. */
|
|
155
|
-
export type TypedStatement<T extends string, P> = Statement<P> & {
|
|
156
|
-
readonly predicateType: T;
|
|
157
|
-
readonly subject: readonly DigestSubject[];
|
|
158
|
-
};
|
|
159
|
-
/** A subject: the name and the SHA-256 of the bytes. */
|
|
160
|
-
export declare function digestSubject(name: string, bytes: Uint8Array): Promise<DigestSubject>;
|
|
161
|
-
/** An in-toto Statement v1 of a predicate of the type named about the subjects. */
|
|
162
|
-
export declare function intotoStatement<const T extends string, P>(subjects: readonly DigestSubject[], predicateType: T, predicate: P): TypedStatement<T, P>;
|
|
163
|
-
/** A CycloneDX BOM as the predicate of an in-toto statement about the subjects. */
|
|
164
|
-
export declare function bomStatement(bom: CdxBom, subjects: readonly DigestSubject[]): TypedStatement<typeof CYCLONEDX_PREDICATE_TYPE, CdxBom>;
|
|
@@ -1,24 +0,0 @@
|
|
|
1
|
-
/**
|
|
2
|
-
* Base64 and base64url (RFC 4648 §4 and §5), both ways, on bytes (commons 0005-typescript-runtime FR-042): what DSSE envelopes, JWTs, data
|
|
3
|
-
* URLs, PEM and signed URLs carry. Decoding refuses what is not base64 of the alphabet asked for, rather than skipping it; base64url is
|
|
4
|
-
* written without padding and read with or without it. Taken from the helpers Stolos wrote in `src/archon/export/intoto.ts` and S/MIME.
|
|
5
|
-
*
|
|
6
|
-
* @example
|
|
7
|
-
* ```ts
|
|
8
|
-
* import { fromBase64, toBase64, toBase64Url } from "./base64.js";
|
|
9
|
-
* toBase64(new TextEncoder().encode("foobar")); // "Zm9vYmFy"
|
|
10
|
-
* toBase64Url(Uint8Array.of(0xfb, 0xff)); // "-_8"
|
|
11
|
-
* fromBase64("Zm9v"); // { kind: "ok", value: Uint8Array [102, 111, 111] }
|
|
12
|
-
* ```
|
|
13
|
-
*
|
|
14
|
-
* @module
|
|
15
|
-
*/
|
|
16
|
-
import { type Result } from "@intellectual-frontiers/core";
|
|
17
|
-
/** Bytes as standard base64, padded. */
|
|
18
|
-
export declare function toBase64(bytes: Uint8Array): string;
|
|
19
|
-
/** Standard base64 as bytes; white space between the characters is ignored, and anything else that is not base64 refused. */
|
|
20
|
-
export declare function fromBase64(text: string): Result<Uint8Array, string>;
|
|
21
|
-
/** Bytes as base64url, without padding. */
|
|
22
|
-
export declare function toBase64Url(bytes: Uint8Array): string;
|
|
23
|
-
/** Base64url (padded or not) as bytes; anything else refused. */
|
|
24
|
-
export declare function fromBase64Url(text: string): Result<Uint8Array, string>;
|
|
@@ -1,39 +0,0 @@
|
|
|
1
|
-
import { type Result } from "@intellectual-frontiers/core";
|
|
2
|
-
/** A map key this module reads and writes: an integer or a text string. */
|
|
3
|
-
export type CborKey = number | bigint | string;
|
|
4
|
-
/** A tagged value (major type 6): its tag number and the value it tags. */
|
|
5
|
-
export type CborTagged = {
|
|
6
|
-
readonly tag: number | bigint;
|
|
7
|
-
readonly value: CborValue;
|
|
8
|
-
};
|
|
9
|
-
/** A CBOR data item as a value: integers (a `bigint` beyond the safe range), floats, strings, bytes, arrays, maps, tags and simple values. */
|
|
10
|
-
export type CborValue = number | bigint | string | Uint8Array | boolean | null | undefined | readonly CborValue[] | ReadonlyMap<CborKey, CborValue> | CborTagged;
|
|
11
|
-
/** Why bytes are not CBOR this reader takes: what, and at which byte. */
|
|
12
|
-
export type CborError = {
|
|
13
|
-
readonly kind: "cbor";
|
|
14
|
-
readonly at: number;
|
|
15
|
-
readonly message: string;
|
|
16
|
-
};
|
|
17
|
-
/** One data item read from a longer input: its value and the offset just after it. */
|
|
18
|
-
export type CborItem = {
|
|
19
|
-
readonly value: CborValue;
|
|
20
|
-
readonly end: number;
|
|
21
|
-
};
|
|
22
|
-
/** The deepest nesting of arrays, maps and tags read. */
|
|
23
|
-
export declare const MAX_DEPTH = 64;
|
|
24
|
-
/** A CBOR error as one line. */
|
|
25
|
-
export declare function formatCborError(e: CborError): string;
|
|
26
|
-
/** Whether a value is a tagged value (rather than a map, an array or bytes). */
|
|
27
|
-
export declare function isTagged(value: CborValue): value is CborTagged;
|
|
28
|
-
/** Whether a value is a map. */
|
|
29
|
-
export declare function isMap(value: CborValue): value is ReadonlyMap<CborKey, CborValue>;
|
|
30
|
-
/** The data item that starts at `offset`, and the offset just after it: for CBOR followed by more bytes (WebAuthn's authenticator data). */
|
|
31
|
-
export declare function decodeCborItem(bytes: Uint8Array, offset?: number): Result<CborItem, CborError>;
|
|
32
|
-
/** The one data item the bytes hold; bytes left after it are an error. */
|
|
33
|
-
export declare function decodeCbor(bytes: Uint8Array): Result<CborValue, CborError>;
|
|
34
|
-
/**
|
|
35
|
-
* A value as CBOR, in the core deterministic encoding: integers (safe `number`s or `bigint`s) in their shortest head, other numbers as
|
|
36
|
-
* doubles, strings as UTF-8, `Uint8Array` as a byte string, arrays, maps with their keys sorted by their encoding, tags and the four
|
|
37
|
-
* simple values. A value no CBOR item can hold (an integer beyond 64 bits) is a programming error and throws a `RangeError`.
|
|
38
|
-
*/
|
|
39
|
-
export declare function encodeCbor(value: CborValue): Uint8Array;
|
|
@@ -1,106 +0,0 @@
|
|
|
1
|
-
import { type Tlv } from "./der.js";
|
|
2
|
-
import { type Result } from "@intellectual-frontiers/core";
|
|
3
|
-
/** The object identifiers used. */
|
|
4
|
-
export declare const OID: {
|
|
5
|
-
readonly data: "1.2.840.113549.1.7.1";
|
|
6
|
-
readonly authEnvelopedData: "1.2.840.113549.1.9.16.1.23";
|
|
7
|
-
readonly aes256gcm: "2.16.840.1.101.3.4.1.46";
|
|
8
|
-
readonly rsaEncryption: "1.2.840.113549.1.1.1";
|
|
9
|
-
readonly rsaesOaep: "1.2.840.113549.1.1.7";
|
|
10
|
-
readonly mgf1: "1.2.840.113549.1.1.8";
|
|
11
|
-
readonly sha256: "2.16.840.1.101.3.4.2.1";
|
|
12
|
-
readonly commonName: "2.5.4.3";
|
|
13
|
-
readonly emailAddress: "1.2.840.113549.1.9.1";
|
|
14
|
-
readonly subjectAltName: "2.5.29.17";
|
|
15
|
-
readonly keyUsage: "2.5.29.15";
|
|
16
|
-
};
|
|
17
|
-
/** Why CMS or a certificate could not be read, written or opened. */
|
|
18
|
-
export type CmsError = {
|
|
19
|
-
readonly kind: "pem";
|
|
20
|
-
readonly message: string;
|
|
21
|
-
} | {
|
|
22
|
-
readonly kind: "certificate";
|
|
23
|
-
readonly message: string;
|
|
24
|
-
} | {
|
|
25
|
-
readonly kind: "unsupported";
|
|
26
|
-
readonly message: string;
|
|
27
|
-
} | {
|
|
28
|
-
readonly kind: "structure";
|
|
29
|
-
readonly message: string;
|
|
30
|
-
} | {
|
|
31
|
-
readonly kind: "no-recipient";
|
|
32
|
-
readonly message: string;
|
|
33
|
-
} | {
|
|
34
|
-
readonly kind: "decrypt";
|
|
35
|
-
readonly message: string;
|
|
36
|
-
};
|
|
37
|
-
/** A CMS error as one sentence. */
|
|
38
|
-
export declare function formatCmsError(e: CmsError): string;
|
|
39
|
-
/** Every PEM block of a label (`CERTIFICATE`, `PRIVATE KEY`) in a text, as DER; none found, or a block that is not base64, is an error. */
|
|
40
|
-
export declare function readPem(text: string, label: string): Result<readonly Uint8Array[], CmsError>;
|
|
41
|
-
/** DER as a PEM block of a label, base64 in 64-column lines. */
|
|
42
|
-
export declare function toPem(der: Uint8Array, label: string): string;
|
|
43
|
-
/** What encryption and a person need from a recipient's X.509 certificate. */
|
|
44
|
-
export type Certificate = {
|
|
45
|
-
/** The issuer's Name, its DER exactly as in the certificate. */
|
|
46
|
-
readonly issuer: Uint8Array;
|
|
47
|
-
/** The serial number's INTEGER element, exactly as in the certificate. */
|
|
48
|
-
readonly serial: Uint8Array;
|
|
49
|
-
/** The serial number in hexadecimal. */
|
|
50
|
-
readonly serialHex: string;
|
|
51
|
-
/** The SubjectPublicKeyInfo, DER. */
|
|
52
|
-
readonly spki: Uint8Array;
|
|
53
|
-
/** The public key's algorithm, as an OID. */
|
|
54
|
-
readonly keyAlgorithm: string;
|
|
55
|
-
/** The subject's common name, where it has one. */
|
|
56
|
-
readonly commonName: string | undefined;
|
|
57
|
-
/** The addresses it names (subjectAltName rfc822Name and the subject's emailAddress), in lower case. */
|
|
58
|
-
readonly emails: readonly string[];
|
|
59
|
-
/** When it starts being valid, where its time can be read. */
|
|
60
|
-
readonly notBefore: Date | undefined;
|
|
61
|
-
/** When it stops being valid, where its time can be read. */
|
|
62
|
-
readonly notAfter: Date | undefined;
|
|
63
|
-
/** Whether it may encrypt keys: true where it has no keyUsage extension, else its keyEncipherment bit. */
|
|
64
|
-
readonly keyEncipherment: boolean;
|
|
65
|
-
};
|
|
66
|
-
/** An X.509 certificate read for what encryption needs, or why it is not one this reader takes. */
|
|
67
|
-
export declare function readCertificate(der: Uint8Array): Result<Certificate, CmsError>;
|
|
68
|
-
/** Why a certificate cannot encrypt to an address now. */
|
|
69
|
-
export type CertificateProblem = {
|
|
70
|
-
readonly kind: "not-rsa";
|
|
71
|
-
readonly algorithm: string;
|
|
72
|
-
} | {
|
|
73
|
-
readonly kind: "not-yet-valid";
|
|
74
|
-
readonly from: Date;
|
|
75
|
-
} | {
|
|
76
|
-
readonly kind: "expired";
|
|
77
|
-
readonly on: Date;
|
|
78
|
-
} | {
|
|
79
|
-
readonly kind: "signing-only";
|
|
80
|
-
} | {
|
|
81
|
-
readonly kind: "other-address";
|
|
82
|
-
readonly names: readonly string[];
|
|
83
|
-
};
|
|
84
|
-
/** Why a certificate cannot be used to encrypt to `address` at `now`, or undefined where it can. */
|
|
85
|
-
export declare function certificateProblem(c: Certificate, address: string, now: Date): CertificateProblem | undefined;
|
|
86
|
-
/** RSAES-OAEP with SHA-256 and MGF1 with SHA-256, as an AlgorithmIdentifier (RFC 4055 §4.1). */
|
|
87
|
-
export declare function oaepSha256(): Uint8Array;
|
|
88
|
-
/** The fresh secrets of one message: a 32-byte AES-256 content key and a 12-byte GCM nonce. */
|
|
89
|
-
export type CmsKeys = {
|
|
90
|
-
readonly contentKey: Uint8Array;
|
|
91
|
-
readonly nonce: Uint8Array;
|
|
92
|
-
};
|
|
93
|
-
/** Fresh secrets from a source of random bytes, such as `(n) => crypto.getRandomValues(new Uint8Array(n))`. */
|
|
94
|
-
export declare function cmsKeys(random: (length: number) => Uint8Array): CmsKeys;
|
|
95
|
-
/**
|
|
96
|
-
* A CMS ContentInfo holding AuthEnvelopedData, as DER: `content` encrypted with AES-256-GCM, its key encrypted to every recipient with
|
|
97
|
-
* RSA-OAEP SHA-256. No recipient, a recipient whose key is not RSA, or keys of the wrong size are errors.
|
|
98
|
-
*/
|
|
99
|
-
export declare function authEnveloped(content: Uint8Array, recipients: readonly Certificate[], keys: CmsKeys): Promise<Result<Uint8Array, CmsError>>;
|
|
100
|
-
/** Whether an AlgorithmIdentifier is RSAES-OAEP with SHA-256, MGF1 with SHA-256 and the default label, however its NULLs are written. */
|
|
101
|
-
export declare function isOaepSha256(t: Tlv): boolean;
|
|
102
|
-
/**
|
|
103
|
-
* The content of an AuthEnvelopedData, opened by the recipient whose certificate is `cert` with its RSA-OAEP SHA-256 private key; or why
|
|
104
|
-
* it cannot be: not this structure, no RecipientInfo for this certificate, or a key or tag that does not decrypt (the content was changed).
|
|
105
|
-
*/
|
|
106
|
-
export declare function openAuthEnveloped(der: Uint8Array, cert: Certificate, privateKey: CryptoKey): Promise<Result<Uint8Array, CmsError>>;
|
|
@@ -1,103 +0,0 @@
|
|
|
1
|
-
/**
|
|
2
|
-
* A command tree declared once as data (commons 0005-typescript-runtime FR-072): a command of groups and verbs to any depth, each with a
|
|
3
|
-
* name and a summary, and each verb with its options (`./args.ts`'s declaration) and its arguments. From that declaration alone it
|
|
4
|
-
* resolves an argument vector to the verb it names, to the help asked for, or to a typed error that names the word not known, where, the
|
|
5
|
-
* words known there and the nearest of them; and it renders the help of every level, so that help never runs a verb.
|
|
6
|
-
*
|
|
7
|
-
* @remarks
|
|
8
|
-
* A group named with no verb asks for its help, as `git remote` with no verb would list; `--help` or `-h` anywhere before `--` asks for
|
|
9
|
-
* the help of the deepest group or verb named before it. Unknown options of a verb are its own parser's business (`parseArgs`), which the
|
|
10
|
-
* verb runs on the arguments left to it.
|
|
11
|
-
*
|
|
12
|
-
* @example
|
|
13
|
-
* ```ts
|
|
14
|
-
* import { group, resolveCommand, verb } from "./commands.js";
|
|
15
|
-
* const tree = group({ name: "tool", summary: "A tool.", children: [group({ name: "work", summary: "Works.", children: [
|
|
16
|
-
* verb({ name: "build", summary: "Build.", options: {} }),
|
|
17
|
-
* ] })] });
|
|
18
|
-
* resolveCommand(tree, ["work", "build", "a"]); // ok: the verb build, with ["a"] left
|
|
19
|
-
* resolveCommand(tree, ["wrk"]); // err: wrk is not known at the top, did you mean work?
|
|
20
|
-
* ```
|
|
21
|
-
*
|
|
22
|
-
* @module
|
|
23
|
-
*/
|
|
24
|
-
import { type Result } from "@intellectual-frontiers/core";
|
|
25
|
-
import { type Operand, type Spec, type SpecCheck } from "./args.js";
|
|
26
|
-
/** An example of a verb: the words after the verb, and what it does. */
|
|
27
|
-
export type Example = {
|
|
28
|
-
readonly args: readonly string[];
|
|
29
|
-
readonly says: string;
|
|
30
|
-
};
|
|
31
|
-
/** A verb: a leaf of the tree, with the options and arguments it takes. */
|
|
32
|
-
export type Verb<S extends Spec = Spec> = {
|
|
33
|
-
readonly kind: "verb";
|
|
34
|
-
readonly name: string;
|
|
35
|
-
readonly summary: string;
|
|
36
|
-
readonly options: S;
|
|
37
|
-
readonly operands: readonly Operand[];
|
|
38
|
-
readonly examples: readonly Example[];
|
|
39
|
-
};
|
|
40
|
-
/** A group: a word that names more words, groups or verbs. */
|
|
41
|
-
export type Group = {
|
|
42
|
-
readonly kind: "group";
|
|
43
|
-
readonly name: string;
|
|
44
|
-
readonly summary: string;
|
|
45
|
-
readonly children: readonly CommandNode[];
|
|
46
|
-
};
|
|
47
|
-
/** One node of a command tree. */
|
|
48
|
-
export type CommandNode = Group | Verb;
|
|
49
|
-
/** A verb, declared with its options checked as `parseArgs` checks them. */
|
|
50
|
-
export declare function verb<S extends Spec>(v: {
|
|
51
|
-
readonly name: string;
|
|
52
|
-
readonly summary: string;
|
|
53
|
-
readonly options: S & SpecCheck<S>;
|
|
54
|
-
readonly operands?: readonly Operand[];
|
|
55
|
-
readonly examples?: readonly Example[];
|
|
56
|
-
}): Verb<S>;
|
|
57
|
-
/** A group of nodes. */
|
|
58
|
-
export declare function group(g: {
|
|
59
|
-
readonly name: string;
|
|
60
|
-
readonly summary: string;
|
|
61
|
-
readonly children: readonly CommandNode[];
|
|
62
|
-
}): Group;
|
|
63
|
-
/** Whether a name is one a command may have: lower case letters, digits and dashes, beginning with a letter. */
|
|
64
|
-
export declare function validCommandName(name: string): boolean;
|
|
65
|
-
/** What is wrong with a declared tree: a name that may not be one, or two children of a group with the same name. */
|
|
66
|
-
export type TreeProblem = {
|
|
67
|
-
readonly kind: "bad-name";
|
|
68
|
-
readonly path: readonly string[];
|
|
69
|
-
readonly name: string;
|
|
70
|
-
} | {
|
|
71
|
-
readonly kind: "duplicate";
|
|
72
|
-
readonly path: readonly string[];
|
|
73
|
-
readonly name: string;
|
|
74
|
-
};
|
|
75
|
-
/** Every problem of a tree, in the order of its nodes; none where it is well formed. */
|
|
76
|
-
export declare function treeProblems(root: CommandNode, path?: readonly string[]): readonly TreeProblem[];
|
|
77
|
-
/** What an argument vector names: a verb with the arguments left for it, or the help of a node. */
|
|
78
|
-
export type Resolved = {
|
|
79
|
-
readonly kind: "verb";
|
|
80
|
-
readonly path: readonly string[];
|
|
81
|
-
readonly verb: Verb;
|
|
82
|
-
readonly args: readonly string[];
|
|
83
|
-
} | {
|
|
84
|
-
readonly kind: "help";
|
|
85
|
-
readonly path: readonly string[];
|
|
86
|
-
readonly node: CommandNode;
|
|
87
|
-
};
|
|
88
|
-
/** Why an argument vector names nothing: a word not known below `path`, the words known there, and the nearest. */
|
|
89
|
-
export type CommandError = {
|
|
90
|
-
readonly kind: "unknown-command";
|
|
91
|
-
readonly path: readonly string[];
|
|
92
|
-
readonly word: string;
|
|
93
|
-
readonly known: readonly string[];
|
|
94
|
-
readonly suggestion: string | undefined;
|
|
95
|
-
};
|
|
96
|
-
/** Whether a word asks for help. */
|
|
97
|
-
export declare function asksForHelp(word: string): boolean;
|
|
98
|
-
/** Resolves an argument vector (the words after the program's name) against a tree whose root is the program. */
|
|
99
|
-
export declare function resolveCommand(root: Group, argv: readonly string[]): Result<Resolved, CommandError>;
|
|
100
|
-
/** A command error as one sentence, with the help to run next. */
|
|
101
|
-
export declare function formatCommandError(e: CommandError): string;
|
|
102
|
-
/** The help of a node at `path` (the words that name it, the program's first), from its declaration alone. */
|
|
103
|
-
export declare function commandHelp(path: readonly string[], node: CommandNode): string;
|
|
@@ -1,34 +0,0 @@
|
|
|
1
|
-
import { type Result } from "@intellectual-frontiers/core";
|
|
2
|
-
/** COSE's identifier of ES256: ECDSA on P-256 with SHA-256. */
|
|
3
|
-
export declare const ES256 = -7;
|
|
4
|
-
/** COSE's identifier of EdDSA (here always Ed25519). */
|
|
5
|
-
export declare const EDDSA = -8;
|
|
6
|
-
/** The algorithms commons accepts, in order of preference. */
|
|
7
|
-
export declare const ALGORITHMS: readonly number[];
|
|
8
|
-
/** A public key read from a `COSE_Key`: an EC2 key on P-256 for ES256, or an OKP key on Ed25519 for EdDSA. */
|
|
9
|
-
export type CoseKey = {
|
|
10
|
-
readonly kty: "EC2";
|
|
11
|
-
readonly alg: typeof ES256;
|
|
12
|
-
readonly crv: "P-256";
|
|
13
|
-
readonly x: Uint8Array;
|
|
14
|
-
readonly y: Uint8Array;
|
|
15
|
-
} | {
|
|
16
|
-
readonly kty: "OKP";
|
|
17
|
-
readonly alg: typeof EDDSA;
|
|
18
|
-
readonly crv: "Ed25519";
|
|
19
|
-
readonly x: Uint8Array;
|
|
20
|
-
};
|
|
21
|
-
/** A `COSE_Key` read from its CBOR: a map with `kty` (1), `alg` (3), `crv` (-1), `x` (-2) and, for EC2, `y` (-3); anything else refused. */
|
|
22
|
-
export declare function parseCoseKey(bytes: Uint8Array): Result<CoseKey, string>;
|
|
23
|
-
/** The CBOR `COSE_Key` of a key (deterministic: its labels sorted). */
|
|
24
|
-
export declare function encodeCoseKey(key: CoseKey): Uint8Array;
|
|
25
|
-
/** The `COSE_Key` of a public JSON Web Key: EC on P-256 (as ES256) or OKP on Ed25519 (as EdDSA); any other key refused. */
|
|
26
|
-
export declare function coseKeyFromJwk(jwk: JsonWebKey): Result<Uint8Array, string>;
|
|
27
|
-
/** The public JSON Web Key of a COSE key. */
|
|
28
|
-
export declare function jwkOfCoseKey(key: CoseKey): JsonWebKey;
|
|
29
|
-
/** The key imported into Web Crypto for verifying; a point not on its curve is refused. */
|
|
30
|
-
export declare function importCoseKey(key: CoseKey): Promise<Result<CryptoKey, string>>;
|
|
31
|
-
/** An ECDSA signature as DER (`Ecdsa-Sig-Value ::= SEQUENCE { r INTEGER, s INTEGER }`) turned into raw `r || s` of `size` bytes each. */
|
|
32
|
-
export declare function ecdsaDerToRaw(der: Uint8Array, size?: number): Result<Uint8Array, string>;
|
|
33
|
-
/** Whether `signature` is the key's signature of `data` (ES256: DER as WebAuthn gives it; EdDSA: 64 raw bytes); an unusable key or a malformed signature is an error. */
|
|
34
|
-
export declare function verifyCose(key: CoseKey, signature: Uint8Array, data: Uint8Array): Promise<Result<boolean, string>>;
|
|
@@ -1,30 +0,0 @@
|
|
|
1
|
-
/**
|
|
2
|
-
* SHA-512 crypt (`$6$`), the password hash of glibc's `crypt(3)` that Linux accounts and Ubuntu's installer accept, on Web Crypto alone
|
|
3
|
-
* (commons 0005-typescript-runtime FR-034). The algorithm is Ulrich Drepper's "Unix crypt using SHA-256 and SHA-512". The salt is given,
|
|
4
|
-
* so the kernel stays free of effects: a caller makes one from random bytes with `cryptSalt(crypto.getRandomValues(new Uint8Array(16)))`.
|
|
5
|
-
* Taken from Stolos's `src/archon/core/crypt.ts`.
|
|
6
|
-
*
|
|
7
|
-
* @example
|
|
8
|
-
* ```ts
|
|
9
|
-
* import { sha512Crypt } from "./crypt.js";
|
|
10
|
-
* await sha512Crypt("Hello world!", "saltstring");
|
|
11
|
-
* // "$6$saltstring$svn8UoSVapNtMuq1ukKS4tPQd8iKwSMHWjl/O817G3uBnIFNjnQJuesI68u4OTLiBFdcbYEdFCoEOfaS35inz1"
|
|
12
|
-
* ```
|
|
13
|
-
*
|
|
14
|
-
* @module
|
|
15
|
-
*/
|
|
16
|
-
/** The rounds glibc uses when none are named, and the least and most it accepts. */
|
|
17
|
-
export declare const CRYPT_ROUNDS: {
|
|
18
|
-
readonly default: 5000;
|
|
19
|
-
readonly min: 1000;
|
|
20
|
-
readonly max: 999999999;
|
|
21
|
-
};
|
|
22
|
-
/** A salt of crypt's alphabet (`./0-9A-Za-z`) made from bytes, one character each, at most 16. */
|
|
23
|
-
export declare function cryptSalt(bytes: Uint8Array): string;
|
|
24
|
-
/**
|
|
25
|
-
* A password hashed as SHA-512 crypt: `$6$<salt>$<hash>`, with `rounds=<n>$` after `$6$` where rounds are given (5000 where they are
|
|
26
|
-
* not). Only the first 16 characters of the salt count, and given rounds are clamped to what glibc accepts, as glibc does.
|
|
27
|
-
*/
|
|
28
|
-
export declare function sha512Crypt(password: string, salt: string, rounds?: number): Promise<string>;
|
|
29
|
-
/** Whether a password matches a `$6$` hash, by hashing it again with the hash's own salt and rounds. */
|
|
30
|
-
export declare function verifySha512Crypt(password: string, hash: string): Promise<boolean>;
|
|
@@ -1,38 +0,0 @@
|
|
|
1
|
-
/**
|
|
2
|
-
* CSV by RFC 4180, read and written with no outside package (commons 0005-typescript-runtime FR-036): fields separated by a comma (or
|
|
3
|
-
* another single character), a field quoted where it holds the separator, a quote or a line break, a quote inside one doubled, records
|
|
4
|
-
* ended by CRLF or LF. The reader refuses a quote in an unquoted field and a quoted field that is not closed, and says the line and column;
|
|
5
|
-
* it can give each record as an object by the header's names. Replaces `@std/csv` in erga.
|
|
6
|
-
*
|
|
7
|
-
* @example
|
|
8
|
-
* ```ts
|
|
9
|
-
* import { parseCsv, toCsv } from "./csv.js";
|
|
10
|
-
* parseCsv('name,quote\nAda,"Hello, ""world"""\n'); // { kind: "ok", value: [["name", "quote"], ["Ada", 'Hello, "world"']] }
|
|
11
|
-
* toCsv([["a", "b,c"]]); // 'a,"b,c"\r\n'
|
|
12
|
-
* ```
|
|
13
|
-
*
|
|
14
|
-
* @module
|
|
15
|
-
*/
|
|
16
|
-
import { type Result } from "@intellectual-frontiers/core";
|
|
17
|
-
/** Where a text stops being CSV, and why. Lines and columns count from 1. */
|
|
18
|
-
export type CsvError = {
|
|
19
|
-
readonly kind: "csv";
|
|
20
|
-
readonly line: number;
|
|
21
|
-
readonly column: number;
|
|
22
|
-
readonly message: string;
|
|
23
|
-
};
|
|
24
|
-
/** A CSV error as one line: `3:14: a quote in a field that is not quoted`. */
|
|
25
|
-
export declare function formatCsvError(e: CsvError): string;
|
|
26
|
-
/** How to read and write: the separator (a comma by default), and for writing the line ending (CRLF by default, as RFC 4180 has it). */
|
|
27
|
-
export type CsvOptions = {
|
|
28
|
-
readonly separator?: string;
|
|
29
|
-
readonly lineEnding?: "\r\n" | "\n";
|
|
30
|
-
};
|
|
31
|
-
/** The records of a CSV text, each a list of fields; a final line break ends the last record and makes no empty one. */
|
|
32
|
-
export declare function parseCsv(text: string, options?: CsvOptions): Result<readonly (readonly string[])[], CsvError>;
|
|
33
|
-
/** The records of a CSV text with a header, each an object by the header's names; a record whose length is not the header's is an error. */
|
|
34
|
-
export declare function parseCsvRecords(text: string, options?: CsvOptions): Result<readonly Readonly<Record<string, string>>[], CsvError>;
|
|
35
|
-
/** A field as CSV writes it: quoted, with its quotes doubled, where it holds the separator, a quote, a line break or leading or trailing space. */
|
|
36
|
-
export declare function csvField(value: string, separator?: string): string;
|
|
37
|
-
/** Records as CSV text, each ended by the line ending. */
|
|
38
|
-
export declare function toCsv(records: readonly (readonly string[])[], options?: CsvOptions): string;
|
|
@@ -1,67 +0,0 @@
|
|
|
1
|
-
import { type Result } from "@intellectual-frontiers/core";
|
|
2
|
-
/** The universal tags used (class universal, with the constructed bit where it applies). */
|
|
3
|
-
export declare const TAG: {
|
|
4
|
-
readonly boolean: 1;
|
|
5
|
-
readonly integer: 2;
|
|
6
|
-
readonly bitString: 3;
|
|
7
|
-
readonly octetString: 4;
|
|
8
|
-
readonly null: 5;
|
|
9
|
-
readonly oid: 6;
|
|
10
|
-
readonly utf8String: 12;
|
|
11
|
-
readonly printableString: 19;
|
|
12
|
-
readonly ia5String: 22;
|
|
13
|
-
readonly utcTime: 23;
|
|
14
|
-
readonly generalizedTime: 24;
|
|
15
|
-
readonly sequence: 48;
|
|
16
|
-
readonly set: 49;
|
|
17
|
-
};
|
|
18
|
-
/** Why bytes are not DER this reader knows: what, and at which byte. */
|
|
19
|
-
export type DerError = {
|
|
20
|
-
readonly kind: "der";
|
|
21
|
-
readonly at: number;
|
|
22
|
-
readonly message: string;
|
|
23
|
-
};
|
|
24
|
-
/** One element read: its tag byte, its content, and its whole encoding (to copy it into another structure). */
|
|
25
|
-
export type Tlv = {
|
|
26
|
-
readonly tag: number;
|
|
27
|
-
readonly content: Uint8Array;
|
|
28
|
-
readonly raw: Uint8Array;
|
|
29
|
-
};
|
|
30
|
-
/** A DER length: the short form below 128, else `0x80` with the number of length bytes, then the bytes. */
|
|
31
|
-
export declare function encodeLength(n: number): Uint8Array;
|
|
32
|
-
/** One element: the tag byte, the content's length, the content. */
|
|
33
|
-
export declare function tlv(tag: number, content: Uint8Array): Uint8Array;
|
|
34
|
-
/** A SEQUENCE of these encodings, in order. */
|
|
35
|
-
export declare function sequence(...items: readonly Uint8Array[]): Uint8Array;
|
|
36
|
-
/** Two byte strings compared as DER sorts them: byte by byte, a prefix first. */
|
|
37
|
-
export declare function compareBytes(a: Uint8Array, b: Uint8Array): number;
|
|
38
|
-
/** A SET OF these encodings, sorted as DER requires (X.690 §11.6). */
|
|
39
|
-
export declare function setOf(...items: readonly Uint8Array[]): Uint8Array;
|
|
40
|
-
/** An OCTET STRING. */
|
|
41
|
-
export declare function octetString(b: Uint8Array): Uint8Array;
|
|
42
|
-
/** A BIT STRING of whole bytes (no unused bits). */
|
|
43
|
-
export declare function bitString(b: Uint8Array): Uint8Array;
|
|
44
|
-
/** A UTF8String. */
|
|
45
|
-
export declare function utf8String(s: string): Uint8Array;
|
|
46
|
-
/** A BOOLEAN. */
|
|
47
|
-
export declare function boolean(v: boolean): Uint8Array;
|
|
48
|
-
/** NULL. */
|
|
49
|
-
export declare function derNull(): Uint8Array;
|
|
50
|
-
/** An INTEGER: a JavaScript integer or a bigint (negative too), or big-endian unsigned magnitude bytes; always in its minimal form. */
|
|
51
|
-
export declare function integer(v: number | bigint | Uint8Array): Uint8Array;
|
|
52
|
-
/** An OBJECT IDENTIFIER from its dotted form (`1.2.840.113549`). */
|
|
53
|
-
export declare function oid(dotted: string): Uint8Array;
|
|
54
|
-
/** A context-specific EXPLICIT tag `[n]` around one encoding. */
|
|
55
|
-
export declare function explicit(n: number, inner: Uint8Array): Uint8Array;
|
|
56
|
-
/** A context-specific IMPLICIT tag `[n]`: this content under the tag, constructed where the underlying type is. */
|
|
57
|
-
export declare function implicit(n: number, content: Uint8Array, constructed: boolean): Uint8Array;
|
|
58
|
-
/** An AlgorithmIdentifier: `SEQUENCE { algorithm OID, parameters ANY OPTIONAL }`. */
|
|
59
|
-
export declare function algorithm(id: string, params?: Uint8Array): Uint8Array;
|
|
60
|
-
/** The element that starts at `offset`: its tag, its content and its whole encoding; or why it is not DER this reader knows. */
|
|
61
|
-
export declare function readTlv(bytes: Uint8Array, offset?: number): Result<Tlv, DerError>;
|
|
62
|
-
/** The elements inside a constructed element's content, in order. */
|
|
63
|
-
export declare function children(content: Uint8Array): Result<readonly Tlv[], DerError>;
|
|
64
|
-
/** The dotted form of an OBJECT IDENTIFIER's content. */
|
|
65
|
-
export declare function readOid(content: Uint8Array): Result<string, DerError>;
|
|
66
|
-
/** The value of an INTEGER's content, as a bigint (two's complement). */
|
|
67
|
-
export declare function readInteger(content: Uint8Array): Result<bigint, DerError>;
|