网络请求的数据需要加密，服务器给的他们那一套在Android一直报错，自己写了一个；

  1. package com.cc.common.util;
  3. import javax.crypto.Cipher;
  4. import java.security.*;
  5. import java.security.spec.PKCS8EncodedKeySpec;
  6. import java.security.spec.X509EncodedKeySpec;
  7. import sun.misc.BASE64Decoder;
  8. import sun.misc.BASE64Encoder;
  10. /**
  11.  * RSA加解密工具类
  12.  */
  13. public class RSAUtils {
  14.     //公钥加密
  15.     public static String encrypt(String content, PublicKey publicKey) {
  16.         try{
  17.             Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");//java默认"RSA"="RSA/ECB/PKCS1Padding"
  18.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  19.             byte[] output = cipher.doFinal(content.getBytes());
  20.             BASE64Encoder encoder = new BASE64Encoder();
  21.             return encoder.encode(output);
  22.         }catch (Exception e){
  23.             e.printStackTrace();
  24.         }
  25.         return null;
  26.     }
  28.     //公钥加密
  29.     public static byte[] encrypt(byte[] content, PublicKey publicKey) {
  30.         try{
  31.             Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");//java默认"RSA"="RSA/ECB/PKCS1Padding"
  32.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  33.             return  cipher.doFinal(content);
  34.         }catch (Exception e){
  35.             e.printStackTrace();
  36.         }
  37.         return null;
  38.     }
  40.     //私钥解密
  41.     public static byte[] decrypt(byte[] content, PrivateKey privateKey) {
  42.         try {
  43.             Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
  44.             cipher.init(Cipher.DECRYPT_MODE, privateKey);
  45.             return cipher.doFinal(content);
  46.         } catch (Exception e){
  47.             e.printStackTrace();
  48.             return null;
  49.         }
  50.     }
  51.     //私钥解密
  52.     public static String decrypt(String content, PrivateKey privateKey) {
  53.         try {
  54.             Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
  55.             cipher.init(Cipher.DECRYPT_MODE, privateKey);
  56.             byte [] b = cipher.doFinal(content.getBytes());
  57.             BASE64Encoder encoder = new BASE64Encoder();
  58.             return encoder.encode(b);
  59.         } catch (Exception e){
  60.             e.printStackTrace();
  61.             return null;
  62.         }
  63.     }
  65.     /**
  66.      * String转公钥PublicKey
  67.      * @param key
  68.      * @return
  69.      * @throws Exception
  70.      */
  71.     public static PublicKey getPublicKey(String key) throws Exception {
  72.         byte[] keyBytes;
  73.         keyBytes = (new BASE64Decoder()).decodeBuffer(key);
  74.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
  75.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  76.         PublicKey publicKey = keyFactory.generatePublic(keySpec);
  77.         return publicKey;
  78.     }
  80.     /**
  81.      * String转私钥PrivateKey
  82.      * @param key
  83.      * @return
  84.      * @throws Exception
  85.      */
  86.     public static PrivateKey getPrivateKey(String key) throws Exception {
  87.         byte[] keyBytes;
  88.         keyBytes = (new BASE64Decoder()).decodeBuffer(key);
  89.         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
  90.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  91.         PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
  92.         return privateKey;
  93.     }
  94. }

如果你的 BASE64Decoder()一直报错，请添加Base64.jar；

链接: https://pan.baidu.com/s/1-pXV7xpFwqhv54DHGGbliw 密码: tcge

