对称密钥加密系统 — DES

银行系统的密钥有三种,主密钥/pinkey/Mackey,其中pinkey是用来加密密码的,而mackey是用来校验报文是否有错码,主密钥是用来加密pinkey和mackey的.

公钥密码的特性:

对称密钥加密机制即对称密码体系,也称单玥密码体系和传统密码体系。对称密码体系通常分为两大类:分组密码(如DES、AES算法),另一类为序列密码(如RC4算法)。

对称密码体系加密和解密时所用的密钥是相通的或者是类似的,即由加密密钥很容易推导出解密密钥,反之亦然。对称密钥加密,最大的优势是加/解密速度快,适合对大数据量进行加密,但密钥管理困难。

对于普通的对称密码学,加密运算与解密运算使用同样的密钥。通常使用的对称密钥加密算法比较简单高效,密钥剪短,破译极其困难,由于系统的保密性主要取决于密钥的安全性,,所以在公开的计算机网络上安全的传送和保护密钥时一个严峻的问题。而且由于对称密码学中双方使用相同的密钥,因此无法实现数据签名和不可否认性等功能。

金融行业密钥体系介绍(转)

其中主密钥加密pinkey和mackey是是用3des来加解密的

1.加密和解密使用不同的钥匙

DES加密流程

对于任意长的铭文,DES首先对其进行分组,使得每一组的长度为64位,然后分别对每个64位的铭文分组进行加密。对于每个64位长度的明文分组的加密过程如下:

1、初始置换:输入分组按照初始置换表重排次序,进行初始置换。

2、16轮循环:DES对经过初始置换的64位铭文进行16轮类似的子加密过程。每一轮的子加密过程要经过DES的f函数,其过程如下:

  • 将64位明文在中间分开,划为2部分,每部分32位,左半部分记为L,右半部分记为R,以下的操作都是对有半部分数据进行。
  • 扩展置换:扩展置换将32位的输入数据根据扩展置换表扩展称为48位输出数据。
  • 异或运算:将48位的明文数据与48位的子密钥进行异或运算。
  • S盒置换:S盒置换是非线性的,48位输入数据根据S盒置换表置换成为32位输出数据。
  • 直接置换:S盒置换后的32位输出数据根据直接置换表进行直接置换。
  • 经过直接置换的32位输出数据与本轮的L部分进行异或运算,结果作为下一轮子加密过程中的R部分。本轮的R部分直接作为下一轮子加密过程中的L部分。然后进行下一轮子加密过程,直到16轮全部完成。

3、终结置换:按照终结置换表进行终结置换,64位输出就是密文。

金融行业因为对数据比较敏感,所以对数据的加密也相应的重视。在其中有关密钥及加密方面的文章很少,并且散发在各个银行及公司的手中,在网上没有专门对这部分进行介绍的文章。本文对金融行业的密钥进行较深入的介绍,包括像到底什么是主密钥(MasterKey)、传输密钥(MacKey),为什么我们需要这些东西等。

代码如下:

2.从一个钥匙推出另一个钥匙在计算上不可行

DES加密流程详解

 

 

3.每个钥匙都可以做加密和解密

DES的分组过程

DES是一种分组加密算法,所谓分组加密算法就是对一定大小的明文后密文来做加密或解密动作。在DES加密系统中,每次加密或解密的分组大小均为64位,所以DES没有密文扩充的问题。对大于64位的明文只要按每64位的一组进行切割,而对于小于64位的明文只要在后面补“0”即可。

DES所用的加密或解密密钥也是64位大小,但因其中有8个位时奇偶校验位,所有64位中真正起密钥作用的只有56位,密钥过短也是DES最大的缺点。

本文采取追源溯本的方式,力求让对这些感兴趣的人达到知其然,同时也知其所以然,而不是模模糊糊的知道几个概念和名词。因为本文主要是针对那些对金融行业的密钥体系不是很熟悉的人,所以如果你对密钥很熟悉就不必仔细看了。

