JAVA 的加密演算法

import java.security.*;

public class myDigest {

  public static void main(String[] args)  {

    myDigest my=new myDigest();

    my.testDigest();

  }

  public void testDigest()

  {

   try {

     String myinfo="我的測試訊息";

    //java.security.MessageDigest alg=java.security.MessageDigest.getInstance("MD5");

      java.security.MessageDigest alga=java.security.MessageDigest.getInstance("SHA-1");

      alga.update(myinfo.getBytes());

      byte[] digesta=alga.digest();

      System.out.println("本訊息摘要是:"+byte2hex(digesta));

      //透過某中方式傳給其它人你的訊息(myinfo)和摘要(digesta) 對方可以判斷是否變更或傳輸正常

      java.security.MessageDigest algb=java.security.MessageDigest.getInstance("SHA-1");

      algb.update(myinfo.getBytes());

      if (algb.isEqual(digesta,algb.digest())) {

         System.out.println("訊息檢查正常");

       }

       else

        {

          System.out.println("摘要不相同");

         }

   }

   catch (java.security.NoSuchAlgorithmException ex) {

     System.out.println("非法摘要演算法");

   }

  }

  public 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();

    }

}

   java.security.KeyPairGenerator  keygen=java.security.KeyPairGenerator.getInstance("DSA");

    如果設定亂數產生器就用下列程式碼初始化

     SecureRandom secrand=new SecureRandom();

     secrand.setSeed("tttt".getBytes()); //初始化亂數產生器

     keygen.initialize(512,secrand);     //初始化金鑰產生器

    否則

     keygen.initialize(512);

    產生公開金鑰 pubkey 和 私密金鑰 prikey

      KeyPair keys=keygen.generateKeyPair(); //產生金鑰組

      PublicKey pubkey=keys.getPublic();

      PrivateKey prikey=keys.getPrivate();

    分別儲存在myprikey.dat和mypubkey.dat中,以便下次不在產生

    (產生金鑰對的時間比較長

     java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myprikey.dat"));

     out.writeObject(prikey);

     out.close();

     out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("mypubkey.dat"));

     out.writeObject(pubkey);

     out.close();

   java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("myprikey.dat"));

    PrivateKey myprikey=(PrivateKey)in.readObject();

    in.close();

    初始一個Signature物件,並用私密金鑰對訊息簽章

     java.security.Signature signet=java.security.Signature.getInstance("DSA");

     signet.initSign(myprikey);

     signet.update(myinfo.getBytes());

     byte[] signed=signet.sign();

    把訊息和簽章儲存在一個文件中(myinfo.dat)

      java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myinfo.dat"));

      out.writeObject(myinfo);

      out.writeObject(signed);

      out.close();

    把他的公開金鑰的訊息及簽章發給其它使用者

  byte[] bobEncodedPubKey=mypublic.getEncoded(); //產生編碼

   //傳送二進位編碼

   //以下程式碼轉換編碼為相應key物件

   X509EncodedKeySpec bobPubKeySpec = new X509EncodedKeySpec(bobEncodedPubKey);

   KeyFactory keyFactory = KeyFactory.getInstance("DSA");

   PublicKey bobPubKey = keyFactory.generatePublic(bobPubKeySpec);

 byte[] bPKCS=myprikey.getEncoded();

  //傳送二進位編碼

  //以下程式碼轉換編碼為相應key物件

  PKCS8EncodedKeySpec priPKCS8=new PKCS8EncodedKeySpec(bPKCS);

  KeyFactory keyf=KeyFactory.getInstance("DSA");

  PrivateKey otherprikey=keyf.generatePrivate(priPKCS8);

 */

 import java.security.*;

 import java.security.spec.*;

public class testdsa {

  public static void main(String[] args) throws java.security.NoSuchAlgorithmException,java.lang.Exception {

        testdsa my=new testdsa();

        my.run();

  }

  public void run()

