博客园_.net 空间，扩展，更新。。。。。

RSA算法的分析与实现(转载)

2012-01-20T06:10:00Z

中国科学技术大学

继续教育学院课程设计

论文报告

论文题目：	RSA算法的分析与实现
学员姓名：	肖百庆
学号：	TB04039136
专业：	计算机科学与技术
指导教师：
日期：	2006年12月26日

RSA算法的分析与实现

[摘要] 随着信息技术的发展，特别是电子商务的发展，网络信息的安全传输逐渐成为人们最为关心和头痛的事情。密码安全研究与设计是当前密码学领域的热点问题。通过对RSA的安全性进行了分析，提出构造安全素数。
    在实际应用中，在混合密码体制中占有重要地位RSA算法存在着计算复杂，运行速度慢的问题。这些基本算法包括模加，模乘，模逆和模幂运算。大数运算是很费时间的，尤其是大整数的模逆和模幂运算。同时我将结合自己在用基本类型进RSA算法中，应注意的一些问题.进行论述。

[关键词] RSA算法密码安全

1. 绪论
    RSA密码体制是美国麻省理工学院（MIT）Rivest、Shami和Adleman于1978年提出来的，它是第一个理论上最为成功的公开密钥密码体制，它的安全性基于数论中的Euler定理和计算复杂性理论中的下述论断：求两个大素数的乘积是很容易计算的，但要分解两个大素数的乘积，求出它们的素数因子却是非常困难的，它属于NP—完全类，是一种幂模运算的加密体制。除了用于加密外，它还能用于数字签字和身份认证。下面将从各个方面来详细对RSA公钥体制进行研究。