/*
param:
    pKey:密钥(十六进制)
    strPlainAKey:需要加解密的字符串(十六进制) 
    ciperAKey:返回值
    iflag:1解密 0加密
*/
void getCiper(char* pKey, char* strPlainAKey, char* ciperAKey,  int iflag)
{
    unsigned char binPlainAKey[64] = {0};
    hex2binary(binPlainAKey, strPlainAKey, strlen(strPlainAKey));
    ASCIIStr2BinCharStrBy3DES(pKey,(unsigned char*)binPlainAKey,strlen(strPlainAKey)/2, (unsigned char*)ciperAKey, iflag);
}

/*
param:
    pKey:密钥(十六进制)
    inBinary:加解密字符串的字节形式
    inLen:加解密字符串的长度
    binCharString:返回值
    iflag:1解密 0加密
*/
void ASCIIStr2BinCharStrBy3DES(char* pKey, unsigned char* inBinary, int inLen, unsigned char* binCharString,int iflag)
{
    unsigned char targetIdBin[DESBINARY_LEN] = {0}; //TargetIdLen=8
    // 3DES encription
    unsigned char key[LEN_OF_KEY];
    unsigned char block_key[9];   
    memset(key, 0, LEN_OF_KEY);
    hex2binary(key, pKey, strlen(pKey));
    DES_key_schedule ks,ks2,ks3;


    memset(block_key, 0, sizeof(block_key));  
    memcpy(block_key, key + 0, 8); 
    DES_set_key_unchecked((const_DES_cblock*)block_key, &ks); 
    memcpy(block_key, key + 8, 8);  
    DES_set_key_unchecked((const_DES_cblock*)block_key, &ks2);
    memcpy(block_key, key + 0, 8);  
    DES_set_key_unchecked((const_DES_cblock*)block_key, &ks3); 


    unsigned char input[8];
    memset(input, 0, sizeof(input));
    unsigned char encryptedOutBinary[DESBINARY_LEN];
    memset(encryptedOutBinary, 0, sizeof(encryptedOutBinary));
    for(int i=0; i<inLen/8; i++)
    {
        memset(targetIdBin, 0, sizeof(targetIdBin));
        memcpy((void*)targetIdBin, (const void*)(inBinary+i*8), 8);
        DES_ecb3_encrypt((const_DES_cblock*)targetIdBin, (DES_cblock*)encryptedOutBinary, &ks, &ks2, &ks3, iflag);
        binary2char((char*)binCharString+i*16, encryptedOutBinary, DESBINARY_LEN);
    }
}




//
// A public function: convert binary string to character string, the character string's length = 2 // binary string.
// @param charArray: character array. output.
// @param binArray: binary array. input.
// @param binLen: length of binary array.
//
void binary2char(char* charArray, const unsigned char* binArray, int binLen)
{
        int i;
        for(i = 0; i < binLen; i++)
        {
                sprintf(charArray + 2*i, "%02X", binArray[i]);
        }
        charArray[2*i] = '\0';
}


//
// A public function: convert hex string to binary string, the hex string's length = 2 * binary string.
// @param binArray: binary array. output.
// @param hexCharArray: character array contains hex string. input.
// @param hexLen: length of hex string array. input.
//  
void hex2binary(unsigned char* binArray, const char* hexCharArray, int hexLen)
{
        if (hexLen%2 != 0)
        {
            printf("hex2binary(): length of input parameter hexCharArray should be even number!\n");
            return;
        }


        int i, j;
        //convert two hex chars to one byte
        char atom[2 + 1] = "\0";
        for (i = 0, j = 0; i < hexLen/2; i++, j+=2)
        {
            strncpy(atom, hexCharArray + j, sizeof(atom) - 1);
            atom[sizeof(atom) - 1] = '\0';
            binArray[i] = (unsigned char)strtol(atom, NULL, 16);
        }
}

 

初始置换

经过分组后的64位明文分组将按照初始置换表重新排列次序,进行初始置换,置换方法如下:初始置换表从左到右,从上到下读取,如第一行第一列为58,意味着将原文分组中的第58位置换到第一位,初始置换表下一个数位50,意味着将原明文分组的第50位置置换到第2位,依次类推,将原明文分组的64位全部置换完成。