  {

  //數位簽章產生金鑰

  //第一步產生金鑰對,如果已經產生過,本過程就可以略過,對使用者來講myprikey.dat要儲存在本地

  //而mypubkey.dat給發佈給其它使用者

   if ((new java.io.File("myprikey.dat")).exists()==false) {

       if (generatekey()==false) {

           System.out.println("產生金鑰對敗");

           return;

          };

        }

//第二步,此使用者

//從文件中讀入私密金鑰,對一個字串進行簽章後儲存在一個文件(myinfo.dat)中

//並且再把myinfo.dat傳送出去

//為了方便數位簽章也放進了myifno.dat文件中,當然也可分別傳送

  try {

  java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("myprikey.dat"));

  PrivateKey myprikey=(PrivateKey)in.readObject();

  in.close();

 // java.security.spec.X509EncodedKeySpec pubX509=new java.security.spec.X509EncodedKeySpec(bX509);

 //java.security.spec.X509EncodedKeySpec pubkeyEncode=java.security.spec.X509EncodedKeySpec

  String myinfo="這是我的訊息";    //要簽章的訊息

  //用私密金鑰對訊息產生數位簽章

  java.security.Signature signet=java.security.Signature.getInstance("DSA");

  signet.initSign(myprikey);

  signet.update(myinfo.getBytes());

  byte[] signed=signet.sign();  //對訊息的數位簽章

  System.out.println("signed(簽章內容)="+byte2hex(signed));

 //把訊息和數位簽章儲存在一個文件中

  java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myinfo.dat"));

  out.writeObject(myinfo);

  out.writeObject(signed);

  out.close();

  System.out.println("簽章並產生文件成功");

  }

  catch (java.lang.Exception e) {

    e.printStackTrace();

    System.out.println("簽章並產生文件失敗");

  };

  //第三步

  //其它人透過公用方式得到此戶的公開金鑰和文件

  //其它人用此戶的公開金鑰,對文件進行檢查,如果成功說明是此使用者發佈的訊息.

  //

  try {

   java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("mypubkey.dat"));

   PublicKey pubkey=(PublicKey)in.readObject();

   in.close();

   System.out.println(pubkey.getFormat());

   in=new java.io.ObjectInputStream(new java.io.FileInputStream("myinfo.dat"));

   String info=(String)in.readObject();

   byte[] signed=(byte[])in.readObject();

   in.close();

  java.security.Signature signetcheck=java.security.Signature.getInstance("DSA");

  signetcheck.initVerify(pubkey);

  signetcheck.update(info.getBytes());

  if (signetcheck.verify(signed)) {

  System.out.println("info="+info);

   System.out.println("簽章正常");

  }

  else  System.out.println("非簽章正常");

  }

  catch (java.lang.Exception e) {e.printStackTrace();};

  }

  //產生一對文件myprikey.dat和mypubkey.dat---私密金鑰和公開金鑰,

  //公開金鑰要使用者傳送(文件,網路等方法)給其它使用者,私密金鑰儲存在本地

  public boolean generatekey()

  {

    try {

  java.security.KeyPairGenerator  keygen=java.security.KeyPairGenerator.getInstance("DSA");

 // SecureRandom secrand=new SecureRandom();

 // secrand.setSeed("tttt".getBytes()); //初始化亂數產生器

 // keygen.initialize(576,secrand);     //初始化金鑰產生器

  keygen.initialize(512);

  KeyPair keys=keygen.genKeyPair();

//  KeyPair keys=keygen.generateKeyPair(); //產生金鑰組

  PublicKey pubkey=keys.getPublic();

  PrivateKey prikey=keys.getPrivate();

  java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myprikey.dat"));

  out.writeObject(prikey);

  out.close();

  System.out.println("寫入物件 prikeys ok");

  out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("mypubkey.dat"));

   out.writeObject(pubkey);

   out.close();

   System.out.println("寫入物件 pubkeys ok");

   System.out.println("產生金鑰對成功");

   return true;

  }

  catch (java.lang.Exception e) {

   e.printStackTrace();

   System.out.println("產生金鑰對失敗");

   return false;

   };

  }

  public 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();

    }

}

   SecretKey deskey = keygen.generateKey();

   byte[] desEncode=deskey.getEncoded();

   javax.crypto.spec.SecretKeySpec destmp=new javax.crypto.spec.SecretKeySpec(desEncode,Algorithm);

   SecretKey mydeskey=destmp;