1.1 RSA的构成
    RSA系统由以下几部分组成：
    (1) 随机选取的在素数P和Q，还有N ，其中N=P*Q ，P和Q保密，N公开。
    (2) 任取 (n)=（P-1）*(Q-1)，其中 (n)表示比n小的素数的个数，任取2<=e<= (n),且(e, (n))=1,e为加密密钥，公开。
    (3) (计算d,使e*d=1(mod (n)),称d为e对模 (n)的逆，其中d为解密秘钥，保密。在RSA系统中，设m为明文，且明文块的数值大小小于n,c为密文，则其加密和解密算法如下：
    加密算法 C=E(m)=m^e(mod n)
    加密算法 m=D(c)=c^d(mod n)
    在RSA系统中(e,n)构成加密秘钥，即公钥，(d,n) 构成解密秘钥，即私钥。
1.2 RSA思想的证明
    RSA是基于数论中的Euler定理和其它同余性质的，在证明RSA系统思想正确性之前，先给出Euler定理和同余式相乘的性质：
    Euler定理：设（a,n）=1,即a 和 n互素，则有

a^Φ(n) = 1 (mod n )    同余式相乘性质:设有
    a=b (mod n),c=d (mod n) 则有
a*c=b*d ( mod n)    证明RSA系统思想正确性主要是看能否从密文c和解密秘钥d恢复明文m,即由c和d,计算出m=D(c)=Cd (mod n)。
    下面就证明是否能从密文c和解密密钥d恢复明文m,
    ∵ 为 e*d=1 (mod (n))
    ∴ e*d=k* (n)+1,其中K为任意整数。
    由解密公式D(c) = C^d(mod n) 有：
    D(c)=C^d(mod n)=M^e*d=M^k*Φ(n)+1= M^k*Φ(n)*M
    又由Euler定理有
    M^k*Φ(n) =(M^Φ(n))^k = 1( mod n)
    同样由同余式相乘性质有      D(c)=C^d(mod n)=M^e*d=M^k*Φ(n)+1 = M^k*Φ(n)*M = M (mod n)
    由于明文块数值大小小于n,则有
    D(c)=C^d(mod n)=M^e*d=M ^k*Φ(n)+1 = M^k*Φ(n)*M =M (mod n) = M
    故RSA中，能利用e和c恢复明文m,则RSA的系统思想证明是正确的。但众所周知RSA是基于整数因子分解的密码体制，它利用的是：求两个大素数的乘积是很容易计算的，但分解密两个大素数的乘积，求出它们的素数因子却是非常困难的，这样一个数学难题，它属于NP-完全类。因此RSA的安全性完全信赖于因子分解的困难性，只要N=P*Q被因子分解，则RSA便被击破，这样在RSA系统中怎样选取大的素数P，Q才是关键所在。
1.3 RSA中素数的选取
    在RSA中，因N=P*Q，若P，Q被知道，即能将N因子分解，则由 Φ(n)=（P-1）*(Q-1)可以算出。由于e是公开密钥，且解密秘钥D关于E满足
    D*E=1 (mod Φ(n))
    则D也不难求得，这样RSA系统便被完全攻破。
    RSA中的素数都是上面位的十进制数，怎样才能选择好的P和Q，怎样才能生成这样的数，并且判断它是否为素数，这是一个RSA系统关键的问题。针对素数P和Q的选择，1978年Rivest等人在正式发表的RSA公开密钥的论文中，就建议对素数P和Q的选择应当满足：
    (1) P、Q要足够在，在长度上应相差几位，且二者之差与P、Q位数相近；
    (2) P-1与Q-1的最大公约数GCD(P-1,Q-1)就尽量小；
    (3) P-1与Q-1均应至少含有一个大的素数因子。
    并把满足这些条件的素数称为安全素数。
1.4 RSA安全性分析
    在公布RSA算法之后，在使用RSA密码体制和分析RSA算法发现了一系列的算法本身脆弱性及其存在的问题。
    （1）RSA公钥密码体制在加密或解密变化中涉及大量的数值计算，其加密和解密的运算时间比较长，这比数据加密标准DES的计算量开销大，在一定程度上限制了它的应用范围，以致于实际使用RSA密码体制无法用软件产品，必须用超大规模集成电路的硬件产品。
    （2）虽然提高N=P*Q的位数会大大提高RSA密码体制的安全性，但其计算量呈指数增长，以致使其实现的难度增大，实用性降低。
    （3）RSA公钥密码体制的算法完整性（指密钥控制加密或解密变换的唯一性）和安全性（指密码算法除密钥本身外，不应该存在其它可破译密码体制的可能性）沿有等进一步完善。
    （4）RSA算法面临着数学方法的进步和计算机技术飞跃发展带来的破译密码能力日趋增强的严重挑战。因子分解问题有了长跑的发展，1995年人类成功地分解了128位十进制数RSA密码算法，破译512位长的RSA指日可待。
    尽管如此，自1978年RSA算法公布以来，公开密钥密码已从理论研究进入实际应用研究阶段。RSA公开密钥密码算法在信息交换过程中使用比较广泛，安全性比较高。以当前的计算机水平，如选择1024位长的密钥（相当于300位十进制数字）就认为是无法攻破的。

2. RSA算法的程序实现
    首先产生密钥，过程如下：
    (1) 随机产生两个长度为K/2位的素数P 和 Q
    (2) 计算公钥 publicKey=P*Q;(publicKey 是k位的长度)
    (3) 随机产生一个加密密钥 keyE, 2<=keyE<=Φ(n)-1其中GCD(keyE, Φ(n))=1;
    注意这是保证解密密钥keyE *keyD mod Φ(n)=1 有解的充要条件， Φ(n)称为n的欧拉函数,值为: Φ(n)=(P-1)*(Q-1)
    (4) 求解解密密钥keyD=keyE-1 mod (n) ,keyE-1为解密密钥keyD的逆元，此公式原方程为(keyE*keyD mod (n)=1)
    由此公钥，加密密钥，解密密钥全部产生。
    其次对明文加密或对密文进行解密,过程如下:
    (1) 加密: C = M^keyE mod publicKey;其中M表示明文,C表示密文
    (2) 解密: M = C^keyD mod publicKey. 其中M表示明文,C表示密文

图1 加密或解密流程图

图2 总的流程图

图3 产生密钥流程图

根据前述过程，下面是RSA加密解密代码实现,以及在实现过程中应注意的细节。

2.1 产生密钥
2.1.1 产生两个素数iPrimeOne,iPrimeTwo,调用的函数为long int ProductPrime();

////////////////////////////////////////////////////////////////////////////////
// 产生第一个大素数
long int iPrimeOne=ProductPrime(); //产生第二个大素数
long int iPrimeTwo=ProductPrime(); //防止产生相同的素数
while(iPrimeTwo==iPrimeOne)
{
   iPrimeTwo=ProductPrime();
}
/////////////////////////////////////////////////////////////////////////////////
/***************************
* 产生素数
****************************/
long int CRSADlg::ProductPrime()
{ long int iBigPrime=0; //用来保存产生的素数
  //产生素数
  while(true)
  { //将素数产生的范围控制在100-----200以内，
    BigPrime=rand()%100+100; //判断是否为素数,是，跳出循环
    if(IsPrime(BigPrime)) break;
  }
  return BigPrime; //返回产生的素数
}

上面这个函数中我将素数的大小控制100----200以内.即产生的素数是三位的，这个素数值不能太大，因为我用的是基本类型做加密解密,太大的话，两个素数的乘积将会超出long int 所能表示的最大数,太小的话，产生的公钥的值可能会比明文的值小，所以素数值的大小，取决于你的加密解密要求。可以使用下面这个小程序测一下你的long int 所能表示的最大数，来决定产生的素数最大值为多少

#include
#include
using namespace std;
void main()
{
  cout<<"largest long int"<<numeric_limits<long int>::max()<<endl;
}
//*************************************************
// 素数判断. 除到它的开方仍不能被整数，它就是素数
//*************************************************
bool CRSADlg::IsPrime(long int iValue)
{
  long int iPrime=iValue;
  //求这个数开方，加1是为了防止强制类型转换时，使这个数被
  //四舍五入后可能少除了最后一个数，故加上1来避免这种误差
  long int iSQRT=(long int) sqrt( iPrime)+1;
  //从2开始到要判断的这个数是否素数的开方+1
  for(int i=2;i<iSQRT;i++)
  {
  //能够整除，说明不是素数
    if((iPrime % i)==0)
    {
     return false;
    }
  }
  //都不能整除，说明这个数是素数
  return true;
}

2.1.2 求解公钥，以及公钥的欧拉函数
    long int iPublicKey=iPrimeOne*iPrimeTwo;
    long int iOrLa=(iPrimeOne-1)*(iPrimeTwo-1);

2.1.3 求加密密钥iKeyE,调用的函数为ProductKEYE(long int iOrLa)
    long int iKeyE= ProductKEYE(iOrLa);

//*************************************************
// 产生加密密钥KEYE,加密密钥的要求
// 2<=iKeyE<=iOrLa-1
// 且iKeyE与iOrLa互素
//**************************************************
long int CRSADlg::ProductKEYE(long int iOrLa)
{
  long int keyE=0;
  while(true)
  {
    keyE=rand()%iOrLa;
    //如果加密密钥大于2，且与欧拉函数公约数为1，即互素满足
    if( (keyE>=2) && GCD(keyE,iOrLa)==1)
    {
      break;
    }
  }
  return keyE;
}

//**************************
//求两个数的最大公约数
//**************************
long int CRSADlg::GCD(long int keyE,long int iOrLa)
{
  long int iDividend=iOrLa; //被除数
  long int iDivisor=keyE; //除数
  long int iResidual=iDividend%iDivisor; //余数
  //碾转相除法
  while(iResidual!=0)
  {
     //将除数作为被除数
    iDividend=iDivisor;
     //把余数作为除数
    iDivisor=iResidual;
     //求新的余数
    iResidual=iDividend%iDivisor;
  }
  //最大公约数
  return iDivisor;
}

2.1.4 求解密密钥iKeyD
    求解密密钥实际上是如何去解一次同余方程 ax ≡ 1 mod n。根据费马定理与欧拉定理给出了同余方程的解为:
    x=a^(Φ(n)-1) mod n
    由此可得出iKeyD*iKeyE≡ 1 mod Φ(n)
    即iKeyD=iKeyE^{(Φ(Φ(n))-1)} mod Φ(n)
    对解密密钥的求解可以分为二步

1) 求欧拉函数的欧拉函数,欧拉函数的定义是: 1,2,3…………n-1中与n互素的个数称为n的欧拉函数
//**************************
//求解欧拉函数的欧拉函数
//**************************

