BlogJava-xiaomage234-随笔分类-securityhttp://www.blogjava.net/xiaomage234/category/34729.html生命本就是一次凄美的漂流，记忆中放不下的，永远是孩提时代的那一份浪漫与纯真！zh-cnSat, 14 Sep 2013 06:02:43 GMTSat, 14 Sep 2013 06:02:43 GMT60HTTP摘要認證http://www.blogjava.net/xiaomage234/archive/2013/09/13/404036.html小马歌小马歌Fri, 13 Sep 2013 04:05:00 GMThttp://www.blogjava.net/xiaomage234/archive/2013/09/13/404036.htmlhttp://www.blogjava.net/xiaomage234/comments/404036.htmlhttp://www.blogjava.net/xiaomage234/archive/2013/09/13/404036.html#Feedback0http://www.blogjava.net/xiaomage234/comments/commentRss/404036.htmlhttp://www.blogjava.net/xiaomage234/services/trackbacks/404036.html阅读全文

小马歌 2013-09-13 12:05 发表评论
]]>浅谈CSRF攻击方式http://www.blogjava.net/xiaomage234/archive/2013/04/24/398349.html小马歌小马歌Wed, 24 Apr 2013 09:00:00 GMThttp://www.blogjava.net/xiaomage234/archive/2013/04/24/398349.htmlhttp://www.blogjava.net/xiaomage234/comments/398349.htmlhttp://www.blogjava.net/xiaomage234/archive/2013/04/24/398349.html#Feedback0http://www.blogjava.net/xiaomage234/comments/commentRss/398349.htmlhttp://www.blogjava.net/xiaomage234/services/trackbacks/398349.html浅谈CSRF攻击方式2009-04-09 22:44 by hyddd, 18997 阅读, 39 评论, 收藏, 编辑

一.CSRF是什么？

　　CSRF（Cross-site request forgery），中文名称：跨站请求伪造，也被称为：one click attack/session riding，缩写为：CSRF/XSRF。

二.CSRF可以做什么？

　　你这可以这么理解CSRF攻击：攻击者盗用了你的身份，以你的名义发送恶意请求。CSRF能够做的事情包括：以你名义发送邮件，发消息，盗取你的账号，甚至于购买商品，虚拟货币转账......造成的问题包括：个人隐私泄露以及财产安全。

三.CSRF漏洞现状

　　CSRF这种攻击方式在2000年已经被国外的安全人员提出，但在国内，直到06年才开始被关注，08年，国内外的多个大型社区和交互网站分别爆出CSRF漏洞，如：NYTimes.com（纽约时报）、Metafilter（一个大型的BLOG网站），YouTube和百度HI......而现在，互联网上的许多站点仍对此毫无防备，以至于安全业界称CSRF为“沉睡的巨人”。

四.CSRF的原理

　　下图简单阐述了CSRF攻击的思想：

　　

　　从上图可以看出，要完成一次CSRF攻击，受害者必须依次完成两个步骤：

　　1.登录受信任网站A，并在本地生成Cookie。

　　2.在不登出A的情况下，访问危险网站B。

　　看到这里，你也许会说：“如果我不满足以上两个条件中的一个，我就不会受到CSRF的攻击”。是的，确实如此，但你不能保证以下情况不会发生：

　　1.你不能保证你登录了一个网站后，不再打开一个tab页面并访问另外的网站。

　　2.你不能保证你关闭浏览器了后，你本地的Cookie立刻过期，你上次的会话已经结束。（事实上，关闭浏览器不能结束一个会话，但大多数人都会错误的认为关闭浏览器就等于退出登录/结束会话了......）

　　3.上图中所谓的攻击网站，可能是一个存在其他漏洞的可信任的经常被人访问的网站。

 

　　上面大概地讲了一下CSRF攻击的思想，下面我将用几个例子详细说说具体的CSRF攻击，这里我以一个银行转账的操作作为例子（仅仅是例子，真实的银行网站没这么傻:>）

　　示例1：

　　银行网站A，它以GET请求来完成银行转账的操作，如：http://www.mybank.com/Transfer.php?toBankId=11&money=1000

　　危险网站B，它里面有一段HTML的代码如下：

　　<img src=http://www.mybank.com/Transfer.php?toBankId=11&money=1000>

　　首先，你登录了银行网站A，然后访问危险网站B，噢，这时你会发现你的银行账户少了1000块......

　　为什么会这样呢？原因是银行网站A违反了HTTP规范，使用GET请求更新资源。在访问危险网站B的之前，你已经登录了银行网站A，而B中的<img>以GET的方式请求第三方资源（这里的第三方就是指银行网站了，原本这是一个合法的请求，但这里被不法分子利用了），所以你的浏览器会带上你的银行网站A的Cookie发出Get请求，去获取资源“http://www.mybank.com/Transfer.php?toBankId=11&money=1000”，结果银行网站服务器收到请求后，认为这是一个更新资源操作（转账操作），所以就立刻进行转账操作......

　　示例2：

　　为了杜绝上面的问题，银行决定改用POST请求完成转账操作。

　　银行网站A的WEB表单如下：　　

　　<form action="Transfer.php" method="POST">
　　　　<p>ToBankId: <input type="text" name="toBankId" /></p>
　　　　<p>Money: <input type="text" name="money" /></p>
　　　　<p><input type="submit" value="Transfer" /></p>
　　</form>

　　后台处理页面Transfer.php如下：

