android rsa文件加密,Android RSA加密

最新推荐文章于 2024-07-21 11:25:24 发布
最新推荐文章于 2024-07-21 11:25:24 发布
阅读量334 收藏
点赞数
文章标签： android rsa文件加密
本文档提供了一个Base64工具类和RSA加密工具类的详细实现，包括Base64编码和解码以及RSA加密和解密的方法。Base64工具类实现了将字节数据转换为Base64字符串和反之的过程，而RSA加密工具类则提供了使用私钥解密和公钥加密的功能，结合了Base64编码以确保数据的安全传输。
摘要由CSDN通过智能技术生成

Base64工具类

public class Base64Util {

static private final int BASELENGTH = 128;

static private final int LOOKUPLENGTH = 64;

static private final int TWENTYFOURBITGROUP = 24;

static private final int EIGHTBIT = 8;

static private final int SIXTEENBIT = 16;

static private final int FOURBYTE = 4;

static private final int SIGN = -128;

static private final char PAD = '=';

static private final boolean fDebug = false;

static final private byte[] base64Alphabet = new byte[BASELENGTH];

static final private char[] lookUpBase64Alphabet = new char[LOOKUPLENGTH];

static {

for (int i = 0; i < BASELENGTH; ++i) {

base64Alphabet[i] = -1;

}

for (int i = 'Z'; i >= 'A'; i--) {

base64Alphabet[i] = (byte) (i - 'A');

}

for (int i = 'z'; i >= 'a'; i--) {

base64Alphabet[i] = (byte) (i - 'a' + 26);

}

for (int i = '9'; i >= '0'; i--) {

base64Alphabet[i] = (byte) (i - '0' + 52);

}

base64Alphabet['+'] = 62;

base64Alphabet['/'] = 63;

for (int i = 0; i <= 25; i++) {

lookUpBase64Alphabet[i] = (char) ('A' + i);

}

for (int i = 26, j = 0; i <= 51; i++, j++) {

lookUpBase64Alphabet[i] = (char) ('a' + j);

}

for (int i = 52, j = 0; i <= 61; i++, j++) {

lookUpBase64Alphabet[i] = (char) ('0' + j);

}

lookUpBase64Alphabet[62] = (char) '+';

lookUpBase64Alphabet[63] = (char) '/';

}

private static boolean isWhiteSpace(char octect) {

return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);

}

private static boolean isPad(char octect) {

return (octect == PAD);

}

private static boolean isData(char octect) {

return (octect < BASELENGTH && base64Alphabet[octect] != -1);

}

/**

* Encodes hex octects into Base64

*

* @param binaryData Array containing binaryData

* @return Encoded Base64 array

*/

public static String encode(byte[] binaryData) {

if (binaryData == null) {

return null;

}

int lengthDataBits = binaryData.length * EIGHTBIT;

if (lengthDataBits == 0) {

return "";

}

int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;

int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;

int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;

char encodedData[] = null;

encodedData = new char[numberQuartet * 4];

byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;

int encodedIndex = 0;

int dataIndex = 0;

if (fDebug) {

System.out.println("number of triplets = " + numberTriplets);

}

for (int i = 0; i < numberTriplets; i++) {

b1 = binaryData[dataIndex++];

b2 = binaryData[dataIndex++];

b3 = binaryData[dataIndex++];

if (fDebug) {

System.out.println("b1= " + b1 + ", b2= " + b2 + ", b3= " + b3);

}

l = (byte) (b2 & 0x0f);

k = (byte) (b1 & 0x03);

byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);

byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);

byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);

if (fDebug) {

System.out.println("val2 = " + val2);

System.out.println("k4 = " + (k << 4));

System.out.println("vak = " + (val2 | (k << 4)));

}

encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];

encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];

encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];

encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];

}

// form integral number of 6-bit groups

if (fewerThan24bits == EIGHTBIT) {

b1 = binaryData[dataIndex];

k = (byte) (b1 & 0x03);

if (fDebug) {

System.out.println("b1=" + b1);

System.out.println("b1<<2 = " + (b1 >> 2));

}

byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);

encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];

encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];

encodedData[encodedIndex++] = PAD;

encodedData[encodedIndex++] = PAD;

} else if (fewerThan24bits == SIXTEENBIT) {

b1 = binaryData[dataIndex];

b2 = binaryData[dataIndex + 1];

l = (byte) (b2 & 0x0f);

k = (byte) (b1 & 0x03);

byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);

byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);

encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];

encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];

encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];

encodedData[encodedIndex++] = PAD;

}

return new String(encodedData);

}

/**

* Decodes Base64 data into octects

*

* @param encoded string containing Base64 data

* @return Array containind decoded data.

*/

