Android平台使用大宝CA版本JCE完成SM2、SM3、SM4国密算法、密钥、国密数字证书的详细说明

最新推荐文章于 2024-07-28 17:00:00 发布
最新推荐文章于 2024-07-28 17:00:00 发布
阅读量4.1k 收藏 1
点赞数 1
文章标签： 软件防盗版 软件防复制 PP软件授权 
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/upset_ming/article/details/100936009
版权

系统要求
Android 5.0（API 21）及以上 

功能介绍

  1. SM2密钥对的生成功能
  2. SM2密钥对的还原功能
  3. SM2算法的非对称加解密功能
  4. SM2算法的签名/验证功能
  5. SM3算法的摘要功能
  6. SM4算法的对称加解密功能
  7. 大宝CA版本Keystore文件（DCKS文件）存储SM2密钥对和国密数字证书的功能

Android调用JCE的主要代码

package com.doubleca.android.sample.gmjce;

import com.doubleca.b146.c16.util.encoders.Base64;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.math.BigInteger;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.KeyStore;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.SignatureException;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Enumeration;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

import doubleca.security.provider.DoubleCA;
import doubleca.security.provider.jdk7.sm4.SM4KeySpec;

public class GmTest
{
    private static final String SIGNATURE_KEY_ALGORITHM = "SM2";
    private static final String SIGNATURE_ALGORITHM = "SM3withSM2";
    private static final int SIGNATURE_KEY_SIZE = 256;
    private static final String DIGEST_ALGORITHM = "SM3";
    private static final String CIPHER_SM4_KEY_ALGORITHM = "SM4";
    //	private static final String CIPHER_SM4_ALGORITHM = "SM4/ECB/PKCS5Padding";
    private static final String CIPHER_SM4_ALGORITHM = "SM4/CBC/PKCS5Padding";
    // private static final String CIPHER_SM4_ALGORITHM = "SM4/ECB/NOPadding";
    // private static final String CIPHER_SM4_ALGORITHM = "SM4/CBC/NOPadding";
    private static final String CIPHER_SM2_ALGORITHM = "SM2/NONE/NOPadding";