附：ResCoder

  1. public class RSACoder {
  2.     private static final String KEY_ALGORITHM = "RSA";
  3.     private static final String CIPHER_TYPE = "RSA/None/PKCS1Padding"; // Android端加密算法
  4.     private static final String SIGNATURE_ALGORITHM = "MD5withRSA";
  6.     private static final String PUBLIC_KEY = "RSAPublicKey";
  7.     private static final String PRIVATE_KEY = "RSAPrivateKey";
  9.     /**
  10.      * RSA最大加密明文大小
  11.      */
  12.     private static final int MAX_ENCRYPT_BLOCK = 117;
  14.     /**
  15.      * RSA最大解密密文大小
  16.      */
  17.     private static final int MAX_DECRYPT_BLOCK = 128;
  19.     public static byte[] decryptBASE64(String key) {
  20.         return Base64.decode(key, Base64.NO_WRAP);
  21. //        return Base64.getDecoder().decode(key);
  22.     }
  24.     public static String encryptBASE64(byte[] bytes) {
  25.         return Base64.encodeToString(bytes, Base64.NO_WRAP);
  26. //        return Base64.getEncoder().encodeToString(bytes);
  27.     }
  29.     /**
  30.      * 用私钥对信息生成数字签名
  31.      *
  32.      * @param data       加密数据
  33.      * @param privateKey 私钥
  34.      * @return
  35.      * @throws Exception
  36.      */
  37.     public static String sign(byte[] data, String privateKey) throws Exception {
  38.         // 解密由base64编码的私钥
  39.         byte[] keyBytes = decryptBASE64(privateKey);
  40.         // 构造PKCS8EncodedKeySpec对象
  41.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  42.         // KEY_ALGORITHM 指定的加密算法
  43.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  44.         // 取私钥匙对象
  45.         PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
  46.         // 用私钥对信息生成数字签名
  47.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  48.         signature.initSign(priKey);
  49.         signature.update(data);
  50.         return encryptBASE64(signature.sign());
  51.     }
  53.     /**
  54.      * 校验数字签名
  55.      *
  56.      * @param data      加密数据
  57.      * @param publicKey 公钥
  58.      * @param sign      数字签名
  59.      * @return 校验成功返回true 失败返回false
  60.      * @throws Exception
  61.      */
  62.     public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
  63.         // 解密由base64编码的公钥
  64.         byte[] keyBytes = decryptBASE64(publicKey);
  65.         // 构造X509EncodedKeySpec对象
  66.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
  67.         // KEY_ALGORITHM 指定的加密算法
  68.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  69.         // 取公钥匙对象
  70.         PublicKey pubKey = keyFactory.generatePublic(keySpec);
  71.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  72.         signature.initVerify(pubKey);
  73.         signature.update(data);
  74.         // 验证签名是否正常
  75.         return signature.verify(decryptBASE64(sign));
  76.     }
  78.     /**
  79.      * 私钥解密
  80.      *
  81.      * @param data
  82.      * @param key
  83.      * @return
  84.      * @throws Exception
  85.      */
  86.     public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception {
  87.         // 对密钥解密
  88.         byte[] keyBytes = decryptBASE64(key);
  89.         // 取得私钥
  90.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  91.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  92.         Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
  93.         // 对数据解密
  94.         Cipher cipher = Cipher.getInstance(CIPHER_TYPE);
  95.         cipher.init(Cipher.DECRYPT_MODE, privateKey);
  96.         int inputLen = data.length;
  97.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  98.         int offSet = 0;
  99.         byte[] cache;
  100.         int i = 0;
  101.         // 对数据分段解密
  102.         while (inputLen - offSet > 0) {
  103.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  104.                 cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
  105.             } else {
  106.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  107.             }
  108.             out.write(cache, 0, cache.length);
  109.             i++;
  110.             offSet = i * MAX_DECRYPT_BLOCK;
  111.         }
  112.         byte[] decryptedData = out.toByteArray();
  113.         out.close();
  114.         return decryptedData;
  115.     }
  117.     /**
  118.      * 解密<br>
  119.      * 用私钥解密
  120.      *
  121.      * @param data
  122.      * @param key
  123.      * @return
  124.      * @throws Exception
  125.      */
  126.     public static byte[] decryptByPrivateKey(String data, String key) throws Exception {
  127.         return decryptByPrivateKey(decryptBASE64(data), key);
  128.     }
  130.     /**
  131.      * 解密<br>
  132.      * 用公钥解密
  133.      *
  134.      * @param data
  135.      * @param key
  136.      * @return
  137.      * @throws Exception
  138.      */
  139.     public static byte[] decryptByPublicKey(byte[] data, String key) throws Exception {
  140.         // 对密钥解密
  141.         byte[] keyBytes = decryptBASE64(key);
  142.         // 取得公钥
  143.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  144.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  145.         Key publicKey = keyFactory.generatePublic(x509KeySpec);
  146.         // 对数据解密
  147.         Cipher cipher = Cipher.getInstance(CIPHER_TYPE);
  148.         cipher.init(Cipher.DECRYPT_MODE, publicKey);
  149.         int inputLen = data.length;
  150.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  151.         int offSet = 0;
  152.         byte[] cache;
  153.         int i = 0;
  154.         // 对数据分段解密
  155.         while (inputLen - offSet > 0) {
  156.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  157.                 cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
  158.             } else {
  159.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  160.             }
  161.             out.write(cache, 0, cache.length);
  162.             i++;
  163.             offSet = i * MAX_DECRYPT_BLOCK;
  164.         }
  165.         byte[] decryptedData = out.toByteArray();
  166.         out.close();
  167.         return decryptedData;
  168.     }
  170.     /**
  171.      * 加密<br>
  172.      * 用公钥加密
  173.      *
  174.      * @param data
  175.      * @param key
  176.      * @return
  177.      * @throws Exception
  178.      */
  179.     public static byte[] encryptByPublicKey(String data, String key) throws Exception {
  180.         // 对公钥解密
  181.         byte[] keyBytes = decryptBASE64(key);
  182.         // 取得公钥
  183.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  184.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  185.         Key publicKey = keyFactory.generatePublic(x509KeySpec);
  186.         // 对数据加密(分段)
  187.         Cipher cipher = Cipher.getInstance(CIPHER_TYPE);
  188.         cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  189.         byte[] dataByteArray = data.getBytes();
  190.         int inputLen = dataByteArray.length;
  191.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  192.         int offSet = 0;
  193.         byte[] cache;
  194.         int i = 0;
  195.         // 对数据分段加密
  196.         while (inputLen - offSet > 0) {
  197.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  198.                 cache = cipher.doFinal(dataByteArray, offSet, MAX_ENCRYPT_BLOCK);
  199.             } else {
  200.                 cache = cipher.doFinal(dataByteArray, offSet, inputLen - offSet);
  201.             }
  202.             out.write(cache, 0, cache.length);
  203.             i++;
  204.             offSet = i * MAX_ENCRYPT_BLOCK;
  205.         }
  206.         byte[] encryptedData = out.toByteArray();
  207.         out.close();
  208.         return encryptedData;
  209.     }
  211.     /**
  212.      * 加密<br>
  213.      * 用私钥加密
  214.      *
  215.      * @param data
  216.      * @param key
  217.      * @return
  218.      * @throws Exception
  219.      */
  220.     public static byte[] encryptByPrivateKey(byte[] data, String key) throws Exception {
  221.         // 对密钥解密
  222.         byte[] keyBytes = decryptBASE64(key);
  223.         // 取得私钥
  224.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  225.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  226.         Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
  227.         // 对数据加密
  228.         Cipher cipher = Cipher.getInstance(CIPHER_TYPE);
  229.         cipher.init(Cipher.ENCRYPT_MODE, privateKey);
  230.         int inputLen = data.length;
  231.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  232.         int offSet = 0;
  233.         byte[] cache;
  234.         int i = 0;
  235.         // 对数据分段加密
  236.         while (inputLen - offSet > 0) {
  237.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  238.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  239.             } else {
  240.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  241.             }
  242.             out.write(cache, 0, cache.length);
  243.             i++;
  244.             offSet = i * MAX_ENCRYPT_BLOCK;
  245.         }
  246.         byte[] encryptedData = out.toByteArray();
  247.         out.close();
  248.         return encryptedData;
  249.     }
  251.     /**
  252.      * 取得私钥
  253.      *
  254.      * @param keyMap
  255.      * @return
  256.      * @throws Exception
  257.      */
  258.     public static String getPrivateKey(Map<String, Key> keyMap) {
  259.         Key key = keyMap.get(PRIVATE_KEY);
  260.         return encryptBASE64(key.getEncoded());
  261.     }
  263.     /**
  264.      * 取得公钥
  265.      *
  266.      * @param keyMap
  267.      * @return
  268.      * @throws Exception
  269.      */
  270.     public static String getPublicKey(Map<String, Key> keyMap) {
  271.         Key key = keyMap.get(PUBLIC_KEY);
  272.         return encryptBASE64(key.getEncoded());
  273.     }
  275.     /**
  276.      * 初始化密钥
  277.      *
  278.      * @return
  279.      * @throws Exception
  280.      */
  281.     public static Map<String, Key> initKey() throws NoSuchAlgorithmException {
  282.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
  283.         keyPairGen.initialize(1024);
  284.         KeyPair keyPair = keyPairGen.generateKeyPair();
  285.         Map<String, Key> keyMap = new HashMap<>(2);
  286.         keyMap.put(PUBLIC_KEY, keyPair.getPublic());// 公钥
  287.         keyMap.put(PRIVATE_KEY, keyPair.getPrivate());// 私钥
  288.         return keyMap;
  289.     }
  290. }

