@lepistabioinformatics/mycelium-sdk 2.0.0 → 2.1.0

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/index.cjs CHANGED
@@ -25,33 +25,72 @@ __export(src_exports, {
25
25
  DEFAULT_EMAIL_KEY: () => DEFAULT_EMAIL_KEY,
26
26
  DEFAULT_MYCELIUM_ROLE_KEY: () => DEFAULT_MYCELIUM_ROLE_KEY,
27
27
  DEFAULT_PROFILE_KEY: () => DEFAULT_PROFILE_KEY,
28
+ DEFAULT_PROFILE_SIGNATURE_KEY: () => DEFAULT_PROFILE_SIGNATURE_KEY,
29
+ DEFAULT_PROFILE_SIGNATURE_TOLERANCE_SECONDS: () => DEFAULT_PROFILE_SIGNATURE_TOLERANCE_SECONDS,
28
30
  DEFAULT_REQUEST_ID_KEY: () => DEFAULT_REQUEST_ID_KEY,
29
31
  DEFAULT_SCOPE_KEY: () => DEFAULT_SCOPE_KEY,
30
32
  DEFAULT_TENANT_ID_KEY: () => DEFAULT_TENANT_ID_KEY,
31
33
  InsufficientLicensesError: () => InsufficientLicensesError,
32
34
  InsufficientPrivilegesError: () => InsufficientPrivilegesError,
35
+ JwksProfileSignatureVerifier: () => JwksProfileSignatureVerifier,
33
36
  LicensedResourceSchema: () => LicensedResourceSchema,
34
37
  LicensedResourcesSchema: () => LicensedResourcesSchema,
38
+ MAX_PROFILE_SIGNATURE_BYTES: () => MAX_PROFILE_SIGNATURE_BYTES,
39
+ MAX_PROFILE_SIGNATURE_TOLERANCE_SECONDS: () => MAX_PROFILE_SIGNATURE_TOLERANCE_SECONDS,
35
40
  MyceliumError: () => MyceliumError,
36
41
  OwnerSchema: () => OwnerSchema,
42
+ PROFILE_JWKS_ALLOW_INSECURE_HTTP_ENV: () => PROFILE_JWKS_ALLOW_INSECURE_HTTP_ENV,
43
+ PROFILE_JWKS_DEFAULT_MAX_AGE_SECONDS: () => PROFILE_JWKS_DEFAULT_MAX_AGE_SECONDS,
44
+ PROFILE_JWKS_EMPTY_RETRY_SECONDS: () => PROFILE_JWKS_EMPTY_RETRY_SECONDS,
45
+ PROFILE_JWKS_FETCH_TIMEOUT_SECONDS: () => PROFILE_JWKS_FETCH_TIMEOUT_SECONDS,
46
+ PROFILE_JWKS_MAX_BYTES: () => PROFILE_JWKS_MAX_BYTES,
47
+ PROFILE_JWKS_MAX_MAX_AGE_SECONDS: () => PROFILE_JWKS_MAX_MAX_AGE_SECONDS,
48
+ PROFILE_JWKS_MAX_STALE_SECONDS: () => PROFILE_JWKS_MAX_STALE_SECONDS,
49
+ PROFILE_JWKS_MIN_MAX_AGE_SECONDS: () => PROFILE_JWKS_MIN_MAX_AGE_SECONDS,
50
+ PROFILE_JWKS_PATH: () => PROFILE_JWKS_PATH,
51
+ PROFILE_JWKS_REFETCH_COOLDOWN_SECONDS: () => PROFILE_JWKS_REFETCH_COOLDOWN_SECONDS,
52
+ PROFILE_JWKS_URL_ENV: () => PROFILE_JWKS_URL_ENV,
53
+ PROFILE_SIGNATURE_AUDIENCE_ENV: () => PROFILE_SIGNATURE_AUDIENCE_ENV,
54
+ PROFILE_SIGNATURE_CONFIG_INVALID_CODE: () => PROFILE_SIGNATURE_CONFIG_INVALID_CODE,
55
+ PROFILE_SIGNATURE_INVALID_CODE: () => PROFILE_SIGNATURE_INVALID_CODE,
56
+ PROFILE_SIGNATURE_TOLERANCE_ENV: () => PROFILE_SIGNATURE_TOLERANCE_ENV,
37
57
  Permission: () => Permission,
38
58
  PermissionSchema: () => PermissionSchema,
39
59
  Profile: () => Profile,
40
60
  ProfileDecodingError: () => ProfileDecodingError,
61
+ ProfileJwksFetchError: () => ProfileJwksFetchError,
62
+ ProfileKeyStore: () => ProfileKeyStore,
41
63
  ProfileMetaSchema: () => ProfileMetaSchema,
42
64
  ProfileSchema: () => ProfileSchema,
65
+ ProfileSignatureConfigurationError: () => ProfileSignatureConfigurationError,
66
+ ProfileSignatureError: () => ProfileSignatureError,
67
+ ProfileSignatureVerifier: () => ProfileSignatureVerifier,
68
+ SIGNATURE_INTERNAL_DETAIL: () => SIGNATURE_INTERNAL_DETAIL,
69
+ SIGNATURE_REJECTION_DETAIL: () => SIGNATURE_REJECTION_DETAIL,
43
70
  TenantOwnershipSchema: () => TenantOwnershipSchema,
44
71
  TenantsOwnershipSchema: () => TenantsOwnershipSchema,
45
72
  VerboseStatusSchema: () => VerboseStatusSchema,
46
73
  compressAndEncodeProfileToBase64: () => compressAndEncodeProfileToBase64,
47
74
  decodeAndDecompressProfileFromBase64: () => decodeAndDecompressProfileFromBase64,
75
+ fetchProfileJwks: () => fetchProfileJwks,
76
+ isCanonicalKeyVersion: () => isCanonicalKeyVersion,
48
77
  licensedResourceFromUrlString: () => licensedResourceFromUrlString,
78
+ loadProfileSignatureVerifierFromEnv: () => loadProfileSignatureVerifierFromEnv,
79
+ parseProfileJwks: () => parseProfileJwks,
80
+ parseProfileJwksUrl: () => parseProfileJwksUrl,
49
81
  permissionFromInt: () => permissionFromInt,
50
82
  permissionToInt: () => permissionToInt,
83
+ prepareProfileSignatureVerifier: () => prepareProfileSignatureVerifier,
84
+ profileHeaderHash: () => profileHeaderHash,
85
+ readJwksCacheMaxAge: () => readJwksCacheMaxAge,
86
+ readSignatureKeyVersion: () => readSignatureKeyVersion,
51
87
  safeDecodeAndDecompressProfileFromBase64: () => safeDecodeAndDecompressProfileFromBase64,
52
88
  tenantOwnershipFromUrlString: () => tenantOwnershipFromUrlString,
53
89
  toLicensesVector: () => toLicensesVector,
54
- toOwnershipVector: () => toOwnershipVector
90
+ toOwnershipVector: () => toOwnershipVector,
91
+ verifyAndDecodeProfile: () => verifyAndDecodeProfile,
92
+ verifyProfileSignature: () => verifyProfileSignature,
93
+ verifyRequestProfile: () => verifyRequestProfile
55
94
  });