表1.1初始化置换表

58 50 42 34 26 18 10 2
60 52 44 36 28 20 12 4
62 54 46 38 30 22 14 6
64 56 48 40 32 24 16 8
57 49 41 33 25 17 9 1
59 51 43 35 27 19 11 3
61 53 45 37 29 21 13 5
63 55 47 39 31 23 15 7

 

 

RSA算法:

威尼斯网址开户网站,扩展置换

32位的有半部分明文数据首先要进行扩展置换,扩展置换将32位输入数据扩展成为48位的输出数据,他有三个目的:第一,它产生了与子密钥同长度的数据以进行异或运算;第二,它提供劳务更长的结果,使得在以后的子加密过程中能进行压缩;第三,它产生雪崩效应,这也是扩展置换最主要的目的,使得输入的一位将影响两个替换,所以输出对输入的依懒性将传播的更快(雪崩效应)。其实我只明白第一和第三点。。。

扩展置换的置换方法与初始置换相同,只是置换表不同,扩展置换表如下所示:

表1.2 扩展置换表

32 1 2 3 4 5
4 5 6 7 8 9
8 9 10 11 12 13
12 13 14 15 16 17
16 17 18 19 20 21
20 21 22 23 24 25
24 25 26 27 28 29
28 29 30 31 32 1

好了,咱们言规正传。我们知道,金融行业有很多数据要在网络上传递,包括从前置到主机,从自助终端到前置等,这些数据在网络上传来传去,我们很容易就会想到安全性的问题,如果这些数据被人窃取或拦截下来,那我们怎么敢在银行存钱了。这个问题在计算机出现时就被前人考虑到了,所以出现了很多各种各样的加解密技术。抛开这些不管,假设当初由我们自己来设计怎样解决数据被窃取的情况。假设我们有一段数据,是ATM取款的报文,包括一个人的磁卡号、密码、取款金额,现在需要将这些数据从一台ATM机器传到前置机处理,这些数据是比较机密的,如果被人窃取了,就可以用该卡号和密码把帐户中的钱取走。

一般来说,ATM拿到pinkey密文会使用主密钥解密,得到pinkey明文,然后是用帐号+密码生成pinblock明文,然后使用pinkey使用3des加密,然后传给后端

1978年, MIT三位数学家 R.L.Rivest,A.Shamir和L.Adleman发明了RSA算法。
RSA算法可用于加密、又可用于数字签字,易懂且易于实现,是目前仍然安全并且逐步被广泛应用的一种体制。
国际上一些标准化组织ISO、ITU、及SWIFT等均已接受RSA体制作为标准。

异或运算

扩展置换的48位输出数据与相应的子密钥进行按位异或运算。异或以后的48位结果将继续进行S盒置换。

 

生成pinblock明文的算法为:

 

S盒置换

S盒置换是DES算法中最重要的部分,也是最关键的步骤,因为其他运算都是线性的,只有S盒置换是非线性的,它比DES中任何一步都提供了更好的安全性。

经过异或运算得到的48位输出数据要经过S盒置换,置换由8个盒完成,记为S盒,每个S盒都有6位输入,4位输出。这8个S盒是不同的,每个S盒置换方法如下图所示。使用方法如下:48位的输入分成8组,每组6位分别进入8个S盒。将每组的6位输入记为B0、B1、B2、B3、B4、B5,那么表中的行号由B0B5决定,而列号由B1B2B3B4决定。例如第一个分组位111000要进入第一个S盒S1,那么行号位B0B5,即10,化为十进制即2,即第二行;列号位1100(B1B2B3B4),即为第12列,第2行第12列在下表中的S1中查找位数据3,所有这个S和的4位输出就是3,化为二进制即0011.

表1.3 盒置换表

威尼斯网址开户网站 1

首先,我们可以想到用专用的银行内部网络,外面的人无法获得网络的访问权。这个仔细想想显然不可行的,因为一是不能保证外人一定没办法进入银行内部网络,二是银行内部人员作案是没法防止的。

 

RSA涉及的一些数论知识…

直接置换

