精华内容
下载资源
问答
  • 1.确定椭圆曲线 具体包括确定模数P;系数a和b;生成器点A,构造素数阶循环群q. 2.随机选取KPR值 随机选取整数d,且有0<d<q KPR=d 3.计算公钥 B=dA KPB=(P,A,B,q,A,B) 4.生成签名 1.选择临时密钥Ke,其中0<...
  • 椭圆曲线数字签名算法(ECDSA)是使用椭圆曲线数字签名算法(DSA)的模拟,与普通的离散对数问题(discrete logarithm problem DLP)和大数分解问题(integer factorization problem IFP)不同,椭圆曲线离散对数...
  • 椭圆曲线数字签名算法

    千次阅读 2020-10-11 00:53:04
    椭圆曲线密码学(ECC,Elliptic Curve Cryptogphay)是一种流行的非对称加密算法,其背后的数学原理,是椭圆曲线上的离散对数难题。我们还知道,ECC 的私钥,本质是一个整数,其对应的公钥,是椭圆曲线上的一个点。 ...

    https://aaron67.cc/2020/09/30/ecdsa/

    在文章非对称加密和签名认证中,我们介绍了双钥系统的两种应用场景:

    • 加密解密时,公钥用于加密,私钥用于解密
    • 身份认证时,私钥用于签名,公钥用于验证

    椭圆曲线密码学(ECC,Elliptic Curve Cryptogphay)是一种流行的非对称加密算法,其背后的数学原理,是椭圆曲线上的离散对数难题。我们还知道,ECC 的私钥,本质是一个整数,其对应的公钥,是椭圆曲线上的一个点。

    在将 ECC 作为双钥系统使用时,针对不同的应用场景,会涉及到不同的算法。常见的有

    • 在加密和解密时使用的椭圆曲线集成加密框架(ECIES,Elliptic Curve Integrated Encryption Schema)
    • 用于协商和交换公共密钥的椭圆曲线 Diffie-Hellman 密钥交换算法(ECDH,Elliptic Curve Diffie-Hellman Key Exchange)
    • 用于生成和验证数字签名的椭圆曲线数字签名算法(ECDSA,Elliptic Curve Digital Signature Algorithm)

    本文将介绍并实现 ECDSA 的相关内容。

    签名

    用私钥 a a a 对消息 m m m 签名,得到的结果是两个整数 ( r , s ) (r, s) (r,s) ,计算过程如下。

    • 随机生成临时私钥 k k k,并计算其对应的公钥 K = k ⋅ G = ( x K , y K ) K = k \cdot G = (x_K, y_K) K=kG=(xK,yK)
    • 计算 r = x K   m o d   n r = x_K \bmod{n} r=xKmodn,若 r r r 为 0,则回到第一步
    • 计算消息 m m m 的哈希 e = h a s h ( m ) e = hash(m) e=hash(m),并将 e e e 的二进制序列转成一个整数
    • 计算 s = k − 1 ( e + r a )   m o d   n s = k^{-1}(e + ra) \bmod{n} s=k1(e+ra)modn,若 s s s 为 0,则回到第一步
    • 得到签名 ( r , s ) (r, s) (r,s)
    import hashlib
    
    
    def sha256(payload: bytes) -> bytes:
        return hashlib.sha256(payload).digest()
    
    
    def double_sha256(payload: bytes) -> bytes:
        return sha256(sha256(payload))
    
    import random
    
    
    def hash_to_int(message: bytes) -> int:
        """Calculate the bitcoin double-sha256 hash of the message, return as an integer"""
        h = double_sha256(message)
        return int.from_bytes(h, byteorder='big')
    
    
    def sign(private_key: int, message: bytes) -> tuple:
        """Create ECDSA signature (r, s)"""
        e = hash_to_int(message)
        r, s = 0, 0
        while not r or not s:
            k = random.randrange(1, curve.n)
            k_x, _ = scalar_multiply(k, curve.g)
            r = k_x % curve.n
            s = ((e + r * private_key) * modular_multiplicative_inverse(k, curve.n)) % curve.n
        return r, s
    

    如果每次签名都使用相同的 k k k,当知道了消息 e 1 e_1 e1 e 2 e_2 e2 和签名 ( r 1 , s 1 ) (r_1, s_1) (r1,s1) ( r 2 , s 2 ) (r_2, s_2) (r2,s2) 时,有

    • r 1 = r 2 r_1 = r_2 r1=r2,因为 k k k 相同
    • 根据 s s s 的定义,有 s 1 − s 2 = k − 1 ( e 1 − e 2 )   m o d   n s_1 - s_2 = k^{-1}(e_1 - e_2) \bmod{n} s1s2=k1(e1e2)modn
    • 将上式两边同时乘以 k k k 再除以 ( s 1 − s 2 ) (s_1 - s_2) (s1s2),有 k = ( s 1 − s 2 ) − 1 ( e 1 − e 2 )   m o d   n k = (s_1 - s_2)^{-1}(e_1 - e_2) \bmod{n} k=(s1s2)1(e1e2)modn

    这样就得到了 k k k,再根据 s = k − 1 ( e + r a )   m o d   n s = k^{-1}(e + ra) \bmod{n} s=k1(e+ra)modn,从而反推出 a = r − 1 ( s k − e )   m o d   n a = r^{-1}(sk - e) \bmod{n} a=r1(ske)modn。类似的攻击方法在 k k k 值可预测时也能使用。

    所以请务必注意,每次签名时使用的 k k k,都需要保证绝对私密且生成时足够随机,以保证私钥 a a a 的安全。

    验签

    用公钥 A A A 和消息 m m m 验证签名 ( r , s ) (r, s) (r,s),过程如下。

    • 计算消息 m m m 的哈希 e = h a s h ( m ) e = hash(m) e=hash(m),并将 e e e 的二进制序列转成一个整数
    • 计算整数 u 1 = s − 1 e   m o d   n u_1 = s^{-1}e \bmod{n} u1=s1emodn
    • 计算整数 u 2 = s − 1 r   m o d   n u_2 = s^{-1}r \bmod{n} u2=s1rmodn
    • 计算点 P = u 1 ⋅ G + u 2 ⋅ A = ( x P , y P ) P = u_1 \cdot G + u_2 \cdot A = (x_P, y_P) P=u1G+u2A=(xP,yP)
    • 当且仅当 r = x P   m o d   n r = x_P \bmod{n} r=xPmodn 时,验签成功
    def verify_signature(public_key: tuple, message: bytes, signature: tuple) -> bool:
        """Verify signature with public key and message"""
        e = hash_to_int(message)
        r, s = signature
        w = modular_multiplicative_inverse(s, curve.n)
        u1 = (w * e) % curve.n
        u2 = (w * r) % curve.n
        x, _ = add(scalar_multiply(u1, curve.g), scalar_multiply(u2, public_key))
        return r == (x % curve.n)
    

    证明

    在开始之前,需要先明确一点:椭圆曲线上点的加法运算,符合交换律和结合律。

    所以有 a G + b G = ( a + b ) ⋅ G aG + bG = (a + b) \cdot G aG+bG=(a+b)G,因为

    a G + b G = G + G + . . . + G ⏟ _ a   个 + G + G + . . . + G ⏟ _ b   个 = G + G + . . . + G ⏟ _ ( a + b )   个 = ( a + b ) ⋅ G aG + bG = \underbrace{G + G + ... + G}\_{a\ 个} + \underbrace{G + G + ... + G}\_{b\ 个} = \underbrace{G + G + ... + G}\_{(a + b)\ 个} = (a + b) \cdot G aG+bG= G+G+...+G_a + G+G+...+G_b = G+G+...+G_(a+b) =(a+b)G

    进一步的,有 a ⋅ b G = a b ⋅ G a \cdot bG = ab \cdot G abG=abG,因为

    a ⋅ b G = b G + b G + . . . + b G ⏟ _ a   个 = ( G + . . . + G ) + . . . + ( G + . . . + G ) ⏟ _ a   个 = G + G + . . . + G ⏟ _ a b   个 = a b ⋅ G a \cdot bG = \underbrace{bG + bG + ... + bG}\_{a\ 个} = \underbrace{(G + ... + G) + ... + (G + ... + G)}\_{a\ 个} = \underbrace{G + G + ... + G}\_{ab\ 个} = ab \cdot G abG= bG+bG+...+bG_a = (G+...+G)+...+(G+...+G)_a = G+G+...+G_ab =abG

    让我们借助上面这两个推论,通过公式变换,证明验签过程的正确性。

    已知 A = a G A = aG A=aG,则

    P = u 1 ⋅ G + u 2 ⋅ A = u 1 ⋅ G + u 2 ⋅ a G = ( u 1 + u 2 a ) ⋅ G P = u_1 \cdot G + u_2 \cdot A = u_1 \cdot G + u_2 \cdot aG = (u_1 + u_2a) \cdot G P=u1G+u2A=u1G+u2aG=(u1+u2a)G

    带入 u 1 u_1 u1 u 2 u_2 u2 的定义,则

    P = ( u 1 + u 2 a ) ⋅ G = ( s − 1 e + s − 1 r a ) ⋅ G = s − 1 ( e + r a ) ⋅ G P = (u_1 + u_2a) \cdot G = (s^{-1}e + s^{-1}ra) \cdot G = s^{-1}(e + ra) \cdot G P=(u1+u2a)G=(s1e+s1ra)G=s1(e+ra)G

    请注意,这里我们忽略了 u 1 u_1 u1 u 2 u_2 u2 定义中的模 n n n 运算,这不会有任何问题,因为 a ⋅ G = ( a   m o d   n ) ⋅ G a \cdot G = (a \bmod{n}) \cdot G aG=(amodn)G。如果你想知道为什么,可以搜索关键字“循环子群”阅读更多资料。

    我们还知道 s = k − 1 ( e + r a )   m o d   n s = k^{-1}(e + ra) \bmod{n} s=k1(e+ra)modn,将等式两边同时乘以 k k k 再除以 s s s,就会得到

    k = s − 1 ( e + r a )   m o d   n k = s^{-1}(e + ra) \bmod{n} k=s1(e+ra)modn

    也就是说,如果 ( r , s ) (r, s) (r,s) 正确,验签时计算出的点 P P P 就是签名时临时私钥 k k k 对应的公钥。

    P = s − 1 ( e + r a ) ⋅ G = k ⋅ G = ( x P , y P ) P = s^{-1}(e + ra) \cdot G = k \cdot G = (x_P, y_P) P=s1(e+ra)G=kG=(xP,yP)

    根据 r r r 的定义,即当且仅当 r = x P   m o d   n r = x_P \bmod{n} r=xPmodn 时,验签成功。

    验证

    我们可以写一个简单的例子来测试代码。

    if __name__ == '__main__':
        # 私钥
        priv_key = 0xf97c89aaacf0cd2e47ddbacc97dae1f88bec49106ac37716c451dcdd008a4b62
        # 公钥
        pub_key = scalar_multiply(priv_key, curve.g)
        # 要签名的消息
        plain_text = '你好世界'
        digest = sha256(plain_text.encode('utf-8'))
        # 签名
        sig_r, sig_s = sign(priv_key, digest)
        print(' r =', sig_r)
        print(' s =', sig_s)
        # 验证签名 (r, s)
        print(verify_signature(pub_key, digest, (sig_r, sig_s)))
    

    运行结果为

    r = 114587593887127314608220924841831336233967095853165151956820984900193959037698
    s = 24000727837347392504013031837120627225728348681623127776947626422811445180558
    True
    

    输出符合预期。

    签名的“对称性”

    对 ECDSA 签名 ( r , s ) (r, s) (r,s),在验证时如果使用 ( r , − s   m o d   n ) (r, -s \bmod{n}) (r,smodn),则也能验签成功。

    if __name__ == '__main__':
        #
        # ...
        #
        # 验证签名 (r, -s)
        negative_s = -sig_s % curve.n
        print('-s =', negative_s)
        print(verify_signature(pub_key, digest, (sig_r, negative_s)))
    

    运行结果为

     r = 106466997694091524629965845090867478458136818253940782993316021692670806749258
     s = 62904381853960967395432938678025872957596216909471919761592805395928247608025
    True
    -s = 52887707383355228028138046330662034895241347369602984621012357745589913886312
    True
    

    这个“特性”本文暂不展开介绍,直接把结论放在这里,以保证整体内容的完整性。

    完整代码

    sign.py

    参考

    展开全文
  • 椭圆曲线数字签名算法——ECDSA1. 算法简述3. 代码实现3.1 算法实现3.2 测试代码3.3 运行结果 1. 算法简述 该算法是微软操作系统及办公软件的序列号验证算法。 ECDSA(Elliptic Curve Digital Signature Algorithm, ...

    @TOC

    1. 算法简述

    该算法是微软操作系统及办公软件的序列号验证算法。
    ECDSA(Elliptic Curve Digital Signature Algorithm, 椭圆曲线数字签名算法) 于1999年作为ANSI标准, 并于2000年成为IEEE和NIST标准。

    ECDSA算法具有速度快、强度高、签名短等有点。

    3. 代码实现

    Java中未对该算法做实现, 而在Bouncy Castle中有该算法实现。

    下面的表格说明了实现细节。

    算法密钥长度密钥默认长度签名长度备注
    NONEwithECDSA、RIPEMD160withECDSA、SHA1withECDSA、SHA224withECDSA、SHA256withECDSA、SHA384withECDSA、SHA512withECDSA--128、160、160、224、256、384、512Bouncy Castle实现

    3.1 算法实现

    基于Bouncy Castle的 ECDSA算法实现

    package com.calvin.android.demo2.secrity;
    
    import org.bouncycastle.jce.ECNamedCurveTable;
    import org.bouncycastle.jce.provider.BouncyCastleProvider;
    import org.bouncycastle.jce.spec.ECParameterSpec;
    
    import java.security.Key;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.PrivateKey;
    import java.security.Provider;
    import java.security.PublicKey;
    import java.security.SecureRandom;
    import java.security.Security;
    import java.security.Signature;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * Author:cl
     * Email:lhzheng@grandstream.cn
     * Date:20-10-21
     */
    //java – 在BouncyCastle上使用数字签名算法(ECDSA)实现的椭圆曲线 http://www.voidcn.com/article/p-vmamxfcn-bup.html
    public class ECDSACoder {
        /**
         * 数字签名密钥算法
         */
        public static final String KEY_ALGORITHM = "ECDSA";
    
        /**
         * 数字签名
         * 签名/验证算法
         */
        public static final String SIGNATURE_ALGORITHM = "SHA1withECDSA";
    
        //公钥 Map Key
        private static final String PUBLIC_KEY = "ECDSAPublicKey";
        //私钥Map key
        private static final String PRIVATE_KEY = "ECDSAPrivateKey";
    
        /**
         * DSA密钥长度,默认1024位,密钥长度必须是64的倍数,范围512~1024位之间
         */
        private static final int KEY_SIZE = 1024;
    
        /**
         * 签名
         * @param data 待签名数据
         * @param privateKey 私钥
         * @return byte[] 数字签名
         * @throws Exception 异常
         */
        public static byte[] sign(byte[] data, byte[] privateKey) throws Exception {
            //转换私钥材料
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKey);
            //实例化密钥工厂
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            //取私钥对象
            PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
            //实例化Signature
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM, "BC");
            //初始化Signature
            signature.initSign(priKey);
            //更新
            signature.update(data);
            //签名
            return signature.sign();
        }
    
        /**
         * 校验
         * @param data 待校验数据
         * @param publicKey 公钥
         * @param sign 数字签名
         * @return boolean 校验成功返回true,校验失败返回false
         * @throws Exception
         */
        public static boolean verity(byte[] data, byte[] publicKey, byte[] sign) throws  Exception{
            //转换公钥材料
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
            //实例化密钥工厂
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            //生成公钥
            PublicKey pubKey = keyFactory.generatePublic(keySpec);
            //实例化Signature
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM, "BC");
            //初始化Signature
            signature.initVerify(pubKey);
            //更新
            signature.update(data);
            //校验证
            return signature.verify(sign);
        }
    
        public static Map<String, Object> initKey() throws Exception {
            //实例化BC Provider
            Provider bcProvider = new BouncyCastleProvider();
            Security.removeProvider("BC");
            Security.addProvider(bcProvider);
    
            ECParameterSpec ecSpec = ECNamedCurveTable.getParameterSpec("B-571");
            //实例化密钥对生成器
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM, "BC");
            keyPairGen.initialize(ecSpec, new SecureRandom());
    
            //生成密钥对
            KeyPair keyPair = keyPairGen.generateKeyPair();
            //公钥
            PublicKey publicKey = (PublicKey)keyPair.getPublic();
            //私钥
            PrivateKey privateKey = (PrivateKey)keyPair.getPrivate();
            //封装密钥
            Map<String, Object> keyMap = new HashMap<>(2);
            keyMap.put(PUBLIC_KEY, publicKey);
            keyMap.put(PRIVATE_KEY, privateKey);
            return keyMap;
        }
    
        public static byte[] getPublicKey(Map<String, Object> keyMap){
            return  ((Key)keyMap.get(PUBLIC_KEY)).getEncoded();
        }
    
        public static byte[] getPrivateKey(Map<String, Object> keyMap){
            return  ((Key)keyMap.get(PRIVATE_KEY)).getEncoded();
        }
    }
    
    

    3.2 测试代码

    @Test
        public void ecdsaSignTest() throws Exception {
            //初始化密钥
            Map<String, Object> keyMap = ECDSACoder.initKey();
            byte[] publicKey = ECDSACoder.getPublicKey(keyMap);
            byte[] privateKey = ECDSACoder.getPrivateKey(keyMap);
            System.out.println("ECDSA公钥:\t"+Base64.encodeToString(publicKey, Base64.DEFAULT));
            System.out.println("ECDSA私钥:\t"+Base64.encodeToString(privateKey, Base64.DEFAULT));
    
            String inputStr = "ECDSA数字签名";
            byte[] data = inputStr.getBytes();
            //产生签名
            byte[] sign = ECDSACoder.sign(data, privateKey);
            System.out.println("ECDSA签名:\t"+ Hex.toHexString(sign));
            //验证签名
            boolean status = ECDSACoder.verity(data, publicKey, sign);
            System.out.println("ECDSA验签状态:\t"+ status);
            assertTrue(status);
        }
    

    3.3 运行结果

    2020-10-21 15:41:36.454 16472-16487/com.calvin.android.demo2 I/System.out: ECDSA公钥:	MIGnMBAGByqGSM49AgEGBSuBBAAnA4GSAAQA9ile2ZpcTRb3y22xpaxeMcqJ0GuU8GuovBxpVnAC
    2020-10-21 15:41:36.455 16472-16487/com.calvin.android.demo2 I/System.out: xeEjE0UdFe8V+8T0cCrhCw8zkJjvv+lpAlX+NtedI1oIL9APgIzOFEACBNB5qQwFYQn9hh8PA5P+
    2020-10-21 15:41:36.455 16472-16487/com.calvin.android.demo2 I/System.out: y+QXTgw6ATLGPfxg73U7Ydp51ZPXLt5VivuN+dOynDpoY8nJhIuhC4N6aNde2P6R+0u8mz2HAJY=
    2020-10-21 15:41:36.455 16472-16487/com.calvin.android.demo2 I/System.out: ECDSA私钥:	MIIBCQIBADAQBgcqhkjOPQIBBgUrgQQAJwSB8TCB7gIBAQRIA32LqVgupwwD8q7eItT6vM7X1xB8
    2020-10-21 15:41:36.455 16472-16487/com.calvin.android.demo2 I/System.out: OUZnP222ZEhIvLkHciYb7AQrRVX1XRuH2a8tX0LyH6YRHDBe9aPZkxyBpzkSGuaV9Ez8oAcGBSuB
    2020-10-21 15:41:36.455 16472-16487/com.calvin.android.demo2 I/System.out: BAAnoYGVA4GSAAQA9ile2ZpcTRb3y22xpaxeMcqJ0GuU8GuovBxpVnACxeEjE0UdFe8V+8T0cCrh
    2020-10-21 15:41:36.455 16472-16487/com.calvin.android.demo2 I/System.out: Cw8zkJjvv+lpAlX+NtedI1oIL9APgIzOFEACBNB5qQwFYQn9hh8PA5P+y+QXTgw6ATLGPfxg73U7
    2020-10-21 15:41:36.455 16472-16487/com.calvin.android.demo2 I/System.out: Ydp51ZPXLt5VivuN+dOynDpoY8nJhIuhC4N6aNde2P6R+0u8mz2HAJY=
    2020-10-21 15:41:36.705 16472-16487/com.calvin.android.demo2 I/System.out: ECDSA签名:	3081940248019e556404e8cfae0f752bef094de22d35677f231aa2262f353371d1f518b7429b9f49390a19fd212652fb1b271d3bd2170f8b23594d81e4779f61aff13f130d104613479e91ad76024800e4eafe20e9980e0a402693207ec11546f9c2a1fca1aa6e25f9de0b8416fd91b03b62e7090592dda26dd094a2b1338e6801b439cf5072ada0522daa2ef8ecc5c422f46a4efb2b3c
    2020-10-21 15:41:36.854 16472-16487/com.calvin.android.demo2 I/System.out: ECDSA验签状态:	true
    
    展开全文
  • 椭圆曲线数字签名算法

    椭圆曲线数字签名算法(ECDSA)

    首先,我们给出ECDSA处理过程的简要概述。本质上,包括四个基本要素:

    1. 参与数字签名的所有通信方都使用相同的全局域参数,用定义椭圆曲线以及曲线上的基点
    2. 签名者首先需要生成一对公钥、私钥。对于私钥,签名者选择一个随机数或者伪随机数作为签名者的私钥。使用随机数和基点,签名者计算出椭圆曲线上的另一解点,作为签名者的公钥
    3. 对于待签名的消息计算其hash值。使用私钥、全局域参数、hash值来产生签名、签名包括两个整数,r和s
    4. 如果要对签名进行验证,验证者使用签名者的公钥、全局域参数、整数s作为输入,并将计算得到的输出值v与收到的r进行比较。如果v=r,则签名通过

    接下来,我们依次介绍这四个基本元素

    全局域参数

    可用于密码应用的椭圆曲线有两类:上的素数域椭圆曲线和上的二次域椭圆曲线。对于ECDSA使用素数域椭圆曲线。ECDSA的全局域参数入戏:

    q           一个素数

    a,b    上的整数,通过等式来定义椭圆曲线

    G         满足椭圆曲线等式的基点,表示为

    n         点G的阶,即n是满足nG=0 的最小正整数。这也等于曲线上点的个数

     密钥产生

    每个签名者需要产生一个密钥对,包括一个私钥和一个公钥。签名者,假设是Bob,通过以下步骤产生上述两个密钥:

    1. 选择随机整数d,
    2. 计算Q=dG。得到一个曲线上的解点
    3. Bob的公钥是Q,私钥是d

    数字签名的产生与认证

    通过使用公开的全局域参数和手中的私钥,Bob对于消息m产生320字节数字签名的步骤如下:

    1. 选择一个随机整数或伪随机整数k,
    2. 计算曲线的解点p=(x,y)=kG,以及r =x mod n 。如果r=0,则跳到步骤1
    3. 计算 
    4. 计算e=H(m)。这里的H是hash函数SHA-2或SHA-3
    5. 计算 如果s=0,则跳到步骤1
    6. 消息m的签名是(r,s)对

    Alice拥有公开的全局域参数以及Bob的公钥,Alice收到Bob发送的消息以及数字签名后,对于签名的验证步骤如下:

    1. 检查r和s是否为1到n-1之内的整数
    2. 使用SHA,计算160位的hash值e=H(m)
    3. 计算
    4. 计算 和 
    5. 计算解点
    6. 当且晋档v=r时,接受Bob的签名

     

     

     

     

     

     

     

     

     

    展开全文
  • 椭圆曲线数字签名及验证 1.生成私钥和公钥 生成椭圆曲线对象 生成密钥对,返回私钥对象 编码生成公钥字节数组,参数是椭圆曲线、x坐标、y坐标 2.ECDSA数字签名 数字签名生成r、s的big.Int对象,参数是随机数、私钥、...
  • 基于哈希证明系统的区块链两方椭圆曲线数字签名算法研究 刘峰1,2, 杨杰2, 齐佳音2() 1.华东师范大学计算机科学与技术学院,上海 200062 2.上海对外经贸大学人工智能与变革管理研究院,上海 200336 收稿日期:2020-10-28...

    基于哈希证明系统的区块链两方椭圆曲线数字签名算法研究
    刘峰1,2, 杨杰2, 齐佳音2()

    1.华东师范大学计算机科学与技术学院,上海 200062
    2.上海对外经贸大学人工智能与变革管理研究院,上海 200336
    收稿日期:2020-10-28 出版日期:2021-01-10 发布日期:2021-02-23
    通讯作者: 齐佳音 E-mail:qijiayin@139.com
    作者简介:刘峰(1988—),男,湖北,博士研究生,主要研究方向为区块链、数据科学|杨杰(1998—),男,江苏,硕士研究生,主要研究方向为区块链、密码学、隐私保护|齐佳音(1972—),女,陕西,教授,博士,主要研究方向为人工智能
    基金资助:国家重点研发计划(2017YFB0803304);国家自然科学基金(72042004)

    Two-Party ECDSA for Blockchain Based on Hash Proof Systems
    LIU Feng1,2, YANG Jie2, QI Jiayin2()

    1. School of Computer Science and Technology, East China Normal University, Shanghai 200062, China
    2. Institute of Artificial Intelligence and Change Management,Shanghai University of International Business and Economics, Shanghai 200336, China
      Received:2020-10-28 Online:2021-01-10 Published:2021-02-23
      Contact: QI Jiayin E-mail:qijiayin@139.com

    摘要:

    椭圆曲线数字签名算法(ECDSA)是区块链密码学技术中常见的数字签名之一,其在加密货币、密钥身份认证等方面已被广泛应用。然而当前的区块链ECDSA算法灵活性较低、匿名性较弱且分散性不高,性能相对高效的应用实例也十分有限。基于哈希证明系统,文章提出一种适用于区块链的两方椭圆曲线数字签名算法。通过给定签名算法的数理逻辑及其安全模型,融入区块链进行测评,证明了方案的可行性。最后,对签名方案的安全性进行了分析,证实该方案无需交互性安全假设便可在零知识性的基础上减少通信开销。

    关键词: 哈希证明系统, 椭圆曲线数字签名算法, 区块链, 安全性证明, 隐私保护

    Abstract:

    Elliptic curve signature ECDSA is one of the common digital signatures in blockchain cryptography technology, which has been widely used in cryptocurrency, key identity authentication, etc. However, current blockchain ECDSA algorithm is inflexible, weakly anonymous and poorly decentralized, and have limited examples of relatively high-performing applications. This study intended to propose a two-party elliptic curve signature suitable for blockchain with the help of Hash proof systems. Given the mathematical logic of the signature algorithm and its security model, its incorporation into the blockchain was evaluated to show the feasibility of the scheme. Finally, the security of the signature scheme was analyzed, and a simulation-based security proof was used to demonstrated that the scheme did not require interactive security assumptions and can reduce the overhead in communication with zero knowledge proof.

    Key words: Hash proof system, ECDSA, blockchain, security proof, privacy protection

    全文链接

    展开全文
  • 椭圆曲线算法只需要较小长度的密钥就可以获得较高的安全性,因此非常适合用智能卡来实现椭圆曲线数字签名算法 。首先介绍了智能卡提供的硬件加速模块的特点,为提高椭圆曲线数字签名算法的执行速度,采用射影坐标代替...
  • 本文从椭圆曲线加密学的基础-点倍积开始讲起,完整介绍了椭圆曲线数字签名算法的理论基础和实现算法,以及以太坊中是如何调用椭圆曲线数字签名算法进行数字签名操作的。
  • 1、一条曲线方程2、在曲线上随机选择一个起始点(私钥)3、利用起始点做一些变化,获得曲线上的第二个点(公钥)4、利用私钥与文件hash值进行运算得到数字签名,40字节5、数字签名由两部分构成R与S,各160位6、用...
  • 一、 赛题简介1985年,Victor Miller和Neal Koblitz分别提出了椭圆曲线密码体制(Elliptic Curve Cryptography,ECC)。椭圆曲线密码算法...
  • 简单阐述经典椭圆曲线数字签名(ECDSA)的基本原理,并分析其时间复杂度。在文中列举两种已经改进ECDSA签名算法,同时也分析它们时间复杂度。从椭圆曲线数字签名的安全性和高效性出发,提出一种椭圆曲线数字签名新...
  • ECDSA(Elliptic Curve Digital Signature Algorithm), 使用椭圆曲线加密算法学进行 数字签名 的一种算法. 参考文档3 安全等级(用bit表示其破解最大可能运算次数). 如: 80bit的公钥, 意味着最大可能需要2^80次运算...
  • # Fabric 1.0源代码笔记 之 ECDSA(椭圆曲线数字签名算法)## 1、椭圆曲线算法概述### 1.1、无穷远点、无穷远直线、射影平面* 平行线相交于无穷远点;* 直线上有且只有一个无穷远点;* 一组相互平行的直线有公共的...
  • 基于椭圆曲线数字签名算法和相位检索算法的光学身份认证方案
  • #资源达人分享计划#
  • 签名照 一种结合椭圆曲线数字签名算法和LSB水印图像认证的实现
  • multi-party-ecdsa:{t,n}阈值ECDSA的Rust实现(椭圆曲线数字签名算法
  • 椭圆曲线数字签名算法(ECDSA)是使用椭圆曲线数字签名算法(DSA)的模拟 与普通的离散对数问题(discrete logarithm problem DLP)和大数分解问题(integer factorization problem IFP)不同,椭圆曲线离散对数...
  • 椭圆曲线密码学(Elliptic curve cryptography,缩写为ECC),是基于椭圆曲线数学理论实现的一种非对称加密算法椭圆曲线算法又细分为多种具体的算法。Go语言内置的椭圆曲线是secp256R1算法,而比特币系统中使用...
  • PHP扩展包装ed25519,一种椭圆曲线数字签名算法,由Dan Bernstein,Niels Duif,Tanja Lange,Peter Schwabe和Bo-Yin Yin开发。 这种扩展是基于两个项目:从ed25519 FPGA实现从和原始PHP扩展curve25519 如何安装...
  • 基于椭圆曲线数字签名算法的序列号软件保护方案。论文
  • ecdsa 椭圆曲线数字签名算法

    千次阅读 2015-03-27 15:52:27
    来源:... Elliptic Curve Digital Signature Algorithm, 或者 ECDSA, 是 FIPS-186. 定义的一种数字签名方法,当前版本是 Change 3, dated June 2009. 如果对非椭圆
  • 二、数字签名算法 1.辅助函数 密码杂凑算法和随机数发生器 杂凑运算:这个输出串称为该消息的杂凑值。 就是一种可将一个 key 对应到一个索引的函数,一个可能的杂凑函数为 h(x)=key % 100 , (% 传回 key 除以 ...
  • 比特币目前使用ECDSA对货币的所有权进行鉴定,当然前提是对于付款地址是椭圆曲线算法的公钥(secp256k1 for bitcoin)。 如果是puzzle类型等非标准的付款方式,那么resolve的方式就不是签名/验证的形式了,那...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,308
精华内容 2,923
关键字:

椭圆曲线数字签名算法