long int CRSADlg::IOrLaOfIOrLa(long int iOrLa)
{
  //1与任意的一个数互素故初始化1
  long int iOrLaOfiOrLa=1;
  for(int i=2;i   {
    //根据公式，2……n-1中互素（公约数为1）则欧拉值加1
    if(GCD(i,iOrLa)==1)
      iOrLaOfiOrLa++;
    }
  return iOrLaOfiOrLa;
}

2) 做高次模运算
//****************************
// 这个函数用来做高次模
//****************************
long int CRSADlg::HightMod(long int iBottomNumber,long int iExponent,long int iMod)
{
  long int iValueMessageAfterCompute=1;
  long int iValueMessage=iBottomNumber;
  long int iKey=iExponent;
  //把key以2进制的形式进行移位乘用
  while(iKey)
  {
    if(iKey&1) iValueMessageAfterCompute=(iValueMessageAfterCompute*iValueMessage)%iMod;
    //高位右移
    iKey>>=1;
    iValueMessage=(iValueMessage*iValueMessage)%iMod;
  }
  return iValueMessageAfterCompute;
}

因为在做加密和解密的时候也存在做高次模运算，所以在这暂不赘述，在加密和解密过程里将详细讲解

//***************************
//解密密钥
//**************************
long int CRSADlg::ProductKEYD(long int *iOrLaPtr,long int *iKeyEPtr)
{
  //求欧拉函数的欧拉函数 iOrLaOfiOrLa= Φ(Φ(n))
  long int iOrLaOfiOrLa=IOrLaOfIOrLa(*iOrLaPtr);
  //求高次模iKeyE^{( iOrLaOfiOrLa-1)} mod Φ(n)
  //第一参数为iKeyE,第二个参数为 Φ(Φ(n))-1,第三个参数为 Φ(n)
  long int iKEYD=HightMod(*iKeyEPtr, iOrLaOfiOrLa-1, *iOrLaPtr);
  return iKEYD;
}

所以,可得解密密钥
//产生解密密钥
long int iKeyD=ProductKEYD(&iOrLa,&iKeyE );
这里还一种方法可以解解密密钥
因为iKeyD * iKeyE mod iOrLa =1

long int ProductKEYD(long int ikeyE,lont int iOrLa)
{
  long int iKeyD=iOrLa /iKeyE
  while(true)
  {
    if(((iKeyD* iKeyE)%iOrLa)==1)
      break;
    else
      iKeyD++;
  }
  return iKeyD;
}

    这种方法有个缺陷，当iKeyD与iKeyE较大时，iKeyD* iKeyE就会越界，所以这种方法较适用于自定义的大数据类型，当然，这种函数的执行速度还是比较慢的.

2.2 数据的加密解密
    产生密钥后，下一步所要做的就是进行加密和解密，首先我们看一下加密解密的公式：
    C=M^keyE mod publicKey;
    M=C^keyD mod publicKey;
    其中C表示明文，M表示密文，keyE表示加密密钥,KeyD表示解密密钥,publicKey表示公钥.     由此公式可以看出，难点是如何做高次模，先做指数运算，再求模，显然是行不通的，因为keyE通常比较大,M的指数次方运算后所得的值可能会越界，这样求模后的值肯定不正确，(M=C^keyD mod publicKey同理),而且这样做的效率也十分的低。在说明如何做高次模运算时，我们先看一下这个公式:
    (a*b)mod n = [(a mod n)*(b mod n)](mod n)
    当a=b时,这个公式就是
    a mod n=a mod n
    a² mod n =(a*a)mod n = [(a mod n)*(a mod n)](mod n)
    a³ mod n =( a² *a)mod n = [(a2 mod n)*(a mod n)] mod n
    ∶
    ∶
    aⁿ mod n =( a^n-1 *a)mod n = [(an-1 mod n)*(a mod n)] mod n
    aⁿ⁺¹ mod n =( aⁿ *a)mod n = [(aⁿ mod n)*(a mod n)] mod n
    在实际编程时，我们不需要按一个一个底数分解因子，而是以2次方的形式迭代计算高次模。