S盒置换后的32位输出数据将进行直接置换,该置换把每个输入位映射到输出位,任意一位不能映射两次,不能略去。

 

char uniteBytes(char a,char b)
{
    char c = (int(a-'0')<<4)+b-'0';
    return c;
}
/**
    * getHPin
    * 对密码进行转换
    * PIN格式
    * BYTE 1 PIN的长度
    * BYTE 2 – BYTE 3/4/5/6/7 4--12个PIN(每个PIN占4个BIT)
    * BYTE 4/5/6/7/8 – BYTE 8 FILLER “F” (每个“F“占4个BIT)
    * @param pin String
    * @return byte[]
    */
void getHPin(char* pin, char* encode) 
{
    encode[0] = 6;
    encode[1] = uniteBytes(pin[0], pin[1]);
    encode[2] = uniteBytes(pin[2], pin[3]);
    encode[3] = uniteBytes(pin[4], pin[5]);
    encode[4] = 255;
    encode[5] = 255;
    encode[6] = 255;
    encode[7] = 255;
}

    /**
    * getHAccno
    * 对帐号进行转换
    * BYTE 1 — BYTE 2 0X0000
    * BYTE 3 — BYTE 8 12个主帐号
    * 取主帐号的右12位(不包括最右边的校验位),不足12位左补“0X00”。
    * @param accno String
    * @return byte[]
    */
char* getHAccno(char* accno,char* encode) 
{
    int len = strlen(accno);
    int beginPos = len < 13 ? 0 : len - 13;
    char arrTemp[13] = {0};
    memcpy(arrTemp, accno+beginPos, len-beginPos-1);
    char arrAccno[12];
    for(int i=0; i<12; i++)
    {
    arrAccno[i] = (i <= strlen(arrTemp) ? arrTemp[i] : 0);
    }

    encode[0] = 0;
    encode[1] = 0;
    encode[2] = uniteBytes(arrAccno[0], arrAccno[1]);
    encode[3] = uniteBytes(arrAccno[2], arrAccno[3]);
    encode[4] = uniteBytes(arrAccno[4], arrAccno[5]);
    encode[5] = uniteBytes(arrAccno[6], arrAccno[7]);
    encode[6] = uniteBytes(arrAccno[8], arrAccno[9]);
    encode[7] = uniteBytes(arrAccno[10], arrAccno[11]);
    return encode;
}


/**
    * getPinBlock
    * 标准ANSI X9.8 Format(带主帐号信息)的PIN BLOCK计算
    * PIN BLOCK 格式等于 PIN 按位异或 主帐号;
    * @param pin String
    * @param accno String
    * @return byte[]
    */
void process(char* pin, char* accno,char* pHexRet) 
{
    char arrAccno[128]={0};
    getHAccno(accno,arrAccno);
    char arrPin[128]={0};
    getHPin(pin, arrPin);
    unsigned char arrRet[8]={0};
    for(int i=0; i<8; i++){
    arrRet[i] = (unsigned char)(arrPin[i] ^ arrAccno[i]);
    }

    binary2char(pHexRet, arrRet, 8);
}

Euler函数:

终结置换

终结置换与初始置换相对应,都不影响DES的安全性,主要目的是为了更容易的将明文和密文数据以字节大小放入des的f算法或者DES芯片中。

接着,我们很容易想到,既然保证数据不被窃取的可能性很小,那我们何不变换一下思路,数据避免不了被窃取,那我如果将数据处理下,让你即使窃取到数据,也是一些无用的乱码,这样不就解决问题了吗。这个想法比较接近现在的做法了,当前置机接收到了数据,它肯定是对数据进行反处理,即与ATM端完全步骤相反的数据处理,即可得到明文的数据。我们再进一步想想,如果因为某种原因,报文中的取款金额被改变了,这样就会导致ATM出的钱和前置扣帐记录的钱不一致的情况,看来我们必须加上一个验证机制,当前置机收到ATM发送的一个报文时,能够确认报文中的数据在网络传输过程中没有被更改过。怎样实现?最简单的,像计算机串口通讯一样,对通讯数据每一位进行异或,得到0或1,把0或1放在在通讯数据后面,算是加上一个奇偶校验位,收到数据同样对数据每位进行异或,得到0或1,再判断下收到数据最后一位与算出来的是否一致。这种方式太简单了,对于上面提到的ATM到前置机的报文来说,没什么用处,不过我们可以将对数据每一位异或的算法改成一个比较复杂点的。

 