56
95
  module.exports = __toCommonJS(src_exports);
57
96
 
@@ -86,6 +125,22 @@ var ProfileDecodingError = class extends MyceliumError {
86
125
  this.name = "ProfileDecodingError";
87
126
  }
88
127
  };
128
+ var PROFILE_SIGNATURE_INVALID_CODE = "MYC_PROFILE_SIGNATURE_INVALID";
129
+ var PROFILE_SIGNATURE_CONFIG_INVALID_CODE = "MYC_PROFILE_SIGNATURE_CONFIG_INVALID";
130
+ var ProfileSignatureConfigurationError = class extends MyceliumError {
131
+ constructor(message) {
132
+ super(message, PROFILE_SIGNATURE_CONFIG_INVALID_CODE, false);
133
+ this.name = "ProfileSignatureConfigurationError";
134
+ }
135
+ };
136
+ var ProfileSignatureError = class extends MyceliumError {
137
+ reason;
138
+ constructor(reason) {
139
+ super(`Profile signature rejected: ${reason}`, PROFILE_SIGNATURE_INVALID_CODE, true);
140
+ this.name = "ProfileSignatureError";
141
+ this.reason = reason;
142
+ }
143
+ };
89
144
 
90
145
  // src/settings.ts
91
146
  var DEFAULT_PROFILE_KEY = "x-mycelium-profile";
@@ -95,6 +150,23 @@ var DEFAULT_MYCELIUM_ROLE_KEY = "x-mycelium-role";
95
150
  var DEFAULT_REQUEST_ID_KEY = "x-mycelium-request-id";
96
151
  var DEFAULT_CONNECTION_STRING_KEY = "x-mycelium-connection-string";
97
152
  var DEFAULT_TENANT_ID_KEY = "x-mycelium-tenant-id";
153
+ var DEFAULT_PROFILE_SIGNATURE_KEY = "x-mycelium-profile-signature";
154
+ var PROFILE_JWKS_URL_ENV = "MYCELIUM_JWKS_URL";
155
+ var PROFILE_JWKS_ALLOW_INSECURE_HTTP_ENV = "MYCELIUM_JWKS_ALLOW_INSECURE_HTTP";
156
+ var PROFILE_JWKS_PATH = "/.well-known/mycelium-profile-jwks.json";
157
+ var PROFILE_JWKS_FETCH_TIMEOUT_SECONDS = 5;
158
+ var PROFILE_JWKS_MAX_BYTES = 64 * 1024;
159
+ var PROFILE_JWKS_REFETCH_COOLDOWN_SECONDS = 30;
160
+ var PROFILE_JWKS_EMPTY_RETRY_SECONDS = 5;
161
+ var PROFILE_JWKS_DEFAULT_MAX_AGE_SECONDS = 43200;
162
+ var PROFILE_JWKS_MIN_MAX_AGE_SECONDS = 60;
163
+ var PROFILE_JWKS_MAX_MAX_AGE_SECONDS = 86400;
164
+ var PROFILE_JWKS_MAX_STALE_SECONDS = 86400;
165
+ var PROFILE_SIGNATURE_TOLERANCE_ENV = "MYC_PROFILE_SIGNATURE_TOLERANCE_SECONDS";
166
+ var PROFILE_SIGNATURE_AUDIENCE_ENV = "MYC_PROFILE_SIGNATURE_AUDIENCE";
167
+ var DEFAULT_PROFILE_SIGNATURE_TOLERANCE_SECONDS = 60;
168
+ var MAX_PROFILE_SIGNATURE_TOLERANCE_SECONDS = 300;
169
+ var MAX_PROFILE_SIGNATURE_BYTES = 4096;
98
170
 
99
171
  // src/models/permission.ts
100
172
  var import_zod = require("zod");
@@ -104,7 +176,10 @@ var Permission = {
104
176
  };
105
177
  var PermissionSchema = import_zod.z.union([
106
178
  import_zod.z.literal(0),
107
- import_zod.z.literal(1)
179
+ import_zod.z.literal(1),
180
+ // Rust serializes Permission with serde rename_all = camelCase.
181
+ import_zod.z.literal("read").transform(() => Permission.READ),
182
+ import_zod.z.literal("write").transform(() => Permission.WRITE)
108
183
  ]);
