@blockchyp/blockchyp-ts 1.0.0

package/src/cryptoutils.js

@@ -0,0 +1,89 @@
+"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 });
+exports.BlockChypCrypto = void 0;
+const createHmac = require('create-hmac');
+const randomBytes = require('randombytes');
+const moment = require('moment');
+const base32 = require('base32');
+const shajs = require('sha.js');
+const EC = __importStar(require("elliptic"));
+const aesjs = __importStar(require("aes-js"));
+class BlockChypCrypto {
+    generateGatewayHeaders(creds) {
+        const nonce = this.generateNonce();
+        const ts = this.generateIsoTimestamp();
+        const toSign = creds.apiKey + creds.bearerToken + ts + nonce;
+        const key = Buffer.from(creds.signingKey, 'hex');
+        const hmac = createHmac('sha256', key);
+        hmac.update(toSign);
+        const sig = hmac.digest('hex');
+        const results = {
+            'Nonce': nonce,
+            'Timestamp': ts,
+            'Authorization': 'Dual ' + creds.bearerToken + ':' + creds.apiKey + ':' + sig
+        };
+        return results;
+    }
+    encrypt(hexKey, plainText) {
+        const key = Buffer.from(hexKey, 'hex').slice(0, 32);
+        const keyArr = [...key];
+        const iv = randomBytes(16);
+        const ivArr = [...iv];
+        const aesCbc = new aesjs.ModeOfOperation.cbc(keyArr, ivArr);
+        const plainBytes = aesjs.padding.pkcs7.pad(aesjs.utils.utf8.toBytes(plainText));
+        const encryptedBytes = aesCbc.encrypt(plainBytes);
+        return iv.toString('hex') + aesjs.utils.hex.fromBytes(encryptedBytes);
+    }
+    sha256Hash(msg) {
+        return shajs('sha256').update(msg, 'hex').digest('hex');
+    }
+    validateSignature(publicKey, msg, sig) {
+        const ec = new EC.ec('p256');
+        const key = ec.keyFromPublic({ x: publicKey.x, y: publicKey.y });
+        const msgHash = this.sha256Hash(msg);
+        return key.verify(msgHash, { r: sig.r, s: sig.s });
+    }
+    decrypt(hexKey, cipherText) {
+        const key = Buffer.from(hexKey, 'hex').slice(0, 32);
+        const keyArr = [...key];
+        const cipherBytes = Buffer.from(cipherText, 'hex');
+        const iv = cipherBytes.slice(0, 16);
+        const aesCbc = new aesjs.ModeOfOperation.cbc(keyArr, iv);
+        const cipher = cipherBytes.slice(16, cipherBytes.length);
+        const cipherArr = [...cipher];
+        const decryptedBytes = aesjs.padding.pkcs7.strip(aesCbc.decrypt(cipherArr));
+        return aesjs.utils.utf8.fromBytes(decryptedBytes);
+    }
+    generateNonce() {
+        return base32.encode(randomBytes(32), "Crockford").toUpperCase();
+    }
+    generateIsoTimestamp() {
+        return moment().utc().format('YYYY-MM-DDTHH:mm:ss') + 'Z';
+    }
+}
+exports.BlockChypCrypto = BlockChypCrypto;
+const CryptoUtils = new BlockChypCrypto();
+exports.default = CryptoUtils;

package/src/cryptoutils.ts

@@ -0,0 +1,80 @@
+const createHmac = require('create-hmac')
+const randomBytes = require('randombytes')
+const moment = require('moment')
+const base32 = require('base32')
+const shajs = require('sha.js')
+import * as EC from 'elliptic'
+import * as aesjs from 'aes-js'
+import { BlockChypCredentials } from './client'
+
+export class BlockChypCrypto {
+  generateGatewayHeaders (creds: BlockChypCredentials) {
+    const nonce = this.generateNonce()
+    const ts = this.generateIsoTimestamp()
+    const toSign = creds.apiKey + creds.bearerToken + ts + nonce
+    const key = Buffer.from(creds.signingKey, 'hex')
+    const hmac = createHmac('sha256', key)
+    hmac.update(toSign)
+    const sig = hmac.digest('hex')
+
+    const results = {
+      'Nonce': nonce,
+      'Timestamp': ts,
+      'Authorization': 'Dual ' + creds.bearerToken + ':' + creds.apiKey + ':' + sig
+    }
+
+    return results
+  }
+
+  encrypt (hexKey: string, plainText: string) {
+    const key = Buffer.from(hexKey, 'hex').slice(0, 32)
+    const keyArr = [...key]
+
+    const iv = randomBytes(16)
+    const ivArr = [...iv]
+
+    const aesCbc = new aesjs.ModeOfOperation.cbc(keyArr, ivArr)
+    const plainBytes = aesjs.padding.pkcs7.pad(aesjs.utils.utf8.toBytes(plainText))
+    const encryptedBytes = aesCbc.encrypt(plainBytes)
+
+    return iv.toString('hex') + aesjs.utils.hex.fromBytes(encryptedBytes)
+  }
+
+  sha256Hash (msg: string) {
+    return shajs('sha256').update(msg, 'hex').digest('hex')
+  }
+
+  validateSignature (publicKey: any, msg: string, sig: any) {
+    const ec = new EC.ec('p256')
+    const key = ec.keyFromPublic({x: publicKey.x, y: publicKey.y})
+    const msgHash = this.sha256Hash(msg)
+    return key.verify(msgHash, {r: sig.r, s: sig.s})
+  }
+
+  decrypt (hexKey: string, cipherText: string) {
+    const key = Buffer.from(hexKey, 'hex').slice(0, 32)
+    const keyArr = [...key]
+
+    const cipherBytes = Buffer.from(cipherText, 'hex')
+    const iv = cipherBytes.slice(0, 16)
+
+    const aesCbc = new aesjs.ModeOfOperation.cbc(keyArr, iv)
+
+    const cipher = cipherBytes.slice(16, cipherBytes.length)
+    const cipherArr = [...cipher]
+    const decryptedBytes = aesjs.padding.pkcs7.strip(aesCbc.decrypt(cipherArr))
+
+    return aesjs.utils.utf8.fromBytes(decryptedBytes)
+  }
+
+  generateNonce () {
+    return base32.encode(randomBytes(32), "Crockford").toUpperCase()
+  }
+
+  generateIsoTimestamp () {
+    return moment().utc().format('YYYY-MM-DDTHH:mm:ss') + 'Z'
+  }
+}
+
+const CryptoUtils = new BlockChypCrypto()
+export default CryptoUtils

package/src/global.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = __importDefault(require("./client"));
+if (typeof window !== 'undefined') {
+    window.blockchyp = client_1.default;
+}

package/src/global.ts

@@ -0,0 +1,5 @@
+import BlockChyp from './client'
+
+if (typeof window !== 'undefined') {
+  (window as any).blockchyp = BlockChyp;
+}