精华内容
下载资源
问答
  • SM2基于ECC,ECC(Elliptic Curves Cryptography)加密算法是一种公钥加密算法,与主流的RSA算法相比,ECC算法可以使用较短的密钥达到相同的安全程度。近年来,人们对ECC的认识已经不再处于研究阶段,开始逐步进入...

            SM2基于ECC,ECC(Elliptic Curves Cryptography)加密算法是一种公钥加密算法,与主流的RSA算法相比,ECC算法可以使用较短的密钥达到相同的安全程度。近年来,人们对ECC的认识已经不再处于研究阶段,开始逐步进入实际应用,如国家密码管理局颁布的SM2算法就是基于ECC算法的。


      demo下载:  https://github.com/HungryGoogle/SM2_Demo_replace_RSA/tree/master

    1 调用函数
        SM2Utils.testSm2();
        
    2 运行结果:
        <br/>leeTest------>: 1 ---------------------------------------
        <br/>leeTest------>: privateKey = 128B2FA8BD433C6C068C8D803DFF79792A519A55171B1B650C23661D15897263
        <br/>leeTest------>: pubkey = 040AE4C7798AA0F119471BEE11825BE46202BB79E2A5844495E97C04FF4DF2548A7C0240F88F1CD4E16352A73C17B7F16F07353E53A176D684A9FE0C6BB798E857
        <br/>leeTest------>: userId = lee@deepin.com
        <br/>leeTest------>: after privateKey sign, result = 304402206E0266508466EEB68C4E50D1D823101C405EEF3295859BD160811E0E455FF53002205372010CC62B1D73341982906D99EAAC4A1472618150F4D690B4D92B8BA41B0D
        <br/>leeTest------>: user pubkey verifyResult = true
        <br/>leeTest------>: 2 ---------------------------------------
        <br/>leeTest------>: cipherText = 307202203DF61DE93F19AA4547DF343BD1C369CE4062C2F523FC1F111945EF1952CAD72202200245B30B374D0ECB3FB140DBEB01BB66D307A7B2254CD74E4C1602701A504CFA0420AD353782C492BE55041B394B7CB2DB8BFC664E2F6F2C78DA1B726BA83A424463040AEE6592603C35E9891EA9
        <br/>leeTest------>: plainText = HelloWorld
        <br/>leeTest------>: End ---------------------------------------
    
     3 文章来自于
        http://blog.csdn.net/moonshine99/article/details/79426665

    展开全文
  • 椭圆曲线加密算法 java语言实现 elliptic curve private keys produce DER encodings of PKCS8 PrivateKeyInfo objects and elliptic curve public keys produce DER encodings of X.509 SubjectPublicKeyInfo ...
  • ECC加密算法 java

    万次阅读 2015-10-12 12:04:38
    ECC  ECC-Elliptic Curves Cryptography,椭圆曲线... 当我开始整理《Java加密技术(二)》的时候,我就已经在开始研究ECC了,但是关于Java实现ECC算法的资料实在是太少了,无论是国内还是国外的 资料,无论是官方

    ECC 
    ECC-Elliptic Curves Cryptography,椭圆曲线密码编码学,是目前已知的公钥体制中,对每比特所提供加密强度最高的一种体制。在软件注册保护方面起到很大的作用,一般的序列号通常由该算法产生。 
        当我开始整理《Java加密技术(二)》的时候,我就已经在开始研究ECC了,但是关于Java实现ECC算法的资料实在是太少了,无论是国内还是国外的 资料,无论是官方还是非官方的解释,最终只有一种答案——ECC算法在jdk1.5后加入支持,目前仅仅只能完成密钥的生成与解析。 如果想要获得ECC算法实现,需要调用硬件完成加密/解密(ECC算法相当耗费资源,如果单纯使用CPU进行加密/解密,效率低下),涉及到Java Card领域,PKCS#11。 其实,PKCS#11配置很简单,但缺乏硬件设备,无法尝试! 

        尽管如此,我照旧提供相应的Java实现代码,以供大家参考。 

    通过java代码实现如下:Coder类见

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    import java.math.BigInteger;
    import java.security.Key;
    import java.security.KeyFactory;
    import java.security.interfaces.ECPrivateKey;
    import java.security.interfaces.ECPublicKey;
    import java.security.spec.ECFieldF2m;
    import java.security.spec.ECParameterSpec;
    import java.security.spec.ECPoint;
    import java.security.spec.ECPrivateKeySpec;
    import java.security.spec.ECPublicKeySpec;
    import java.security.spec.EllipticCurve;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.HashMap;
    import java.util.Map;
     
    import javax.crypto.Cipher;
    import javax.crypto.NullCipher;
     
    import sun.security.ec.ECKeyFactory;
    import sun.security.ec.ECPrivateKeyImpl;
    import sun.security.ec.ECPublicKeyImpl;
     
    /**
     * ECC安全编码组件
     
     * @author 梁栋
     * @version 1.0
     * @since 1.0
     */
    public abstract class ECCCoder extends Coder {
     
        public static final String ALGORITHM = "EC";
        private static final String PUBLIC_KEY = "ECCPublicKey";
        private static final String PRIVATE_KEY = "ECCPrivateKey";
     
        /**
         * 解密<br>
         * 用私钥解密
         
         * @param data
         * @param key
         * @return
         * @throws Exception
         */
        public static byte[] decrypt(byte[] data, String key) throws Exception {
            // 对密钥解密
            byte[] keyBytes = decryptBASE64(key);
     
            // 取得私钥
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = ECKeyFactory.INSTANCE;
     
            ECPrivateKey priKey = (ECPrivateKey) keyFactory
                    .generatePrivate(pkcs8KeySpec);
     
            ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(priKey.getS(),
                    priKey.getParams());
     
            // 对数据解密
            // TODO Chipher不支持EC算法 未能实现
            Cipher cipher = new NullCipher();
            // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());
            cipher.init(Cipher.DECRYPT_MODE, priKey, ecPrivateKeySpec.getParams());
     
            return cipher.doFinal(data);
        }
     
        /**
         * 加密<br>
         * 用公钥加密
         
         * @param data
         * @param privateKey
         * @return
         * @throws Exception
         */
        public static byte[] encrypt(byte[] data, String privateKey)
                throws Exception {
            // 对公钥解密
            byte[] keyBytes = decryptBASE64(privateKey);
     
            // 取得公钥
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = ECKeyFactory.INSTANCE;
     
            ECPublicKey pubKey = (ECPublicKey) keyFactory
                    .generatePublic(x509KeySpec);
     
            ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(pubKey.getW(),
                    pubKey.getParams());
     
            // 对数据加密
            // TODO Chipher不支持EC算法 未能实现
            Cipher cipher = new NullCipher();
            // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());
            cipher.init(Cipher.ENCRYPT_MODE, pubKey, ecPublicKeySpec.getParams());
     
            return cipher.doFinal(data);
        }
     
        /**
         * 取得私钥
         
         * @param keyMap
         * @return
         * @throws Exception
         */
        public static String getPrivateKey(Map<String, Object> keyMap)
                throws Exception {
            Key key = (Key) keyMap.get(PRIVATE_KEY);
     
            return encryptBASE64(key.getEncoded());
        }
     
        /**
         * 取得公钥
         
         * @param keyMap
         * @return
         * @throws Exception
         */
        public static String getPublicKey(Map<String, Object> keyMap)
                throws Exception {
            Key key = (Key) keyMap.get(PUBLIC_KEY);
     
            return encryptBASE64(key.getEncoded());
        }
     
        /**
         * 初始化密钥
         
         * @return
         * @throws Exception
         */
        public static Map<String, Object> initKey() throws Exception {
            BigInteger x1 = new BigInteger(
                    "2fe13c0537bbc11acaa07d793de4e6d5e5c94eee8"16);
            BigInteger x2 = new BigInteger(
                    "289070fb05d38ff58321f2e800536d538ccdaa3d9"16);
     
            ECPoint g = new ECPoint(x1, x2);
     
            // the order of generator
            BigInteger n = new BigInteger(
                    "5846006549323611672814741753598448348329118574063"10);
            // the cofactor
            int h = 2;
            int m = 163;
            int[] ks = { 763 };
            ECFieldF2m ecField = new ECFieldF2m(m, ks);
            // y^2+xy=x^3+x^2+1
            BigInteger a = new BigInteger("1"2);
            BigInteger b = new BigInteger("1"2);
     
            EllipticCurve ellipticCurve = new EllipticCurve(ecField, a, b);
     
            ECParameterSpec ecParameterSpec = new ECParameterSpec(ellipticCurve, g,
                    n, h);
            // 公钥
            ECPublicKey publicKey = new ECPublicKeyImpl(g, ecParameterSpec);
     
            BigInteger s = new BigInteger(
                    "1234006549323611672814741753598448348329118574063"10);
            // 私钥
            ECPrivateKey privateKey = new ECPrivateKeyImpl(s, ecParameterSpec);
     
            Map<String, Object> keyMap = new HashMap<String, Object>(2);
     
            keyMap.put(PUBLIC_KEY, publicKey);
            keyMap.put(PRIVATE_KEY, privateKey);
     
            return keyMap;
        }
     
    }



        请注意上述代码中的TODO内容,再次提醒注意,Chipher不支持EC算法 ,以上代码仅供参考。Chipher、Signature、KeyPairGenerator、KeyAgreement、SecretKey均不支持EC算法。为了确保程序能够正常执行,我们使用了NullCipher类,验证程序。

    照旧提供一个测试类:

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    import static org.junit.Assert.*;
     
    import java.math.BigInteger;
    import java.security.spec.ECFieldF2m;
    import java.security.spec.ECParameterSpec;
    import java.security.spec.ECPoint;
    import java.security.spec.ECPrivateKeySpec;
    import java.security.spec.ECPublicKeySpec;
    import java.security.spec.EllipticCurve;
    import java.util.Map;
     
    import org.junit.Test;
     
    /**
     
     * @author 梁栋
     * @version 1.0
     * @since 1.0
     */
    public class ECCCoderTest {
     
        @Test
        public void test() throws Exception {
            String inputStr = "abc";
            byte[] data = inputStr.getBytes();
     
            Map<String, Object> keyMap = ECCCoder.initKey();
     
            String publicKey = ECCCoder.getPublicKey(keyMap);
            String privateKey = ECCCoder.getPrivateKey(keyMap);
            System.err.println("公钥: \n" + publicKey);
            System.err.println("私钥: \n" + privateKey);
     
            byte[] encodedData = ECCCoder.encrypt(data, publicKey);
     
            byte[] decodedData = ECCCoder.decrypt(encodedData, privateKey);
     
            String outputStr = new String(decodedData);
            System.err.println("加密前: " + inputStr + "\n\r" "解密后: " + outputStr);
            assertEquals(inputStr, outputStr);
        }
    }



    控制台输出:

    公钥: 
    MEAwEAYHKoZIzj0CAQYFK4EEAAEDLAAEAv4TwFN7vBGsqgfXk95ObV5clO7oAokHD7BdOP9YMh8u
    gAU21TjM2qPZ
    
    私钥: 
    MDICAQAwEAYHKoZIzj0CAQYFK4EEAAEEGzAZAgEBBBTYJsR3BN7TFw7JHcAHFkwNmfil7w==
    
    加密前: abc
    
    解密后: abc

        本篇的主要内容为Java证书体系的实现。 

    展开全文
  • java借助bouncycastle库实现ECC双向加密解密算法Utils工具包。
  • Java 实现 ECC 非对称加密算法加解密和签名验签前言一、ECC 椭圆曲线算法简介二、ECC 加解密代码实例1.生成 ECC 密钥2.ECC 加解密3.测试代码三、ECC 签名验签代码实例1. ECC 签名验签2. 测试代码 前言 文章字数比较...

    前言

    文章字数比较多,可直接查看代码:源码地址,文中描述有误的地方欢迎各位大神指导。

    一、ECC 椭圆曲线算法简介

    ECC是椭圆曲线算法,其加密算法叫ECIES,签名算法叫ECDSA。JDK 并不支持 ECC 算法,可以引入 BouncyCastle 库使用。ECC算法相当耗费资源,如果单纯使用CPU进行加密/解密,效率低下。

    引入 BouncyCastle 库

            <dependency>
                <groupId>org.bouncycastle</groupId>
                <artifactId>bcprov-jdk15on</artifactId>
                <version>1.64</version>
            </dependency>
    

    二、ECC 加解密代码实例

    1.生成 ECC 密钥

    由于 BouncyCastle 库对 keysize 有指定要求的,可以看 BouncyCastle 库中的类:KeyPairGeneratorSpi,从中可以看出支持的 keysize 就这么几个:192、239、256、224、384、521。

    注意: 需要使用静态初始化块初始化 Provider,常量 EC_ALGORITHM = ”EC“ EC_PROVIDER = “BC”

    代码如下:

        /**
         * 生成密钥对
         *
         * @param keysize 密钥长度
         * @return
         */
        public static KeyPair generateECCKeyPair(int keysize) {
            try {
                // 获取指定算法的密钥对生成器
                KeyPairGenerator generator = KeyPairGenerator.getInstance(EC_ALGORITHM, EC_PROVIDER);
                // 初始化密钥对生成器(指定密钥长度, 使用默认的安全随机数源)
                generator.initialize(keysize);
                // 随机生成一对密钥(包含公钥和私钥)
                return generator.generateKeyPair();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    

    2.ECC 加解密

    ECIES_ALGORITHM = “ECIES”
    EC_PROVIDER = “BC”

    代码如下:

    /**
         * ECC 加密
         *
         * @param publicKey 公钥
         * @param plain     原文
         * @return 密文
         */
        public static byte[] eccEncrypt(PublicKey publicKey, byte[] plain) {
            try {
                Cipher cipher = Cipher.getInstance(ECIES_ALGORITHM, EC_PROVIDER);
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                return cipher.doFinal(plain);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * ECC 解密
         *
         * @param privateKey  私钥
         * @param encrypted   密文
         * @return 原文
         */
        public static byte[] eccDecrypt(PrivateKey privateKey, byte[] encrypted) {
            try {
                Cipher cipher = Cipher.getInstance(ECIES_ALGORITHM, EC_PROVIDER);
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                return cipher.doFinal(encrypted);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    

    3.测试代码

     public static void main(String[] args) {
            // 测试文本
            byte[] plain = "123".getBytes();
    
            // 生成密钥对
            KeyPair keyPair = generateECCKeyPair(256);
            PublicKey publicKey = keyPair.getPublic();
            PrivateKey privateKey = keyPair.getPrivate();
    
            // 加解密
            byte[] encrypt = eccEncrypt(publicKey, plain);
            byte[] decrypt = eccDecrypt(privateKey, encrypt);
            System.err.println(new String(decrypt).equals(new String(plain)));
        }
    

    三、ECC 签名验签代码实例

    签名验签使用的密钥同上,签名算法使用:SHA256withECDSA 即 SIGNATURE = “SHA256withECDSA”。

    1. ECC 签名验签

    /**
         * 私钥签名
         *
         * @param privateKey 私钥
         * @param plain      原文
         * @return 签名
         */
        public static byte[] eccSign(PrivateKey privateKey, byte[] plain) {
            try {
                Signature signature = Signature.getInstance(SIGNATURE);
                signature.initSign(privateKey);
                signature.update(plain);
                return signature.sign();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 公钥验签
         *
         * @param publicKey 公钥
         * @param plain     原文
         * @param sign      签名
         * @return
         */
        public static boolean eccVerify(PublicKey publicKey, byte[] plain, byte[] sign) {
            try {
                Signature signature = Signature.getInstance(SIGNATURE);
                signature.initVerify(publicKey);
                signature.update(plain);
                return signature.verify(sign);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return false;
        }
    

    2. 测试代码

     public static void main(String[] args) {
            // 测试文本
            byte[] plain = "123".getBytes();
    
            // 生成密钥对
            KeyPair keyPair = generateECCKeyPair(256);
            PublicKey publicKey = keyPair.getPublic();
            PrivateKey privateKey = keyPair.getPrivate();
    
            // 签名验签
            byte[] sign = eccSign(privateKey, plain);
            boolean verify = eccVerify(publicKey, plain, sign);
            System.err.println(verify);
        }
    
    展开全文
  • SafeCurves-Java的目的是提供用于实现椭圆曲线加密功能的低级原语。 SafeCurves-Java并非旨在实现JCA接口。 SafeCurves-Java的基本目标是帮助为常规使用提供更多种类的可靠密码。 支持的曲线来自。 支持的曲线 ...
  •  椭圆加密算法(ECC)是一种公钥加密体制,最初由Koblitz和Miller两人于1985年提出,其数学基础是利用椭圆曲线上的有理点构成Abel加法群上椭圆离散对数的计算困难性。  是目前已知的公钥体制中,对每比特所提供...

    一、ECC加密解密【暂时无意义】

      椭圆加密算法(ECC)是一种公钥加密体制,最初由Koblitz和Miller两人于1985年提出,其数学基础是利用椭圆曲线上的有理点构成Abel加法群上椭圆离散对数的计算困难性。

      是目前已知的公钥体制中,对每比特所提供加密强度最高的一种体制。在软件注册保护方面起到很大的作用,一般的序列号通常由该算法产生。

      ECC算法在jdk1.5后加入支持,目前仅仅只能完成密钥的生成与解析。 如果想要获得ECC算法实现,需要调用硬件完成加密/解密(ECC算法相当耗费资源,如果单纯使用CPU进行加密/解密,效率低下).

    代码地址:https://github.com/bjlhx15/algorithm-sign.git  加解密示例代码【仅有理解意义】

    二、ECDSA签名

    基于ECC与DSA签名算法分类信息,ECDSA(elliptic curve digital signature algorithm) 椭圆曲线数字签名算法:速度快,强度高,签名短

    算法 密钥长度 默认长度 签名长度 实现的方
    NONEwithECDSA 112-571 256 128 JDK/BC
    RIPEMD160withECDSA 同上 256 160 BC
    SHA1withECDSA ... 256 160 JDK/BC
    SHA224withECDSA ... 256 224 BC
    SHA256withECDSA ... 256 256 JDK/BC
    SHA384withECDSA ... 256 384 JDK/BC
    SHA512withECDSA ... 256 512 JDK/BC

     

    秘钥长度可以选择使用 160 ,相当于rsa /dsa 的1024 秘钥长度。

    签名示例

      代码地址:https://github.com/bjlhx15/algorithm-sign.git

    展开全文
  • JAVA实现ECC加密 eclipse

    2020-06-06 16:58:01
    了解如何使用Java简单实现ECC椭圆曲线加密算法。 掌握ECC椭圆曲线加密算法的简单代码实验。 熟悉JPBC密码学库。 三、开发环境 JDK1.8,Java相关开发环境(本实验以Windows平台为例) 四、实验内容 需要导入相关的...
  • 国密算法Java实现(含详细测试代码) 我自己按照国密文档通过Java实现SM2密码算法加密/解密、签名验签,SM3密码杂凑算法,SM4分组密码算法ECB、CBC模式加密/解密。 经过详尽的测试过后没有发现问题,但建议大家在...
  • 按照国密文档通过Java实现SM2密码算法加密/解密、签名验签,SM3密码杂凑算法,SM4分组密码算法ECB、CBC模式加密/解密。 经过详尽的测试过后没有发现问题,但建议大家在使用时仍进行验证。若有问题请及时反馈,期待和...
  • JAVA加密算法7

    2009-05-11 12:10:31
    关键字: ecc, 椭圆曲线加密, 非对称加密 ECC ECC-Elliptic Curves Cryptography,椭圆曲线密码编码学,是目前已知的公钥体制中,对每比特所提供加密强度最高的一种体制。在软件注册保护方面起到很大的作用,一般...
  • 按照国密文档通过Java实现SM2密码算法加密/解密、签名验签,SM3密码杂凑算法,SM4分组密码算法ECB、CBC模式加密/解密。 经过详尽的测试过后没有发现问题,但建议大家在使用时仍进行验证。若有问题请及时反馈,期待和...
  • 我自己按照国密文档通过Java实现SM2密码算法加密/解密、签名验签,SM3密码杂凑算法,SM4分组密码算法ECB、CBC模式加密/解密。 经过详尽的测试过后没有发现问题,但建议大家在使用时仍进行验证。若有问题请及时反馈,...
  • ECCECC-Elliptic Curves Cryptography,... 当我开始整理《Java加密算法(二)》的时候,我就已经在开始研究ECC了,但是关于Java实现ECC算法的资料实在是太少了,无论是国内还是国外的资料,无论是官方还是非官方...
  • 如花商城免费开源 对称加密算法(JDK和BC实现方式) DES (是数据加密标准,很多年前常用,已被破解不具备安全性) 3DES(三重DES,又称:Triple DES或...ELGamal (椭圆曲线加密,未举例)如何安全的传递密钥,是对称
  • ECC   ECC-Elliptic Curves Cryptography,椭圆曲线密码编码学,是... 当我开始整理《Java加密技术(二)》的时候,我就已经在开始研究ECC了,但是关于Java实现ECC算法的资料实在是太少了,无论是国内还是国外的资
  • 该代码涵盖了密钥交换,数字签名,对称加密,组的顺序(有限域中的点数)和椭圆曲线离散对数问题。 这取决于 。 2-爱德华兹曲线数字签名算法 , 与常规椭圆曲线形式相比,提供了更快的计算速度。 3-查找比特币...
  • 文章介绍了 SM2 椭圆曲线公钥密码算法,分析了 SM2 算法实现流程与...用 Java 语言实现了 SM2 算法的四大功能 :SM2 数字签名、SM2 签名验证、SM2 加密、SM2 解密。文章 还测试了算法的性能,论证了算法的实用性。
  • JAVA加密算法(ECC )

    2011-05-20 13:34:49
    ECC-Elliptic Curves Cryptography,... 当我开始整理《Java加密技术(二)》的时候,我就已经在开始研究ECC了,但是关于Java实现ECC算法的资料实在是太少了,无论是国内还是国外的资料,无论是官方还是非官方的解...
  • ECC  ECC-Elliptic Curves Cryptography,椭圆曲线... 当我开始整理《Java加密技术(二)》的时候,我就已经在开始研究ECC了,但是关于Java实现ECC算法的资料实在是太少了,无论是国内还是国外的资料,无论是官方还

空空如也

空空如也

1 2 3 4
收藏数 74
精华内容 29
关键字:

椭圆曲线加密算法java实现

java 订阅