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里。