复制代码
　　<?php
　　　　session_start();
　　　　if (isset($_REQUEST['toBankId'] &&　isset($_REQUEST['money']))
　　　　{
　　　　    buy_stocks($_REQUEST['toBankId'],　$_REQUEST['money']);
　　　　}
　　?>
复制代码

　　危险网站B，仍然只是包含那句HTML代码：

　　<img src=http://www.mybank.com/Transfer.php?toBankId=11&money=1000>

　　和示例1中的操作一样，你首先登录了银行网站A，然后访问危险网站B，结果.....和示例1一样，你再次没了1000块～T_T，这次事故的原因是：银行后台使用了$_REQUEST去获取请求的数据，而$_REQUEST既可以获取GET请求的数据，也可以获取POST请求的数据，这就造成了在后台处理程序无法区分这到底是GET请求的数据还是POST请求的数据。在PHP中，可以使用$_GET和$_POST分别获取GET请求和POST请求的数据。在JAVA中，用于获取请求数据request一样存在不能区分GET请求数据和POST数据的问题。

　　示例3：

　　经过前面2个惨痛的教训，银行决定把获取请求数据的方法也改了，改用$_POST，只获取POST请求的数据，后台处理页面Transfer.php代码如下：

复制代码
　　<?php
　　　　session_start();
　　　　if (isset($_POST['toBankId'] &&　isset($_POST['money']))
　　　　{
　　　　    buy_stocks($_POST['toBankId'],　$_POST['money']);
　　　　}
　　?>
复制代码

　　然而，危险网站B与时俱进，它改了一下代码：

复制代码
<html>
　　<head>
　　　　<script type="text/javascript">
　　　　　　function steal()
　　　　　　{
          　　　　 iframe = document.frames["steal"];
　　     　　      iframe.document.Submit("transfer");
　　　　　　}
　　　　</script>
　　</head>

　　<body onload="steal()">
　　　　<iframe name="steal" display="none">
　　　　　　<form method="POST" name="transfer"　action="http://www.myBank.com/Transfer.php">
　　　　　　　　<input type="hidden" name="toBankId" value="11">
　　　　　　　　<input type="hidden" name="money" value="1000">
　　　　　　</form>
　　　　</iframe>
　　</body>
</html>
复制代码

如果用户仍是继续上面的操作，很不幸，结果将会是再次不见1000块......因为这里危险网站B暗地里发送了POST请求到银行!

　　总结一下上面3个例子，CSRF主要的攻击模式基本上是以上的3种，其中以第1,2种最为严重，因为触发条件很简单，一个<img>就可以了，而第3种比较麻烦，需要使用JavaScript，所以使用的机会会比前面的少很多，但无论是哪种情况，只要触发了CSRF攻击，后果都有可能很严重。

　　理解上面的3种攻击模式，其实可以看出，CSRF攻击是源于WEB的隐式身份验证机制！WEB的身份验证机制虽然可以保证一个请求是来自于某个用户的浏览器，但却无法保证该请求是用户批准发送的！

五.CSRF的防御

　　我总结了一下看到的资料，CSRF的防御可以从服务端和客户端两方面着手，防御效果是从服务端着手效果比较好，现在一般的CSRF防御也都在服务端进行。

　　1.服务端进行CSRF防御

　　服务端的CSRF方式方法很多样，但总的思想都是一致的，就是在客户端页面增加伪随机数。

　　(1).Cookie Hashing(所有表单都包含同一个伪随机值)：

　　这可能是最简单的解决方案了，因为攻击者不能获得第三方的Cookie(理论上)，所以表单中的数据也就构造失败了:>

　　<?php
　　　　//构造加密的Cookie信息
　　　　$value = “DefenseSCRF”;
　　　　setcookie(”cookie”, $value, time()+3600);
　　?>

　　在表单里增加Hash值，以认证这确实是用户发送的请求。

复制代码
　　<?php
　　　　$hash = md5($_COOKIE['cookie']);
　　?>
　　<form method=”POST” action=”transfer.php”>
　　　　<input type=”text” name=”toBankId”>
　　　　<input type=”text” name=”money”>
　　　　<input type=”hidden” name=”hash” value=”<?=$hash;?>”>
　　　　<input type=”submit” name=”submit” value=”Submit”>
　　</form>
复制代码

　　然后在服务器端进行Hash值验证

复制代码
      <?php
　　      if(isset($_POST['check'])) {
     　　      $hash = md5($_COOKIE['cookie']);
          　　 if($_POST['check'] == $hash) {
               　　 doJob();
　　           } else {
　　　　　　　　//...
          　　 }
　　      } else {
　　　　　　//...
　　      }
      ?>
复制代码

　　这个方法个人觉得已经可以杜绝99%的CSRF攻击了，那还有1%呢....由于用户的Cookie很容易由于网站的XSS漏洞而被盗取，这就另外的1%。一般的攻击者看到有需要算Hash值，基本都会放弃了，某些除外，所以如果需要100%的杜绝，这个不是最好的方法。
　　(2).验证码

　　这个方案的思路是：每次的用户提交都需要用户在表单中填写一个图片上的随机字符串，厄....这个方案可以完全解决CSRF，但个人觉得在易用性方面似乎不是太好，还有听闻是验证码图片的使用涉及了一个被称为MHTML的Bug，可能在某些版本的微软IE中受影响。

　　(3).One-Time Tokens(不同的表单包含一个不同的伪随机值)

　　在实现One-Time Tokens时，需要注意一点：就是“并行会话的兼容”。如果用户在一个站点上同时打开了两个不同的表单，CSRF保护措施不应该影响到他对任何表单的提交。考虑一下如果每次表单被装入时站点生成一个伪随机值来覆盖以前的伪随机值将会发生什么情况：用户只能成功地提交他最后打开的表单，因为所有其他的表单都含有非法的伪随机值。必须小心操作以确保CSRF保护措施不会影响选项卡式的浏览或者利用多个浏览器窗口浏览一个站点。

　　以下我的实现:

　　1).先是令牌生成函数(gen_token())：

复制代码
     <?php
     function gen_token() {
　　　　//这里我是贪方便，实际上单使用Rand()得出的随机数作为令牌，也是不安全的。
　　　　//这个可以参考我写的Findbugs笔记中的《Random object created and used only once》
          $token = md5(uniqid(rand(), true));
          return $token;
     }
复制代码

　　2).然后是Session令牌生成函数(gen_stoken())：

复制代码
     <?php
     　　function gen_stoken() {
　　　　　　$pToken = "";
　　　　　　if($_SESSION[STOKEN_NAME]  == $pToken){
　　　　　　　　//没有值，赋新值
　　　　　　　　$_SESSION[STOKEN_NAME] = gen_token();
　　　　　　}    
　　　　　　else{
　　　　　　　　//继续使用旧的值
　　　　　　}
     　　}
     ?>
复制代码

　　3).WEB表单生成隐藏输入域的函数：　　

复制代码
     <?php
　　     function gen_input() {
     　　     gen_stoken();
　　          echo “<input type=\”hidden\” name=\”" . FTOKEN_NAME . “\”
          　　     value=\”" . $_SESSION[STOKEN_NAME] . “\”> “;
     　　}
     ?>
复制代码

　　4).WEB表单结构：

复制代码
     <?php
          session_start();
          include(”functions.php”);
     ?>
     <form method=”POST” action=”transfer.php”>
          <input type=”text” name=”toBankId”>
          <input type=”text” name=”money”>
          <? gen_input(); ?>
          <input type=”submit” name=”submit” value=”Submit”>
     </FORM>
复制代码

　　5).服务端核对令牌：

　　这个很简单，这里就不再啰嗦了。

　　上面这个其实不完全符合“并行会话的兼容”的规则，大家可以在此基础上修改。

 

　　其实还有很多想写，无奈精力有限，暂且打住，日后补充，如果错漏，请指出:>

　　PS：今天下午写这篇文档的时候FF崩溃了一次，写了一半文章的全没了，郁闷好久T_T.......

　　转载请说明出处，谢谢[hyddd(http://www.cnblogs.com/hyddd/)]



小马歌 2013-04-24 17:00 发表评论
]]>图文详解Keepass使用教程http://www.blogjava.net/xiaomage234/archive/2013/04/18/398037.html小马歌小马歌Thu, 18 Apr 2013 08:45:00 GMThttp://www.blogjava.net/xiaomage234/archive/2013/04/18/398037.htmlhttp://www.blogjava.net/xiaomage234/comments/398037.htmlhttp://www.blogjava.net/xiaomage234/archive/2013/04/18/398037.html#Feedback0http://www.blogjava.net/xiaomage234/comments/commentRss/398037.htmlhttp://www.blogjava.net/xiaomage234/services/trackbacks/398037.htmlKeePass Password Safe（以下简称KeePass）是一套类似数据库管理的密码管理软件，通过密码和密钥，它能够提供一个足够安全的密码存储空间。只要你记住这一个管理密码，妥善保管好密钥文件和数据库文件，基本上可以安枕无忧了。同时KeePass也有强大的密码生成功能，绝对比你自己想的要安全。它的操作方式也极为 简单，没有复杂的步骤。

一：下载及安装
站长百科下载站最新版下载地址：http://down.zzbaike.com/download/KeePass–1257.html，下载安装包解压后双击安装文件根据安装向导就可以安装。

选择I accept意思也就是我同意，然后next（下一步），根据提示继续next就可以安装成功。
软件是英文的，安装好之后我们看到界面仍旧都是英文的，我们可以去http://keepass.info/translations.html，中下载简体中文插件复制放到安装目录下，运行软件“KeePass”，点击“View”菜单中“Change Language”命令，选择“简体中文”重新启动程序即可。


二：使用软件
经过上面的步骤，我们返回到桌面双击keepass的快捷键，就可以看到软件的语言已经变成中文的了

这样就可以方便我们的使用了。
如果是第一次使用，我们首先的是要创建数据库，也就是存放密码的数据库，KeePass将会把你的所有密码存储在这个数据库中。
单击菜单上的“文件—新建”，选择数据库存放的路径

选择一个路径来保存我们的数据库，然后点击保存，

这里需要填入数据库管理密码，并要确认密码，我们同时要勾选上密匙文件，并选择密钥的保存位置（可以选择不用密钥）。这样将来在开启数据库时就要“主密码”和“密钥文件”同时具备才行。输入完毕后点击“确定”然后点击创建

鼠标在黑色区域划过生成的密码位数在下方可以很清楚的看到，然后点击确定

在这里描述或者不描述都可以，点击确定后就进入主窗口并可以看到一条示例记录，点击示例记录在下方可以看到网址和密码并且也创建时间。

主窗口的左边是密码群组，各个群组又可建立子群组。右边是你的密码记录。密码记录收纳于不同的密码群组中。你可以使用Keepass默认的密码群组，或删除它们，创建自己的密码组。

在主窗口右边单击右键，选择“添加记录…”，就可以编辑你的记录了：记录标题，用户名，网址，密码，备注等。可以空着不填。确认后就完成了一条记录了，在主窗口右边的子窗口中看到刚才新增的密码条目。

当你再次使用这个文件时，选中该条记录，在记录上右击鼠标就可以真正使用它了。你可以将用户名拷贝后，就可以在其它的任何软件中粘贴了，还可以将用户名拖放到其它窗口中。最后，一定要记住保存密码，点击“文件->保存”，或工具栏上的保存按钮。

