aes加密文件工具类java安卓_android加密工具类1

最新推荐文章于 2022-07-14 09:53:15 发布
最新推荐文章于 2022-07-14 09:53:15 发布
阅读量121 收藏
点赞数
文章标签： aes加密文件工具类java安卓
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35628611/article/details/114807983
版权

1.AES加密

package cn.cw.common.utils;

import java.io.UnsupportedEncodingException;

import java.security.InvalidKeyException;

import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.NoSuchPaddingException;

import javax.crypto.spec.SecretKeySpec;

/**

* ClassName: AESUtils.

* Description: AES加密工具类.

* Date: 2019年04月10日.

*

* @author

* @version 2.0.1

* @since 1.7

*/

public class AESUtils {

/**

* -默认字符集

*/

private static final String CHARSET = "utf-8";

/**

* -加密算法

*/

private static final String KEY_ALGORITHM = "AES";

/**

* -填充方式

*/

private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";

/**

* -AES 加密操作

*

* @param content

* @param password

* @return

* @throws Exception

*/

public static String encrypt(String content, String password) {

Cipher cipher = null;

byte[] result = null;

try {

cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(password));

byte[] byteContent = content.getBytes(CHARSET);

result = new byte[0];

result = cipher.doFinal(byteContent);

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

} catch (NoSuchPaddingException e) {

e.printStackTrace();

} catch (InvalidKeyException e) {

e.printStackTrace();

} catch (UnsupportedEncodingException e) {

e.printStackTrace();

} catch (IllegalBlockSizeException e) {

e.printStackTrace();

} catch (BadPaddingException e) {

e.printStackTrace();

}

return HexUtils.bytesToHex(result);

}

/**

* 加密并base64编码

*

* @param content

* @param password

* @return

* @throws Exception

*/

public static String encryptBase64(String content, String password) throws Exception {

Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(password));

byte[] byteContent = content.getBytes(CHARSET);

byte[] result = cipher.doFinal(byteContent);

return Base64Utils.encode(result);

}

/**

* -AES 解密操作

*

* @param content

* @param password

* @return

* @throws Exception

*/

public static String decrypt(String content, String password) throws Exception {

Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

cipher.init(Cipher.DECRYPT_MODE, getSecretKey(password));

byte[] result = cipher.doFinal(HexUtils.hexStringToByte(content));

return new String(result, CHARSET);

}

/**

* 解密base64字符串

*

* @param content

* @param password

* @return

* @throws Exception

*/

public static String decryptBase64(String content, String password) throws Exception {

Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

cipher.init(Cipher.DECRYPT_MODE, getSecretKey(password));

byte[] result = cipher.doFinal(Base64Utils.decode(content));

return new String(result, CHARSET);

}

/**

* -生成加密秘钥

*

* @return

*/

private static SecretKeySpec getSecretKey(final String password) {

try {

return new SecretKeySpec(password.getBytes(CHARSET), KEY_ALGORITHM);

} catch (Exception e) {

throw new IllegalArgumentException("encode init error");

}

}

}

2.DES加密

package cn.cw.common.utils;

import java.io.IOException;

import java.security.SecureRandom;

import javax.crypto.Cipher;

import javax.crypto.SecretKey;

import javax.crypto.SecretKeyFactory;

import javax.crypto.spec.DESKeySpec;

/**

* ClassName: DESUtils.

* Description: DES加密工具类.

* Date:2019年5月20日.

*

* @author

* @version 1.1.0

* @since 1.7

*/

public class DESUtils {

/**

*-加密算法

*/

private final static String DES = "DES";

/**

*-默认字符集

*/

private final static String CHARSET = "utf-8";

/**

*-根据键值进行加密

* @param data

* @param key 加密键byte数组

* @return

* @throws Exception

*/

public static String encrypt(String data, String key) throws Exception {

return Base64Utils.encode(

encrypt(data.getBytes(CHARSET), key.getBytes(CHARSET)));

}

/**

*-根据键值进行解密

* @param data

* @param key 加密键byte数组

* @return

* @throws IOException

* @throws Exception

*/

public static String decrypt(String data, String key) throws Exception {

return new String(decrypt(Base64Utils.decode(data), key.getBytes(CHARSET)));

}

/**

*-根据键值进行加密

* @param data

* @param key 加密键byte数组

* @return

* @throws Exception

*/

public static byte[] encrypt(byte[] data, byte[] key) throws Exception {

// 生成一个可信任的随机数源

SecureRandom sr = new SecureRandom();

// 从原始密钥数据创建DESKeySpec对象

DESKeySpec dks = new DESKeySpec(key);

// 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象

SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);

SecretKey securekey = keyFactory.generateSecret(dks);

// Cipher对象实际完成加密操作

Cipher cipher = Cipher.getInstance(DES);

// 用密钥初始化Cipher对象

cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);

