环境：vs.2003 C#
需求：
/*使用二个64位的验证密钥，KeyA和KeyB。
a) 计算算法的数据源包括：
账号、失效期和代码，从左至右顺序编排。
例如19位账号、4位失效期和3位代码组成26个字符的数据源。
b) 将上述数据源扩展成128位二进制数据（不足128位右补二进制0）。
c) 将128位二进制数据分成两个64位的数据块。最左边的64位为Block1，最右边的64位为Block2。
d) 使用KeyA对Block1进行加密。
e) 将Block1的加密结果与Block2进行异或。使用KeyA对异或结果进行加密。
f) 使用KeyB对加密结果进行解密。
g) 使用KeyA对解密结果进行加密。
h) 从左至右将加密结果中的数字（0－9）抽出，组成一组数字。
i) 从左至右将加密结果中的字符（A－F）抽出，减10后将余数组成一组数字，排列在步骤（8）的数字之后。
j) 步骤（9）的左边第一组三位数即为结果值。*/例：
账 号：4123 4567 8901 2345（例子省去几位） KeyA：0123 4567 89AB CDEF
失效期：8701 KeyB：FEDC BA98 7654 3210
代码：111第一步：数据源为4123456789012345 8701 111
第二步：扩展为4123 4567 8901 2345 8701 1110 0000 0000
第三步：Block1=4123 4567 8901 2345
Block2=8701 1110 0000 0000
第四步：用KeyA对Block1加密；
结果为：B76A DDCE 71CC C6BE
第五步：将结果与Block2异或，结果为：306B CCDE 71CC C6BE
再用KeyA加密， 结果为：BAE6 746F 6DE1 F0E6
第六步：用KeyB解密， 结果为：B262 ABCB 9DE9 9A63
第七步：用KeyA加密， 结果为：8D56 25FA 7801 1A0C
第八步：抽出结果中的数字， 结果为：8562 5780 110
第九步：抽出结果中的字符， 结果为：DFAA C
减10后， 结果为：3500 2
连接到第八步的结果之后为： 8562 5780 1103 5002
第十步 最左边三位数就是算法需要得到的值856。
求算法思路及代码。
需求：
/*使用二个64位的验证密钥，KeyA和KeyB。
a) 计算算法的数据源包括：
账号、失效期和代码，从左至右顺序编排。
例如19位账号、4位失效期和3位代码组成26个字符的数据源。
b) 将上述数据源扩展成128位二进制数据（不足128位右补二进制0）。
c) 将128位二进制数据分成两个64位的数据块。最左边的64位为Block1，最右边的64位为Block2。
d) 使用KeyA对Block1进行加密。
e) 将Block1的加密结果与Block2进行异或。使用KeyA对异或结果进行加密。
f) 使用KeyB对加密结果进行解密。
g) 使用KeyA对解密结果进行加密。
h) 从左至右将加密结果中的数字（0－9）抽出，组成一组数字。
i) 从左至右将加密结果中的字符（A－F）抽出，减10后将余数组成一组数字，排列在步骤（8）的数字之后。
j) 步骤（9）的左边第一组三位数即为结果值。*/例：
账 号：4123 4567 8901 2345（例子省去几位） KeyA：0123 4567 89AB CDEF
失效期：8701 KeyB：FEDC BA98 7654 3210
代码：111第一步：数据源为4123456789012345 8701 111
第二步：扩展为4123 4567 8901 2345 8701 1110 0000 0000
第三步：Block1=4123 4567 8901 2345
Block2=8701 1110 0000 0000
第四步：用KeyA对Block1加密；
结果为：B76A DDCE 71CC C6BE
第五步：将结果与Block2异或，结果为：306B CCDE 71CC C6BE
再用KeyA加密， 结果为：BAE6 746F 6DE1 F0E6
第六步：用KeyB解密， 结果为：B262 ABCB 9DE9 9A63
第七步：用KeyA加密， 结果为：8D56 25FA 7801 1A0C
第八步：抽出结果中的数字， 结果为：8562 5780 110
第九步：抽出结果中的字符， 结果为：DFAA C
减10后， 结果为：3500 2
连接到第八步的结果之后为： 8562 5780 1103 5002
第十步 最左边三位数就是算法需要得到的值856。
求算法思路及代码。
解决方案 »
- C#Application.OpenForms与Form.Show()的问题。高手帮忙一下。谢谢。
- 弄了一天的，服了
- 寻求思路“论坛自动回帖”
- 关于计算器小数点的问题
- C#中 如何把a.aspx页面中的form 提交到弹出窗口 B.aspx ？？
- 如何将ORACLE的一个数据库备份到外部存储介质（如U盘），通过程序实现
- datagrid导出为excel时，数据“12-21-4A”在Excel显示成“2005-9-19 4:00:00”，如何解决？
- .net下如何制作一个复杂的学生课后练习系统？请大家提提想法
- Winform的ReportViewer动态绑定数据源和报表的问题！
- 如何用C#写一个简单的COM程序？？
- c#算法面试题,高手的请来
- 求助各位高手sql连接问题
我拿"4123456789012345","0123456789ABCDEF"加密怎么也加不出来B76A DDCE 71CC C6BE
然后第二步转换成二进制，向右补齐128位，在第三步一分为二
账号： 6224219601000004994
失效期：4912
代码：120
第一步：62242196010000049944912120
第二步：622421960100000499449121200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
第三步：
Block1:6224219601000004994491212000000000000000000000000000000000000000
Block2:000000000000000000000000000000000000000000000000000000000000
第四步往后我还不知道怎么具体做
结果为：B76A DDCE 71CC C6BE
怎么来的？
你的需求方是干嘛的。。怎么都是弄加密呢。那你得问一下他怎么加密出来的，DES的运算模式就有5种。。
int Get_CSD(char *kstr,char *mdte,char *mfdm,char *r_cvn)
{
/*************************************************************
*账号(kstr)+有效期(mdte)+代码(mfdm)
**************************************************************/
unsigned char KeyA[8]={0xd3,0x1a,0xe7,0x29,0x5b,0x48,0xcf,0x06};
unsigned char KeyB[8]={0x2b,0x62,0x13,0x7d,0x0b,0xfb,0x9a,0x68}; unsigned char data[8],data1[8],tmstr1[5],result[17]; char mstr[33],bstr[129],tmstr[3];
char block1[17],block2[17];
int tlen,i,len,l;
char t1,t2,t3[2];
char cstr[2],cestr[2],tnum[17],cnum[17],tstr[17],testr[17];
char rnum[17];
char cvn[4]; tlen=32; /**************************************************************
*将账号+有效期+代码扩展到128位数据源（不足128右补二进制0）
**************************************************************/
memset(mstr,'\0',sizeof(mstr)); pub_base_strpack(kstr);
pub_base_strpack(mdte);
pub_base_strpack(mfdm); strcpy(mstr,kstr);
strcat(mstr,mdte);
strcat(mstr,mfdm); for (i=strlen(mstr);i<tlen;i++)
{
strcat(mstr,"0");
} /**************************************************************
*将128位数据源分成两个64位的数据块。最左边64位为block1，最右边
*64位为block2
**************************************************************/
memset(block1,'\0',sizeof(block1));
memset(block2,'\0',sizeof(block2)); strncpy(block1,mstr,16); strncpy(block2,mstr+16,16); /**************************************************************
*block1转换为8字节的十六进制字符串data
**************************************************************/
memset(data,'\0',sizeof(data));
memset(tmstr,'\0',sizeof(tmstr));
memset(tmstr1,'\0',sizeof(tmstr1)); len=0;
for(i=0;i<8;i++)
{
strncpy(tmstr,block1+len,2);
sub_asc_to_bcd(tmstr1,tmstr,2,0);
data[i]=tmstr1[0];
len=len+2;
} /**************************************************************
*将data数据用KeyA加密，结果为result
**************************************************************/
memset(result,'\0',sizeof(result)); des(data,result,KeyA,1); /**************************************************************
*将result，转换为8字节的字符串tstr
**************************************************************/
memset(tstr,'\0',sizeof(tstr));
memset(cstr,'\0',sizeof(cstr)); for(i=0;i<8;i++)
{
sprintf(cstr,"%02x", result[i]);
strcat(tstr,cstr);
} /**************************************************************
*将tstr同block2进行异或，结果为testr
**************************************************************/
memset(testr,'\0',sizeof(testr));
memset(cestr,'\0',sizeof(cestr)); for(i=0;i<16;i++)
{
if (tstr[i]>='a' || tstr[i]>='A')
t1=tstr[i]-'a'+10;
else
t1=tstr[i]-'0';
if (block2[i]>='a' || block2[i]>='A')
t2=block2[i]-'a'+10;
else
t2=block2[i]-'0';
sprintf(cestr,"%x", t1^t2);
strcat(testr,cestr);
} /**************************************************************
*testr转换为8字节的十六进制字符串data1
**************************************************************/
memset(data1,'\0',sizeof(data1));
memset(tmstr,'\0',sizeof(tmstr));
memset(tmstr1,'\0',sizeof(tmstr1));
len=0;
for(i=0;i<8;i++)
{
strncpy(tmstr,testr+len,2);
sub_asc_to_bcd(tmstr1,tmstr,2,0);
data1[i]=tmstr1[0];
len=len+2;
} /**************************************************************
*将data1数据用KeyA加密，结果为result
**************************************************************/
memset(result,'\0',sizeof(result));
des(data1,result,KeyA,1);
/**************************************************************
*将result数据用KeyB解密，结果为result
**************************************************************/
des(result,result,KeyB,0);
/**************************************************************
*将result数据用KeyA加密，结果为result
**************************************************************/
des(result,result,KeyA,1); /**************************************************************
*将result转换为8字节十六进制数据tstr
**************************************************************/
memset(cstr,'\0',sizeof(cstr));
memset(tstr,'\0',sizeof(tstr)); for(i=0;i<8;i++)
{
sprintf(cstr,"%02x", result[i]);
strcat(tstr,cstr);
} /**************************************************************
*将tstr中的数字提取出来，结果tnum；
*将tstr中的字符抽出，减10后将余数组成一组数字cnum，放在tnum后
**************************************************************/
memset(tnum,'\0',sizeof(tnum));
memset(cnum,'\0',sizeof(cnum)); for(i=0;i<16;i++)
{
if (tstr[i]>='0' && tstr[i]<='9')
{
sprintf(t3,"%c",tstr[i] );
strcat(tnum,t3);
}
if ((tstr[i]>='a' && tstr[i]<='f') ||
(tstr[i]>='A' && tstr[i]<='F'))
{
sprintf(t3,"%d",tstr[i]-'a');
strcat(cnum,t3);
}
} memset(rnum,'\0',sizeof(rnum));
strcpy(rnum,tnum);
strcat(rnum,cnum); memset(cvn,'\0',sizeof(cvn)); strncpy(cvn,rnum,3); strcpy(r_cvn,cvn); return 0;
}
账号、失效期和代码，从左至右顺序编排。
例如19位账号、4位失效期和3位代码组成26个字符的数据源。
b) 将上述数据源扩展成128位二进制数据（不足128位右补二进制0）。
c) 将128位二进制数据分成两个64位的数据块。最左边的64位为Block1，最右边的64位为Block2。 这时Block1的值是不是二进制的？
d) 使用KeyA对Block1进行加密。这里是不是对二进制的Block1进行加密
e) 将Block1的加密结果与Block2进行异或。使用KeyA对异或结果进行加密。
第一步：数据源为4123456789012345 8701 111
第二步：扩展为4123 4567 8901 2345 8701 1110 0000 0000
第三步：Block1=4123 4567 8901 2345 如果上面都是二进制的话这里Block1的值不应该是这个，应该是1110101001100100001100011001001001111101111101111001才对呀，如果不是这个值那上面转成二进制有何用？
Block2=8701 1110 0000 0000
{
unsigned char bufout[64],kwork[56],worka[48],kn[48],buffer[64],key[64];
unsigned char nbrofshift, temp1, temp2;
int valindex;
register i, j, k, iter; /* INITIALIZE THE TABLES */
/* Table - s1 */
static unsigned char s1[4][16] = {
14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 }; /* Table - s2 */
static unsigned char s2[4][16] = {
15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 }; /* Table - s3 */
static unsigned char s3[4][16] = {
10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 }; /* Table - s4 */
static unsigned char s4[4][16] = {
7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 }; /* Table - s5 */
static unsigned char s5[4][16] = {
2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 }; /* Table - s6 */
static unsigned char s6[4][16] = {
12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 }; /* Table - s7 */
static unsigned char s7[4][16] = {
4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 }; /* Table - s8 */
static unsigned char s8[4][16] = {
13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 }; /* Table - Shift */
static unsigned char shift[16] = {
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 }; /* Table - Binary */
static unsigned char binary[64] = {
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1,
0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1,
1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1,
1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 }; /* MAIN PROCESS */
/* Convert from 64-bit key into 64-byte key */
for (i = 0; i < 8; i++) {
key[8*i] = ((j = *(inkey + i)) / 128) % 2;
key[8*i+1] = (j / 64) % 2;
key[8*i+2] = (j / 32) % 2;
key[8*i+3] = (j / 16) % 2;
key[8*i+4] = (j / 8) % 2;
key[8*i+5] = (j / 4) % 2;
key[8*i+6] = (j / 2) % 2;
key[8*i+7] = j % 2;
} /* Convert from 64-bit data into 64-byte data */
for (i = 0; i < 8; i++) {
buffer[8*i] = ((j = *(source + i)) / 128) % 2;
buffer[8*i+1] = (j / 64) % 2;
buffer[8*i+2] = (j / 32) % 2;
buffer[8*i+3] = (j / 16) % 2;
buffer[8*i+4] = (j / 8) % 2;
buffer[8*i+5] = (j / 4) % 2;
buffer[8*i+6] = (j / 2) % 2;
buffer[8*i+7] = j % 2;
} /* Initial Permutation of Data */
bufout[ 0] = buffer[57];
bufout[ 1] = buffer[49];
bufout[ 2] = buffer[41];
bufout[ 3] = buffer[33];
bufout[ 4] = buffer[25];
bufout[ 5] = buffer[17];
bufout[ 6] = buffer[ 9];
bufout[ 7] = buffer[ 1];
bufout[ 8] = buffer[59];
bufout[ 9] = buffer[51];
bufout[10] = buffer[43];
bufout[11] = buffer[35];
bufout[12] = buffer[27];
bufout[13] = buffer[19];
bufout[14] = buffer[11];
bufout[15] = buffer[ 3];
bufout[16] = buffer[61];
bufout[17] = buffer[53];
bufout[18] = buffer[45];
bufout[19] = buffer[37];
bufout[20] = buffer[29];
bufout[21] = buffer[21];
bufout[22] = buffer[13];
bufout[23] = buffer[ 5];
bufout[24] = buffer[63];
bufout[25] = buffer[55];
bufout[26] = buffer[47];
bufout[27] = buffer[39];
bufout[28] = buffer[31];
bufout[29] = buffer[23];
bufout[30] = buffer[15];
bufout[31] = buffer[ 7];
bufout[32] = buffer[56];
bufout[33] = buffer[48];
bufout[34] = buffer[40];
bufout[35] = buffer[32];
bufout[36] = buffer[24];
bufout[37] = buffer[16];
bufout[38] = buffer[ 8];
bufout[39] = buffer[ 0];
bufout[40] = buffer[58];
bufout[41] = buffer[50];
bufout[42] = buffer[42];
bufout[43] = buffer[34];
bufout[44] = buffer[26];
bufout[45] = buffer[18];
bufout[46] = buffer[10];
bufout[47] = buffer[ 2];
bufout[48] = buffer[60];
bufout[49] = buffer[52];
bufout[50] = buffer[44];
bufout[51] = buffer[36];
bufout[52] = buffer[28];
bufout[53] = buffer[20];
bufout[54] = buffer[12];
bufout[55] = buffer[ 4];
bufout[56] = buffer[62];
bufout[57] = buffer[54];
bufout[58] = buffer[46];
bufout[59] = buffer[38];
bufout[60] = buffer[30];
bufout[61] = buffer[22];
bufout[62] = buffer[14];
bufout[63] = buffer[ 6];
/* Initial Permutation of Key */
kwork[ 0] = key[56];
kwork[ 1] = key[48];
kwork[ 2] = key[40];
kwork[ 3] = key[32];
kwork[ 4] = key[24];
kwork[ 5] = key[16];
kwork[ 6] = key[ 8];
kwork[ 7] = key[ 0];
kwork[ 8] = key[57];
kwork[ 9] = key[49];
kwork[10] = key[41];
kwork[11] = key[33];
kwork[12] = key[25];
kwork[13] = key[17];
kwork[14] = key[ 9];
kwork[15] = key[ 1];
kwork[16] = key[58];
kwork[17] = key[50];
kwork[18] = key[42];
kwork[19] = key[34];
kwork[20] = key[26];
kwork[21] = key[18];
kwork[22] = key[10];
kwork[23] = key[ 2];
kwork[24] = key[59];
kwork[25] = key[51];
kwork[26] = key[43];
kwork[27] = key[35];
kwork[28] = key[62];
kwork[29] = key[54];
kwork[30] = key[46];
kwork[31] = key[38];
kwork[32] = key[30];
kwork[33] = key[22];
kwork[34] = key[14];
kwork[35] = key[ 6];
kwork[36] = key[61];
kwork[37] = key[53];
kwork[38] = key[45];
kwork[39] = key[37];
kwork[40] = key[29];
kwork[41] = key[21];
kwork[42] = key[13];
kwork[43] = key[ 5];
kwork[44] = key[60];
kwork[45] = key[52];
kwork[46] = key[44];
kwork[47] = key[36];
kwork[48] = key[28];
kwork[49] = key[20];
kwork[50] = key[12];
kwork[51] = key[ 4];
kwork[52] = key[27];
kwork[53] = key[19];
kwork[54] = key[11];
kwork[55] = key[ 3]; /* 16 Iterations */
for (iter = 1; iter < 17; iter++) {
for (i = 0; i < 32; i++)
buffer[i] = bufout[32+i];
/* Calculation of F(R, K) */
/* Permute - E */
worka[ 0] = buffer[31];
worka[ 1] = buffer[ 0];
worka[ 2] = buffer[ 1];
worka[ 3] = buffer[ 2];
worka[ 4] = buffer[ 3];
worka[ 5] = buffer[ 4];
worka[ 6] = buffer[ 3];
worka[ 7] = buffer[ 4];
worka[ 8] = buffer[ 5];
worka[ 9] = buffer[ 6];
worka[10] = buffer[ 7];
worka[11] = buffer[ 8];
worka[12] = buffer[ 7];
worka[13] = buffer[ 8];
worka[14] = buffer[ 9];
worka[15] = buffer[10];
worka[16] = buffer[11];
worka[17] = buffer[12];
worka[18] = buffer[11];
worka[19] = buffer[12];
worka[20] = buffer[13];
worka[21] = buffer[14];
worka[22] = buffer[15];
worka[23] = buffer[16];
worka[24] = buffer[15];
worka[25] = buffer[16];
worka[26] = buffer[17];
worka[27] = buffer[18];
worka[28] = buffer[19];
worka[29] = buffer[20];
worka[30] = buffer[19];
worka[31] = buffer[20];
worka[32] = buffer[21];
worka[33] = buffer[22];
worka[34] = buffer[23];
worka[35] = buffer[24];
worka[36] = buffer[23];
worka[37] = buffer[24];
worka[38] = buffer[25];
worka[39] = buffer[26];
worka[40] = buffer[27];
worka[41] = buffer[28];
worka[42] = buffer[27];
worka[43] = buffer[28];
worka[44] = buffer[29];
worka[45] = buffer[30];
worka[46] = buffer[31];
worka[47] = buffer[ 0];
if (flg) {
nbrofshift = shift[iter-1];
for (i = 0; i < (int) nbrofshift; i++) {
temp1 = kwork[0];
temp2 = kwork[28];
for (j = 0; j < 27; j++) {
kwork[j] = kwork[j+1];
kwork[j+28] = kwork[j+29];
}
kwork[27] = temp1;
kwork[55] = temp2;
}
} else if (iter > 1) {
nbrofshift = shift[17-iter];
for (i = 0; i < (int) nbrofshift; i++) {
temp1 = kwork[27];
temp2 = kwork[55];
for (j = 27; j > 0; j--) {
kwork[j] = kwork[j-1];
kwork[j+28] = kwork[j+27];
}
kwork[0] = temp1;
kwork[28] = temp2;
}
} /* Permute kwork - PC2 */
kn[ 0] = kwork[13];
kn[ 1] = kwork[16];
kn[ 2] = kwork[10];
kn[ 3] = kwork[23];
kn[ 4] = kwork[ 0];
kn[ 5] = kwork[ 4];
kn[ 6] = kwork[ 2];
kn[ 7] = kwork[27];
kn[ 8] = kwork[14];
kn[ 9] = kwork[ 5];
kn[10] = kwork[20];
kn[11] = kwork[ 9];
kn[12] = kwork[22];
kn[13] = kwork[18];
kn[14] = kwork[11];
kn[15] = kwork[ 3];
kn[16] = kwork[25];
kn[17] = kwork[ 7];
kn[18] = kwork[15];
kn[19] = kwork[ 6];
kn[20] = kwork[26];
kn[21] = kwork[19];
kn[22] = kwork[12];
kn[23] = kwork[ 1];
kn[24] = kwork[40];
kn[25] = kwork[51];
kn[26] = kwork[30];
kn[27] = kwork[36];
kn[28] = kwork[46];
kn[29] = kwork[54];
kn[30] = kwork[29];
kn[31] = kwork[39];
kn[32] = kwork[50];
kn[33] = kwork[44];
kn[34] = kwork[32];
kn[35] = kwork[47];
kn[36] = kwork[43];
kn[37] = kwork[48];
kn[38] = kwork[38];
kn[39] = kwork[55];
kn[40] = kwork[33];
kn[41] = kwork[52];
kn[42] = kwork[45];
kn[43] = kwork[41];
kn[44] = kwork[49];
kn[45] = kwork[35];
kn[46] = kwork[28];
kn[47] = kwork[31];
/* KS Function End */ /* worka XOR kn */
for (i = 0; i < 48; i++)
worka[i] = worka[i] ^ kn[i]; /* 8 s-functions */
valindex = s1[2*worka[ 0]+worka[ 5]]
[2*(2*(2*worka[ 1]+worka[ 2])+
worka[ 3])+worka[ 4]];
valindex = valindex * 4;
kn[ 0] = binary[0+valindex];
kn[ 1] = binary[1+valindex];
kn[ 2] = binary[2+valindex];
kn[ 3] = binary[3+valindex];
valindex = s2[2*worka[ 6]+worka[11]]
[2*(2*(2*worka[ 7]+worka[ 8])+
worka[ 9])+worka[10]];
valindex = valindex * 4;
kn[ 4] = binary[0+valindex];
kn[ 5] = binary[1+valindex];
kn[ 6] = binary[2+valindex];
kn[ 7] = binary[3+valindex];
valindex = s3[2*worka[12]+worka[17]]
[2*(2*(2*worka[13]+worka[14])+
worka[15])+worka[16]];
valindex = valindex * 4;
kn[ 8] = binary[0+valindex];
kn[ 9] = binary[1+valindex];
kn[10] = binary[2+valindex];
kn[11] = binary[3+valindex];
valindex = s4[2*worka[18]+worka[23]]
[2*(2*(2*worka[19]+worka[20])+
worka[21])+worka[22]];
valindex = valindex * 4;
kn[12] = binary[0+valindex];
kn[13] = binary[1+valindex];
kn[14] = binary[2+valindex];
kn[15] = binary[3+valindex];
valindex = s5[2*worka[24]+worka[29]]
[2*(2*(2*worka[25]+worka[26])+
worka[27])+worka[28]];
valindex = valindex * 4;
kn[16] = binary[0+valindex];
kn[17] = binary[1+valindex];
kn[18] = binary[2+valindex];
kn[19] = binary[3+valindex];
valindex = s6[2*worka[30]+worka[35]]
[2*(2*(2*worka[31]+worka[32])+
worka[33])+worka[34]];
valindex = valindex * 4;
kn[20] = binary[0+valindex];
kn[21] = binary[1+valindex];
kn[22] = binary[2+valindex];
kn[23] = binary[3+valindex];
valindex = s7[2*worka[36]+worka[41]]
[2*(2*(2*worka[37]+worka[38])+
worka[39])+worka[40]];
valindex = valindex * 4;
kn[24] = binary[0+valindex];
kn[25] = binary[1+valindex];
kn[26] = binary[2+valindex];
kn[27] = binary[3+valindex];
valindex = s8[2*worka[42]+worka[47]]
[2*(2*(2*worka[43]+worka[44])+
worka[45])+worka[46]];
valindex = valindex * 4;
kn[28] = binary[0+valindex];
kn[29] = binary[1+valindex];
kn[30] = binary[2+valindex];
kn[31] = binary[3+valindex];
/* Permute - P */
worka[ 0] = kn[15];
worka[ 1] = kn[ 6];
worka[ 2] = kn[19];
worka[ 3] = kn[20];
worka[ 4] = kn[28];
worka[ 5] = kn[11];
worka[ 6] = kn[27];
worka[ 7] = kn[16];
worka[ 8] = kn[ 0];
worka[ 9] = kn[14];
worka[10] = kn[22];
worka[11] = kn[25];
worka[12] = kn[ 4];
worka[13] = kn[17];
worka[14] = kn[30];
worka[15] = kn[ 9];
worka[16] = kn[ 1];
worka[17] = kn[ 7];
worka[18] = kn[23];
worka[19] = kn[13];
worka[20] = kn[31];
worka[21] = kn[26];
worka[22] = kn[ 2];
worka[23] = kn[ 8];
worka[24] = kn[18];
worka[25] = kn[12];
worka[26] = kn[29];
worka[27] = kn[ 5];
worka[28] = kn[21];
worka[29] = kn[10];
worka[30] = kn[ 3];
worka[31] = kn[24]; /* bufout XOR worka */
for (i = 0; i < 32; i++) {
bufout[i+32] = bufout[i] ^ worka[i];
bufout[i] = buffer[i];
}
} /* End of Iter */ /* Prepare Output */
for (i = 0; i < 32; i++) {
j = bufout[i];
bufout[i] = bufout[32+i];
bufout[32+i] = j;
}
/* Inverse Initial Permutation */
buffer[ 0] = bufout[39];
buffer[ 1] = bufout[ 7];
buffer[ 2] = bufout[47];
buffer[ 3] = bufout[15];
buffer[ 4] = bufout[55];
buffer[ 5] = bufout[23];
buffer[ 6] = bufout[63];
buffer[ 7] = bufout[31];
buffer[ 8] = bufout[38];
buffer[ 9] = bufout[ 6];
buffer[10] = bufout[46];
buffer[11] = bufout[14];
buffer[12] = bufout[54];
buffer[13] = bufout[22];
buffer[14] = bufout[62];
buffer[15] = bufout[30];
buffer[16] = bufout[37];
buffer[17] = bufout[ 5];
buffer[18] = bufout[45];
buffer[19] = bufout[13];
buffer[20] = bufout[53];
buffer[21] = bufout[21];
buffer[22] = bufout[61];
buffer[23] = bufout[29];
buffer[24] = bufout[36];
buffer[25] = bufout[ 4];
buffer[26] = bufout[44];
buffer[27] = bufout[12];
buffer[28] = bufout[52];
buffer[29] = bufout[20];
buffer[30] = bufout[60];
buffer[31] = bufout[28];
buffer[32] = bufout[35];
buffer[33] = bufout[ 3];
buffer[34] = bufout[43];
buffer[35] = bufout[11];
buffer[36] = bufout[51];
buffer[37] = bufout[19];
buffer[38] = bufout[59];
buffer[39] = bufout[27];
buffer[40] = bufout[34];
buffer[41] = bufout[ 2];
buffer[42] = bufout[42];
buffer[43] = bufout[10];
buffer[44] = bufout[50];
buffer[45] = bufout[18];
buffer[46] = bufout[58];
buffer[47] = bufout[26];
buffer[48] = bufout[33];
buffer[49] = bufout[ 1];
buffer[50] = bufout[41];
buffer[51] = bufout[ 9];
buffer[52] = bufout[49];
buffer[53] = bufout[17];
buffer[54] = bufout[57];
buffer[55] = bufout[25];
buffer[56] = bufout[32];
buffer[57] = bufout[ 0];
buffer[58] = bufout[40];
buffer[59] = bufout[ 8];
buffer[60] = bufout[48];
buffer[61] = bufout[16];
buffer[62] = bufout[56];
buffer[63] = bufout[24];
j = 0;
for (i = 0; i < 8; i++) {
*(dest + i) = 0x00;
for (k = 0; k < 7; k++)
*(dest + i) = ((*(dest + i)) + buffer[j+k]) * 2;
*(dest + i) = *(dest + i) + buffer[j+7];
j += 8;
}
有的话 我试试反编译把它转成C#的
不然不知道这么弄了
int GetCVN(char *OriStr,char *result)
{
// memset(OriStr,0,sizeof(OriStr));
// sprintf(OriStr,"%s","41234567890123458701111");
unsigned char operstr[9];
unsigned char uTmp[9];
char OperOri[32+1];
char szBlock1[16+1];
char szBlock2[16+1];
char buf[16+1];
char szResultA[16+1];
char szResultB[16+1];
unsigned long enkA[48], dekB[48];
int len=0;
int i=0,j=0,k=0;//第一步生成数据源,并扩展数据源为32位10进制数
memset(OperOri,0,sizeof(OperOri));
len=strlen(OriStr);
sprintf(OperOri,"%s",OriStr);
sprintf(OperOri+len,"%*.0*d",32-len,32-len,0);
log("第一步:数据源=[%s]\n",OperOri);
//第三步设置block1,block2
memset(szBlock1,0,sizeof(szBlock1));
memset(szBlock2,0,sizeof(szBlock2));
sprintf(szBlock1,"%16.16s",OperOri);
sprintf(szBlock2,"%16.16s",OperOri+16);
log("第三步:Block1=[%s]\n\tBlock2=[%s]\n",szBlock1,szBlock2);//第四步用KeyA对Block1加密
memset(buf,0,sizeof(buf));
memset(operstr,0,sizeof(operstr));
sprintf(buf,"%16.16s",szBlock1);
log("buf=[%s]\n",buf);
asc_to_bcd(buf,16,(char *)operstr);
log("operstr=[%s]\n",operstr);
deskey(KeyA, EN0, enkA);
deskey(KeyB, DE1, dekB); memset(uTmp,0,sizeof(uTmp));
desalgo (operstr,8,uTmp, enkA);// cDes desA(KeyA);
// log("实例des成功......\n");
// Sun_Des desA(KeyA);
// des.Sun_Encrypt((unsigned char *)buf,16);
// desA.Sun_Encrypt(operstr,8);
// desA.Encrypt(operstr,8);
memset(szResultA,0,sizeof(szResultA));
// memset(operstr,0,sizeof
memcpy(operstr,uTmp,8);// bcd_to_asc((char *)buf,16,szResultA);
bcd_to_asc((char *)operstr,16,szResultA);
log("第四步:用KeyA对Block1加密=[%s],buf=[%s]\n",szResultA,(char *)operstr);//第五步:用Block1的加密结果与Block2异或,在用KeyA加密
memset(szResultB,0,sizeof(szResultB));
memset(buf,0,sizeof(buf));
asc_to_bcd(szBlock2,16,buf); for(i=0; i<8; i++)
operstr[i] ^= buf[i];
bcd_to_asc((char *)operstr,16,szResultB);
log("第五步:Block1加密结果与Block2异或结果operstr=[%s],RB=[%s]\n",operstr,szResultB);
memset(uTmp,0,sizeof(uTmp));
desalgo(operstr,8,uTmp,enkA);
// desA.Encrypt(operstr,8);
// desA.Sun_Encrypt(operstr,8);
memset(szResultB,0,sizeof(szResultB));
memcpy(operstr,uTmp,8);
bcd_to_asc((char *)operstr,16,szResultB);
log("\t\t用KeyA加密后的结果:=[%s]\n",szResultB);
//第六步:用KeyB解密
memset(uTmp,0,sizeof(uTmp));
desalgo(operstr,8,uTmp,dekB);
// cDes desB(KeyB);
// desB.Decrypt(operstr,8);
// Sun_Des desB(KeyB)
// desB.Sun_Decrypt(operstr,8); memset(szResultB,0,sizeof(szResultB));
memcpy(operstr,uTmp,8);
bcd_to_asc((char *)operstr,16,szResultB);
log("第六步:用KeyB解密后的结果为=[%s]\n",szResultB);//第七步:用KeyA加密
memset(uTmp,0,sizeof(uTmp));
desalgo(operstr,8,uTmp,enkA);
// desA.Encrypt(operstr,8);
// desA.Sun_Encrypt(operstr,8); memset(szResultB,0,sizeof(szResultB));
memcpy(operstr,uTmp,8);
bcd_to_asc((char *)operstr,16,szResultB);
log("第七步:用KeyA加密后的结果为=[%s]\n",szResultB);//第八步:抽出结果中的数字
memset(szResultA,0,sizeof(szResultA));
memset(buf,0,sizeof(buf));
for(i=0;i<16;i++)
{
if(isdigit(szResultB[i]))
{
szResultA[j]=szResultB[i];
j++;
}
else
{
buf[k]=szResultB[i];
k++;
}
}
log("第八步:抽出结果中的数字=[%s]\n",szResultA);//第九步:抽出结果中的字符,减10后,连接到第八步的结果之后
log("第九步:抽出结果中的字符=[%s]\n",buf);
memset(OperOri,0,sizeof(OperOri)); len=strlen(buf);
for(i=0;i<len;i++)
{
switch(buf[i])
{
case 'A':
j=10;
break;
case 'B':
j=11;
break;
case 'C':
j=12;
break;
case 'D':
j=13;
break;
case 'E':
j=14;
break;
case 'F':
j=15;
break;
default:
return -1;
}
sprintf(OperOri+i,"%d",j-10);
}
log("\t\t减10后的数字串是:=[%s]\n",OperOri);
strcat(szResultA,OperOri);
log("\t\t连接到地八步后的串是:=[%s]\n",szResultA);//第十部取结果串的最左边三位为CVN码
memset(result,0,sizeof(result));
sprintf(result,"%3.3s",szResultA);
log("第十步:CVN=[%s]\n",result);
return 1;}
int CARD::Get_Cvn(char *kstr,char *mdte,char *mfdm)
{
/*************************************************************
*卡号(kstr)+有效期(mdte)+服务代码(mfdm)
**************************************************************/
unsigned char KeyA[8]={0xd3,0x1a,0xe7,0x29,0x5b,0x48,0xcf,0x06};
unsigned char KeyB[8]={0x2b,0x62,0x13,0x7d,0x0b,0xfb,0x9a,0x68};
//logfile->Write("zgy bb:kstr=%19.19s,mdte=%4.4s,mfdm=%3.3s\n",kstr,mdte,mfdm);
//logfile->Write("zgy bb:kstr=%s,mdte=%s,mfdm=%s\n",kstr,mdte,mfdm); cDes desA (KeyA);
cDes desB (KeyB);
unsigned char data[8],data1[8],tmstr1[5],result[17]; char mstr[33],bstr[129],tmstr[3];
char block1[17],block2[17];
int tlen,i,len,l;
char t1,t2,t3[2];
char cstr[2],cestr[2],tnum[17],cnum[17],tstr[17],testr[17];
char rnum[17];
char cvn[4]; tlen=32; /**************************************************************
*将卡号+有效期+服务代码扩展到128位数据源（不足128右补二进制0）
**************************************************************/
memset(mstr,'\0',sizeof(mstr)); /*nTrim(kstr);
nTrim(mdte);
nTrim(mfdm);*/
strcpy(kstr,trim(kstr));
strcpy(mdte,trim(mdte));
strcpy(mfdm,trim(mfdm)); strcpy(mstr,kstr);
strcat(mstr,mdte);
strcat(mstr,mfdm);
for (i=strlen(mstr);i<tlen;i++)
{
strcat(mstr,"0");
} /**************************************************************
*将128位数据源分成两个64位的数据块。最左边64位为block1，最右边
*64位为block2
**************************************************************/
memset(block1,'\0',sizeof(block1));
memset(block2,'\0',sizeof(block2)); strncpy(block1,mstr,16); strncpy(block2,mstr+16,16); /**************************************************************
*block1转换为8字节的十六进制字符串data
**************************************************************/
memset(data,'\0',sizeof(data));
memset(tmstr,'\0',sizeof(tmstr));
memset(tmstr1,'\0',sizeof(tmstr1)); len=0;
for(i=0;i<8;i++)
{
strncpy(tmstr,block1+len,2);
asc_to_bcd((unsigned char *)tmstr1,(unsigned char *)tmstr,2,0);
data[i]=tmstr1[0];
len=len+2;
} /**************************************************************
*将data数据用KeyA加密，结果为result
**************************************************************/
memset(result,'\0',sizeof(result)); //des(data,result,KeyA,1);
memcpy(result, data, sizeof(data));
desA.Encrypt(result);/*
printf("%02x",result[0]);
printf("%02x",result[1]);
printf("%02x",result[2]);
printf("%02x",result[3]);
printf("%02x",result[4]);
printf("%02x",result[5]);
printf("%02x",result[6]);
printf("%02x\n",result[7]);
*/ /**************************************************************
*将result，转换为8字节的字符串tstr
**************************************************************/
memset(tstr,'\0',sizeof(tstr));
memset(cstr,'\0',sizeof(cstr)); for(i=0;i<8;i++)
{
sprintf(cstr,"%02x", result[i]);
strcat(tstr,cstr);
} /**************************************************************
*将tstr同block2进行异或，结果为testr
**************************************************************/
memset(testr,'\0',sizeof(testr));
memset(cestr,'\0',sizeof(cestr)); for(i=0;i<16;i++)
{
if (tstr[i]>='a' || tstr[i]>='A')
t1=tstr[i]-'a'+10;
else
t1=tstr[i]-'0';
if (block2[i]>='a' || block2[i]>='A')
t2=block2[i]-'a'+10;
else
t2=block2[i]-'0';
sprintf(cestr,"%x", t1^t2);
strcat(testr,cestr);
} /**************************************************************
*testr转换为8字节的十六进制字符串data1
**************************************************************/
memset(data1,'\0',sizeof(data1));
memset(tmstr,'\0',sizeof(tmstr));
memset(tmstr1,'\0',sizeof(tmstr1));
len=0;
for(i=0;i<8;i++)
{
strncpy(tmstr,testr+len,2);
asc_to_bcd((unsigned char *)tmstr1,(unsigned char *)tmstr,2,0);
data1[i]=tmstr1[0];
len=len+2;
} /**************************************************************
*将data1数据用KeyA加密，结果为result
**************************************************************/
memset(result,'\0',sizeof(result)); //des(data1,result,KeyA,1);
memcpy(result, data1, sizeof(data1));
desA.Encrypt(result);/*
printf("%02x",result[0]);
printf("%02x",result[1]);
printf("%02x",result[2]);
printf("%02x",result[3]);
printf("%02x",result[4]);
printf("%02x",result[5]);
printf("%02x",result[6]);
printf("%02x\n",result[7]);
*/ /**************************************************************
*将result数据用KeyB解密，结果为result
**************************************************************/
//des(result,result,KeyB,0);
//memcpy(result, result, sizeof(result));
desB.Decrypt(result);/*
printf("%02x",result[0]);
printf("%02x",result[1]);
printf("%02x",result[2]);
printf("%02x",result[3]);
printf("%02x",result[4]);
printf("%02x",result[5]);
printf("%02x",result[6]);
printf("%02x\n",result[7]);
*/ /**************************************************************
*将result数据用KeyA加密，结果为result
**************************************************************/
//des(result,result,KeyA,1);
//memcpy(result, result, sizeof(result));
desA.Encrypt(result);/*
printf("%02x",result[0]);
printf("%02x",result[1]);
printf("%02x",result[2]);
printf("%02x",result[3]);
printf("%02x",result[4]);
printf("%02x",result[5]);
printf("%02x",result[6]);
printf("%02x\n",result[7]);
*/ /**************************************************************
*将result转换为8字节十六进制数据tstr
**************************************************************/
memset(cstr,'\0',sizeof(cstr));
memset(tstr,'\0',sizeof(tstr)); for(i=0;i<8;i++)
{
sprintf(cstr,"%02x", result[i]);
strcat(tstr,cstr);
} /**************************************************************
*将tstr中的数字提取出来，结果tnum；
*将tstr中的字符抽出，减10后将余数组成一组数字cnum，放在tnum后
**************************************************************/
memset(tnum,'\0',sizeof(tnum));
memset(cnum,'\0',sizeof(cnum)); for(i=0;i<16;i++)
{
if (tstr[i]>='0' && tstr[i]<='9')
{
sprintf(t3,"%c",tstr[i] );
strcat(tnum,t3);
}
if ((tstr[i]>='a' && tstr[i]<='f') ||
(tstr[i]>='A' && tstr[i]<='F'))
{
sprintf(t3,"%d",tstr[i]-'a');
strcat(cnum,t3);
}
} memset(rnum,'\0',sizeof(rnum));
strcpy(rnum,tnum);
strcat(rnum,cnum); memset(cvn,'\0',sizeof(cvn)); strncpy(cvn,rnum,3); strcpy(Tcvn,cvn);
//logfile->Write("Tcvn=%s,cvn=%s\n",Tcvn,cvn); return 0;
}
我把代码拷贝到c++项目里编译一下错误一大堆，不知道怎么改。
你还是再发个帖子请个会c++的进来这边看把。
结果：B76A DDCE 71CC C6BE 16位我加密出来的结果却是24位
private void Button1_Click(object sender, System.EventArgs e)
{
//第一步：合并字符串（将卡号+有效期+服务代码）
string str = "62242196010000049944912120"; //第二步：补齐128位二进制零
byte[] binaryBytes = System.Text.Encoding.Unicode.GetBytes(str);
//以UTF8编码方式，把字节数组还原为字符串。
string newText = System.Text.Encoding.Unicode.GetString( binaryBytes );
//向右补齐128位二进制零
while(newText.Length<32)
{
newText=newText+"0";
} //第三步：/**************************************************************/
/*将128位数据源分成两个64位的数据块。最左边64位为block1，最右边*/
/*64位为block2**************************************************/
string Block1=newText.Substring(0,16);//最左边的64位为Block1
string Block2=newText.Substring(16);//最右边的64位为Block2
//第四步：。。
}
将data数据用KeyA加密，结果为result
将result，转换为8字节的字符串tstr
参照C代码
/**************************************************************
*block1转换为8字节的十六进制字符串data
**************************************************************/
memset(data,'\0',sizeof(data));//设置s中的所有字节为ch, s数组的大小由n给定
memset(tmstr,'\0',sizeof(tmstr));
memset(tmstr1,'\0',sizeof(tmstr1)); len=0;
for(i=0;i<8;i++)
{
strncpy(tmstr,block1+len,2);
asc_to_bcd((unsigned char *)tmstr1,(unsigned char *)tmstr,2,0);
data[i]=tmstr1[0];
len=len+2;
} /**************************************************************
*将data数据用KeyA加密，结果为result
**************************************************************/
memset(result,'\0',sizeof(result)); memcpy(result, data, sizeof(data));
desA.Encrypt(result);
/**************************************************************
*将result，转换为8字节的字符串tstr
**************************************************************/
memset(tstr,'\0',sizeof(tstr));
memset(cstr,'\0',sizeof(cstr)); for(i=0;i<8;i++)
{
sprintf(cstr,"%02x", result[i]);
strcat(tstr,cstr);
}
(string)block1转换为16进制为:36323234323139363031303030303034 采用密钥:0123456789ABCDEF进行3DES加密结果为q7DTyQsmu5NQ5L6riPCnVDx6GXsYORFzHhJZA2pjHjyrulxKIzP4Qw==
(int)block1转换为16进制为:161CE50E525644 采用密钥:0123456789ABCDEF进行3DES加密结果为5DQAlwA3AH8rXp4EntS8vg==结果都跟你那个不一样呀
len=0;
for(i=0;i<8;i++)
{
strncpy(tmstr,block1+len,2);
asc_to_bcd((unsigned char *)tmstr1,(unsigned char *)tmstr,2,0);
data[i]=tmstr1[0];
len=len+2;
}//C#==================
string [] data = new string[8];
int j = 0;
for (int i = 0; i < 8; i++)
{
data[i] = String.Format(CultureInfo.InvariantCulture, "{0:X2}", Convert.ToInt32(Block1.Substring(j, 2)));
j += 2;
}==========加密============
desA.Encrypt(result);
怎么加密都不对 不会翻译这里。
=========================
//C++======================
for(i=0;i<8;i++)
{
sprintf(cstr,"%02x", result[i]);
strcat(tstr,cstr);
}
//C#======================
string tstr = "";
for(i=0;i<8;i++)\
{
tstr += result[i].ToString("X2");
}
block1转换为8字节的十六进制字符串data，我刚在看这里是我把字符串转成十六进制在截取8位还是怎么算的。
*block1转换为8字节的十六进制字符串data
**************************************************************/
memset(data,'\0',sizeof(data));//设置s中的所有字节为ch, s数组的大小由n给定
memset(tmstr,'\0',sizeof(tmstr));
memset(tmstr1,'\0',sizeof(tmstr1)); len=0;
for(i=0;i<8;i++)
{
strncpy(tmstr,block1+len,2); // 假如:block1 =4123456789012345,第一次循环截取 41，第二次截取23、45、67类推。
asc_to_bcd((unsigned char *)tmstr1,(unsigned char *)tmstr,2,0);//十六进制字符串data，上面注释中这样写到，应该是将41（string还是int就不知道了）转换成16进制。
data[i]=tmstr1[0]; // 把转换后的结果给data数组， data是string[]还是byte[]也不知道
len=len+2;
}
不如你直接问一下需求方
1.是否采用3DES加密，字符串的编码有什么规定，不同编码加密出来的东西也不一样
2.如果值是 4123456789012345 KEY是:0123456789ABCDEF 加密出来的数据是多少？（可以有个正确参照）、
3. 是直接拿4123456789012345 进行加密还是处理后的数据进行的DES加密，如果是处理后的那么处理的需求是什么（如上面的什么转换成8位16进制）。
这几个问题搞清楚了就没什么难度了