DES、AES、RSA加密解密

其中用到android自带的Base64类，java环境只需修改此类

基类Coder

package com.api.safe.coder;

public interface ICoder {
public String encode(String data, String key) throws Exception;

public String decode(String data, String key) throws Exception;

}

DESCoder实现

package com.api.safe.coder.impl;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

import android.annotation.SuppressLint;
import android.util.Base64;

import com.api.safe.AlgorithmType;
import com.api.safe.coder.ICoder;

public class DESCoder implements ICoder {
private static final String CHARSET_UTF_8 = "UTF-8";

private static final ICoder CODER = new DESCoder();

private DESCoder() {

}

@SuppressLint("TrulyRandom")
@Override
public String encode(String data, String key) throws Exception {
byte[] raw = Base64.decode(key.getBytes(CHARSET_UTF_8), Base64.DEFAULT);
SecretKeySpec secretKeySpec = new SecretKeySpec(raw, AlgorithmType.DES.getValue());
Cipher cipher = Cipher.getInstance(AlgorithmType.DES.getValue());
cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
byte[] encodeData = cipher.doFinal(data.getBytes(CHARSET_UTF_8));
byte[] base64Data = Base64.encode(encodeData, Base64.DEFAULT);
return new String(base64Data, CHARSET_UTF_8);
}

@Override
public String decode(String data, String key) throws Exception {
byte[] raw = Base64.decode(key.getBytes(CHARSET_UTF_8), Base64.DEFAULT);
SecretKeySpec secretKeySpec = new SecretKeySpec(raw, AlgorithmType.DES.getValue());
Cipher cipher = Cipher.getInstance(AlgorithmType.DES.getValue());
cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
byte[] base64Data = Base64.decode(data.getBytes(CHARSET_UTF_8), Base64.DEFAULT);
byte[] decodeData = cipher.doFinal(base64Data);
return new String(decodeData, CHARSET_UTF_8);
}

public static ICoder getInstance() {
return CODER;
}
}

AESCoder实现

package com.api.safe.coder.impl;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

import android.annotation.SuppressLint;
import android.util.Base64;

import com.api.safe.AlgorithmType;
import com.api.safe.coder.ICoder;

public class AESCoder implements ICoder {
private static final String CHARSET_UTF_8 = "UTF-8";

private static final ICoder CODER = new AESCoder();

private AESCoder() {

}

@SuppressLint("TrulyRandom")
@Override
public String encode(String data, String key) throws Exception {
byte[] raw = Base64.decode(key.getBytes(CHARSET_UTF_8), Base64.DEFAULT);
SecretKeySpec secretKeySpec = new SecretKeySpec(raw, AlgorithmType.AES.getValue());
Cipher cipher = Cipher.getInstance(AlgorithmType.AES.getValue());
cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
byte[] encodeData = cipher.doFinal(data.getBytes(CHARSET_UTF_8));
byte[] base64Data = Base64.encode(encodeData, Base64.DEFAULT);
return new String(base64Data, CHARSET_UTF_8);
}

@Override
public String decode(String data, String key) throws Exception {
byte[] raw = Base64.decode(key.getBytes(CHARSET_UTF_8), Base64.DEFAULT);
SecretKeySpec secretKeySpec = new SecretKeySpec(raw, AlgorithmType.AES.getValue());
Cipher cipher = Cipher.getInstance(AlgorithmType.AES.getValue());
cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
byte[] base64Data = Base64.decode(data.getBytes(CHARSET_UTF_8), Base64.DEFAULT);
byte[] decodeData = cipher.doFinal(base64Data);
return new String(decodeData, CHARSET_UTF_8);
}

public static ICoder getInstance() {
return CODER;
}
}

RESCoder实现

package com.api.safe.coder.impl;

import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

import android.annotation.SuppressLint;
import android.util.Base64;

import com.api.safe.AlgorithmType;
import com.api.safe.coder.ICoder;

