关键词:eos 签名 验签 ecc dsa 加密 解密 eosjs aes
本文主要探讨两方面
1.eosjs中用密钥对进行加解密功能
2.eos中密钥对生成,签名和验签过程(私钥签名 公钥验签)常用的加密算法
对称性加密算法
对称式加密就是加密和解密使用同一个密钥,信息接收双方都需事先知道密匙和加解密算法，之后便是对数据进行加解密了.对称加密算法用来对敏感数据等信息进行加密。
对称性加密算法有:AES、DES、3DES
DES(Data EncryptionStandard):数据加密标准,速度较快,适用于加密大量数据的场合.
3DES(Triple DES):是基于DES,对一块数据用三个不同的密钥进行三次加密,强度更高.
AES(Advanced EncryptionStandard):高级加密标准,是下一代的加密算法标准,速度快,安全级别高;AES是一个使用128为分组块的分组加密算法,分组块和128 192或256位的密钥一起作为输入,对4×4的字节数组上进行操作.众所周之AES是种十分高效的算法,尤其在8位架构中,这源于它面向字节的设计.AES 适用于8位的小型单片机或者普通的32位微处理器,并且适合用专门的硬件实现,硬件实现能够使其吞吐量(每秒可以到达的加密/解密bit数)达到十亿量级.同样,其也适用于RFID系统非对称算法
非对称式加密就是加密和解密所使用的不是同一个密钥,通常有两个密钥,称为"公钥"和"私钥",它们两个必需配对使用,否则不能打开加密文件.发送双方A,B事先均生成一堆密匙,然后A将自己的公有密匙发送给B,B将自己的公有密匙发送给A,如果A要给B发送消息,则先需要用B的公有密匙进行消息加密,然后发送给B端,此时B端再用自己的私有密匙进行消息解密,B向A发送消息时为同样的道理
非对称性算法有:RSA、DSA、ECC
RSA:由 RSA 公司发明,是一个支持变长密钥的公共密钥算法,需要加密的文件块的长度也是可变的.RSA在国外早已进入实用阶段,已研制出多种高速的RSA的专用芯片.
DSA(Digital SignatureAlgorithm):数字签名算法，是一种标准的DSS(数字签名标准),严格来说不算加密算法.
ECC(Elliptic CurvesCryptography):椭圆曲线密码编码学.ECC和RSA相比具有多方面的绝对优势,主要有:抗攻击性强.相同的密钥长度,其抗攻击性要强很多倍.计算量小,处理速度快.ECC总的速度比RSA、DSA要快得多.存储空间占用小.ECC的密钥尺寸和系统参数与RSA、DSA相比要小得多,意味着它所占的存贮空间要小得多.这对于加密算法在IC卡上的应用具有特别重要的意义.带宽要求低.当对长消息进行加解密时,三类密码系统有相同的带宽要求,但应用于短消息时ECC带宽要求却低得多.带宽要求低使ECC在无线网络领域具有广泛的应用前景散列算法
散列算法,是一种单向的不可逆的加密算法.它对不同长度的输入消息,产生固定长度的输出.多用于网络传输过程验证数据的完整性
散列算法(签名算法)有:MD5、SHA1
用途:主要用于验证,防止信息被修.具体用途如:文件校验、数字签名、鉴权协议总结
对称加密算法,速度快,安全性低,目前大量数据加密建议采用对称加密算法，提高加解密速度
非对称加密算法,速度较慢,安全性高,小量的机密数据，可以采用非对称加密算法。
实际工作中常用的方式是采用非对称加密算法管理对称算法的密钥，然后用对称加密算法加密数据，这样我们就集成了两类加密算法的优点，既实现了加密速度快的优点，又实现了安全方便管理密钥的优点。eosjs中用密钥对进行加解密功能
场景一
AES的Key经过接收方公钥加密和AES加密的内容 一起发送给接收方，接收方通过自己私钥先将加密后的AES_KEY解密，再通过解密得到的原始AES_KEY，并用该key解密发送方发送的内容，得到明文
结论 这种算法是目前市面上常用的,既增加了安全性又提升了加密速度
场景二
先来看一下ECC 数学函数 Q=dG; (Q是公钥 d是私钥 G是他们之间的关系)；Q1 = d1G1; Q2=d2G2;那么能推出 key＝Q1d2G2 = Q2d1G1;
结论 1的公钥和2的私钥 2的公钥和1的私钥 他们能得到一个相同的值 key,这个相同的key 作为他们之间AES加解密的key eosjs就是通过这种方式实现的
通过对eosjs中ecc库的测试 结果跟上边的场景二是一致的我们通过分析源码来看一下
someonesPrivateKey = ecc.seedPrivate("someone");
someonesPublicKey = ecc.privateToPublic(someonesPrivateKey);
console.log('someonesPrivateKey:\t', someonesPrivateKey.toString())
console.log('someonesPublicKey:\t', someonesPublicKey.toString())
myPrivate = ecc.seedPrivate("my");
myPublic = ecc.privateToPublic(myPrivate);
console.log('myPrivate:\t', myPrivate.toString())
console.log('myPublic:\t', myPublic.toString())
encryptedMessage = ecc.Aes.encrypt(myPrivate, someonesPublicKey, message)//MY用自己的私钥和someone的公钥进行加密
decryptedMessage = ecc.Aes.decrypt(someonesPrivateKey, myPublic, encryptedMessage.nonce, encryptedMessage.message, encryptedMessage.checksum)//someone用自己的私钥和my的公钥进行解密随机生成两对密钥对
最重要的是加密encrypt和解密decrypt这两个函数
function encrypt(private_key, public_key, message) {
var nonce = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : uniqueNonce();
return crypt(private_key, public_key, nonce, message);
}
function decrypt(private_key, public_key, nonce, message, checksum) {
return crypt(private_key, public_key, nonce, message, checksum).message;
}他们两个其实都是通过一个crypt函数实现的,我们看一下crypt的具体实现流程
function crypt(private_key, public_key, nonce, message, checksum) {
private_key = PrivateKey(private_key);//检查私钥的合理性,是否符合sha256x2, K1等算法要求,这一部分稍后会详细的跟踪一下
if (!private_key) throw new TypeError('private_key is required');
public_key = PublicKey(public_key);//验证公钥的合法性,这里对公钥进行了去除EOS头的处理
if (!public_key) throw new TypeError('public_key is required');
nonce = toLongObj(nonce);//随机或唯一uint64在重新使用相同的私钥/公钥时提供熵,这个nonce是通过时间生成的,我测试了如果 不加这个逻辑加解密也没问题,应该是增加安全性的吧,后续会再继续跟踪
if (!nonce) throw new TypeError('nonce is required');
console.log('nonce:\t', nonce.toString())
//这一部分是将要加密的格式转换成封装的Buffer格式,Buffer支持"ascii" | "utf8" | "utf16le" | "ucs2" | "base64" | "latin1" | "binary" | "hex"编码格式
if (!Buffer.isBuffer(message)) {
if (typeof message !== 'string') throw new TypeError('message should be buffer or string');
message = new Buffer(message, 'binary');
}
if (checksum && typeof checksum !== 'number') throw new TypeError('checksum should be a number');
var S = private_key.getSharedSecret(public_key);//获取共享密钥key,这个key在函数中调用了一次hash.sha512
var ebuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);//
ebuf.writeUint64(nonce);
ebuf.append(S.toString('binary'), 'binary');
ebuf = new Buffer(ebuf.copy(0, ebuf.offset).toBinary(), 'binary');
var encryption_key = hash.sha512(ebuf);//对数据又进行了一次hash
// D E B U G
console.log('crypt', {
priv_to_pub: private_key.toPublic().toString(),
pub: public_key.toString(),
nonce: nonce.toString(),
message: message.length,
checksum,
S: S.toString('hex'),
encryption_key: encryption_key.toString('hex'),
})
var iv = encryption_key.slice(32, 48);//获取AES需要的IV初始向量
var key = encryption_key.slice(0, 32);//获取AES的密钥
//获取共享秘密校验和,这个用来校验两端获取的key是否一致
var check = hash.sha256(encryption_key);
check = check.slice(0, 4);
var cbuf = ByteBuffer.fromBinary(check.toString('binary'), ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
check = cbuf.readUint32();
if (checksum) {
if (check !== checksum) throw new Error('Invalid key');
message = cryptoJsDecrypt(message, key, iv);//aes解密
} else {
message = cryptoJsEncrypt(message, key, iv);//aes加密
}
return { nonce: nonce, message: message, checksum: check };
}
这里边最重要的一个函数 就是getSharedSecret,通过这个接口 就实现了场景二中提到的 1的公钥和2的私钥 2的公钥和1的私钥 他们能得到一个相同的key
看一下他内部做了一些什么操作
function getSharedSecret(public_key) {
public_key = PublicKey(public_key);//验证公钥的合法性,这里对公钥进行了去除EOS头的处理
var KB = public_key.toUncompressed().toBuffer();//获取公开密钥K
var KBP = Point.fromAffine(secp256k1, BigInteger.fromBuffer(KB.slice(1, 33)), // x
BigInteger.fromBuffer(KB.slice(33, 65)) // y
);//获取K的椭圆曲线上的映射点(x,y)
var r = toBuffer();
var P = KBP.multiply(BigInteger.fromBuffer(r));//KBP对应的(x,y)分别和r进行相乘获取新的点point
var S = P.affineX.toBuffer({ size: 32 });//新生成的point的X坐标
// SHA512 used in ECIES
return hash.sha512(S);
}具体的aes加密和解密函数
function cryptoJsDecrypt(message, key, iv) {
message.toString(),key.toString('hex'), iv.toString('hex'))
assert(message, "Missing cipher text");
message = toBinaryBuffer(message);
var decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
// decipher.setAutoPadding(true)
message = Buffer.concat([decipher.update(message), decipher.final()]);
return message;
}
function cryptoJsEncrypt(message, key, iv) {
message.toString(),key.toString('hex'), iv.toString('hex'))
assert(message, "Missing plain text");
message = toBinaryBuffer(message);
var cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
// cipher.setAutoPadding(true)
message = Buffer.concat([cipher.update(message), cipher.final()]);
return message;
}对应java也有封装的库可以调用
对应的aes-256-cbc为aes的256位的cbc模式 这个后续会继续介绍
eos中密钥对生成,签名和验签过程
1.密钥对生成
当我们在终端输入下面命令时 可以获取一对密钥对
wls@wls-TM1701:~/9f-git/eosjs/api/local$ cleos create key --to-console
Private key: 5HptWorg6Q8ao3i7i1AjWnEoou1AZwoaTEkfpo1LeXrT9afBawS
Public key: FZS7BoDwkm4oZiWobX3HH9wtJ27a42RQuJm6en2ZnJfX1K4yDyKTV
让我们看一下内部是如何实现的
cleos对应main.cpp中如下代码
bool r1 = false;
string key_file;
bool print_console = false;
// create key
auto create_key = create->add_subcommand("key", localized("Create a new keypair and print the public and private keys"))->set_callback( [&r1, &key_file, &print_console](){
if (key_file.empty() && !print_console) {
std::cerr << "ERROR: Either indicate a file using \"--file\" or pass \"--to-console\"" << std::endl;//当--file和--to-console都没有指定的时候 退出
return;
}
auto pk = r1 ? private_key_type::generate_r1() : private_key_type::generate();//默认K1方式 当参数制定--ri时 采用r1方式
auto privs = string(pk);
auto pubs = string(pk.get_public_key());
if (print_console) {
std::cout << localized("Private key: ${key}", ("key", privs) ) << std::endl;
std::cout << localized("Public key: ${key}", ("key", pubs ) ) << std::endl;
} else {
std::cerr << localized("saving keys to ${filename}", ("filename", key_file)) << std::endl;
std::ofstream out( key_file.c_str() );
out << localized("Private key: ${key}", ("key", privs) ) << std::endl;
out << localized("Public key: ${key}", ("key", pubs ) ) << std::endl;
}
});ecc的ri和k1方式区别在哪儿 我们继续跟踪
template< typename KeyType = ecc::private_key_shim >//这里是定义在ecc命令空间中
static private_key generate() {
return private_key(storage_type(KeyType::generate()));
}
template< typename KeyType = r1::private_key_shim >//这里定义在fc::ri的命名空间中
static private_key generate_r1() {
return private_key(storage_type(KeyType::generate()));
}可以两个定义在不同的命名空间中
下面我们具体分析这两种命名空间中具体代码的实现区别
ecc命名空间中的调用代码
private_key private_key::generate()
{
EC_KEY* k = EC_KEY_new_by_curve_name( NID_secp256k1 );//首先通过椭圆曲线的标识符NID_secp256k1生成一个EC_KEY,通过这种方式生成的EC_KEY里已经包含了椭圆曲线的参数。否则，需要手动设置EC_GROUP
if( !k ) FC_THROW_EXCEPTION( exception, "Unable to generate EC key" );
if( !EC_KEY_generate_key( k ) )//生成私钥和公钥
{
FC_THROW_EXCEPTION( exception, "ecc key generation error" );
}
return private_key( k );
} ri命名空间中的实现代码
private_key private_key::generate()
{
private_key self;
EC_KEY* k = EC_KEY_new_by_curve_name( NID_X9_62_prime256v1 );//首先通过椭圆曲线的标识符NID_X9_62_prime256v1生成一个EC_KEY,通过这种方式生成的EC_KEY里已经包含了椭圆曲线的参数。否则，需要手动设置EC_GROUP
if( !k ) FC_THROW_EXCEPTION( exception, "Unable to generate EC key" );
self.my->_key = k;
if( !EC_KEY_generate_key( self.my->_key ) )//生成私钥和公钥
{
FC_THROW_EXCEPTION( exception, "ecc key generation error" );
}通过跟踪标识符的定义发现还有好多种不同的曲线算法,不同的椭圆曲线只有参数上的不同。所以，算出正确签名的前提是设置正确的参数
fc::sha256 private_key::get_secret( const EC_KEY * const k )
{
if( !k )
{
return fc::sha256();
}
fc::sha256 sec;
const BIGNUM* bn = EC_KEY_get0_private_key(k);
if( bn == NULL )
{
FC_THROW_EXCEPTION( exception, "get private key failed" );
}
int nbytes = BN_num_bytes(bn);
BN_bn2bin(bn, &((unsigned char*)&sec)[32-nbytes] );
return sec;
}签约和验签流程后续会补充