//***********************
//做高次模运算
//***********************
long int CEncryptAndDecrypt::GetValues(long int iMessage,long int key)
{
  //保存乘积的模
  long int iValueMessageAfterCompute=1;
  //指数
  long int iValueMessage=iMessage;
  //底数
  long int iKey=key;
  //把key以2进制的形式进行移位相乘做迭代
  while(iKey)
  {
    //当前的最低位是否为1，是将计算一次乘积
    if(iKey&1) iValueMessageAfterCompute=(iValueMessageAfterCompute*ValueMessage)%PUBLICKEY;
    //高位右移，即指数除以了2
    iKey>>=1;
    //做一次二次方，一直到指数最高位为0为止 iValueMessage=(iValueMessage*iValueMessage)%PUBLICKEY;
  }
  return iValueMessageAfterCompute;
}

    至此，对RSA算法的分析完毕。我在编写RSA加密解密时是以字符为单位，而在实际应用中可以以行单位进行加密解密，这样可以提高加密解密的速度，但总体来看，RSA加密解密的速度在目前的加密解密算法中是最慢的。

3. 总结
    本论文对当前应用广泛的RSA公钥密码体制进行了分析与研究，了解了怎样的密码体制才能充分发挥RSA的安全作用。分析了RSA加密解密的安全性，以及如何选取RSA密钥长度的问题。同时我们考虑到在实际的应用过程中，在满足安全性前提下应当降低计算的复杂度，提高信息加、解密的速度。便于降低成本，利于推广应用等因素，目前国内外对RSA算法实现的研究大多是在运算速度很高的计算机上，在硬件上也主要采用串行处理，为了提高速度，安全性就必然很差，相反，为提高安全强度，则运算处理速度又会降低。在RSA算法中，最基本的算法主要包括模加、模乘、模逆和模幂运算。大数运算很费时间，尤其是大整数的模逆和模幂运算。为了得到较快的加/解密速度，本程序进行了深层次的优化，主要采用移位的方法，大大提高了RSA算法实际应用的运算速度和执行效率。

    总之，随着密码技术的进一步发展，以及计算机安全研究的技术人员的不断努力，我相信具有更高性能、更高效率的密码加密体制将会诞生。

4. 程序运行

程序运行界面    运行程序后，先点击“产生密钥”按钮，产生一对密钥。然后可以进行加密、解密运算。
    1）加密：选择要加密的文件和加密后文件的存放地，点击“加密”按钮就进行加密运算。
    2）选择要解密的文件和解密后文件的存放地，点击“解密”按钮就进行加密运算。但所使用的解密密钥必须是加密时产生的私钥

5.软件下载演示
点击下载RSA加解密软件

6. 参考文献
[1] 李艺，《网络安全课程PPT讲义》
[2] 胡道元，闵京华《网络安全》清华大学出版社 2005 年
[3] 冯登国，裴定一《密码学导引》,科学出版社，1999 年
[4] 卓光辉，祁明，周浩华《数字签名技术的研究和进展》,2000 年
[5] 曹珍富《公钥密码学》,黑龙江教育出版社，1993年

本文链接

云计算经济学

2012-01-18T05:20:00Z

1848年美国内华达山脉发现金矿不久，众多淘金者涌进加利福尼亚州，引发了轰轰烈烈的淘金热。但有谁知道在这股淘金热中的发财者不是挖金子的人，而是在矿井边卖水的人。

可当送水人多了之后，还有谁能够发?财？

云计算平台就相当于金矿，基于云平台的各种应用程序提供商就是在矿井边买水的人。这样把基础设施和增值服务结合起来，企业间不再是单独个体，而是一个商业生态共同体。

让我们先来看一下云计算的四种形态，私有云、公有云、混合云和社区云。

私有云就是企业内部搭建的计算资源平台，IBM在企业内部拥有并使用很多私有云平台，比如说开发测试云—IBM Ring Cloud。研发人员看不到物理机器，每个人每天使用的是虚拟机，想要什么样的环境就分配给他什么样的环境。最近笔者在做一个大规模数据分析的项目，需要对以P为单位的数据来进行分析，用到数以千计的虚机资源。

公共云是在公共网络上搭建的计算平台，比如亚马逊等网站提供的云服务。社区云是公有云和私有云的变种，实际上是若干个企业共享一个云计算平台，介于公有云和私有云之间，主要特征是使用权和所属权的分离。混合云是将私有云和公有云结合起来计算资源，比如很多银行和保险公司在月底做报表的时候需要大量的计算资源，如果按照这个峰值配置硬件设备又很浪费，80%的时间内有80%的机器是闲置的。就可以将企业内部的机器和亚马逊这类的云服务供应商相连接，需要的时候通过云计算服务租取机器。

根据经济学概念来看，在交付渠道层面，云计算使得IT基础设施的使用权和所属权分开。在交付服务层面，云计算获得使用并且放弃基础设施的过程都是以服务的方式来进行的。在交付模式层面，私有云的私有权和所属权是结合在一起的；公有云的使用权和所有权是分开的，而且拥有者允许开放的人群、开放的企业来进行访问；社区云的使用者是受限的目标群体；混合云则是将公有云和私有云结合起来。

比基本的基础设施更进一步，云计算还可以提供应用服务。也就是说不仅可以帮助客户把系统做好，平台建好，提供工具给客户，使客户可以利用这个平台进行工作部署。进一步来说，云计算服务提供商还可以在平台上为客户搭建应用，提供应用服务。

这对于最终用户来讲，在经济学上意味着一件极其重大的事情，那就是云计算带来的是新的服务交付模式。

基础设备因为IT的形态变得如此的灵活。拿淘宝购物来说，其实客户使用的是一个B2C的服务。用户只要使用浏览器去搜索、下单、选择物流方式、付款，这一系列动作都由淘宝后台系统进行支持。从这个角度来说，星巴克提供的就是咖啡服务，餐馆提供的就是用餐服务。

云计算透过新形态的IT资源使用模式，使同样的物理资源可以做更多的事情，成本更低，效率更高，而且有更加便捷的客户体验，但这些只是非常基础层面的价?值。