109
184
  function permissionToInt(permission) {
110
185
  return permission;
@@ -344,7 +419,7 @@ var ProfileSchema = import_zod9.z.object({
344
419
  accountWasApproved: import_zod9.z.boolean(),
345
420
  accountWasArchived: import_zod9.z.boolean(),
346
421
  accountWasDeleted: import_zod9.z.boolean(),
347
- verboseStatus: VerboseStatusSchema.optional(),
422
+ verboseStatus: VerboseStatusSchema.nullish(),
348
423
  licensedResources: LicensedResourcesSchema.optional(),
349
424
  tenantsOwnership: TenantsOwnershipSchema.optional(),
350
425
  meta: ProfileMetaSchema.optional(),
@@ -673,6 +748,625 @@ function formatZodError(error) {
673
748
  return `field '${path}' ${issue.message}`;
674
749
  }).join("; ");
675
750
  }
751
+
752
+ // src/functions/verifyProfileSignature.ts
753
+ var import_node_crypto = require("crypto");
754
+ var import_jose = require("jose");
755
+ var import_zod10 = require("zod");
756
+
757
+ // src/profileSignatureVerifier.ts
758
+ var CANONICAL_POSITIVE_INTEGER = /^[1-9][0-9]*$/;
759
+ var MAX_KEY_VERSION = 4294967295;
760
+ var ProfileSignatureVerifier = class {
761
+ #keys;
762
+ toleranceSeconds;
763
+ expectedAudience;
764
+ constructor(keys, toleranceSeconds, expectedAudience) {
765
+ this.#keys = new Map(keys);
766
+ this.toleranceSeconds = toleranceSeconds;
767
+ this.expectedAudience = expectedAudience;
768
+ Object.freeze(this);
769
+ }
770
+ keyFor(kid) {
771
+ return this.#keys.get(kid);
772
+ }
773
+ get keyVersions() {
774
+ return [...this.#keys.keys()].sort();
775
+ }
776
+ };
777
+ function isCanonicalKeyVersion(raw) {
778
+ return CANONICAL_POSITIVE_INTEGER.test(raw) && Number(raw) <= MAX_KEY_VERSION;
779
+ }
780
+
781
+ // src/functions/verifyProfileSignature.ts
782
+ var FORBIDDEN_HEADER_MEMBERS = ["crit", "b64", "jku", "jwk", "x5u", "x5c"];
783
+ var ENCODED_DIGEST_LENGTH = 43;
784
+ function reject(reason) {
785
+ return new ProfileSignatureError(reason);
786
+ }
787
+ function isCanonicalHash(value) {
788
+ if (value.length !== ENCODED_DIGEST_LENGTH) return false;
789
+ const raw = Buffer.from(value, "base64url");
790
+ return raw.length === 32 && raw.toString("base64url") === value;
791
+ }
792
+ var claimsSchema = import_zod10.z.object({
793
+ iat: import_zod10.z.number().refine((value) => Number.isSafeInteger(value) && value >= 0),
794
+ ph: import_zod10.z.string().refine(isCanonicalHash),
795
+ aud: import_zod10.z.string().refine((value) => value.trim() !== "")
796
+ });
797
+ function decodeSegment(segment) {
798
+ try {
799
+ const value = JSON.parse(
800
+ Buffer.from(segment, "base64url").toString("utf8")
801
+ );
802
+ const isObject2 = typeof value === "object" && value !== null && !Array.isArray(value);
803
+ return isObject2 ? value : void 0;
804
+ } catch {
805
+ return void 0;
806
+ }
807
+ }
808
+ function splitToken(signatureHeader) {
809
+ if (signatureHeader === "") throw reject("missing_signature");
810
+ const parts = signatureHeader.split(".");
811
+ const oversized = Buffer.byteLength(signatureHeader, "utf8") > MAX_PROFILE_SIGNATURE_BYTES;
812
+ if (oversized || parts.length !== 3) throw reject("malformed_signature");
813
+ return parts;
814
+ }
815
+ function selectKey(header, verifier) {
816
+ if (header.alg !== "EdDSA") throw reject("unsupported_algorithm");
817
+ const hasForbidden = FORBIDDEN_HEADER_MEMBERS.some((member) => member in header);
818
+ if (hasForbidden) throw reject("malformed_signature");
819
+ const kid = header.kid;
820
+ const key = typeof kid === "string" && isCanonicalKeyVersion(kid) ? verifier.keyFor(kid) : void 0;
821
+ if (key === void 0) throw reject("unknown_key");
822
+ return key;
823
+ }
824
+ async function verifyJws(token, key) {
825
+ try {
826
+ const { payload } = await (0, import_jose.compactVerify)(token, key, {
827
+ algorithms: ["EdDSA"]
828
+ });
829
+ return payload;
830
+ } catch (error) {
831
+ if (error instanceof import_jose.errors.JWSSignatureVerificationFailed) {
832
+ throw reject("invalid_signature");
833
+ }
834
+ throw reject("malformed_signature");
835
+ }
836
+ }
837
+ function parseClaims(payload) {
838
+ let decoded;
839
+ try {
840
+ decoded = JSON.parse(Buffer.from(payload).toString("utf8"));
841
+ } catch {
842
+ throw reject("invalid_claims");
843
+ }
844
+ const parsed = claimsSchema.safeParse(decoded);
845
+ if (!parsed.success) throw reject("invalid_claims");
846
+ return parsed.data;
847
+ }
848
+ function resolveNow(nowSeconds) {
849
+ const now = nowSeconds ?? Math.floor(Date.now() / 1e3);
850
+ if (!Number.isSafeInteger(now) || now < 0) {
851
+ throw new RangeError("Verifier clock is outside the safe integer range");
852
+ }
853
+ return now;
854
+ }
855
+ function profileHeaderHash(profileHeader) {
856
+ return (0, import_node_crypto.createHash)("sha256").update(profileHeader, "utf8").digest("base64url");
857
+ }
858
+ function sameHash(received, expected) {
859
+ const left = Buffer.from(received, "utf8");
860
+ const right = Buffer.from(expected, "utf8");
861
+ return left.length === right.length && (0, import_node_crypto.timingSafeEqual)(left, right);
862
+ }
863
+ function checkClaims(claims, profileHeader, verifier, now) {
864
+ if (Math.abs(now - claims.iat) > verifier.toleranceSeconds) {
865
+ throw reject("timestamp_out_of_tolerance");
866
+ }
867
+ if (!sameHash(claims.ph, profileHeaderHash(profileHeader))) {
868
+ throw reject("profile_hash_mismatch");
869
+ }
870
+ const expected = verifier.expectedAudience;
871
+ if (expected !== void 0 && claims.aud !== expected) {
872
+ throw reject("audience_mismatch");
873
+ }
874
+ }
875
+ async function verifyProfileSignature(profileHeader, signatureHeader, verifier, nowSeconds) {
876
+ if (profileHeader === "") throw reject("missing_profile");
877
+ const parts = splitToken(signatureHeader);
878
+ const header = decodeSegment(parts[0] ?? "");
879
+ if (header === void 0) throw reject("malformed_signature");
880
+ const key = selectKey(header, verifier);
881
+ const payload = await verifyJws(signatureHeader, key);
882
+ const claims = parseClaims(payload);
883
+ checkClaims(claims, profileHeader, verifier, resolveNow(nowSeconds));
884
+ }
885
+ async function verifyAndDecodeProfile(profileHeader, signatureHeader, verifier, nowSeconds) {
886
+ await verifyProfileSignature(profileHeader, signatureHeader, verifier, nowSeconds);
887
+ try {
888
+ return decodeAndDecompressProfileFromBase64(profileHeader);
889
+ } catch {
890
+ throw reject("invalid_profile");
891
+ }
892
+ }
893
+
894
+ // src/jwks/parseProfileJwks.ts
895
+ var import_node_crypto2 = require("crypto");
896
+ var JWKS = "profile JWKS";
897
+ var BASE64URL = /^[A-Za-z0-9_-]+$/;
898
+ var ED25519_PUBLIC_KEY_BYTES = 32;
899
+ function invalid(problem) {
900
+ return new ProfileSignatureConfigurationError(`${JWKS} ${problem}`);
901
+ }
902
+ function isObject(value) {
903
+ return typeof value === "object" && value !== null && !Array.isArray(value);
904
+ }
905
+ function expectMember(jwk, name, expected, required) {
906
+ if (!(name in jwk) && !required) return;
907
+ if (jwk[name] !== expected) {
908
+ throw invalid(`entry member ${name} must be ${expected}`);
909
+ }
910
+ }
911
+ function readKid(jwk) {
912
+ const kid = jwk.kid;
913
+ if (typeof kid !== "string" || !isCanonicalKeyVersion(kid)) {
914
+ throw invalid("entry kid must be a canonical positive integer");
915
+ }
916
+ return kid;
917
+ }
918
+ function readX(jwk) {
919
+ const x = jwk.x;
920
+ const isKey = typeof x === "string" && BASE64URL.test(x) && Buffer.from(x, "base64url").length === ED25519_PUBLIC_KEY_BYTES && Buffer.from(x, "base64url").toString("base64url") === x;
921
+ if (!isKey) throw invalid("entry x must be a 32-byte Base64URL key");
922
+ return x;
923
+ }
924
+ function importEntry(entry) {
925
+ if (!isObject(entry)) throw invalid("entry is not a JSON object");
926
+ if ("d" in entry) throw invalid("entry carries private key material (d)");
927
+ expectMember(entry, "kty", "OKP", true);
928
+ expectMember(entry, "crv", "Ed25519", true);
929
+ expectMember(entry, "use", "sig", false);
930
+ expectMember(entry, "alg", "EdDSA", false);
931
+ const kid = readKid(entry);
932
+ const x = readX(entry);
933
+ try {
934
+ const key = (0, import_node_crypto2.createPublicKey)({
935
+ key: { kty: "OKP", crv: "Ed25519", x },
936
+ format: "jwk"
937
+ });
938
+ return [kid, key];
939
+ } catch {
940
+ throw invalid("entry x is not an Ed25519 key");
941
+ }
942
+ }
943
+ function parseProfileJwks(document) {
944
+ let parsed;
945
+ try {
946
+ parsed = JSON.parse(document);
947
+ } catch {
948
+ throw invalid("is not JSON");
949
+ }
950
+ const entries = isObject(parsed) ? parsed.keys : void 0;
951
+ if (!Array.isArray(entries) || entries.length === 0) {
952
+ throw invalid("has no keys array");
953
+ }
954
+ const keys = /* @__PURE__ */ new Map();
955
+ for (const entry of entries) {
956
+ const [kid, key] = importEntry(entry);
957
+ if (keys.has(kid)) throw invalid("has a duplicated kid");
958
+ keys.set(kid, key);
959
+ }
960
+ return keys;
961
+ }
962
+
963
+ // src/jwks/readJwksCacheMaxAge.ts
964
+ var UNSIGNED_INTEGER = /^\+?[0-9]+$/;
965
+ var U64_MAX = 18446744073709551615n;
966
+ function readMaxAgeDirective(directive) {
967
+ const separator = directive.indexOf("=");
968
+ if (separator < 0) return void 0;
969
+ const name = directive.slice(0, separator).trim().toLowerCase();
970
+ const value = directive.slice(separator + 1).trim();
971
+ if (name !== "max-age" || !UNSIGNED_INTEGER.test(value)) return void 0;
972
+ const seconds = BigInt(value);
973
+ if (seconds > U64_MAX) return void 0;
974
+ return seconds > BigInt(PROFILE_JWKS_MAX_MAX_AGE_SECONDS) ? PROFILE_JWKS_MAX_MAX_AGE_SECONDS : Number(seconds);
975
+ }
976
+ function readJwksCacheMaxAge(cacheControl) {
977
+ let announced;
978
+ for (const directive of (cacheControl ?? "").split(",")) {
979
+ announced = readMaxAgeDirective(directive);
980
+ if (announced !== void 0) break;
981
+ }
982
+ const seconds = announced ?? PROFILE_JWKS_DEFAULT_MAX_AGE_SECONDS;
983
+ return Math.min(
984
+ Math.max(seconds, PROFILE_JWKS_MIN_MAX_AGE_SECONDS),
985
+ PROFILE_JWKS_MAX_MAX_AGE_SECONDS
986
+ );
987
+ }
988
+
989
+ // src/jwks/fetchProfileJwks.ts
990
+ var ProfileJwksFetchError = class extends Error {
991
+ constructor(problem) {
992
+ super(`profile_jwks_fetch_failed: ${problem}`);
993
+ this.name = "ProfileJwksFetchError";
994
+ }
995
+ };
996
+ async function readBounded(response) {
997
+ const declared = Number(response.headers.get("content-length") ?? "0");
998
+ if (declared > PROFILE_JWKS_MAX_BYTES) {
999
+ throw new ProfileJwksFetchError("body exceeds the size limit");
1000
+ }
1001
+ const chunks = [];
1002
+ let total = 0;
1003
+ for await (const chunk of response.body ?? []) {
1004
+ total += chunk.byteLength;
1005
+ if (total > PROFILE_JWKS_MAX_BYTES) {
1006
+ throw new ProfileJwksFetchError("body exceeds the size limit");
1007
+ }
1008
+ chunks.push(chunk);
1009
+ }
1010
+ return Buffer.concat(chunks).toString("utf8");
1011
+ }
1012
+ async function download(url) {
1013
+ try {
1014
+ return await fetch(url, {
1015
+ method: "GET",
1016
+ headers: { accept: "application/json" },
1017
+ redirect: "manual",
1018
+ signal: AbortSignal.timeout(PROFILE_JWKS_FETCH_TIMEOUT_SECONDS * 1e3)
1019
+ });
1020
+ } catch (error) {
1021
+ const detail = error instanceof Error ? error.message : String(error);
1022
+ throw new ProfileJwksFetchError(`request failed: ${detail}`);
1023
+ }
1024
+ }
1025
+ var fetchProfileJwks = async (url) => {
1026
+ const response = await download(url);
1027
+ if (response.status < 200 || response.status > 299) {
1028
+ await response.body?.cancel();
1029
+ throw new ProfileJwksFetchError(`status ${response.status}`);
1030
+ }
1031
+ const maxAgeSeconds = readJwksCacheMaxAge(response.headers.get("cache-control"));
1032
+ let body;
1033
+ try {
1034
+ body = await readBounded(response);
1035
+ } catch (error) {
1036
+ await response.body?.cancel().catch(() => void 0);
1037
+ if (error instanceof ProfileJwksFetchError) throw error;
1038
+ throw new ProfileJwksFetchError("body unreadable");
1039
+ }
1040
+ return { keys: parseProfileJwks(body), maxAgeSeconds };
1041
+ };
1042
+
1043
+ // src/jwks/readSignatureKeyVersion.ts
1044
+ function readSignatureKeyVersion(signatureHeader) {
1045
+ const protectedHeader = signatureHeader.split(".")[0] ?? "";
1046
+ try {
1047
+ const header = JSON.parse(
1048
+ Buffer.from(protectedHeader, "base64url").toString("utf8")
1049
+ );
1050
+ const kid = typeof header === "object" && header !== null ? header.kid : void 0;
1051
+ return typeof kid === "string" && isCanonicalKeyVersion(kid) ? kid : void 0;
1052
+ } catch {
1053
+ return void 0;
1054
+ }
1055
+ }
1056
+
1057
+ // src/jwks/jwksProfileSignatureVerifier.ts
1058
+ var JwksProfileSignatureVerifier = class {
1059
+ store;
1060
+ toleranceSeconds;
1061
+ expectedAudience;
1062
+ constructor(store, toleranceSeconds, expectedAudience) {
1063
+ this.store = store;
1064
+ this.toleranceSeconds = toleranceSeconds;
1065
+ this.expectedAudience = expectedAudience;
1066
+ Object.freeze(this);
1067
+ }
1068
+ /** Download the key set before serving; rejects when it cannot. */
1069
+ prefetch() {
1070
+ return this.store.prefetch();
1071
+ }
1072
+ /**
1073
+ * Verify the signed profile, refetching the JWKS once on an unknown,
1074
+ * canonical `kid`. Rejects with `ProfileSignatureError` like
1075
+ * `verifyAndDecodeProfile`.
1076
+ */
1077
+ async verifyAndDecode(profileHeader, signatureHeader, nowSeconds) {
1078
+ await this.store.refreshIfStale();
1079
+ const { generation } = this.store.current();
1080
+ try {
1081
+ return await this.#verifyWithCurrentKeys(profileHeader, signatureHeader, nowSeconds);
1082
+ } catch (error) {
1083
+ const deservesRefetch = error instanceof ProfileSignatureError && error.reason === "unknown_key" && readSignatureKeyVersion(signatureHeader) !== void 0;
1084
+ if (!deservesRefetch) throw error;
1085
+ if (!await this.store.refreshAfterUnknownKey(generation)) throw error;
1086
+ }
1087
+ return this.#verifyWithCurrentKeys(profileHeader, signatureHeader, nowSeconds);
1088
+ }
1089
+ #verifyWithCurrentKeys(profileHeader, signatureHeader, nowSeconds) {
1090
+ const verifier = new ProfileSignatureVerifier(
1091
+ this.store.current().keys,
1092
+ this.toleranceSeconds,
1093
+ this.expectedAudience
1094
+ );
1095
+ return verifyAndDecodeProfile(profileHeader, signatureHeader, verifier, nowSeconds);
1096
+ }
1097
+ };
1098
+
1099
+ // src/jwks/parseProfileJwksUrl.ts
1100
+ function invalid2(problem) {
1101
+ return new ProfileSignatureConfigurationError(
1102
+ `${PROFILE_JWKS_URL_ENV} ${problem}`
1103
+ );
1104
+ }
1105
+ function withDefaultScheme(configured) {
1106
+ if (configured.includes("://")) return configured;
1107
+ if (configured === "" || configured.startsWith("/")) {
1108
+ throw invalid2("is not an absolute URL");
1109
+ }
1110
+ return `https://${configured}`;
1111
+ }
1112
+ function checkScheme(url, allowInsecureHttp) {
1113
+ if (url.protocol === "https:") return;
1114
+ if (url.protocol === "http:" && allowInsecureHttp) {
1115
+ console.warn(
1116
+ `[mycelium-sdk] ${PROFILE_JWKS_URL_ENV} uses plain HTTP; development only`
1117
+ );
1118
+ return;
1119
+ }
1120
+ throw invalid2("must use https");
1121
+ }
1122
+ function withJwksPath(url) {
1123
+ if (url.pathname.endsWith(PROFILE_JWKS_PATH)) return url;
1124
+ if (/[?#]/.test(url.href)) {
1125
+ throw invalid2("must not carry a query or fragment");
1126
+ }
1127
+ try {
1128
+ return new URL(`${url.href.replace(/\/+$/, "")}${PROFILE_JWKS_PATH}`);
1129
+ } catch {
1130
+ throw invalid2("is not an absolute URL");
1131
+ }
1132
+ }
1133
+ function parseProfileJwksUrl(raw, allowInsecureHttp) {
1134
+ let url;
1135
+ try {
1136
+ url = new URL(withDefaultScheme(raw.trim()));
1137
+ } catch (error) {
1138
+ if (error instanceof ProfileSignatureConfigurationError) throw error;
1139
+ throw invalid2("is not an absolute URL");
1140
+ }
1141
+ if (url.username !== "" || url.password !== "") {
1142
+ throw invalid2("must not carry credentials");
1143
+ }
1144
+ checkScheme(url, allowInsecureHttp);
1145
+ return withJwksPath(url);
1146
+ }
1147
+
1148
+ // src/jwks/profileKeyStore.ts
1149
+ var systemClock = () => performance.now();
1150
+ var ProfileKeyStore = class {
1151
+ #url;
1152
+ #fetcher;
1153
+ #cooldownMs;
1154
+ #clock;
1155
+ #keys = /* @__PURE__ */ new Map();
1156
+ #generation = 0;
1157
+ #freshUntil;
1158
+ #lastAttempt;
1159
+ #inFlight;
1160
+ constructor(url, fetcher, cooldownSeconds, clock = systemClock) {
1161
+ this.#url = url;
1162
+ this.#fetcher = fetcher;
1163
+ this.#cooldownMs = cooldownSeconds * 1e3;
1164
+ this.#clock = clock;
1165
+ }
1166
+ get url() {
1167
+ return new URL(this.#url);
1168
+ }
1169
+ /** The trusted keys now, and the generation they belong to. */
1170
+ current() {
1171
+ return { keys: this.#trustedKeys(), generation: this.#generation };
1172
+ }
1173
+ /** The cached keys, or none once they outlived the maximum staleness. */
1174
+ #trustedKeys() {
1175
+ const outlived = this.#freshUntil !== void 0 && this.#clock() >= this.#freshUntil + PROFILE_JWKS_MAX_STALE_SECONDS * 1e3;
1176
+ return outlived ? /* @__PURE__ */ new Map() : this.#keys;
1177
+ }
1178
+ /** Fetch the set now; any failure rejects (startup must abort). */
1179
+ async prefetch() {
1180
+ await this.#inFlight?.catch(() => void 0);
1181
+ const fetching = this.#fetchAndStore();
1182
+ this.#inFlight = fetching.then(
1183
+ () => true,
1184
+ () => false
1185
+ );
1186
+ try {
1187
+ await fetching;
1188
+ } finally {
1189
+ this.#inFlight = void 0;
1190
+ }
1191
+ }
1192
+ /** Refresh when the cached set expired (or was never fetched). */
1193
+ async refreshIfStale() {
1194
+ const stale = this.#freshUntil === void 0 || this.#clock() >= this.#freshUntil;
1195
+ if (!stale) return;
1196
+ if (this.#generation > 0 && this.#inFlight !== void 0) return;
1197
+ await this.#refreshFrom(this.#generation);
1198
+ }
1199
+ /** Refetch after an unknown `kid`; `true` when newer keys are available. */
1200
+ refreshAfterUnknownKey(seenGeneration) {
1201
+ return this.#refreshFrom(seenGeneration);
1202
+ }
1203
+ async #refreshFrom(seenGeneration) {
1204
+ while (this.#inFlight !== void 0) {
1205
+ await this.#inFlight.catch(() => void 0);
1206
+ }
1207
+ if (this.#generation !== seenGeneration) return true;
1208
+ const coolingDown = this.#lastAttempt !== void 0 && this.#clock() - this.#lastAttempt < this.#retryIntervalMs();
1209
+ if (coolingDown) return false;
1210
+ this.#inFlight = this.#fetchAndStore().then(
1211
+ () => true,
1212
+ (error) => {
1213
+ logRefreshFailure(error);
1214
+ return false;
1215
+ }
1216
+ );
1217
+ try {
1218
+ return await this.#inFlight;
1219
+ } finally {
1220
+ this.#inFlight = void 0;
1221
+ }
1222
+ }
1223
+ /** The cooldown, shortened while no key set was ever stored. */
1224
+ #retryIntervalMs() {
1225
+ if (this.#generation > 0) return this.#cooldownMs;
1226
+ return Math.min(this.#cooldownMs, PROFILE_JWKS_EMPTY_RETRY_SECONDS * 1e3);
1227
+ }
1228
+ async #fetchAndStore() {
1229
+ let fetched;
1230
+ try {
1231
+ fetched = await this.#fetcher(new URL(this.#url));
1232
+ } finally {
1233
+ this.#lastAttempt = this.#clock();
1234
+ }
1235
+ this.#keys = new Map(fetched.keys);
1236
+ this.#generation += 1;
1237
+ this.#freshUntil = this.#clock() + fetched.maxAgeSeconds * 1e3;
1238
+ }
1239
+ };
1240
+ function logRefreshFailure(error) {
1241
+ const reason = error instanceof Error ? error.message : String(error);
1242
+ console.warn(
1243
+ `[mycelium-sdk] profile_signature.jwks outcome=refresh_failed reason=${reason}; keeping the last valid profile JWKS`
1244
+ );
1245
+ }
1246
+
1247
+ // src/profileSignatureConfig.ts
1248
+ var CANONICAL_POSITIVE_INTEGER2 = /^[1-9][0-9]*$/;
1249
+ function parseTolerance(env) {
1250
+ const raw = env[PROFILE_SIGNATURE_TOLERANCE_ENV];
1251
+ if (raw === void 0) return DEFAULT_PROFILE_SIGNATURE_TOLERANCE_SECONDS;
1252
+ const trimmed = raw.trim();
1253
+ const value = Number(trimmed);
1254
+ if (!CANONICAL_POSITIVE_INTEGER2.test(trimmed) || !(value <= MAX_PROFILE_SIGNATURE_TOLERANCE_SECONDS)) {
1255
+ throw new ProfileSignatureConfigurationError(
1256
+ `${PROFILE_SIGNATURE_TOLERANCE_ENV} must be an integer between 1 and ${MAX_PROFILE_SIGNATURE_TOLERANCE_SECONDS}`
1257
+ );
1258
+ }
1259
+ return value;
1260
+ }
1261
+ function parseAudience(env) {
1262
+ const raw = env[PROFILE_SIGNATURE_AUDIENCE_ENV];
1263
+ if (raw === void 0) return void 0;
1264
+ if (raw.trim() === "") {
1265
+ throw new ProfileSignatureConfigurationError(
1266
+ `${PROFILE_SIGNATURE_AUDIENCE_ENV} must not be empty`
1267
+ );
1268
+ }
1269
+ return raw;
1270
+ }
1271
+ function parseInsecureSwitch(env) {
1272
+ const raw = env[PROFILE_JWKS_ALLOW_INSECURE_HTTP_ENV]?.trim();
1273
+ if (raw === void 0 || raw === "false") return false;
1274
+ if (raw === "true") return true;
1275
+ throw new ProfileSignatureConfigurationError(
1276
+ `${PROFILE_JWKS_ALLOW_INSECURE_HTTP_ENV} must be true or false`
1277
+ );
1278
+ }
1279
+ function loadProfileSignatureVerifierFromEnv(env = process.env, fetcher = fetchProfileJwks) {
1280
+ const toleranceSeconds = parseTolerance(env);
1281
+ const audience = parseAudience(env);
1282
+ const allowInsecureHttp = parseInsecureSwitch(env);
1283
+ const rawUrl = env[PROFILE_JWKS_URL_ENV];
1284
+ if (rawUrl === void 0) return void 0;
1285
+ const url = parseProfileJwksUrl(rawUrl, allowInsecureHttp);
1286
+ if (audience === void 0) {
1287
+ throw new ProfileSignatureConfigurationError(
1288
+ `${PROFILE_SIGNATURE_AUDIENCE_ENV} is required when ${PROFILE_JWKS_URL_ENV} is set`
1289
+ );
1290
+ }
1291
+ const store = new ProfileKeyStore(
1292
+ url,
1293
+ fetcher,
1294
+ PROFILE_JWKS_REFETCH_COOLDOWN_SECONDS
1295
+ );
1296
+ return new JwksProfileSignatureVerifier(store, toleranceSeconds, audience);
1297
+ }
1298
+ async function prepareProfileSignatureVerifier(env = process.env, fetcher = fetchProfileJwks) {
1299
+ const verifier = loadProfileSignatureVerifierFromEnv(env, fetcher);
1300
+ await verifier?.prefetch();
1301
+ return verifier;
1302
+ }
1303
+
1304
+ // src/profileSignatureEnforcement.ts
1305
+ var SIGNATURE_REJECTION_DETAIL = "Unable to verify Mycelium profile";
1306
+ var SIGNATURE_INTERNAL_DETAIL = "Unable to check user identity. Please contact administrators";
1307
+ async function reportRejection(listener, reason) {
1308
+ try {
1309
+ await listener?.(reason);
1310
+ return true;
1311
+ } catch {
1312
+ return false;
1313
+ }
1314
+ }
1315
+ function singleValue(values, missingReason) {
1316
+ if (values !== void 0 && values.length > 1) {
1317
+ throw new ProfileSignatureError("duplicate_header");
1318
+ }
1319
+ const value = values?.[0];
1320
+ if (value === void 0 || value === "") {
1321
+ throw new ProfileSignatureError(missingReason);
1322
+ }
1323
+ return value;
1324
+ }
1325
+ function receivedValues(message, name) {
1326
+ const distinct = message.headersDistinct?.[name];
1327
+ if (distinct !== void 0) return distinct;
1328
+ const raw = message.rawHeaders;
1329
+ if (Array.isArray(raw) && raw.length > 0) {
1330
+ const values = raw.filter(
1331
+ (_value, index) => index % 2 === 1 && String(raw[index - 1]).toLowerCase() === name
1332
+ );
1333
+ return values.length === 0 ? void 0 : values;
1334
+ }
1335
+ const value = message.headers[name];
1336
+ if (value === void 0) return void 0;
1337
+ return Array.isArray(value) ? value : [value];
1338
+ }
1339
+ function distinctValues(message, name) {
1340
+ return receivedValues(message, name)?.flatMap(
1341
+ (value) => value.split(",").map((part) => part.trim())
1342
+ );
1343
+ }
1344
+ async function verifyRequestProfile(message, verifier, onRejected) {
1345
+ try {
1346
+ const profileHeader = singleValue(
1347
+ distinctValues(message, DEFAULT_PROFILE_KEY),
1348
+ "missing_profile"
1349
+ );
1350
+ const signatureHeader = singleValue(
1351
+ distinctValues(message, DEFAULT_PROFILE_SIGNATURE_KEY),
1352
+ "missing_signature"
1353
+ );
1354
+ const profile = await verifier.verifyAndDecode(
1355
+ profileHeader,
1356
+ signatureHeader
1357
+ );
1358
+ return { ok: true, profile };
1359
+ } catch (error) {
1360
+ if (error instanceof ProfileSignatureError) {
1361
+ if (!await reportRejection(onRejected, error.reason)) {
1362
+ return { ok: false, status: 500, detail: SIGNATURE_INTERNAL_DETAIL };
1363
+ }
1364
+ return { ok: false, status: 403, detail: SIGNATURE_REJECTION_DETAIL };
1365
+ }
1366
+ await reportRejection(onRejected, "internal_error");
1367
+ return { ok: false, status: 500, detail: SIGNATURE_INTERNAL_DETAIL };
1368
+ }
1369
+ }
676
1370
  // Annotate the CommonJS export names for ESM import in node:
677
1371
  0 && (module.exports = {
678
1372
  AccountMetaKeySchema,
@@ -680,32 +1374,71 @@ function formatZodError(error) {
680
1374
  DEFAULT_EMAIL_KEY,
681
1375
  DEFAULT_MYCELIUM_ROLE_KEY,
682
1376
  DEFAULT_PROFILE_KEY,
1377
+ DEFAULT_PROFILE_SIGNATURE_KEY,
1378
+ DEFAULT_PROFILE_SIGNATURE_TOLERANCE_SECONDS,
683
1379
  DEFAULT_REQUEST_ID_KEY,
684
1380
  DEFAULT_SCOPE_KEY,
685
1381
  DEFAULT_TENANT_ID_KEY,
686
1382
  InsufficientLicensesError,
687
1383
  InsufficientPrivilegesError,
1384
+ JwksProfileSignatureVerifier,
688
1385
  LicensedResourceSchema,
689
1386
  LicensedResourcesSchema,
1387
+ MAX_PROFILE_SIGNATURE_BYTES,
1388
+ MAX_PROFILE_SIGNATURE_TOLERANCE_SECONDS,
690
1389
  MyceliumError,
691
1390
  OwnerSchema,
1391
+ PROFILE_JWKS_ALLOW_INSECURE_HTTP_ENV,
1392
+ PROFILE_JWKS_DEFAULT_MAX_AGE_SECONDS,
1393
+ PROFILE_JWKS_EMPTY_RETRY_SECONDS,
1394
+ PROFILE_JWKS_FETCH_TIMEOUT_SECONDS,
1395
+ PROFILE_JWKS_MAX_BYTES,
1396
+ PROFILE_JWKS_MAX_MAX_AGE_SECONDS,
1397
+ PROFILE_JWKS_MAX_STALE_SECONDS,
1398
+ PROFILE_JWKS_MIN_MAX_AGE_SECONDS,
1399
+ PROFILE_JWKS_PATH,
1400
+ PROFILE_JWKS_REFETCH_COOLDOWN_SECONDS,
1401
+ PROFILE_JWKS_URL_ENV,
1402
+ PROFILE_SIGNATURE_AUDIENCE_ENV,
1403
+ PROFILE_SIGNATURE_CONFIG_INVALID_CODE,
1404
+ PROFILE_SIGNATURE_INVALID_CODE,
1405
+ PROFILE_SIGNATURE_TOLERANCE_ENV,
692
1406
  Permission,
693
1407
  PermissionSchema,
694
1408
  Profile,
695
1409
  ProfileDecodingError,
1410
+ ProfileJwksFetchError,
1411
+ ProfileKeyStore,
696
1412
  ProfileMetaSchema,
697
1413
  ProfileSchema,
1414
+ ProfileSignatureConfigurationError,
1415
+ ProfileSignatureError,
1416
+ ProfileSignatureVerifier,
1417
+ SIGNATURE_INTERNAL_DETAIL,
1418
+ SIGNATURE_REJECTION_DETAIL,
698
1419
  TenantOwnershipSchema,
699
1420
  TenantsOwnershipSchema,
700
1421
  VerboseStatusSchema,
701
1422
  compressAndEncodeProfileToBase64,
702
1423
  decodeAndDecompressProfileFromBase64,
1424
+ fetchProfileJwks,
1425
+ isCanonicalKeyVersion,
703
1426
  licensedResourceFromUrlString,
1427
+ loadProfileSignatureVerifierFromEnv,
1428
+ parseProfileJwks,
1429
+ parseProfileJwksUrl,
704
1430
  permissionFromInt,
705
1431
  permissionToInt,
1432
+ prepareProfileSignatureVerifier,
1433
+ profileHeaderHash,
1434
+ readJwksCacheMaxAge,
1435
+ readSignatureKeyVersion,
706
1436
  safeDecodeAndDecompressProfileFromBase64,
707
1437
  tenantOwnershipFromUrlString,
708
1438
  toLicensesVector,
709
- toOwnershipVector
1439
+ toOwnershipVector,
1440
+ verifyAndDecodeProfile,
1441
+ verifyProfileSignature,
1442
+ verifyRequestProfile
710
1443
  });
711
1444
  //# sourceMappingURL=index.cjs.map