return cipher.doFinal(data);

}

/**

*-根据键值进行解密

* @param data

* @param key 加密键byte数组

* @return

* @throws Exception

*/

private static byte[] decrypt(byte[] data, byte[] key) throws Exception {

// 生成一个可信任的随机数源

SecureRandom sr = new SecureRandom();

// 从原始密钥数据创建DESKeySpec对象

DESKeySpec dks = new DESKeySpec(key);

// 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象

SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);

SecretKey securekey = keyFactory.generateSecret(dks);

// Cipher对象实际完成解密操作

Cipher cipher = Cipher.getInstance(DES);

// 用密钥初始化Cipher对象

cipher.init(Cipher.DECRYPT_MODE, securekey, sr);

return cipher.doFinal(data);

}

}

3.RSA加密

package cn.cw.common.utils;

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.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;

/**

* ClassName: RSAUtils.

* Description:

非对称加密算法RSA算法组件

*

非对称算法一般是用来传送对称加密算法的密钥来使用的，相对于DH算法，RSA算法只需要一方构造密钥，不需要

*

大费周章的构造各自本地的密钥对了。DH算法只能算法非对称算法的底层实现。而RSA算法算法实现起来较为简单

* Date:2019年6月9日.

*

* @author

* @version 1.1.0

* @since 1.7

*/

public class RSAUtils {

/**

*-定义加密方式

*/

public static final String KEY_RSA = "RSA";

/**

* key的长度

*/

private final static int KEY_SIZE = 1024;

/**

*-定义公钥关键词

*/

public static final String KEY_RSA_PUBLICKEY = "RSAPublicKey";

/**

*-定义私钥关键词

*/

public static final String KEY_RSA_PRIVATEKEY = "RSAPrivateKey";

/**

*-定义签名算法

*/

private final static String KEY_RSA_SIGNATURE = "MD5withRSA";

/**

*-生成公私密钥对

*/

public static Map initKey() throws NoSuchAlgorithmException {

//设置密钥对的bit数，越大越安全，但速度减慢，一般使用512或1024

KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_RSA);

keyPairGenerator.initialize(KEY_SIZE);

KeyPair keyPair = keyPairGenerator.generateKeyPair();

// 获取公钥,私钥

RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

// 将密钥对封装为Map

Map map = new HashMap();

map.put(KEY_RSA_PUBLICKEY, publicKey);

map.put(KEY_RSA_PRIVATEKEY, privateKey);

return map;

}

/**

* -获取Base64编码的公钥字符串

* @param map

* @return

*/

public static byte[] getPublicKey(Map map) {

Key key = (Key) map.get(KEY_RSA_PUBLICKEY);

return key.getEncoded();

}

/**

* -获取Base64编码的私钥字符串

* @param map

* @return

*/

public static byte[] getPrivateKey(Map map) {

Key key = (Key) map.get(KEY_RSA_PRIVATEKEY);

return key.getEncoded();

}

/**

* -公钥加密

* @param data

* @param keyBytes

* @return

* @throws Exception

*/

public static byte[] encryptByPublic(byte[] data, byte[] keyBytes) throws Exception {

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

// 取得待加密数据

KeyFactory factory = KeyFactory.getInstance(KEY_RSA);

PublicKey publicKey = factory.generatePublic(keySpec);

// 对数据加密

Cipher cipher = Cipher.getInstance(factory.getAlgorithm());

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

return cipher.doFinal(data);

}

/**

* -私钥解密

* @param data

* @param keyBytes

* @return

* @throws Exception

*/