RSA加密解密，String转PublicKey、PrivateKey；附Base64.JAR的更多相关文章

  1. 兼容javascript和C#的RSA加密解密算法，对web提交的数据进行加密传输

    Web应用中往往涉及到敏感的数据,由于HTTP协议以明文的形式与服务器进行交互,因此可以通过截获请求的数据包进行分析来盗取有用的信息.虽然https可以对传输的数据进行加密,但是必须要申请证书(一般都 ...

  2. iOS使用Security.framework进行RSA 加密解密签名和验证签名

    iOS 上 Security.framework为我们提供了安全方面相关的api: Security框架提供的RSA在iOS上使用的一些小结 支持的RSA keySize 大小有:512,768,10 ...

  3. C# 与JAVA 的RSA 加密解密交互，互通，C#使用BouncyCastle来实现私钥加密，公钥解密的方法

    因为C#的RSA加密解密只有公钥加密,私钥解密,没有私钥加密,公钥解密.在网上查了很久也没有很好的实现.BouncyCastle的文档少之又少.很多人可能会说,C#也是可以的,通过Biginteger ...

  4. C# Java间进行RSA加密解密交互

    原文:C# Java间进行RSA加密解密交互 这里,讲一下RSA算法加解密在C#和Java之间交互的问题,这两天纠结了很久,也看了很多其他人写的文章,颇受裨益,但没能解决我的实际问题,终于,还是被我捣 ...

  5. C# Java间进行RSA加密解密交互（二）

    原文:C# Java间进行RSA加密解密交互(二) 接着前面一篇文章C# Java间进行RSA加密解密交互,继续探讨这个问题. 在前面,虽然已经实现了C# Java间进行RSA加密解密交互,但是还是与 ...

  6. C# Java间进行RSA加密解密交互（三）

    原文:C# Java间进行RSA加密解密交互(三) 接着前面一篇C# Java间进行RSA加密解密交互(二)说吧,在上篇中为了实现 /** * RSA加密 * @param text--待加密的明文 ...

  7. C# RSA加密/解密

    RSA公钥加密算法是1977年由Ron Rivest.Adi Shamirh和LenAdleman在(美国麻省理工学院)开发的.RSA取名来自开发他们三者的名字.RSA是目前最有影响力的公钥加密算法, ...

  8. RSA加密解密及数字签名Java实现--转

    RSA公钥加密算法是1977年由罗纳德·李维斯特(Ron Rivest).阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)一起提出的.当时他们三人都在麻省理工学院 ...

  9. RSA加密解密和读取公钥、私钥

    /// <summary>     /// RSA加密解密及RSA签名和验证    /// </summary>     public class RSADE    {    ...

  10. RSA加密解密及RSA加签验签

    RSA安全性应用场景说明 在刚接触RSA的时候,会混淆RSA加密解密和RSA加签验签的概念.简单来说加密解密是公钥加密私钥解密,持有公钥(多人持有)可以对数据加密,但是只有持有私钥(一人持有)才可以解 ...

