C++博客-天下-随笔分类-加密解密

单文件AES加解密算法

天下 — Mon, 30 Aug 2021 13:39:00 GMT

#pragma once #include //for int8_t #include //for memcmp #include //for intrinsics for AES-NI //compile using gcc and following arguments: -g;-O0;-Wall;-msse2;-msse;-march=native;-maes //internal stuff //macros #define DO_ENC_BLOCK(m,k) \ do{\ m = _mm_xor_si128 (m, k[ 0]); \ m = _mm_aesenc_si128 (m, k[ 1]); \ m = _mm_aesenc_si128 (m, k[ 2]); \ m = _mm_aesenc_si128 (m, k[ 3]); \ m = _mm_aesenc_si128 (m, k[ 4]); \ m = _mm_aesenc_si128 (m, k[ 5]); \ m = _mm_aesenc_si128 (m, k[ 6]); \ m = _mm_aesenc_si128 (m, k[ 7]); \ m = _mm_aesenc_si128 (m, k[ 8]); \ m = _mm_aesenc_si128 (m, k[ 9]); \ m = _mm_aesenclast_si128(m, k[10]);\ }while(0) #define DO_DEC_BLOCK(m,k) \ do{\ m = _mm_xor_si128 (m, k[10+0]); \ m = _mm_aesdec_si128 (m, k[10+1]); \ m = _mm_aesdec_si128 (m, k[10+2]); \ m = _mm_aesdec_si128 (m, k[10+3]); \ m = _mm_aesdec_si128 (m, k[10+4]); \ m = _mm_aesdec_si128 (m, k[10+5]); \ m = _mm_aesdec_si128 (m, k[10+6]); \ m = _mm_aesdec_si128 (m, k[10+7]); \ m = _mm_aesdec_si128 (m, k[10+8]); \ m = _mm_aesdec_si128 (m, k[10+9]); \ m = _mm_aesdeclast_si128(m, k[0]);\ }while(0) #define AES_128_key_exp(k, rcon) aes_128_key_expansion(k, _mm_aeskeygenassist_si128(k, rcon)) static __m128i aes_128_key_expansion(__m128i key, __m128i keygened) { keygened = _mm_shuffle_epi32(keygened, _MM_SHUFFLE(3,3,3,3)); key = _mm_xor_si128(key, _mm_slli_si128(key, 4)); key = _mm_xor_si128(key, _mm_slli_si128(key, 4)); key = _mm_xor_si128(key, _mm_slli_si128(key, 4)); return _mm_xor_si128(key, keygened); } //public API static void aes128_load_key_enc_only(uint8_t *enc_key, __m128i *key_schedule) { key_schedule[0] = _mm_loadu_si128((const __m128i*) enc_key); key_schedule[1] = AES_128_key_exp(key_schedule[0], 0x01); key_schedule[2] = AES_128_key_exp(key_schedule[1], 0x02); key_schedule[3] = AES_128_key_exp(key_schedule[2], 0x04); key_schedule[4] = AES_128_key_exp(key_schedule[3], 0x08); key_schedule[5] = AES_128_key_exp(key_schedule[4], 0x10); key_schedule[6] = AES_128_key_exp(key_schedule[5], 0x20); key_schedule[7] = AES_128_key_exp(key_schedule[6], 0x40); key_schedule[8] = AES_128_key_exp(key_schedule[7], 0x80); key_schedule[9] = AES_128_key_exp(key_schedule[8], 0x1B); key_schedule[10] = AES_128_key_exp(key_schedule[9], 0x36); } static void aes128_load_key(uint8_t *enc_key, __m128i *key_schedule) { aes128_load_key_enc_only(enc_key, key_schedule); // generate decryption keys in reverse order. // k[10] is shared by last encryption and first decryption rounds // k[0] is shared by first encryption round and last decryption round (and is the original user key) // For some implementation reasons, decryption key schedule is NOT the encryption key schedule in reverse order key_schedule[11] = _mm_aesimc_si128(key_schedule[9]); key_schedule[12] = _mm_aesimc_si128(key_schedule[8]); key_schedule[13] = _mm_aesimc_si128(key_schedule[7]); key_schedule[14] = _mm_aesimc_si128(key_schedule[6]); key_schedule[15] = _mm_aesimc_si128(key_schedule[5]); key_schedule[16] = _mm_aesimc_si128(key_schedule[4]); key_schedule[17] = _mm_aesimc_si128(key_schedule[3]); key_schedule[18] = _mm_aesimc_si128(key_schedule[2]); key_schedule[19] = _mm_aesimc_si128(key_schedule[1]); } static void aes128_enc(__m128i *key_schedule, uint8_t *plainText,uint8_t *cipherText) { __m128i m = _mm_loadu_si128((__m128i *) plainText); DO_ENC_BLOCK(m,key_schedule); _mm_storeu_si128((__m128i *) cipherText, m); } static void aes128_dec(__m128i *key_schedule, uint8_t *cipherText,uint8_t *plainText) { __m128i m = _mm_loadu_si128((__m128i *) cipherText); DO_DEC_BLOCK(m,key_schedule); _mm_storeu_si128((__m128i *) plainText, m); } //return 0 if no error //1 if encryption failed //2 if decryption failed //3 if both failed static int aes128_self_test(void) { uint8_t plain[] = {0x32, 0x43, 0xf6, 0xa8, 0x88, 0x5a, 0x30, 0x8d, 0x31, 0x31, 0x98, 0xa2, 0xe0, 0x37, 0x07, 0x34}; uint8_t enc_key[] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c}; uint8_t cipher[] = {0x39, 0x25, 0x84, 0x1d, 0x02, 0xdc, 0x09, 0xfb, 0xdc, 0x11, 0x85, 0x97, 0x19, 0x6a, 0x0b, 0x32}; uint8_t computed_cipher[16]; uint8_t computed_plain[16]; int out=0; __m128i key_schedule[20]; aes128_load_key(enc_key,key_schedule); aes128_enc(key_schedule,plain,computed_cipher); aes128_dec(key_schedule,cipher,computed_plain); if(memcmp(cipher,computed_cipher,sizeof(cipher))) out=1; if(memcmp(plain,computed_plain,sizeof(plain))) out|=2; return out; }