设n为一正整数,小于n且与n互素的整数的个数,称为Euler数。

总结

刚刚看计算机网络安全相关知识,这一部分不太明白,所以查了一下,自己顺便记录一下,有什么不对的,大家纠正。

 

Mac运算:

1.若n为素数,则Φ(n)=n-1

因为DES算法已经出来了很多年了,并且在金融行业也有广泛的应用,我们何不用DES算法进行处理,来解决上面的问题呢。我们应该了解DES算法(此处指单DES)的,就是用一个64bit(8字节)的Key对64bit的数据进行处理,得到加密后的64bit数据。那我们用一个Key对上面的报文进行DES算法,得到加密后的64bit数据,放到报文的最后,跟报文一起送到前置机,前置机收到报文后,同样用Key对数据(不包括最后的64bit加密数据)进行DES解密,得出64bit的数据,用该数据与ATM发送过来的报文最后的64bit数据比较,如果两个数据相同,说明报文没有中途被更改过。

ATM拿到mackey,通过主密钥解密得到密钥明文,使用一串双方协议好的macdata格式,通过ANSI
9.19得到macblock,随报文发到后端,后端也会做同样的操作,然后比对,得到校验结果

2.若n为两个素数的乘积,则Φ(n)=Φ(p1)Φ(p2)=(p1)x(p2)

 

Ansi 9.19的算法如下

Euler定理:

再进一步,因为DES只能够对64bit的数据进行加密,一个报文可不止64bit,那我们怎么处理呢?只对报文开头的64bit加密?这个是显然不够的。我们可以这样,先对报文的开始64bit加密,接着对报文第二个64bit加密,依次类推,不过这有问题,因为每个64bit都会得到同样长度的加密后的数据,我不能把这些数据都放到报文的后面,那报文的长度不变成两倍长了。换个思路,我们先对报文第一个64bit加密,得到64bit的加密后数据data1,接着再拿加密后的data1与报文第二个64bit数据进行按位异或,得到同样长64bit的数据data2,我再用Key对data2加密,得到加密后的数据data3,再拿data3与报文第三个64bit数据进行按位异或,同样的处理依次类推。直到最后会得到一个64bit的数据,将这个数据放到报文的最后发到前置机,这样报文的长度只增加了64bit而已。这个算法就叫做MAC算法。(现在你知道POS中的MAC域是怎么来的了吧?!)

 

若a与n互素,则aΦ(n)≡1 mod n

 

void xor(unsigned char *input1,unsigned char *input2,unsigned char *output,int len)
{
    while (len) {
        *output++=*input1++^*input2++;
        len--;
    }
}


/*
*@brief: 根据输入数据计算MAC,初始IV向量默认为"x00x00x00x00x00x00x00x00"
*@param: sMacKey 密钥
*@param: pInData 输入数据
*@param: pRetData 计算出来的MAC
*@调用自定义xor和des函数
*/