提示：随着数据库里的记录数目的逐步增多，通过“编辑”菜单中的“在数据库中查找”或“在此群组内查找”命令可以迅速的找到要查的信息。另外，我们可以把数据库导出为TXT、HTML、XML、CSV等格式，导入CSV、TXT、KeePass数据库等格式的文件。

三：数据库的配置

点击“文件->数据库设置…”，在弹出的窗口的选择“安全”按钮创建一个加密算法，并设置密钥的加密次数（如果选择生成密钥的话）。通常加密次数的数量级达到10万，也就足够了。

四：Keepass数据的备份
首先要备份KeePass.exe所在目录中的KeePass.ini文件。其次，备份你所保存的密码数据库文件（*.kdb）。如果你生在了密钥，还要保存密钥文件。以上文件打包后，可以放入多动存储装置中，或放入网络空间。
提示：如果用户的密码记录经常变动，那么相应的KeePass数据也要经常备份。保存好你的数据。尽管你有数不清的密码，但只需看好一个KeePass数据备份就可以了。
五：密码生成器
在添加记录时，我们可以利用密码生成器来生成复杂的密码，点击“密码”右侧的“生成”按钮，调出“密码生成器”属性框，然后，点击“确定”按钮即可自动生成随机密码。通过点击“***”按钮将密码明文显示，清楚的看到由生成器所产生的字符串。

六：Keepass常用设置

打开【工具】->【选项…】，就可以对Keepass作设置了。

在“安全”选项卡中勾上：设定锁定主窗口时间：300（自己设置适合的时间）
自动清空剪贴板时间，设置时间为3秒
“高级”选项卡中根据需要勾上适合的选项。

我们现在生活中各个方面都需要用到密码，网站，邮箱，论坛，银行卡等等，使用keepass可以方便的为我们服务记录各种不同的密码，使我们的操作更加省时高效，管理更方便安全。

版权申明： 葫芦博客(www.huluboke.com )专栏作家原创
原文地址 http://www.huluboke.com/keepass-jiaocheng/转载请保留本版权信息



小马歌 2013-04-18 16:45 发表评论
]]>为Linode VPS配置监控宝SNMP监控http://www.blogjava.net/xiaomage234/archive/2012/11/09/391076.html小马歌小马歌Fri, 09 Nov 2012 03:10:00 GMThttp://www.blogjava.net/xiaomage234/archive/2012/11/09/391076.htmlhttp://www.blogjava.net/xiaomage234/comments/391076.htmlhttp://www.blogjava.net/xiaomage234/archive/2012/11/09/391076.html#Feedback0http://www.blogjava.net/xiaomage234/comments/commentRss/391076.htmlhttp://www.blogjava.net/xiaomage234/services/trackbacks/391076.html

VPS就像一台服务器，我们需要了解它的运行状态。虽然Linode控制面板已经有了很强大的监控图标功能，但是还是不能满足大多 数人的需求。这里我给大家推荐一个名为监控宝的服务，Linode经过简单的配置可以支持SNMP监控，以图表的形式监控CPU、IO和进程，能够自动报 警，而且这一切都是免费的哦。

jiankongbao-logo

目前提供的监控项目

  1. CPU使用率，监控CPU的使用率比例，包括用户态(User)、内核态(System)、I/O等待(IOWait)、空闲(Idle)等
  2. 平均负载，监控Linux服务器的平均负载(load average)，包括最近1分钟、5分钟、15分钟等
  3. 内存使用率，监控内存使用率，对于Linux服务器，包括空闲内存、Buffer Cache、Page Cache、应用程序内存等
  4. 磁盘I/O，监控所有磁盘分区的I/O流量，包括写入和读取
  5. 网络流量，监控所有网络设备的流量，包括流入和流出
  6. 磁盘空间使用率，监控所有磁盘分区的空间使用率，包括总空间和已用空间

有关更多的内容，请访问：http://blog.jiankongbao.com/?p=133

如何在Linode的VPS上配置监控宝SNMP监控

系统环境：Centos 5.6_32

我们可以使用yum命令下载软件省去代码编译烦恼。

1）首先请关闭Centos的Selinux服务，否则会和snmp服务有冲突。关闭方法自行百度，很easy的。

2）在shell环境下，输入以下命令：

1、下载必要的SNMP组件，以及配置管理工具，差不多10M

1yum install net-snmp net-snmp-devel net-snmp-utils

2、创建监控用户，例如我创建一个用户名为jiankongbao，密码为123456的监控只读账户

1net-snmp-config --create-snmpv3-user -ro -A 1234565 jiankongbao

3、启动SNMP服务并且加入开机启动（大约耗费5M内存）

1service snmpd start chkconfig snmpd on

4、检测SNMP是否正常开启

1snmpwalk -v 3 -u jiankongbao -a MD5 -A "123456" -l authNoPriv 127.0.0.1 sysDescr

如果返回类内容，就说明SNMP服务已经配置好了。

3）配置SNMP服务安全问题

默认情况下，任何机器可以通过SNMP服务的账号密码通过UDP161端口远程获取服务器的状态，所以会对服务器安全产生威胁，除了建立账户和给账 户分配密码之外，还可以配合iptables只让监控宝的服务器访问Linode 的VPS，彻底杜绝安全隐患（账户密码+指定IP访问SNMP绝对专业级的安全）。

配置监控宝的iptables，只对监控宝的服务器开放SNMP的161（UDP）端口

1iptables -I INPUT -p udp -s 60.195.252.107 --dport 161 -j ACCEPT
2iptables -I INPUT -p udp -s 60.195.252.110 --dport 161 -j ACCEPT
3service iptables save
4service iptables restart

这样在服务器端SNMP的配置就OK了。

配置监控宝网站配置连接Linode的VPS

1）在导航条上方，添加服务器监控，如图：

填写服务器信息

名称任意，IP填写您的Linode服务器IP，服务器类型选择Linux/UNnix/Mac那一项

2）接下来填写SNMP服务的身份验证信息

snmp设置

如果按照本文配置的话，SNMP传输协议版本选择3，Security Nmae是您刚才配置的用户名，Pass Phrase是您刚才配置的密码（上文配置的是123456），验证选择MD5.

然后点击提交，监控宝会验证您Linode VPS的SNMP设置，需要稍等片刻，之后提示成功：

服务器添加成功

如果不成功请检查是否填错了用户密码或者iptables生效了没有。

3）下面选择监控项目，默认全部勾选

选择监控项目

这样的话，监控宝部分就配置完成了，过一阵子就能看到监控信息了。是不是很简单啊？

本文固定链接: http://www.limutian.com/linode-vps-configure-the-monitor-snmp/ | LMT的那些事



小马歌 2012-11-09 11:10 发表评论
]]>rsync 服务端和客户端配置http://www.blogjava.net/xiaomage234/archive/2011/11/02/362512.html小马歌小马歌Wed, 02 Nov 2011 02:32:00 GMThttp://www.blogjava.net/xiaomage234/archive/2011/11/02/362512.htmlhttp://www.blogjava.net/xiaomage234/comments/362512.htmlhttp://www.blogjava.net/xiaomage234/archive/2011/11/02/362512.html#Feedback0http://www.blogjava.net/xiaomage234/comments/commentRss/362512.htmlhttp://www.blogjava.net/xiaomage234/services/trackbacks/362512.html
   rsync的试用方法 
