@hiveio/dhive 1.2.4 → 1.2.6-rc.0

package/lib/chain/deserializer.d.ts

@@ -0,0 +1,5 @@
+import * as ByteBuffer from 'bytebuffer';
+export declare type Deserializer = (buffer: ByteBuffer) => void;
+export declare const types: {
+    EncryptedMemoD: any;
+};

package/lib/chain/deserializer.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ByteBuffer = require("bytebuffer");
+const crypto_1 = require("../crypto");
+const PublicKeyDeserializer = (buf) => {
+    const c = fixed_buf(buf, 33);
+    return crypto_1.PublicKey.fromBuffer(c);
+};
+const UInt64Deserializer = (b) => b.readUint64();
+const UInt32Deserializer = (b) => b.readUint32();
+const BinaryDeserializer = (b) => {
+    const len = b.readVarint32();
+    const b_copy = b.copy(b.offset, b.offset + len);
+    b.skip(len);
+    return Buffer.from(b_copy.toBinary(), 'binary');
+};
+const BufferDeserializer = (keyDeserializers) => (buf) => {
+    const obj = {};
+    for (const [key, deserializer] of keyDeserializers) {
+        try {
+            // Decodes a binary encoded string to a ByteBuffer.
+            buf = ByteBuffer.fromBinary(buf.toString('binary'), ByteBuffer.LITTLE_ENDIAN);
+            obj[key] = deserializer(buf);
+        }
+        catch (error) {
+            error.message = `${key}: ${error.message}`;
+            throw error;
+        }
+    }
+    return obj;
+};
+function fixed_buf(b, len) {
+    if (!b) {
+        throw Error('No buffer found on first parameter');
+    }
+    else {
+        const b_copy = b.copy(b.offset, b.offset + len);
+        b.skip(len);
+        return Buffer.from(b_copy.toBinary(), 'binary');
+    }
+}
+const EncryptedMemoDeserializer = BufferDeserializer([
+    ['from', PublicKeyDeserializer],
+    ['to', PublicKeyDeserializer],
+    ['nonce', UInt64Deserializer],
+    ['check', UInt32Deserializer],
+    ['encrypted', BinaryDeserializer]
+]);
+exports.types = {
+    EncryptedMemoD: EncryptedMemoDeserializer
+};

package/lib/chain/serializer.d.ts

