@proton/ccxt
Version:
A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 130+ exchanges
196 lines (191 loc) • 7.03 kB
JavaScript
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var base64 = require('./lib/jsbn/base64.js');
var JSEncryptRSAKey = require('./JSEncryptRSAKey.js');
const version = typeof process !== 'undefined'
? process.env?.npm_package_version
: undefined;
/**
*
* @param {Object} [options = {}] - An object to customize JSEncrypt behaviour
* possible parameters are:
* - default_key_size {number} default: 1024 the key size in bit
* - default_public_exponent {string} default: '010001' the hexadecimal representation of the public exponent
* - log {boolean} default: false whether log warn/error or not
* @constructor
*/
class JSEncrypt {
constructor(options = {}) {
options = options || {};
this.default_key_size = options.default_key_size
? parseInt(options.default_key_size, 10)
: 1024;
this.default_public_exponent = options.default_public_exponent || "010001"; // 65537 default openssl public exponent for rsa key type
this.log = options.log || false;
// The private and public key.
this.key = null;
}
/**
* Method to set the rsa key parameter (one method is enough to set both the public
* and the private key, since the private key contains the public key paramenters)
* Log a warning if logs are enabled
* @param {Object|string} key the pem encoded string or an object (with or without header/footer)
* @public
*/
setKey(key) {
if (this.log && this.key) {
console.warn("A key was already set, overriding existing.");
}
this.key = new JSEncryptRSAKey.JSEncryptRSAKey(key);
}
/**
* Proxy method for setKey, for api compatibility
* @see setKey
* @public
*/
setPrivateKey(privkey) {
// Create the key.
this.setKey(privkey);
}
/**
* Proxy method for setKey, for api compatibility
* @see setKey
* @public
*/
setPublicKey(pubkey) {
// Sets the public key.
this.setKey(pubkey);
}
/**
* Proxy method for RSAKey object's decrypt, decrypt the string using the private
* components of the rsa key object. Note that if the object was not set will be created
* on the fly (by the getKey method) using the parameters passed in the JSEncrypt constructor
* @param {string} str base64 encoded crypted string to decrypt
* @return {string} the decrypted string
* @public
*/
decrypt(str) {
// Return the decrypted string.
try {
return this.getKey().decrypt(base64.b64tohex(str));
}
catch (ex) {
return false;
}
}
/**
* Proxy method for RSAKey object's encrypt, encrypt the string using the public
* components of the rsa key object. Note that if the object was not set will be created
* on the fly (by the getKey method) using the parameters passed in the JSEncrypt constructor
* @param {string} str the string to encrypt
* @return {string} the encrypted string encoded in base64
* @public
*/
encrypt(str) {
// Return the encrypted string.
try {
return base64.hex2b64(this.getKey().encrypt(str));
}
catch (ex) {
return false;
}
}
/**
* Proxy method for RSAKey object's sign.
* @param {string} str the string to sign
* @param {function} digestMethod hash method
* @param {string} digestName the name of the hash algorithm
* @return {string} the signature encoded in base64
* @public
*/
sign(str, digestMethod, digestName) {
// return the RSA signature of 'str' in 'hex' format.
try {
return base64.hex2b64(this.getKey().sign(str, digestMethod, digestName));
}
catch (ex) {
return false;
}
}
/**
* Proxy method for RSAKey object's verify.
* @param {string} str the string to verify
* @param {string} signature the signature encoded in base64 to compare the string to
* @param {function} digestMethod hash method
* @return {boolean} whether the data and signature match
* @public
*/
verify(str, signature, digestMethod) {
// Return the decrypted 'digest' of the signature.
try {
return this.getKey().verify(str, base64.b64tohex(signature), digestMethod);
}
catch (ex) {
return false;
}
}
/**
* Getter for the current JSEncryptRSAKey object. If it doesn't exists a new object
* will be created and returned
* @param {callback} [cb] the callback to be called if we want the key to be generated
* in an async fashion
* @returns {JSEncryptRSAKey} the JSEncryptRSAKey object
* @public
*/
getKey(cb) {
// Only create new if it does not exist.
if (!this.key) {
// Get a new private key.
this.key = new JSEncryptRSAKey.JSEncryptRSAKey();
if (cb && {}.toString.call(cb) === "[object Function]") {
this.key.generateAsync(this.default_key_size, this.default_public_exponent, cb);
return;
}
// Generate the key.
this.key.generate(this.default_key_size, this.default_public_exponent);
}
return this.key;
}
/**
* Returns the pem encoded representation of the private key
* If the key doesn't exists a new key will be created
* @returns {string} pem encoded representation of the private key WITH header and footer
* @public
*/
getPrivateKey() {
// Return the private representation of this key.
return this.getKey().getPrivateKey();
}
/**
* Returns the pem encoded representation of the private key
* If the key doesn't exists a new key will be created
* @returns {string} pem encoded representation of the private key WITHOUT header and footer
* @public
*/
getPrivateKeyB64() {
// Return the private representation of this key.
return this.getKey().getPrivateBaseKeyB64();
}
/**
* Returns the pem encoded representation of the public key
* If the key doesn't exists a new key will be created
* @returns {string} pem encoded representation of the public key WITH header and footer
* @public
*/
getPublicKey() {
// Return the private representation of this key.
return this.getKey().getPublicKey();
}
/**
* Returns the pem encoded representation of the public key
* If the key doesn't exists a new key will be created
* @returns {string} pem encoded representation of the public key WITHOUT header and footer
* @public
*/
getPublicKeyB64() {
// Return the private representation of this key.
return this.getKey().getPublicBaseKeyB64();
}
}
JSEncrypt.version = version;
exports.JSEncrypt = JSEncrypt;