WIP

Author: CMCDragonkai

package-lock.json

@@ -90,6 +90,7 @@
     "@matrixai/workers": "^1.3.6",
     "@noble/ed25519": "^1.7.1",
     "@noble/hashes": "^1.1.2",
+    "@scure/bip39": "^1.1.0",
     "ajv": "^7.0.4",
     "bip39": "^3.0.3",
     "canonicalize": "^1.0.5",

package.json

@@ -1,10 +1,26 @@
+import * as jest from 'jest';
+import * as jose from 'jose';
 import { webcrypto } from 'crypto';
-import * as bip39 from 'bip39';
+import * as bip39 from '@scure/bip39';
+import { wordlist } from '@scure/bip39/wordlists/english';
+import * as utils from '@noble/hashes/utils';
 import * as nobleEd from '@noble/ed25519';
+import * as base64 from 'multiformats/bases/base64';
 import * as noblePbkdf2 from '@noble/hashes/pbkdf2';
-import * as nobleSha256 from '@noble/hashes/sha256';
+import { sha512 as nobleSha512 } from '@noble/hashes/sha512';
+
+// @ts-ignore - this overrides the random source used by @noble and @scure libraries
+utils.randomBytes = (size: number = 32) => getRandomBytesSync(size);
+nobleEd.utils.randomBytes = (size: number = 32) => getRandomBytesSync(size);
+
+// Note that NodeJS Buffer is also Uint8Array
+function getRandomBytesSync(size: number): Uint8Array {
+  console.log('CUSTOM CALLED');
+  const randomArray = webcrypto.getRandomValues(new Uint8Array(size));
+  return randomArray;
+  // return Buffer.from(randomArray, randomArray.byteOffset, randomArray.byteLength);
+}
 