public static byte[] decode(String encoded) {

if (encoded == null) {

return null;

}

char[] base64Data = encoded.toCharArray();

// remove white spaces

int len = removeWhiteSpace(base64Data);

if (len % FOURBYTE != 0) {

return null;//should be divisible by four

}

int numberQuadruple = (len / FOURBYTE);

if (numberQuadruple == 0) {

return new byte[0];

}

byte decodedData[] = null;

byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;

char d1 = 0, d2 = 0, d3 = 0, d4 = 0;

int i = 0;

int encodedIndex = 0;

int dataIndex = 0;

decodedData = new byte[(numberQuadruple) * 3];

for (; i < numberQuadruple - 1; i++) {

if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))

|| !isData((d3 = base64Data[dataIndex++]))

|| !isData((d4 = base64Data[dataIndex++]))) {

return null;

}//if found "no data" just return null

b1 = base64Alphabet[d1];

b2 = base64Alphabet[d2];

b3 = base64Alphabet[d3];

b4 = base64Alphabet[d4];

decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);

decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));

decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);

}

if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {

return null;//if found "no data" just return null

}

b1 = base64Alphabet[d1];

b2 = base64Alphabet[d2];

d3 = base64Data[dataIndex++];

d4 = base64Data[dataIndex++];

if (!isData((d3)) || !isData((d4))) {//Check if they are PAD characters

if (isPad(d3) && isPad(d4)) {

if ((b2 & 0xf) != 0)//last 4 bits should be zero

{

return null;

}

byte[] tmp = new byte[i * 3 + 1];

System.arraycopy(decodedData, 0, tmp, 0, i * 3);

tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);

return tmp;

} else if (!isPad(d3) && isPad(d4)) {

b3 = base64Alphabet[d3];

if ((b3 & 0x3) != 0)//last 2 bits should be zero

{

return null;

}

byte[] tmp = new byte[i * 3 + 2];

System.arraycopy(decodedData, 0, tmp, 0, i * 3);

tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);

tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));

return tmp;

} else {

return null;

}

} else { //No PAD e.g 3cQl

b3 = base64Alphabet[d3];

b4 = base64Alphabet[d4];

decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);

decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));

decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);

}

return decodedData;

}

/**

* remove WhiteSpace from MIME containing encoded Base64 data.

*

* @param data the byte array of base64 data (with WS)

* @return the new length

*/

private static int removeWhiteSpace(char[] data) {

if (data == null) {

return 0;

}

// count characters that's not whitespace

int newSize = 0;

int len = data.length;

for (int i = 0; i < len; i++) {

if (!isWhiteSpace(data[i])) {

data[newSize++] = data[i];

}

}

return newSize;

}

}

RSA 加密工具类

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.InputStream;

import java.security.KeyFactory;

import java.security.NoSuchAlgorithmException;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

/**

* RSA加密类

*/

public class RSAencrypt {

/**

* 使用私钥解密

*

* @param content

* @param private_key

* @param input_charset

* @return

* @throws Exception

*/

public static String decrypt(String content, String private_key, String input_charset) throws Exception {

PrivateKey prikey = getPrivateKey(private_key);

Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

cipher.init(Cipher.DECRYPT_MODE, prikey);

InputStream ins = new ByteArrayInputStream(Base64Util.decode(content));

ByteArrayOutputStream writer = new ByteArrayOutputStream();

byte[] buf = new byte[128];

int bufl;

while ((bufl = ins.read(buf)) != -1) {

byte[] block = null;

if (buf.length == bufl) {

block = buf;

} else {

block = new byte[bufl];

for (int i = 0; i < bufl; i++) {

block[i] = buf[i];

}

}

writer.write(cipher.doFinal(block));

}

return new String(writer.toByteArray(), input_charset);

}

/**

* 获得私钥

*

* @param key 私钥

* @throws Exception

*/

public static PrivateKey getPrivateKey(String key) throws Exception {

byte[] keyBytes;

keyBytes = Base64Util.decode(key);

PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

return privateKey;

}

/**

* 得到公钥

*

* @param bysKey

* @return

*/

private static PublicKey getPublicKeyFromX509(String bysKey) throws NoSuchAlgorithmException, Exception {

byte[] decodedKey = Base64Util.decode(bysKey);

X509EncodedKeySpec x509 = new X509EncodedKeySpec(decodedKey);

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

return keyFactory.generatePublic(x509);

}

/**

* 使用公钥加密

*

* @param content 密文

* @return

*/

public static String encryptByPublic(String content,String pulickey) {

try {

PublicKey pubkey = getPublicKeyFromX509(pulickey);

Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

cipher.init(Cipher.ENCRYPT_MODE, pubkey);

byte plaintext[] = content.getBytes("UTF-8");

byte[] output = cipher.doFinal(plaintext);

String s = new String(Base64Util.encode(output));

return s;

} catch (Exception e) {

return null;

}

}

}

