add base64url interface

README.md

@@ -40,6 +40,7 @@ You can use predefined functions to select the type of hash to generate.
 Hash.create(HASH.SHA256).update('string').hex();
 Hash.create(HASH.SHA256).update('string').binary();
 Hash.create(HASH.SHA256).update('string').base64();
+Hash.create(HASH.SHA256).update('string').base64url();
 Hash.create(HASH.SHA256).update('string').buffer();
 Hash.create(HASH.SHA256).update('string').uint8Array();
 ```
@@ -103,6 +104,9 @@ Cipher.create(CIPHER.AES_256_CBC, key).decrypt.binary(encrypted, iv);
 Cipher.create(CIPHER.AES_256_CBC, key).encrypt.base64('string', iv);
 Cipher.create(CIPHER.AES_256_CBC, key).decrypt.base64(encrypted, iv);
 
+Cipher.create(CIPHER.AES_256_CBC, key).encrypt.base64url('string', iv);
+Cipher.create(CIPHER.AES_256_CBC, key).decrypt.base64url(encrypted, iv);
+
 Cipher.create(CIPHER.AES_256_CBC, key).encrypt.buffer(Buffer.from('string'), iv);
 Cipher.create(CIPHER.AES_256_CBC, key).decrypt.buffer(encrypted, iv);
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jihyunlab/crypto",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "JihyunLab Crypto.",
   "license": "MIT",
   "author": "JihyunLab <info@jihyunlab.com> (https://jihyunlab.com)",
@@ -33,12 +33,12 @@
     "node": ">=16"
   },
   "devDependencies": {
-    "@jihyunlab/eslint-config": "^1.1.1",
-    "@jihyunlab/prettier-config": "^1.1.1",
-    "@types/jest": "^29.5.8",
-    "@types/node": "^20.9.0",
+    "@jihyunlab/eslint-config": "^1.1.2",
+    "@jihyunlab/prettier-config": "^1.1.2",
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.10.6",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.1",
-    "typescript": "^5.2.2"
+    "typescript": "^5.3.3"
   }
 }

src/cryptos/aead/crypto.aead.ts

@@ -46,6 +46,15 @@ export class Aead {
       return { text: string.text, tag: string.tag };
     },
 
+    base64url(text: string, nonce: string | Buffer, inputEncoding?: crypto.Encoding) {
+      if (!inputEncoding) {
+        inputEncoding = 'utf8';
+      }
+
+      const string = this.string(text, nonce, inputEncoding, 'base64url');
+      return { text: string.text, tag: string.tag };
+    },
+
     uint8Array(text: Buffer, nonce: string | Buffer) {
       const buffer = this.buffer(text, nonce);
       return { text: new Uint8Array(buffer.text), tag: buffer.tag };
@@ -148,6 +157,10 @@ export class Aead {
       return this.string(text, tag, nonce, 'base64', outputEncoding);
     },
 
+    base64url(text: string, tag: Buffer, nonce: string | Buffer, outputEncoding?: crypto.Encoding) {
+      return this.string(text, tag, nonce, 'base64url', outputEncoding);
+    },
+
     uint8Array(text: Uint8Array, tag: Buffer, nonce: string | Buffer) {
       const buffer = this.buffer(Buffer.from(text), tag, nonce);
       return buffer;

src/cryptos/cipher/crypto.cipher.ts

@@ -34,6 +34,14 @@ export class Cipher {
       return this.string(text, iv, inputEncoding, 'base64');
     },
 
+    base64url(text: string, iv: string | Buffer | null, inputEncoding?: crypto.Encoding) {
+      if (!inputEncoding) {
+        inputEncoding = 'utf8';
+      }
+
+      return this.string(text, iv, inputEncoding, 'base64url');
+    },
+
     uint8Array(text: Buffer, iv: string | Buffer | null) {
       const buffer = this.buffer(text, iv);
       return new Uint8Array(buffer);
@@ -84,6 +92,10 @@ export class Cipher {
       return this.string(text, iv, 'base64', outputEncoding);
     },
 
+    base64url(text: string, iv: string | Buffer | null, outputEncoding?: crypto.Encoding) {
+      return this.string(text, iv, 'base64url', outputEncoding);
+    },
+
     uint8Array(text: Uint8Array, iv: string | Buffer | null) {
       const buffer = this.buffer(Buffer.from(text), iv);
       return buffer;

src/cryptos/hash/crypto.hash.ts

@@ -26,6 +26,10 @@ export class Hash {
     return this.digest('base64').toString();
   }
 
+  base64url() {
+    return this.digest('base64url').toString();
+  }
+
   digest(encoding?: crypto.BinaryToTextEncoding) {
     let result: string | Buffer;
 

src/cryptos/hmac/crypto.hmac.ts

@@ -28,6 +28,10 @@ export class Hmac {
     return this.digest('base64').toString();
   }
 
+  base64url() {
+    return this.digest('base64url').toString();
+  }
+
   digest(encoding?: crypto.BinaryToTextEncoding) {
     let result: string | Buffer;
 

test/cryptos/aead.crypto.test.ts

@@ -151,6 +151,50 @@ describe('Aead', () => {
     }
   });
 
+  test('base64url()', () => {
+    const values = Object.values(AEAD);
+
+    for (let i = 0; i < values.length; i++) {
+      const name = values[i];
+
+      let key: string | Buffer = Helper.key.generate(name, passwordString, saltString);
+      let aead = Aead.create(name, key);
+      let nonce: string | Buffer;
+
+      nonce = Helper.nonce.generate(name);
+
+      let encrypted = aead.encrypt.base64url(textString, nonce);
+      let decrypted = aead.decrypt.base64url(encrypted.text, encrypted.tag, nonce);
+      expect(decrypted).toBe(textString);
+
+      key = Helper.key.normalize(name, key);
+      aead = Aead.create(name, key);
+
+      decrypted = aead.decrypt.base64url(encrypted.text, encrypted.tag, nonce);
+      expect(decrypted).toBe(textString);
+
+      key = Helper.key.generate(name, passwordBuffer, saltBuffer, PBKDF.PBKDF2, 2048, HASH.SHA256);
+      aead = Aead.create(name, key, authTagLength);
+      nonce = Helper.nonce.normalize(name, nonceString);
+
+      encrypted = aead.encrypt.base64url(textString, nonce);
+      decrypted = aead.decrypt.base64url(encrypted.text, encrypted.tag, nonce);
+      expect(decrypted).toBe(textString);
+
+      key = Helper.key.normalize(name, keyString);
+      aead = Aead.create(name, key, authTagLength, aad);
+      nonce = Helper.nonce.normalize(name, nonceBuffer);
+
+      encrypted = aead.encrypt.base64url(textString, nonce);
+
+      key = Helper.key.normalize(name, keyBuffer);
+      aead = Aead.create(name, key, authTagLength, aad);
+
+      decrypted = aead.decrypt.base64url(encrypted.text, encrypted.tag, nonce);
+      expect(decrypted).toBe(textString);
+    }
+  });
+
   test('string()', () => {
     const values = Object.values(AEAD);
 

test/cryptos/cipher.crypto.test.ts

@@ -148,6 +148,50 @@ describe('Cipher', () => {
     }
   });
 
+  test('base64url()', () => {
+    const values = Object.values(CIPHER);
+
+    for (let i = 0; i < values.length; i++) {
+      const name = values[i];
+
+      let key: string | Buffer = Helper.key.generate(name, passwordString, saltString);
+      let crypto = Cipher.create(name, key);
+      let iv: string | Buffer | null;
+
+      iv = Helper.iv.generate(name);
+
+      let encrypted = crypto.encrypt.base64url(textString, iv);
+      let decrypted = crypto.decrypt.base64url(encrypted, iv);
+      expect(decrypted).toBe(textString);
+
+      key = Helper.key.normalize(name, key);
+      crypto = Cipher.create(name, key);
+
+      decrypted = crypto.decrypt.base64url(encrypted, iv);
+      expect(decrypted).toBe(textString);
+
+      key = Helper.key.generate(name, passwordBuffer, saltBuffer, PBKDF.PBKDF2, 2048, HASH.SHA256);
+      crypto = Cipher.create(name, key);
+      iv = Helper.iv.normalize(name, ivString);
+
+      encrypted = crypto.encrypt.base64url(textString, iv);
+      decrypted = crypto.decrypt.base64url(encrypted, iv);
+      expect(decrypted).toBe(textString);
+
+      key = Helper.key.normalize(name, keyString);
+      crypto = Cipher.create(name, key);
+      iv = Helper.iv.normalize(name, ivBuffer);
+
+      encrypted = crypto.encrypt.base64url(textString, iv);
+
+      key = Helper.key.normalize(name, keyBuffer);
+      crypto = Cipher.create(name, key);
+
+      decrypted = crypto.decrypt.base64url(encrypted, iv);
+      expect(decrypted).toBe(textString);
+    }
+  });
+
   test('string()', () => {
     const values = Object.values(CIPHER);
 

test/cryptos/hash.crypto.test.ts

@@ -93,6 +93,29 @@ describe('Hash', () => {
     }
   });
 
+  test('base64url()', () => {
+    const values = Object.values(HASH);
+
+    for (let i = 0; i < values.length; i++) {
+      const name = values[i];
+      const hex = map.get(name);
+
+      if (!hex) {
+        continue;
+      }
+
+      let hash = Hash.create(name).update(textBuffer);
+      expect(hash.base64url()).toBe(Buffer.from(hex, 'hex').toString('base64url'));
+
+      hash = Hash.create(name).update(textString);
+      expect(hash.base64url()).toBe(Buffer.from(hex, 'hex').toString('base64url'));
+
+      hash = Hash.create(name);
+      expect(hash.update(textBuffer).base64url()).toBe(Buffer.from(hex, 'hex').toString('base64url'));
+      expect(hash.update(textBuffer).base64url()).toBe(Buffer.from(hex, 'hex').toString('base64url'));
+    }
+  });
+
   test('buffer()', () => {
     const values = Object.values(HASH);
 
@@ -174,6 +197,7 @@ describe('Hash', () => {
     expect(Hash.create('sha256').update(textString).binary()).toEqual(Buffer.from(hex, 'hex').toString('binary'));
     expect(Hash.create('sha256').update(textString).hex()).toEqual(Buffer.from(hex, 'hex').toString('hex'));
     expect(Hash.create('sha256').update(textString).base64()).toEqual(Buffer.from(hex, 'hex').toString('base64'));
+    expect(Hash.create('sha256').update(textString).base64url()).toEqual(Buffer.from(hex, 'hex').toString('base64url'));
     expect(Hash.create('sha256').update(textString).buffer()).toEqual(Buffer.from(hex, 'hex'));
     expect(Hash.create('sha256').update(textString).uint8Array()).toStrictEqual(
       new Uint8Array(Buffer.from(hex, 'hex'))