bt下載與小說520

MPL License，允許免費重發布、免費修改，但要求修改后的代碼版權歸軟件的發起者。這種授權維護了商業軟件的利益，，它要求基于這種軟件得修改無償貢獻版權給該軟件。這樣，圍繞該軟件得所有代碼得版權都集中在發起開發人得手中。但MPL是允許修改，無償使用得。MPL軟件對鏈接沒有要求。

SD開源協議

BSD開源協議是一個給于使用者很大自由的協議。可以自由的使用，修改源代碼，也可以將修改后的代碼作為開源或者專有軟件再發布。 當你發布使用了BSD協議的代碼，或則以BSD協議代碼為基礎做二次開發自己的產品時，需要滿足三個條件：

1. 如果再發布的產品中包含源代碼，則在源代碼中必須帶有原來代碼中的BSD協議。

2. 如果再發布的只是二進制類庫/軟件，則需要在類庫/軟件的文檔和版權聲明中包含原來代碼中的BSD協議。

3. 不可以用開源代碼的作者/機構名字和原來產品的名字做市場推廣。

BSD代碼鼓勵代碼共享，但需要尊重代碼作者的著作權。BSD由于允許使用者修改和重新發布代碼，也允許使用或在BSD代碼上開發商業軟件發布和銷售，因此是對商業集成很友好的協議。而很多的公司企業在選用開源產品的時候都首選BSD協議，因為可以完全控制這些第三方的代碼，在必要的時候可以修改或者二次開發。

Apache Licence 2.0

Apache Licence是著名的非盈利開源組織Apache采用的協議。該協議和BSD類似，同樣鼓勵代碼共享和尊重原作者的著作權，同樣允許代碼修改，再發布(作為開源或商業軟件)。需要滿足的條件：

1. 需要給代碼的用戶一份Apache Licence

2. 如果你修改了代碼，需要再被修改的文件中說明。

3. 在延伸的代碼中(修改和有源代碼衍生的代碼中)需要帶有原來代碼中的協議，商標，專利聲明和其他原來作者規定需要包含的說明。

4. 如果再發布的產品中包含一個Notice文件，則在Notice文件中需要帶有Apache Licence。你可以在Notice中增加自己的許可，但不可以表現為對Apache Licence構成更改。

Apache Licence也是對商業應用友好的許可。使用者也可以在需要的時候修改代碼來滿足需要并作為開源或商業產品發布/銷售。

GPL

GPL許可證是自由軟件的應用最廣泛的軟件許可證，人們可以修改程式的一個或幾個副本或程式的任何部分，以此形成基於這些程式的衍生作品。必須在修改過的檔案中附有明顯的說明：您修改了此一檔案及任何修改的日期。 您必須讓您發布或出版的作品，包括本程式的全部或一部分，或內含本程式的全部或部分所衍生的作品，允許第三方在此許可證條款下使用，并且不得因為此項授權行為而收費。

LGPL

Linux就是采用了GPL。GPL協議和BSD, Apache Licence等鼓勵代碼重用的許可很不一樣。GPL的出發點是代碼的開源/免費使用和引用/修改/衍生代碼的開源/免費使用，但不允許修改后和衍生的代碼做為閉源的商業軟件發布和銷售。這也就是為什么我們能用免費的各種linux，包括商業公司的linux和linux上各種各樣的由個人，組織，以及商業軟件公司開發的免費軟件了。

GPL協議的主要內容是只要在一個軟件中使用(“使用”指類庫引用，修改后的代碼或者衍生代碼)GPL協議的產品，則該軟件產品必須也采用GPL協議，既必須也是開源和免費。這就是所謂的”傳染性”。GPL協議的產品作為一個單獨的產品使用沒有任何問題，還可以享受免費的優勢。

由于GPL嚴格要求使用了GPL類庫的軟件產品必須使用GPL協議，對于使用GPL協議的開源代碼，商業軟件或者對代碼有保密要求的部門就不適合集成/采用作為類庫和二次開發的基礎。

其它細節如再發布的時候需要伴隨GPL協議等和BSD/Apache等類似。

Public Domain

公共域授權。將軟件授權為公共域，這些軟件包沒有授權協議，任何人都可以隨意使用它。

Artistic許可

使作者保持對進一步開發的控制。

  參考與資料


COfundOS - 一個討論開源軟件，尋找投資的平臺。 http://www.5a520.cn
Mac Yenta - 獨立 Mac 開發者的社會化網絡平臺
CorkDump - 一個關于常用資源（代碼片段，CSS，Flash 等）討論板。
All Developers Network - 開發者社會化網絡
CodePlex - 來自微軟的開源項目托管站點


UnmatchList - 開發設計者的資源庫
developerAnalytics - 社會媒體評價與報告，幫助你發現有潛力的社會媒體應用。
CollabFinder - 一個供開發設計者協同工作的地方。
測試，監控，Bug 跟蹤，項目管理



CloudStatus - 對 Web 上最流行云服務進行觀察

BetaBitz - 一個幫助你尋找 Beta 測試者的地方

observu - 免費的網站與服務器監測服務

UserFix - Bug 報告與功能請求站點

OctaGate SiteTimer - 用來測試你的站點的訪問時延



Cuzillion - 簡單的頁面測試與檢查程序

Mob4Hire - 為你的移動應用程序需要大量測試者

Beanstalk - 一個托管的服務，用來瀏覽跟蹤版本控制，包含對Basecamp 以及 Campfire 等同類服務的集成。

