加密解密java

最新推荐文章于 2024-07-17 14:16:50 发布
最新推荐文章于 2024-07-17 14:16:50 发布
阅读量878 收藏
点赞数
分类专栏： Java 加密解密 文章标签： java加密解密
package com.company.item.util;

    import java.security.SecureRandom;
    import java.security.Security;

    import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.SecretKeyFactory;
    import javax.crypto.spec.DESKeySpec;

    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;

    public class Corpy22 {

    public String decryptMessage(String encryptedText) {
    // TODO Auto-generated method stub
    String passwordString = encryptedText.substring(0, 12);//截取传入的字符串前12位取出秘钥，秘钥为24字节
    String cipherString = encryptedText.substring(12, encryptedText//截取出秘钥后面的需要解密的信息段
    .length());
    System.out.println(cipherString.toString()+"需要解密的信息部分");
    BASE64Decoder decoder = new BASE64Decoder();
    try {
    /**将秘钥和解密部分进行base64处理*/
    byte[] password = decoder.decodeBuffer(passwordString);
    byte[] cipherText = decoder.decodeBuffer(cipherString);
    //秘钥配置
    Security.addProvider(new com.sun.crypto.provider.SunJCE());
    //创建加密后数据对应的秘钥，得到对应的解密钥匙key
    DESKeySpec keySpec = new DESKeySpec(password);
    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    SecretKey key = keyFactory.generateSecret(keySpec);
    //解密配置参数
    byte[] iv = new sun.misc.BASE64Decoder().decodeBuffer("t4JPbY+rXgk=");
    javax.crypto.spec.IvParameterSpec ips = new javax.crypto.spec.IvParameterSpec(
    iv);
    //定义解密器
    Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
    cipher.init(Cipher.DECRYPT_MODE, key,ips);
    
    return new String(cipher.doFinal(cipherText));
    
    } catch (Exception e) {
    e.printStackTrace();
    return null;
    }
    }

    public String encryptMessage(String plainText) {
    // TODO Auto-generated method stub
    try {
    byte[] password = new byte[8];
    SecureRandom random = new SecureRandom();
    random.nextBytes(password);//随机生成一个对应的秘钥
    
    Security.addProvider(new com.sun.crypto.provider.SunJCE());
    DESKeySpec keySpec = new DESKeySpec(password);
    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    SecretKey key = keyFactory.generateSecret(keySpec);
    
    Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
    //iv在解密的时候必须要这个，加密器参数
    byte[] iv = new sun.misc.BASE64Decoder().decodeBuffer("t4JPbY+rXgk=");
    javax.crypto.spec.IvParameterSpec ips = new javax.crypto.spec.IvParameterSpec(
    iv);
    System.out.println();
    cipher.init(Cipher.ENCRYPT_MODE, key,ips);
    byte[] cipherText = cipher.doFinal(plainText.getBytes());
    BASE64Encoder encoder = new BASE64Encoder();
   return encoder.encode(password).concat(encoder.encode(cipherText));
 
    } catch (Exception e) {
    e.printStackTrace();
    return null;
    }
    }

    public static void main(String[] args) {
    Corpy22 test1 = new Corpy22();
    //String cipher = test1.encryptMessage("555he142我们啊的他们");
       // System.out.println(cipher+"**加密过后的字符串");
  //  String cipher ="0/P5Nm69/aI=bJbQmQr7r9kYwPs5OGhyruo6XU4qdyEV";
      //  String cipher = "O0Ewf68H60A=aVq4PajiEFskyEUJO7IcyTivWOcCl9OlfwTDsJSQxzk=";
       // String cipher = "O0Ewf68H60A=aVq4PajiEFskyEUJO7IcyTivWOcCl9OlfwTDsJSQxzk=";
        String cipher ="O0Ewf68H60A=aVq4PajiEFskyEUJO7IcyTivWOcCl9OlfwTDsJSQxzk=";
   String cipher1 = test1.decryptMessage(cipher);
   System.out.println(cipher1+"**解密后的字符串");
    }

    }


/**********************************************2******************************/