天下 2021-08-30 21:39 发表评论

对openssl做的一些简单封装

天下 — Fri, 21 Mar 2014 09:40:00 GMT

#include "stdafx.h"

int GetRSA(RSA **RsaKeys)
{
    *RsaKeys=RSA_generate_key(RSALEN,RSA_F4,NULL,NULL);
    if(NULL==*RsaKeys)
        return -1;
    return 0 ;
}

//取得私钥
int GetPrivateKey(RSA *RsaKeys,RSA **Pvtkey)
{
    *Pvtkey = RSAPrivateKey_dup(RsaKeys);
    if(NULL==*Pvtkey)
        return -1;
    return 0;
}

//私钥To数据流
int PrivateKeyToData(RSA *Pvtkey,unsigned char* bufkey)
{
    BIO* pBio = BIO_new(BIO_s_mem());
    if (pBio == NULL) {
        return -1;
    }
    memset(bufkey,'\0',RSALEN);
    if( i2d_RSAPrivateKey_bio(pBio,Pvtkey) < 0 ) {
        BIO_free(pBio);
        return -1;
    }
    BIO_read(pBio,bufkey,RSALEN);

    BIO_free(pBio);
    return 0;
}

//数据流To私钥
int DataToPrivateKey(unsigned char* bufkey,RSA **Pvtkey)
{
    BIO *pBio = BIO_new(BIO_s_mem());
    if (pBio == NULL) {
        return -1;
    }
    BIO_write(pBio,bufkey,RSALEN);
    if( NULL == d2i_RSAPrivateKey_bio(pBio,Pvtkey)) {
        BIO_free(pBio);
        return -1;
    }
    BIO_free(pBio);
    return 0;
}

//取得公钥
int GetPublicKey(RSA *RsaKeys,RSA **Pubkey)
{
    *Pubkey = RSAPublicKey_dup(RsaKeys);
    if(NULL==*Pubkey)
        return -1;
    return 0;
}

