Android和JAVA后台实现RSA加解密

最新推荐文章于 2022-08-21 19:15:36 发布

要想进步先学cv

最新推荐文章于 2022-08-21 19:15:36 发布

阅读量791

点赞数

分类专栏：加解密文章标签： java android apache

原文链接：https://blog.youkuaiyun.com/qq_40525756/article/details/109649435

版权

加解密专栏收录该内容

2 篇文章

订阅专栏

原文链接：https://blog.youkuaiyun.com/qq_40525756/article/details/109649435

##安卓端代码

import android.util.Base64;
import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;

/**

author: WeiFeiChen
date: 2020/11/6.
describe: RSA加解密

/
public class RSAUtils {
/*
* RSA最大加密明文大小
/
private static final int MAX_ENCRYPT_BLOCK = 117;
/*
* RSA最大解密密文大小
*/
private static final int MAX_DECRYPT_BLOCK = 128;

public static final String KEY_ALGORITHM = "RSA";
private static KeyFactory keyFactory = null;

static {
    try {
        keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
}

public static Key getPrivateKeyFromBase64KeyEncodeStr(String keyStr) {
    byte[] keyBytes = Base64.decode(keyStr, Base64.NO_WRAP);
    // 取得私钥
    PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
    Key privateKey = null;
    try {
        privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
    } catch (InvalidKeySpecException e) {
        e.printStackTrace();
    }
    return privateKey;
}

/**
 * 获取base64加密后的字符串的原始公钥
 *
 * @param keyStr
 * @return
 */
public static Key getPublicKeyFromBase64KeyEncodeStr(String keyStr) {
    byte[] keyBytes = Base64.decode(keyStr, Base64.NO_WRAP);
    X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
    Key publicKey = null;
    try {
        publicKey = keyFactory.generatePublic(x509KeySpec);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return publicKey;
}

/**
 * 公钥加密
 *
 * @param data 待加密数据
 * @param key  密钥
 * @return byte[] 加密数据
 */
public static String encryptPublicKey(byte[] data, String key) throws Exception {
    //解密密钥
    byte[] keyBytes = Base64.decode(key, Base64.NO_WRAP);
    //实例化密钥工厂
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    //初始化公钥
    //密钥材料转换
    X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
    //产生公钥
    PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

    //数据加密
    Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");//Android端使用
    cipher.init(Cipher.ENCRYPT_MODE, pubKey);
    byte[] bytes = cipher.doFinal(data);
    return new String(Base64.encode(bytes, Base64.NO_WRAP));
}

/**
 * 私钥解密
 *
 * @param data       待解密数据
 * @param privateKey 密钥
 * @return byte[] 解密数据
 */
public static String decryptPrivateKey(String data, String privateKey) throws Exception {


    Key decodePrivateKey = getPrivateKeyFromBase64KeyEncodeStr(privateKey);
    Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");//Android端使用
    cipher.init(Cipher.DECRYPT_MODE, decodePrivateKey);

    byte[] encryptedData = Base64.decode(data, Base64.NO_WRAP);
    byte[] decodedData = cipher.doFinal(encryptedData);
    String decodedDataStr = new String(decodedData);
    return decodedDataStr;
}

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

/**
 * 使用公钥进行分段加密
 *
 * @param dataStr 要加密的数据
 * @return 公钥base64字符串
 * @throws Exception
 */
public static String encryptByPublicKey(String dataStr, String publicKey)
        throws Exception {
    byte[] data = dataStr.getBytes();
    // 对公钥解密
    Key decodePublicKey = getPublicKeyFromBase64KeyEncodeStr(publicKey);
    // 对数据加密
    Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");//Android端使用
    cipher.init(Cipher.ENCRYPT_MODE, decodePublicKey);
    int inputLen = data.length;
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    int offSet = 0;
    byte[] cache;
    int i = 0;
    // 对数据分段加密
    while (inputLen - offSet > 0) {
        if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
            cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
        } else {
            cache = cipher.doFinal(data, offSet, inputLen - offSet);
        }
        out.write(cache, 0, cache.length);
        i++;
        offSet = i * MAX_ENCRYPT_BLOCK;
    }
    byte[] encryptedData = out.toByteArray();
    out.close();
    String encodedDataStr = new String(Base64.encode(encryptedData, Base64.NO_WRAP));

    return encodedDataStr;
}

/**
 * 使用私钥进行分段解密
 *
 * @param dataStr 使用base64处理过的密文
 * @return 解密后的数据
 * @throws Exception
 */
public static String decryptByPrivateKey(String dataStr, String privateKey)
        throws Exception {

    byte[] encryptedData = Base64.decode(dataStr, Base64.NO_WRAP);

    Key decodePrivateKey = getPrivateKeyFromBase64KeyEncodeStr(privateKey);

    Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");//Android端使用
    cipher.init(Cipher.DECRYPT_MODE, decodePrivateKey);
    int inputLen = encryptedData.length;
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    int offSet = 0;
    byte[] cache;
    int i = 0;
    // 对数据分段解密
    while (inputLen - offSet > 0) {
        if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
            cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
        } else {
            cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
        }
        out.write(cache, 0, cache.length);
        i++;
        offSet = i * MAX_DECRYPT_BLOCK;
    }
    byte[] decryptedData = out.toByteArray();
    out.close();
    String decodedDataStr = new String(decryptedData, "utf-8");
    return decodedDataStr;
}

}