void MacArithmetic(char *sMacKey,char *inBinary,char *pRetData)
{
//MAC算法:
//将字符串pInata分为8字节为单位的数据块,不足补x00,分别标号为D1,D2,D3,...,Dn
//设置初始向量E0="x00x00x00x00x00x00x00x00"
//将E0^D1 —---->E1(E0,D1异或的后结果经使用密钥左8位des加密得到E1)
//将E1^D2 ----->E2
//如此类推,知道得出En结束,
//使用密钥右8位des解密En得到En0
//使用密钥左8位加密En0得到En1
//En1即是计算出来的MAC

    unsigned char sUpData[512];
    unsigned char sData[20];
    unsigned char sXorData[20];
    unsigned char sDesData[20];
    int i,n,iNum,iInLen;

    unsigned char key[16];
    unsigned char block_key[9];   
    iInLen=strlen(inBinary);
    memset(key, 0, sizeof(key));
    hex2binary(key, sMacKey, strlen(sMacKey));
    DES_key_schedule ks,ks2,ks3;


    memset(block_key, 0, sizeof(block_key));  
    memcpy(block_key, key + 0, 8); 
    DES_set_key_unchecked((const_DES_cblock*)block_key, &ks); 
    memcpy(block_key, key + 8, 8);  
    DES_set_key_unchecked((const_DES_cblock*)block_key, &ks2);
    memcpy(block_key, key + 0, 8);  
    DES_set_key_unchecked((const_DES_cblock*)block_key, &ks3); 

    memset(sUpData,0,sizeof(sUpData));
    memset(sData,0,sizeof(sData));
    memset(sXorData,0,sizeof(sXorData));
    memset(sDesData,0,sizeof(sDesData));


//补全要加密数据成8倍数到sUpData,不足补x00
    memcpy(sUpData,inBinary,iInLen);
    iNum = iInLen%8;
    if (iNum == 0)
        n=iInLen/8;
    else {
        n=iInLen/8+1;
        memcpy(sUpData+iInLen,"\0\0\0\0\0\0\0\0",8-iNum);
    }

    printf("n=%dnsUpData=[%s]n",n,sUpData);

    memset(sDesData,0,sizeof(sDesData)); //初始向量赋给sDesData
    for (i=0;i<n;i++) {
        memcpy(sData,sUpData+i*8,8);
        xor(sDesData,sData,sXorData,8); //异或
        DES_ecb_encrypt((const_DES_cblock*)sXorData, (DES_cblock*)sDesData, &ks,1);
    }
    DES_ecb_encrypt((const_DES_cblock*)sDesData, (DES_cblock*)sXorData, &ks2,0);
    DES_ecb_encrypt((const_DES_cblock*)sXorData, (DES_cblock*)sDesData, &ks,1);

    binary2char(pRetData, sDesData, 8);

    return ;
}

 

好了,到目前为止我们已经知道了什么是MAC算法,为什么需要它,接着我们再看看经常被提起的另外一个名词。在上面说到MAC算法的时候,我们会注意到其中进行DES加密算法时提到了一个Key,这个用来参与MAC计算的Key就常被称为MacKey,也有叫工作密钥、过程密钥的。

 

RSA密钥对生成步骤

 

1.独立地选取两个大素数p和q,计算n=pXq,计算Φ(n)=(p-1)(q-1)

我们继续来处理ATM和前置机间网络数据传输的问题。前面提到的MAC算法对传送的报文进行了处理,保证了在网络传输过程中数据不会被有意或无意的篡改,但是,我们再进一步想想,如果仍然是上面提到的一个取款报文,如果想作案的话,我不改报文的内容,我只是截取报文的内容,因为内容里面有卡号和密码,都是明文的形式,很容易就看出来哪些内容是卡号、哪些内容是密码。有了卡号和密码,我就好办了,找个读卡器就能够很快的制出一张磁卡,然后拿这个磁卡可以随便取钱了,根本不需要修改报文,这样你就算前置机对报文的MAC校验通过了,也只是保证了报文没改动过,对于防止作案没有实质上的帮助。

2.选一整数e,(1<=e<Φ(n),e与Φ(n)互素)。在模Φ(n)下,e有唯一逆元,

 

计算d=e-1mod (Φ(n))

那我们很容易想到,我再加上一道加密,这次我把整个存款的报文都用DES加密,将明文全部转换成密文,然后送到前置机,这下好了吧。即使你把报文截取了也没用,你拿着这些密文也没有用,你也没有DES的密钥来解密它,只有前置机才知道密钥。这是个好主意,确实防止了卡号和密码等被人获知的危险。这也是现在普遍采取的做法,不过我们需要对这个做法进行一些改进。

3.取公钥为(n,e),私钥为(n,d),并销毁p、q

 

 