//公钥To数据流
int PublicKeyToData(RSA *Pubkey,unsigned char* bufkey)
{
    BIO *pBio = BIO_new(BIO_s_mem());
    if (pBio ==NULL) {
        return -1;
    }
    memset(bufkey,'\0',RSALEN);
    if(i2d_RSAPublicKey_bio(pBio,Pubkey) < 0) {
        BIO_free(pBio);
        return -1;
    }
    BIO_read(pBio,bufkey,RSALEN);
    BIO_free(pBio);
    return 0;
}

//数据流To公钥
int DataToPublicKey(unsigned char*bufkey,RSA **Pubkey)
{
    BIO    * pBio=BIO_new(BIO_s_mem());
    if (pBio ==NULL)
    {
        return -1;
    }
    BIO_write(pBio,bufkey,RSALEN);
    if( d2i_RSAPublicKey_bio(pBio,Pubkey) < 0 ) {
        BIO_free(pBio);
        return -1;
    }
    BIO_free(pBio);
    return 0;
}

/*公钥加密->私钥解密*/
int RSAPublicEncrypt(RSA *Publickey, char *From, char *To)
{
    int len=0;
    len = RSA_size(Publickey) -11;

    if(-1 == (len=RSA_public_encrypt(len,(unsigned char *)From,(unsigned char *)To,Publickey,RSA_PKCS1_PADDING)) )
        return -1;

    return len;
}

/*私钥解密<-公钥加密*/
int RSAPrivateDecrypt(RSA *Privtekey, char *From, char *To)
{
    if(-1 == (RSA_private_decrypt(RSALEN/8,(unsigned char *)From,(unsigned char *)To,Privtekey,RSA_PKCS1_PADDING)))
        return -1;

    return 0;
}

/*私钥加密->公钥解密*/
int RSAPrivateEncrypt(RSA *Privtekey, char *From, char *To)
{
    int len = RSA_size(Privtekey)-11;
    if(-1 == (len = RSA_private_encrypt(len,(unsigned char *)From,(unsigned char *)To,Privtekey,RSA_PKCS1_PADDING)))
        return -1;

    return len;
}

/*公钥解密<-私钥加密*/
int RSAPublicDecrypt(RSA *Publickey, char *From, char *To)
{
    if(-1 == (RSA_public_decrypt(RSALEN/8,(unsigned char *)From,(unsigned char *)To,Publickey,RSA_PKCS1_PADDING)) )
        return -1;

    return 0;
}

//void DesEncrypt(char *Key,char *Msg, char *Result,int Length)
//{
//    int             n=0;
//    DES_cblock      desblock;
//    DES_key_schedule schedule;
//
//    DES_string_to_key(Key,&desblock);
//    DES_set_key_checked( &desblock, &schedule );
//
//    DES_cfb64_encrypt( (unsigned char *)Msg, (unsigned char *)Result,
//        Length, &schedule, &desblock, &n, DES_ENCRYPT );
//
//}
//
//
//void DesDecrypt( char *Key, char *Msg, char *Result,int Length)
//{
//
//    int             n=0;
//
//    DES_cblock      desblock;
//    DES_key_schedule schedule;
//
//    DES_string_to_key(Key,&desblock);
//    DES_set_key_checked( &desblock, &schedule );
//
//    DES_cfb64_encrypt( (unsigned char *) Msg, (unsigned char *)Result,
//        Length, &schedule, &desblock, &n, DES_DECRYPT );
//
//}

void DESGenerateKey(char *pKey)
{
    int nLen=33;
    int flag=0;
    int i,k=0;

    srand((unsigned)time(NULL));
    for(i=0;i<nLen-1;i++)
    {
        flag=rand()%2;
        if(flag)
            pKey[k++]='A'+rand()%26;
        else
            pKey[k++]='a'+rand()%26;
    }

    pKey[k]='\0';
}

天下 2014-03-21 17:40 发表评论

密码学(十)、Openssl的安装

天下 — Sun, 19 Jun 2011 02:20:00 GMT

openssl简介
openssl是一个功能丰富且自包含的开源安全工具箱。它提供的主要功能有：SSL协议实现(包括SSLv2、SSLv3和TLSv1)、大量软算法(对称/非对称/摘要)、大数运算、非对称算法密钥生成、ASN.1编解码库、证书请求(PKCS10)编解码、数字证书编解码、CRL编解码、OCSP协议、数字证书验证、PKCS7标准实现和PKCS12个人数字证书格式实现等功能。