BUGtrack - 項目管理，Bug 跟蹤

UserZoom - 用戶體驗測試平臺


devunity - 曾是一個 Beta 版 Bug 跟蹤服務，現已成為社會化開發平臺
BuiltWith - 對任何站點提供技術分析與 SEO 信息服務
fixx - Bug 跟蹤，包含移動設備界面與協同功能
BugWiki - 一個簡易的 Bug 跟蹤系統
litmus - 基于 Web 的測試程序，在不同瀏覽器上檢查你的設計


Bugtagger - 一個包含標簽機制的 Bug 跟蹤程序，方便找到每個 Bug 是與什么相關的
FEED Validator - 驗證你的 Atom, RSS 以及 KML 聚合服務
pastebin - Debug 工具允許你協同工作以找到問題所在
JUnit.org - 一個測試框架，編寫并執行自動測試程序
  Ruby 以及 Ruby on Rails 資源與工具


Open Source Rails - 一個用來展示基于開源 Ruby on Rails 站點的地方
Exceptional - Rails 程序異常跟蹤與管理工具
TuneUp - 使用 Rails 插件檢查你的程序的性能
heroku - Ruby on Rails平臺，無需安裝配置，直接在瀏覽器中寫代碼。
RSpec 1.1.8 - Ruby 的開發框架，包括 Scenario 框架與代碼示例框架



Lovd By Less - 一個開源的 Ruby on Rails 社會網絡平臺
Merb - 一個 Ruby 框架，包含廣泛功能
Camping - 一個 Ruby 微框架
  Ajax, Java & JavaScript 資源與工具


Javxs - 在線工具，將 HTML 轉換為 JavaScript
frevvo - 一個 Ajax 表單創建工具，包括 XML 支持與拖放式控制
AjaxDaddy - Ajax 程序演示
WaveMaker - 可視化，開源 Ajax 所見即所得編輯器
AppJet - JavaScript 程序編寫平臺



SproutCore - 一個 JavaScript 框架，用來創建桌面質量的 Web 程序
Bungee Connect - Ajax Web 程序平臺，跨瀏覽器支持
Spring - 企業 Java 應用平臺，旨在提高開發效率與程序質量
jQuery - 一個用于 Ajax Web 開發的 JavaScript 庫。
KSS - 使用該框架，無需編寫任何代碼就可以開發基于 javaScript 的 UI
    PHP 資源與工具


Flow3 - 一個最初用于 TYPO3 5.0 的 PHP 框架，但可以獨立使用
Prado - 一個基于組件的 PHP 5 編程框架，面向對象，事件驅動
  Perl 資源與工具


Mason - 基于 Perl 的 網站開發引擎，包含 Debug, 模板等工具
  Flash 資源與工具


OpenLaszlo - 富 Internet 平臺，結合 Flash 與 DHTML，但只需一次編寫
  Python 資源與工具


GTK+ - 一個用于 Python 的 GUI 開發工具套件
Wing IDE - 專業的 Python 開發環境，提供30天試用
Cheetah - 一個開源的，基于 Python 的模板引擎與代碼生成工具

Web 程序創建類


DreamFace - 一個用來創建個性化 Web 程序的框架。

Organic Incentive - 以拖放式界面創建 Web 飾件 http://www.5a520.cn

dbFLEX - 商務程序開發平臺。

app2you - 在線創建與定制 Web 程序。

Qrimp - 一個便宜的數據庫平臺，基于你周圍的數據（如 Excel）創建應用程序。





Lightspoke - 拖放式程序創建工具，動態過濾，排序，真正的關系數據庫后臺。

Tersus - 可視化程序創建工具，無需編寫代碼。

Qt - 跨平臺應用程序框架，可以同時開發應用與界面。


代碼庫與代碼搜索




byteMyCode - 代碼搜索

Snipplr - 幫你存儲，管理所有代碼片段。

ErrorKey - 錯誤代碼搜索引擎。

findJAR.com - JAR 文件搜索

github - 代碼庫，既支持公共代碼，又支持私人代碼，私人代碼通過 SSH 以及 SSL 訪問。



merobase - 搜索組件。

Codebase - 代碼庫，技術支持與安裝部署跟蹤程序。

CONFiles - 配置文件的在線存儲與分享

CodeSnippets - 公共代碼庫，也支持私人代碼

GWT-Ext - 免費的，可下載的飾件庫


開發環境，平臺與框架


SocialGO - 社會化網絡托管平臺，包括消息，視頻聊天，會員資料，照片分享，博客等
Pringo - 社會化網絡平臺，功能包括視頻，MP3 支持，圖片庫，圈子，podcasting 等。
slinkset - 一個用于創建社會化新聞站點的在線平臺
iWidgets - 社會化 Syndication 平臺，允許你將你的內容聚合到社會化網絡
WackWall - 一個 Hosted 的社會化網絡平臺




WhiteLabelDating.com - 一個創建約會，社會網絡，社區站點的平臺，允許以自己公司的名義創建。
ONEsite - 社會網絡平臺，包括博客，照片與視頻庫，評分與標簽，消息板，私人消息等
jinity - 免費的社會網絡平臺，包括消息板，聊天，圈子，日志，投票，新聞等
Magnify.net - 網站視頻工具，包括全套媒體工具
ShoutEm - 微博客與社會網絡平臺