@@ -48,6 +48,9 @@ export declare const Types: {
     Binary: (size?: number | undefined) => (buffer: ByteBuffer, data: Buffer | HexBuffer) => void;
     Boolean: (buffer: ByteBuffer, data: boolean) => void;
     Date: (buffer: ByteBuffer, data: string) => void;
+    EncryptedMemo: (buffer: ByteBuffer, data: {
+        [key: string]: any;
+    }) => void;
     FlatMap: (keySerializer: Serializer, valueSerializer: Serializer) => (buffer: ByteBuffer, data: [any, any][]) => void;
     Int16: (buffer: ByteBuffer, data: number) => void;
     Int32: (buffer: ByteBuffer, data: number) => void;

package/lib/chain/serializer.js

@@ -530,6 +530,13 @@ const TransactionSerializer = ObjectSerializer([
     ['operations', ArraySerializer(OperationSerializer)],
     ['extensions', ArraySerializer(StringSerializer)]
 ]);
+const EncryptedMemoSerializer = ObjectSerializer([
+    ['from', PublicKeySerializer],
+    ['to', PublicKeySerializer],
+    ['nonce', UInt64Serializer],
+    ['check', UInt32Serializer],
+    ['encrypted', BinarySerializer()]
+]);
 exports.Types = {
     Array: ArraySerializer,
     Asset: AssetSerializer,
@@ -537,6 +544,7 @@ exports.Types = {
     Binary: BinarySerializer,
     Boolean: BooleanSerializer,
     Date: DateSerializer,
+    EncryptedMemo: EncryptedMemoSerializer,
     FlatMap: FlatMapSerializer,
     Int16: Int16Serializer,
     Int32: Int32Serializer,

package/lib/crypto.d.ts

@@ -33,6 +33,7 @@
  * in the design, construction, operation or maintenance of any military facility.
  */
 /// <reference types="node" />
+import * as ByteBuffer from 'bytebuffer';
 import { SignedTransaction, Transaction } from './chain/transaction';
 /**
  * Network id used in WIF-encoding.
@@ -74,9 +75,13 @@ declare function isWif(privWif: string | Buffer): boolean;
  * ECDSA (secp256k1) public key.
  */
 export declare class PublicKey {
-    readonly key: Buffer;
+    readonly key: any;
     readonly prefix: string;
-    constructor(key: Buffer, prefix?: string);
+    readonly uncompressed: Buffer;
+    constructor(key: any, prefix?: string);
+    static fromBuffer(key: ByteBuffer): {
+        key: ByteBuffer;
+    };
     /**
      * Create a new instance from a WIF-encoded key.
      */
@@ -110,6 +115,7 @@ export declare type KeyRole = 'owner' | 'active' | 'posting' | 'memo';
  */
 export declare class PrivateKey {
     private key;
+    secret: Buffer;
     constructor(key: Buffer);
     /**
      * Convenience to create a new instance from WIF string or buffer.
@@ -127,6 +133,7 @@ export declare class PrivateKey {
      * Create key from username and password.
      */
     static fromLogin(username: string, password: string, role?: KeyRole): PrivateKey;
+    multiply(pub: any): Buffer;
     /**
      * Sign message.
      * @param message 32-byte message.
@@ -145,6 +152,10 @@ export declare class PrivateKey {
      * to get the full encoded key you need to explicitly call {@link toString}.
      */
     inspect(): string;
+    /**
+     * Get shared secret for memo cryptography
+     */
+    get_shared_secret(public_key: PublicKey): Buffer;
 }
 /**
  * ECDSA (secp256k1) signature.

package/lib/crypto.js

@@ -35,15 +35,21 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert = require("assert");
+const crypto_1 = require("crypto");
+const bigInteger = require("bigi");
 const bs58 = require("bs58");
 const ByteBuffer = require("bytebuffer");
-const crypto_1 = require("crypto");
+const ecurve = require("ecurve");
 const Ripemd160 = require("ripemd160");
 const secp256k1 = require("secp256k1");
 const verror_1 = require("verror");
 const serializer_1 = require("./chain/serializer");
 const client_1 = require("./client");
 const utils_1 = require("./utils");
+/**
+ * secp256k1 ecurve
+ */
+const secp256k1Curve = ecurve.getCurveByName('secp256k1');
 /**
  * Network id used in WIF-encoding.
  */
@@ -64,6 +70,14 @@ function sha256(input) {
         .update(input)
         .digest();
 }
+/**
+ * Return sha512 hash of input
+ */
+function sha512(input) {
+    return crypto_1.createHash('sha512')
+        .update(input)
+        .digest();
+}
 /**
  * Return 2-round sha256 hash of input.
  */
@@ -145,6 +159,11 @@ class PublicKey {
         this.key = key;
         this.prefix = prefix;
         assert(secp256k1.publicKeyVerify(key), 'invalid public key');
+        this.uncompressed = Buffer.from(secp256k1.publicKeyConvert(key, false));
+    }
+    static fromBuffer(key) {
+        assert(secp256k1.publicKeyVerify(key), 'invalid buffer as public key');
+        return { key };
     }
     /**
      * Create a new instance from a WIF-encoded key.
@@ -230,6 +249,9 @@ class PrivateKey {
         const seed = username + role + password;
         return PrivateKey.fromSeed(seed);
     }
+    multiply(pub) {
+        return Buffer.from(secp256k1.publicKeyTweakMul(pub.key, this.secret, false));
+    }
     /**
      * Sign message.
      * @param message 32-byte message.
@@ -265,6 +287,15 @@ class PrivateKey {
         const key = this.toString();
         return `PrivateKey: ${key.slice(0, 6)}...${key.slice(-6)}`;
     }
+    /**
+     * Get shared secret for memo cryptography
+     */
+    get_shared_secret(public_key) {
+        const KBP = ecurve.Point.fromAffine(secp256k1Curve, bigInteger.fromBuffer(public_key.uncompressed.slice(1, 33)), bigInteger.fromBuffer(public_key.uncompressed.slice(33, 65)));
+        const P = KBP.multiply(bigInteger.fromBuffer(this.key));
+        const S = P.affineX.toBuffer({ size: 32 });
+        return sha512(S);
+    }
 }
 exports.PrivateKey = PrivateKey;
 /**

package/lib/helpers/aes.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { PrivateKey, PublicKey } from '../crypto';
+export declare const encrypt: (private_key: PrivateKey, public_key: PublicKey, message: Buffer, nonce?: string) => any;
+export declare const decrypt: (private_key: PrivateKey, public_key: PublicKey, nonce: any, message: any, checksum: number) => any;

package/lib/helpers/aes.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const crypto_1 = require("crypto");
+const ByteBuffer = require('bytebuffer');
+const Long = ByteBuffer.Long;
+exports.encrypt = (private_key, public_key, message, nonce = uniqueNonce()) => crypt(private_key, public_key, nonce, message);
+exports.decrypt = (private_key, public_key, nonce, message, checksum) => crypt(private_key, public_key, nonce, message, checksum).message;
+/**
+ * @arg {Buffer} message - Encrypted or plain text message (see checksum)
+ * @arg {number} checksum - shared secret checksum (null to encrypt, non-null to decrypt)
+ */
+const crypt = (private_key, public_key, nonce, message, checksum) => {
+    const nonceL = toLongObj(nonce);
+    //   const bufferMessage = Buffer.from(messageString, 'binary')
+    const S = private_key.get_shared_secret(public_key);
+    let ebuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+    ebuf.writeUint64(nonceL);
+    ebuf.append(S.toString('binary'), 'binary');
+    ebuf = Buffer.from(ebuf.copy(0, ebuf.offset).toBinary(), 'binary');
+    const encryption_key = crypto_1.createHash('sha512').update(ebuf).digest();
+    const iv = encryption_key.slice(32, 48);
+    const tag = encryption_key.slice(0, 32);
+    // check if first 64 bit of sha256 hash treated as uint64_t truncated to 32 bits.
+    const check = crypto_1.createHash('sha256').update(encryption_key).digest().slice(0, 4);
+    const cbuf = ByteBuffer.fromBinary(check.toString('binary'), ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+    ByteBuffer.fromBinary(check.toString('binary'), ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+    const check32 = cbuf.readUint32();
+    if (checksum) {
+        if (check32 !== checksum) {
+            throw new Error('Invalid key');
+        }
+        message = cryptoJsDecrypt(message, tag, iv);
+    }
+    else {
+        message = cryptoJsEncrypt(message, tag, iv);
+    }
+    return { nonce: nonceL, message, checksum: check32 };
+};
+/**
+ * This method does not use a checksum, the returned data must be validated some other way.
+ * @arg {string|Buffer} ciphertext - binary format
+ * @return {Buffer} the decrypted message
+ */
+const cryptoJsDecrypt = (message, tag, iv) => {
+    assert(message, 'Missing cipher text');
+    let messageBuffer = message;
+    const decipher = crypto_1.createDecipheriv('aes-256-cbc', tag, iv);
+    messageBuffer = Buffer.concat([decipher.update(messageBuffer), decipher.final()]);
+    return messageBuffer;
+};
+/**
+ * This method does not use a checksum, the returned data must be validated some other way.
+ * @arg {string|Buffer} plaintext - binary format
+ * @return {Buffer} binary
+ */
+const cryptoJsEncrypt = (message, tag, iv) => {
+    assert(message, 'Missing plain text');
+    let messageBuffer = message;
+    const cipher = crypto_1.createCipheriv('aes-256-cbc', tag, iv);
+    messageBuffer = Buffer.concat([cipher.update(messageBuffer), cipher.final()]);
+    return messageBuffer;
+};
+/** @return {string} unique 64 bit unsigned number string.  Being time based,
+ * this is careful to never choose the same nonce twice.  This value could
+ * clsbe recorded in the blockchain for a long time.
+ */
+let unique_nonce_entropy = null;
+const uniqueNonce = () => {
+    if (unique_nonce_entropy === null) {
+        const uint8randomArr = new Uint8Array(2);
+        for (let i = 0; i < 2; ++i) {
+            uint8randomArr[i] = crypto_1.randomBytes(2).readUInt8(i);
+        }
+        unique_nonce_entropy = Math.round((uint8randomArr[0] << 8) | uint8randomArr[1]);
+    }
+    let long = Long.fromNumber(Date.now());
+    const entropy = ++unique_nonce_entropy % 0xffff;
+    long = long.shiftLeft(16).or(Long.fromNumber(entropy));
+    return long.toString();
+};
+const toLongObj = (o) => (o ? (Long.isLong(o) ? o : Long.fromString(o)) : o);

package/lib/index.d.ts

@@ -47,5 +47,7 @@ export * from './chain/misc';
 export * from './chain/operation';
 export * from './chain/serializer';
 export * from './chain/transaction';
+export * from './chain/hivemind';
 export * from './client';
 export * from './crypto';
+export * from './memo';

package/lib/index.js

@@ -50,3 +50,4 @@ __export(require("./chain/misc"));
 __export(require("./chain/serializer"));
 __export(require("./client"));
 __export(require("./crypto"));
+__export(require("./memo"));

package/lib/memo.d.ts

@@ -0,0 +1,5 @@
+import { PrivateKey, PublicKey } from './crypto';
+export declare const Memo: {
+    decode: (private_key: string | PrivateKey, memo: string) => string;
+    encode: (private_key: string | PrivateKey, public_key: string | PublicKey, memo: string, testNonce?: string | undefined) => string;
+};

package/lib/memo.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bs58 = require("bs58");
+const ByteBuffer = require("bytebuffer");
+const deserializer_1 = require("./chain/deserializer");
+const serializer_1 = require("./chain/serializer");
+const crypto_1 = require("./crypto");
+const Aes = require("./helpers/aes");
+/**
+ * Memo/Any message encoding using AES (aes-cbc algorithm)
+ * @param {Buffer|string} private_key Private memo key of sender
+ * @param {Buffer|string} public_key public memo key of recipient
+ * @param {string} memo message to be encrypted
+ * @param {number} testNonce nonce with high entropy
+ */
+const encode = (private_key, public_key, memo, testNonce) => {
+    if (!memo.startsWith('#')) {
+        return memo;
+    }
+    memo = memo.substring(1);
+    checkEncryption();
+    private_key = toPrivateObj(private_key);
+    public_key = toPublicObj(public_key);
+    const mbuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+    mbuf.writeVString(memo);
+    const memoBuffer = Buffer.from(mbuf.copy(0, mbuf.offset).toBinary(), 'binary');
+    const { nonce, message, checksum } = Aes.encrypt(private_key, public_key, memoBuffer, testNonce);
+    const mbuf2 = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+    serializer_1.Types.EncryptedMemo(mbuf2, {
+        check: checksum,
+        encrypted: message,
+        from: private_key.createPublic(),
+        nonce,
+        to: public_key
+    });
+    mbuf2.flip();
+    const data = Buffer.from(mbuf2.toBuffer());
+    return '#' + bs58.encode(data);
+};
+/**
+ * Encrypted memo/message decryption
+ * @param {PrivateKey|string} private_key Private memo key of recipient
+ * @param {string}memo Encrypted message/memo
+ */
+const decode = (private_key, memo) => {
+    if (!memo.startsWith('#')) {
+        return memo;
+    }
+    memo = memo.substring(1);
+    checkEncryption();
+    private_key = toPrivateObj(private_key);
+    memo = bs58.decode(memo);
+    let memoBuffer = deserializer_1.types.EncryptedMemoD(Buffer.from(memo, 'binary'));
+    const { from, to, nonce, check, encrypted } = memoBuffer;
+    const pubkey = private_key.createPublic().toString();
+    const otherpub = pubkey === new crypto_1.PublicKey(from.key).toString()
+        ? new crypto_1.PublicKey(to.key)
+        : new crypto_1.PublicKey(from.key);
+    memoBuffer = Aes.decrypt(private_key, otherpub, nonce, encrypted, check);
+    const mbuf = ByteBuffer.fromBinary(memoBuffer.toString('binary'), ByteBuffer.LITTLE_ENDIAN);
+    try {
+        mbuf.mark();
+        return '#' + mbuf.readVString();
+    }
+    catch (e) {
+        mbuf.reset();
+        // Sender did not length-prefix the memo
+        memo = Buffer.from(mbuf.toString('binary'), 'binary').toString('utf-8');
+        return '#' + memo;
+    }
+};
+let encodeTest;
+const checkEncryption = () => {
+    if (encodeTest === undefined) {
+        let plaintext;
+        encodeTest = true; // prevent infinate looping
+        try {
+            const wif = '5JdeC9P7Pbd1uGdFVEsJ41EkEnADbbHGq6p1BwFxm6txNBsQnsw';
+            const pubkey = 'STM8m5UgaFAAYQRuaNejYdS8FVLVp9Ss3K1qAVk5de6F8s3HnVbvA';
+            const cyphertext = encode(wif, pubkey, '#memo爱');
+            plaintext = decode(wif, cyphertext);
+        }
+        catch (e) {
+            throw new Error(e);
+        }
+        finally {
+            encodeTest = plaintext === '#memo爱';
+        }
+    }
+    if (encodeTest === false) {
+        throw new Error('This environment does not support encryption.');
+    }
+};
+const toPrivateObj = (o) => o ? (o.key ? o : crypto_1.PrivateKey.fromString(o)) : o; /* null or undefined*/
+const toPublicObj = (o) => o ? (o.key ? o : crypto_1.PublicKey.fromString(o)) : o; /* null or undefined*/
+exports.Memo = {
+    decode,
+    encode
+};

package/lib/utils.d.ts

@@ -71,7 +71,7 @@ export interface WitnessProps {
     hbd_interest_rate?: number;
     url?: string;
 }
-export declare function buildWitnessUpdateOp(owner: string, props: WitnessProps): WitnessSetPropertiesOperation;
+export declare const buildWitnessUpdateOp: (owner: string, props: WitnessProps) => WitnessSetPropertiesOperation;
 export declare const operationOrders: {
     vote: number;
     comment: number;

package/lib/utils.js

@@ -182,15 +182,15 @@ const failover = (url, urls, currentAddress, consoleOnFailover) => {
 // Can hopefully be removed when hived's JSON representation is fixed
 const ByteBuffer = require("bytebuffer");
 const serializer_1 = require("./chain/serializer");
-function serialize(serializer, data) {
+const serialize = (serializer, data) => {
     const buffer = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
     serializer(buffer, data);
     buffer.flip();
     // `props` values must be hex
     return buffer.toString('hex');
     // return Buffer.from(buffer.toBuffer());
-}
-function buildWitnessUpdateOp(owner, props) {
+};
+exports.buildWitnessUpdateOp = (owner, props) => {
     const data = {
         extensions: [],
         owner,
@@ -227,8 +227,7 @@ function buildWitnessUpdateOp(owner, props) {
     }
     data.props.sort((a, b) => a[0].localeCompare(b[0]));
     return ['witness_set_properties', data];
-}
-exports.buildWitnessUpdateOp = buildWitnessUpdateOp;
+};
 const JSBI = require('jsbi');
 exports.operationOrders = {
     vote: 0,

package/lib/version.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = '1.2.3';
+exports.default = '1.2.6';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hiveio/dhive",
-  "version": "1.2.4",
+  "version": "1.2.6-rc.0",
   "description": "Hive blockchain RPC client library",
   "author": "hive-network",
   "license": "BSD-3-Clause-No-Military-License",
@@ -32,10 +32,12 @@
     "dhive"
   ],
   "dependencies": {
+    "bigi": "^1.4.2",
     "bs58": "^4.0.1",
     "bytebuffer": "^5.0.1",
     "core-js": "^3.6.4",
     "cross-fetch": "^3.0.4",
+    "ecurve": "^1.0.6",
     "https": "^1.0.0",
     "jsbi": "^3.1.4",
     "node-fetch": "^2.6.0",