package com.company.item.util;

    import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.Key;
import java.security.Security;

import javax.crypto.Cipher;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

    public class Decode2{
     private static BASE64Encoder encoder = new BASE64Encoder();
     private static BASE64Decoder decoder = new BASE64Decoder();
     static String strDefaultKey = "initkey";
     static Cipher encryptCipher = null;
     static Cipher decryptCipher = null;
     
     static {
         Security.addProvider(new com.sun.crypto.provider.SunJCE());
         Key key = null;
        try {
          key = getKey(strDefaultKey.getBytes());
          encryptCipher = Cipher.getInstance("DES");
          encryptCipher.init(Cipher.ENCRYPT_MODE, key);

          decryptCipher = Cipher.getInstance("DES");
          decryptCipher.init(Cipher.DECRYPT_MODE, key);
        }catch(Exception e){
            e.printStackTrace();
            }
        }

     public Decode2(String strDefauKey){
       Security.addProvider(new com.sun.crypto.provider.SunJCE());
             Key key = null;
            try {
              key = getKey(strDefaultKey.getBytes());
              encryptCipher = Cipher.getInstance("DES");
              encryptCipher.init(Cipher.ENCRYPT_MODE, key);

              decryptCipher = Cipher.getInstance("DES");
              decryptCipher.init(Cipher.DECRYPT_MODE, key);
            }catch(Exception e){
                e.printStackTrace();
                }
            }
     

     public static byte[] encrypt(byte[] arrB) throws Exception {
      return encryptCipher.doFinal(arrB);
     }

     public static byte[] decrypt(byte[] arrB) throws Exception {
      return decryptCipher.doFinal(arrB);
     }

     private static  Key getKey(byte[] arrBTmp) throws Exception {
      byte[] arrB = new byte[8];
      for (int i = 0; i < arrBTmp.length && i < arrB.length; i++) {
       arrB[i] = arrBTmp[i];
      }
      Key key = new javax.crypto.spec.SecretKeySpec(arrB, "DES");
      return key;
     }
     
     public static void main(String[] args) {
     Decode2 d2 = new Decode2(strDefaultKey);
     String str = "啊ta他们是ddd584";
     try {
         String str1 = encoder.encode(d2.encrypt(str.getBytes("utf-8")));
        System.out.println(str1+"加密后的字符串");
        
    } catch (UnsupportedEncodingException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
     String str2 = "UT62+Vxd7IeX2CDEEJvRR70iG33HiEbu";
    try {
       String str3 = new String(d2.decrypt(decoder.decodeBuffer(str2)));
       System.out.println("解密后的数据:"+str3);
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    }
     
    }

///******************公钥私钥的控制******************///

package com.company.item.util;




    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.security.InvalidKeyException;
    import java.security.Key;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.HashMap;
    import java.util.Map;

    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;

    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;

    /**
     * RSA算法，实现数据的加密解密。
     * @author ShaoJiang
     *
     */
    class RSAUtil {
       
        private static Cipher cipher;
        
        static{
            try {
                cipher = Cipher.getInstance("RSA"); // RSA/ECB/NoPadding
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            }
        }
        
    

        /**
         * 生成密钥对
         * @param filePath 生成密钥的路径
         * @return
         */
        public static Map<String,String> generateKeyPair(String filePath){
            try {
                KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
                // 密钥位数
                keyPairGen.initialize(1024);
                // 密钥对
                KeyPair keyPair = keyPairGen.generateKeyPair();
                // 公钥
                PublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
                // 私钥
                PrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
                
                //得到公钥字符串
                String publicKeyString = getKeyString(publicKey);
                //得到私钥字符串
                String privateKeyString = getKeyString(privateKey);
                //将密钥对写入到文件
                FileWriter pubfw = new FileWriter(filePath+"/publicKey.keystore");
                FileWriter prifw = new FileWriter(filePath+"/privateKey.keystore");
                BufferedWriter pubbw = new BufferedWriter(pubfw);
                BufferedWriter pribw = new BufferedWriter(prifw);
                pubbw.write(publicKeyString);
                pribw.write(privateKeyString);
                pubbw.flush();
                pubbw.close();
                pubfw.close();
                pribw.flush();
                pribw.close();
                prifw.close();
                //将生成的密钥对返回
                Map<String,String> map = new HashMap<String,String>();
                map.put("publicKey",publicKeyString);
                map.put("privateKey",privateKeyString);
                return map;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
        
        /**
         * 得到公钥方法,并对公钥进行base64处理
         *
         * @param key
         *            密钥字符串（经过base64编码）
         * @throws Exception
         */
        public static PublicKey getPublicKey(String key) throws Exception {
            byte[] keyBytes;
            keyBytes = (new BASE64Decoder()).decodeBuffer(key);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey = keyFactory.generatePublic(keySpec);
            return publicKey;
        }
        
        /**
         * 得到私钥
         *
         * @param key
         *            密钥字符串（经过base64编码）
         * @throws Exception
         */
        public static PrivateKey getPrivateKey(String key) throws Exception {
            byte[] keyBytes;
            keyBytes = (new BASE64Decoder()).decodeBuffer(key);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
            return privateKey;
        }

        /**
         * 得到密钥字符串（经过base64编码）
         *
         * @return
         */
        public static String getKeyString(Key key) throws Exception {
            byte[] keyBytes = key.getEncoded();
            String s = (new BASE64Encoder()).encode(keyBytes);
            return s;
        }       
        
        /**
         * 使用公钥对明文进行加密，返回BASE64编码的字符串
         * @param publicKey
         * @param plainText
         * @return
         */
        public static String encrypt(PublicKey publicKey,String plainText){
            try {            
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                byte[] enBytes = cipher.doFinal(plainText.getBytes());            
                return (new BASE64Encoder()).encode(enBytes);
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            }
            return null;
        }
        
        /**
         * 使用keystore对明文进行加密
         * @param publicKeystore 公钥文件路径
         * @param plainText      明文
         * @return
         */
        public static String encrypt(String publicKeystore,String plainText){
            try {        
                
                FileReader fr = new FileReader(publicKeystore);
                BufferedReader br = new BufferedReader(fr);
                String publicKeyString="";
                String str;
                while((str=br.readLine())!=null){
                    publicKeyString+=str;
                }
                br.close();
                fr.close();
                System.out.println(publicKeyString.toString()+"***公钥");
                cipher.init(Cipher.ENCRYPT_MODE,getPublicKey(publicKeyString));
                byte[] enBytes = cipher.doFinal(plainText.getBytes());            
                return (new BASE64Encoder()).encode(enBytes);
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }    
        
        /**
         * 使用私钥对明文密文进行解密
         * @param privateKey
         * @param enStr
         * @return
         */
        public static String decrypt(PrivateKey privateKey,String enStr){
            try {
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));
                return new String(deBytes);
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
        
        /**
         * 使用keystore对密文进行解密
         * @param privateKeystore  私钥路径
         * @param enStr                                         密文
         * @return
         */
        public static String decrypt(String privateKeystore,String enStr){
            try {
                FileReader fr = new FileReader(privateKeystore);
                BufferedReader br = new BufferedReader(fr);
                String privateKeyString="";
                String str;
                while((str=br.readLine())!=null){
                    privateKeyString+=str;
                }
                br.close();
                fr.close();            
                cipher.init(Cipher.DECRYPT_MODE, getPrivateKey(privateKeyString));
                byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));
                return new String(deBytes);
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    }

    public class JavaToC {

        // 将 s 进行 BASE64 编码
        public static String getBASE64(String s) {
            if (s == null) return null;
            return (new sun.misc.BASE64Encoder()).encode( s.getBytes() );
        }

        // 将 BASE64 编码的字符串 s 进行解码
        public static String getFromBASE64(String s) {
            if (s == null) return null;
            BASE64Decoder decoder = new BASE64Decoder();
            try {
            byte[] b = decoder.decodeBuffer(s);
            return new String(b);
            } catch (Exception e) {
            return null;
            }
        }
        
        public static void testBASE64()
        {                   //  12345678876543211234567887654321123456788765432112345678876543211234567887654321
            //String s = "1234567887654321123456788765432112345678876543211234567887654321123456788765432112345678876543211234567887654321123456788765432112345678876543211234567887654321";
            String s = "java加密后的数据29875";
            System.out.println("length=" + s.length());
            String ans = getBASE64(s);
            System.out.println("length=" + ans.length());
            System.out.println(ans+"64编码数据");
            //String temp = "MTIzNDU2Nzg4NzY1NDMyMTEyMzQ1Njc4ODc2NTQzMjExMjM0NTY3ODg3NjU0MzIxMTIzNDU2Nzg4NzY1NDMyMTEyMzQ1Njc4ODc2NTQzMjE=";
            //String res = getFromBASE64(temp);
            String res = getFromBASE64(ans);
            System.out.println(res+"64解码后的数据");
            System.out.println("----------------------------------------");
        }


/*************************************加盐值随机数的加密解密**************************************************/

1加密方法：

package com.company.item.util;

import java.io.FileOutputStream;
import java.util.*;
import java.security.*;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class DEcode {
    private static BASE64Encoder encoder = new BASE64Encoder();
    private static BASE64Decoder decoder = new BASE64Decoder();
    public static void main(String[] args) throws Exception {
     String s="welcome to java";
        String str = "123456";//加密口令
        char[] passwd = str.toCharArray();
        PBEKeySpec pbks = new PBEKeySpec(passwd);
        SecretKeyFactory kf = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
        SecretKey k = kf.generateSecret(pbks);//生成秘钥
        
        byte[] salt = new byte[8];//生成随机数 盐：必须是8个元素的字节数组
        Random ran = new Random();
         ran.nextBytes(salt);
         
         Cipher cp = Cipher.getInstance("PBEWithMD5AndDES");//创建并初始化密码器
         
        PBEParameterSpec ps = new PBEParameterSpec(salt,1000);//为了提高破解难度，增加盐的迭代次数 1000次
        
        cp.init(Cipher.ENCRYPT_MODE, k,ps);//初始化加密器
        byte[] ptext = s.getBytes("utf-8");//获取要加密的字符串，转为字节形式，并指定字符集
        byte[] ctext = cp.doFinal(ptext);//调用doFinal方法对传入的文本进行加密
       
       FileOutputStream fos = new FileOutputStream("PBEEnc.dat");
       fos.write(salt);
       fos.write(ctext);//将盐和加密有的文本写入PBEEnc.dat文件中
   
       for(int i=0;i<salt.length;i++){
           System.out.println(salt[i]+",");
       }
        System.out.println("");
        for(int i=0;i<ctext.length;i++){
        System.out.println(ctext[i]+",");
        }
        
    }
   
}

2**************解密方法：

package com.company.item.util;

import java.io.FileInputStream;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;

public class EDcode {
    public static void main(String args[]) throws Exception {
    
    String str = "123456";//解密口令与加密口令一
    char[] passwd = str.toCharArray();
    PBEKeySpec pbks = new PBEKeySpec(passwd);
    SecretKeyFactory kf = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
    SecretKey k = kf.generateSecret(pbks);

    byte[] salt = new byte[8];
    FileInputStream f = new FileInputStream("PBEEnc.dat");
    f.read(salt);

    int num = f.available();
    byte[] ctext = new byte[num];
    f.read(ctext);

    Cipher cp = Cipher.getInstance("PBEWithMD5AndDES");
    PBEParameterSpec ps = new PBEParameterSpec(salt, 1000);
    cp.init(Cipher.DECRYPT_MODE, k,ps);
    byte[] ptext = cp.doFinal(ctext);
    System.out.println(new String(ptext));
    }
}

      
        public static void main(String[] args)
        {
            RSAUtil util = new RSAUtil();
             util.generateKeyPair("key");
            //String cp = "M04d2l9MyDiUUfAQ32FdphesAQJHZUk0dEsYQcU06IJo/RCF311GtJXBK1FhapITIvjkpsiz9NR25AGEFPdz4bs2o5/F0QIj5yFA+biLxgcFrDpd5gSWI1F8V7wbsl06tNLNOVihFfzl8xWbHMVqPhY3tj8Vu/QHEPPnx7mvHlc="; // cp保存的是由openssl加密后的结果（包括了对密文的base64编码）
            String cipher = util.encrypt("D:/WorkSpaces/CSTSystem/key/publicKey.keystore", "hello world");//公钥加密
            //privateKey
            JavaToC.testBASE64();
            String recover = util.decrypt("D:/WorkSpaces/CSTSystem/key/privateKey.keystore", cipher);//私钥解密
            System.out.println("加密后cipher=" + cipher);
            System.out.println("解密后recover=" + recover);        
        }
    }



真土
关注
专栏目录
JAVA加密解密
04-24
NULL 博文链接：https://xiaoyuzhou.iteye.com/blog/2381362
DES加密解密java工具类
07-31
DES加密解密java工具类 public static final String KEY_ALGORITHM = "DES"; public static final String CIPHER_ALGORITHM = "DES/ECB/PKCS5PADDING"; validKeySpecException, NoSuchPaddingException, ...
java加密解密
qq_42591048的博客
04-02 247
异或：a.同为0，异为1； b.一个数，两次异或之后，是原数本身 - 加密 解密 a(97) - 01100001 3 - 00000011 a与3的异或 01100010 一次异或后的结果 3 - 00000011 再次与3异或 01100001 ...
【Java】使用RSA进行加密解密（代码实现）
最新发布
m0_64210833的博客
07-17 900
使用RSA进行加密解密（代码实现）
java的加密解密
haiguo6hao的博客
08-26 188
一、加密 加密函数代码： public String Encrypt(String S, int Key) { StringBuffer Result = new StringBuffer(); StringBuffer str; int i, j; for (i = 0; i < S.length(); i++) { ...
Java 加密解密
Pig
02-27 1647
来自网络，稍作修改，仅做记录 import java.security.Key; import javax.crypto.BadPaddingException; import javax.crypto.Cipher; import javax.crypto.IllegalBlockSizeException; /** * 加密解密字符串和字节码 * * @version 2013
SM4国密加密解密JAVA代码实现.zip
12-19
SMS4国密JAVA加密解密完整代码，无异常java类文件，导入即用。Convert.java 内部字符串进制转换类，SMS4.java 国密加密解密处理方法类。TestMain.java 测试类，调用 encrypt 加密 decode 解密
Des.java 加密解密JAVA源代码
10-13
加密、解密过程，需要传递四个变量。 加密的四个变量依次为：明文，代码1，代码2，代码3 解密的四个变量依次为：密文，代码1，代码2，代码3
Playfair_Java.rar_playfair_加密 解密_加密算法_加密解密 java_解密
09-21
在Java中实现加密解密算法，需要熟悉数据结构、字符串处理以及基本的加密原理。通过分析和实践提供的代码，开发者可以进一步理解如何在实际项目中使用这些技术，比如在开发安全通信软件或者数据存储解决方案时。同时...
des加密解密JAVA与.NET互通实例
09-04
在Java和.NET之间进行互通时，DES加密解密的实现是至关重要的，因为这允许两个平台之间的应用程序能够共享加密过的数据并正确地解密。下面将详细解释DES加密解密的基本原理、Java实现以及如何在Java与.NET之间进行...
Java加密解密
04-23
NULL 博文链接：https://jiage17.iteye.com/blog/2257020
java密码加密与解密
10-26
java代码编写的密码加密类，可以解密。根据自己需求改变秘钥，更安全。windows和Linux环境密文不一致问题解决方案见我的博客https://blog.csdn.net/yang1393214887/article/details/83411051#comments
java加密解密程序
08-15
采用MyEclipse编写的一个java加密解密程序，算法是凯撒加密法，欢迎有兴趣的朋友下载
java实现文件加密解密
10-25
利用java实现将资源文件（包括图片、动画等类型）进行简单的加密、解密
java 加密解密
shaier的专栏
01-28 525
/**　　 * @(#)Eryptogram.java 1.00 04/03/11　　 *　　 * Copyright (c) 2003-2004 Abacus,Ltd.　　 *　　 * 加密解密类　　 *　　 * 　　 *　　 */　　 package  com.abacus.common ;　　 import  java.security. *;　　 import  javax.crypto.
SM2加密解密 java实现
09-02
要在Java中实现SM2加密解密，您可以使用bcprov库。在使用之前，您需要确保已经导入了bcprov-ext-jdk15on-151.jar和bcprov-jdk15on-151.jar这两个包。 首先，您需要生成SM2的密钥对。可以使用以下代码生成密钥对： ```java import org.bouncycastle.jce.provider.BouncyCastleProvider; import org.bouncycastle.util.encoders.Hex; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.Security; public class SM2Example { public static void main(String[] args) throws Exception { Security.addProvider(new BouncyCastleProvider()); KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("SM2", "BC"); KeyPair keyPair = keyPairGenerator.generateKeyPair(); byte[] publicKey = keyPair.getPublic().getEncoded(); byte[] privateKey = keyPair.getPrivate().getEncoded(); System.out.println("公钥: " + Hex.toHexString(publicKey)); System.out.println("私钥: " + Hex.toHexString(privateKey)); } } ``` 然后，您可以使用以下代码进行SM2加密和解密： ```java import org.bouncycastle.asn1.ASN1Integer; import org.bouncycastle.asn1.DERSequence; import org.bouncycastle.asn1.pkcs.PrivateKeyInfo; import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo; import org.bouncycastle.crypto.InvalidCipherTextException; import org.bouncycastle.crypto.engines.SM2Engine; import org.bouncycastle.crypto.params.ECPrivateKeyParameters; import org.bouncycastle.crypto.params.ECPublicKeyParameters; import org.bouncycastle.crypto.util.PrivateKeyInfoFactory; import org.bouncycastle.crypto.util.SubjectPublicKeyInfoFactory; import org.bouncycastle.jce.provider.BouncyCastleProvider; import org.bouncycastle.util.encoders.Hex; import java.security.KeyFactory; import java.security.PrivateKey; import java.security.PublicKey; import java.security.Security; import java.security.spec.PKCS8EncodedKeySpec; import java.security.spec.X509EncodedKeySpec; public class SM2Example { public static void main(String[] args) throws Exception { Security.addProvider(new BouncyCastleProvider()); // 加载公钥和私钥 byte[] publicKeyBytes = Hex.decode("公钥"); byte[] privateKeyBytes = Hex.decode("私钥"); KeyFactory keyFactory = KeyFactory.getInstance("SM2", "BC"); X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(publicKeyBytes); PublicKey publicKey = keyFactory.generatePublic(publicKeySpec); PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(privateKeyBytes); PrivateKey privateKey = keyFactory.generatePrivate(privateKeySpec); // 加密 SM2Engine engine = new SM2Engine(); engine.init(true, new ECPublicKeyParameters((ECPublicKey) publicKey, SM2Util.DOMAIN_PARAMETERS)); byte[] plaintext = "要加密的数据".getBytes(); byte[] encrypted = engine.processBlock(plaintext, 0, plaintext.length); System.out.println("加密结果: " + Hex.toHexString(encrypted)); // 解密 engine.init(false, new ECPrivateKeyParameters((ECPrivateKey) privateKey, SM2Util.DOMAIN_PARAMETERS)); byte[] decrypted = engine.processBlock(encrypted, 0, encrypted.length); System.out.println("解密结果: " + new String(decrypted)); } } ``` 请注意，这只是一个基础的示例，您可能需要根据您的具体需求进行修改和完善。另外，您还可以通过了解更多关于bcprov库的文档和示例来深入学习和使用SM2加密解密。<span class="em">1</span> #### 引用[.reference_title] - *1* [SM2加密解密JAVA版本.zip](https://download.csdn.net/download/kill_bugs/13500151)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值