随机推荐

  1. AIX系统日志

    1.系统错误日志 存放路径:/var/adm/ras/errlog 说明:该日志记录了系统所检测到的软硬件故障和错误,尤其对系统的硬件故障有很大的参考价值,是AIX提供的最有价值的日志之一, errl ...

  2. JMeterPlugins插件监听器学习－监听器

    JMeterPlugins插件监听器学习-监听器 1.jp@gc - Actiive Threads Over Time:不同时间活动用户数量展示(图表)2.jp@gc - AutoStop List ...

  3. JQuery 树状结构 jQuery-treeview.js 插件

    由简入繁实现Jquery树状结构 在项目中,我们经常会需要一些树状结构的样式来显示层级结构等,比如下图的样式,之前在学.net的时候可以直接拖个服务端控件过来直接使用非常方便.但是利用Jquery的一 ...

  4. c# 一些细节

    1.动态对象和匿名对象偶然看到一个语法,觉得特别方便然后频繁使用,但是没有深究,直到今天忽然发现我潜意思中对它的认知居然是错误的. var data=new { State=1,Message=&qu ...

  5. piwik优化之定时任务生成统计数据

    piwik的ui界面,使用起来是无比的慢,让苏南大叔不得不对比wordpress的使用体验.当然了,如果你的服务器足够强大,这些都是小事儿.官方对此给出了一系列的优化建议,大家可以读一下:https: ...

  6. 关于AXI_Quad_SPI的寄存器配置

    关于AXI_Quad_SPI的寄存器配置 1.核初始化配置 首先是: 40:0000_000A 1C:8000_0000 28:0000_0004 2.命令与dummy_data 60:000001E ...

  7. Delphi实现菜单项上出现提示

    type TMenuHintWindow = class(THintWindow) private FTimerShow: TTimer; FTimerHide: TTimer; procedure ...

  8. ubuntu 阿里云 常出问题 运维工作日志

    一.2015-8.26(数据库 error—28) tmp文件临时数据写入不了----解决办法 1.查看临时文件 ls -l 找到了 2.由此可以查看得出来tmp文件有的权限是有的 3.查看tmp 存 ...

  9. ThinkPHP 3.1.2 视图 MVC-V -5

    一.模板的使用        (重点) a.规则 模板文件夹下[TPL]/[分组文件夹/][模板主题文件夹/]和模块名同名的文件夹[Index]/和方法名同名的文件[index].html(.tpl) ...

  10. Java第01次实验提纲(基本概念+编程环境入门+PTA)

    0. 控制台下编译.运行 在Notepad++编写Java程序 学会使用控制台,javac.java 学会使用Notepad++ 参考资料: 控制台-cmd应用基础 扫盲教程 使用命令行编译并运行ja ...