HackerHermit
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android RSA加密解密文件
09-17
Android RSA加密解密文件
Android数据加密之Rsa加密
05-08 226
前言： 最近无意中和同事交流数据安全传输的问题，想起自己曾经使用过的Rsa非对称加密算法，闲下来总结一下。 其他几种加密方式： Android数据加密之Rsa加密 Android数据加密之Aes加密 Android数据加密之Des加密 Android数据加密之MD5加密 Android数据加密之Base64编码算法...
Android RSA 加解密
最新发布
xingfuyisheng的专栏
07-21 907
RSA是一种常用的非对称加密算法，所谓非对称加密是指使用一对密钥（公钥和私钥）进行加密和解密，公钥人人都可以获得，用于加密数据，私钥保存在服务器中，用于解密数据。加密解密过程如下：使用RSA进行加密解密，其优点是非常不容易破解，缺点是和对称加密（如AES）相比，加密速度较慢。因此，实际使用中，常常将对称加密和非对称加密结合使用，即使用非对称加密协商对称加密的密钥，使用对称加密密钥加密传输内容。
androidRSA加密
10-30
RSA封装类 ，完整的RSA加密和解密 public class RSAUtilEncrypt { public static final String KEY_ALGORTHM = "RSA";// public static final String KEY_ALGORTHM_RSA_ECB_PKCS1PADDING = "RSA/ECB/PKCS1Padding"; public static String RSA_PUBLIC_KEY = "rsa_public_key"; public static String RSA_PRIVATE_KEY = "rsa_private_key"; private int KeySize = 1024; private Map keyMap; private static String RSA = "RSA"; private static PublicKey publickey; public RSAUtilEncrypt(int KeySize,String publickey) { this.KeySize = KeySize; try { this.publickey=generatePublicKeyByString(publickey); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } private RSAPublicKey generatePublicKeyByString(String publicKeyStr) throws Exception { try { BASE64Decoder base64Decoder = new BASE64Decoder(); byte[] buffer = base64Decoder.decodeBuffer(publicKeyStr); X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); return (RSAPublicKey) keyFactory.generatePublic(keySpec); } catch (NoSuchAlgorithmException e) { throw new Exception("No Algorthm,Checked by cemung!"); } catch (InvalidKeySpecException e) { throw new Exception("InvalidKeySpec!"); } catch (IOException e) { throw new Exception("Io exception!"); } catch (NullPointerException e) { throw new Exception("Illegle pointer reference!"); } } // Encypt public byte[] RSAEncrypt(byte[] data, RSAPublicKey publickey) throws Exception { Cipher cipher = Cipher.getInstance(KEY_ALGORTHM_RSA_ECB_PKCS1PADDING); cipher.init(Cipher.ENCRYPT_MODE, this.publickey); byte[] cipherbytes = cipher.doFinal(data); return cipherbytes; } // Encypt public byte[] RSAEncrypt(byte[] data) throws Exception { Cipher cipher = Cipher.getInstance(KEY_ALGORTHM_RSA_ECB_PKCS1PADDING); cipher.init(Cipher.ENCRYPT_MODE, this.publickey); byte[] cipherbytes = cipher.doFinal(data); return cipherbytes; } // Get Public key with format byte[] public byte[] getPublicKeyByte() { RSAPublicKey pubkey = (RSAPublicKey) keyMap.get(RSA_PUBLIC_KEY); return pubkey.getEncoded(); } public static byte[] decryptBASE64(String key) throws Exception { return (new BASE64Decoder()).decodeBuffer(key); } public static String encryptBASE64(byte[] key) throws Exception { return (new BASE64Encoder()).encodeBuffer(key); } public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception { byte[] keyBytes = decryptBASE64(key); PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec( keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM); Key privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec); Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); cipher.init(Cipher.DECRYPT_MODE, privateKey); return cipher.doFinal(data); } public static byte[] encryptByPublicKey(byte[] data, String key) throws Exception { byte[] keyBytes = decryptBASE64(key); X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM); Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec); Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); cipher.init(Cipher.ENCRYPT_MODE, publicKey); return cipher.doFinal(data); } public static byte[] decryptByPublicKey(byte[] data, String key) throws Exception { byte[] keyBytes = decryptBASE64(key); X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM); Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec); Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); cipher.init(Cipher.DECRYPT_MODE, publicKey); return cipher.doFinal(data); } 使用方法 private RSAUtilEncrypt rsa = new RSAUtilEncrypt(1024, publikey); /* * 给信息加密,获取密文 */ public String getCiphertext(String str_encrode) { try { byte[] estr = rsa.RSAEncrypt(str_encrode.getBytes()); // 密文 String ciphertext = Base64.encodeToString(estr, Base64.DEFAULT); return ciphertext; } catch (Exception e) { e.printStackTrace(); } return null; } 有疑问的留言
Android RSA 加密
yanftch的博客
06-23 630
Android RSA 加密 项目中遇到需要向后台传递的密码(纯数字)进行RSA加密，在踩了无数坑之后，终于实现了~~~~~~~~~相信来看本文的同学，都是在项目中遇到了此需求，那么我就将我整理的跟大家分享一下。首先，什么事RSA？这个的解释我就不说了，随便百度一下，N多解释内容，其次，RSA的公钥和私钥，网上有很多生成方式(仅限于自己玩哈，真正上生产了可不能泄露了私钥~)，在这我也不说了，我们项
android RSA2加密解密
09-24
android RSA2加密解密，里边提供两个方法，一个是生成公有私有秘钥加密解密，另一个是加密解密
C#Android互通RSA加密解密
06-13
"C# Android互通RSA加密解密"这一主题就聚焦于如何在C#和Android之间安全地进行数据传输，通过RSA加密算法确保数据的安全性。 RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，它基于大数因子分解的困难性，为...
Android RSA加密jar包
11-01
这个“Android RSA加密jar包”就是专为Android平台设计的，用于实现RSA加密和解密功能的Java库。 RSA加密的基本原理是基于两个大素数的乘积，这两个大素数只有乘积关系，很难从结果反推出原始素数。加密过程使用...
Android数据加密之Rsa加密的简单实现
09-01
Rsa加密是一种广泛使用的非对称加密算法，适合在Android平台上实现数据的安全传输和存储。本文将详细介绍Rsa加密的基本概念、工作原理以及如何在Android中进行简单的实现。 Rsa加密，全称为Rivest-Shamir-Adleman...
Android RSA加密解密demo
08-23
Android RSA加密解密demo，详情请参看博客：http://blog.csdn.net/bbld_/article/details/38777491
Android 客户端RSA加密的实现方法
08-29
主要介绍了Android 客户端RSA加密的实现方法的相关资料,希望通过本文能掌握RSA 的使用，需要的朋友可以参考下
安卓RSA加密和解密，和后台能够进行数据互通的算法
11-17
android平台的RSA加密和解密算法，和后台JAVA加密和解密算法有所不同，能够和后台进行数据互通。完美解决后台的加密数据，android平台解密后乱码问题，也不会出现android平台加密密文，后台解析出现乱码问题
Android RSA加密
邵旺运的博客
04-05 313
Android RSA加密
android rsa数据加密,Android中的RSA加密
weixin_39716703的博客
05-31 244
Frank..5这里有一个如何做到的例子,但在实践中,您不能仅使用RSA加密和解密整个文件.RSA算法只能加密单个块,并且执行整个文件的速度相当慢.您可以使用3DES或AES加密文件,然后使用预期收件人的RSA公钥加密AES密钥.一些代码:public static void main(String[] args) throws Exception {KeyPairGenerator kpg = ...
Android加密篇 RSA
圈池
02-12 4129
使用场景 文件或数据在本地使用公钥或私钥加密，加密后的数据传送到服务器，服务器使用同一套密钥中的私钥或者公钥进行解密。 import android.util.Base64; import java.security.InvalidKeyException; import java.security.Key; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchAlg
Android RSA加密，解密
xiyangyang8110的博客
10-10 657
在前后端数据传输的过程中，数据被网截工具拦截容易泄露，此时我们可以把数据用RSA进行加密，使得数据安全。RSA非对称加密，加密解密规则不一样，数据更安全！ 使用公钥进行加密：cipher.init(Cipher.ENCRYPT_MODE, publicKey);// 1024 KeyPairGenerator kg=KeyPairGenerator.getInstance("RSA
Android 数据加密之Rsa加密
Android SVG之pathData
08-17 591
什么是Rsa加密 RSA算法是最流行的公钥密码算法，使用长度可以变化的密钥。RSA是第一个既能用于数据加密也能用于数字签名的算法。 RSA算法原理如下： 1.随机选择两个大质数p和q，p不等于q，计算N=pq； 2.选择一个大于1小于N的自然数e，e必须与(p-1)(q-1)互素。 3.用公式计算出d：d×e = 1 (mod (p-1)(q-1)) 。 4.销毁p和q。 RSA...
Android RSA加密解密实战教程
以上就是Android平台使用RSA加密和解密的基本原理及示例代码解析，开发者可以根据这些信息在自己的项目中实现安全的数据加密与解密。在设计系统安全时，还需要考虑其他因素，如密钥的生命周期管理、安全传输协议等，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值