一、设置Rsync Server端 
Rsync server需要设定四个方面： 
1．规划建立备份目录区 
2．设定: /etc/xinetd.d/rsync 
3．设定: /etc/rsyncd.conf 
4．设定: 密码文件。 
说明如下： 
1．规划建立备份目录区： 
建议你在rsync server上开一个较大的磁盘分割区，并在其下建立好备份用的目录。比如：/home/asialinux。 
2．设定: /etc/xinetd.d/rsync： 
即#vi /etc/xinetd.d/rsync 
#default: off 
#description:The rsync server is a good addition to am ftp server,as it 
#     allows crc checksumming etc. 
service rsync 
{ 
     disable = no 
     socket_type    = stream 
     wait       = no 
     user       = root 
     server      = /usr/bin/rsync 
     server_args    = --daemon 
     log_on_failure += USERID 
} 
把其中的disable = yes 改为 disable = no之后退出保存就可以了，这还没有完成，还需启动rsync的服务。 
#service xinetd restart 
或者 
#ntsysv 
选中 
rsync确定即可。 
这样就开通了873通道（port），一旦有rsync client连接，xinetd就会把它转介给rsyncd跑port873。 
3．设定: /etc/rsyncd.conf 
如果在/etc下没有这个文件，请不要迷惑，自己创建一个不就得了，假设要备份的机器名为asialinux(IP:192.168.0.1)， 
即Samba文件服务器： 
#vi /etc/rsyncd.conf 
uid = nobody 
gid = nobody 
use chroot = no 
max connections = 4 
pid file = /var/run/rsyncd.pid 
lock file = /var/run/rsync.lock 
log file = /var/log/rsyncd.log 
secrets file = /etc/rsync.pass 
[backup] 
path = /home/server/asialinux 
auth users = feixue 
uid = root 
gid = root 
secrets file = /home/rsyncd.secrets 
read only = no 
退出vi编辑模式并保存。 
说明： 
[backup]代表欲备份的主机代号，可以和主机名相同，也可以自定。本例为backup，而没有用asialinux以便大家在下面使用rsync命令时加以理解。 
Path就是用来存放备份档案的绝对目录，请你一定要用mkdir开设好，名称自定，如本例要在/home目录下面建立server目录以及server下面的子目录asialinux。 
注：如果你没有建立目录、目录建立的不对或者路径不对，都将不能进行rsync的备份，情况如下所示： 
#rsync –rvlHopDtS --password-file=/root/rsyncd.recrets /home feixue@testsmb::backup 
@ERROR:chroot failed 
rsync:connection unexpectedly closed (75 bytes read so far) 
rsync error: error in rsync protocol data stream (code 12) at io.c(165) 
auth users代表授权的账号，名称可自定。 
secrets file代表存储账号和密码的档案路径。 
当然，大家可以在/etc/rsyncd.conf内加入更多的区块，来备份多台主机或者一台主机的多个目录等，可以灵活运用。 
4．设定:密码文件 
如果没有和ssh在一块儿运用的话，rsyncd.secrets的内容很简单，格式为 账号：密码 
例如： 
feixue:asialinux 
注：上述设定只是一个范例，请大家务必自定一组，千万不可以直接套用。 
账号和密码设定完成之后，为了安全，还要对其属主和权限进行限定，我测试过，server和client端的权限都设为000时，只要密码两者相符，依然可以正常的备份。：D 
#chown root.root rsyncd.secrets 
#chmod 600 rsyncd.secrets 
这样，我们的Rsync Server端就设定完成了，当然你可以查看rsync的记录日志档案，请参考：/var/log/rsyncd.log。 
二、设置Rsync Client端 
假设欲备份的机器名称为testsmb（IP:192.168.2.220）下的目录/home备份到Rsync Server（asialinux）上。可以做如下设定： 
1.设定密码文件 
2.测试rsync执行指令 
3.将rsync指令放入工作排程（crontab） 
说明如下： 
1.设定密码文件 
假设把密码文件放在/root/rsyncd.secrets，内容很简单，只要含有一行密码即可： 
#vi /root/rsyncd.secrets 
asialinux 
退出vi编辑模式并保存。 
注：为了安全，设定密码档案的属性为：600。rsyncd.secrets的密码一定要和Rsync Server密码设定档案里的密码一样。 
如果不同，将会出现如下的错误: 
#rsync –rvlHopDtS --password-file=/root/rsyncd.recrets /home feixue@testsmb::backup 
@ERROR: auth failed on module backup 
rsync: connection unexpectedly closed (90 bytes read so far) 
rsync error: error in rsync protocol data stream (code 12) at io.c(165) 
2. 测试rsync执行指令 
一切设定完之后，我们可以带着兴奋的心情来测试、体验一下Rsync的魅力吧：） 
# rsync –rvlHopDtS --password-file=/root/rsyncd.recrets /home feixue@testsmb::backup 
如果出现如下所示的画面，那么恭喜一下，成功了： 
上传备份 
# rsync –rvlHopDtS --password-file=/root/rsyncd.recrets /home feixue@testsmb::backup 
下载备份 
# rsync -vzrtopg --delete --password-file=/etc/rsync.pass --progress user@192.168.1.26::shanxlu /home/wenti 
building file list ... done 
.profiles/Application Data/Microsoft/Office/WEBFDR16.INF 
.profiles/Application Data/Microsoft/WELCOME/DEFAULT.WBM 
若出现如下: 
# rsync –rvlHopDtS --password-file=/root/rsyncd.recrets /home feixue@testsmb::backup 
rsync: getaddrinto: testsmb 873: Name or service not know 
rsync error: error in socket IO (code 10 ) at clientserver.c(83) 
请分别编辑Rsync Server（假设hostname为asialinux,IP:192.168.0.1）和Rsync Client（假设hostname为testsmb，IP:192.168.0.2）的/etc/hosts文件，分别加入对方的IP地址和机器名，如下: 
[root@asialinux root]#vi /etc/hosts 
192.168.0.2     testsmb 
退出vi编辑模式并保存。 
［root@testsmb root］#vi /etc/hosts 
192.168.0.1     asialinux 
退出vi编辑模式并保存。 
如果没有出现期望的画面，那么请检查一下你的设定。 
3.将rsync指令放入工作排程（crontab） 
现在可以把我们的备份工作置入排程了，假设每天凌晨1点开始备份工作： 
#crontab –u root –e 
0 1 * * * /usr/bin/rsync --password-file=/root/rsyncd.recrets /home feixue@testsmb::backup 
如果你有其他的目录需要备份，则如法炮制吧 
@rsync 试用参数: 
-h , --help 显示rsync求助资讯 
--version 顯示rsync版本 
-v , --verbose 复杂的输出信息 
-q , --quiet 安静模式，几乎没有讯息产生， 常用在以cron执行rsync 
-I, --ignore-times 通常rsync为了加快速度会忽略同样档案大小且同样,同样存取时间点的档案 
可以通过此参数开关此快速检查. 
--size-only rsync   只检查档案大小是否改变,不管时间存取点是否改变 
通常用在mirror, 且对方时间不太正确时 
-c, --checksum 在传送之前透过128bit的md4检查码来检查所有要传送的档案(会托满速度); 
-a, --archive archive mode 权限保存模式,相当于 -rlptgoD 参数. 
很快速的保存几乎所有的权限设定,除了硬式连接(透过-H设定). 
-r, --recursive 复制所有下面的资料(透过) 
-R, --relative 使用相对路径 
如: rsync foo/bar/foo.c remote:/tmp/ 在远端产生/tmp/foo.c档案 
rsync -R foo/bar/foo.c remote:/tmp/ 在远端产生/tmp/foo/bar/foo.c 档案 
-R, --relative 不使用相对路径 
-b, --backup 目的地端先前已经存在的档案在传输或删除前会被备份 
--backup-dir=DIR 设定备份的资料夹 
--suffix=SUFFIX 指定备份的档案名称字尾形式(预设为~) 
-K, --keep-dirlinks 接收方将连接到资料夹的档案视为资料夹处理 
-l, --links 复制所有的连接 
-H, --hard-links 保留硬式连结 
-p, --perms 保留档案权限 
-o, --owner 保留档案所有者(root only) 
-g, --group 保留档案群组 
-D, --devices 保留device资讯(root only) 
-t, --times 保留时间点 
-n, --dry-run 不实际执行传送, 只显示将会有的传输动作 
-S, --sparse 尝试去处理稀疏的档案, 让这些档案在目的端占去较少的磁碟空间 
-W, --whole-file 复制所有的档案, 不额外作检查 
--no-whole-file 关闭 --whole-file 参数 
-x, --one-file-system 不要跨越档案系统分界(只在一个档案系统处理) 
-B, --block-size=SIZE 强制透过rsync程式去比对修复block-sizeforce 
-e --rsh=COMMAND 定义所试用的remote shell 
--rsync-path=PATH 定义rsync在远端机器存放资料的路径 
--existing 只对比更新目的端已经存在的档案 
--ignore-existing 忽略目的断已经存在的档案(也就是不更新) 
--delete 删除传送断已经不存在,而目的端存在的档案 
--delete-excluded 除了把传送端已经不存在, 而目的端存在的档案删除之外, 也删除 --exclude 参数所包含的档案 
--delete-after rsync预设会在档案传送前进行相关删除动作确保接收端有足够的档案空间, 
单可以透过 --delete-after 让删除动作在档案传送后在进行删除 
--ignore-errors 忽略任何错误即使是I/O error 也进行 --delete 删除动作 
--max-delete=NUM 定义rsync不要删除超过NUM个档案 
--partial rsync若遇到传输过程中断时, 会把那些已经传输的档案删除. 
在某种状况下保留那些部分传送的档案是令人高兴的; 
你可以透过 --partial 参数达到这个目的. 
--partial-dir=DIR 在 --partial 参数启动时, 你还是可以定义rsync把那些部分传送的档案 
写入定义的资料夹, 而非直接写入目的端,需要注意的是, 
此资料夹不应该被其他试用者可以写入.(如:/tmp) 
--force 当目的端资料夹被传送端非资料夹名称覆盖时, 强制rsync删除资料夹, 即使该资料夹不是空的. 
--numeric-ids 不将传送端档案的uid及gid值, 与目的端的使用者/群组进行配对, 
若传送端并没有uid及gid的对应名称(如:原帐号群组被删除的遗留档案), 
或目的端没有相对应的帐号/群组, 保留数字型式的uid/gid 
--timeout=TIMEOUT 设定I/O 超时的时间(秒). 超过这个秒数而没有资料传送, rsync将会结束. 预设为0,也就是没有定义超时时间 
-T, --temp-dir=DIR 定义rsync在接收端产生暂时性的复制档案时使用资料夹暂存， 预设时直接在接收端资料夹直接产生暂存档案 
--compare-dest=DIR 定义rsync在目的端建立资料夹来比对传送过来的档案. 
--link-dest=DIR 与 --compare-dest 相同,但同时会针对无法改变的档案建立硬式连结. 
-z, --compress 压缩模式, 当资料在传送到目的端进行档案压缩. 
-P -P参数和 --partial --progress 相同.只是为了把参数简单化. 
-C, --cvs-exclude 排除那些通常不希望传送的档案, 定义的方式与CVS传送相同: 
RCS SCCS CVS CVS.adm RCSLOG cvslog.* tags TAGS .make.state 
.nse_depinfo *~ #* .#* ,* _$* *$ *.old *.bak *.BAK *.orig *.rej 
.del-* *.a *.olb *.o *.obj *.so *.exe *.Z *.elc *.ln core .svn/ 
符合以上条件的都会被忽略不传送. 
--exclude=PATTER 符合PATTERN(规则表示式)样式的档案不仅行传送 
--exclude-from=FILE 和 --exclude 参数相同, 不过是把不进行传送的档案事先写入某一档案. 
执行时, 透过此参数让rsync读取. 
(; #开头的行列或者空白会被rsync忽略) 
--include=PATTERN 定义rsync不要排除符合pattern样式的档案 
--include-from=FILE 和--include参数相同,只不过把要包含的档案写到某一档案. 
--files-from=FILE 把要传送的档案名称都精确的写入某一档案, 让rsync读取. 
如: rsync -a --files-from=/tmp/foo /usr remote:/backup 
-0 --from0 定义档案所要读取的档案时null字元结尾. 
--version 现四版本信息. 
--daemon 定义rsync以daemon型态执行 
--no-detach 当以daemon形态执行时,不要进行分裂且变成背景程序. 
--address=ADDRESS 定义所要连接(bind)的ip位置或者是host名称(daemon限定) 
--config=FILE 定义所要读取的设定档rsyncd.conf位置(daemon限定) 
预设值为 /usr/local/etc/rsyncd.conf 
--port=PORT 定义rsyncd(daemon)要旨行的port(预设为tcp 873) 
--blocking-io 使用blocking I/O连结远端的shell, 如rsh, remsh 
--no-blocking-io 使用non-blocking连结远端的shell, 如ssh(预设值) 
--stats 显示档案传送时的资讯状态 
--progress 显示传送的进度.(给档案传送时,怕无聊的人用的..) 
--log-format=FORMAT 定义log的格式(在rsyncd.conf设定) 
--password-file=FILE 从档案读取与远端rsync伺服务连结的密码 
--bwlimit=KBPS 定义传输频宽的大小(KBytes/秒) 
--write-batch=FILE 把记录资料写入一个档案(给其他相同环境且相同需求的机器试用) 
--read-batch=FILE 透过读取记录档案来进行传输.(档案由 --write-batch 参数产生) 
--checksum-seed=NUM 定义档案 checksum-seed 的大小(byte) 
-4 --ipv4 使用IPv4协定 
-6 --ipv6 使用IPv6协定 




小马歌 2011-11-02 10:32 发表评论
]]>https下弹出“本页不但包含安全的内容，也包含不安全的内容”的解决方法http://www.blogjava.net/xiaomage234/archive/2011/05/14/350240.html小马歌小马歌Sat, 14 May 2011 08:02:00 GMThttp://www.blogjava.net/xiaomage234/archive/2011/05/14/350240.htmlhttp://www.blogjava.net/xiaomage234/comments/350240.htmlhttp://www.blogjava.net/xiaomage234/archive/2011/05/14/350240.html#Feedback0http://www.blogjava.net/xiaomage234/comments/commentRss/350240.htmlhttp://www.blogjava.net/xiaomage234/services/trackbacks/350240.html通过HTTPS访问我们做的网站时，总会弹出“本页不但包含安全的内容，也包含不安全的内容”的对话框。
    这是由于网页中含有<iframe>，但iframe的src属性没有设置造成的。
    解决该问题可用如下方法： 
      客户端：设置IE的属性。例：在IE6上，工具-〉Internet选项-〉安全选项卡-〉自定义级别-〉将“显示混合内容”设置为启用 即可解决该问题。这个讨厌的对话框就不会总出现了，嘿嘿。