public static final Cipher getInstance(java.lang.String transformation)

                                throws java.security.NoSuchAlgorithmException,

                                       NoSuchPaddingException

public final byte[] doFinal(byte[] input)

                     throws java.lang.IllegalStateException,

                            IllegalBlockSizeException,

                            BadPaddingException

/*

安全程式 DESede/DES測試

*/

import java.security.*;

import javax.crypto.*;

public class testdes {

public static void main(String[] args){

    testdes my=new testdes();

    my.run();

  }

public  void run() {

//加入新安全演算法,如果用JCE就要把它加入進去

 Security.addProvider(new com.sun.crypto.provider.SunJCE());

String Algorithm="DES"; //定義 加密演算法,可用方法如右 DES,DESede(TripleDES),AES,Blowfish,RC2,RC4(ARCFOUR)

String myinfo="要加密的訊息";

   try {

   //產生金鑰

   KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);

   SecretKey deskey = keygen.generateKey();

   //加密

   System.out.println("加密前的二進串:"+byte2hex(myinfo.getBytes()));

   System.out.println("加密前的訊息:"+myinfo);

   Cipher c1 = Cipher.getInstance(Algorithm);

   c1.init(Cipher.ENCRYPT_MODE,deskey);

   byte[] cipherByte=c1.doFinal(myinfo.getBytes());

    System.out.println("加密後的二進串:"+byte2hex(cipherByte));

   //解密

   c1 = Cipher.getInstance(Algorithm);

   c1.init(Cipher.DECRYPT_MODE,deskey);

   byte[] clearByte=c1.doFinal(cipherByte);

   System.out.println("解密後的二進串:"+byte2hex(clearByte));

   System.out.println("解密後的訊息:"+(new String(clearByte)));

  }

   catch (java.security.NoSuchAlgorithmException e1) {e1.printStackTrace();}

   catch (javax.crypto.NoSuchPaddingException e2) {e2.printStackTrace();}

   catch (java.lang.Exception e3) {e3.printStackTrace();}

  }

 public 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();

    }

}

System.out.println("ALICE: 產生 DH 對 ...");

KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");

 aliceKpairGen.initialize(512);

KeyPair aliceKpair = aliceKpairGen.generateKeyPair();

byte[] alicePubKeyEnc = aliceKpair.getPublic().getEncoded();

   DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();

    KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");

    bobKpairGen.initialize(dhParamSpec);

    KeyPair bobKpair = bobKpairGen.generateKeyPair();

   KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");

    bobKeyAgree.init(bobKpair.getPrivate());

    bobKeyAgree.doPhase(alicePubKey, true);

    SecretKey bobDesKey = bobKeyAgree.generateSecret("DES");

      byte[] bobPubKeyEnc = bobKpair.getPublic().getEncoded();

       ,,,,,,解碼

    KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");

    aliceKeyAgree.init(aliceKpair.getPrivate());

    aliceKeyAgree.doPhase(bobPubKey, true);

    SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES");

import java.io.*;

import java.math.BigInteger;

import java.security.*;

import java.security.spec.*;

import java.security.interfaces.*;

import javax.crypto.*;

import javax.crypto.spec.*;

import javax.crypto.interfaces.*;

import com.sun.crypto.provider.SunJCE;

public class testDHKey {

    public static void main(String argv[]) {

        try {

            testDHKey my= new testDHKey();

            my.run();

        } catch (Exception e) {

            System.err.println(e); 

        }

    }