openssl采用C语言作为开发语言，这使得它具有优秀的跨平台性能。openssl支持Linux、UNIX、windows、Mac等平台。openssl目前最新的版本是openssl-1.0.0d.

官方网址：http://www.openssl.org/

linux下的安装：
wget http://www.openssl.org/source/openssl-1.0.0d.tar.gz
tar xvzf openssl-1.0.0d.tar.gz
cd openssl-1.0.0d
如果需要zlib压缩模块的话，还需要先安装zlib
然后：
./config --prefix=/usr/local/ssl shared zlib-dynamic

不需要就直接用：
./config --prefix=/usr/local/ssl shared no-zlib

更多详细帮助请运行
./config --help

然后：
make && make install

没问题的话就会一路跑下去，可以去泡杯咖啡，泡个妞，回来差不多就好了。

ARM平台的交叉编译安装：
编译：openssl
./config no-asm no-zlib --prefix=/arm/openssl os/compiler:arm-linux-gcc

修改：
CC= arm-linux-gcc
AR= arm-linux-ar $(ARFLAGS) r
RANLIB= arm-linux-ranlib
如果存在 -march=pentium 就去掉。

windows下的安装：
OpenSSL在Windows下的编译安装
解压openssl-1.0.0d.tar.gz以后，在其目录下可以发现有个INSTALL.W32文件，这个文件就是在windows下的安装说明。
1.安装perl,perl可以从http://www.activestate.com/ActivePerl下载。
2.安装编译器（任意一个都可以）,我在Visual C++ 2005安装成功了，VC2008安装失败了

3.如果通过汇编的方式编译，需要安装汇编语言编译器。MASM NASM都可以。如果速度要求不高，可以不用汇编的方式编译，即不需要安装。MASM一般由VC++自带，Windows NT 4.0 DDK a和Windows 98 DDK也带有MASM。把XXXXXml.exe和XXXXXml.err文件，提取出来，命名为ml.exe和ml.err，并把他们放到PATH路径中即可。

NASM可以免费获取，很多地方都可以下载到，如http://www.kernel.org/pub/software/devel/nasm/binaries/win32/
nasmw.exe文件也需要放到PATH路径中。

4.打开一个DOS窗口，输入：perl Configure VC-WIN32

5.如果使用MASM，接着输入：ms\do_masm
如果使用NASM，接着输入：ms\do_nasm
如果不使用汇编语言编译器，输入:ms\do_ms

我用的是:ms\do_ms
6.在DOS窗口中接着输入：nmake -f ms\ntdll.mak
如果没有错误的话，编译就通过了，在out32dll目录下面就可以看到，生成的dll文件和可执行文件了。把他们放到，PATH环境变量对应的一个目录里就可以了。

下一节讲openssl的一些基础知识

天下 2011-06-19 10:20 发表评论

密码学(三)、Crypto++使用

天下 — Sat, 25 Dec 2010 03:29:00 GMT

1.安装
Crypto++ 的官网:
http://www.cryptopp.com/

下载,我下的版本是: Crypto++ Library 5.6.1 - a Free C++ Class Library of Cryptographic Schemes

Crypto++^® Library 5.6.1

解压后,用VS2008有4个工程:
cryptest
cryptlib
cryptopp
dlltest

编译 cryptlib 工程 ,乖乖, 编译出来的cryptlib.lib 有50多M,
不管了.继续.
将cryptlib.lib库加入到工程中.
编写hello world

//现在写一个hello world程序看看能不能编译通过。
#include
using namespace std;

#include
using namespace CryptoPP;

int main()
{
       cout << "hello crypto++" << endl;
       cout << "Aes block size is " << AES::BLOCKSIZE << endl;

       return 0;
}

附上一个用户指南:
http://www.cppblog.com/Files/aaxron/CryptoPPGuide.7z

天下 2010-12-25 11:29 发表评论

密码学(二)、对称加密和不对称加密

天下 — Sat, 25 Dec 2010 02:07:00 GMT