云计算更大的价值在于利用这种全新的IT形态所带来的业务创新机会。云计算因为自身的经济模式属性，彻底改变了传统的商业模式和业务模式。

首先，云计算带来规模效应，Google有数以百万计的服务器。但Google的固定资产不仅仅是这些服务器，而是网络效应。打电话的人越多，意味着电话的网络价值越大。这点还适用于互联网上提供的云服务，使用的人越多，价值也就越大。Google的搜索结果其实每天都在根据每个搜索者的搜索结果进行修正，如果说Google提供的搜索结果准确率高是因为每一个使用者都在为此做出贡献。

还有亚马逊的云服务，因为买书的消费者数量巨大，所以亚马逊可以提供一个非常强大的推荐榜单，这也是根据读者的购买数据统计出来的。这就是传统的交叉销售，亚马逊网站所销售的图书超过一半是靠这个方式卖出去的，这就是亚马逊独有的、不可复制的商业秘密。

这就是网络效应，所有的云服务其实多多少少具有这个特性。网络效应加上全球访问带来的结果是什么？从经济学的角度来讲是边际成本的递减，效益递增，最终达到边际成本趋于零。

云计算还带来个性化的价值，几乎所有云服务都提供搜索，而推荐是另外一种搜索。网站可以根据用户现在的搜索动作，由系统自动推荐哪些是消费者可能感兴趣的，从而形成推荐榜单。在社交网络上也是如此，某些领域内的专家和名人的喜好会成为这个领域的新趋势、新流行。移动互联带来了未知属性，进一步让我们的喜好有一个空间上的分割，通过这些可以充分地把消费者的个性和喜好都抓住。而这些在商业上将产生最大的价值，因为互联网提供给用户的是个性化的服务，这也是用户最想要的，这一点跟工业经济大规模的销售完全不?同。

云计算还带来了长尾效应，非常多的个性化需求加起来可以产生巨大价值。消费者很可能不知道，亚马逊网站上卖的冷门图书加起来超过总销售量的70%，而畅销书只占30%。所以云服务的价值在于开创“蓝海”。从经济学的属性来看，云服务比传统服务具有超过若干个数量级的竞争能?力。

云计算的生产还可以众包，这也是所有互联网服务的特点。让我们来看苹果公司，在iphone和ipad上开发软件都是依靠众包，不需要耗费苹果公司的资源，而在此平台基础上开发出来的每一个软件如果盈利还要付给苹果公司30%的利润。

网络效应、个性化服务、长尾效应、蓝海、众包，云计算带来的不仅是IT基础设施使用的改变，更重要的是重塑了经济学概念，促进企业业务模式的改变从而快速迈进服务经济时代。

(本文来源：环球企业家网站 www.gemag.com.cn )

本文链接

Memcached在Windows操作系统下多实例并存(转载)

2012-01-18T05:19:00Z

memcached.exe的-d install命令安装时其他参数貌似无法作用，-p和-m加上后，安装完成Windows服务的binpath里面只有-runservice一个参数。这个可以通过注册表改掉，但还是无法同时安装多个服务。解决这个问题可以用sc服务命令。

比如安装两个个端口11212、11213，500M内存上限的缓存服务，通过cmd命令创建以下两个缓存服务：

----------------------------- 端口11212 --------------------------------

sc create MemcachedServer11212 binPath= "F:\memcached\memcached.exe -d runservice -m 500 -p 11212" start= auto DisplayName= "Memcached Server (11212)"

sc description MemcachedServer11212 "缓存服务：端口11212。"

----------------------------- 端口11213 --------------------------------

sc create MemcachedServer11213 binPath= "F:\memcached\memcached.exe -d runservice -m 500 -p 11213" start= auto DisplayName= "Memcached Server (11213)"

sc description MemcachedServer11213 "缓存服务：端口11213。"

注意：

1、参数名区分大小写，例如：binPath、DisplayName；

2、参数名与“=”等号之间不允许有空格，参数值与“=”等号之间必须有1个空格。

3、删除服务方法形如：sc delete MemcachedServer11212

本文链接

一致性哈希算法及其在分布式系统中的应用（转载）

2012-01-17T07:06:00Z

源文地址：http://wangxiang0794.blog.163.com/blog/static/639080052011713115817686/

摘要

本文将会从实际应用场景出发，介绍一致性哈希算法（Consistent Hash）及其在分布式系统中的应用。首先本文会描述一个在日常开发中经常会遇到的问题场景，借此介绍一致性哈希算法以及这个算法如何解决此问题；接下来会对这个算法进行相对详细的描述，并讨论一些如虚拟节点等与此算法应用相关的话题。

分布式缓存问题

假设我们有一个网站，最近发现随着流量增加，服务器压力越来越大，之前直接读写数据库的方式不太给力了，于是我们想引入Memcached作为缓存机制。现在我们一共有三台机器可以作为Memcached服务器，如下图所示。

很显然，最简单的策略是将每一次Memcached请求随机发送到一台Memcached服务器，但是这种策略可能会带来两个问题：一是同一份数据可能被存在不同的机器上而造成数据冗余，二是有可能某数据已经被缓存但是访问却没有命中，因为无法保证对相同key的所有访问都被发送到相同的服务器。因此，随机策略无论是时间效率还是空间效率都非常不好。

要解决上述问题只需做到如下一点：保证对相同key的访问会被发送到相同的服务器。很多方法可以实现这一点，最常用的方法是计算哈希。例如对于每次访问，可以按如下算法计算其哈希值：

h = Hash(key) % 3