小马歌 2011-05-14 16:02 发表评论
]]>java非对称加密的源代码(RSA) http://www.blogjava.net/xiaomage234/archive/2008/09/19/229981.html小马歌小马歌Fri, 19 Sep 2008 09:15:00 GMThttp://www.blogjava.net/xiaomage234/archive/2008/09/19/229981.htmlhttp://www.blogjava.net/xiaomage234/comments/229981.htmlhttp://www.blogjava.net/xiaomage234/archive/2008/09/19/229981.html#Feedback0http://www.blogjava.net/xiaomage234/comments/commentRss/229981.htmlhttp://www.blogjava.net/xiaomage234/services/trackbacks/229981.html下载bcprov-jdk14-123.jar。
　　
　　import javax.crypto.Cipher;
　　import java.security.*;
　　import java.security.spec.RSAPublicKeySpec;
　　import java.security.spec.RSAPrivateKeySpec;
　　import java.security.spec.InvalidKeySpecException;
　　import java.security.interfaces.RSAPrivateKey;
　　import java.security.interfaces.RSAPublicKey;
　　import java.io.*;
　　import java.math.BigInteger;
　　
　　/**
　　* RSA 工具类。提供加密，解密，生成密钥对等方法。
　　* 需要到http://www.bouncycastle.org下载bcprov-jdk14-123.jar。
　　*
　　*/
　　public class RSAUtil {
　　
　　/**
　　* 生成密钥对
　　* @return KeyPair
　　* @throws EncryptException
　　*/
　　public static KeyPair generateKeyPair() throws EncryptException {
　　try {
　　KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA",
　　new org.bouncycastle.jce.provider.BouncyCastleProvider());
　　final int KEY_SIZE = 1024;//没什么好说的了，这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低
　　keyPairGen.initialize(KEY_SIZE, new SecureRandom());
　　KeyPair keyPair = keyPairGen.genKeyPair();
　　return keyPair;
　　} catch (Exception e) {
　　throw new EncryptException(e.getMessage());
　　}
　　}
　　/**
　　* 生成公钥
　　* @param modulus
　　* @param publicExponent
　　* @return RSAPublicKey
　　* @throws EncryptException
　　*/
　　public static RSAPublicKey generateRSAPublicKey(byte[] modulus, byte[] publicExponent) throws EncryptException {
　　KeyFactory keyFac = null;
　　try {
　　keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
　　} catch (NoSuchAlgorithmException ex) {
　　throw new EncryptException(ex.getMessage());
　　}
　　
　　RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(modulus), new BigInteger(publicExponent));
　　try {
　　return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);
　　} catch (InvalidKeySpecException ex) {
　　throw new EncryptException(ex.getMessage());
　　}
　　}
　　/**
　　* 生成私钥
　　* @param modulus
　　* @param privateExponent
　　* @return RSAPrivateKey
　　* @throws EncryptException
　　*/
　　public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus, byte[] privateExponent) throws EncryptException {
　　KeyFactory keyFac = null;
　　try {
　　keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
　　} catch (NoSuchAlgorithmException ex) {
　　throw new EncryptException(ex.getMessage());
　　}
　　
　　RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(modulus), new BigInteger(privateExponent));
　　try {
　　return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);
　　} catch (InvalidKeySpecException ex) {
　　throw new EncryptException(ex.getMessage());
　　}
　　}
　　/**
　　* 加密
　　* @param key 加密的密钥
　　* @param data 待加密的明文数据
　　* @return 加密后的数据
　　* @throws EncryptException
　　*/
　　public static byte[] encrypt(Key key, byte[] data) throws EncryptException {
　　try {
　　Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
　　cipher.init(Cipher.ENCRYPT_MODE, key);
　　int blockSize = cipher.getBlockSize();//获得加密块大小，如：加密前数据为128个byte，而key_size=1024 加密块大小为127 byte,加密后为128个byte;因此共有2个加密块，第一个127 byte第二个为1个byte
　　int outputSize = cipher.getOutputSize(data.length);//获得加密块加密后块大小
　　int leavedSize = data.length % blockSize;
　　int blocksSize = leavedSize != 0 ? data.length / blockSize + 1 : data.length / blockSize;
　　byte[] raw = new byte[outputSize * blocksSize];
　　int i = 0;
　　while (data.length - i * blockSize > 0) {
　　if (data.length - i * blockSize > blockSize)
　　cipher.doFinal(data, i * blockSize, blockSize, raw, i * outputSize);
　　else
　　cipher.doFinal(data, i * blockSize, data.length - i * blockSize, raw, i * outputSize);
　　//这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到ByteArrayOutputStream中，而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了OutputSize所以只好用dofinal方法。
　　
　　i++;
　　}
　　return raw;
　　} catch (Exception e) {
　　throw new EncryptException(e.getMessage());
　　}
　　}
　　/**
　　* 解密
　　* @param key 解密的密钥
　　* @param raw 已经加密的数据
　　* @return 解密后的明文
　　* @throws EncryptException
　　*/
　　public static byte[] decrypt(Key key, byte[] raw) throws EncryptException {
　　try {
　　Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
　　cipher.init(cipher.DECRYPT_MODE, key);
　　int blockSize = cipher.getBlockSize();
　　ByteArrayOutputStream bout = new ByteArrayOutputStream(64);
　　int j = 0;
　　
　　while (raw.length - j * blockSize > 0) {
　　bout.write(cipher.doFinal(raw, j * blockSize, blockSize));
　　j++;
　　}
　　return bout.toByteArray();
　　} catch (Exception e) {
　　throw new EncryptException(e.getMessage());
　　}
　　}
　　/**
　　*
　　* @param args
　　* @throws Exception
　　*/
　　public static void main(String[] args) throws Exception {
　　File file = new File("test.html");
　　FileInputStream in = new FileInputStream(file);
　　ByteArrayOutputStream bout = new ByteArrayOutputStream();
　　byte[] tmpbuf = new byte[1024];
　　int count = 0;
　　while ((count = in.read(tmpbuf)) != -1) {
　　bout.write(tmpbuf, 0, count);
　　tmpbuf = new byte[1024];
　　}
　　in.close();
　　byte[] orgData = bout.toByteArray();
　　KeyPair keyPair = RSAUtil.generateKeyPair();
　　RSAPublicKey pubKey = (RSAPublicKey) keyPair.getPublic();
　　RSAPrivateKey priKey = (RSAPrivateKey) keyPair.getPrivate();
　　
　　byte[] pubModBytes = pubKey.getModulus().toByteArray();
　　byte[] pubPubExpBytes = pubKey.getPublicExponent().toByteArray();
　　byte[] priModBytes = priKey.getModulus().toByteArray();
　　byte[] priPriExpBytes = priKey.getPrivateExponent().toByteArray();
　　RSAPublicKey recoveryPubKey = RSAUtil.generateRSAPublicKey(pubModBytes,pubPubExpBytes);
　　RSAPrivateKey recoveryPriKey = RSAUtil.generateRSAPrivateKey(priModBytes,priPriExpBytes);
　　
　　byte[] raw = RSAUtil.encrypt(priKey, orgData);
　　file = new File("encrypt_result.dat");
　　OutputStream out = new FileOutputStream(file);
　　out.write(raw);
　　out.close();
　　byte[] data = RSAUtil.decrypt(recoveryPubKey, raw);
　　file = new File("decrypt_result.html");
　　out = new FileOutputStream(file);
　　out.write(data);
　　out.flush();
　　out.close();
　　}
　　}
　　
　　加密可以用公钥，解密用私钥；或者加密用私钥。通常非对称加密是非常消耗资源的，因此可以对大数据用对称加密如：des（具体代码可以看我以前发的贴子），而对其对称密钥进行非对称加密，这样既保证了数据的安全，还能保证效率。