对称加密　　
采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密，也称为单密钥加密。　　
需要对加密和解密使用相同密钥的加密算法。由于其速度，对称性加密通常在消息发送方需要加密大量数据时使用。对称性加密也称为密钥加密。　　
所谓对称，就是采用这种加密方法的双方使用方式用同样的密钥进行加密和解密。密钥实际上是一种算法，通信发送方使用这种算法加密数据，接收方再以同样的算法解密数据。　　
因此对称式加密本身不是安全的。
　　
常用的对称加密算法有：

DES（Data Encryption Standard）：数据加密标准，速度较快，适用于加密大量数据的场合。

3DES（Triple DES）：是基于DES，对一块数据用三个不同的密钥进行三次加密，强度更高。

AES（Advanced Encryption Standard）：高级加密标准，是下一代的加密算法标准，速度快，安全级别高； 

RC4，也是为   RSA   Data   Security,   Inc.   开发的密码系统的商标名称。


DES、3DES、Blowfish、IDEA、RC4、RC5、RC6和AES

DES、IDEA、RC2、RC4、SKIPJACK算法等
用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密，也称为单密钥加密。

DES

单密钥算法,是信息的发送方采用密钥A进行数据加密,信息的接收方采用同一个密钥A进行数据解密.

单密钥算法是一个对称算法.

缺点:由于采用同一个密钥进行加密解密,在多用户的情况下,密钥保管的安全性是一个问题.

对称加密算法
对称加密算法是应用较早的加密算法，技术成熟。在对称加密算法中，数据发信方将明文（原始数据）和加密密钥一起经过特殊加密算法处理后，使其变成复杂的加密密文发送出去。收信方收到密文后，若想解读原文，则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密，才能使其恢复成可读明文。在对称加密算法中，使用的密钥只有一个，发收信双方都使用这个密钥对数据进行加密和解密，这就要求解密方事先必须知道加密密钥。对称加密算法的特点是算法公开、计算量小、加密速度快、加密效率高。不足之处是，交易双方都使用同样钥匙，安全性得不到保证。此外，每对用户每次使用对称加密算法时，都需要使用其他人不知道的惟一钥匙，这会使得发收信双方所拥有的钥匙数量成几何级数增长，密钥管理成为用户的负担。对称加密算法在分布式网络系统上使用较为困难，主要是因为密钥管理困难，使用成本较高。在计算机专网系统中广泛使用的对称加密算法有DES、IDEA和AES。

传统的DES由于只有56位的密钥，因此已经不适应当今分布式开放网络对数据加密安全性的要求。1997年RSA数据安全公司发起了一项“DES挑战赛”的活动，志愿者四次分别用四个月、41天、56个小时和22个小时破解了其用56位密钥DES算法加密的密文。即DES加密算法在计算机速度提升后的今天被认为是不安全的。

AES是美国联邦政府采用的商业及政府数据加密标准，预计将在未来几十年里代替DES在各个领域中得到广泛应用。AES提供128位密钥，因此，128位AES的加密强度是56位DES加密强度的1021倍还多。假设可以制造一部可以在1秒内破解DES密码的机器，那么使用这台机器破解一个128位AES密码需要大约149亿万年的时间。（更深一步比较而言，宇宙一般被认为存在了还不到200亿年）因此可以预计，美国国家标准局倡导的AES即将作为新标准取代DES。

非对称加密
　　1976年，美国学者Dime和Henman为解决信息公开传送和密钥管理问题，提出一种新的密钥交换协议，允许在不安全的媒体上的通讯双方交换信息，安全地达成一致的密钥，这就是“公开密钥系统”。相对于“对称加密算法”这种方法也叫做“非对称加密算法”。　　与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。

特性
　　非对称加密算法实现机密信息交换的基本过程是：甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开；得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方；甲方再用自己保存的另一把专用密钥对加密后的信息进行解密。甲方只能用其专用密钥解密由其公用密钥加密后的任何信息。　　非对称加密算法的保密性比较好，它消除了最终用户交换密钥的需要，但加密和解密花费时间长、速度慢，它不适合于对文件加密而只适用于对少量数据进行加密。　　经典的非对称加密算法如RSA算法等安全性都相当高. 　　非对称加密的典型应用是数字签名。　　采用双钥密码系统的加密方法，在一个过程中使用两个密钥，一个用于加密，另一个用于解密，这种加密方法称为非对称加密，也称为公钥加密，因为其中一个密钥是公开的（另一个则需要保密）。

不对称加密算法

