vialeys 0.0.1 → 0.0.2

package/lib/Utils/crypto.js

@@ -1,57 +1,37 @@
 "use strict"
 
-var __createBinding = (this && this.__createBinding) || (Object.create ? function(o, m, k, k2) {
-  if (k2 === undefined) k2 = k
-  var desc = Object.getOwnPropertyDescriptor(m, k)
-  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-    desc = { enumerable: true, get: function() { return m[k] } }
-  }
-  Object.defineProperty(o, k2, desc)
-} : function(o, m, k, k2) {
-  if (k2 === undefined) k2 = k
-  o[k2] = m[k]
-})
-
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? function(o, v) {
-  Object.defineProperty(o, "default", { enumerable: true, value: v })
-} : function(o, v) {
-  o["default"] = v
-})
-
-var __importStar = (this && this.__importStar) || function(mod) {
-  if (mod && mod.__esModule) return mod
-  var result = {}
-  if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k)
-  __setModuleDefault(result, mod)
-  return result
-}
-
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const crypto_1 = require("crypto")
-const libsignal = __importStar(require("libsignal-node"))
-const Defaults_1 = require("../Defaults")
+const { 
+  createCipheriv, 
+  createDecipheriv,
+  createHash, 
+  createHmac,
+  randomBytes 
+} = require("crypto")
+const { curve } = require("libsignal-node")
+const { KEY_BUNDLE_TYPE } = require("../Defaults/constants")
 
 const generateSignalPubKey = (pubKey) => (
-  pubKey.length === 33 ? pubKey : Buffer.concat([Defaults_1.KEY_BUNDLE_TYPE, pubKey])
+  pubKey.length === 33 ? pubKey : Buffer.concat([KEY_BUNDLE_TYPE, pubKey])
 )
 
 const Curve = {
   generateKeyPair: () => {
-    const { pubKey, privKey } = libsignal.curve.generateKeyPair()
+    const { pubKey, privKey } = curve.generateKeyPair()
     return {
       private: Buffer.from(privKey),
       public: Buffer.from(pubKey.slice(1))
     }
   },
   sharedKey: (privateKey, publicKey) => {
-    const shared = libsignal.curve.calculateAgreement(generateSignalPubKey(publicKey), privateKey)
+    const shared = curve.calculateAgreement(generateSignalPubKey(publicKey), privateKey)
     return Buffer.from(shared)
   },
-  sign: (privateKey, buf) => libsignal.curve.calculateSignature(privateKey, buf),
+  sign: (privateKey, buf) => curve.calculateSignature(privateKey, buf),
   verify: (pubKey, message, signature) => {
     try {
-      libsignal.curve.verifySignature(generateSignalPubKey(pubKey), message, signature)
+      curve.verifySignature(generateSignalPubKey(pubKey), message, signature)
       return true
     } catch {
       return false
@@ -69,13 +49,13 @@ const signedKeyPair = (identityKeyPair, keyId) => {
 const GCM_TAG_LENGTH = 128 >> 3
 
 function aesEncryptGCM(plaintext, key, iv, additionalData) {
-  const cipher = crypto_1.createCipheriv('aes-256-gcm', key, iv)
+  const cipher = createCipheriv('aes-256-gcm', key, iv)
   cipher.setAAD(additionalData)
   return Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()])
 }
 
 function aesDecryptGCM(ciphertext, key, iv, additionalData) {
-  const decipher = crypto_1.createDecipheriv('aes-256-gcm', key, iv)
+  const decipher = createDecipheriv('aes-256-gcm', key, iv)
   const enc = ciphertext.slice(0, ciphertext.length - GCM_TAG_LENGTH)
   const tag = ciphertext.slice(ciphertext.length - GCM_TAG_LENGTH)
   if (additionalData) decipher.setAAD(additionalData)
@@ -84,12 +64,12 @@ function aesDecryptGCM(ciphertext, key, iv, additionalData) {
 }
 
 function aesEncryptCTR(plaintext, key, iv) {
-  const cipher = crypto_1.createCipheriv('aes-256-ctr', key, iv)
+  const cipher = createCipheriv('aes-256-ctr', key, iv)
   return Buffer.concat([cipher.update(plaintext), cipher.final()])
 }
 
 function aesDecryptCTR(ciphertext, key, iv) {
-  const decipher = crypto_1.createDecipheriv('aes-256-ctr', key, iv)
+  const decipher = createDecipheriv('aes-256-ctr', key, iv)
   return Buffer.concat([decipher.update(ciphertext), decipher.final()])
 }
 
@@ -98,31 +78,31 @@ function aesDecrypt(buffer, key) {
 }
 
 function aesDecryptWithIV(buffer, key, IV) {
-  const aes = crypto_1.createDecipheriv('aes-256-cbc', key, IV)
+  const aes = createDecipheriv('aes-256-cbc', key, IV)
   return Buffer.concat([aes.update(buffer), aes.final()])
 }
 
 function aesEncrypt(buffer, key) {
-  const IV = crypto_1.randomBytes(16)
-  const aes = crypto_1.createCipheriv('aes-256-cbc', key, IV)
+  const IV = randomBytes(16)
+  const aes = createCipheriv('aes-256-cbc', key, IV)
   return Buffer.concat([IV, aes.update(buffer), aes.final()])
 }
 
 function aesEncrypWithIV(buffer, key, IV) {
-  const aes = crypto_1.createCipheriv('aes-256-cbc', key, IV)
+  const aes = createCipheriv('aes-256-cbc', key, IV)
   return Buffer.concat([aes.update(buffer), aes.final()])
 }
 
 function hmacSign(buffer, key, variant = 'sha256') {
-  return crypto_1.createHmac(variant, key).update(buffer).digest()
+  return createHmac(variant, key).update(buffer).digest()
 }
 
 function sha256(buffer) {
-  return crypto_1.createHash('sha256').update(buffer).digest()
+  return createHash('sha256').update(buffer).digest()
 }
 
 function md5(buffer) {
-  return crypto_1.createHash('md5').update(buffer).digest()
+  return createHash('md5').update(buffer).digest()
 }
 
 async function hkdf(buffer, expandedLength, info) {