##Java后台代码

package com.gbss.common.utils;

import java.io.ByteArrayOutputStream;
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.SecureRandom;
import java.security.Security;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import javax.crypto.Cipher;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

/**

RSA加解密
@author 吴帅
created at 2017/6/8
*/
public class RSAUtils {

/** //*
- RSA最大加密明文大小
  */
  private static final int MAX_ENCRYPT_BLOCK = 117;
/** //*
- RSA最大解密密文大小
  */
  private static final int MAX_DECRYPT_BLOCK = 128;
public static final String KEY_ALGORITHM = “RSA”;//RSA/ECB/PKCS1Padding

private static KeyFactory keyFactory = null;

static {
try {
keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}

/**
- 获取base64加密后的字符串的原始私钥
- @param keyStr
- @return
  */
  public static Key getPrivateKeyFromBase64KeyEncodeStr(String keyStr) {
  byte[] keyBytes = Base64.getDecoder().decode(keyStr);
  // 取得私钥
  PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  Key privateKey=null;
  try {
  privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
  } catch (InvalidKeySpecException e) {
  e.printStackTrace();
  }
  return privateKey;
  }
/**
- 获取base64加密后的字符串的原始公钥
- @param keyStr
- @return
  */
  public static Key getPublicKeyFromBase64KeyEncodeStr(String keyStr) {
  byte[] keyBytes = Base64.getDecoder().decode(keyStr);
  X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  Key publicKey = null;
  try {
  publicKey = keyFactory.generatePublic(x509KeySpec);
  } catch (Exception e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  }
  return publicKey;
  }
/**
- 公钥加密方法
- @param dataStr 要加密的数据
- @param dataStr 公钥base64字符串
- @return 加密后的base64字符串
- @throws Exception
  */
  public static String encryptPublicKey(String dataStr, String publicKey) throws Exception{
  //要加密的数据
  System.out.println(“要加密的数据:”+dataStr);
  byte[] data = dataStr.getBytes();
  // 对公钥解密
  Key decodePublicKey = getPublicKeyFromBase64KeyEncodeStr(publicKey);
  // 对数据加密
  Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
  cipher.init(Cipher.ENCRYPT_MODE, decodePublicKey);
  byte[] encodedData = cipher.doFinal(data);
  String encodedDataStr = new String(Base64.getEncoder().encode(encodedData));
  System.out.println(“公钥加密后的数据:”+encodedDataStr);
  return encodedDataStr;
  }
/**
- 私钥解密
  */
  public static String decrypt(String dataStr, String privateKey) throws Exception{
  //要加密的数据
  System.out.println(“要解密的数据:”+dataStr);
  //对私钥解密
  Key decodePrivateKey = getPrivateKeyFromBase64KeyEncodeStr(privateKey);
  //Log.i(“机密”,""+decodePrivateKey);
  Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
  cipher.init(Cipher.DECRYPT_MODE, decodePrivateKey);
  byte[] encodedData = Base64.getDecoder().decode(dataStr);
  byte[] decodedData = cipher.doFinal(encodedData);
  String decodedDataStr = new String(decodedData,“utf-8”);
  System.out.println(“私钥解密后的数据:”+decodedDataStr);
  return decodedDataStr;
  }
/**
- 使用公钥进行分段加密
- @param dataStr 要加密的数据
- @return 公钥base64字符串
- @throws Exception
  */
  public static String encryptByPublicKey(String dataStr, String publicKey)
  throws Exception {
  //要加密的数据
  System.out.println(“要加密的数据:”+dataStr);
  byte[] data = dataStr.getBytes();
  // 对公钥解密
  Key decodePublicKey = getPublicKeyFromBase64KeyEncodeStr(publicKey);
  
  KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  // 对数据加密
  String s = keyFactory.getAlgorithm();
  Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  cipher.init(Cipher.ENCRYPT_MODE, decodePublicKey);
  int inputLen = data.length;
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  int offSet = 0;
  byte[] cache;
  int i = 0;
  // 对数据分段加密
  while (inputLen - offSet > 0) {
  if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  } else {
  cache = cipher.doFinal(data, offSet, inputLen - offSet);
  }
  out.write(cache, 0, cache.length);
  i++;
  offSet = i * MAX_ENCRYPT_BLOCK;
  }
  byte[] encryptedData = out.toByteArray();
  out.close();
  String encodedDataStr = new String(Base64.getEncoder().encode(encryptedData));
  System.out.println(“公钥加密后的数据:”+encodedDataStr);
  return encodedDataStr;
  }
/**
- 使用私钥进行分段解密
- @param dataStr 使用base64处理过的密文
- @return 解密后的数据
- @throws Exception
  */
  public static String decryptByPrivateKey(String dataStr, String privateKey)
  throws Exception {
  byte[] encryptedData = Base64.getDecoder().decode(dataStr);
  
  KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  Key decodePrivateKey = getPrivateKeyFromBase64KeyEncodeStr(privateKey);
  
  Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  //Cipher cipher = Cipher.getInstance(“RSA/ECB/PKCS1Padding”);
  cipher.init(Cipher.DECRYPT_MODE, decodePrivateKey);
  int inputLen = encryptedData.length;
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  int offSet = 0;
  byte[] cache;
  int i = 0;
  // 对数据分段解密
  while (inputLen - offSet > 0) {
  if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  } else {
  cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
  }
  out.write(cache, 0, cache.length);
  i++;
  offSet = i * MAX_DECRYPT_BLOCK;
  }
  byte[] decryptedData = out.toByteArray();
  out.close();
  String decodedDataStr = new String(decryptedData,“utf-8”);
  System.out.println(“私钥解密后的数据:”+decodedDataStr);
  return decodedDataStr;
  }
