WIP

Author: CMCDragonkai

test-bootstrapping.ts

@@ -85,17 +85,19 @@ async function main () {
   // 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({
+  const privateKeyJSON = {
     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;
+  };
+
+  // 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(privateKeyJSON) as jose.KeyLike;
 
   const publicKey = await jose.importJWK({
     alg: 'EdDSA',
@@ -135,23 +137,6 @@ async function main () {
   // 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"
-  };
-
-  const testJWKS = JSON.stringify(testJWK);
-
-  console.log([...Buffer.from(testJWKS)]);
 
   /*
   THIS IS THE JWE HEADER!!
@@ -175,9 +160,203 @@ async function main () {
   Wait a minute... what is this?
   Oh so this is the key
 
+  A CEK is encrypted with PBKDF2.
+  A CEK is the JWK that we are encrypting.
+  The CEK in JSON array notation is ...(don't we need to turn it into JSON?)
+
+  After we have encrypted it, we create a BASE64URL encoding of the encrypted data.
+  This gives us another base64 url string...
+
+  Also an initialisation vector. Another base64url becomes another string.
+
+  Additional data encryption parameter is ASCII(BASE64URL(UTF8(Protected header)))
+
+  Then more is done...
+
+  The JWE Compact Serialization of
+  this result, as defined in Section 7.1 of [JWE], is the string
+  BASE64URL(UTF8(JWE Protected Header)) || '.' || BASE64URL(JWE
+  Encrypted Key) || '.' || BASE64URL(JWE Initialization Vector) || '.'
+  || BASE64URL(JWE Ciphertext) || '.' || BASE64URL(JWE Authentication
+  Tag).
+
+  I see, so it's a concatenation of all of this at the very end.
+  And this is known as a compact serialisation.
+
+  Compact serialisation is the common serialisation. It's all just a compact string?
+
+  Flattened is a JSON structure, but flattened? But it's still JSON.
+
+  It's not optomised for compactness nor URL safe. Compact representation is something you can send to somewhere.
+
+  I think we want the general serialisation. We are going to store it on disk.
+  But it's also dseigned to be sent to multiple recipients.
+
+  We only have 1 recipient, ourselves... so maybe flattened serialisation is better.
+
+  JWE compact only has 1 recipient
+  JWE flattened is only for 1 recipient
+
+  Why is the key also encrypted?
+  I guess cause a symmetric key is being used to enrypt the thing
+  But the key itself is encrypted
+  Then the symmetric key is used to decrypt the actual ciphertext
+
+  This is different from before...
+  The assumption was that a root password -> PBKDF2 to key, use key to encrypt
+  But we don't keep the key around.
+
+  Now with JWE, root password -> PBKDF2, gives us a key, that key itself is then used to encrypt the ciphertext.
+
+  The content encryption key is a symmetric algorithm.
+
+  The alg defines an encryptiong algorithm to encrypt the content encryption key.
+
+  It is a key wrapping algorithm which wraps teh CEK.
+
+  Wait... are we saying that the CEK is the ciphertext or something else??
+
+  jwk+json
+
+  Ok so we could have a JWE that has both A256GCM as the encryption of the content, and RSA-OAEP for key wrapping.
+  Symmetric keys are used to encrypt the content.
+  Faster than asymmetric.
+
+  Ok I understand now. A JWE has to contain both the encrypted symmetric key and the encrypted content with the symmetric key.
+
+  This does mean we are doing things slightly differently.
+
+  Technically in our case, since the symmetric key is generated from a PBKCDF2, we could just use the password to encrypt the content.
+
+  We don't actually even need tokkeep the encrypted symmetric key. But due to the format, it is expected to be there...
+
+  We have a JWK now, I want to encrypt this as an encrypted JWK, stored as a JWE.
+
   */
 
 
+  // 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"
+  // };
+  // const testJWKS = JSON.stringify(testJWK);
+
+  // console.log([...Buffer.from(testJWKS)]);
+
+  const privateKeyJSONstring = JSON.stringify(privateKeyJSON);
+
+  // Binary representation from text
+  const jwe = new jose.FlattenedEncrypt(Buffer.from(privateKeyJSONstring, 'utf-8'));
+
+  // console.log(jwe);
+
+  // Used to determine the CEK?
+  // What does even mean?
+  // PBES2 means "password based encryption scheme 2"
+
+  // PBES2 is pas word based encryption
+  // it means using PBKDF2
+  // HS256 means SHA-256  as the HMAC (used as the pseudo random function)
+  // A256KW means AES 256 bit Key Wrap (used to actually encrypt)
+  // The result of encrypting a CEK wiusing the result of the pass word based encryption
+  // And coresponding key wrapping algoritm
+  // p2s is the salt input - 8 or more octets, generate random salt for every encryption operation?
+  // p2c is the count iteration - minimum of 1000 is preferred here
+
+  // We could do this directly without going through jose though
+
+  // A256GCM is better is used to actually encrypt the data
+  // Why not use HS512?
+  // AES256KW is used to encrypt the CEK
+
+  // Is the salt meant to be random?
+  // If so, does the user need to remember this salt?
+  // Because PBKDF2 will require this salt...
+  // Plus if we are decrypting it, we need to pass in the salt
+
+  // p2s is the salt input - 8 or more octets, generate random salt for every encryption operation?
+  // It doesn't matter what it is
+
+  const randomSalt = getRandomBytesSync(8);
+
+  // JOSE HEADER
+  jwe.setProtectedHeader({
+    alg: 'PBES2-HS512+A256KW',
+    enc: 'A256GCM', // symmetric encryption algo
+    cty: 'jwk+json' // this is a encrypted JWK
+  });
+
+  // These parameters only apply here
+  // jwe.setKeyManagementParameters(
+  //   {
+  //     p2s: new Uint8Array(),
+  //     // p2s: randomSalt,
+  //     p2c: 1000
+  //   }
+  // );
+
+  // PBES2 Salt Input must be 8 or more octets
+
+  const key = await noblePbkdf2.pbkdf2Async(
+    // Using HMAC 512
+    nobleSha512,
+    Buffer.from('some password'),
+    // This is how the salt is "defined"
+    // note how we join the alg, then a null character
+    // then finally the actual salt being specified
+    // It appears to be "saved" in the actual thing
+    // Buffer.from(''),
+    Buffer.concat([
+      Buffer.from('PBES2-HS512+A256KW', 'utf-8'),
+      Buffer.from([0]),
+      // randomSalt
+    ]),
+    {
+      c: 1000,
+      // It is 32 bytes, because we want a A256KW
+      dkLen: 64
+    }
+  );
+
+  console.log('key length', key.length);
+
+  const encryptedJWK = await jwe.encrypt(key);
+
+  console.log('ENCRYPTED JWK', encryptedJWK);
+
+  const decryptedJWK = await jose.flattenedDecrypt(
+    encryptedJWK,
+    key
+  );
+
+  console.log('DECRYPTED JWK', decryptedJWK);
+
+  console.log(decryptedJWK.plaintext.toString());
+
+
+
+  // // This has to use a key to encrypt
+  // // which key can we use for this?
+  // // Do we need to create a CEK to do this?
+  // const result = await jwe.encrypt(Buffer.from('some password'));
+
+  // I think we actually need to create a key here...
+  // not just anything... how do we use a particular key to do this?
+  // It's a password
+  // console.log(result);
+
+
+
+  // A "cty" (content type) Header Parameter value of "jwk+json" MUST be used to indicate that the content of the JWE is a JWK
 
 
 
@@ -212,7 +391,6 @@ async function main () {
 
 
 
-
   // The ed25519 key is not intended for encryption
   // We can "derive" a x25519 key to do the encryption
   // This avoids using 2 keys