Soceeo - 社會網絡平臺，包含文件分享，新聞，投票等
Swift - 移動站點創建工具，包括多種設計選項，支持 RSS Feed，多媒體等
SnappVille - 社會網絡平臺，包括組，博客工具，即時消息等
Ning - 社會網絡平臺，允許使用自己的品牌，包括會員資料，事件列表，甚至 Facebook 集成。
mixxt - 社會網絡平臺，包括事件，論壇等
zembly - 一個用來創建社會應用的的平臺，目前處于 Beta 版。Yuku - 一個社區平臺，可定制，擁有很強大的系統管理工具SocialEngine - 基于 PHP 的社會網絡平臺，功能包括 multi-part profiles，子網，搜索友好 URL，博客，圈子等。Cappuccino - 一個用來創建桌面品質 Web 程序的開源框架Jaws - 一個用戶友好 CMS 平臺。   綜合開發工具


Tabifier - 對你的代碼進行自動縮進。
Sms2do - 一個用來評測和演示 SMS 程序的免費工具。
Pretty Printer - 源代碼格式化工具，支持 PHP, JavaScript, CSS 等
Jitterbit - 一個開源集成方案，提高可擴充性與性能
Bitizer - 二進制，十進制，16進制，Base 36 以及 ASCII 轉換工具



thmbnl - 顯示你站點中那些鏈接網頁的縮略圖
ID Selector - 一個 OpenID 工具
consoleFISH - 免費的，基于 Web 的 SSH 服務器訪問
form site - 用來創建自定義表單
99Polls - 用來創建投票與調查



Warehouse - 一個非常漂亮的代碼庫瀏覽服務，支持多代碼庫以及非常完善的權限控制
rendur 2.1 - 一個沙箱程，讓你一邊寫代碼，一邊生成頁面
Languify - 翻譯管理系統
ROR Sitemap Generator - 顧名思義，這是一個 ROR 網站地圖生成工具
MicroMaps - 用來生成交互式地圖，放在你的網站



Newsfeed Maker - 為你的網站或博客創建 News Feed
WriteMaps - 網站地圖在線生成工具
Project Kenai - 免費的開源項目或代碼托管站點
Launch Splash - 為你還沒有開通的網站免費生成一個歡迎頁面
Browser Shell - 基于瀏覽器的 SSH 工具
foigo - 創建自定義表單，調查，以及數據庫AggData - Premade lists for your development projects.SnapCasa - 網站縮略圖工具Versionshelf - 代碼庫安全管理   Mashups 與 APIs


The Echo Nest - 音樂相關的開發服務 API，包括歌手資料，音樂推薦等功能
Zeep Mobile - 為你的站點添加基于文本的消息系統
Clickatell - 一個短消息網關，讓你的網站通過多中連接方式發短消息
Nonoba - 在線游戲開發 API，支持多玩家。
Zong - 移動支付平臺，包含開發 API



Web Shots Pro - 一個 API，開發者可用來在他們的程序中添加網站縮略圖。
Pushpin - 一個簡單易用的在線地圖 API，支持大量標記以及眾多其它功能
Datamash - Create widgets and mashups for your site with information anywhere on the Web.借助網絡上的眾多信息為你的站點創建 widgets 與 mashups
Spicy Pipes - Mashup builder.

TreeMap是紅黑樹算法的實現,實現了SortedMap接口,要注意的是它不在使用哈希表,存儲方式是一個特殊的二叉樹,有關紅黑樹:
http://baike.baidu.com/view/133754.htm  http://www.bt285.cn

這篇文章介紹的不錯,我之前沒有聽說過二叉樹,我就是看這篇文章加上看一下TreeMap的源代碼才搞懂紅黑樹算法的.

這里不打算研究TreeMap的源代碼了,因為完全是一個算法的實現,如果對這個算法不了解,肯定看不懂,我也有很多地方不是沒有完全看明白,這里就談談TreeMap的使用吧.

TreeMap的聲明:public class TreeMap extends AbstractMap implements SortedMap,Cloneable, java.io.Serializable
所以我們要知道SortedMap接口:
SortedMap表示的是一個排序的Map
public interface SortedMap extends Map
增加了幾個方法的定義
SortedMap headMap(Object toKey)
SortedMap tailMap(Object fromKey)
SortedMap subMap(Object fromKey, Object toKey)
Object firstKey()
Object lastKey()

既然TreeMap是有序的,自然要求元素是可以比較大小的,如果構造函數指定Comparator的話,就使用這個Comparator比較大小,如果沒有指定Comparator的話,就使用自然排序(元素要實現Comparable接口).如果這兩個都不可用,就等著出錯吧.

現看一下該接口的定義:
public interface Comparable{
   public int compareTo(Object o);
}
該接口定義類的自然順序,實現該接口的類就可以按這種方式排序.
一般要求:
e1.equals((Object)e2)和e1.compareTo((Object)e2)==0具有相同的值,
這樣的話我們就稱自然順序就和equals一致.
這個接口有什么用呢?
如果數據或者List中的元素實現了該接口的話,我們就可以調用Collections.sort或者Arrays方法給他們排序.

如果自然順序和equals不一致的話,如果出現在Sorted Map和Set里面,
就會出現預想不到的邏輯錯誤,可能你調用add的時候添加不了,而集合里面確沒有這個元素.具體的討論要接口哈希表的應用.

public interface Comparator {
　　int compare(Object o1, Object o2);
　　boolean equals(Object obj);
}
定義了兩個方法,其實我們一般都只需要實現compare方法就行了,因為類都是默認從Object繼承
所以會使用Object的equals方法.
Comparator一般都作為一個匿名類出現,對于沒有實現Comparable的對象的集合,排序的時候
需要指定一個Comparator.