    public static SecretKey TestSM4Cipher()
    {
        try
        {
            String plainText1 = "软件（库）授权与防复制、防盗版，全平台支持：";
            String plainText2 = "https://www.PPLIC.com ";
            byte[] plain1 = plainText1.getBytes();
            byte[] plain2 = plainText2.getBytes();
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(CIPHER_SM4_KEY_ALGORITHM, DoubleCA.PROVIDER_NAME);
            SM4KeySpec keySpec = new SM4KeySpec("1234567812345678".getBytes("utf-8"));
            IvParameterSpec iv = new IvParameterSpec("1234567812345678".getBytes());
            SecretKey key = keyFactory.generateSecret(keySpec);
            BigInteger keyBuffer = new BigInteger(1, key.getEncoded());
            System.out.println("SM4 Key :" + keyBuffer.toString(16).toUpperCase());

            //			KeyGenerator kgen = KeyGenerator.getInstance("OID.1.2.156.10197.1.104");
            //			KeyGenerator kgen = KeyGenerator.getInstance("1.2.156.10197.1.104");
            //			KeyGenerator kgen = KeyGenerator.getInstance("SMS4");

            KeyGenerator kgen = KeyGenerator.getInstance(CIPHER_SM4_KEY_ALGORITHM);
            kgen.init(128, new SecureRandom("12345678".getBytes()));
            SecretKey secretKey = kgen.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            SecretKeySpec sm4keySpec = new SecretKeySpec(enCodeFormat, CIPHER_SM4_KEY_ALGORITHM);
            keyBuffer = new BigInteger(1, sm4keySpec.getEncoded());
            System.out.println("SM4KeySpec :" + keyBuffer.toString(16).toUpperCase());
            Cipher cipher = Cipher.getInstance(CIPHER_SM4_ALGORITHM);// 创建密码器
            //			cipher.init(Cipher.ENCRYPT_MODE, sm4keySpec);// 初始化
            cipher.init(Cipher.ENCRYPT_MODE, sm4keySpec, iv);// 初始化
            byte[] sm4ResultBuffer = new byte[cipher.getOutputSize(plain1.length + plain2.length)];
            int bufferLen = cipher.update(plain1, 0, plain1.length, sm4ResultBuffer, 0);
            bufferLen += cipher.update(plain2, 0, plain2.length, sm4ResultBuffer, bufferLen);
            bufferLen += cipher.doFinal(sm4ResultBuffer, bufferLen);
            byte[] result = new byte[bufferLen];
            System.arraycopy(sm4ResultBuffer, 0, result, 0, sm4ResultBuffer.length);
            BigInteger buffer = new BigInteger(1, result);
            System.out.println("原文1：" + plainText1);
            System.out.println("原文2：" + plainText2);
            System.out.println("密文：" + new String(Base64.encode(result)));
            //			cipher.init(Cipher.DECRYPT_MODE, sm4keySpec);// 初始化
            cipher.init(Cipher.DECRYPT_MODE, sm4keySpec, iv);// 初始化
            sm4ResultBuffer = new byte[cipher.getOutputSize(result.length)];
            bufferLen = cipher.update(result, 0, result.length / 2, sm4ResultBuffer, 0);
            bufferLen += cipher.update(result, result.length / 2, result.length - (result.length / 2), sm4ResultBuffer, bufferLen);
            bufferLen += cipher.doFinal(sm4ResultBuffer, bufferLen);
            result = new byte[bufferLen];
            System.arraycopy(sm4ResultBuffer, 0, result, 0, result.length);
            System.out.println("原文：" + new String(result));
            return key;
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            return null;
        }
    }

    public static boolean TestSM3Digest()
    {
        try
        {
            MessageDigest md = MessageDigest.getInstance(DIGEST_ALGORITHM);
            byte[] result;
            md.update("大宝CA 国密SSL（v1.1）算法库：https://www.DoubleCA.com ".getBytes());
            // byte[] result = md.digest("1234512345".getBytes());
            result = md.digest();
            System.out.println(md.getAlgorithm() + " MessageDigest : " + new BigInteger(1, result).toString(16).toUpperCase());
            return true;
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            return false;
        }
    }

    public static boolean TestSM2Signature(KeyPair key) throws NoSuchAlgorithmException, SignatureException, InvalidKeyException
    {
        String content = "大宝CA 国密SSL（v1.1）Tomcat：https://www.DoubleCA.com ";
        System.out.println("原文：" + content);
        java.security.Signature signature = java.security.Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(key.getPrivate());
        signature.update(content.getBytes());
        byte[] signValue = signature.sign();
        System.out.println("签名值：" + new String(Base64.encode(signValue)));
        signature.initVerify(key.getPublic());
        signature.update(content.getBytes());
        boolean result = signature.verify(signValue);
        System.out.println("签名验证结果 ：" + result);
        return result;
    }

    public static boolean TestSM2AsymmetricCipher(KeyPair key)
    {
        try
        {
            Cipher cipher = Cipher.getInstance(CIPHER_SM2_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, key.getPublic());
            String plainText = "软件（库）授权与防复制：https://www.PPLIC.com ";
            System.out.println("原文：" + plainText);
            cipher.update(plainText.getBytes());
            byte[] cipherByte = cipher.doFinal();
            System.out.println("密文：" + new String(Base64.encode(cipherByte)));
            cipher.init(Cipher.DECRYPT_MODE, key.getPrivate());
            byte[] plainByte = cipher.doFinal(cipherByte);
            System.out.println("原文：" + new String(plainByte));
            return true;
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            return false;
        }
    }