不对称加密算法使用两把完全不同但又是完全匹配的一对钥匙—公钥和私钥。在使用不对称加密算法加密文件时，只有使用匹配的一对公钥和私钥，才能完成对明文的加密和解密过程。加密明文时采用公钥加密，解密密文时使用私钥才能完成，而且发信方（加密者）知道收信方的公钥，只有收信方（解密者）才是唯一知道自己私钥的人。不对称加密算法的基本原理是，如果发信方想发送只有收信方才能解读的加密信息，发信方必须首先知道收信方的公钥，然后利用收信方的公钥来加密原文；收信方收到加密密文后，使用自己的私钥才能解密密文。显然，采用不对称加密算法，收发信双方在通信之前，收信方必须将自己早已随机生成的公钥送给发信方，而自己保留私钥。由于不对称算法拥有两个密钥，因而特别适用于分布式系统中的数据加密。广泛应用的不对称加密算法有RSA算法和美国国家标准局提出的DSA。以不对称加密算法为基础的加密技术应用非常广泛。

RSA（Rivest Shamir Adlemen，一种因特网加密和认证体系）：由 RSA 公司发明，是一个支持变长密钥的公共密钥算法，需要加密的文件块的长度也是可变的；

DSA（Digital Signature Algorithm）：数字签名算法，是一种标准的 DSS（数字签名标准）；

ECC（Elliptic Curves Cryptography）：椭圆曲线密码编码学。

DSA

所谓数字签名是指发送方从发送报文中抽取特征数据(称为数字指纹或摘要),然后用发送方的私钥对数字指纹使用加密算法进行算法操作,接受方使用发送方已经公开的公钥解密并验证报文.

数字签名用户验证发送方身份或者发送方信息的完整性

中文名称：密钥加密
英文名称：secret key encryption
定义：发送和接收数据的双方，使用相同的或对称的密钥对明文进行加密解密运算的加密方法。

公钥加密
中文名称：公钥加密
英文名称：public key encryption
定义：由对应的一对唯一性密钥(即公开密钥和私有密钥)组成的加密方法。它解决了密钥的发布和管理问题，是目前商业密码的核心。

中文名称：数字签名
英文名称：digital signature
定义：以电子形式存在于数据信息之中的，或作为其附件的或逻辑上与之有联系的数据，可用于辨别数据签署人的身份，并表明签署人对数据信息中包含的信息的认可。

数字签名（又称公钥数字签名、电子签章）是一种类似写在纸上的普通的物理签名，但是使用了公钥加密领域的技术实现，用于鉴别数字信息的方法。一套数字签名通常定义两种互补的运算，一个用于签名，另一个用于验证。

Hash算法

Hash算法特别的地方在于它是一种单向算法，用户可以通过Hash算法对目标信息生成一段特定长度的唯一的Hash值，却不能通过这个Hash值重新获得目标信息。因此Hash算法常用在不可还原的密码存储、信息完整性校验等。

常见的Hash算法有MD2、MD4、MD5、HAVAL、SHA

MD5/SHA

MessageDigest是一个数据的数字指纹.即对一个任意长度的数据进行计算,产生一个唯一指纹号.
MessageDigest的特性:

A) 两个不同的数据,难以生成相同的指纹号

B) 对于指定的指纹号,难以逆向计算出原始数据

其他介绍:
PGP（Pretty Good Privacy）技术 PGP技术是一个基于不对称加密算法RSA公钥体系的邮件加密技术，也是一种操作简单、使用方便、普及程度较高的加密软件。PGP技术不但可以对电子邮件加密，防止非授权者阅读信件；还能对电子邮件附加数字签名，使收信人能明确了解发信人的真实身份；也可以在不需要通过任何保密渠道传递密钥的情况下，使人们安全地进行保密通信。PGP技术创造性地把RSA不对称加密算法的方便性和传统加密体系结合起来，在数字签名和密钥认证管理机制方面采用了无缝结合的巧妙设计，使其几乎成为最为流行的公钥加密软件包。