這里舉例說明
對于實現了Comparable的類我們就用最簡單的Integer
List list=new ArrayList();
list.add(new Integer(3));
list.add(new Integer(53));
list.add(new Integer(34));
Collections.sort(list);

對于沒有實現Comparable的,我們就用Object,按照hashCode大小來排序.
List list= new ArrayList();
list.add(new Object());
list.add(new Object());
list.add(new Object());
Collections.sort(list,new Comparator(){ public int compare(Object o1, Object o2){
　　　　　　　　　　　　　　　　　　　　return (o1.hashCode()-o2.hashCode());
})

因為是二叉樹,所以一般查找時間復雜度為 o(lg(n)),這個效率當然沒有HashMap的效率高.不過TreeMap比HashMap功能強大,如果不需要排序的話當然不會用TreeMap,如果需要排序的話,HashMap無法勝任,當然要用TreeMap了,它可以求子Map.所以這個是適用場合問題,無法比較他們.
 
另外,我們也習慣了,有Map就會跟一個Set,我們都可以猜到TreeSet和通過TreeMap實現的一個SortedSet的實現.不過我覺的TreeSet好像比TreeMap用的場合多一些,求子集是很常用的呀!!

以前我一直以為File#renameTo(File)方法與OS下面的 move/mv 命令是相同的，可以達到改名、移動文件的目的。不過后來經常發現問題，真的很bt,File#renameTo(File)方法會返回失敗(false)，文件沒有移動，又查不出原因，再后來干脆棄用該方法，自己實現一個copy方法，問題倒是再也沒有出現過。

昨天老板同學又遇到這個問題，File#renameTo(File)方法在windows下面工作的好好的，在linux下偶爾又失靈了。回到家我掃了一遍JDK中File#renameTo(File)方法的源代碼，發現它調用的是一個本地的方法(native method)，無法再跟蹤下去。網上有人說該方法在window下是正常的，在linux下面是不正常的。這個很難說通，SUN不可能搞出這種平臺不一致的代碼出來啊。

后面在SUN的官方論壇上看到有人提到這個問題“works on windows, don't work on linux”，后面有人回復說是“file systems”不一樣。究竟怎么不一樣呢？還是沒有想出來...

后面在一個論壇里面發現了某人關于這個問題的闡述：
In the Unix'esque O/S's you cannot renameTo() across file systems. This behavior is different than the Unix "mv" command. When crossing file systems mv does a copy and delete which is what you'll have to do if this is the case.

The same thing would happen on Windows if you tried to renameTo a different drive, i.e. C: -> D:
終于明白咯。

做個實驗：

File sourceFile = new File("c:/test.txt");
File targetFile1 = new File("e:/test.txt");
File targetFile2 = new File("d:/test.txt");
System.out.println("source file is exist? " + sourceFile.exists()
+ ", source file => " + sourceFile);
System.out.println(targetFile1 + " is exist? " + targetFile1.exists());
System.out.println("rename to " + targetFile1 + " => "
+ sourceFile.renameTo(targetFile1));
System.out.println("source file is exist? " + sourceFile.exists()
+ ", source file => " + sourceFile);
System.out.println(targetFile2 + " is exist? " + targetFile2.exists());
System.out.println("rename to " + targetFile2 + " => "
+ sourceFile.renameTo(targetFile2));

注意看結果，從C盤到E盤失敗了，從C盤到D盤成功了。因為我的電腦C、D兩個盤是NTFS格式的，而E盤是FAT32格式的。所以從C到E就是上面文章所說的"file systems"不一樣。從C到D由于同是NTFS分區，所以不存在這個問題，當然就成功了。

果然是不能把File#renameTo(File)當作move方法使用。

可以考慮使用apache組織的commons-io包里面的FileUtils#copyFile(File,File)和FileUtils#copyFileToDirectory(File,File)方法實現copy的效果。至于刪除嘛，我想如果要求不是那么精確，可以調用File#deleteOnExit()方法，在虛擬機終止的時候，刪除掉這個目錄或文件。

BTW:File是文件和目錄路徑名的抽象表示形式，所以有可能是目錄，千萬小心。
下面我寫的一個實現方法

/**
  * 使用FileChannel拷貝文件
  *
  * @param srcFile
  * @param destFile
  * @throws IOException
  */
 public static void copyUseChannel(File srcFile, File destFile)
   throws IOException {
  if ((!srcFile.exists()) || (srcFile.isDirectory())) {
   return;
  }

  if (!destFile.exists()) {
   createFile(destFile.getAbsolutePath());
  }

  FileChannel out = null;
  FileChannel in = null;
  try {
   out = new FileOutputStream(destFile).getChannel();
   in = new FileInputStream(srcFile).getChannel();
   ByteBuffer buffer = ByteBuffer.allocate(102400);
   int position = 0;
   int length = 0;
   while (true) {
    length = in.read(buffer, position);
    if (length <= 0) {
     break;
    }
    // System.out.println("after read:"+buffer);
    buffer.flip();
    // System.out.println("after flip:"+buffer);
    out.write(buffer, position);
    position += length;
    buffer.clear();
    // System.out.println("after clear:"+buffer);
   }

  } finally {
   if (out != null) {
    out.close();
   }
   if (in != null) {
    in.close();
   }
  }
 }

第1章基礎知識

1.1. 單鑰密碼體制

單鑰密碼體制是一種傳統的加密算法，是指信息的發送方和接收方共同使用同一把密鑰進行加解密。

通常,使用的加密算法比較簡便高效,密鑰簡短，加解密速度快，破譯極其困難。但是加密的安全性依靠密鑰保管的安全性,在公開的計算機網絡上安全地傳送和保管密鑰是一個嚴峻的問題，并且如果在多用戶的情況下密鑰的保管安全性也是一個問題。

單鑰密碼體制的代表是美國的DES

1.2. 消息摘要

一個消息摘要就是一個數據塊的數字指紋。即對一個任意長度的一個數據塊進行計算，產生一個唯一指印（對于SHA1是產生一個20字節的二進制數組）。

消息摘要有兩個基本屬性：

• 兩個不同的報文難以生成相同的摘要
• 難以對指定的摘要生成一個報文，而由該報文反推算出該指定的摘要

代表：美國國家標準技術研究所的SHA1和麻省理工學院Ronald Rivest提出的MD5

1.3. Diffie-Hellman密鑰一致協議

密鑰一致協議是由公開密鑰密碼體制的奠基人Diffie和Hellman所提出的一種思想。

先決條件,允許兩名用戶在公開媒體上交換信息以生成"一致"的,可以共享的密鑰

代表：指數密鑰一致協議(Exponential Key Agreement Protocol)

1.4. 非對稱算法與公鑰體系

1976年，Dittie和Hellman為解決密鑰管理問題，在他們的奠基性的工作"密碼學的新方向"一文中，提出一種密鑰交換協議，允許在不安全的媒體上通過通訊雙方交換信息，安全地傳送秘密密鑰。在此新思想的基礎上，很快出現了非對稱密鑰密碼體制，即公鑰密碼體制。在公鑰體制中，加密密鑰不同于解密密鑰，加密密鑰公之于眾，誰都可以使用；解密密鑰只有解密人自己知道。它們分別稱為公開密鑰（Public key）和秘密密鑰（Private key）。

迄今為止的所有公鑰密碼體系中，RSA系統是最著名、最多使用的一種。RSA公開密鑰密碼系統是由R.Rivest、A.Shamir和L.Adleman俊教授于1977年提出的。RSA的取名就是來自于這三位發明者的姓的第一個字母

1.5. 數字簽名

所謂數字簽名就是信息發送者用其私鑰對從所傳報文中提取出的特征數據（或稱數字指紋）進行RSA算法操作，以保證發信人無法抵賴曾發過該信息（即不可抵賴性），同時也確保信息報文在經簽名后末被篡改（即完整性）。當信息接收者收到報文后，就可以用發送者的公鑰對數字簽名進行驗證。　

在數字簽名中有重要作用的數字指紋是通過一類特殊的散列函數（HASH函數）生成的，對這些HASH函數的特殊要求是：

1. 接受的輸入報文數據沒有長度限制；
2. 對任何輸入報文數據生成固定長度的摘要（數字指紋）輸出
3. 從報文能方便地算出摘要；
4. 難以對指定的摘要生成一個報文，而由該報文反推算出該指定的摘要；
5. 兩個不同的報文難以生成相同的摘要

代表：DSA

回頁首

第2章在JAVA中的實現

2.1. 相關

Diffie-Hellman密鑰一致協議和DES程序需要JCE工具庫的支持,可以到 http://java.sun.com/security/index.html  或是www.bt285.cn 下載JCE,并進行安裝。簡易安裝把 jce1.2.1\lib 下的所有內容復制到 %java_home%\lib\ext下,如果沒有ext目錄自行建立,再把jce1_2_1.jar和sunjce_provider.jar添加到CLASSPATH內,更詳細說明請看相應用戶手冊

2.2. 消息摘要MD5和SHA的使用

使用方法:

首先用生成一個MessageDigest類,確定計算方法

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

添加要進行計算摘要的信息

alga.update(myinfo.getBytes());

計算出摘要

byte[] digesta=alga.digest();

發送給其他人你的信息和摘要

其他人用相同的方法初始化,添加信息,最后進行比較摘要是否相同

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

相關AIP

java.security.MessageDigest 類

static getInstance(String algorithm)

返回一個MessageDigest對象,它實現指定的算法

參數:算法名,如 SHA-1 或MD5

void update (byte input)

void update (byte[] input)

void update(byte[] input, int offset, int len)

添加要進行計算摘要的信息

byte[] digest()

完成計算,返回計算得到的摘要(對于MD5是16位,SHA是20位)

void reset()

復位

static boolean isEqual(byte[] digesta, byte[] digestb)

比效兩個摘要是否相同

代碼：

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

2.3. 數字簽名DSA

1. 對于一個用戶來講首先要生成他的密鑰對,并且分別保存

   生成一個KeyPairGenerator實例

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

   
   
   
2. 用他私人密鑰(prikey)對他所確認的信息(info)進行數字簽名產生一個簽名數組

   從文件中讀入私人密鑰(prikey)

   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(); 把他的公鑰的信息及簽名發給其它用戶

   
   
   
3. 其他用戶用他的公共密鑰(pubkey)和簽名(signed)和信息(info)進行驗證是否由他簽名的信息

   讀入公鑰
   java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("mypubkey.dat"));