首先,我们要知道用DES对数据加解密是耗时间的,尤其是使用硬加密(下一步讲什么是硬加密)的情况,速度是比较慢的。我们来想想,整个存款报文有必要每个数据都DES加密吗,像报文中的什么流水号、ATM号等信息,对它们加密没什么意义,进一步讲,取款金额加密也没意义,假设你取500块,但是你将报文改成了100块,导致主机只把你帐户扣100块钱,你白赚了400块。这个听起来挺划算的,实际上是不可行的,因为这样造成了帐务上的短款,银行当然会查账的,根据ATM记录的硬件出钞张数和主机扣款金额,肯定会把你查出来的,那这种掩耳盗铃的做法,下场显而易见,想必没人这么傻。

RSA加密和解密的步骤

 

加密前,首先将明文分成比n小的数据分组,再对每个每个分组加密

我们来考虑一个报文中到底什么信息是需要加密的,目前一般的做法是只对帐号和密码(也有只对密码加密的)进行加密,其他的内容不加密的,明文就明文,没什么大不了的。对帐号和密码加密有个术语,我们可能都听说过,叫PinBlock,即PIN块,就是对帐号和密码进行DES加密处理后的一个密文数据块。既然使用了DES算法来加密帐号和密码,则必然有个Key来加密,那么我们就把这个Key称为PinKey,就是专门来加密帐户和密码的Key。

加密:C=Me(mod n)

 

解密:M=Cd(mod n)

至于怎样进行加密形成最后的密文PinBlock,有很多标准的,像IBM3624、ANSI、ISO、DIEBOLD等标准,其实它们大同小异,就是在对报文中的密码进行一个预处理,再用PinKey来DES加密,主要的差别就是怎样预处理而已,比如有的是密码后面补F,补够16位,就是类似这样的预处理。

 

 

RSA密钥对生成实例

到这里我们应该理解PinKey和PinBlock了。通过PinKey和MacKey对报文进行了两重处理,基本上报文就是安全的了。如果我们对DES算法比较了解,就会知道,如果想对加密后的密文解密,必须要知道Key才行,所以说Key一定要保密。怎样来保密Key呢?我们前面提到的无论是算MAC还是算PIN块,都是直接拿明文的Key来计算的,那么这个Key很容易被窃取的,比如有人在机器上装了个黑客程序,只要检测到你在用Key加密数据,就把明文的Key获取了。这个听起来好像挺玄乎的,不过是有这个可能性的,尤其是网上银行这些东东最容易中招了。

1.独立选取两个素数(这里取的素数很小)p1=47和p2=71

 

      n=47X71=3337

这样看来,我们还要对PinKey和MacKey本身进行加密,不要让人知道了。怎样实现,同样是DES算法大显身手的地方。我再找个Key对PinKey和MacKey进行一次加密,这样你就看不到PinKey和MacKey的明文了,好,解决问题了。这时用来对PinKey和MacKey进行加密的Key就被我们称为MasterKey,即主密钥,用来加密其他密钥的密钥。不过,需要等一下,那MasterKey怎么办,它是明文啊。再找个Key来加密MasterKey,那最终无论处理多少道,最后的那个Key肯定是明文,这样看来,安全的问题还没有解决啊。

      Φ(n)=(47-1)(71-1)=3220

 

2.选整数e=79,(1<=e<3220,3220与79互素)。在模3220下,79有逆元d=1019

既然此路不通,那我们需要换个思维角度了,仔细想想怎样处理明文的MasterKey。黑客程序只能窃取我软件上的东西,如果我把MasterKey放到硬件里面怎么样,黑客是没能力跑到我硬件里面把MasterKey取出来的,当然,不排除道高一尺、魔高一丈的情况,但至少99.9%的黑客都没这能力的。那这样不就解决了我们遇到的问题了吗,只要把MasterKey放到硬件里面(一般是键盘的加密模块里面)就好了。

3.取公钥(3337,79),私钥(3337,1019),销毁47,71

 

 