-// webcrypto is used for symmetric encryption
 
 /**
  * Opaque types are wrappers of existing types
@@ -15,29 +31,195 @@ declare const brand: unique symbol;
 
 type RecoveryCode = Opaque<'RecoveryCode', string>;
 
-function getRandomBytesSync(size: number): Buffer {
-  const randomArray = webcrypto.getRandomValues(new Uint8Array(size));
-  return Buffer.from(randomArray, randomArray.byteOffset, randomArray.byteLength);
-}
+
+// webcrypto is used for symmetric encryption
 
 function generateRecoveryCode(size: 12 | 24 = 24): RecoveryCode {
   if (size === 12) {
-    return bip39.generateMnemonic(128, getRandomBytesSync) as RecoveryCode;
+    return bip39.generateMnemonic(wordlist, 128) as RecoveryCode;
   } else if (size === 24) {
-    return bip39.generateMnemonic(256, getRandomBytesSync) as RecoveryCode;
+    return bip39.generateMnemonic(wordlist, 256) as RecoveryCode;
   }
   throw RangeError(size);
 }
 
+async function generateDeterministicKeyPair(recoveryCode: string) {
+  // This uses BIP39 standard, the result is 64 byte seed
+  // This is deterministic, and does not use any random source
+  const recoverySeed = await bip39.mnemonicToSeed(recoveryCode);
+  // Slice it to 32 bytes, as ed25519 private key is only 32 bytes
+  const privateKey = recoverySeed.slice(0, 32);
+  const publicKey = await nobleEd.getPublicKey(privateKey);
+  return {
+    publicKey,
+    privateKey
+  };
+}
+
 async function main () {
 
   const recoveryCode = generateRecoveryCode(24);
 
-  console.log(recoveryCode);
+  console.log('RECOVERY CODE', recoveryCode);
 
-  // console.log(nobleEd.utils.randomPrivateKey());
+  const rootKeyPair = await generateDeterministicKeyPair(recoveryCode);
+
+  console.log('ROOT KEY PAIR', rootKeyPair);
+
+  // How do we turn it into a JWK?
+  // unless you use webcrypto to do this
+  // This is a bit weird
+
+  // webcrypto.subtle.importKey(
+  //   'raw',
+  //   rootKeyPair.privateKey,
+  //   'Ed25519',
+  //   true,
+  //   ['sign']
+  // );
+
+  // JWK uses base64url encoding, not base64 encoding
+  const d = base64.base64url.baseEncode(rootKeyPair.privateKey);
+  const x = base64.base64url.baseEncode(rootKeyPair.publicKey);
+
+  // This will import into "opaque" keylike objects
+  // These can be used by jose operations
+
+  // If you pass in `d` you must pass in `x`, this gives you a private key
+  // If you pass only `x`, this gives you a public key JWK
+  const privateKey = await jose.importJWK({
+    alg: 'EdDSA',
+    kty: 'OKP', // Octet key pair
+    crv: 'Ed25519', // Curve
+    d: d, // Private key
+    x: x, // Public key
+    ext: true, // Extractable (always true in nodejs)
+    key_ops: ['sign', 'verify'], // Key operations
+  }) as jose.KeyLike;
+
+  const publicKey = await jose.importJWK({
+    alg: 'EdDSA',
+    kty: 'OKP', // Octet key pair
+    crv: 'Ed25519', // Curve
+    x: x, // Public key
+    ext: true, // Extractable (always true in nodejs)
+    key_ops: ['verify'], // Key operations
+  }) as jose.KeyLike;
+
+  // We can alo use x5u parameter
+  // But it is a URI pointing to it
+  // We can do this.. by providing a URI to a pk resource
+  // Like pk:://<NodeId>/certificate
+  // A URI resource
+  // The key in the first certificate
+  // must match the public key represented by other members of JWK
+  // Also x5c parameter too
+
+  console.log('PRIVATE', privateKey);
+  console.log('PUBLIC', publicKey);
+
+  // JOSE should also have overrides secrets...
+
+  // Private Key PEM
+  console.log(await jose.exportPKCS8(privateKey));
+
+  // Public Key PEM
+  console.log(await jose.exportSPKI(publicKey));
+
+
+  // This does not "preserve" all the JWK information
+  // I actually have constructed it already above
+  console.log(await jose.exportJWK(privateKey));
+
+  // We shouldn't use this
+  // we can use the above to maintain information about the JWK
+  console.log(await jose.exportJWK(publicKey));
+
+  const testJWK = {
+    "kty":"RSA",
+    "kid":"juliet@capulet.lit",
+    "use":"enc",
+    "n":"t6Q8PWSi1dkJj9hTP8hNYFlvadM7DflW9mWepOJhJ66w7nyoK1gPNqFMSQRyO125Gp-TEkodhWr0iujjHVx7BcV0llS4w5ACGgPrcAd6ZcSR0-Iqom-QFcNP8Sjg086MwoqQU_LYywlAGZ21WSdS_PERyGFiNnj3QQlO8Yns5jCtLCRwLHL0Pb1fEv45AuRIuUfVcPySBWYnDyGxvjYGDSM-AqWS9zIQ2ZilgT-GqUmipg0XOC0Cc20rgLe2ymLHjpHciCKVAbY5-L32-lSeZO-Os6U15_aXrk9Gw8cPUaX1_I8sLGuSiVdt3C_Fn2PZ3Z8i744FPFGGcG1qs2Wz-Q",
+    "e":"AQAB",
+    "d":"GRtbIQmhOZtyszfgKdg4u_N-R_mZGU_9k7JQ_jn1DnfTuMdSNprTeaSTyWfSNkuaAwnOEbIQVy1IQbWVV25NY3ybc_IhUJtfri7bAXYEReWaCl3hdlPKXy9UvqPYGR0kIXTQRqns-dVJ7jahlI7LyckrpTmrM8dWBo4_PMaenNnPiQgO0xnuToxutRZJfJvG4Ox4ka3GORQd9CsCZ2vsUDmsXOfUENOyMqADC6p1M3h33tsurY15k9qMSpG9OX_IJAXmxzAh_tWiZOwk2K4yxH9tS3Lq1yX8C1EWmeRDkK2ahecG85-oLKQt5VEpWHKmjOi_gJSdSgqcN96X52esAQ",
+    "p":"2rnSOV4hKSN8sS4CgcQHFbs08XboFDqKum3sc4h3GRxrTmQdl1ZK9uw-PIHfQP0FkxXVrx-WE-ZEbrqivH_2iCLUS7wAl6XvARt1KkIaUxPPSYB9yk31s0Q8UK96E3_OrADAYtAJs-M3JxCLfNgqh56HDnETTQhH3rCT5T3yJws",
+    "q":"1u_RiFDP7LBYh3N4GXLT9OpSKYP0uQZyiaZwBtOCBNJgQxaj10RWjsZu0c6Iedis4S7B_coSKB0Kj9PaPaBzg-IySRvvcQuPamQu66riMhjVtG6TlV8CLCYKrYl52ziqK0E_ym2QnkwsUX7eYTB7LbAHRK9GqocDE5B0f808I4s",
+    "dp":"KkMTWqBUefVwZ2_Dbj1pPQqyHSHjj90L5x_MOzqYAJMcLMZtbUtwKqvVDq3tbEo3ZIcohbDtt6SbfmWzggabpQxNxuBpoOOf_a_HgMXK_lhqigI4y_kqS1wY52IwjUn5rgRrJ-yYo1h41KR-vz2pYhEAeYrhttWtxVqLCRViD6c",
+    "dq":"AvfS0-gRxvn0bwJoMSnFxYcK1WnuEjQFluMGfwGitQBWtfZ1Er7t1xDkbN9GQTB9yqpDoYaN06H7CFtrkxhJIBQaj6nkF5KKS3TQtQ5qCzkOkmxIe3KRbBymXxkb5qwUpX5ELD5xFc6FeiafWYY63TmmEAu_lRFCOJ3xDea-ots",
+    "qi":"lSQi-w9CpyUReMErP1RsBLk7wNtOvs5EQpPqmuMvqW57NBUczScEoPwmUqqabu9V0-Py4dQ57_bapoKRu1R90bvuFnU63SHWEFglZQvJDMeAvmj4sm-Fp0oYu_neotgQ0hzbI5gry7ajdYy9-2lNx_76aBZoOUu9HCJ-UsfSOI8"
+  };
 
-  // Need to seed a random source with this
+  const testJWKS = JSON.stringify(testJWK);
+
+  console.log([...Buffer.from(testJWKS)]);
+
+  /*
+  THIS IS THE JWE HEADER!!
+
+  {
+    alg: "PBES2-HS256+A128KW", // algorithm used for encryption
+    p2s: "...", // salt
+    p2c: "...", // iteration count
+    enc: "A1128CBC-HS256", // authenticated encryption
+    cty: "jwk+json", // It is an application/jwk+json type
+  }
+
+  The JWE protected header is then base64url(utf8(json stringify)) encoded
+
+  SOMESTRING...
+
+  CONTENT encryption key is generated... (or derived from password)
+  It's 256 bits
+
+  The content encryption key is what is used to encrypt the data the JWK string.
+  Wait a minute... what is this?
+  Oh so this is the key
+
+  */
+
+
+
+
+
+
+  // To do this
+  // we can use webcrypto
+  // OR we can use jose
+
+
+  // Ok we got the root key pair
+  // Encode as JWK so it can be saved on disk
+  // Encrypt the private key with a root password using a symmetric cipher
+  // To do this, the root password must be hashed with a key derivation function
+  // Which is then used to encrypt the private key JWK file
+  // We can also use 2 files
+  // Or 1 file being JWKS - a set of JWKs
+  // The reason to use 2 files, is that the public key doesn't need encryption
+
+
+
+  // Now with the ed25519 master key
+  // We should be able to "derive/generate" subkeys DEKs
+  // These DEKs - the database one in particular should be used
+  // to encrypt the database
+  // The DEKs can be randomly generated, they do not need to be "connected"
+  // to the Master Key
+  // But the DEK when outside the DB, needs to be stored on disk
+  // In particular the DEK used for the DB must be encrypted with the root key
+  // To do this the root key can be directly used for encryption
+  // Converted to X25519 to encrypt
+  // Or use an HKDF over the ed25519 key to do so...
+
+
+
+
+  // The ed25519 key is not intended for encryption
+  // We can "derive" a x25519 key to do the encryption
+  // This avoids using 2 keys
+  // Some places argue to create a second key to do this
+
+
+  // console.log(nobleEd.utils.randomPrivateKey());
 
 }