PublicKey pubkey=(PublicKey)in.readObject();
in.close();

   讀入簽名和信息
   in=new java.io.ObjectInputStream(new java.io.FileInputStream("myinfo.dat"));
String info=(String)in.readObject();
byte[] signed=(byte[])in.readObject();
in.close();

   初始一個Signature對象,并用公鑰和簽名進行驗證
   java.security.Signature signetcheck=java.security.Signature.getInstance("DSA");
signetcheck.initVerify(pubkey);
signetcheck.update(info.getBytes());
if (signetcheck.verify(signed)) { System.out.println("簽名正常");}

   對于密鑰的保存本文是用對象流的方式保存和傳送的,也可可以用編碼的方式保存.注意要
   import java.security.spec.*
import java.security.*

   具休說明如下

   • public key是用X.509編碼的,例碼如下:

     byte[] bobEncodedPubKey=mypublic.getEncoded(); //生成編碼 //傳送二進制編碼 //以下代碼轉換編碼為相應key對象 X509EncodedKeySpec bobPubKeySpec = new X509EncodedKeySpec(bobEncodedPubKey); KeyFactory keyFactory = KeyFactory.getInstance("DSA"); PublicKey bobPubKey = keyFactory.generatePublic(bobPubKeySpec);

     
     
     
   • 對于Private key是用PKCS#8編碼,例碼如下:

     byte[] bPKCS=myprikey.getEncoded(); //傳送二進制編碼 //以下代碼轉換編碼為相應key對象 PKCS8EncodedKeySpec priPKCS8=new PKCS8EncodedKeySpec(bPKCS); KeyFactory keyf=KeyFactory.getInstance("DSA"); PrivateKey otherprikey=keyf.generatePrivate(priPKCS8);

     
     
   
   