好,到这里,我们已经不怕有人把报文中的关键信息获取到了,总算是安全了。在最近,老是有人提到“硬加密”,这个有什么用呢?我上面不是已经解决了加密的问题了吗,还要这个概念干什么?看来我还是有些地方没考虑到。我一直想的是将明文的密码加密成密文,其中有个环节需要考虑下,明文的密码是怎样形成的,不就是我按键盘上面的数字形成的吗。以前我的软件处理是这样的,键盘每按一下,我就把那个数字在程序里面先存起来,等到4位或6位密码按完后,再把它们合在一起,再送给PinKey加密。那如果黑客程序直接把我的按键信息获取,那他根本不用破解报文中用PinKey加密后的密码,直接简单的就把我输入的密码得到了,我前面费尽心思对密码进行加密处理变得一点意义都没有了。

加密消息“RSA”,ascii码为828365

 

分成比n小的数据,为了简单,M1=82,M2=83,M3=65

怎么办?如果我把获取按键的程序固化进入加密硬件(一般在键盘中),按键的数字根本不通过上层的软件,直接一步进入硬件里面处理,等到按键按完了后,硬件直接把经过一道处理的按键信息给我上层软件,此时已经是密文了,就相当于把前面计算PinBlock的处理移到硬件里面去了,那黑客就没法获取我的按键了。这种处理现在就被称为硬加密,伴随着EMV和3DES算法,变得越来越流行了,好像自助终端不支持硬加密就不行,连EMV也强制要求了。正是基于这种硬加密的思想,催生一种叫作加密机的加密设备的诞生。加密机是一种具有密钥管理功能的硬件设备。在现在的金融交易平台中,要做到除了顶层密钥外,所有的密钥都是以密文形式存在的,而且顶层密钥往往也是分段管理,一个人不可能知道整个顶层密钥的全部,而这个顶层密钥往往就保存在加密机中。这样也就保证了整个密钥体系具备较高的安全性。

加密后:C1=274,C2=2251,C3=541

 

结果:274,2251,541

最近还有个名词经常被提到,就是3DES。为什么要提出3DES的概念呢?我在一篇文章中提到了3
DES的具体算法,其实推出3DES是因为原来的单DES算法随着计算机硬件的速度提升,存在被破解的可能性,所以将算法进行了改进,改为3DES算法。但是对于我们理解金融行业的密钥及加密机制来说,用什么算法都一样。不同算法的差别只是怎样对数据进行移位变换等具体处理而已。

 

 

解密后:M1=82,M2=83,M3=65

对于ATM交易安全性的考虑问题,系统通过pin加密,MAC效验来保证系统交易数据的合法性及完整性,PIN
BLOCK产生,PIN加密,MAC效验都可在ATM的加密键盘进行。

结果是正确的,过程就不写出来了,套用公式就能算。

 

 

以下简单解释概念:

RSA的速度:

 

硬件实现:比DES大约慢1000倍

1.工作密钥(WK)PIN Key:持卡人密码的加密传输(TPK,ZPK,PVK)

软件实现:比DES大约慢100倍

 

相同安全强度所需的密钥长度比较:

2.MAC Key:用于交易报文的鉴别,保证数据完整性(TAK, ZAK)

威尼斯网址开户网站 2

 

RSA的缺点:

3.COM Key:用于交易报文的通讯加密/解密(TEK,ZEK)

受到素数产生技术的限制,产生密钥很麻烦。

 

分组长度很长,为保证足够安全,n至少要600比特以上,使运算代价很高,且随着大数分解技术的发展,这个长度还需要增加,不利于数据格式的标准化。

4.密钥交换密钥(KEK)Zone Master Key:节点间交换工作密钥时加密保护(ZMK)

 

5.Terminal Master Key:用于主机与金融终端交换工作密钥(TMK)

 

6.本地主密钥(LMK)Local Master Key:用于加密存储其它密钥

 

系统密钥的管理是保证整个系统交易安全的关键,三级密钥管理体系:

 

LMK(本地主密钥)                       最高层密钥,用于加密TMK,ZMK

 

TMK(终端主密钥),ZMK(区域主密钥)      交换密钥,用于加密PIN KEY ,MAC
KEY,COM KEY        

 

工作密钥

 

PIN KEY,MAC KEY,COM KEY               PIN KEY用于加密密码,MAC
KEY用于效验报文,COM KEY用于通讯加密

相关文章