登录
当前位置： 首页 > 编程笔记 >

Android 获取签名公钥和公钥私钥加解密的方法(推荐)

龙兴学
2023-03-14
本文向大家介绍Android 获取签名公钥和公钥私钥加解密的方法(推荐)，包括了Android 获取签名公钥和公钥私钥加解密的方法(推荐)的使用技巧和注意事项，需要的朋友参考一下

如下所示：

public class GetPublicKey {
   
  /**
   * 获取签名公钥
   * @param mContext
   * @return
   */
  protected static String getSignInfo(Context mContext) {
    String signcode = "";
    try {
      PackageInfo packageInfo = mContext.getPackageManager().getPackageInfo(
          GetAppInfo.getPackageName(mContext), PackageManager.GET_SIGNATURES);
      Signature[] signs = packageInfo.signatures;
      Signature sign = signs[0];
 
      signcode = parseSignature(sign.toByteArray());
      signcode = signcode.toLowerCase();
    } catch (Exception e) {
      Log.e(Constants.TAG, e.getMessage(), e);
    }
    return signcode;
  }
 
  protected static String parseSignature(byte[] signature) {
    String sign = "";
    try {
      CertificateFactory certFactory = CertificateFactory
          .getInstance("X.509");
      X509Certificate cert = (X509Certificate) certFactory
          .generateCertificate(new ByteArrayInputStream(signature));
      String pubKey = cert.getPublicKey().toString();
      String ss = subString(pubKey);
      ss = ss.replace(",", "");
      ss = ss.toLowerCase();
      int aa = ss.indexOf("modulus");
      int bb = ss.indexOf("publicexponent");
      sign = ss.substring(aa + 8, bb);
    } catch (CertificateException e) {
      Log.e(Constants.TAG, e.getMessage(), e);
    }
    return sign;
  }
 
  public static String subString(String sub) {
    Pattern pp = Pattern.compile("\\s*|\t|\r|\n");
    Matcher mm = pp.matcher(sub);
    return mm.replaceAll("");
  }
}



package com.example.xscamera;
 
import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
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.Cipher;
 
/**
 * <p>
 * RSA公钥/私钥/签名工具包
 * <p>
 * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
 * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>
 * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全
 * </p>
 * 
 */
public class RSAUtils{
 
  /**
   * 加密算法RSA
   */
  public static final String KEY_ALGORITHM = "RSA";
   
  /**
   * 签名算法
   */
  public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
 
  /**
   * 获取公钥的key
   */
  private static final String PUBLIC_KEY = "LocatorPublicKey";
   
  /**
   * 获取私钥的key
   */
  private static final String PRIVATE_KEY = "LocatorPrivateKey";
   
  /**
   * RSA最大加密明文大小
   */
  private static final int MAX_ENCRYPT_BLOCK = 117;
   
  /**
   * RSA最大解密密文大小
   */
  private static final int MAX_DECRYPT_BLOCK = 128;
 
  /**
   * <p>
   * 生成密钥对(公钥和私钥)
   * </p>
   * 
   * @return
   * @throws Exception
   */
  public static Map<String, Object> genKeyPair() throws Exception {
    KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    keyPairGen.initialize(1024);
    KeyPair keyPair = keyPairGen.generateKeyPair();
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    Map<String, Object> keyMap = new HashMap<String, Object>(2);
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);
    return keyMap;
  }
   
  /**
   * <p>
   * 用私钥对信息生成数字签名
   * </p>
   * 
   * @param data 已加密数据
   * @param privateKey 私钥(BASE64编码)
   * 
   * @return
   * @throws Exception
   */
  public static String sign(byte[] data, String privateKey) throws Exception {
    byte[] keyBytes = Base64Utils.decode(privateKey);
    PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
    Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
    signature.initSign(privateK);
    signature.update(data);
    return Base64Utils.encode(signature.sign());
  }
 
  /**
   * <p>
   * 校验数字签名
   * </p>
   * 
   * @param data 已加密数据
   * @param publicKey 公钥(BASE64编码)
   * @param sign 数字签名
   * 
   * @return
   * @throws Exception
   * 
   */
  public static boolean verify(byte[] data, String publicKey, String sign)
      throws Exception {
    byte[] keyBytes = Base64Utils.decode(publicKey);
    X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    PublicKey publicK = keyFactory.generatePublic(keySpec);
    Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
    signature.initVerify(publicK);
    signature.update(data);
    return signature.verify(Base64Utils.decode(sign));
  }
 
  /**
   * <P>
   * 私钥解密
   * </p>
   * 
   * @param encryptedData 已加密数据
   * @param privateKey 私钥(BASE64编码)
   * @return
   * @throws Exception
   */
  public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
      throws Exception {
    byte[] keyBytes = Base64Utils.decode(privateKey);
    PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, privateK);
    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();
    return decryptedData;
  }
 
  /**
   * <p>
   * 公钥解密
   * </p>
   * 
   * @param encryptedData 已加密数据
   * @param publicKey 公钥(BASE64编码)
   * @return
   * @throws Exception
   */
  public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
      throws Exception {
    byte[] keyBytes = Base64Utils.decode(publicKey);
    X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    Key publicK = keyFactory.generatePublic(x509KeySpec);
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, publicK);
    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();
    return decryptedData;
  }
 
  /**
   * <p>
   * 公钥加密
   * </p>
   * 
   * @param data 源数据
   * @param publicKey 公钥(BASE64编码)
   * @return
   * @throws Exception
   */
  public static byte[] encryptByPublicKey(byte[] data, String publicKey)
      throws Exception {
    byte[] keyBytes = Base64Utils.decode(publicKey);
    X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    Key publicK = keyFactory.generatePublic(x509KeySpec);
    // 对数据加密
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, publicK);
    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();
    return encryptedData;
  }
 
  /**
   * <p>
   * 私钥加密
   * </p>
   * 
   * @param data 源数据
   * @param privateKey 私钥(BASE64编码)
   * @return
   * @throws Exception
   */
  public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
      throws Exception {
    byte[] keyBytes = Base64Utils.decode(privateKey);
    PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, privateK);
    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();
    return encryptedData;
  }
 
  /**
   * <p>
   * 获取私钥
   * </p>
   * 
   * @param keyMap 密钥对
   * @return
   * @throws Exception
   */
  public static String getPrivateKey(Map<String, Object> keyMap)
      throws Exception {
    Key key = (Key) keyMap.get(PRIVATE_KEY);
    return Base64Utils.encode(key.getEncoded());
  }
 
  /**
   * <p>
   * 获取公钥
   * </p>
   * 
   * @param keyMap 密钥对
   * @return
   * @throws Exception
   */
  public static String getPublicKey(Map<String, Object> keyMap)
      throws Exception {
    Key key = (Key) keyMap.get(PUBLIC_KEY);
    return Base64Utils.encode(key.getEncoded());
  }
 
}