4. 常用API

   java.security.KeyPairGenerator 密鑰生成器類
   public static KeyPairGenerator getInstance(String algorithm) throws NoSuchAlgorithmException
   以指定的算法返回一個KeyPairGenerator 對象
   參數: algorithm 算法名.如:"DSA","RSA"

   public void initialize(int keysize)

   以指定的長度初始化KeyPairGenerator對象,如果沒有初始化系統以1024長度默認設置

   參數:keysize 算法位長.其范圍必須在 512 到 1024 之間，且必須為 64 的倍數

   public void initialize(int keysize, SecureRandom random)
   以指定的長度初始化和隨機發生器初始化KeyPairGenerator對象
   參數:keysize 算法位長.其范圍必須在 512 到 1024 之間，且必須為 64 的倍數
   random 一個隨機位的來源(對于initialize(int keysize)使用了默認隨機器

   public abstract KeyPair generateKeyPair()
   產生新密鑰對

   java.security.KeyPair 密鑰對類
   public PrivateKey getPrivate()
   返回私鑰

   public PublicKey getPublic()
   返回公鑰

   java.security.Signature 簽名類
   public static Signature getInstance(String algorithm) throws NoSuchAlgorithmException
   返回一個指定算法的Signature對象
   參數 algorithm 如:"DSA"

   public final void initSign(PrivateKey privateKey)
   throws InvalidKeyException
   用指定的私鑰初始化
   參數:privateKey 所進行簽名時用的私鑰

   public final void update(byte data)
   throws SignatureException
   public final void update(byte[] data)
   throws SignatureException
   public final void update(byte[] data, int off, int len)
   throws SignatureException
   添加要簽名的信息

   public final byte[] sign()
   throws SignatureException
   返回簽名的數組,前提是initSign和update

   public final void initVerify(PublicKey publicKey)
   throws InvalidKeyException
   用指定的公鑰初始化
   參數:publicKey 驗證時用的公鑰

   public final boolean verify(byte[] signature)
   throws SignatureException
   驗證簽名是否有效,前提是已經initVerify初始化
   參數: signature 簽名數組

   */ 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(); } }

   
   
   

2.4. DESede/DES對稱算法

首先生成密鑰,并保存(這里并沒的保存的代碼,可參考DSA中的方法)

KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);

SecretKey deskey = keygen.generateKey();

用密鑰加密明文(myinfo),生成密文(cipherByte)

Cipher c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.ENCRYPT_MODE,deskey);

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

傳送密文和密鑰,本文沒有相應代碼可參考DSA

.............

用密鑰解密密文

c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.DECRYPT_MODE,deskey);

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

相對來說對稱密鑰的使用是很簡單的,對于JCE來講支技DES,DESede,Blowfish三種加密術

對于密鑰的保存各傳送可使用對象流或者用二進制編碼,相關參考代碼如下

   SecretKey deskey = keygen.generateKey();
            byte[] desEncode=deskey.getEncoded();
            javax.crypto.spec.SecretKeySpec destmp=new javax.crypto.spec.SecretKeySpec(desEncode,Algorithm);
               SecretKey mydeskey=destmp;

相關API

KeyGenerator 在DSA中已經說明,在添加JCE后在instance進可以如下參數

DES,DESede,Blowfish,HmacMD5,HmacSHA1

javax.crypto.Cipher 加/解密器

public static final Cipher getInstance(java.lang.String transformation)
            throws java.security.NoSuchAlgorithmException,
            NoSuchPaddingException

返回一個指定方法的Cipher對象

參數:transformation 方法名(可用 DES,DESede,Blowfish)

public final void init(int opmode, java.security.Key key)
throws java.security.InvalidKeyException

用指定的密鑰和模式初始化Cipher對象

參數:opmode 方式(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)

key 密鑰

public final byte[] doFinal(byte[] input)
            throws java.lang.IllegalStateException,
            IllegalBlockSizeException,
            BadPaddingException
            

對input內的串,進行編碼處理,返回處理后二進制串,是返回解密文還是加解文由init時的opmode決定