小马歌 2008-09-19 17:15 发表评论
]]>RSA算法http://www.blogjava.net/xiaomage234/archive/2008/09/19/229980.html小马歌小马歌Fri, 19 Sep 2008 09:15:00 GMThttp://www.blogjava.net/xiaomage234/archive/2008/09/19/229980.htmlhttp://www.blogjava.net/xiaomage234/comments/229980.htmlhttp://www.blogjava.net/xiaomage234/archive/2008/09/19/229980.html#Feedback0http://www.blogjava.net/xiaomage234/comments/commentRss/229980.htmlhttp://www.blogjava.net/xiaomage234/services/trackbacks/229980.html 　　RSA算法是第一个能同时用于加密和数字签名的算法，也易于理解和操作。
　　RSA是被研究得最广泛的公钥算法，从提出到现在已近二十年，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一。RSA的安全性依赖于大数的因子分解，但并没有从理论上证明破译RSA的难度与大数分解难度等价。即RSA的重大缺陷是无法从理论上把握它的保密性能如何，而且密码学界多数人士倾向于因子分解不是NPC问题。
　　RSA的缺点主要有：A)产生密钥很麻烦，受到素数产生技术的限制，因而难以做到一次一密。B)分组长度太大，为保证安全性，n 至少也要 600 bits以上，使运算代价很高，尤其是速度较慢，较对称密码算法慢几个数量级；且随着大数分解技术的发展，这个长度还在增加，不利于数据格式的标准化。目前，SET(Secure Electronic Transaction)协议中要求CA采用2048比特长的密钥，其他实体使用1024比特的密钥。
　　这种算法1978年就出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman。
　　RSA算法是一种非对称密码算法，所谓非对称，就是指该算法需要一对密钥，使用其中一个加密，则需要用另一个才能解密。
　　RSA的算法涉及三个参数，n、e1、e2。
　　其中，n是两个大质数p、q的积，n的二进制表示时所占用的位数，就是所谓的密钥长度。
　　e1和e2是一对相关的值，e1可以任意取，但要求e1与(p-1)*(q-1)互质；再选择e2，要求(e2*e1)mod((p-1)*(q-1))=1。
　　(n及e1),(n及e2)就是密钥对。
　　RSA加解密的算法完全相同,设A为明文，B为密文，则：A=B^e1 mod n；B=A^e2 mod n；
　　e1和e2可以互换使用，即：
　　A=B^e2 mod n；B=A^e1 mod n；
一、RSA 的安全性
　　RSA的安全性依赖于大数分解，但是否等同于大数分解一直未能得到理论上的证明，因为没有证明破解 RSA就一定需要作大数分解。假设存在一种无须分解大数的算法，那它肯定可以修改成为大数分解算法。目前， RSA 的一些变种算法已被证明等价于大数分解。不管怎样，分解n是最显然的攻击方法。现在，人们已能分解多个十进制位的大素数。因此，模数n 必须选大一些，因具体适用情况而定。
二、RSA的速度
　　由于进行的都是大数计算，使得RSA最快的情况也比DES慢上倍，无论是软件还是硬件实现。速度一直是RSA的缺陷。一般来说只用于少量数据加密。
三、RSA的选择密文攻击
　　RSA在选择密文攻击面前很脆弱。一般攻击者是将某一信息作一下伪装( Blind)，让拥有私钥的实体签署。然后，经过计算就可得到它所想要的信息。实际上，攻击利用的都是同一个弱点，即存在这样一个事实：乘幂保留了输入的乘法结构：
　　( XM )^d = X^d *M^d mod n
　　前面已经提到，这个固有的问题来自于公钥密码系统的最有用的特征--每个人都能使用公钥。但从算法上无法解决这一问题，主要措施有两条：一条是采用好的公钥协议，保证工作过程中实体不对其他实体任意产生的信息解密，不对自己一无所知的信息签名；另一条是决不对陌生人送来的随机文档签名，签名时首先使用One-Way HashFunction 对文档作HASH处理，或
四、RSA的公共模数攻击
　　若系统中共有一个模数，只是不同的人拥有不同的e和d，系统将是危险的。最普遍的情况是同一信息用不同的公钥加密，这些公钥共模而且互质，那末该信息无需私钥就可得到恢复。设P为信息明文，两个加密密钥为e1和e2，公共模数是n，则：
　　C1 = P^e1 mod n
　　C2 = P^e2 mod n
　　密码分析者知道n、e1、e2、C1和C2，就能得到P。
　　因为e1和e2互质，故用Euclidean算法能找到r和s，满足：
　　r * e1 + s * e2 = 1
　　假设r为负数，需再用Euclidean算法计算C1^(-1)，则
　　( C1^(-1) )^(-r) * C2^s = P mod n
　　另外，还有其它几种利用公共模数攻击的方法。总之，如果知道给定模数的一对e和d，一是有利于攻击者分解模数，一是有利于攻击者计算出其它成对的e’和d’，而无需分解模数。解决办法只有一个，那就是不要共享模数n。
　　RSA的小指数攻击。 有一种提高 RSA速度的建议是使公钥e取较小的值，这样会使加密变得易于实现，速度有
　　所提高。但这样作是不安全的，对付办法就是e和d都取较大的值。
　　RSA算法是第一个能同时用于加密和数字签名的算法，也易于理解和操作。RSA是被研究得最广泛的公钥算法，从提出到现在已近二十年，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一。RSA的安全性依赖于大数的因子分解，但并没有从理论上证明破译RSA的难度与大数分解难度等价。即RSA的重大缺陷是无法从理论上把握它的保密性能如何，而且密码学界多数人士倾向于因子分解不是NPC问题。 RSA的缺点主要有：A)产生密钥很麻烦，受到素数产生技术的限制，因而难以做到一次一密。B)分组长度太大，为保证安全性，n 至少也要 600 bits 以上，使运算代价很高，尤其是速度较慢，较对称密码算法慢几个数量级；且随着大数分解技术的发展，这个长度还在增加，不利于数据格式的标准化。目前，SET( Secure Electronic Transaction )协议中要求CA采用比特长的密钥，其他实体使用比特的密钥。