    public static KeyPair TestSM2KeyPairGenerator() throws Exception
    {
        // 生成密钥对
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance(SIGNATURE_KEY_ALGORITHM);
        keyGen.initialize(SIGNATURE_KEY_SIZE);
        KeyPair key = keyGen.generateKeyPair();
        PublicKey publicKey = key.getPublic();
        BigInteger a = new BigInteger(1, key.getPrivate().getEncoded());
        BigInteger b = new BigInteger(1, publicKey.getEncoded());
        System.out.println(keyGen.getAlgorithm() + " KeyPairGenerator publickey : " + b.toString(16));
        System.out.println(keyGen.getAlgorithm() + " KeyPairGenerator privatekey : " + a.toString(16));
        return key;
    }

    public static boolean TestSM2KeyFactory(byte[] publicKeyByteArray, byte[] privateKeyByteArray)
    {
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKeyByteArray);
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKeyByteArray);
        try
        {
            KeyFactory factory = KeyFactory.getInstance(SIGNATURE_KEY_ALGORITHM);
            PublicKey publicKey = factory.generatePublic(x509EncodedKeySpec);
            PrivateKey privateKey = factory.generatePrivate(pkcs8EncodedKeySpec);
            BigInteger b = new BigInteger(1, publicKey.getEncoded());
            BigInteger a = new BigInteger(1, privateKey.getEncoded());
            System.out.println(factory.getAlgorithm() + " KeyFactory public key : " + b.toString(16));
            System.out.println(factory.getAlgorithm() + " KeyFactory private key : " + a.toString(16));
            return true;
        }
        catch (NoSuchAlgorithmException | InvalidKeySpecException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return false;
        }
    }

    public static boolean TestReadDCKS(InputStream fis, String password)
    {
        KeyStore ks = null;
        if (fis != null)
        {
            try
            {
                ks = KeyStore.getInstance("DCKS");
                ks.load(fis, password.toCharArray());
                Enumeration e = ks.aliases();
                while (e.hasMoreElements())
                {
                    String alias = (String) e.nextElement();
                    System.out.println("alias : " + alias);
                    if (ks.isKeyEntry(alias))
                    {
                        // key
                        Key key = ks.getKey(alias, password.toCharArray());
                        System.out.println("Key Type : " + key.getFormat());
                        System.out.println("Key Algorithm : " + key.getAlgorithm());
                        if (key instanceof PrivateKey)
                        {
                            System.out.println("PrivateKey Value : " + new BigInteger(1, key.getEncoded()));
                            Certificate cert = ks.getCertificate(alias);
                            System.out.println("Certificate Value : " + cert);
                        }
                        else if (key instanceof SecretKey)
                        {
                            System.out.println("Key Value : " + new BigInteger(1, key.getEncoded()));
                        }
                        else
                        {
                            System.out.println("unknown key type...");
                        }
                    }
                    else if (ks.isCertificateEntry(alias))
                    {
                        // cert
                        System.out.println("CertificateEntry : " + ks.getCertificate(alias));
                    }
                    else
                    {
                        // trusted cert
                        System.out.println("TrustedEntry : " + ks.getCertificate(alias));
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                ex.printStackTrace();
                return false;
            }
        }
        return false;
    }
    public static boolean TestCreateDCKS(String fileName, String password, KeyPair sm2Key, SecretKey sm4key)
    {
        KeyStore ks = null;
        File keyStoreFile = new File(fileName);
        try
        {
            ks = KeyStore.getInstance("DCKS");
            ks.load(null, password.toCharArray());
            FileOutputStream fos = new FileOutputStream(keyStoreFile);
            KeyStore.PasswordProtection p = new KeyStore.PasswordProtection(password.toCharArray());

            if (sm2Key != null)
            {
                CertificateFactory cf = CertificateFactory.getInstance("X.509", DoubleCA.PROVIDER_NAME);
                X509Certificate cert = (X509Certificate) cf.generateCertificate(new FileInputStream("resources/sm2cert.cer"));
                X509Certificate[] serverChain = new X509Certificate[] {cert};
                ks.setEntry("DoubleCA-SM2", new KeyStore.PrivateKeyEntry(sm2Key.getPrivate(), serverChain), p);
            }
            if (sm4key != null)
            {
                KeyStore.Entry entry = new KeyStore.SecretKeyEntry(sm4key);
                ks.setEntry("DoubleCA-SM4", entry, p);
            }
            ks.store(fos, password.toCharArray());
            fos.close();
            return true;
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            return false;
        }
    }

}

Android平台运行结果

Android控制台输出结果

I/System.out:  ------ http://www.DoubleCA.com ---- 大宝CA ------ 
     -------       Watchdata & DoubleCA       ------- 
I/System.out: TestSM2KeyPairGenerator
I/System.out: SM2 KeyPairGenerator publickey : 3059301306072a8648ce3d020106082a811ccf5501822d034200040286345d8b9df6a2c775ecba32bef0847c3ef5e64881a64481c9567227b57f3cdd2f9685d8f55f478124db5cda0d8bb010e8e0002e2021e1e884cfdd74fd0c20
    SM2 KeyPairGenerator privatekey : 30818b020100301306072a8648ce3d020106082a811ccf5501822d0471306f02010104207dd3196abef53a19ab869687bddf6bdba86b25eff75ba60af632c6041fe15ba3a0020500a144034200040286345d8b9df6a2c775ecba32bef0847c3ef5e64881a64481c9567227b57f3cdd2f9685d8f55f478124db5cda0d8bb010e8e0002e2021e1e884cfdd74fd0c20
    TestSM2KeyFactory
I/System.out: SM2 KeyFactory public key : 3059301306072a8648ce3d020106082a811ccf5501822d034200040286345d8b9df6a2c775ecba32bef0847c3ef5e64881a64481c9567227b57f3cdd2f9685d8f55f478124db5cda0d8bb010e8e0002e2021e1e884cfdd74fd0c20
I/System.out: SM2 KeyFactory private key : 308193020100301306072a8648ce3d020106082a811ccf5501822d0479307702010104207dd3196abef53a19ab869687bddf6bdba86b25eff75ba60af632c6041fe15ba3a00a06082a811ccf5501822da144034200040286345d8b9df6a2c775ecba32bef0847c3ef5e64881a64481c9567227b57f3cdd2f9685d8f55f478124db5cda0d8bb010e8e0002e2021e1e884cfdd74fd0c20
    TestSM3Digest
I/System.out: SM3 MessageDigest : 6B2CB90C78B51E714E1BEB8290A58C75CDAF3DFDB5DBBCCF9CE247DEFB4A1308
    TestSM4Cipher
I/System.out: SM4 Key :31323334353637383132333435363738
I/System.out: SM4KeySpec :EBDD39999C2358607CB7EF92F7C3A916
I/System.out: 原文1：软件（库）授权与防复制、防盗版，全平台支持：
I/System.out: 原文2：https://www.PPLIC.com 
    密文：1lc6FUKGS+1ftIGiFDDfFdkZOEi2i1XUFsvZZnRvp8LzW6caJfJ5GBgn2d2sBVHdQaMI+IJBiX1i8EwltTbyYSkX4p6Qg1sKtoeYCEXpFk8pJK3HwwgjONpOet7Au4SG
    原文：软件（库）授权与防复制、防盗版，全平台支持：https://www.PPLIC.com 
I/System.out: TestSM2AsymmetricCipher
    原文：软件（库）授权与防复制：https://www.PPLIC.com 
I/System.out: 密文：MIGjAiEA1Gh/7xfFIPFRPh3MP5MZ2JQNUvNV77SyqfbbX/t09cECICbF0A20CfVcY4ikuKZUUOIRwEoTj1Jgs9JCM0UGF7xLBCCxnItl0TAl9MfjmvvDT+UWCGuj+Zw6hJFxBmbJM4BJVAQ6oasCBpiSqvRe7uPwLBEuQ+fC9E1aNp3tzkrmDTADMMzHXP/rF3riEKd5qA5Ims7xbysXU6ZhXEwHyA==
I/System.out: 原文：软件（库）授权与防复制：https://www.PPLIC.com 
I/System.out: TestSM2Signature
    原文：大宝CA 国密SSL（v1.1）Tomcat：https://www.DoubleCA.com 
I/System.out: 签名值：MEQCICGazQkd/G6YQU0Y3kSXeqGYeyMIKnCjGMniZSvPlX47AiAjvlGAtrTvICI6BRe0NJHIRkyPjUAqbY1aIYgkUwjg8A==
I/System.out: 签名验证结果 ：true
    TestReadDCKS
I/System.out: alias : cn=客户端国密ssl测试证书,e=service@doubleca.com,ou=测试,c=cn
I/System.out: Key Type : PKCS#8
    Key Algorithm : SM2
    PrivateKey Value : 3362573024668345226776108319589020300863179425454674990711302050875880756269172595625955136383413772263809955023913419607219872954724110972477389615746516786534283224853253730182499166945837
I/System.out: Certificate Value :   [0]         Version: 3
             SerialNumber: 54562568ffab8b47d4b8d0b5449d7bad
                 IssuerDN: C=CN,ST=BEIJING,O=www.DoubleCA.com,CN=DoubleCA.com TEST01 CA SM2
               Start Date: Sun Feb 17 14:56:11 GMT+00:00 2019
               Final Date: Mon Feb 17 14:56:11 GMT+00:00 2020
                SubjectDN: C=CN,OU=测试,E=service@doubleca.com,CN=客户端国密SSL测试证书
               Public Key: DoubleCA SM2 public key, 256 bits
      public x coord: 65215284186172334808088917997998955419701388929546536492749289805550975234211
      public y coord: 69132452507784084332570142049583404962143056570916935248218677493657120037057
      parameters: com.doubleca.security.spec.SM2ParameterSpec@c8e4f88
      Signature Algorithm: SM3WithSM2Encryption
                Signature: 3045022100f8e5c5c0d511e11c0a78d33195796c
                           821bed0a76a87d1c76e7cf008e374fed3a02200b
                           4242535a2a89cbebc2c0e72a3deb3680cb4014eb
                           c44921f7d4b502035eb5cb
           Extensions: 
                           critical(false) 2.5.29.37 value = DER Sequence
        ObjectIdentifier(1.3.6.1.5.5.7.3.1)
        ObjectIdentifier(1.3.6.1.5.5.7.3.2)
                           critical(false) NetscapeCertType: 0xc0
                           critical(false) 2.5.29.17 value = DER Sequence
        Tagged [2] IMPLICIT 
            DER Octet String[16] 
        Tagged [7] IMPLICIT 
            DER Octet String[4] 
                           critical(false) 2.5.29.14 value = DER Octet String[20] 
                           critical(false) KeyUsage: 0xf8
                           critical(false) 2.5.29.31 value = DER Sequence
I/System.out:     DER Sequence
            Tagged [0]
                Tagged [0]
                    Tagged [6] IMPLICIT 
                        DER Octet String[58] 
    alias : cn=doubleca.com root ca sm2,o=www.doubleca.com,st=beijing,c=cn
I/System.out: CertificateEntry :   [0]         Version: 3
             SerialNumber: 283909e859da6101c286b6d79fc61375
                 IssuerDN: C=CN,ST=BEIJING,O=www.DoubleCA.com,CN=DoubleCA.com ROOT CA SM2
               Start Date: Tue Feb 20 15:29:34 GMT+00:00 2018
               Final Date: Thu Feb 20 15:29:34 GMT+00:00 2048
                SubjectDN: C=CN,ST=BEIJING,O=www.DoubleCA.com,CN=DoubleCA.com ROOT CA SM2
               Public Key: DoubleCA SM2 public key, 256 bits
      public x coord: 63567973297631315756188461682412948032663271290975609239585908391063398144336
      public y coord: 94293482803615337477639920676818685203833495478712519677665296690516936973566
      parameters: com.doubleca.security.spec.SM2ParameterSpec@c8e4f88
      Signature Algorithm: SM3WithSM2Encryption
                Signature: 3046022100ccdc6e27d819f86166bee2d011b422
                           da247b7325a9ebdd0372ed6cdbf0333102022100
                           a5ff2eb05a0154f1475d4facc9056f857e541065
                           0586acc21d2decbf2cbab88b
           Extensions: 
                           critical(false) 2.5.29.35 value = DER Sequence
        Tagged [0] IMPLICIT 
            DER Octet String[20] 
                           critical(false) 2.5.29.14 value = DER Octet String[20] 
                           critical(false) KeyUsage: 0x6
I/System.out:                        critical(true) BasicConstraints: isCa(true)
    alias : cn=doubleca.com test01 ca sm2,o=www.doubleca.com,st=beijing,c=cn
    CertificateEntry :   [0]         Version: 3
             SerialNumber: 366fab022c0d7e8ae6801e445c865086
I/System.out:              IssuerDN: C=CN,ST=BEIJING,O=www.DoubleCA.com,CN=DoubleCA.com ROOT CA SM2
               Start Date: Tue Feb 20 15:49:22 GMT+00:00 2018
               Final Date: Sat Feb 20 15:49:22 GMT+00:00 2038
                SubjectDN: C=CN,ST=BEIJING,O=www.DoubleCA.com,CN=DoubleCA.com TEST01 CA SM2
               Public Key: DoubleCA SM2 public key, 256 bits
      public x coord: 60595735744867038260274389887165641798371778284629229257466280556093420133086
      public y coord: 59336568717492114170665705208274640089654406332240289026426787465310346749757
      parameters: com.doubleca.security.spec.SM2ParameterSpec@c8e4f88
      Signature Algorithm: SM3WithSM2Encryption
                Signature: 3045022100fbea4e34a1eb2175f559eee65401a8
                           66c3e44bb45b54533220bef12a1cb7d0af022049
                           3ba8f11225343982e484951d98c33f1ea89d952c
                           2a1ac9c5ab4cd0e2b8deb2
           Extensions: 
                           critical(false) 2.5.29.31 value = DER Sequence
        DER Sequence
            Tagged [0]
                Tagged [0]
                    Tagged [6] IMPLICIT 
                        DER Octet String[56] 
                           critical(false) KeyUsage: 0xfe
                           critical(false) 2.5.29.14 value = DER Octet String[20] 
                           critical(false) BasicConstraints: isCa(true), pathLenConstraint = 3
     finish.

示例代码下载地址：https://download.csdn.net/download/upset_ming/11761957

大宝CA国密SSL国密TOMCAT
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于国密算法的Android智能终端SSL协议设计与实现.pdf
09-21
基于国密算法的Android智能终端SSL协议设计与实现.pdf
sm2多端加密解密，java，js，android，ios实战
王林冲的博客
07-27 3846
sm2多端加密解密，java，js，android，ios实战
Bouncy Castle集成SM2与SM3
最新发布
weixin_41850878的博客
07-28 535
SM2和SM3作为中国国家密码管理局制定的密码算法，在信息安全领域具有重要地位。在Bouncy Castle库中，可以方便地实现这两种算法以及它们的结合使用（如SM2+SM3签名算法），为Java应用程序提供高安全性的加密签名功能。
Android_国密_SM2、SM3、SM4
ylineyline的专栏
05-31 9576
因业务要求，RSA、AES、MD5等加密方式，要合规，需要替换成，SM2、SM3、SM4。因此，个人整理资料，实现了一份。 一：参考 https://github.com/gotoworld/hsd-cipher-sm -- 代码主体 https://blog.csdn.net/wkernel/article/details/71193413 -- 对应关系 https:/...
android 国密签名,关于国密 （sm2,sm3,sm4）在Linux、python、Android、java、ios中的...
weixin_33048525的博客
05-27 3894
国密即国家密码局认定的国产密码算法。主要有SM1，SM2，SM3，SM4和最新的sm9。在国内环境主要使用的国家密码局认定的算法。SM2算法：SM2椭圆曲线公钥密码算法是我国自主设计的公钥密码算法，包括SM2-1椭圆曲线数字签名算法，SM2-2椭圆曲线密钥交换协议，SM2-3椭圆曲线公钥加密算法，分别用于实现数字签名密钥协商和数据加密等功能。SM2算法与RSA算法不同的是，SM2算法是基于椭圆曲线...
SM2只有私钥情况下解密
csdn_zxw的博客
10-26 2393
结合了两个大佬的代码，目前应该都是第一个大佬的代码 第一个Android_国密_SM2、SM3、SM4_ylineyline的专栏-CSDN博客 第二个Android常用加密库集合_lambert_Lei的专栏-CSDN博客 首先导入包：Android_国密_SM2、SM3、SM4_ylineyline的专栏-CSDN博客 implementation 'org.bouncycastle:bcprov-jdk16:1.46' 接下来，都是自定义的东西不要找SM2的包在哪，SM2是自己的类 p
Android调用大宝CA版本JCE完成SM2、SM3、SM4国密算法和国密数字证书的示例代码，1.1.0版本
09-17
AndroidStudio示例工程，Android API 21及以上 1. SM2密钥对的生成功能 2. SM2密钥对的还原功能 3. SM2算法的非对称加解密功能 ...7. 大宝CA版本Keystore文件（DCKS文件）存储SM2密钥对和国密数字证书的功能
基于Java的（SM2_SM3_SM4）国密算法java源代码及工具类及测试demo
10-24
这里的“基于Java的（SM2_SM3_SM4）国密算法java源代码及工具类及测试demo”是一个关于如何在Java环境中实现中国国家标准加密算法的资源包。下面我们将详细探讨这些算法的核心概念、用途以及如何在Java中应用。 1. ...
大宝CA版本的国密算法DoubleCA-JCE实现，1.1.2版本，Android5.0可用，含应用示例代码
01-27
1. 国密算法的JCE实现，SM2、SM3、SM4算法，以及国密证书和密钥存储的DCKS文件格式 2. 适用于JDK7及以上 3. 适用于Android API 21平台及以上 4. 导出的PEM数据格式与OPENSSL保持一致，新增可导入的私钥格式
非常全且非常好用的国密算法DoubleCA-JCE完整实现，0.94版本，含国密SSL的SM2密钥协商，（附详细测试和应用代码）
04-09
密钥生成算法 SM2密钥对生成算法的实现 SM4密钥生成算法的实现 加解密算法 ...SM2算法数字证书、SM2密钥对加密保护与存储功能的实现 国密SSL功能 国密SSL规范预主密钥、主密钥生成与计算功能的实现
SM4算法加解密及实现
weixin_40750633的博客
04-06 1万+
SM4算法，ECB/CBC模式加解密
android杂凑算法,SM3密码杂凑算法分析
weixin_42316952的博客
05-29 2392
SM3密码杂凑算法分析杂凑函数在密码学中具有重要的地位,被广泛应用在数字签名,消息认证,数据完整性检测等领域。杂凑函数通常被认为需要满足三个基本特性：碰撞稳固性,原根稳固性和第二原根稳固性。2005年,Wang等人给出了MD5算法和SHA-1算法的碰撞攻击方法。被广泛应用的MD5算法和SHA-1算法不再是安全的算法。由此,美国国家标准与技术研究所(NIST)于2007年开始了新一轮的杂凑函数的征集...
android java 算法_android(java) SM3，SM4国密算法踩坑总结
weixin_29901323的博客
02-13 1068
1 public classSM4Util {23 public static final int KEY_SIZE = 128;45 public static final String ALGORITHM = "SM4";67 public static final String IV = "根据自己的项目定义";89 public static final S...
基于安卓系统的SM4-SM2/3加解密软件开发报告
qq_44465615的博客
01-06 3643
目 录 第一章需求分析 1.1软件功能需求 1.2平台需求 1.3人员分工 第二章概要设计 2.1 软件开发平台 2.2 软件基本流程 2.3 UML图 第三章 程序详细设计 3.1 程序接口设计 3.2 SM2、3算法设计 3.3 SM4算法设计 3.4 UI设计 第四章 调试分析 4.1 出现问题及解决方案 第五章 结果测试 5.1 SM2\3测试结果 5.2 SM4 测试结果 5.3 软件整体测试 第六章总结与感想 6.1 总结与感想 6.2 未来展望 第七章附录 7.1 各部分代码及其注释 第一章
Android\java实现SMS4加解密算法
cugzhaolc的博客
05-25 2346
垃圾代码，禁止转载。算法结构直接百度，代码如下。SMS4.javapackage saftybox.operate; import java.util.Arrays; public class SMS4 { private static final int DECRYPT = 0; public static final int ROUND = 32; private static fi...
SM2加解密、签名验签
热门推荐
qq_42873640的博客
08-11 1万+
加密流程。
记自己发现的—SM2国密算法应用的高危漏洞—CVE-2021-3711
Oh~Why not!
08-27 3253
openssl在8月24日发布了openssl 1.1.1l的稳定版，其中修复了一个高危漏洞：CVE-2021-3711。该漏洞会影响openssl 1.1.1l 之前的所有包含SM2商密算法版本，其中也包括基于openssl改造过的版本：阿里巴巴的babassl。 漏洞产生的原因，是解密 SM2公钥加密后的数据时，有可能分配了一个过小的内存，导致解密后的明文长度，大于该内存长度，造成内存越界，从而导致整个应用程序崩溃。而这个漏洞，对基于openssl搭建的国密网关服务、WEB服务，有一定概率导致...
sm2签名与sm4加密（一）
2301_76249656的博客
03-20 3161
2.将报文进行分组，每16个字也就是128bit为一组，这里采用最简单的ECB分组方式，对不足16位的最后一组进行补位，采用pkcs7方式进行补位，就是差几位就补几位的几，比如8位差八位，就补八个八，对于16整数倍补16位的16（方便解码）4.进行加密，同样将一组16个字也是32位分成八位一组的四组，轮加密Bi⊕F（B(i-1)⊕B(i-2)⊕B(i-3)⊕k(i-4)）得到下一组，最终得到B31-B35，拼成一个串返回这一组的加密结果，单组加密完毕。收到报文后，先进行sm4解密，解密后将报文进行验签。
椭圆曲线加密算法SM2在Android用Java调用实现
moonshine99的专栏
03-02 3755
        SM2基于ECC，ECC（Elliptic Curves Cryptography）加密算法是一种公钥加密算法，与主流的RSA算法相比，ECC算法可以使用较短的密钥达到相同的安全程度。近年来，人们对ECC的认识已经不再处于研究阶段，开始逐步进入实际应用，如国家密码管理局颁布的SM2算法就是基于ECC算法的。  demo下载：  https://github.com/HungryGo...
国密算法（SM2-SM3）Java 使用 demo maven 工程
06-10
以下是一个使用国密算法（SM2-SM3）的Java Demo Maven工程，供您参考： 1. 首先，在pom.xml文件中添加以下依赖： ```xml <groupId>com.huawei.security</groupId> <artifactId>sm <version>2.0.5.300 ``` 2....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值