    private void run() throws Exception {

        Security.addProvider(new com.sun.crypto.provider.SunJCE());

    System.out.println("ALICE: 產生 DH 對 ...");

    KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");

        aliceKpairGen.initialize(512);

    KeyPair aliceKpair = aliceKpairGen.generateKeyPair(); //產生時間長

        // 張三(Alice)產生公開金鑰 alicePubKeyEnc 並傳送給李四(Bob) ,

        //比如用文件方式,socket.....

    byte[] alicePubKeyEnc = aliceKpair.getPublic().getEncoded();

       //bob接收到alice的編碼後的公開金鑰,將其解碼

    KeyFactory bobKeyFac = KeyFactory.getInstance("DH");

    X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec  (alicePubKeyEnc);

    PublicKey alicePubKey = bobKeyFac.generatePublic(x509KeySpec);

        System.out.println("alice公開金鑰bob解碼成功");

     // bob必須用相同的參數初始化的他的DH KEY對,所以要從Alice發給他的公開金鑰,

         //中讀出參數,再用這個參數初始化他的 DH key對

         //從alicePubKye中取alice初始化時用的參數

    DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();

    KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");

    bobKpairGen.initialize(dhParamSpec);

    KeyPair bobKpair = bobKpairGen.generateKeyPair();

        System.out.println("BOB: 產生 DH key 對成功");

    KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");

    bobKeyAgree.init(bobKpair.getPrivate());

        System.out.println("BOB: 初始化本地key成功");

        //李四(bob) 產生本地的金鑰 bobDesKey

    bobKeyAgree.doPhase(alicePubKey, true);

    SecretKey bobDesKey = bobKeyAgree.generateSecret("DES");

    System.out.println("BOB: 用alice的公開金鑰搜尋本地key,產生本地DES金鑰成功");

        // Bob產生公開金鑰 bobPubKeyEnc 並傳送給Alice,

        //比如用文件方式,socket.....,使其產生本地金鑰

    byte[] bobPubKeyEnc = bobKpair.getPublic().getEncoded();

        System.out.println("BOB向ALICE傳送公開金鑰");

         // alice接收到 bobPubKeyEnc後產生bobPubKey

         // 再進行搜尋,使aliceKeyAgree搜尋在bobPubKey

    KeyFactory aliceKeyFac = KeyFactory.getInstance("DH");

    x509KeySpec = new X509EncodedKeySpec(bobPubKeyEnc);

    PublicKey bobPubKey = aliceKeyFac.generatePublic(x509KeySpec);

       System.out.println("ALICE接收BOB公開金鑰並解碼成功");

;

    KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");

    aliceKeyAgree.init(aliceKpair.getPrivate());

        System.out.println("ALICE: 初始化本地key成功");

    aliceKeyAgree.doPhase(bobPubKey, true);

        // 張三(alice) 產生本地的金鑰 aliceDesKey

    SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES");

        System.out.println("ALICE: 用bob的公開金鑰搜尋本地key,並產生本地DES金鑰");

        if (aliceDesKey.equals(bobDesKey)) System.out.println("張三和李四的金鑰相同");

       //現在張三和李四的本地的deskey是相同的所以,完全可以進行傳送加密,接收後解密,達到

       //安全通道的的目的

        /*

         * bob用bobDesKey金鑰加密訊息

         */

    Cipher bobCipher = Cipher.getInstance("DES");

    bobCipher.init(Cipher.ENCRYPT_MODE, bobDesKey);

        String bobinfo= "這是李四的機密訊息";

        System.out.println("李四加密前原文:"+bobinfo);

    byte[] cleartext =bobinfo.getBytes();

    byte[] ciphertext = bobCipher.doFinal(cleartext);

        /*

         * alice用aliceDesKey金鑰解密

         */

    Cipher aliceCipher = Cipher.getInstance("DES");

    aliceCipher.init(Cipher.DECRYPT_MODE, aliceDesKey);

    byte[] recovered = aliceCipher.doFinal(ciphertext);

        System.out.println("alice解密bob的訊息:"+(new String(recovered)));

    if (!java.util.Arrays.equals(cleartext, recovered))

        throw new Exception("解密後與原文訊息不同");

    System.out.println("解密後相同");

    }

}