npm/tic-crypto
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

rename seckey to prikey

Browse Source
This commit is contained in:
陆柯 2022-08-14 15:51:19 +08:00
parent 7a8ea70608
commit e7f538b472
2 changed files with 46 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
test.js
View File

@ -94,8 +94,8 @@ console.log('address = ', add)
/////////////////////// keyutil /////////////////////// keyutil
let seckeyObject = new keyutil.Key('oct', Buffer.from(acc.seckey, 'hex'), { namedCurve: 'P-256K' }) // {P-256 : secp256r1, P-384 : secp384r1, P-521 : secp521r1, P-256K : secp256k1} let seckeyObject = new keyutil.Key('oct', Buffer.from(acc.prikey, 'hex'), { namedCurve: 'P-256K' }) // {P-256 : secp256r1, P-384 : secp384r1, P-521 : secp521r1, P-256K : secp256k1}
let seckeyObject2 = new keyutil.Key('oct', tic.hex_to_buf(acc.seckey, 'hex'), { namedCurve: 'P-256K' }) let seckeyObject2 = new keyutil.Key('oct', tic.hex_to_buf(acc.prikey, 'hex'), { namedCurve: 'P-256K' })
let seckeyPEM let seckeyPEM
seckeyObject.export('pem').then((data) => (seckeyPEM = data)) seckeyObject.export('pem').then((data) => (seckeyPEM = data))
let seckeyDER let seckeyDER
@ -124,17 +124,17 @@ verifyKU.end()
var verified = verifyKU.verify(pubkeyPEM, signatureKU) // specify format in [pem,der] and type in [pkcs1,spki] var verified = verifyKU.verify(pubkeyPEM, signatureKU) // specify format in [pem,der] and type in [pkcs1,spki]
console.log('verified = ', verified) // 可以验证通过，但是用的privatekey，没有成功使用publickey。 console.log('verified = ', verified) // 可以验证通过，但是用的privatekey，没有成功使用publickey。
crypto.createCipheriv('aes-256-cfb', Buffer.from(acc.seckey, 'hex'), Buffer.alloc(16)) crypto.createCipheriv('aes-256-cfb', Buffer.from(acc.prikey, 'hex'), Buffer.alloc(16))
////////////////////// crypto + PEM ////////////////////// crypto + PEM
toPEM = function (kp) { toPEM = function (kp) {
let pubkey = crypto let pubkey = crypto
.createECDH('secp256k1') .createECDH('secp256k1')
.setPrivateKey(kp.seckey, 'hex') .setPrivateKey(kp.prikey, 'hex')
.getPublicKey('hex', 'compressed') .getPublicKey('hex', 'compressed')
console.log('ECDH created publickey = ', pubkey) console.log('ECDH created publickey = ', pubkey)
let mykey = '308187020100301306072a8648ce3d020106082a8648ce3d030107046d306b0201010420' + kp.seckey + 'a144034200' + pubkey let mykey = '308187020100301306072a8648ce3d020106082a8648ce3d030107046d306b0201010420' + kp.prikey + 'a144034200' + pubkey
console.log(mykey) console.log(mykey)
let privKey = '-----BEGIN PRIVATE KEY-----\n' + Buffer.from(mykey, 'hex').toString('base64') + '\n-----END PRIVATE KEY-----' let privKey = '-----BEGIN PRIVATE KEY-----\n' + Buffer.from(mykey, 'hex').toString('base64') + '\n-----END PRIVATE KEY-----'
// pubKey2 = crypto.createPublicKey(privKey); //也可恢复出公钥。测试不成功。 // pubKey2 = crypto.createPublicKey(privKey); //也可恢复出公钥。测试不成功。
@ -156,7 +156,7 @@ console.log('pemKP = ', pemKP)
// https://www.shangyang.me/2017/05/24/encrypt-rsa-keyformat/ // https://www.shangyang.me/2017/05/24/encrypt-rsa-keyformat/
var buf1 = Buffer.from('308141020100301306072a8648ce3d020106082a8648ce3d030107042730250201010420', 'hex') // specific byte-sequence for curve prime256v1 var buf1 = Buffer.from('308141020100301306072a8648ce3d020106082a8648ce3d030107042730250201010420', 'hex') // specific byte-sequence for curve prime256v1
var buf2 = Buffer.from(acc.seckey, 'hex') // raw private key (32 bytes) var buf2 = Buffer.from(acc.prikey, 'hex') // raw private key (32 bytes)
var privateKeyPkcs8Der = Buffer.concat([buf1, buf2], buf1.length + buf2.length) var privateKeyPkcs8Der = Buffer.concat([buf1, buf2], buf1.length + buf2.length)
var sign = crypto.createSign('sha256') var sign = crypto.createSign('sha256')
sign.write('毛主席万岁') sign.write('毛主席万岁')
@ -186,7 +186,7 @@ var EC = require('elliptic').ec
var ec = new EC('secp256k1') var ec = new EC('secp256k1')
// Generate keys // Generate keys
//var key = ec.genKeyPair(); //var key = ec.genKeyPair();
var key = ec.keyFromPrivate(acc.seckey) // 注意，不需要 'hex' 参数 var key = ec.keyFromPrivate(acc.prikey) // 注意，不需要 'hex' 参数
// Sign the message's hash (input must be an array, or a hex-string) // Sign the message's hash (input must be an array, or a hex-string)
var msgHash = tic.hash('毛主席万岁') var msgHash = tic.hash('毛主席万岁')
var msgHashBad = tic.hash('毛主席万岁 ') var msgHashBad = tic.hash('毛主席万岁 ')

78
ticc.js
View File

@ -138,14 +138,14 @@ class TicCrypto {
* 测试是否合法的私钥 * 测试是否合法的私钥
* *
* @static * @static
* @param {String} seckey * @param {String} prikey
* @return {Boolean} * @return {Boolean}
* @memberof TicCrypto * @memberof TicCrypto
*/ */
static is_seckey ({ seckey } = {}) { static is_seckey ({ prikey } = {}) {
// 比特币、以太坊的私钥：64 hex // 比特币、以太坊的私钥：64 hex
// nacl.sign 的私钥 128 hex, nacl.box 的私钥 64 hex // nacl.sign 的私钥 128 hex, nacl.box 的私钥 64 hex
return /^([a-fA-F0-9]{128}|[a-fA-F0-9]{64})$/.test(seckey) return /^([a-fA-F0-9]{128}|[a-fA-F0-9]{64})$/.test(prikey)
} }
/** /**
@ -228,7 +228,7 @@ class TicCrypto {
ciphertext += encryptor.final(outputEncoding) // 但是 Buffer + Buffer 还是会变成string ciphertext += encryptor.final(outputEncoding) // 但是 Buffer + Buffer 还是会变成string
return { iv: iv.toString('hex'), ciphertext } // 有 iv，显然每次结果不一样 return { iv: iv.toString('hex'), ciphertext } // 有 iv，显然每次结果不一样
} }
} else if (keytype === 'seckey') { } else if (keytype === 'prikey') {
// 尚未走通，不能使用 ticc 生成的 Elliptic curve 椭圆曲线算法公私钥，只能用 crypto.generateKeyPairSync('rsa') 生成的 rsa 公私钥 // 尚未走通，不能使用 ticc 生成的 Elliptic curve 椭圆曲线算法公私钥，只能用 crypto.generateKeyPairSync('rsa') 生成的 rsa 公私钥
let seckeyPEM = await new keyman.Key('oct', this.hex_to_buf(key), { namedCurve: 'P-256K' }).export('pem') // 私钥导出的der格式为144字节。 let seckeyPEM = await new keyman.Key('oct', this.hex_to_buf(key), { namedCurve: 'P-256K' }).export('pem') // 私钥导出的der格式为144字节。
return crypto.privateEncrypt(seckeyPEM, Buffer.from(data)) // 返回 Buffer。每次结果都一样。 return crypto.privateEncrypt(seckeyPEM, Buffer.from(data)) // 返回 Buffer。每次结果都一样。
@ -272,7 +272,7 @@ class TicCrypto {
// 如果用户输入错误密码，deciper也能解密，无法自动判断是否正确结果。可在返回后人工判断。 // 如果用户输入错误密码，deciper也能解密，无法自动判断是否正确结果。可在返回后人工判断。
return decrypted return decrypted
} }
} else if (keytype === 'seckey') { } else if (keytype === 'prikey') {
// 尚未走通，不能使用 ticc 生成的 Elliptic curve 椭圆曲线算法公私钥 // 尚未走通，不能使用 ticc 生成的 Elliptic curve 椭圆曲线算法公私钥
let seckeyPEM = await new keyman.Key('oct', this.hex_to_buf(key), { namedCurve: 'P-256K' }).export('pem') // 私钥导出的der格式为144字节。 let seckeyPEM = await new keyman.Key('oct', this.hex_to_buf(key), { namedCurve: 'P-256K' }).export('pem') // 私钥导出的der格式为144字节。
return crypto.privateDecrypt(seckeyPEM, Buffer.from(data)) // 返回 Buffer。每次结果都一样。 return crypto.privateDecrypt(seckeyPEM, Buffer.from(data)) // 返回 Buffer。每次结果都一样。
@ -288,26 +288,26 @@ class TicCrypto {
* *
* @static * @static
* @param {*} data * @param {*} data
* @param {String} seckey * @param {String} prikey
* @param {Object} option [option={}] * @param {Object} option [option={}]
* @return {String} * @return {String}
* @memberof TicCrypto * @memberof TicCrypto
*/ */
static async sign_easy ({ data, seckey, tool = 'crypto', hasher = my.HASHER }) { static async sign_easy ({ data, prikey, tool = 'crypto', hasher = my.HASHER }) {
// data can be string or buffer or object, results are the same // data can be string or buffer or object, results are the same
if (this.is_hashable({ data }) && this.is_seckey({ seckey })) { if (this.is_hashable({ data }) && this.is_seckey({ prikey })) {
if (tool === 'nacl' && seckey.length === 128) { if (tool === 'nacl' && prikey.length === 128) {
// 使用nacl的签名算法。注意，nacl.sign需要的seckey是64字节=128字符。 // 使用nacl的签名算法。注意，nacl.sign需要的seckey是64字节=128字符。
let hashBuf = this.hash_easy(data, { output: 'buf' }) // 哈希必须输出为 buffer let hashBuf = this.hash_easy(data, { output: 'buf' }) // 哈希必须输出为 buffer
let signature = nacl.sign.detached(hashBuf, Buffer.from(seckey, 'hex')) let signature = nacl.sign.detached(hashBuf, Buffer.from(prikey, 'hex'))
return Buffer.from(signature).toString('hex') // 签名是64节，128个hex字符 return Buffer.from(signature).toString('hex') // 签名是64节，128个hex字符
} else if (tool === 'eccrypto' && seckey.length === 64) { } else if (tool === 'eccrypto' && prikey.length === 64) {
// eccrypto 对同一组data,seckey生成的签名是固定的，观察到hex长度为140或142，是der格式。 // eccrypto 对同一组data,seckey生成的签名是固定的，观察到hex长度为140或142，是der格式。
let signature = await eccrypto.sign(Buffer.from(seckey, 'hex'), this.hash_easy(data, { output: 'buf' })) let signature = await eccrypto.sign(Buffer.from(prikey, 'hex'), this.hash_easy(data, { output: 'buf' }))
return signature.toString('hex') return signature.toString('hex')
} else if (seckey.length === 64) { } else if (prikey.length === 64) {
// 纯 crypto // 纯 crypto
let seckeyPEM = await new keyman.Key('oct', this.hex_to_buf(seckey), { namedCurve: 'P-256K' }).export('pem') // 私钥导出的der格式为144字节。 let seckeyPEM = await new keyman.Key('oct', this.hex_to_buf(prikey), { namedCurve: 'P-256K' }).export('pem') // 私钥导出的der格式为144字节。
let signer = crypto.createSign(hasher) // 注意，不知为何，hasher必须含有'sha'才能完成签名，例如 sha1, sha256, sha512, sha3, RSA-SHA1, id-rsassa-pkcs1-v1_5-with-sha3-224, 其他都会报错。 let signer = crypto.createSign(hasher) // 注意，不知为何，hasher必须含有'sha'才能完成签名，例如 sha1, sha256, sha512, sha3, RSA-SHA1, id-rsassa-pkcs1-v1_5-with-sha3-224, 其他都会报错。
signer.update(this.hash_easy(data)).end() signer.update(this.hash_easy(data)).end()
let signature = signer.sign(seckeyPEM, 'hex') let signature = signer.sign(seckeyPEM, 'hex')
@ -368,7 +368,7 @@ class TicCrypto {
* @static * @static
* @param {String} pass * @param {String} pass
* @param {Object} option * @param {Object} option
* @return {Object} {pubkey, seckey, address,} * @return {Object} {pubkey, prikey, address,}
* @memberof TicCrypto * @memberof TicCrypto
*/ */
static pass_to_keypair ({ pass, hasher = my.HASHER } = {}) { static pass_to_keypair ({ pass, hasher = my.HASHER } = {}) {
@ -382,7 +382,7 @@ class TicCrypto {
return { return {
hash: hashBuf.toString('hex'), hash: hashBuf.toString('hex'),
pubkey: Buffer.from(keypair.publicKey).toString('hex'), // 测试过 不能直接keypair.publicKey.toString('hex')，不是buffer类型 pubkey: Buffer.from(keypair.publicKey).toString('hex'), // 测试过 不能直接keypair.publicKey.toString('hex')，不是buffer类型
seckey: Buffer.from(keypair.secretKey).toString('hex'), prikey: Buffer.from(keypair.secretKey).toString('hex'),
} }
} }
return null return null
@ -425,7 +425,7 @@ class TicCrypto {
* @static * @static
* @param {String} secword * @param {String} secword
* @param {Object} option * @param {Object} option
* @return {Object} {pubkey, seckey,} * @return {Object} {pubkey, prikey,}
* @memberof TicCrypto * @memberof TicCrypto
*/ */
static secword_to_keypair ({ secword, coin, pass, pathRoot, pathIndex, path, tool, hasher = my.HASHER } = {}) { static secword_to_keypair ({ secword, coin, pass, pathRoot, pathIndex, path, tool, hasher = my.HASHER } = {}) {
@ -450,7 +450,7 @@ class TicCrypto {
let keypair = nacl.sign.keyPair.fromSeed(hashBuf) // nacl.sign.keyPair.fromSeed 要求32字节的种子，而 this.secword2seed生成的是64字节种子，所以要先做一次sha256 let keypair = nacl.sign.keyPair.fromSeed(hashBuf) // nacl.sign.keyPair.fromSeed 要求32字节的种子，而 this.secword2seed生成的是64字节种子，所以要先做一次sha256
return { return {
pubkey: Buffer.from(keypair.publicKey).toString('hex'), // 测试过 不能直接keypair.publicKey.toString('hex')，不是buffer类型 pubkey: Buffer.from(keypair.publicKey).toString('hex'), // 测试过 不能直接keypair.publicKey.toString('hex')，不是buffer类型
seckey: Buffer.from(keypair.secretKey).toString('hex'), // nacl.sign.keyPair.fromSeed 得到的 seckey 是64字节的，不同于比特币/以太坊的32字节密钥。 prikey: Buffer.from(keypair.secretKey).toString('hex'), // nacl.sign.keyPair.fromSeed 得到的 prikey 是64字节的，不同于比特币/以太坊的32字节密钥。
tool, tool,
} }
} else { } else {
@ -472,7 +472,7 @@ class TicCrypto {
} }
return { return {
path, path,
seckey: key.privateKey.toString('hex'), // 或者 key.toJSON().privateKey。或者 key.privateKey.slice(2) 删除开头的'0x'如果是ethers.HDNode.fromMnemonic(secword)的结果 prikey: key.privateKey.toString('hex'), // 或者 key.toJSON().privateKey。或者 key.privateKey.slice(2) 删除开头的'0x'如果是ethers.HDNode.fromMnemonic(secword)的结果
pubkey: key.publicKey.toString('hex'), pubkey: key.publicKey.toString('hex'),
} }
} }
@ -591,29 +591,29 @@ class TicCrypto {
* 从私钥到公钥 * 从私钥到公钥
* *
* @static * @static
* @param {*} seckey * @param {*} prikey
* @param {*} [option={}] * @param {*} [option={}]
* @return {*} * @return {*}
* @memberof TicCrypto * @memberof TicCrypto
*/ */
static seckey_to_pubkey ({ seckey, curve, compress } = {}) { static seckey_to_pubkey ({ prikey, curve, compress } = {}) {
if (this.is_seckey({ seckey }) && seckey.length === 64) { if (this.is_seckey({ prikey }) && prikey.length === 64) {
// 只能用于32字节的私钥（BTC, ETH)。也就是不能用于 TIC 的私钥。 // 只能用于32字节的私钥（BTC, ETH)。也就是不能用于 TIC 的私钥。
curve = my.CURVE_LIST.includes(curve) ? curve : my.CURVE // 默认为 secp256k1 curve = my.CURVE_LIST.includes(curve) ? curve : my.CURVE // 默认为 secp256k1
// return new crypto.createECDH(curve).setPrivateKey(seckey,'hex').getPublicKey('hex', compress===false?'uncompressed':'compressed') // ecdh.getPublicKey(不加参数) 默认为 'compressed'。用 HBuilderX 2.6.4 打包成ios或安卓 app 后 setPrivateKey() 报错：TypeError: null is not an object (evaluating 'this.rand.getBytes') // return new crypto.createECDH(curve).setPrivateKey(prikey,'hex').getPublicKey('hex', compress===false?'uncompressed':'compressed') // ecdh.getPublicKey(不加参数) 默认为 'compressed'。用 HBuilderX 2.6.4 打包成ios或安卓 app 后 setPrivateKey() 报错：TypeError: null is not an object (evaluating 'this.rand.getBytes')
// 从 nodejs 10.0 开始，还有 crypto.ECDH.convertKey 方法，更直接。但可惜，浏览器里不存在 crypto.ECDH。 // 从 nodejs 10.0 开始，还有 crypto.ECDH.convertKey 方法，更直接。但可惜，浏览器里不存在 crypto.ECDH。
return this.buf_to_hex(secp256k1.publicKeyCreate(Buffer.from(seckey, 'hex'), compress !== false)) // 可用于浏览器。缺省输出压缩公钥，compress=false时输出非压缩公钥。 return this.buf_to_hex(secp256k1.publicKeyCreate(Buffer.from(prikey, 'hex'), compress !== false)) // 可用于浏览器。缺省输出压缩公钥，compress=false时输出非压缩公钥。
// 或者 bitcorelib.PublicKey.fromPrivateKey(new bitcorelib.PrivateKey(seckey)).toString('hex') // 可用于浏览器 // 或者 bitcorelib.PublicKey.fromPrivateKey(new bitcorelib.PrivateKey(prikey)).toString('hex') // 可用于浏览器
// 或者 const ecc = require('eccrypto') // 或者 const ecc = require('eccrypto')
// if (compress===false){ // if (compress===false){
// return ecc.getPublic(this.hex_to_buf(seckey)).toString('hex') // return ecc.getPublic(this.hex_to_buf(prikey)).toString('hex')
// }else{ // }else{
// return ecc.getPublicCompressed(this.hex_to_buf(seckey)).toString('hex') // return ecc.getPublicCompressed(this.hex_to_buf(prikey)).toString('hex')
// } // }
// 注意，Buffer.from(nacl.box.keyPair.fromSecretKey(Buffer.from(seckey,'hex')).publicKey).toString('hex') 得到的公钥与上面的不同 // 注意，Buffer.from(nacl.box.keyPair.fromSecretKey(Buffer.from(prikey,'hex')).publicKey).toString('hex') 得到的公钥与上面的不同
} else if (this.is_seckey({ seckey }) && seckey.length === 128) { } else if (this.is_seckey({ prikey }) && prikey.length === 128) {
// 用于64字节=128 hex的 TIC 私钥 // 用于64字节=128 hex的 TIC 私钥
let keypair = nacl.sign.keyPair.fromSecretKey(Buffer.from(seckey, 'hex')) let keypair = nacl.sign.keyPair.fromSecretKey(Buffer.from(prikey, 'hex'))
return Buffer.from(keypair.publicKey).toString('hex') // 测试过 不能直接keypair.publicKey.toString('hex')，不是buffer类型 return Buffer.from(keypair.publicKey).toString('hex') // 测试过 不能直接keypair.publicKey.toString('hex')，不是buffer类型
} }
return null return null
@ -623,21 +623,21 @@ class TicCrypto {
* 从私钥到地址 * 从私钥到地址
* *
* @static * @static
* @param {*} seckey * @param {*} prikey
* @param {*} option * @param {*} option
* @return {*} * @return {*}
* @memberof TicCrypto * @memberof TicCrypto
*/ */
static seckey_to_address ({ seckey, coin, world } = {}) { static seckey_to_address ({ prikey, coin, world } = {}) {
coin = coin?.toUpperCase() || my.COIN coin = coin?.toUpperCase() || my.COIN
if (this.is_seckey({ seckey })) { if (this.is_seckey({ prikey })) {
/** @type {*} */ /** @type {*} */
let pubkey let pubkey
if (coin === 'ETH') { if (coin === 'ETH') {
pubkey = this.seckey_to_pubkey({ seckey, compress: false }) pubkey = this.seckey_to_pubkey({ prikey, compress: false })
return this.pubkey_to_address({ pubkey: pubkey, coin, world }) return this.pubkey_to_address({ pubkey: pubkey, coin, world })
} else { } else {
pubkey = this.seckey_to_pubkey({ seckey, compress: true }) pubkey = this.seckey_to_pubkey({ prikey, compress: true })
return this.pubkey_to_address({ pubkey: pubkey, coin, world }) return this.pubkey_to_address({ pubkey: pubkey, coin, world })
} }
} }
@ -912,14 +912,14 @@ class TicCrypto {
kp = nacl.sign.keyPair() kp = nacl.sign.keyPair()
} }
return { return {
seckey: Buffer.from(kp.secretKey).toString('hex'), prikey: Buffer.from(kp.secretKey).toString('hex'),
pubkey: Buffer.from(kp.publicKey).toString('hex'), pubkey: Buffer.from(kp.publicKey).toString('hex'),
} }
} else { } else {
let seckey = this.randomize_seckey() let prikey = this.randomize_seckey()
let pubkey = this.seckey_to_pubkey({ seckey }) let pubkey = this.seckey_to_pubkey({ prikey })
return { return {
seckey, prikey,
pubkey, pubkey,
} }
} }