⑴ 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); //將位元組數組轉化為字元串，獲得加密後的字元串密碼解密與之差不多