⑴ android，java 通用的加密解密方式有几种
移动端越来越火了，我们在开发过程中，总会碰到要和移动端打交道的场景，比如.NET和android或者iOS的打交道。为了让数据交互更安全，我们需要对数据进行加密传输。今天研究了一下，把几种语言的加密都实践了一遍，实现了.NET，java(android)，iOS都同一套的加密算法，下面就分享给大家。
AES加密有多种算法模式，下面提供两套模式的可用源码。
加密方式：
先将文本AES加密
返回Base64转码
解密方式：
将数据进行Base64解码
进行AES解密
一、CBC（Cipher Block Chaining，加密块链）模式
是一种循环模式，前一个分组的密文和当前分组的明文异或操作后再加密，这样做的目的是增强破解难度.
密钥
密钥偏移量
java/adroid加密AESOperator类：
package com.bci.wx.base.util;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
/**
* AES 是一种可逆加密算法，对用户的敏感信息加密处理 对原始数据进行AES加密后，在进行Base64编码转化；
*/
public class AESOperator {
/*
* 加密用的Key 可以用26个字母和数字组成 此处使用AES-128-CBC加密模式，key需要为16位。
*/
private String sKey = "smkldospdosldaaa";//key，可自行修改
private String ivParameter = "0392039203920300";//偏移量,可自行修改
private static AESOperator instance = null;
private AESOperator() {
}
public static AESOperator getInstance() {
if (instance == null)
instance = new AESOperator();
return instance;
}
public static String Encrypt(String encData ,String secretKey,String vector) throws Exception {
if(secretKey == null) {
return null;
}
if(secretKey.length() != 16) {
return null;
}
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
byte[] raw = secretKey.getBytes();
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
IvParameterSpec iv = new IvParameterSpec(vector.getBytes());// 使用CBC模式，需要一个向量iv，可增加加密算法的强度
cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
byte[] encrypted = cipher.doFinal(encData.getBytes("utf-8"));
return new BASE64Encoder().encode(encrypted);// 此处使用BASE64做转码。
}
// 加密
public String encrypt(String sSrc) throws Exception {
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
byte[] raw = sKey.getBytes();
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
IvParameterSpec iv = new IvParameterSpec(ivParameter.getBytes());// 使用CBC模式，需要一个向量iv，可增加加密算法的强度
cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
byte[] encrypted = cipher.doFinal(sSrc.getBytes("utf-8"));
return new BASE64Encoder().encode(encrypted);// 此处使用BASE64做转码。
}
// 解密
public String decrypt(String sSrc) throws Exception {
try {
byte[] raw = sKey.getBytes("ASCII");
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
IvParameterSpec iv = new IvParameterSpec(ivParameter.getBytes());
cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
byte[] encrypted1 = new BASE64Decoder().decodeBuffer(sSrc);// 先用base64解密
byte[] original = cipher.doFinal(encrypted1);
String originalString = new String(original, "utf-8");
return originalString;
} catch (Exception ex) {
return null;
}
}
public String decrypt(String sSrc,String key,String ivs) throws Exception {
try {
byte[] raw = key.getBytes("ASCII");
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
IvParameterSpec iv = new IvParameterSpec(ivs.getBytes());
cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
byte[] encrypted1 = new BASE64Decoder().decodeBuffer(sSrc);// 先用base64解密
byte[] original = cipher.doFinal(encrypted1);
String originalString = new String(original, "utf-8");
return originalString;
} catch (Exception ex) {
return null;
}
}
public static String encodeBytes(byte[] bytes) {
StringBuffer strBuf = new StringBuffer();
for (int i = 0; i < bytes.length; i++) {
strBuf.append((char) (((bytes[i] >> 4) & 0xF) + ((int) 'a')));
strBuf.append((char) (((bytes[i]) & 0xF) + ((int) 'a')));
}
return strBuf.toString();
}
⑵ java如何读取一个加密后的.xls文件
近日来，研究了一下Excel Biff8（xls 97-2007）与OpenXML（ECMA-376）的加密文档的读取（这还是为了我们世界先进Grid而做的 ^__^）。有些成果，写在这里，希望能给要做类似功能的XD们一些参考。
如有不详，请联系：[email protected] / [email protected]
前提：
1. 加密文档：指Wookbook级的加密，就是在Save Excel文档时在General Settings中设置open password之后的文档；
2. 打开：需要用户传入密码。并非破解。但请勿将本文方法添加暴力模块使用 :-) ；
3. 本文涉及较多为，密钥计算，关于解密细节请参考微软相关文档；
使用的加密算法： RC4, SHA1, MD5, AES-128（其中RC4并不包含在所有版本的.NET Framework中，AES算法可以在.NET Framework 3.5中找到）
本文示例依赖 .NET Framework 3.5
A. Biff8 的加密文档读取
1. 通过文档中FILEPASS的record取得，文档的加密信息（关于Biff文档的格式问题，请参阅Biff的微软文档）
其中Biff8可以使用两种方法加密：Biff8标准加密算法和Biff8扩充加密算法。本文主要讨论最常用的Biff标准加密算法
2. 通过FILEPASS的结构，获得如下信息：
salt（加密随机数，16 bytes）
password verifier （密码效验器，16 bytes）
password verifier hash（密码效验器Hash，16 bytes）
3. 通过以上信息，生成解密key。并通过密码效验器，验证密码：
i. 将密码转化成unicode数组，并进行MD5 Hash；
ii. 将hash结果与salt串联，然后将byte数组，反复串联16次（336 bytes） ，然后再进行MD5 Hash；
iii. 将上步hash结果的前五位，串联上4 bytes的block值（在密码验证阶段为0，在以后解密阶段为block的index） ，然后进行MD5 Hash；
iv. 将上步hash结果的前16位，作为key
v. 使用RC4对称加密算法，将password verifier和password verifier hash分别解密，然后对password verifier的解密结果进行MD5 hash，其值应和password verifier hash的解密结果一致，即为密码正确。
vi. 之后进行逐个record的解密。excel biff8加密原则基本为，record的标示不加密，长度不加密，个别record不加密（见文档）；另外，在record解密时，还需要通过block的值重新计算解密key，block的大小为1024.
4. 详细请参照示例代码；
B. OpenXML(ECMA-376) 加密文档的读取
1. 通常来说，xlsx文件相当于一个zip文件，可以用zip程序，直接打开。而在加密后，为了安全性考虑，微软使用了 structured storage（一种OLE文档存储方式）存储（可以用7-zip或者OLE document viewer打开，windows也有相应API来操作此类结构）。在上述文档中，有一个叫做“EncryptedPackage”加密的package，就是一个zip包通过AES算法进行加密之后的结果。我们将使用和A一样的方式来检查密码，但生成key的方法不同；OpenXML的加密类型也有多种，我们这里就讨论常用的用AES-128进行加密的流程；
2. 通过文档的“EncryptedInfo”部分，需要过的一下信息（关于此部分的结构，请参考[MS-OFFCRYPTO].pdf）
salt（加密随机数，16 bytes）
password verifier （密码效验器，16 bytes）
password verifier hash（密码效验器Hash，32 bytes）
3. 通过以上信息，生成解密key。并通过密码效验器，验证密码：
i. 首先，定义一个H函数，其有两个输入，内部使用SHA1算法将两个输入串联之后的结果hash返回；
ii. 先将salt与password（password的unicode数组）进行H计算，h = H(salt, password) ；
iii.然后设iterator为0x00000000，将其转为4byte的数组，然后进行H计算，h1 = H(iterator, h);
iv.将上面的iterator递增一，然后再与h1进行H计算，h2 = H(iterator,h1)，然后将这个递增和计算过程重复50000次，最后计算过的iterator为49999即可；
v. 现在有计算结果h50000，将h50000再与0x00000000(4 byte数组)进行H计算，Hfinal = H(h50000, 0x00000000)；
vi. 生成一个64byte的数组，将每位都初始化成0x36，然后将这个数组与Hfinal异或；(关于这个地方，微软文档中写的有错误，按照原文的方法生成的key不正确，要不是文档的作者回信告诉我要使用这个法子，就算我想破头也想不出来啊 T__T)
vii.将异或结果，进行SHA1 hash，结果的前16byte就是解密的key；
viii.初始化AES算法，key长度为128，模式为ECB模式，Padding为none； 然后将password verifier 和password verifier hash分别解密；
ix. password verifier 解密后的SHA1 hash结果应该与password verifier hash解密后的前20byte相同；
4. 关于"EncryptedPackage" 的解密则更为简单，只许将“EncryptedPackage”读入，去除前8byte的size信息后，进行AES解密，即为未加密的标准openxml文档。
参考：
[MS-OFFCRYPTO].pdf
[MS-XLS].pdf
ECMA-376 standards
Reply by "winnow", 2008-09-10, 1:17
-----------------------------------------------------
总结一下, 关于这两种基于密码的加密方法, 基本上都是基于RFC2898 建议, 思想是这样:
输入是用户的密码:password, 输出是提供给加密函数的密钥:key.
考虑安全, 需要使同样的password生成的key不一样, 这样用相同的password加密后的结果就无法比较. 需要一个随机数salt.
另外, 为了使暴力破解的代价增大, 考虑使用一个循环多次的过程, 需要循环次数:iteration_count.
概念上, 生成方法为: 将password和salt进行某种运算, 配合一个Hash函数, 以某种方式循环iteration_count次, 在最后的结果里取一部分作为key输出.
具体参照RFC2898中的建议方法PBKDF1和PBKDF2.
这样, 用户输入的密码与一个随机数组合, 经过一定代价的运算, 就生成了可以供加密函数使用的密钥. 使用这个密钥和一个加密函数, 就可以进行加密了.
在应用中, 为了快速判断密码是否错误. 生成一个随机数verifier, 用一个Hash函数计算verifier的hash值:verifier_hash, 分别加密verifier和verifier_hash并保存.
解密的时候, 先分别解密出verifier和verifier_hash, 计算verifier的hash值, 与verifier_hash比较, 如果一致, 即说明密码正确.
⑶ 怎样用java程序加密解密文本文件
基本思路简单,
首先用流把文件内容读出来,
然后把内容转成acsii码,
之后移位,可以全文用一种移位,也可以每行或者每个字用一种移位.
最后用流写回去即可.
比如 "我" 这个字的ascii码是\u6211,加1移位成\u6212(戒),这样一片文章就面目全非了.当然移位成什么看你自己的移位算法,然后再转成汉字写回去.
package test;
import java.io.IOException;
public class Native2ascii {
private static final String java_path = "G:\\Java\\jdk 1.6";//你的jdk的绝对路径
private static final String target_file = "C:\\a.txt"; //原始文本的完整路径
private static final String result_file = "C:\\b.txt";//转码后的路径
private static final String back_file = "C:\\c.txt";//转回的路径
private static final String encoding = "GBK";// 编码
public static void native2ascii()
{
try {
Runtime.getRuntime().exec(java_path+"\\bin\\native2ascii.exe -encoding "+encoding+" "+target_file+" "+result_file);
//读取b.txt中的内容进行移位,我的没有移位所以写回c.txt中还能够看懂.
Runtime.getRuntime().exec(java_path+"\\bin\\native2ascii.exe -reverse "+result_file+" "+back_file);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String arg[]){
native2ascii();
}
}
⑷ 如何用JAVA实现字符串简单加密解密
importorg.apache.commons.codec.binary.Base64;
importorg.apache.commons.lang3.StringUtils;
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
importjavax.crypto.Cipher;
importjavax.crypto.spec.SecretKeySpec;
publicclassAESUtil{
publicstaticfinalLoggerLOGGER=LoggerFactory.getLogger(AESUtil.class);
_KEY="<TEST>KEY,123";
/**
*
*@paramsSrc
*@paramsKey
*@return
*@throwsException
*/
publicstaticStringencrypt(StringsSrc,StringsKey)throwsException{
//判断加密串是否为空，长度是否为16
if(StringUtils.isBlank(sKey)||sKey.length()!=16){
LOGGER.error("sKey为空null或长度不是16");
returnnull;
}
byte[]raw=sKey.getBytes("utf-8");
SecretKeySpecskeySpec=newSecretKeySpec(raw,"AES");
Ciphercipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE,skeySpec);
byte[]encrypted=cipher.doFinal(sSrc.getBytes("utf-8"));
returnnewString(newBase64().encode(encrypted),"UTF-8");
}
/**
*
*@paramenString
*@paramsKey
*@return
*@throwsException
*/
publicstaticStringdecrypt(StringenString,StringsKey)throwsException{
try{
if(StringUtils.isBlank(sKey)||sKey.length()!=16){
LOGGER.error("sKey为空null或长度不是16");
returnnull;
}
byte[]raw=sKey.getBytes("utf-8");
SecretKeySpecskeySpec=newSecretKeySpec(raw,"AES");
Ciphercipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(Cipher.DECRYPT_MODE,skeySpec);
byte[]encrypted1=(byte[])newBase64().decode(enString.getBytes());
try{
byte[]original=cipher.doFinal(encrypted1);
StringoriginalString=newString(original,"utf-8");
returnoriginalString;
}catch(Exceptione){
LOGGER.error(e.toString());
returnnull;
}
}catch(Exceptionex){
LOGGER.error(ex.toString());
returnnull;
}
}
}
⑸ 怎么对加密的JAVA class文件进行解密
首先用词就错了.class文件是java文件编译后的文件.class文件转换成java文件叫反编译
你下载个反编译软件,把class文件丢进去就可以了
⑹ java加密解密代码
package com.cube.limail.util;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;/**
* 加密解密类
*/
public class Eryptogram
{
private static String Algorithm ="DES";
private String key="CB7A92E3D3491964";
//定义 加密算法,可用 DES,DESede,Blowfish
static boolean debug = false ;
/**
* 构造子注解.
*/
public Eryptogram ()
{
} /**
* 生成密钥
* @return byte[] 返回生成的密钥
* @throws exception 扔出异常.
*/
public static byte [] getSecretKey () throws Exception
{
KeyGenerator keygen = KeyGenerator.getInstance (Algorithm );
SecretKey deskey = keygen.generateKey ();
System.out.println ("生成密钥:"+bytesToHexString (deskey.getEncoded ()));
if (debug ) System.out.println ("生成密钥:"+bytesToHexString (deskey.getEncoded ()));
return deskey.getEncoded ();
} /**
* 将指定的数据根据提供的密钥进行加密
* @param input 需要加密的数据
* @param key 密钥
* @return byte[] 加密后的数据
* @throws Exception
*/
public static byte [] encryptData (byte [] input ,byte [] key ) throws Exception
{
SecretKey deskey = new javax.crypto.spec.SecretKeySpec (key ,Algorithm );
if (debug )
{
System.out.println ("加密前的二进串:"+byte2hex (input ));
System.out.println ("加密前的字符串:"+new String (input ));
} Cipher c1 = Cipher.getInstance (Algorithm );
c1.init (Cipher.ENCRYPT_MODE ,deskey );
byte [] cipherByte =c1.doFinal (input );
if (debug ) System.out.println ("加密后的二进串:"+byte2hex (cipherByte ));
return cipherByte ;
} /**
* 将给定的已加密的数据通过指定的密钥进行解密
* @param input 待解密的数据
* @param key 密钥
* @return byte[] 解密后的数据
* @throws Exception
*/
public static byte [] decryptData (byte [] input ,byte [] key ) throws Exception
{
SecretKey deskey = new javax.crypto.spec.SecretKeySpec (key ,Algorithm );
if (debug ) System.out.println ("解密前的信息:"+byte2hex (input ));
Cipher c1 = Cipher.getInstance (Algorithm );
c1.init (Cipher.DECRYPT_MODE ,deskey );
byte [] clearByte =c1.doFinal (input );
if (debug )
{
System.out.println ("解密后的二进串:"+byte2hex (clearByte ));
System.out.println ("解密后的字符串:"+(new String (clearByte )));
} return clearByte ;
} /**
* 字节码转换成16进制字符串
* @param byte[] b 输入要转换的字节码
* @return String 返回转换后的16进制字符串
*/
public static String byte2hex (byte [] b )
{
String hs ="";
String stmp ="";
for (int n =0 ;n <b.length ;n ++)
{
stmp =(java.lang.Integer.toHexString (b [n ] & 0XFF ));
if (stmp.length ()==1 ) hs =hs +"0"+stmp ;
else hs =hs +stmp ;
if (n <b.length -1 ) hs =hs +":";
} return hs.toUpperCase ();
}
/**
* 字符串转成字节数组.
* @param hex 要转化的字符串.
* @return byte[] 返回转化后的字符串.
*/
public static byte[] hexStringToByte(String hex) {
int len = (hex.length() / 2);
byte[] result = new byte[len];
char[] achar = hex.toCharArray();
for (int i = 0; i < len; i++) {
int pos = i * 2;
result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
}
return result;
}
private static byte toByte(char c) {
byte b = (byte) "0123456789ABCDEF".indexOf(c);
return b;
}
/**
* 字节数组转成字符串.
* @param String 要转化的字符串.
* @return 返回转化后的字节数组.
*/
public static final String bytesToHexString(byte[] bArray) {
StringBuffer sb = new StringBuffer(bArray.length);
String sTemp;
for (int i = 0; i < bArray.length; i++) {
sTemp = Integer.toHexString(0xFF & bArray[i]);
if (sTemp.length() < 2)
sb.append(0);
sb.append(sTemp.toUpperCase());
}
return sb.toString();
}
/**
* 从数据库中获取密钥.
* @param deptid 企业id.
* @return 要返回的字节数组.
* @throws Exception 可能抛出的异常.
*/
public static byte[] getSecretKey(long deptid) throws Exception {
byte[] key=null;
String value=null;
//CommDao =new CommDao();
// List list=.getRecordList("from Key k where k.deptid="+deptid);
//if(list.size()>0){
//value=((com.csc.sale.bean.Key)list.get(0)).getKey();
value = "CB7A92E3D3491964";
key=hexStringToByte(value);
//}
if (debug)
System.out.println("密钥:" + value);
return key;
}
public String encryptData2(String data) {
String en = null;
try {
byte[] key=hexStringToByte(this.key);
en = bytesToHexString(encryptData(data.getBytes(),key));
} catch (Exception e) {
e.printStackTrace();
}
return en;
}
public String decryptData2(String data) {
String de = null;
try {
byte[] key=hexStringToByte(this.key);
de = new String(decryptData(hexStringToByte(data),key));
} catch (Exception e) {
e.printStackTrace();
}
return de;
}
} 加密使用： byte[] key=Eryptogram.getSecretKey(deptid); //获得钥匙（字节数组）
byte[] tmp=Eryptogram.encryptData(password.getBytes(), key); //传入密码和钥匙，获得加密后的字节数组的密码
password=Eryptogram.bytesToHexString(tmp); //将字节数组转化为字符串，获得加密后的字符串密码解密与之差不多