小马歌 2008-09-19 17:15 发表评论
]]>处理Java程序中的内存漏洞http://www.blogjava.net/xiaomage234/archive/2008/09/19/229979.html小马歌小马歌Fri, 19 Sep 2008 09:10:00 GMThttp://www.blogjava.net/xiaomage234/archive/2008/09/19/229979.htmlhttp://www.blogjava.net/xiaomage234/comments/229979.htmlhttp://www.blogjava.net/xiaomage234/archive/2008/09/19/229979.html#Feedback0http://www.blogjava.net/xiaomage234/comments/commentRss/229979.htmlhttp://www.blogjava.net/xiaomage234/services/trackbacks/229979.htmlJava 程序中也有内存漏洞？当然有。与流行的观念相反，在 Java 编程中，内存治理仍然是需要考虑的问题。在本文中，您将了解到什么会导致内存漏洞以及何时应该关注这些漏洞。您还有机会实践一下在您自己的项目中解决漏洞问题。
　　
　　Java 程序中的内存漏洞是如何显现出来的
　　大多数程序员都知道，使用像 Java 这样的编程语言的一大好处就是，他们不必再担心内存的分配和释放问题。您只须创建对象，当应用程序不再需要这些对象时，Java 会通过一种称为“垃圾收集”的机制将这些对象删除。这种处理意味着 Java 已经解决了困扰其他编程语言的烦人问题 -- 可怕的内存漏洞。是这样的吗？
　　
　　在深入讨论之前，我们先回顾一下垃圾收集的工作方式。垃圾收集器的工作是发现应用程序不再需要的对象，并在这些对象不再被访问或引用时将它们删除。垃圾收集器从根节点（在 Java 应用程序的整个生存周期内始终存在的那些类）开始，遍历被引用的所有节点进行清除。在它遍历这些节点的同时，它跟踪哪些对象当前正被引用着。任何类只要不再被引用，它就符合垃圾收集的条件。当删除这些对象以后，就可将它们所占用的内存资源返回给 Java 虚拟机 (JVM)。
　　
　　所以的确是这样，Java 代码不要求程序员负责内存的治理和清除，它会自动对无用的对象执行垃圾收集。但是，要紧记的一点是 仅当一个对象不再被引用时才会被统计为无用的。图 1 说明了这个概念。
　　
　

　　
图 1. 无用但仍被引用的对象

　　
　　上面说明了在 Java 应用程序执行期间具有不同生存周期的两个类。类 A 首先被实例化，并会在很长一段时间或程序的整个生存期内存在。在某个时候，类 B 被创建，类 A 添加对这个新创建的类的一个引用。现在，我们假定类 B 是某个用户界面小部件，它由用户显示甚至解除。假如没有清除类 A 对 B 的引用，则即便不再需要类 B，并且即便在执行下一个垃圾收集周期以后，类 B 仍将存在并占用内存空间。
　　
　　何时应该关注内存漏洞？
　　假如您的程序在执行一段时间以后发出 java.lang.OutOfMemoryError 错误，则内存漏洞肯定是一个重大嫌疑。除了这种明显的情况之外，何时还应该关注内存漏洞呢？持完美主义观点的程序员肯定会回答，应该查找并纠正 所有内存漏洞。但是，在得出这个结论之前，还有几个方面需要考虑，包括程序的生存期和漏洞的大小。
　　
　　完全有这样的可能，垃圾收集器在应用程序的生存期内可能始终不会运行。不能保证 JVM 何时以及是否会调用垃圾收集器 -- 即便程序显式地调用 System.gc() 也是如此。通常，在当前的可用内存能够满足程序的内存需求时，JVM 不会自动运行垃圾收集器。当可用内存不能满足需求时，JVM 将首先尝试通过调用垃圾收集来释放出更多的可用内存。假如这种尝试仍然不能释放足够的资源，JVM 将从操作系统获取更多的内存，直至达到答应的最大极限。
　　
　　例如，考虑一个小型 Java 应用程序，它显示一些用于修改配置的简单用户界面元素，并且它有一个内存漏洞。很可能到应用程序关闭时也不会调用垃圾收集器，因为 JVM 很可能有足够的内存来创建程序所需的全部对象，而此后可用内存则所剩无几。因此，在这种情况下，即使某些“死”对象在程序执行时占用着内存，它实际上并没有什么用途。
　　
　　假如正在开发的 Java 代码要全天 24 小时在服务器上运行，则内存漏洞在此处的影响就比在我们的配置实用程序中的影响要大得多。在要长时间运行的某些代码中，即使最小的漏洞也会导致 JVM 耗尽全部可用内存。
　　
　　在相反的情况下，即便程序的生存期较短，假如存在分配大量临时对象（或者若干吞噬大量内存的对象）的任何 Java 代码，而且当不再需要这些对象时也没有取消对它们的引用，则仍然可能达到内存极限。
　　
　　最后一种情况是内存漏洞无关紧要。我们不应该认为 Java 内存漏洞像其他语言（如 C++）中的漏洞那样危险，在那些语言中内存将丢失，且永远不会被返回给操作系统。在 Java 应用程序中，我们使不需要的对象依附于操作系统为 JVM 所提供的内存资源。所以从理论上讲，一旦关闭 Java 应用程序及其 JVM，所分配的全部内存将被返回给操作系统。
　　
　　确定应用程序是否有内存漏洞
　　为了查看在 Windows NT 平台上运行的某个 Java 应用程序是否有内存漏洞，您可能试图在应用程序运行时观察“任务治理器”中的内存设置。但是，在观察了运行中的几个 Java 应用程序以后，您会发现它们比本地应用程序占用的内存要多得多。我做过的一些 Java 项目要使用 10 到 20 MB 的系统内存才能启动。而操作系统自带的 Windows EXPlorer 程序只需 5 MB 左右的内存。
　　
　　在 Java 应用程序内存使用方面应注重的另一点是，这个典型程序在 IBM JDK 1.1.8 JVM 中运行时占用的系统内存越来越多。似乎直到为它分配非常多的物理内存以后它才开始向系统返回内存。这些情况是内存漏洞的征兆吗？
　　
　　要理解其中的缘由，我们必须熟悉 JVM 如何将系统内存用作它的堆。当运行 java.exe 时，您使用一定的选项来控制垃圾收集堆的起始大小和最大大小（分别用 -ms 和 -mx 表示）。Sun JDK 1.1.8 的默认起始设置为 1 MB，默认最大设置为 16 MB。IBM JDK 1.1.8 的默认最大设置为系统总物理内存大小的一半。这些内存设置对 JVM 在用尽内存时所执行的操作有直接影响。JVM 可能继续增大堆，而不等待一个垃圾收集周期的完成。
　　
　　这样，为了查找并最终消除内存漏洞，我们需要使用比任务监视实用程序更好的工具。当您试图调试内存漏洞时，内存调试程序（请参阅参考资源）可能派得上用场。这些程序通常会显示堆中的对象数、每个对象的实例数和这些对象所占用的内存等信息。此外，它们也可能提供有用的视图，这些视图可以显示每个对象的引用和引用者，以便您跟踪内存漏洞的来源。
　　
　　下面我将说明我是如何用 Sitraka Software 的 JProbedebugger 检测和去除内存漏洞的，以使您对这些工具的部署方式以及成功去除漏洞所需的过程有所了解。
　　
　　内存漏洞的一个示例
　　本例集中讨论一个问题，我们部门当时正在开发一个商业发行版软件，这是一个 Java JDK 1.1.8 应用程序，一个测试人员花了几个小时研究这个程序才最终使这个问题显现出来。这个 Java 应用程序的基本代码和包是由几个不同的开发小组在不同的时间开发的。我猜想，该应用程序中意外出现的内存漏洞是由那些没有真正理解别人开发的代码的程序员造成的。
　　
　　我们正在讨论的 Java 代码答应用户为 Palm 个人数字助理创建应用程序，而不必编写任何 Palm OS 本地代码。通过使用图形用户界面，用户可以创建窗体，向窗体中添加控件，然后连接这些控件的事件来创建 Palm 应用程序。测试人员发现，随着不断创建和删除窗体和控件，这个 Java 应用程序最终会耗尽内存。开发人员没有检测到这个问题，因为他们的机器有更多的物理内存。
　　
　　为了研究这个问题，我用 JProbe 来确定什么地方出了差错。尽管用了 JProbe 所提供的强大工具和内存快照，研究仍然是一个冗长乏味、不断重复的过程，首先要确定出现内存漏洞的原因，然后修改代码，最后还得检验结果。
　　
　　JProbe 提供几个选项，用来控制调试期间实际记录哪些信息。经过几次试验以后，我断定获取所需信息的最有效方法是，关闭性能数据收集，而将注重力集中在所捕捉的堆数据上。JProbe 提供了一个称为 Runtime Heap Summary 的视图，它显示 Java 应用程序运行时所占用的堆内存量随时间的变化。它还提供了一个工具栏按钮，必要时可以强制 JVM 执行垃圾收集。假如您试图弄清楚，当 Java 应用程序不再需要给定的类实例时，这个实例会不会被作为垃圾收集，这个功能将很有用。图 2 显示了使用中的堆存储量随时间的变化。
　　
　

　　
图 2. Runtime Heap Summary

　　
　　在 Heap Usage Chart 中，蓝色部分表明已分配的堆空间大小。在启动这个 Java 程序并达到稳定状态以后，我强制垃圾收集器运行，在图中的表现就是绿线（这条线表明插入了一个检查点）左侧的蓝线的骤降。随后，我添加了四个窗体，然后又将它们删除，并再次调用了垃圾收集器。当程序返回仅有一个可视窗体的初始状态时，检查点之后的蓝色区域高于检查点之前的蓝色区域这一情况表明可能存在内存漏洞。我通过查看 Instance Summary 证实确实有一个漏洞，因为 Instance Summary 表明 FormFrame 类（它是窗体的主用户界面类）的计数在检查点之后增加了 4。
　　
　　查找原因
　　为了将测试人员报告的问题剔出，我采取的第一个步骤是找出几个简单的、可重复的测试案例。就本例而言，我发现只须添加一个窗体，将它删除，然后强制执行垃圾收集，结果就会导致与被删除窗体相关联的许多类实例仍然处于活动状态。这个问题在 JProbe 的 Instance Summary 视图中很明显，这个视图统计每个 Java 类在堆中的实例数。
　　
　　为了查明使垃圾收集器无法正常完成其工作的那些引用，我使用 JProbe 的 Reference Graph（如图 3 所示）来确定哪些类仍然引用着目前未被删除的 FormFrame 类。在调试这个问题时该过程是最复杂的过程之一，因为我发现许多不同的对象仍然引用着这个无用的对象。用来查明究竟是哪个引用者真正造成这个问题的试错过程相当耗时。
　　
　　在本例中，一个根类（左上角用红色标明的那个类）是问题的发源地。右侧用蓝色突出显示的类处在从最初的 FormFrame 类跟踪而来的路径上。
　　


　　
图 3. 在引