public class RSACoder implements ICoder {
private static final String CHARSET_UTF_8 = "UTF-8";

private static final ICoder CODER = new RSACoder();

private RSACoder() {

}

@SuppressLint("TrulyRandom")
@Override
public String encode(String data, String key) throws Exception {
byte[] raw = Base64.decode(key.getBytes(CHARSET_UTF_8), Base64.DEFAULT);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(raw);
KeyFactory keyFactory = KeyFactory.getInstance(AlgorithmType.RSA.getValue());
PublicKey publicKey = keyFactory.generatePublic(keySpec);
Cipher cipher = Cipher.getInstance(AlgorithmType.RSA.getValue());
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] encodeData = cipher.doFinal(data.getBytes(CHARSET_UTF_8));
byte[] base64Data = Base64.encode(encodeData, Base64.DEFAULT);
return new String(base64Data, CHARSET_UTF_8);
}

@Override
public String decode(String data, String key) throws Exception {
byte[] raw = Base64.decode(key.getBytes(CHARSET_UTF_8), Base64.DEFAULT);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(raw);
KeyFactory keyFactory = KeyFactory.getInstance(AlgorithmType.RSA.getValue());
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
Cipher cipher = Cipher.getInstance(AlgorithmType.RSA.getValue());
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] base64Data = Base64.decode(data.getBytes(CHARSET_UTF_8), Base64.DEFAULT);
byte[] decodeData = cipher.doFinal(base64Data);
return new String(decodeData, CHARSET_UTF_8);
}

public static ICoder getInstance() {
return CODER;
}
}

Coder工厂基类

package com.api.safe.coder;

import com.api.safe.AlgorithmType;

public interface ICoderFactory {
public ICoder create(AlgorithmType type);
}

Coder工厂实现

package com.api.safe.coder.impl;

import com.api.safe.AlgorithmType;
import com.api.safe.coder.ICoder;
import com.api.safe.coder.ICoderFactory;

public class CoderFactory implements ICoderFactory {

@Override
public ICoder create(AlgorithmType type) {
switch (type) {
case DES:
return DESCoder.getInstance();
case AES:
return AESCoder.getInstance();
case RSA:
return RSACoder.getInstance();
}
return null;
}

}

Key基类

package com.api.safe.key;

public interface IkeyInfo {
public String getPublicKey();

public String getPrivateKey();

public void createKey(String seed) throws Exception;
}

BaseKey基类

package com.api.safe.key.impl;

import com.api.safe.key.IkeyInfo;

public abstract class BaseKeyInfo implements IkeyInfo{
protected static final String CHARSET_UTF_8 = "UTF-8";
protected String mPublicKey;
protected String mPrivateKey;
}

DESKey实现类

package com.api.safe.key.impl;

import java.security.Key;
import java.security.SecureRandom;

import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import android.util.Base64;

import com.api.safe.AlgorithmType;

class DESKeyInfo extends BaseKeyInfo {
private static final int KEY_SIZE = 64;

@Override
public String getPublicKey() {
return mPublicKey;
}

@Override
public String getPrivateKey() {
return mPrivateKey;
}

@Override
public void createKey(String seed) throws Exception {
byte[] secretKey = getSecretKey(seed, AlgorithmType.DES.getValue());
Key k = createKey(secretKey, AlgorithmType.DES.getValue());
byte[] raw = k.getEncoded();
byte[] base64Data = Base64.encode(raw, Base64.DEFAULT);
mPublicKey = mPrivateKey = new String(base64Data, CHARSET_UTF_8);
}

private static Key createKey(byte[] key, String algorithm) throws Exception {
SecretKey secretKey = new SecretKeySpec(key, algorithm);
return secretKey;
}

private static byte[] getSecretKey(String seed, String algorithm) throws Exception {
KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
SecureRandom secureRandom;
if (seed != null && !"".equals(seed)) {
secureRandom = new SecureRandom(seed.getBytes());
} else {
secureRandom = new SecureRandom();
}
keyGenerator.init(KEY_SIZE, secureRandom);
SecretKey secretKey = keyGenerator.generateKey();
return secretKey.getEncoded();
}

}

AESKey实现类
package com.api.safe.key.impl;

import java.security.Key;
import java.security.SecureRandom;

import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import android.util.Base64;

import com.api.safe.AlgorithmType;

