Java加密与解密（by quqi99）
Java加密与解密（by quqi99）
作者：张华 发表于：2009-12-31
版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本版权声明
1）base64算法
加密：new BASE64Encoder().encode(byte[] b)
解密: new BASE64Decoder().decode(byte[] b)
2) MD5或SHA摘要
MessageDigest digest = MessageDigest.getInstance("SHA"); //若是md5就 "MD5"
digest.update(byte[] b);
sha.degest();
3) 字节与16进制互换。
String strDigits = "0123456789ABCDEF";
String strDigitArr = {"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
public String byte2Hex(byte[] bytes){
String hs = "";
String stmp = "";
for(int =0;n<bytes.length;n++){
stmp = (Integer.toHexString(bytes[n] & 0XFF));
if(stmp.length() == 1)
hs = hs + "0" + stmp;
else
hs = hs + stmp;
}
return hs.toUpperCase();
}
public byte[] hex2Str(String hexStr){
char[] hexs = hexStr.toCharArray();
byte[] bytes = new byte[hexStr.length()/2];
int n;
for(int i=0;i<bytes.length;i++){
n = strDigits.indexOf(hexs[2*i]) * 16;
n += strDigits.indexOf(hexs[2*i + 1]);
bytes[i] = (byte)(n & 0xff);
}
}
4) RSA有公钥与密钥
生成密钥对：
private KeyPair generateKeyPair(){
KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA");
gen.initialize(1024,new SecureRandom());
KeyPari key = gen.genKeyPair();
return key;
}
//从公钥字节恢复公钥
//从密钥字节恢复密钥与这差不多，只不过将public字眼换成private
private RSAPublicKey recoverRSAPublicKey(byte[] modulus, byte[] publicExponent){
RSAPublicKeySpec spec = new RSAPublicKeySpec(new BigInteger(modulus),new BigInteger(publicExponent));
KeyFactory fac = KeyFacotry.getInstance("RSA");
RSAPublicKey key = (RSAPublicKey)fac.generatePublic(spec);
return key;
}
//RSA加解密
private byte[] rsaTrans(int mode,Key key,byte[] data){
if(mode != Cipher.ENCRYPT_MODE && mode!=Cipher.DECRYPT_MODE)
throw new Exception("");
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(mode,key,new SecureRandom());
return cipher.doFinal(data);
}
使用上述的方法：
KeyPair keyPair = generateKeyPair();
RSAPublicKey pubKey = (RSAPublicKey)keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();
byte[] pubModulusBytes = pubKey.getModulus().toByteArray();
byte[] publicExponentBytes = pubKey.getPublicExponent().toByteArray();
byte[] privateModulusBytes = privateKey.getModulus().toByteArray();
byte[]privateExponentBytes = privateKey.getPrivateExponent().toByteArray();
pubKey = recoverRSAPublicKey(pubModulusBytes,publicExponentBytes); //恢复公钥，恢复密钥类似
//用私钥加密
byte[] encryptData = rsaTran(Cipher.ENCRYPT_MODE,privateKey,bytes));
//用公钥解密
encryptData = rsaTran(Cipher.DECRYPT_MODE,privateKey,bytes));
5) DES为单钥加密机制，加密过程与RSA差不多。
步骤1：生成一个安全密匙。在加密或解密任何数据之前需要有一个密匙。密匙是随同被加密的应用一起发布的一小段数据
import java.security.SecureRandom;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
public class GenerateKey
{
static public void main( String args[] ) throws Exception {
String keyFilename = "key.data";
String algorithm = "DES";
// 生成密匙
SecureRandom sr = new SecureRandom();
KeyGenerator kg = KeyGenerator.getInstance( algorithm );
kg.init( sr );
SecretKey key = kg.generateKey();//[-68, -68, -57, -71, 42, -125, 32, 13]
// 把密匙数据保存到文件
Util.writeFile( keyFilename, key.getEncoded() );
}
}
步骤2：加密数据。得到密匙之后，接下来就可以用它加密数据。
// DES算法要求有一个可信任的随机数源
SecureRandom sr = new SecureRandom();
byte rawKeyData[] = /* 用某种方法获得密匙数据 */;
// 从原始密匙数据创建DESKeySpec对象
DESKeySpec dks = new DESKeySpec( rawKeyData );
// 创建一个密匙工厂，然后用它把DESKeySpec转换
// 一个SecretKey对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance( "DES" );
SecretKey key = keyFactory.generateSecret( dks );
// Cipher对象实际完成加密操作
Cipher cipher = Cipher.getInstance( "DES" );
// 用密匙初始化Cipher对象
cipher.init( Cipher.ENCRYPT_MODE, key, sr )
// 现在，获取数据并加密
byte data[] = /* 用某种方法获取数据 */
// 正式执行加密操作
byte encryptedData[] = cipher.doFinal( data );
// 进一步处理加密后的数据
步骤3：解密数据。
在上述加密数据将
cipher.init( Cipher.ENCRYPT_MODE, key, sr );
一句换成
cipher.init( Cipher.DECRYPT_MODE, key, sr );
doSomething( encryptedData );
下面附一个练习的例子，写的一个License，代码如下：
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.SecureRandom;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
/**
* @version 0.10 2010-2-28
* @author Zhang Hua
* 利用license机制来保护Java软件产品的安全
*/
public class License {
private static final String licensePath = "license.dat";
private static final String keyFilename = "key.data";
private static SimpleDateFormat sdf = new SimpleDateFormat( "yyyy-MM-dd"); //yyyy-MM-dd HH:mm:ss
//Product.title , AppServer
private String title = "AppServer";
//Product.sku, J2EE/CORBA
private String sku = "J2EE/CORBA";
//Serial.number, MAC Address
private byte[] serialNumber;
//Platform, all
private String platform = "";
//Trial.license
private boolean isTrial;
//License.expiry, 2010-05-12
private String expiry = "";
//Test
public static void main(String[] args){
//为用户生成license,并email给他
License om = new License();
om.setTitle("AppServer");
om.setSku("J2EE/CORBA");
String mac = getMACAddress();
om.setPlatform("Windows");
om.setTrial(false);
om.setExpiry("2010-05-12");
License.generateLicense(om,mac);
//在程序中校验license
License.validate();
}
//为用户生成license, 也就是将serialNumber字段的MAC加密
public static License generateLicense(License om,String mac){
try{
//密匙不存在，则生成密匙
if(! new File(keyFilename).exists()){
generateKey();
}
//用密匙加密数据
byte rawKeyData[] = readFile(keyFilename); //用某种方法获得密匙数据
DESKeySpec dks = new DESKeySpec( rawKeyData ); //从原始密匙数据创建DESKeySpec对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES"); //创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象
SecretKey key = keyFactory.generateSecret( dks );
Cipher cipher = Cipher.getInstance( "DES" ); //Cipher对象实际完成加密操作
SecureRandom sr = new SecureRandom(); //DES算法要求有一个可信任的随机数源
cipher.init(Cipher.ENCRYPT_MODE, key, sr ); //用密匙初始化Cipher对象
byte data[] = mac.getBytes(); //用某种方法获取数据
byte encryptedData[] = cipher.doFinal( data ); //正式执行加密操作
System.out.println("加密后的数据：" + encryptedData);
om.setSerialNumber(encryptedData);
//输出license
write(om);
}catch(Exception e){
e.printStackTrace();
}
return om;
}
//生成密匙
private static boolean generateKey(){
boolean result = false'
String algorithm = "DES";
try{
SecureRandom sr = new SecureRandom(); //DES算法要求有一个可信任的随机数源
KeyGenerator kg = KeyGenerator.getInstance(algorithm);
kg.init( sr );
SecretKey key = kg.generateKey(); //[-68, -68, -57, -71, 42, -125, 32, 13]
result = writeFile(keyFilename, key.getEncoded()); //把密匙数据保存到文件
}catch(Exception e){
e.printStackTrace();
}
return result;
}
public static boolean validate(){
boolean result = false;
try{
License om = read()'
String os = System.getProperty("os.name");
if (os.toLowerCase().startsWith(om.getPlatform().toLowerCase()) || "all".equals(om.getPlatform())) {
Date expireDate = sdf.parse(om.getExpiry());
if(expireDate.getTime() - new Date().getTime() < 0){
System.err.println("License过期了");
result = false'
}else{
if(om.isTrial()){
System.out.println("试用License有效");
result = true;
}else{
String mac = getMACAddress();
//用密匙解密数据
byte rawKeyData[] = readFile(keyFilename); //用某种方法获得密匙数据
DESKeySpec dks = new DESKeySpec( rawKeyData ); //从原始密匙数据创建DESKeySpec对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES"); //创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象
SecretKey key = keyFactory.generateSecret( dks );
Cipher cipher = Cipher.getInstance( "DES" ); //Cipher对象实际完成加密操作
SecureRandom sr = new SecureRandom(); //DES算法要求有一个可信任的随机数源
cipher.init(Cipher.DECRYPT_MODE, key, sr ); //用密匙初始化Cipher对象
byte data[] = om.getSerialNumber(); //用某种方法获取数据
byte encryptedData[] = cipher.doFinal(data); //正式执行加密操作
String tmp = new String(encryptedData);
System.out.println("解密后的数据：" + tmp);
if(mac.equals(tmp)){
System.out.println("License有效");
result = true;
}else{
System.err.println("License无效");
result = false;
}
}
}
}else{
System.err.println("License的平台无效");
result = false;
}
}catch(Exception e){
e.printStackTrace();
}
return result;
}
public static License read(){
License om = null;
try{
om = new License();
ObjectInputStream in = new ObjectInputStream(new FileInputStream(licensePath));
om.setTitle((String)in.readObject());
om.setSku((String)in.readObject());
om.setPlatform((String)in.readObject());
om.setTrial(in.readBoolean());
om.setExpiry((String)in.readObject());
om.setSerialNumber((byte[])in.readObject());
in.close();
}catch(Exception e){
e.printStackTrace();
}
return om;
}
public static boolean write(License om){
boolean result;
try{
File f = new File(licensePath);
if(f.exists())
f.delete();
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(om.getTitle());
out.writeObject(om.getSku());
out.writeObject(om.getPlatform());
out.writeBoolean(om.isTrial());
out.writeObject(om.getExpiry());
out.writeObject(om.getSerialNumber());
out.close();
result = true;
}catch(Exception e){
e.printStackTrace();
result = false;
}
return result;
}
public static boolean writeFile(String path, byte[] bytes){
boolean result = false;
try {
FileOutputStream fos = new FileOutputStream(path);
fos.write(bytes);
fos.close();
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
public static byte[] readFile(String path){
byte[] bytes = null;
try {
FileInputStream fin = new FileInputStream(path);
bytes = new byte[fin.available()];
fin.read(bytes);
fin.close();
} catch (Exception e) {
e.printStackTrace();
}
return bytes;
}
public static String getMACAddress() {
String address = "";
String os = System.getProperty("os.name");
if (os.startsWith("Windows")) {
try {
String command = "cmd.exe /c ipconfig /all";
Process p = Runtime.getRuntime().exec(command);
BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
String line;
while ((line = br.readLine()) != null) {
if (line.indexOf("Physical Address") > 0) {
int index = line.indexOf(":");
index += 2;
address = line.substring(index);
break;
}
}
br.close();
return address.trim();
} catch (IOException e) {
e.printStackTrace();
}
} else if (os.startsWith("Linux")) {
String command = "/bin/sh -c ifconfig -a";
Process p;
try {
p = Runtime.getRuntime().exec(command);
BufferedReader br = new BufferedReader(new InputStreamReader(p
.getInputStream()));
String line;
while ((line = br.readLine()) != null) {
if (line.indexOf("HWaddr") > 0) {
int index = line.indexOf("HWaddr") + "HWaddr".length();
address = line.substring(index);
break;
}
}
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
address = address.trim();
return address;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getSku() {
return sku;
}
public void setSku(String sku) {
this.sku = sku;
}
public byte[] getSerialNumber() {
return serialNumber;
}
public void setSerialNumber(byte[] serialNumber) {
this.serialNumber = serialNumber;
}
public String getPlatform() {
return platform;
}
public void setPlatform(String platform) {
this.platform = platform;
}
public boolean isTrial() {
return isTrial;
}
public void setTrial(boolean isTrial) {
this.isTrial = isTrial;
}
public String getExpiry() {
return expiry;
}
public void setExpiry(String expiry) {
this.expiry = expiry;
}
}
关于license的生成，还想说几点：
1）无论是生成二进制license，还是文件的，最好带上指纹校验。
2）无论是用什么加密算法无所谓，问题的关键不在里，在于JAVA容易被反编译，反编译之后很容易看到你的加密算法，人家可以
把这块替掉或者删除掉。另外，人家也可以在主程序调用license处的地方反编译之后直接返回true。
有网友说，对JAR包加密，然后自定义classloader解密，我看也是不行的，因为你自定义的classloader也是很容易被
反编译的，那样你的解密过程也就都清楚了。
所以，我认为，JAVA的东西就应用是开源的。当然，我们可以用混淆工具进行一定程度的混淆，算是给反编译增中一点困难的。
3）我试用了混淆工具proguard，觉得混淆工具有点不满足我的需求。
它默认是都混淆，但可以通过-keep参数指定某些类某些方法不混淆。
而我的需求是大多数类我不想混淆，我只想对少数几个类混淆，而且我的程序非常大，如果按照它的通过-keep参数指定
我不想混淆的类是不是有点太麻烦了。
下面是一个我测试过程中算是比较通用的配置my.conf，它对public,protected都不进行混淆，
用java -cp .;test.jar -jar proguard.jar @E:/workspace/test/my.conf 可执行混淆操作，my.conf文件如下：
-injars E:/workspace/test/test.jar
-outjars E:/workspace/test/test_out.jar
-libraryjars <java.home>/lib/rt.jar
-libraryjars E:/workspace/test/lib/mail.jar
-printmapping proguard.map
-renamesourcefileattribute SourceFile
-keepattributes Exceptions,InnerClasses,Signature,Deprecated,
SourceFile,LineNumberTable,*Annotation*,EnclosingMethod
-keep public class org.**
-keep public class * {
public protected *;
}
-keepclassmembernames class * {
java.lang.Class class$(java.lang.String);
java.lang.Class class$(java.lang.String, boolean);
}
-keepclasseswithmembernames class * {
native <methods>;
}
-keepclassmembers enum * {
public static **[] values();
public static ** valueOf(java.lang.String);
}
-keepclassmembers class * implements java.io.Serializable {
static final long serialVersionUID;
private void writeObject(java.io.ObjectOutputStream);
private void readObject(java.io.ObjectInputStream);
java.lang.Object writeReplace();
java.lang.Object readResolve();
}
一、密码学上常用的概念
1）消息摘要：
这是一种与消息认证码结合使用以确保消息完整性的技术。主要使用单向散列函数算法，可用于检验消息的完整性，和通过散列密码直接以文本形式 保存等，目前广泛使用的算法有MD4、MD5、SHA-1，jdk1.5对上面都提供了支持，在java中进行消息摘要很简单， java.security.MessageDigest提供了一个简易的操作方法：
/**
*MessageDigestExample.java
*Copyright 2005-2-16
*/
import java.security.MessageDigest;
/**
*单一的消息摘要算法，不使用密码.可以用 来对明文消息（如：密码）隐藏保存
*/
public class MessageDigestExample{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java MessageDigestExample text");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//使用getInstance("算法")来获得消息摘要, 这里使用SHA-1的160位算法
MessageDigest messageDigest=MessageDigest.getInstance("SHA-1");
System.out.println(" "+messageDigest.getProvider().getInfo());
//开 始使用算法
messageDigest.update(plainText);
System.out.println(" Digest:");
//输出算法运算结果
System.out.println(new String(messageDigest.digest(),"UTF8"));
}
}
还可以通过消息认证码 来进行加密实现，javax.crypto.Mac提供了一个解决方案，有兴趣者可以参考相关API文档，本文只是简单介绍什么是摘要算法。
2）私钥加密：
/**
*MessageDigestExample.java
*Copyright 2005-2-16
*/
import java.security.MessageDigest;
/**
*单一的消息摘要算法，不使用密码.可以用 来对明文消息（如：密码）隐藏保存
*/
public class MessageDigestExample{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java MessageDigestExample text");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//使用getInstance("算法")来获得消息摘要, 这里使用SHA-1的160位算法
MessageDigest messageDigest=MessageDigest.getInstance("SHA-1");
System.out.println(" "+messageDigest.getProvider().getInfo());
//开 始使用算法
messageDigest.update(plainText);
System.out.println(" Digest:");
//输出算法运算结果
System.out.println(new String(messageDigest.digest(),"UTF8"));
}
}
还可以通过消息认证码 来进行加密实现，javax.crypto.Mac提供了一个解决方案，有兴趣者可以参考相关API文档，本文只是简单介绍什么是摘要算法。
2）私钥加密：
消息摘要只能检查消息的完整性，但是单向的，对明文消息并不能加密，要加密明文的消息的话，就要使用其他的算法，要确保机密性，我们需要使 用私钥密码术来交换私有消息。
这种最好理解，使用对称算法。比如：A用一个密钥对一个文件加密，而B读取这个文件的话，则需要和A一样的密 钥，双方共享一个私钥（而在web环境下，私钥在传递时容易被侦听）：
使用私钥加密的话，首先需要一个密钥，可用 javax.crypto.KeyGenerator产生一个密钥(java.security.Key),然后传递给一个加密工具 (javax.crypto.Cipher),该工具再使用相应的算法来进行加密，主要对称算法有：DES（实际密钥只用到56位），AES（支持三种密 钥长度：128、192、256位），通常首先128位，其他的还有DESede等，jdk1.5种也提供了对对称算法的支持，以下例子使用AES算法来 加密：
/**
*PrivateExmaple.java
*Copyright 2005-2-16
*/
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import java.security.Key;
/**
*私鈅加密，保证消息机密性
*/
public class PrivateExample{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java PrivateExample ");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//通过KeyGenerator形成一个key
System.out.println(" Start generate AES key");
KeyGenerator keyGen=KeyGenerator.getInstance("AES");
keyGen.init(128);
Key key=keyGen.generateKey();
System.out.println("Finish generating DES key");
//获得一个私鈅加密类Cipher，ECB是加密方式，PKCS5Padding是填充方法
Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
System.out.println(" "+cipher.getProvider().getInfo());
//使用私鈅加密
System.out.println(" Start encryption:");
cipher.init(Cipher.ENCRYPT_MODE,key);
byte[] cipherText=cipher.doFinal(plainText);
System.out.println("Finish encryption:");
System.out.println(new String(cipherText,"UTF8"));
System.out.println(" Start decryption:");
cipher.init(Cipher.DECRYPT_MODE,key);
byte[] newPlainText=cipher.doFinal(cipherText);
System.out.println("Finish decryption:");
System.out.println(new String(newPlainText,"UTF8"));
}
}
3）公钥加密：
这种最好理解，使用对称算法。比如：A用一个密钥对一个文件加密，而B读取这个文件的话，则需要和A一样的密 钥，双方共享一个私钥（而在web环境下，私钥在传递时容易被侦听）：
使用私钥加密的话，首先需要一个密钥，可用 javax.crypto.KeyGenerator产生一个密钥(java.security.Key),然后传递给一个加密工具 (javax.crypto.Cipher),该工具再使用相应的算法来进行加密，主要对称算法有：DES（实际密钥只用到56位），AES（支持三种密 钥长度：128、192、256位），通常首先128位，其他的还有DESede等，jdk1.5种也提供了对对称算法的支持，以下例子使用AES算法来 加密：
/**
*PrivateExmaple.java
*Copyright 2005-2-16
*/
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import java.security.Key;
/**
*私鈅加密，保证消息机密性
*/
public class PrivateExample{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java PrivateExample ");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//通过KeyGenerator形成一个key
System.out.println(" Start generate AES key");
KeyGenerator keyGen=KeyGenerator.getInstance("AES");
keyGen.init(128);
Key key=keyGen.generateKey();
System.out.println("Finish generating DES key");
//获得一个私鈅加密类Cipher，ECB是加密方式，PKCS5Padding是填充方法
Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
System.out.println(" "+cipher.getProvider().getInfo());
//使用私鈅加密
System.out.println(" Start encryption:");
cipher.init(Cipher.ENCRYPT_MODE,key);
byte[] cipherText=cipher.doFinal(plainText);
System.out.println("Finish encryption:");
System.out.println(new String(cipherText,"UTF8"));
System.out.println(" Start decryption:");
cipher.init(Cipher.DECRYPT_MODE,key);
byte[] newPlainText=cipher.doFinal(cipherText);
System.out.println("Finish decryption:");
System.out.println(new String(newPlainText,"UTF8"));
}
}
3）公钥加密：
上面提到，私钥加密需要一个共享的密钥，那么如何传递密钥呢？web环境下，直接传递的话很容易被侦听到，幸好有了公钥加密的出现。公钥加 密也叫不对称加密，不对称算法使用一对密钥对，一个公钥，一个私钥，使用公钥加密的数据，只有私钥能解开（可用于加密）；同时，使用私钥加密的数据，只有 公钥能解开（签名）。但是速度很慢（比私钥加密慢100到1000倍），公钥的主要算法有RSA，还包括Blowfish,Diffie-Helman 等，jdk1.5种提供了对RSA的支持，是一个改进的地方：
/**
*PublicExample.java
*Copyright 2005-2-16
*/
import java.security.Key;
import javax.crypto.Cipher;
import java.security. KeyPairGenerator ;
import java.security.KeyPair;
/**
*一个简单的公鈅加密例子,Cipher类使用 KeyPairGenerator 生成的公鈅和私鈅
*/
public class PublicExample{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java PublicExample ");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//构成一个RSA密钥
System.out.println(" Start generating RSA key");
KeyPairGenerator keyGen= KeyPairGenerator .getInstance("RSA");
keyGen.initialize(1024);
KeyPair key=keyGen.generateKeyPair();
System.out.println("Finish generating RSA key");
//获得一个RSA的Cipher类，使用公鈅加密
Cipher cipher=Cipher.getInstance("RSA/ECB/PKCS1Padding");
System.out.println(" "+cipher.getProvider().getInfo());
System.out.println(" Start encryption");
cipher.init(Cipher.ENCRYPT_MODE,key.getPublic());
byte[] cipherText=cipher.doFinal(plainText);
System.out.println("Finish encryption:");
System.out.println(new String(cipherText,"UTF8"));
//使用私鈅解密
System.out.println(" Start decryption");
cipher.init(Cipher.DECRYPT_MODE,key.getPrivate());
byte[] newPlainText=cipher.doFinal(cipherText);
System.out.println("Finish decryption:");
System.out.println(new String(newPlainText,"UTF8"));
}
}
4）数字签名：
/**
*PublicExample.java
*Copyright 2005-2-16
*/
import java.security.Key;
import javax.crypto.Cipher;
import java.security. KeyPairGenerator ;
import java.security.KeyPair;
/**
*一个简单的公鈅加密例子,Cipher类使用 KeyPairGenerator 生成的公鈅和私鈅
*/
public class PublicExample{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java PublicExample ");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//构成一个RSA密钥
System.out.println(" Start generating RSA key");
KeyPairGenerator keyGen= KeyPairGenerator .getInstance("RSA");
keyGen.initialize(1024);
KeyPair key=keyGen.generateKeyPair();
System.out.println("Finish generating RSA key");
//获得一个RSA的Cipher类，使用公鈅加密
Cipher cipher=Cipher.getInstance("RSA/ECB/PKCS1Padding");
System.out.println(" "+cipher.getProvider().getInfo());
System.out.println(" Start encryption");
cipher.init(Cipher.ENCRYPT_MODE,key.getPublic());
byte[] cipherText=cipher.doFinal(plainText);
System.out.println("Finish encryption:");
System.out.println(new String(cipherText,"UTF8"));
//使用私鈅解密
System.out.println(" Start decryption");
cipher.init(Cipher.DECRYPT_MODE,key.getPrivate());
byte[] newPlainText=cipher.doFinal(cipherText);
System.out.println("Finish decryption:");
System.out.println(new String(newPlainText,"UTF8"));
}
}
4）数字签名：
数字签名，它是确定交换消息的通信方身份的第一个级别。上面A通过使用公钥加密数据后发给B，B利用私钥解密就得到了需要的数据，问题来 了，由于都是使用公钥加密，那么如何检验是A发过来的消息呢？上面也提到了一点，私钥是唯一的，那么A就可以利用A自己的私钥进行加密，然后B再利用A的 公钥来解密，就可以了；数字签名的原理就基于此，而通常为了证明发送数据的真实性，通过利用消息摘要获得简短的消息内容，然后再利用私钥进行加密散列数据 和消息一起发送。java中为数字签名提供了良好的支持，java.security.Signature类提供了消息签名：
/**
*DigitalSignature2Example.java
*Copyright 2005-2-16
*/
import java.security.Signature;
import java.security. KeyPairGenerator ;
import java.security.KeyPair;
import java.security.SignatureException;
/**
*数字签名，使用RSA私钥对对消息摘要签名，然后使用公鈅验证 测试
*/
public class DigitalSignature2Example{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java DigitalSignature2Example ");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//形成RSA公钥对
System.out.println(" Start generating RSA key");
KeyPairGenerator keyGen= KeyPairGenerator .getInstance("RSA");
keyGen.initialize(1024);
KeyPair key=keyGen.generateKeyPair();
System.out.println("Finish generating RSA key");
//使用私鈅签名
Signature sig=Signature.getInstance("SHA1WithRSA");
sig.initSign(key.getPrivate());
sig.update(plainText);
byte[] signature=sig.sign();
System.out.println(sig.getProvider().getInfo());
System.out.println(" Signature:");
System.out.println(new String(signature,"UTF8"));
//使用公鈅验证
System.out.println(" Start signature verification");
sig.initVerify(key.getPublic());
sig.update(plainText);
try{
if(sig.verify(signature)){
System.out.println("Signature verified");
}else System.out.println("Signature failed");
}catch(SignatureException e){
System.out.println("Signature failed");
}
}
}
/**
*DigitalSignature2Example.java
*Copyright 2005-2-16
*/
import java.security.Signature;
import java.security. KeyPairGenerator ;
import java.security.KeyPair;
import java.security.SignatureException;
/**
*数字签名，使用RSA私钥对对消息摘要签名，然后使用公鈅验证 测试
*/
public class DigitalSignature2Example{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java DigitalSignature2Example ");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//形成RSA公钥对
System.out.println(" Start generating RSA key");
KeyPairGenerator keyGen= KeyPairGenerator .getInstance("RSA");
keyGen.initialize(1024);
KeyPair key=keyGen.generateKeyPair();
System.out.println("Finish generating RSA key");
//使用私鈅签名
Signature sig=Signature.getInstance("SHA1WithRSA");
sig.initSign(key.getPrivate());
sig.update(plainText);
byte[] signature=sig.sign();
System.out.println(sig.getProvider().getInfo());
System.out.println(" Signature:");
System.out.println(new String(signature,"UTF8"));
//使用公鈅验证
System.out.println(" Start signature verification");
sig.initVerify(key.getPublic());
sig.update(plainText);
try{
if(sig.verify(signature)){
System.out.println("Signature verified");
}else System.out.println("Signature failed");
}catch(SignatureException e){
System.out.println("Signature failed");
}
}
}
5)数字证书。
还有个问题，就是公钥问题，A用私钥加密了，那么B接受到消息后，用A提供的公钥解密；那么现在有个讨厌的C，他把消息拦截了，然后用自己 的私钥加密，同时把自己的公钥发给B，并告诉B，那是A的公钥，结果....，这时候就需要一个中间机构出来说话了（相信权威，我是正确的），就出现了 Certificate Authority(也即CA），有名的CA机构有Verisign等，目前数字认证的工业标准是：CCITT的X.509：
数字证书：它将一个身份标识连同公钥一起进行封装，并由称为认证中心或 CA 的第三方进行数字签名。
密钥库：java平台为你提供了密 钥库，用作密钥和证书的资源库。从物理上讲，密钥库是缺省名称为 .keystore 的文件（有一个选项使它成为加密文件）。密钥和证书可以拥有名称（称为别名），每个别名都由唯一的密码保护。密钥库本身也受密码保护；您可以选择让每个别 名密码与主密钥库密码匹配。
使用工具 keytool ，我们来做一件自我认证的 事情吧（相信我的认证）：
1、创建密钥库 keytool -genkey -v -alias feiUserKey -keyalg RSA 默认在自己的home目录下（windows系统是c:documents and settings<你的用户名> 目录下的.keystore文件），创建我们用 RSA 算法生成别名为 feiUserKey 的自签名的证书,如果使用了-keystore mm 就在当前目录下创建一个密钥库mm文件来保存密钥和证书。
2、查看证书： keytool -list 列举了密钥库的所有的证书
也可以在dos下输入 keytool -help查看帮助。
数字证书：它将一个身份标识连同公钥一起进行封装，并由称为认证中心或 CA 的第三方进行数字签名。
密钥库：java平台为你提供了密 钥库，用作密钥和证书的资源库。从物理上讲，密钥库是缺省名称为 .keystore 的文件（有一个选项使它成为加密文件）。密钥和证书可以拥有名称（称为别名），每个别名都由唯一的密码保护。密钥库本身也受密码保护；您可以选择让每个别 名密码与主密钥库密码匹配。
使用工具 keytool ，我们来做一件自我认证的 事情吧（相信我的认证）：
1、创建密钥库 keytool -genkey -v -alias feiUserKey -keyalg RSA 默认在自己的home目录下（windows系统是c:documents and settings<你的用户名> 目录下的.keystore文件），创建我们用 RSA 算法生成别名为 feiUserKey 的自签名的证书,如果使用了-keystore mm 就在当前目录下创建一个密钥库mm文件来保存密钥和证书。
2、查看证书： keytool -list 列举了密钥库的所有的证书
也可以在dos下输入 keytool -help查看帮助。
4）数字签名：
数字签名，它是确定交换消息的通信方身份的第一个级别。上面A通过使用公钥加密数据后发给B，B利用私钥解密就得到了需要的数据，问题来 了，由于都是使用公钥加密，那么如何检验是A发过来的消息呢？上面也提到了一点，私钥是唯一的，那么A就可以利用A自己的私钥进行加密，然后B再利用A的 公钥来解密，就可以了；数字签名的原理就基于此，而通常为了证明发送数据的真实性，通过利用消息摘要获得简短的消息内容，然后再利用私钥进行加密散列数据 和消息一起发送。java中为数字签名提供了良好的支持，java.security.Signature类提供了消息签名：
/**
*DigitalSignature2Example.java
*Copyright 2005-2-16
*/
import java.security.Signature;
import java.security. KeyPairGenerator ;
import java.security.KeyPair;
import java.security.SignatureException;
/**
*数字签名，使用RSA私钥对对消息摘要签名，然后使用公鈅验证 测试
*/
public class DigitalSignature2Example{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java DigitalSignature2Example ");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//形成RSA公钥对
System.out.println(" Start generating RSA key");
KeyPairGenerator keyGen= KeyPairGenerator .getInstance("RSA");
keyGen.initialize(1024);
KeyPair key=keyGen.generateKeyPair();
System.out.println("Finish generating RSA key");
//使用私鈅签名
Signature sig=Signature.getInstance("SHA1WithRSA");
sig.initSign(key.getPrivate());
sig.update(plainText);
byte[] signature=sig.sign();
System.out.println(sig.getProvider().getInfo());
System.out.println(" Signature:");
System.out.println(new String(signature,"UTF8"));
//使用公鈅验证
System.out.println(" Start signature verification");
sig.initVerify(key.getPublic());
sig.update(plainText);
try{
if(sig.verify(signature)){
System.out.println("Signature verified");
}else System.out.println("Signature failed");
}catch(SignatureException e){
System.out.println("Signature failed");
}
}
}
5)数字证书。
/**
*DigitalSignature2Example.java
*Copyright 2005-2-16
*/
import java.security.Signature;
import java.security. KeyPairGenerator ;
import java.security.KeyPair;
import java.security.SignatureException;
/**
*数字签名，使用RSA私钥对对消息摘要签名，然后使用公鈅验证 测试
*/
public class DigitalSignature2Example{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java DigitalSignature2Example ");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//形成RSA公钥对
System.out.println(" Start generating RSA key");
KeyPairGenerator keyGen= KeyPairGenerator .getInstance("RSA");
keyGen.initialize(1024);
KeyPair key=keyGen.generateKeyPair();
System.out.println("Finish generating RSA key");
//使用私鈅签名
Signature sig=Signature.getInstance("SHA1WithRSA");
sig.initSign(key.getPrivate());
sig.update(plainText);
byte[] signature=sig.sign();
System.out.println(sig.getProvider().getInfo());
System.out.println(" Signature:");
System.out.println(new String(signature,"UTF8"));
//使用公鈅验证
System.out.println(" Start signature verification");
sig.initVerify(key.getPublic());
sig.update(plainText);
try{
if(sig.verify(signature)){
System.out.println("Signature verified");
}else System.out.println("Signature failed");
}catch(SignatureException e){
System.out.println("Signature failed");
}
}
}
5)数字证书。
还有个问题，就是公钥问题，A用私钥加密了，那么B接受到消息后，用A提供的公钥解密；那么现在有个讨厌的C，他把消息拦截了，然后用自己 的私钥加密，同时把自己的公钥发给B，并告诉B，那是A的公钥，结果....，这时候就需要一个中间机构出来说话了（相信权威，我是正确的），就出现了 Certificate Authority(也即CA），有名的CA机构有Verisign等，目前数字认证的工业标准是：CCITT的X.509：
数字证书：它将一个身份标识连同公钥一起进行封装，并由称为认证中心或 CA 的第三方进行数字签名。
密钥库：java平台为你提供了密 钥库，用作密钥和证书的资源库。从物理上讲，密钥库是缺省名称为 .keystore 的文件（有一个选项使它成为加密文件）。密钥和证书可以拥有名称（称为别名），每个别名都由唯一的密码保护。密钥库本身也受密码保护；您可以选择让每个别 名密码与主密钥库密码匹配。
使用工具 keytool ，我们来做一件自我认证的 事情吧（相信我的认证）：
1、创建密钥库 keytool
数字证书：它将一个身份标识连同公钥一起进行封装，并由称为认证中心或 CA 的第三方进行数字签名。
密钥库：java平台为你提供了密 钥库，用作密钥和证书的资源库。从物理上讲，密钥库是缺省名称为 .keystore 的文件（有一个选项使它成为加密文件）。密钥和证书可以拥有名称（称为别名），每个别名都由唯一的密码保护。密钥库本身也受密码保护；您可以选择让每个别 名密码与主密钥库密码匹配。
使用工具 keytool ，我们来做一件自我认证的 事情吧（相信我的认证）：
1、创建密钥库 keytool