数字签名（Digital Signature）技术数字签名技术是不对称加密算法的典型应用。数字签名的应用过程是，数据源发送方使用自己的私钥对数据校验和或其他与数据内容有关的变量进行加密处理，完成对数据的合法“签名”，数据接收方则利用对方的公钥来解读收到的“数字签名”，并将解读结果用于对数据完整性的检验，以确认签名的合法性。数字签名技术是在网络系统虚拟环境中确认身份的重要技术，完全可以代替现实过程中的“亲笔签字”，在技术和法律上有保证。在公钥与私钥管理方面，数字签名应用与加密邮件PGP技术正好相反。在数字签名应用中，发送者的公钥可以很方便地得到，但他的私钥则需要严格保密。

PKI（Public Key Infrastructure）技术 PKI技术是一种以不对称加密技术为核心、可以为网络提供安全服务的公钥基础设施。PKI技术最初主要应用在Internet环境中，为复杂的互联网系统提供统一的身份认证、数据加密和完整性保障机制。由于PKI技术在网络安全领域所表现出的巨大优势，因而受到银行、证券、政府等核心应用系统的青睐。PKI技术既是信息安全技术的核心，也是电子商务的关键和基础技术。由于通过网络进行的电子商务、电子政务等活动缺少物理接触，因而使得利用电子方式验证信任关系变得至关重要，PKI技术恰好能够有效解决电子商务应用中的机密性、真实性、完整性、不可否认性和存取控制等安全问题。一个实用的PKI体系还必须充分考虑互操作性和可扩展性。PKI体系所包含的认证中心（CA）、注册中心（RA）、策略管理、密钥与证书管理、密钥备份与恢复、撤销系统等功能模块应该有机地结合在一起。

天下 2010-12-25 10:07 发表评论

密码学(一)、基础

天下 — Sat, 25 Dec 2010 02:03:00 GMT

密码学基础
概述
明文（Plaintext）
密文(Ciphertext)
加密（Encrypt ）
解密（Decrypt）
密码算法(Cryptography Algorithm)
密钥（Secret Key ）
1、系统组成
2、五元组{ M，C，K，E，D }

　　密码技术的一个基本功能是实现保密通信，经典的保密通信模型　　
注意：仅用一个保密通信模型来完整描述密码系统，可能是并不全面和准确的，因为现在的密码系统不单单只提供信息的机密性服务。保密通信是密码技术的一个基本功能。

明文（Plaintext）
　　待伪装或加密的消息（Message）。在通信系统中它可能是比特流，如文本、位图、数字化的语音流或数字化的视频图像等。一般可以简单的认为明文是有意义的字符或比特集，或通过某种公开的编码标准就能获得的消息。明文常用m或p表示。
密文(Ciphertext)
　　对明文施加某种伪装或变换后的输出，也可认为是不可直接理解的字符或比特集，密文常用c表示。
加密（Encrypt ）
　　把原始的信息（明文）转换为密文的信息变换过程。
解密（Decrypt）
　　把己加密的信息（密文）恢复成原始信息明文的过程，也称为脱密。
密码算法(Cryptography Algorithm)
　　也简称密码（Cipher），通常是指加、解密过程所使用的信息变换规则，是用于信息加密和解密的数学函数。　　对明文进行加密时所采用的规则称作加密算法，而对密文进行解密时所采用的规则称作解密算法。加密算法和解密算法的操作通常都是在一组密钥的控制下进行的。
密钥（Secret Key ）
　　密码算法中的一个可变参数，通常是一组满足一定条件的随机序列。　　用于加密算法的叫做加密密钥，用于解密算法的叫做解密密钥，加密密钥和解密密钥可能相同，也可能不相同。　　
密钥常用k表示。
密码系统
1、系统组成
可以有如下几个部分：　　
–消息空间M（又称明文空间）：所有可能明文m的集合；　　
–密文空间C：所有可能密文c的集合；　　
–密钥空间K：所有可能密钥k的集合，其中每一密钥k由加密密钥ke和解密密钥kd组成，即k＝（ke，kd）；　　
–加密算法E：一簇由加密密钥控制的、从M到C的加密变换；　　
–解密算法D: 一簇由解密密钥控制的、从C到M的解密变换。
2、五元组{ M，C，K，E，D }
对称算法的加密和解密表示为：
Ek(M)=C
Dk(C)=M

这种算法具有如下的特性：
Dk(Ek(M))=M

天下 2010-12-25 10:03 发表评论