其中Hash是一个从字符串到正整数的哈希映射函数。这样，如果我们将Memcached Server分别编号为0、1、2，那么就可以根据上式和key计算出服务器编号h，然后去访问。

这个方法虽然解决了上面提到的两个问题，但是存在一些其它的问题。如果将上述方法抽象，可以认为通过：

h = Hash(key) % N

这个算式计算每个key的请求应该被发送到哪台服务器，其中N为服务器的台数，并且服务器按照0 – (N-1)编号。

这个算法的问题在于容错性和扩展性不好。所谓容错性是指当系统中某一个或几个服务器变得不可用时，整个系统是否可以正确高效运行；而扩展性是指当加入新的服务器后，整个系统是否可以正确高效运行。

现假设有一台服务器宕机了，那么为了填补空缺，要将宕机的服务器从编号列表中移除，后面的服务器按顺序前移一位并将其编号值减一，此时每个key就要按h = Hash(key) % (N-1)重新计算；同样，如果新增了一台服务器，虽然原有服务器编号不用改变，但是要按h = Hash(key) % (N+1)重新计算哈希值。因此系统中一旦有服务器变更，大量的key会被重定位到不同的服务器从而造成大量的缓存不命中。而这种情况在分布式系统中是非常糟糕的。

一个设计良好的分布式哈希方案应该具有良好的单调性，即服务节点的增减不会造成大量哈希重定位。一致性哈希算法就是这样一种哈希方案。

一致性哈希算法

算法简述

一致性哈希算法（Consistent Hash）最早在论文《Consistent Hashing and Random Trees: Distributed Caching Protocols for Relieving Hot Spots on the World Wide Web》中被提出。简单来说，一致性哈希将整个哈希值空间组织成一个虚拟的圆环，如假设某哈希函数H的值空间为0 - 2³²-1（即哈希值是一个32位无符号整形），整个哈希空间环如下：

整个空间按顺时针方向组织。0和2³²-1在零点中方向重合。

下一步将各个服务器使用H进行一个哈希，具体可以选择服务器的ip或主机名作为关键字进行哈希，这样每台机器就能确定其在哈希环上的位置，这里假设将上文中三台服务器使用ip地址哈希后在环空间的位置如下：

接下来使用如下算法定位数据访问到相应服务器：将数据key使用相同的函数H计算出哈希值h，通根据h确定此数据在环上的位置，从此位置沿环顺时针“行走”，第一台遇到的服务器就是其应该定位到的服务器。

例如我们有A、B、C、D四个数据对象，经过哈希计算后，在环空间上的位置如下：

根据一致性哈希算法，数据A会被定为到Server 1上，D被定为到Server 3上，而B、C分别被定为到Server 2上。

容错性与可扩展性分析

下面分析一致性哈希算法的容错性和可扩展性。现假设Server 3宕机了：

可以看到此时A、C、B不会受到影响，只有D节点被重定位到Server 2。一般的，在一致性哈希算法中，如果一台服务器不可用，则受影响的数据仅仅是此服务器到其环空间中前一台服务器（即顺着逆时针方向行走遇到的第一台服务器）之间数据，其它不会受到影响。

下面考虑另外一种情况，如果我们在系统中增加一台服务器Memcached Server 4：

此时A、D、C不受影响，只有B需要重定位到新的Server 4。一般的，在一致性哈希算法中，如果增加一台服务器，则受影响的数据仅仅是新服务器到其环空间中前一台服务器（即顺着逆时针方向行走遇到的第一台服务器）之间数据，其它不会受到影响。

综上所述，一致性哈希算法对于节点的增减都只需重定位环空间中的一小部分数据，具有较好的容错性和可扩展性。

虚拟节点

一致性哈希算法在服务节点太少时，容易因为节点分部不均匀而造成数据倾斜问题。例如我们的系统中有两台服务器，其环分布如下：

此时必然造成大量数据集中到Server 1上，而只有极少量会定位到Server 2上。为了解决这种数据倾斜问题，一致性哈希算法引入了虚拟节点机制，即对每一个服务节点计算多个哈希，每个计算结果位置都放置一个此服务节点，称为虚拟节点。具体做法可以在服务器ip或主机名的后面增加编号来实现。例如上面的情况，我们决定为每台服务器计算三个虚拟节点，于是可以分别计算 “Memcached Server 1#1”、“Memcached Server 1#2”、“Memcached Server 1#3”、“Memcached Server 2#1”、“Memcached Server 2#2”、“Memcached Server 2#3”的哈希值，于是形成六个虚拟节点：

同时数据定位算法不变，只是多了一步虚拟节点到实际节点的映射，例如定位到“Memcached Server 1#1”、“Memcached Server 1#2”、“Memcached Server 1#3”三个虚拟节点的数据均定位到Server 1上。这样就解决了服务节点少时数据倾斜的问题。在实际应用中，通常将虚拟节点数设置为32甚至更大，因此即使很少的服务节点也能做到相对均匀的数据分布。

总结

目前一致性哈希基本成为了分布式系统组件的标准配置，例如Memcached的各种客户端都提供内置的一致性哈希支持。本文只是简要介绍了这个算法，更深入的内容可以参看论文《Consistent Hashing and Random Trees: Distributed Caching Protocols for Relieving Hot Spots on the World Wide Web》，同时提供一个C语言版本的实现供参考。

本文链接

网上找了一段代码，利用MemoryStream来存储分块的数据包，将其转换成为byte[]后，所有字节都为0.找到问题了。

2012-01-05T16:21:00Z

原因：再数据追加完毕后，没有将MemoryStream的Position设置为0，所以始终没有读取到数据。

工程下载地址：/Files/bobzhangfw/MyTcpIpClient.rar

工程介绍：