public static byte[] decryptByPrivate(byte[] data, byte[] keyBytes) throws Exception {

// 获得待解密数据

PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

KeyFactory factory = KeyFactory.getInstance(KEY_RSA);

PrivateKey privateKey = factory.generatePrivate(keySpec);

// 对数据解密

Cipher cipher = Cipher.getInstance(factory.getAlgorithm());

cipher.init(Cipher.DECRYPT_MODE, privateKey);

return cipher.doFinal(data);

}

/**

* -私钥加密

* @param data

* @param keyBytes

* @return

* @throws Exception

*/

public static byte[] encryptByPrivate(byte[] data, byte[] keyBytes) throws Exception {

PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

KeyFactory factory = KeyFactory.getInstance(KEY_RSA);

PrivateKey privateKey = factory.generatePrivate(keySpec);

// 对数据加密

Cipher cipher = Cipher.getInstance(factory.getAlgorithm());

cipher.init(Cipher.ENCRYPT_MODE, privateKey);

return cipher.doFinal(data);

}

/**

* -公钥解密

* @param data

* @param keyBytes

* @return

* @throws Exception

*/

public static byte[] decryptByPublic(byte[] data, byte[] keyBytes) throws Exception {

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

// 取得待加密数据

KeyFactory factory = KeyFactory.getInstance(KEY_RSA);

PublicKey publicKey = factory.generatePublic(keySpec);

// 对数据解密

Cipher cipher = Cipher.getInstance(factory.getAlgorithm());

cipher.init(Cipher.DECRYPT_MODE, publicKey);

return cipher.doFinal(data);

}

/**

* -用私钥对加密数据进行签名

* @param data

* @param privateKey

* @return

* @throws Exception

*/

public static String sign(byte[] data, byte[] privateKey) throws Exception {

PKCS8EncodedKeySpec pkcs = new PKCS8EncodedKeySpec(privateKey);

// 指定的加密算法

KeyFactory factory = KeyFactory.getInstance(KEY_RSA);

PrivateKey key = factory.generatePrivate(pkcs);

// 用私钥对信息生成数字签名

Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);

signature.initSign(key);

signature.update(data);

return Base64Utils.encode(signature.sign());

}

/**

* -校验数字签名

* @param data

* @param publicKey

* @param sign

* @return

* @throws Exception

*/

public static boolean verify(byte[] data, byte[] publicKey, String sign) throws Exception {

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);

// 指定的加密算法

KeyFactory factory = KeyFactory.getInstance(KEY_RSA);

PublicKey key = factory.generatePublic(keySpec);

// 用公钥验证数字签名

Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);

signature.initVerify(key);

signature.update(data);

return signature.verify(Base64Utils.decode(sign));

}

public static void main(String[] args) throws Exception {

Map map = RSAUtils.initKey();

System.out.println(Base64Utils.encode(RSAUtils.getPrivateKey(map)));

System.out.println(Base64Utils.encode(RSAUtils.getPublicKey(map)));

}

}

4.SHA256加密

package cn.cw.common.utils;

import java.io.UnsupportedEncodingException;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

/**

* @ProjectName:

* @Package:

* @ClassName: SHA256Util

* @Description: SHA256Util加密工具类

* @Author:

* @CreateDate: 2019/3/22 16:28

*/

public class SHA256Util {

/**

* @date: 2019/3/22 16:30

* @author:

* @description SHA256加密

*/

public static String getSHA256StrJava(String str) {

MessageDigest messageDigest;

String encodeStr = "";

try {

messageDigest = MessageDigest.getInstance("SHA-256");

messageDigest.update(str.getBytes("UTF-8"));

encodeStr = byte2Hex(messageDigest.digest());

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

} catch (UnsupportedEncodingException e) {

e.printStackTrace();

}

return encodeStr;

}

private static String byte2Hex(byte[] bytes) {

StringBuffer stringBuffer = new StringBuffer();

String temp = null;

for (int i = 0; i < bytes.length; i++) {

temp = Integer.toHexString(bytes[i] & 0xFF);

if (temp.length() == 1) {

//1得到一位的进行补0操作

stringBuffer.append("0");

}

stringBuffer.append(temp);

}

return stringBuffer.toString();

}

}

