@tstdl/base 0.83.1 → 0.83.2

package/.eslintrc.cjs

@@ -1,4 +1,5 @@
 module.exports = {
+  root: true,
   env: {
     browser: true,
     es2022: true,

package/authentication/server/authentication.service.js

@@ -271,11 +271,10 @@ let AuthenticationService = class AuthenticationService2 {
   }
   async deriveSigningSecrets() {
     const key = await (0, import_cryptography.importPbkdf2Key)(this.secret);
-    const hash = await globalThis.crypto.subtle.deriveBits({ name: "PBKDF2", hash: "SHA-512", iterations: 5e5, salt: new Uint8Array() }, key, SIGNING_SECRETS_LENGTH * 3);
-    const bufferSize = SIGNING_SECRETS_LENGTH / 8;
-    this.derivedTokenSigningSecret = new Uint8Array(hash.slice(0, bufferSize));
-    this.derivedRefreshTokenSigningSecret = new Uint8Array(hash.slice(bufferSize, bufferSize * 2));
-    this.derivedSecretResetTokenSigningSecret = new Uint8Array(hash.slice(bufferSize * 2));
+    const [derivedTokenSigningSecret, derivedRefreshTokenSigningSecret, derivedSecretResetTokenSigningSecret] = await (0, import_cryptography.deriveBytesMultiple)(3, SIGNING_SECRETS_LENGTH / 8, { name: "PBKDF2", hash: "SHA-512", iterations: 5e5, salt: new Uint8Array() }, key);
+    this.derivedTokenSigningSecret = derivedTokenSigningSecret;
+    this.derivedRefreshTokenSigningSecret = derivedRefreshTokenSigningSecret;
+    this.derivedSecretResetTokenSigningSecret = derivedSecretResetTokenSigningSecret;
   }
   async getHash(secret, salt) {
     const key = await (0, import_cryptography.importPbkdf2Key)(secret);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.83.1",
+  "version": "0.83.2",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/types.d.ts

@@ -83,10 +83,10 @@ type FromEntriesEntryValue<T extends readonly (readonly [any, any])[], K> = Extr
 export type FromEntries<T> = T extends readonly (readonly [infer Key, any])[] ? {
     [K in Cast<Key, PropertyKey>]: Fallback<FromEntriesEntryValue<T, K>, T[number][1]>;
 } : never;
-export type Writable<T> = {
+export type Writable<T> = T extends readonly (infer U)[] ? U[] : {
     -readonly [P in keyof T]: T[P];
 };
-export type DeepWritable<T> = {
+export type DeepWritable<T> = T extends readonly (infer U)[] ? DeepWritable<U>[] : {
     -readonly [P in keyof T]: DeepWritable<T[P]>;
 };
 export type RequiredKeys<T> = {

package/utils/cryptography.d.ts

@@ -1,4 +1,5 @@
 import type { BinaryData, TypedExtract } from '../types.js';
+import type { ReadonlyTuple } from 'type-fest';
 export type AesMode = 'CBC' | 'CTR' | 'GCM' | 'KW';
 export type EcdsaCurve = 'P-256' | 'P-384' | 'P-521';
 export type HashAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
@@ -104,3 +105,13 @@ export declare function generateEcdsaKey(curve: EcdsaCurve, extractable?: boolea
  * @param extractable whether the key can be used for exportKey
  */
 export declare function generatePbkdf2Key(extractable?: boolean): Promise<CryptoKey>;
+type AlgorithmParameter = Parameters<typeof globalThis.crypto.subtle.deriveBits>['0'];
+/**
+ * derive multiply byte arrays
+ * @param count how many Uint8Arrays to dervice
+ * @param length length of each Uint8Array in bytes
+ * @param algorithm algorithm to derive with
+ * @param baseKey key to derive from
+ */
+export declare function deriveBytesMultiple<C extends number>(count: C, length: number, algorithm: AlgorithmParameter, baseKey: CryptoKey): Promise<ReadonlyTuple<Uint8Array, C>>;
+export {};

package/utils/cryptography.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var cryptography_exports = {};
 __export(cryptography_exports, {
   decrypt: () => decrypt,
+  deriveBytesMultiple: () => deriveBytesMultiple,
   digest: () => digest,
   encrypt: () => encrypt,
   generateEcdsaKey: () => generateEcdsaKey,
@@ -31,6 +32,7 @@ __export(cryptography_exports, {
   verify: () => verify
 });
 module.exports = __toCommonJS(cryptography_exports);
+var import_array = require("./array/array.js");
 var import_base64 = require("./base64.js");
 var import_encoding = require("./encoding.js");
 var import_random = require("./random.js");
@@ -120,6 +122,11 @@ async function generatePbkdf2Key(extractable = false) {
   const key = (0, import_random.getRandomBytes)(16);
   return importPbkdf2Key(key, extractable);
 }
+async function deriveBytesMultiple(count, length, algorithm, baseKey) {
+  const totalBits = count * length * 8;
+  const bytes = await globalThis.crypto.subtle.deriveBits(algorithm, baseKey, totalBits);
+  return (0, import_array.createArray)(count, (index) => new Uint8Array(bytes.slice(index * length, index * length + length)));
+}
 function isBinaryKey(key) {
   return (0, import_type_guards.isDefined)(key.byteLength);
 }