注意:本方法的執行前如果有update,是對updat和本次input全部處理,否則是本inout的內容

/*
            安全程序 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,Blowfish
            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();
            }
            }

2.5. Diffie-Hellman密鑰一致協議

公開密鑰密碼體制的奠基人Diffie和Hellman所提出的 "指數密鑰一致協議"(Exponential Key Agreement Protocol),該協議不要求別的安全性先決條件,允許兩名用戶在公開媒體上交換信息以生成"一致"的,可以共享的密鑰。在JCE的中實現用戶alice生成DH類型的密鑰對,如果長度用1024生成的時間請,推薦第一次生成后保存DHParameterSpec,以便下次使用直接初始化.使其速度加快

System.out.println("ALICE: 產生 DH 對 ...");
            KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");
            aliceKpairGen.initialize(512);
            KeyPair aliceKpair = aliceKpairGen.generateKeyPair();

alice生成公鑰發送組bob

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

bob從alice發送來的公鑰中讀出DH密鑰對的初始參數生成bob的DH密鑰對

注意這一步一定要做,要保證每個用戶用相同的初始參數生成的

   DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();
            KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");
            bobKpairGen.initialize(dhParamSpec);
            KeyPair bobKpair = bobKpairGen.generateKeyPair();

bob根據alice的公鑰生成本地的DES密鑰

   KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");
            bobKeyAgree.init(bobKpair.getPrivate());
            bobKeyAgree.doPhase(alicePubKey, true);
            SecretKey bobDesKey = bobKeyAgree.generateSecret("DES");

bob已經生成了他的DES密鑰,他現把他的公鑰發給alice,

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

alice根據bob的公鑰生成本地的DES密鑰

       ,,,,,,解碼
            KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");
            aliceKeyAgree.init(aliceKpair.getPrivate());
            aliceKeyAgree.doPhase(bobPubKey, true);
            SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES");

bob和alice能過這個過程就生成了相同的DES密鑰,在這種基礎就可進行安全能信

常用API

java.security.KeyPairGenerator 密鑰生成器類
public static KeyPairGenerator getInstance(String algorithm)
throws NoSuchAlgorithmException
以指定的算法返回一個KeyPairGenerator 對象
參數: algorithm 算法名.如:原來是DSA,現在添加了 DiffieHellman(DH)

public void initialize(int keysize)
以指定的長度初始化KeyPairGenerator對象,如果沒有初始化系統以1024長度默認設置
參數:keysize 算法位長.其范圍必須在 512 到 1024 之間，且必須為 64 的倍數
注意:如果用1024生長的時間很長,最好生成一次后就保存,下次就不用生成了

public void initialize(AlgorithmParameterSpec params)
throws InvalidAlgorithmParameterException
以指定參數初始化

javax.crypto.interfaces.DHPublicKey
public DHParameterSpec getParams()
返回
java.security.KeyFactory

public static KeyFactory getInstance(String algorithm)
throws NoSuchAlgorithmException
以指定的算法返回一個KeyFactory
參數: algorithm 算法名:DSH,DH

public final PublicKey generatePublic(KeySpec keySpec)
throws InvalidKeySpecException
根據指定的key說明,返回一個PublicKey對象

java.security.spec.X509EncodedKeySpec
public X509EncodedKeySpec(byte[] encodedKey)
根據指定的二進制編碼的字串生成一個key的說明
參數:encodedKey 二進制編碼的字串(一般能過PublicKey.getEncoded()生成)
javax.crypto.KeyAgreement 密碼一至類

public static final KeyAgreement getInstance(java.lang.String algorithm)
throws java.security.NoSuchAlgorithmException
返回一個指定算法的KeyAgreement對象
參數:algorithm 算法名,現在只能是DiffieHellman(DH)

public final void init(java.security.Key key)
throws java.security.InvalidKeyException
用指定的私鑰初始化
參數:key 一個私鑰

public final java.security.Key doPhase(java.security.Key key,
boolean lastPhase)
throws java.security.InvalidKeyException,
java.lang.IllegalStateException
用指定的公鑰進行定位,lastPhase確定這是否是最后一個公鑰,對于兩個用戶的
情況下就可以多次定次,最后確定
參數:key 公鑰
lastPhase 是否最后公鑰

public final SecretKey generateSecret(java.lang.String algorithm)
throws java.lang.IllegalStateException,
java.security.NoSuchAlgorithmException,
java.security.InvalidKeyException
根據指定的算法生成密鑰
參數:algorithm 加密算法(可用 DES,DESede,Blowfish)

*/
            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("解密后相同");
            }
            }

一、Java編碼是怎么回事？

對于使用中文以及其他非拉丁語系語言的開發人員來說，經常會遇到字符集編碼問題。對于Java語言來說，在其內部使用的是UCS2編碼（2個字節的Unicode編碼）。這種編碼并不屬于某個語系的語言編碼，它實際上是一種編碼格式的世界語。在這個世界上所有可以在計算機中使用的語言都有對應的UCS2編碼。

正是因為Java采用了UCS2，因此，在Java中可以使用世界上任何國家的語言來為變量名、方法名、類起名，如下面代碼如下：

    哈哈，是不是有點象“中文編程”。實際上，也可以使用其他的語言來編程，如下面用韓文和日文來定義個類：