QHJJ
关注
Android AES加密解密工具类
川峰的博客
03-11 1476
一个Android AES加密解密工具类 一个Android AES加密解密工具类 一个Android AES加密解密工具类 一个Android AES加密解密工具类 一个Android AES加密解密工具类 一个Android AES加密解密工具类 一个Android AES加密解密工具类 一个Android AES加密解密工具类 一个Android AES加密解密工具类 一个Android AES加密解密工具类 一个Android AES加密解密工具类 一个Android AES加密解密工具类 一个An
工具类JAVA （Android Studio ）+ JS 加密解密 AES + Base 64
最新发布
08-08
工具类JAVA （Android Studio ）+ JS 加密解密 AES + Base 64
Android-EncryptionUtils加密工具类
08-13
加密工具类，这里收集了一些常用的加密方法，包括AES，DES，3DES，MD5，RSA，SHA1，SHA256，SHA384，SHA512。
Android AES加密工具类
Jack_King007的专栏
11-24 6393
1、AES加密工具类 java不支持PKCS7Padding，只支持PKCS5Padding。我们知道加密算法由算法+模式+填充组成，，本篇文章使用PKCS5Padding加密方式。 ''
android加密工具类
weixin_30388677的博客
10-21 74
import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; /** * 加密工具类 * Created by Administrator on 2015/10/21 0021. */ public class EncryptUtils { /** ...
Android加密工具类,Android AES加密工具类分享
weixin_34042899的博客
05-25 426
1、AES加密工具类java不支持PKCS7Padding，只支持PKCS5Padding。我们知道加密算法由算法+模式+填充组成，下一篇介绍iOS和Android通用的AES加密，本篇文章使用PKCS5Padding加密方式。package com.example.aesdemo;import java.io.UnsupportedEncodingException;import javax.c...
AES 加密工具类
weixin_30673715的博客
03-29 226
/** * AES 是一种可逆加密算法，对用户的敏感信息加密处理 对原始数据进行AES加密后，在进行Base64编码转化； */public class AESOperator { /* * 加密用的Key 可以用26个字母和数字组成 此处使用AES-128-CBC加密模式，key需要为16位。0021XdSh0021XdSh */ private String sKe...
Android AES加密工具类分享
09-04
【Android AES加密工具类分享】 在Android开发中，安全传输和存储数据是至关重要的，为此，开发者常常采用加密技术来保护敏感信息。本文将详细介绍一个基于AES（Advanced Encryption Standard）加密的Android工具类...
RSA+AES 加密工具类 Java
03-13
在这个“RSA+AES加密工具类 Java”中，我们将深入探讨这两种加密技术以及如何在Java环境中，包括Android和Web应用，实现它们。 首先，RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，基于大整数因子分解的困难...
AES加密工具类
qq_44985319的博客
07-14 496
AES加密
安卓RSA+AES加密算法实现工具类
11-14
RSA加密算法
AES加解密文件工具类（java）
07-18
文件加解密工具类，使用java，通过AES完成文件的加解密。
java使用AES加密/解密文件
10-28
包含生成密匙,加密文件,用密钥k解密文件
AES加密算法（java）实现
01-15
AES高级加密标准，在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。本软件是用java语言开发，实现了AES算法对文件的加密和解密，并在界面上加了进度条，来提示用户加密解密的进度。如果不足之处，欢迎留言。
Des3Utils.java
07-21
利用Java进行3DES的加密算法，包含字符串密钥，偏移量加密字符串，数组密钥，偏移量加密数组，数组密钥加密数组，字符串密钥加密字符串。如果对你有帮助，麻烦给个好评吧！
送你一个 Android MD5 加密工具类（附代码）
「程序员飞飞」的博客
04-09 2638
Android MD5加密工具类public class MD5Utils { public static String MD5(String sourceStr) { String result = ""; try { MessageDigest md = MessageDigest.getInstance("MD5");
android aes工具类,AES工具类
weixin_29467373的博客
05-26 117
package com.csh.encryptdemo.encryptutils;import java.security.InvalidKeyException;import java.security.NoSuchAlgorithmException;import java.security.NoSuchProviderException;import java.security.Secure...
Java AES加密解密实用工具实例
本文档提供了一个名为`CryptUtil`的简单Java加密解密类，用于实现AES（Advanced Encryption Standard）算法的基础操作。AES是一种对称加密算法，广泛应用于各种信息安全场景中，如数据传输、存储等。 首先，我们来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值