资料引用:http://www.knowsky.com/365325.html



小马歌 2008-09-19 17:10 发表评论
]]>动态口令（OTP，One-Time password）http://www.blogjava.net/xiaomage234/archive/2008/09/19/229978.html小马歌小马歌Fri, 19 Sep 2008 09:07:00 GMThttp://www.blogjava.net/xiaomage234/archive/2008/09/19/229978.htmlhttp://www.blogjava.net/xiaomage234/comments/229978.htmlhttp://www.blogjava.net/xiaomage234/archive/2008/09/19/229978.html#Feedback0http://www.blogjava.net/xiaomage234/comments/commentRss/229978.htmlhttp://www.blogjava.net/xiaomage234/services/trackbacks/229978.html 　　OTP试图解决用户选择强壮密码时的一些问题。大多数OTP基于双要素认证原则运行。要认证一个系统，你需要拥有一个令牌卡和你的个人识别码(PIN personal identification number)。生成和同步密码的方法随OTP系统的不同而不同。在一种比较流行的OTP方法中，令牌卡在一个时间间隔内(通常为 60S)生成登陆密码。这个看上去随机的数字串实际上与OTP服务器和令牌上运行的数学算法紧密相关。一个由令牌生成的登录密码可能类似这样:4F40D974。PIN要么与算法一起使用生成登录密码(随后变成OTP)，要么与登陆密码一起使用。
　　使用由算法和PIN生成登录密码的系统防止个人反复嗅探网络后获得用户的PIN。OTP用以下方法改进了密码：
　　>用户再也不能选择弱密码
　　>用户只要记住PIN，而不用记住传统的强密码
　　> 一旦密码被使用一次，线路上嗅探到的密码就已经失效
　　当然没有大面积的密码系统使用OTP是有原因的，OTP也有一些缺点：
　　> 用户需要拥有令牌卡进行认证
　　>OTP需要一台额外的服务器接受来自认证服务器中继的请求
　　>使用OTP输入一个密码比输入一个用户需要记住的密码时间花费更高
　　> 在大型网络中OTP价格不菲
　　当考虑OTP总体评价时，它显然是一种有价值的技术，只是不能到处使用。大多数的机构选择将OTP用于他们安全策略中的关键系统，或用在密码破解尝试较多的地方。对于一个典型的机构，该地方以为着是财务和人力资源系统，也可以是拨号或虚拟专用网这样的远程系统。
　　动态口令，又叫动态令牌、动态密码。它的主要原理是：用户登录前，依据用户私人身份信息，并引入随机数产生随机变化的口令，使每次登录过程中传送的口令信息都不同，以提高登录过程中用户身份认证的安全性。
　　由于口令每次都变化，即使得到密码也没用，而且这种动态口令由专用算法生成，随机性高，不太容易被破解。因此，动态口令极大地提高了用户身份认证的安全性。

小马歌 2008-09-19 17:07 发表评论
]]>