class ???
{
    public void スーパーマン() {  }
}

    實際上，由于Java內部使用的是UCS2編碼格式，因為，Java并不關心所使用的是哪種語言，而只要這種語言在UCS2中有定義就可以。

    在UCS2編碼中為不同國家的語言進行了分頁，這個分頁也叫“代碼頁”或“編碼頁”。中文根據包含中文字符的多少，分了很多代碼頁，如cp935、cp936等，然而，這些都是在UCS2中的代碼頁名，而對于操作系統來說，如微軟的windows，一開始的中文編碼為GB2312，后來擴展成了GBK。其實GBK和cp936是完全等效的，用它們哪個都行。

二、Java編碼轉換

    上面說了這么多，在這一部分我們做一些編碼轉換，看看會發生什么事情。

    先定義一個字符串變量：

    String gbk = "中國"; // “中國”在Java內部是以UCS2格式保存的

    用下面的語言輸出一定會輸出中文：

System.out.println(gbk);

    實現上，當我們從IDE輸入“中國”時，用的是java源代碼文件保存的格式，一般是GBK，有時也可是utf-8，而在Java編譯程序時，會不由分說地將所有的編碼格式轉換成utf-8編碼，讀者可以用UltraEdit或其他的二進制編輯器打開上面的“中國.class”，看看所生成的二進制是否有utf-8的編碼（utf-8和ucs2之間的轉換非常容易，因為utf-8和ucs2之間是用公式進行轉換的，而不是到代碼頁去查，這就相當于將二進制轉成16進制一樣，4個字節一組）。如“中國”的utf-8編碼按著GBK解析就是“涓  浗”。如下圖所示。

如果使用下面的語言可以獲得“中國”的utf-8字節，結果是6（一個漢字由3個字節組成）

System.out.println(gbk.getBytes("utf-8").length);

下面的代碼將輸出“涓  浗”。

System.out.println(new String(gbk.getBytes("utf-8"), "gbk"));   

由于將“中國“的utf-8編碼格式按著gbk解析，所以會出現亂碼。

如果要返回中文的UCS2編碼，可以使用下面的代碼：

System.out.println(gbk.getBytes("unicode")[2]);

System.out.println(gbk.getBytes("unicode")[3]);

前兩個字節是標識位，要從第3個字節開始。還有就是其他的語言使用的編碼的字節順序可能不同，如在C#中可以使用下面的代碼獲得“中國“的UCS2編碼：

String s = "中";

MessageBox.Show(ASCIIEncoding.Unicode.GetBytes(s)[0].ToString());

MessageBox.Show(ASCIIEncoding.Unicode.GetBytes(s)[1].ToString());

    使用上面的java代碼獲得的“中“的16進制UCS2編碼為4E2D，而使用C#獲得的相應的ucs2編碼為2D4E，這只是C#和Java編碼內部使用的問題，并沒有什么關系。但在C#和Java互操作時要注意這一點。

    如果使用下面的java編碼將獲得16進制的“中”的GBK編碼：

System.out.println(Integer.toHexString(0xff & xyz.getBytes("gbk")[0]));

System.out.println(Integer.toHexString(0xff & xyz.getBytes("gbk")[1]));

“中”的ucs2編碼為2D4E，GBK編碼為D6D0

    讀者可訪問如下的url自行查驗：

    http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP936.TXT

    當然，感興趣的讀者也可以試試其他語言的編碼，如“人類”的韓語是“???”，如下面的代碼將輸出“???”的cp949和ucs2編碼，其中cp949是韓語的代碼頁。

上面代碼的輸出結果如下：

c7

78

c0

ce

    也就是說“?”的ucs2編碼為C778，cp949的編碼為C0CE，要注意的是，在cp949中，ucs2編碼也有C0CE，不要弄混了。讀者可以訪問下面的url來驗證：

http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP949.TXT

http://www.bt285.cn/content.php?id=1196863

Java支持的編碼格式

三、屬性文件

Java中的屬性文件只支持iso-8859-1編碼格式，因此，要想在屬性文件中保存中文，就必須使用UCS2編碼格式（"uxxxx），因此，出現了很多將這種編碼轉換成可視編碼和工具，如Eclipse中的一些屬性文件編輯插件。

實際上，"uxxxx編碼格式在java和C#中都可以使用，如下面的語句所示：

String name= ""u7528"u6237"u540d"u4e0d"u80fd"u4e3a"u7a7a" ;

System.out.println(name);

    上面的代碼將輸出如下結果：

\u7528\u6237\u540d\u4e0d\u80fd\u4e3a\u7a7a

    好了，現在可以利用這個技術來實現一個屬性文件編輯器了。

四、Web中的編碼問題

    下面是個Servlet：

    如果中main.jsp中輸入中文后，向MyPost提交，在控制臺中會輸出“中å?½”，一看就是亂碼。如果將IE的當前編碼設成其他的，如由utf-8改為gbk，仍然會出現亂碼，只是亂得不一樣而已。這是因為客戶端提交數據時是根據瀏覽器當前的編碼格式來提交的，如瀏覽器當前為gbk編碼，就以gbk編碼格式來提交。 這本身是不會出現亂碼的，問題就出在Web服務器接收數據的時候，HttpServletRequest在將客戶端傳來的數據轉成ucs2碼上出了問題。在默認情況下，是按著iso-8859-1編碼格式來轉的，而這種編碼格式并不支持中文，所以也就無法正常顯示中文了，解決這個問題的方法是用和客戶端瀏覽器當前編碼格式一致的編碼來轉換，如果是utf-8，則在doPost方法中應該用以下的語句來處理：

    request.setCharacterEncoding("utf-8");

    為了對每一個Servlet都起作用，可以將上面的語句加到filter里。