ServerTest : 接收客户端分包发送的数据，我以大约10m的文件为例

服务端的代码，在最后完成数据接收后，将MemoryStream转化成为byte[]输出到文件，但是读取到的byte[]中每个字节都是0；

ClientTest : 发送数据

很奇怪。查看MemoryStream的基类中的私有字段buffer，是有数据的。

本文链接

基于GPU的虚拟人物表情绘制(转载)

2012-01-05T03:17:00Z

2009-7-6 作者: 徐远纯刘勇来源: 万方数据

关键字: GPU虚拟表情 Shader语言

本文提出了一种基于GPU的虚拟人物表情绘制方法，该方法运用了GPU运算技术，并且利用Shader语言处理插值数据，从而实现虚拟人物表情动画的快速绘制。实验表明，该方法简单有效，并有利于表情的绘制。

　　1、引言

计算机图形变形技术是计算机动画技术的重要组成部分．它综合利用计算机图形学、图像处理、计算数学及其它学科的知识来实现计算机变形动画，是近年来兴起的一个新的研究领域．具有重要的学术价值和实用价值。其中虚拟人物面部表情模拟．即．如何利用已有的变形技术。方便快捷的实现人物面部表情的模拟是当前研究的一个热点。本文在研究插值算法的基础上．结合GPU加速技术．实现了一个人物表情混合系统。

　2、关键技术及理论

变形，又称为形状融合(shape blending)，即源形体到目标形体的一个连续、光滑、自然过度的过程。其主要研究内容就是设计中间渐变过程，以使变形平滑、自然．即用一定的数学方法在给定的两物体之间自动生成一系列平滑过渡的中同物体。如在动画设计中给出一定数目的关键帧．通过渐变方法内插出中间帧．实现连续动画效果．或是通过从初始物体到目标物体的渐变生成一些融合了两个物体特性的新物体等等。

目前．针对虚拟人物面部表情的动画生成已经有多种方法。Arai K等人通过定义一个独立的参数化的人脸空间．通过叠加人脸面部表情．用双线性插值．实现虚拟人物脸表情的实时变化。M．Cohen等人l’J通过直接参数化模型来控制人脸．定义两类参数，表情参数控制表情．形状参数控制人脸形状。参数值通过对人脸的直接观察来确定。这种直接参数化模型是基于经验描述虚拟的人脸特征．并不考虑各个区域之间的层次连接关系。Thomas W.Sederberg等人的自由变形(Free—Form Defomation，FFDl)方法将待变形物体嵌于一个由一系列控制点组成的假想的三维网格的弹性控制盒中。当挤压．弯曲和扭曲控制盒时，内嵌的物体也相应地被变形，这是一种问接参数化方法。使用这种方法应用于人脸动画时，将人脸变形控制从对面部的描述．转移到不再依赖面部曲面本身。此外．Platt等人提出了基于面部肌肉的人脸模型，通过类似弹簧的肌肉与底层的模拟骨骼相连接．利用肌肉的弹性收缩来产生各种表情。通过研究以上多种人脸表情控制方法发现，线性插值在人脸表情最终绘制阶段，有关键性作用。因此，实现人脸表情的快速实时绘制，是我们的目标。

近年来，随着图形处理器(GPU)性能的大幅度提高以及可编程特性的发展．人们开始将传统的图形渲染流水线的某些处理阶段以及某些图形算法从CPU向GPU转移．由此得到了图形绘制性能的大幅度提升。一个运行在NVlDlA GeForce FX5900UI昀的Shader程序运算速度可达20GnDPs．相当于10GHz的Pentium4。而且图形系统的内存带宽为25.3 GBPs，相比之下Pentium 4只有5.96GBPs。由此可见GPU运算的优势。

传统的图形处理器接受输入的三维信息．然后按照固定的功能进行处理。可以输入的信息有：视点、投影、光照情况等场景的全局信息；顶点位置、面片组成、表面材质设定等场景中三维物体各自的信息。处理器将这些数据在固定流水线上进行处理．输出到帧缓存中，并最终到显示器上输出显示。而可编程的图形处理器对输入信息的处理提供了更为灵活的控制．通过编写的绘制程序来控制。其在顶点级和像素级都提供了灵活的可编程特性，运算上都支持IEEE 32位浮点运算。同时支持多遍绘制的操作．避免了多次CPU与GPU之问的数据交换：支持绘制到纹理，提高了绘制的效率；支持依赖纹理，可以方便地访问数据。

随着图形处理器的发展出现了高端着色语言(high level shading languages)。高端着色语言是一种为GPU编程的类C语言。能充分的利用当前图形处理器的绘制处理能力。针对Shader程序的专有特性．各种HLSL语言都提供了强大的向量数据类型支持．此外还包含了基本的数学函数和纹理处理函数，针对顶点变换、光照处理和各种渲染特效提供了高效的处理机制。这些高级语言加速了Shader编程的开发过程。常用的高端着色语言有：HLSL(微软开发的高端着色语言)，GLSL(0penGL开发的高端着色语言)，CG(NVIDIA开发的高端着色语言)。在这里．我们选用HLSL语言作为我们的Shader编程语言。

　　3、虚拟人脸表情动画的基本原理及实现关键步骤：

　3.1基本原理描述：