class AESKeyInfo extends BaseKeyInfo {
private static final int KEY_SIZE = 128;

@Override
public String getPublicKey() {
return mPublicKey;
}

@Override
public String getPrivateKey() {
return mPrivateKey;
}

@Override
public void createKey(String seed) throws Exception {
byte[] secretKey = getSecretKey(seed, AlgorithmType.AES.getValue());
Key k = createKey(secretKey, AlgorithmType.AES.getValue());
byte[] raw = k.getEncoded();
byte[] base64Data = Base64.encode(raw, Base64.DEFAULT);
mPublicKey = mPrivateKey = new String(base64Data, CHARSET_UTF_8);
}

private static Key createKey(byte[] key, String algorithm) throws Exception {
SecretKey secretKey = new SecretKeySpec(key, algorithm);
return secretKey;
}

private static byte[] getSecretKey(String seed, String algorithm) throws Exception {
KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
SecureRandom secureRandom;
if (seed != null && !"".equals(seed)) {
secureRandom = new SecureRandom(seed.getBytes());
} else {
secureRandom = new SecureRandom();
}
keyGenerator.init(KEY_SIZE, secureRandom);
SecretKey secretKey = keyGenerator.generateKey();
return secretKey.getEncoded();
}

}


RSAKey实现类

package com.api.safe.key.impl;

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;

import android.annotation.SuppressLint;
import android.util.Base64;

import com.api.safe.AlgorithmType;

class RSAKeyInfo extends BaseKeyInfo {
private static final int KEY_SIZE = 1024;

@Override
public String getPublicKey() {
return mPublicKey;
}

@Override
public String getPrivateKey() {
return mPrivateKey;
}

@Override
public void createKey(String seed) throws Exception {
getSecretKey(seed, AlgorithmType.RSA.getValue());
}

@SuppressLint("TrulyRandom")
private void getSecretKey(String seed, String algorithm) throws Exception {
KeyPairGenerator keyGenerator = KeyPairGenerator.getInstance(algorithm);
SecureRandom secureRandom;
if (seed != null && !"".equals(seed)) {
secureRandom = new SecureRandom(seed.getBytes());
} else {
secureRandom = new SecureRandom();
}
keyGenerator.initialize(KEY_SIZE, secureRandom);
KeyPair keyPair = keyGenerator.generateKeyPair();
PrivateKey privateKey = keyPair.getPrivate();
PublicKey publicKey = keyPair.getPublic();
byte[] privateKeyData = Base64.encode(privateKey.getEncoded(), Base64.DEFAULT);
mPrivateKey = new String(privateKeyData, CHARSET_UTF_8);
byte[] publicKeyData = Base64.encode(publicKey.getEncoded(), Base64.DEFAULT);
mPublicKey = new String(publicKeyData, CHARSET_UTF_8);
}

}

Key工厂基类

package com.api.safe.key;

import com.api.safe.AlgorithmType;

public interface IKeyInfoFactory {

public IkeyInfo create(AlgorithmType type);
}

Key工厂实现类

package com.api.safe.key.impl;

import com.api.safe.AlgorithmType;
import com.api.safe.key.IKeyInfoFactory;
import com.api.safe.key.IkeyInfo;

public class KeyInfoFactory implements IKeyInfoFactory {

@Override
public IkeyInfo create(AlgorithmType type) {
switch (type) {
case DES:
return new DESKeyInfo();
case AES:
return new AESKeyInfo();
case RSA:
return new RSAKeyInfo();
}
return null;
}

}

加解密类型AlgorithmType类

package com.api.safe;

public enum AlgorithmType {
AES("AES"), DES("DES"), RSA("RSA");
private String mValue;

private AlgorithmType(String value) {
mValue = value;
}

public String getValue() {
return mValue;
}
}

调用方式

ICoderFactory coderFactory = new CoderFactory();
ICoder corder = coderFactory.create(AlgorithmType.RSA);
IKeyInfoFactory keyInfoFactory = new KeyInfoFactory();
IkeyInfo keyInfo = keyInfoFactory.create(AlgorithmType.RSA);

try {
keyInfo.createKey("1@;“2186￥%哈哈……");
String encode = corder.encode("中国人民共和国$", keyInfo.getPublicKey());
String decode = corder.decode(encode, keyInfo.getPrivateKey());
Toast.makeText(this, decode, Toast.LENGTH_LONG).show();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

其中每次createKey都是创建新的key，实际使用过程中用KeyInfo生成密码需要保存下来。DES、AES加密解密使用的是一个密码（对称加密）。RSA加密使用PublicKey，解密使用PrivateKey，一般加密方持有公钥（PublicKey），解密方持有私钥（PrivateKey）。

源码下载地址：http://download.csdn.net/download/yanhua_dream/9068769