/**
- 生成公私钥
  */
  public static void genKeyPair() throws NoSuchAlgorithmException {
  Security.addProvider(new BouncyCastleProvider());
  KeyPairGenerator generator = KeyPairGenerator.getInstance(“RSA”);
  generator.initialize(1024, new SecureRandom());
  KeyPair pair = generator.generateKeyPair();
  PublicKey pubKey = pair.getPublic();
  PrivateKey privKey = pair.getPrivate();
  byte[] pk = pubKey.getEncoded();
  byte[] privk = privKey.getEncoded();
  String strpk = new String(Base64.getEncoder().encode(pk));
  String strprivk = new String(Base64.getEncoder().encode(privk));
  
  System.out.println(“公钥Base64编码:” + strpk);
  System.out.println(“私钥Base64编码:” + strprivk);
  }
public static void main(String[] args) throws Exception {

// String pubKey = “公钥”;
// String prvKey = “私钥”;
// Map<String, String> data = new HashMap<String, String>();
// data.put(“account”,“111”);
// data.put(“password”,“JJHH”);
// System.out.println("–>加密前：" + data);
//
// String enData = RSAUtils.encryptByPublicKey(JacksonUtils.obj2json(data), pubKey);
// System.out.println("–>加密后：" + enData);
//
// String deData = RSAUtils.decryptByPrivateKey(enData, prvKey);
// System.out.println("–>解密后：" + deData);
// genKeyPair();
}
}