首先．确定一个基本网格模型，由这个网格模型确定模型的顶点在运用变换之前的初始坐标。这个模型定义为源网格模型。然后将各个不同的表情网格模型定义为目标网格。不同表情的网格模型视为不同的关键帧。人脸表情的变化通过对关键帧的多种插值方式来实现。一个新的人脸表情不但可以通过两个关键帧位置生成．而且可以对四个关键位置插值生成(双线性插值1。插值八个关键帧(三线性插值)来生成。这样做的优点是迅速，操作直观．只需定义少数的关键帧网格模型，即可产生一段基本的脸部动画．

3.2 实现关键步骤：

3.2.1 定义网格模型

3.2.3 计算模型差异

通过迭代网格模型的所有顶点，获取源网格

该算法在处理时间上比Hough变换算法要短很多，可直接获得直线的端点及长度信息。尽管该算法对干扰作了处理，但是受分割的影响还是很大。如果在分割过程中丢失了轮廓信息。该算法是无法自动弥补的。这在一定程度上也影响了该算法的性能，此外。检测精度也不高。

　4、快速Hough变换算法

上述介绍的各种改进的Hough变换算法都在一定方面和一定程度上改善了Hough小变换的性能，加快了直线提取的速度。但是在实时性要求很高且所处理的图像分辨率较高的情况下．算法运行的速度还有待提高。为了解决这一问题，提出了下面的快速Hou小变换算法。

这种快速Hough变换算法的思想是：采用”分而治之”(divide and conquer)的思想，加快A(p,0)的计算速度。将图像以x方向进行对半分割，先求分割后图像进行Houglh变换的A值，然后求再分割后的图像得到的A值，最后求得全图的A值。如此则可以从每1列开始。进行A值的迭代计算。需要的迭代次数显然是三D削。需要注意的是。在进行迭代计算前，需要对图像进行补零扩充．使图像规模达到2的整数次幂。

为此引入符号Ap(h,I,j)，表示第p步迭代处理中所计算的某线段所经过的全部像素的灰度值的累加。该线段的起点在(I,j)，终点相对于起点的y方向的偏移量为h。h为正表示该线段与x方向的夹角为锐角。否则表示为钝角。

通过分析．可以得到以下近似迭代式：

这种快速Hough小变换算法描述如下：

这种算法同标准Hough变换相比，需要的存储空间增加了，但由于改进的算法在时间性能上得到了较大的提高，对于加快图像处理的速度．提高图像处理的实时性很有意义。

　5、结论

理论与实践向来是形影不离，相辅相成，Hough变换之所以有如此长足的发展，主要原因还是在于实践应用上的广泛需求；而在实践中所暴露出的不足又进而促进了它的发展，循环往复，就如同生命的演化。Hough变换还应用于生物医学；自动化，机器人视觉：空间技术，军事防御以及办公自动化等，所以，Hough变换有着广泛的关注程度以及良好的应用前景。

本文链接

BT资源汇集。。。速度不错。。。教育网。。。

2011-12-30T09:05:00Z

http://54new.com/seedlist-1-0-2.html

本文链接

VLC组播与接收(转载)

2011-12-27T08:50:00Z

出自：http://blog.csdn.net/wangjiannuaa/article/details/6461316

搭建组播服务器

第一步：运行程序后选择“媒体--串流”；

第二步：通过“添加”选择需要播放的文件（以wmv文件为例），单击“串流”；

第三步：流输出有三项需要设置：来源、目标和选项。来源刚才已指定，点击“下一个”；

第四步：勾选“在本地显示”，选择“RTP/ MPEG Transport Stream”输出，单击“添加”；

第五步：如果建立IPv6组播服务器，可以输入组播地址ff15::1，指定端口号“5004”，单击右下角的“下一个”。如果需要建立IPv4组播服务器，则地址栏可输入“239.1.1.1”（239.0.0.0/8为本地管理组播地址）；

第六步：将TTL设置为10，点击左下角“串流”即可发送组播视频，同时在本地播放（视频打开时间较慢，需要等待半分钟左右）；

第七步：使用WireShark抓包查看。

搭建组播客户端

第一步：运行程序后选择“媒体--打开网络串流”；

第二步：输入URL（rtp://@[ff15::1]:5004），单击“播放”就可以观看组播视频，如果为IPv4组播环境，可输入rtp://239.1.1.1:5004。

注：测试前请关闭PC防火墙，以免影响组播报文的发送和接收。

=======================================

以上技术可以用于模拟“IP高清摄像头传输数据过程 ”。

本文链接

VLC 参数（转载）

2011-12-23T03:40:00Z

http://blog.csdn.net/bytxl/article/details/6613449

standard:标准输出
--access : 设定传输媒介
file
udp
http
https
mmsh
rtp

--mux : 封装方式
ts
ps
mpegl
ogg
asf
asfh
avi
mpjpeg
--dst : 地址
file:存储路径
dup/rtp:单播/多播地址格式: IP:PORT

--sap :服务发现协议仅用在 UDP模式下

--group :分组仅VLC能够读出用于SAP下

--slp :

--name :用于SAP/SLP 下为流命名

transcode:转换
--vcodec : 转换成的编码
--vb     : 视频码率
--venc   : 选择编码器
--fps    : 帧数
--deinterlace :交错
--croptop,cropbottom,cropleft,cropright :裁剪
--scale : 比例
--width/height    : 宽/高
--acodec : 音频编码
--ab     : 音频码率
--aenc   : 音频编码器选择
--samplerate: 采样率
--channels: 声道
--scodec :字幕
--senc   : 字幕转换器选择
--soverlay:字幕直接显示在视频上
--sfilter : 视频上加logo
--threads : 多线程转换
--audio-sync :video/audio同步

duplicate:复制

es:分离基本码流

vlc input_stream --sout "#module1{option1=parameter1{parameter-option1},option2=parameter2}:module2{option1=...,option2=...}:..."

本文链接

VLC命令行参数详解(转载)

2011-12-23T03:39:00Z

http://blog.csdn.net/bytxl/article/details/6613471

本文链接