以上这篇Android 获取签名公钥和公钥私钥加解密的方法(推荐)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持小牛知识库。

 类似资料：
  • 用RSA公钥加密DSA私钥

    并且我将这个函数称为用RSA公钥加密DSA密钥的函数：

  • 获取Android签名证书的公钥和私钥的简单实例

    本文向大家介绍获取Android签名证书的公钥和私钥的简单实例，包括了获取Android签名证书的公钥和私钥的简单实例的使用技巧和注意事项，需要的朋友参考一下 本文以Android签名JKS格式的证书为例： 以上这篇获取Android签名证书的公钥和私钥的简单实例就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持呐喊教程。

  • Android公钥加密

    我的Android应用程序实现了RSA加密，但后端无法解密应用程序生成的令牌。这是代码，公钥的开始行和结束行在调用之前都被删除了，会有什么问题吗？ 后端团队提供了以下可以工作的示例代码，但它是针对桌面Java的。Android库没有base64.getEncoder方法。这和我写的非常相似，但我的就是不起作用。 我比较了每一步的字节数组值。桌面密码和android密码得到的输入完全相同。然而，来自

  • RSACryptoServiceProvider使用自己的公钥和私钥加密和解密

    我被告知，对于非对称密码学，您使用公钥加密明文，并使用私钥解密明文。所以我尝试了以下方法： 以及加密和解密函数 我希望控制台显示，但它显示的是这个。我是否错误地使用了RSACryptoServiceProvider？

  • 获取RSA加密公钥

    说明 微信支付-获取RSA加密公钥SDK，企业付款到银行卡接口需要。 你还需要执行openssl rsa -RSAPublicKey_in -in weixin-rsa-public.pem -pubout 将命令行输出的证书内容覆盖到weixin-rsa-public.pem文件中才可使用 官方文档：https://pay.weixin.qq.com/wiki/doc/api/tools/mch

  • 私钥和公钥分开

    我想在Java中通过SSL/TLS建立一个客户机服务器通信。服务器是多线程的。使用openssl，我充当自己的CA（为权威创建私钥和自签名证书）。现在我要为我的服务器和客户端创建密钥和证书，这些密钥和证书是从我创建的CA签名的。 1）我必须根据提示为每个客户创建证书和密钥吗？还是另一种“自动”方式，例如使用脚本？ 2）我已经看到用于设置密钥库的代码 问题是我如何单独创建这些jks文件？public

相关阅读

Java非对称加密：存储公钥/私钥的首选方法从Java私有获取公钥私钥和公钥之间的区别使用RSA公钥加密AES密钥从私钥派生ECDSA公钥

相关文章

金山办公金山办公JavaScript算法-最长公共前缀小公司面试金山办公 10.10

相关问答

Java库或公钥/私钥消息加密C#BouncyCastle-使用公钥/私钥的RSA加密公钥能否用于解密（验证）使用私钥加密（签名）的文档使用RSA、私钥和公钥的Nimbus JOSE JWT加密在PKCS#1 OAEP加密/解密中交换公钥/私钥

相关工具

HDCP加密/解密算法鸡蛋公司黑客公司太空公司城市公司

相关文档

fbreader 和 移动 DM 和 加解密魔方加密帮助手册文档深入理解 Android基于深度学习的推荐系统：综述和新视角Android Animation 动画详解
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.