3des算法c实现和c#实现

weixin_30752699

于 2019-07-26 10:02:26 发布

阅读量529

点赞数

文章标签： c#

原文链接：http://www.cnblogs.com/codingking/p/4535162.html

版权

Single-length key, single-length plaintext -

* Key : 0123 4567 89ab cdef

* Plain : 0123 4567 89ab cde7

* Cipher : c957 4425 6a5e d31d

* Double-length key, single-length plaintext -

* Key : 0123 4567 89ab cdef fedc ba98 7654 3210

* Plain : 0123 4567 89ab cde7

* Cipher : 7f1d 0a77 826b 8aff

* Double-length key, double-length plaintext -

* Key : 0123 4567 89ab cdef fedc ba98 7654 3210

* Plain : 0123 4567 89ab cdef 0123 4567 89ab cdff

* Cipher : 27a0 8440 406a df60 278f 47cf 42d6 15d7

* Triple-length key, single-length plaintext -

* Key : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567

* Plain : 0123 4567 89ab cde7

* Cipher : de0b 7c06 ae5e 0ed5

* Triple-length key, double-length plaintext -

* Key : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567

* Plain : 0123 4567 89ab cdef 0123 4567 89ab cdff

* Cipher : ad0d 1b30 ac17 cf07 0ed1 1c63 81e4 4de5

#define EN0 0 /* MODE == encrypt */

#define DE1 1 /* MODE == decrypt */

class DESCryptoServiceProvider

{

public :

//3des 加密算法第一个参数为密码，第二个参数为明文，第三个参数为输出的密文，第四个参数为明文的字节数

static void FinalD3desEncryption ( unsigned char * key , unsigned char * inblock , unsigned char * outbolck , int n );

//3des 解密算法第一个参数为密码，第二个参数为密文，第三个参数为输出的明文，第四个参数为密文的字节数

static void FinalD3desDecryption ( unsigned char * key , unsigned char *inblock , unsigned char * outbolck , int n );

protected :

private :

// 这些方法都是自动调用的，并不用去管

//3des 处理字节的数据，第一个参数为输入的明文或者密文，第二个数据为输出的经过加密解密后的数据

static void Ddes ( unsigned char *, unsigned char *);

//3des 处理字节的密码，第一个参数为输入的密码，第二个参数为加密或者解密

static void des3key ( unsigned char *, short );

// 将明文或者密文的数据经过初始处理

static void scrunch ( unsigned char *, unsigned long *);

static void unscrun ( unsigned long *, unsigned char *);

// 将数据经过变换得到后经过 s 盒进行瘦身，得到最终数据

static void desfunc ( unsigned long *, unsigned long *);

// 处理初试密码的函数，将经过次迭代的密码存储到一个临时变量 unsigned long kn[32]中去。

static void deskey ( unsigned char *, short );

// 将次迭代过的密码经过变换得到最终的密码

static void cookey ( unsigned long *);

// 将临时变量中的密码存储到静态变量 Knl 中去

static void cpkey ( unsigned long *);

// 将临时变量中的密码存储到静态变量 Knl Knr Kn3 中去

static void usekey ( unsigned long *);

private :

static unsigned long KnL [32 ]; //把长整形 knl 赋值为

static unsigned long KnR [32 ];

static unsigned long Kn3 [32 ] ;

static unsigned char Df_Key [24 ];

static unsigned short bytebit [8 ];

static unsigned long bigbyte [24 ];

/* Use the key schedule specified in the Standard (ANSI X3.92-1981). */

// 应该是等分密钥表

static unsigned char pc1 [56 ];

static unsigned char totrot [16 ]; //第 i 次迭代时循环左移的位数

static unsigned char pc2 [48 ];

//s 盒

static unsigned long SP1 [64 ] ;

static unsigned long SP2 [64 ];

static unsigned long SP3 [64 ];

static unsigned long SP4 [64 ] ;

static unsigned long SP5 [64 ];

static unsigned long SP6 [64 ] ;

static unsigned long SP7 [64 ];

static unsigned long SP8 [64 ];

};

#include "DESCryptoServiceProvider.h"

#include <stdio.h>

// 数组是存放进行迭代后的字节密码

unsigned long DESCryptoServiceProvider :: KnL [32 ] = { 0L };

unsigned long DESCryptoServiceProvider :: KnR [32 ] = { 0L };

unsigned long DESCryptoServiceProvider :: Kn3 [32 ] = { 0L };

// 取得位数据中的每一位

unsigned long DESCryptoServiceProvider :: bigbyte [24 ] = {

0x800000L , 0x400000L , 0x200000L , 0x100000L ,

0x80000L , 0x40000L , 0x20000L , 0x10000L ,

0x8000L , 0x4000L , 0x2000L , 0x1000L ,

0x800L , 0x400L , 0x200L , 0x100L ,

0x80L , 0x40L, 0x20L, 0x10L,

0x8L , 0x4L, 0x2L, 0x1L };

unsigned char DESCryptoServiceProvider :: Df_Key [24 ] = {

0x01 ,0x23, 0x45,0x67 ,0x89, 0xab,0xcd ,0xef, //ox 是进制

0xfe ,0xdc, 0xba,0x98 ,0x76, 0x54,0x32 ,0x10,

0x89 ,0xab, 0xcd,0xef ,0x01, 0x23,0x45 ,0x67 };

// 用来进行迭代时的密钥循环左移

unsigned short DESCryptoServiceProvider :: bytebit [8 ] = {

0200 , 0100, 040, 020 , 010, 04, 02 , 01 };

//pc1 的表，用来把字节的密钥进行初始化去掉奇偶校验位并且换位

unsigned char DESCryptoServiceProvider :: pc1 [56 ] = {

56 , 48, 40, 32 , 24, 16, 8 , 0 , 57, 49, 41 , 33, 25, 17 ,

9 , 1, 58, 50 , 42, 34, 26 , 18 , 10, 2, 59 , 51, 43, 35 ,

62 , 54, 46, 38 , 30, 22, 14 , 6 , 61, 53, 45 , 37, 29, 21 ,

13 , 5, 60, 52 , 44, 36, 28 , 20 , 12, 4, 27 , 19, 11, 3 };

unsigned char DESCryptoServiceProvider :: totrot [16 ] = {

1 ,2, 4,6 ,8, 10,12 ,14, 15,17 ,19, 21,23 ,25, 27,28 }; //?第 i 次迭代时循环左移的位数

unsigned char DESCryptoServiceProvider :: pc2 [48 ] = { // 迭代结束所生成的位密钥

13 , 16, 10, 23 , 0, 4, 2 , 27, 14, 5 , 20, 9,

22 , 18, 11, 3 , 25, 7, 15 , 6, 26, 19 , 12, 1,

40 , 51, 30, 36 , 46, 54, 29 , 39, 50, 44 , 32, 47,

43 , 48, 38, 55 , 33, 52, 45 , 41, 49, 35 , 28, 31 };

//8 个s盒

unsigned long DESCryptoServiceProvider :: SP1 [64 ] = {

0x01010400L , 0x00000000L, 0x00010000L, 0x01010404L ,

0x01010004L , 0x00010404L, 0x00000004L, 0x00010000L ,

0x00000400L , 0x01010400L, 0x01010404L, 0x00000400L ,

0x01000404L , 0x01010004L, 0x01000000L, 0x00000004L ,

0x00000404L , 0x01000400L, 0x01000400L, 0x00010400L ,

0x00010400L , 0x01010000L, 0x01010000L, 0x01000404L ,

0x00010004L , 0x01000004L, 0x01000004L, 0x00010004L ,

0x00000000L , 0x00000404L, 0x00010404L, 0x01000000L ,

0x00010000L , 0x01010404L, 0x00000004L, 0x01010000L ,

0x01010400L , 0x01000000L, 0x01000000L, 0x00000400L ,

0x01010004L , 0x00010000L, 0x00010400L, 0x01000004L ,

0x00000400L , 0x00000004L, 0x01000404L, 0x00010404L ,

0x01010404L , 0x00010004L, 0x01010000L, 0x01000404L ,

0x01000004L , 0x00000404L, 0x00010404L, 0x01010400L ,

0x00000404L , 0x01000400L, 0x01000400L, 0x00000000L ,

0x00010004L , 0x00010400L, 0x00000000L, 0x01010004L };

unsigned long DESCryptoServiceProvider :: SP2 [64 ] = {

0x80108020L , 0x80008000L, 0x00008000L, 0x00108020L ,

0x00100000L , 0x00000020L, 0x80100020L, 0x80008020L ,

0x80000020L , 0x80108020L, 0x80108000L, 0x80000000L ,

0x80008000L , 0x00100000L, 0x00000020L, 0x80100020L ,

0x00108000L , 0x00100020L, 0x80008020L, 0x00000000L ,

0x80000000L , 0x00008000L, 0x00108020L, 0x80100000L ,

0x00100020L , 0x80000020L, 0x00000000L, 0x00108000L ,

0x00008020L , 0x80108000L, 0x80100000L, 0x00008020L ,

0x00000000L , 0x00108020L, 0x80100020L, 0x00100000L ,

0x80008020L , 0x80100000L, 0x80108000L, 0x00008000L ,

0x80100000L , 0x80008000L, 0x00000020L, 0x80108020L ,

0x00108020L , 0x00000020L, 0x00008000L, 0x80000000L ,

0x00008020L , 0x80108000L, 0x00100000L, 0x80000020L ,

0x00100020L , 0x80008020L, 0x80000020L, 0x00100020L ,

0x00108000L , 0x00000000L, 0x80008000L, 0x00008020L ,

0x80000000L , 0x80100020L, 0x80108020L, 0x00108000L };

unsigned long DESCryptoServiceProvider :: SP3 [64 ] = {

0x00000208L , 0x08020200L, 0x00000000L, 0x08020008L ,

0x08000200L , 0x00000000L, 0x00020208L, 0x08000200L ,

0x00020008L , 0x08000008L, 0x08000008L, 0x00020000L ,

0x08020208L , 0x00020008L, 0x08020000L, 0x00000208L ,

0x08000000L , 0x00000008L, 0x08020200L, 0x00000200L ,

0x00020200L , 0x08020000L, 0x08020008L, 0x00020208L ,

0x08000208L , 0x00020200L, 0x00020000L, 0x08000208L ,

0x00000008L , 0x08020208L, 0x00000200L, 0x08000000L ,

0x08020200L , 0x08000000L, 0x00020008L, 0x00000208L ,

0x00020000L , 0x08020200L, 0x08000200L, 0x00000000L ,

0x00000200L , 0x00020008L, 0x08020208L, 0x08000200L ,

0x08000008L , 0x00000200L, 0x00000000L, 0x08020008L ,

0x08000208L , 0x00020000L, 0x08000000L, 0x08020208L ,

0x00000008L , 0x00020208L, 0x00020200L, 0x08000008L ,

0x08020000L , 0x08000208L, 0x00000208L, 0x08020000L ,

0x00020208L , 0x00000008L, 0x08020008L, 0x00020200L };

unsigned long DESCryptoServiceProvider :: SP4 [64 ] = {

0x00802001L , 0x00002081L, 0x00002081L, 0x00000080L ,

0x00802080L , 0x00800081L, 0x00800001L, 0x00002001L ,

0x00000000L , 0x00802000L, 0x00802000L, 0x00802081L ,

0x00000081L , 0x00000000L, 0x00800080L, 0x00800001L ,

0x00000001L , 0x00002000L, 0x00800000L, 0x00802001L ,

0x00000080L , 0x00800000L, 0x00002001L, 0x00002080L ,

0x00800081L , 0x00000001L, 0x00002080L, 0x00800080L ,

0x00002000L , 0x00802080L, 0x00802081L, 0x00000081L ,

0x00800080L , 0x00800001L, 0x00802000L, 0x00802081L ,

0x00000081L , 0x00000000L, 0x00000000L, 0x00802000L ,

0x00002080L , 0x00800080L, 0x00800081L, 0x00000001L ,

0x00802001L , 0x00002081L, 0x00002081L, 0x00000080L ,

0x00802081L , 0x00000081L, 0x00000001L, 0x00002000L ,

0x00800001L , 0x00002001L, 0x00802080L, 0x00800081L ,

0x00002001L , 0x00002080L, 0x00800000L, 0x00802001L ,

0x00000080L , 0x00800000L, 0x00002000L, 0x00802080L };

unsigned long DESCryptoServiceProvider :: SP5 [64 ] = {

0x00000100L , 0x02080100L, 0x02080000L, 0x42000100L ,

0x00080000L , 0x00000100L, 0x40000000L, 0x02080000L ,

0x40080100L , 0x00080000L, 0x02000100L, 0x40080100L ,

0x42000100L , 0x42080000L, 0x00080100L, 0x40000000L ,

0x02000000L , 0x40080000L, 0x40080000L, 0x00000000L ,

0x40000100L , 0x42080100L, 0x42080100L, 0x02000100L ,

0x42080000L , 0x40000100L, 0x00000000L, 0x42000000L ,

0x02080100L , 0x02000000L, 0x42000000L, 0x00080100L ,

0x00080000L , 0x42000100L, 0x00000100L, 0x02000000L ,

0x40000000L , 0x02080000L, 0x42000100L, 0x40080100L ,

0x02000100L , 0x40000000L, 0x42080000L, 0x02080100L ,

0x40080100L , 0x00000100L, 0x02000000L, 0x42080000L ,

0x42080100L , 0x00080100L, 0x42000000L, 0x42080100L ,

0x02080000L , 0x00000000L, 0x40080000L, 0x42000000L ,

0x00080100L , 0x02000100L, 0x40000100L, 0x00080000L ,

0x00000000L , 0x40080000L, 0x02080100L, 0x40000100L };

unsigned long DESCryptoServiceProvider :: SP6 [64 ] = {

0x20000010L , 0x20400000L, 0x00004000L, 0x20404010L ,

0x20400000L , 0x00000010L, 0x20404010L, 0x00400000L ,

0x20004000L , 0x00404010L, 0x00400000L, 0x20000010L ,

0x00400010L , 0x20004000L, 0x20000000L, 0x00004010L ,

0x00000000L , 0x00400010L, 0x20004010L, 0x00004000L ,

0x00404000L , 0x20004010L, 0x00000010L, 0x20400010L ,

0x20400010L , 0x00000000L, 0x00404010L, 0x20404000L ,

0x00004010L , 0x00404000L, 0x20404000L, 0x20000000L ,

0x20004000L , 0x00000010L, 0x20400010L, 0x00404000L ,

0x20404010L , 0x00400000L, 0x00004010L, 0x20000010L ,

0x00400000L , 0x20004000L, 0x20000000L, 0x00004010L ,

0x20000010L , 0x20404010L, 0x00404000L, 0x20400000L ,

0x00404010L , 0x20404000L, 0x00000000L, 0x20400010L ,

0x00000010L , 0x00004000L, 0x20400000L, 0x00404010L ,

0x00004000L , 0x00400010L, 0x20004010L, 0x00000000L ,

0x20404000L , 0x20000000L, 0x00400010L, 0x20004010L };

unsigned long DESCryptoServiceProvider :: SP7 [64 ] = {

0x00200000L , 0x04200002L, 0x04000802L, 0x00000000L ,

0x00000800L , 0x04000802L, 0x00200802L, 0x04200800L ,

0x04200802L , 0x00200000L, 0x00000000L, 0x04000002L ,

0x00000002L , 0x04000000L, 0x04200002L, 0x00000802L ,

0x04000800L , 0x00200802L, 0x00200002L, 0x04000800L ,

0x04000002L , 0x04200000L, 0x04200800L, 0x00200002L ,

0x04200000L , 0x00000800L, 0x00000802L, 0x04200802L ,

0x00200800L , 0x00000002L, 0x04000000L, 0x00200800L ,

0x04000000L , 0x00200800L, 0x00200000L, 0x04000802L ,

0x04000802L , 0x04200002L, 0x04200002L, 0x00000002L ,

0x00200002L , 0x04000000L, 0x04000800L, 0x00200000L ,

0x04200800L , 0x00000802L, 0x00200802L, 0x04200800L ,

0x00000802L , 0x04000002L, 0x04200802L, 0x04200000L ,

0x00200800L , 0x00000000L, 0x00000002L, 0x04200802L ,

0x00000000L , 0x00200802L, 0x04200000L, 0x00000800L ,

0x04000002L , 0x04000800L, 0x00000800L, 0x00200002L };

unsigned long DESCryptoServiceProvider ::

SP8 [64 ] = {

0x10001040L , 0x00001000L, 0x00040000L, 0x10041040L ,

0x10000000L , 0x10001040L, 0x00000040L, 0x10000000L ,

0x00040040L , 0x10040000L, 0x10041040L, 0x00041000L ,

0x10041000L , 0x00041040L, 0x00001000L, 0x00000040L ,

0x10040000L , 0x10000040L, 0x10001000L, 0x00001040L ,

0x00041000L , 0x00040040L, 0x10040040L, 0x10041000L ,

0x00001040L , 0x00000000L, 0x00000000L, 0x10040040L ,

0x10000040L , 0x10001000L, 0x00041040L, 0x00040000L ,

0x00041040L , 0x00040000L, 0x10041000L, 0x00001000L ,

0x00000040L , 0x10040040L, 0x00001000L, 0x00041040L ,

0x10001000L , 0x00000040L, 0x10000040L, 0x10040000L ,

0x10040040L , 0x10000000L, 0x00040000L, 0x10001040L ,

0x00000000L , 0x10041040L, 0x00040040L, 0x10000040L ,

0x10040000L , 0x10001000L, 0x10001040L, 0x00000000L ,

0x10041040L , 0x00041000L, 0x00041000L, 0x00001040L ,

0x00001040L , 0x00040040L, 0x10000000L, 0x10041000L };

//deskey 函数这个函数的作用是用来将字节位的密码进行初始化并且迭代生成最终密码

void DESCryptoServiceProvider :: deskey ( unsigned char * key , short edf )

{

unsigned char pc1m [56 ], pcr[56];

unsigned long kn [32 ];

for ( j = 0; j < 56; j ++ ) {

l = pc1 [ j ]; // 将那个表的个数赋给 l

m = l & 07;

pc1m [ j ] = ( key [ l >> 3] & bytebit[m]) ? 1 : 0;

}

for ( i = 0; i < 16; i ++ ) {

if ( edf == DE1 ) m = ( 15 - i) << 1;

else m = i << 1;

n = m + 1;

kn [ m ] = kn [ n ] = 0L;

for ( j = 0; j < 28; j ++ ) {

l = j + totrot [ i ];

if ( l < 28 ) pcr[j] = pc1m[l];

else pcr [ j ] = pc1m [ l - 28];

}

for ( j = 28; j < 56; j ++ ) {

l = j + totrot [ i ];

if ( l < 56 ) pcr[j] = pc1m[l];

else pcr [ j ] = pc1m [ l - 28];

}

for ( j = 0; j < 24; j ++ ) {

if ( pcr [ pc2 [ j ]] ) kn [ m ] |= bigbyte [ j ];

if ( pcr [ pc2 [ j +24 ]] ) kn[n] |= bigbyte[j];

}

cookey ( kn );

return ;

}

// 将密码进行一次变换

void DESCryptoServiceProvider :: cookey ( unsigned long * raw1 )

{

unsigned long dough [32 ];

cook = dough ;

for ( i = 0; i < 16; i ++, raw1 ++ ) {

raw0 = raw1 ++;

* cook = (* raw0 & 0x00fc0000L) << 6;

* cook |= (* raw0 & 0x00000fc0L) << 10;

* cook |= (* raw1 & 0x00fc0000L) >> 10;

* cook ++ |= (* raw1 & 0x00000fc0L) >> 6;

* cook = (* raw0 & 0x0003f000L) << 12;

* cook |= (* raw0 & 0x0000003fL) << 16;

* cook |= (* raw1 & 0x0003f000L) >> 4;

* cook ++ |= (* raw1 & 0x0000003fL);

}

usekey ( dough );

}

// 将密码存储到全局变量中去

void DESCryptoServiceProvider :: usekey ( unsigned long * from )

{

to = KnL , endp = & KnL [32 ];

while ( to < endp ) * to ++ = * from ++;

}

// 将字节为数据进行初始变换

void DESCryptoServiceProvider :: scrunch ( unsigned char * outof , unsigned long * into )

{

* into = (* outof ++ & 0xffL) << 24 ;

* into |= (* outof ++ & 0xffL) << 16 ;

* into |= (* outof ++ & 0xffL) << 8 ;

* into ++ |= (* outof ++ & 0xffL);

* into = (* outof ++ & 0xffL) << 24 ;

* into |= (* outof ++ & 0xffL) << 16 ;

* into |= (* outof ++ & 0xffL) << 8 ;

* into |= (* outof & 0xffL);

}

// 将得到的数据进行最终的整理得到最终的数据

void DESCryptoServiceProvider :: unscrun ( unsigned long * outof , unsigned char * into )

{

* into ++ = (* outof >> 24) & 0xffL ;

* into ++ = (* outof >> 16) & 0xffL ;

* into ++ = (* outof >> 8) & 0xffL ;

* into ++ = * outof ++ & 0xffL;

* into ++ = (* outof >> 24) & 0xffL ;

* into ++ = (* outof >> 16) & 0xffL ;

* into ++ = (* outof >> 8) & 0xffL ;

* into = * outof & 0xffL;

}

// 将数据进行分块并且进入 s 盒使得数据瘦身并且得到最终数据

void DESCryptoServiceProvider :: desfunc ( unsigned long * block , unsigned long * keys )

{

leftt = block [0 ];

right = block [1 ];

work = (( leftt >> 4) ^ right) & 0x0f0f0f0fL ;

right ^= work ;

leftt ^= ( work << 4);

work = (( leftt >> 16) ^ right) & 0x0000ffffL ;

right ^= work ;

leftt ^= ( work << 16);

work = (( right >> 2) ^ leftt) & 0x33333333L ;

leftt ^= work ;

right ^= ( work << 2);

work = (( right >> 8) ^ leftt) & 0x00ff00ffL ;

leftt ^= work ;

right ^= ( work << 8);

right = (( right << 1) | ((right >> 31) & 1L)) & 0xffffffffL ;

work = ( leftt ^ right ) & 0xaaaaaaaaL;

leftt ^= work ;

right ^= work ;

leftt = (( leftt << 1) | ((leftt >> 31) & 1L)) & 0xffffffffL ;

for ( round = 0; round < 8; round ++ ) {

work = ( right << 28) | (right >> 4);

work ^= * keys ++;

fval = SP7 [ work & 0x3fL];

fval |= SP5 [( work >> 8) & 0x3fL ];

fval |= SP3 [( work >> 16) & 0x3fL ];

fval |= SP1 [( work >> 24) & 0x3fL ];

work = right ^ * keys ++;

fval |= SP8 [ work & 0x3fL];

fval |= SP6 [( work >> 8) & 0x3fL ];

fval |= SP4 [( work >> 16) & 0x3fL ];

fval |= SP2 [( work >> 24) & 0x3fL ];

leftt ^= fval ;

work = ( leftt << 28) | (leftt >> 4);

work ^= * keys ++;

fval = SP7 [ work & 0x3fL];

fval |= SP5 [( work >> 8) & 0x3fL ];

fval |= SP3 [( work >> 16) & 0x3fL ];

fval |= SP1 [( work >> 24) & 0x3fL ];

work = leftt ^ * keys ++;

fval |= SP8 [ work & 0x3fL];

fval |= SP6 [( work >> 8) & 0x3fL ];

fval |= SP4 [( work >> 16) & 0x3fL ];

fval |= SP2 [( work >> 24) & 0x3fL ];

right ^= fval ;

}

right = ( right << 31) | (right >> 1);

work = ( leftt ^ right ) & 0xaaaaaaaaL;

leftt ^= work ;

right ^= work ;

leftt = ( leftt << 31) | (leftt >> 1);

work = (( leftt >> 8) ^ right) & 0x00ff00ffL ;

right ^= work ;

leftt ^= ( work << 8);

work = (( leftt >> 2) ^ right) & 0x33333333L ;

right ^= work ;

leftt ^= ( work << 2);

work = (( right >> 16) ^ leftt) & 0x0000ffffL ;

leftt ^= work ;

right ^= ( work << 16);

work = (( right >> 4) ^ leftt) & 0x0f0f0f0fL ;

leftt ^= work ;

right ^= ( work << 4);

* block ++ = right ;

* block = leftt ;

}

//3des 算法，第一个参数是字节的明文 / 密文，第二个参数是加密 / 解密得到的密文 / 明文

void DESCryptoServiceProvider :: Ddes ( unsigned char * from , unsigned char * into )

{

unsigned long work [2 ];

/*unsigned char input[]="asdf";

int i=strlen(input);

printf("%d",i);*/

scrunch ( from , work );

desfunc ( work , KnL );

desfunc ( work , KnR );

desfunc ( work , Kn3 );

unscrun ( work , into );

}

void DESCryptoServiceProvider :: cpkey ( unsigned long * into )

{

from = KnL , endp = & KnL [32 ];

while ( from < endp ) * into ++ = * from ++;

return ;

}

// 将字节的 des 密码分别处理并且存储到静态变量当中

void DESCryptoServiceProvider :: des3key ( unsigned char * hexkey , short mode )

{

unsigned char * first , * third ;

short revmod ;

if ( mode == EN0 ) {

revmod = DE1 ;

first = hexkey ;

third = & hexkey [16 ];

}

else {

revmod = EN0 ;

first = & hexkey [16 ];

third = hexkey ;

}

deskey (& hexkey [8 ], revmod);

cpkey ( KnR );

deskey ( third , mode );

cpkey ( Kn3 );

deskey ( first , mode );

}

//3des 的解密算法第一个参数为密码，第二个参数为密钥，第三个参数为输出的明文，第四个参数为密钥的位数

void DESCryptoServiceProvider :: FinalD3desDecryption ( unsigned char * key , unsigned char *inblock , unsigned char * outbolck , int n )

{

unsigned char out [8 ];

unsigned char f_key [24 ];

unsigned char o [9 ];

unsigned char i ;

int j = n /8 ;

int m ;

unsigned char * test ;

unsigned char * temp ;

for ( m =0 ;m<24; m ++)

{

f_key [ m ]=* key ;

key ++;

}

des3key ( f_key ,1 );

for ( i =0 ;i<j;i++)

{

test = inblock ;

for ( m =0 ;m<8; m ++)

{

o [ m ]=*( test + i *8 );

++ test ;

}

Ddes ( o , out );

temp = out ;

for ( m =0 ;m<8; m ++)

{

outbolck [ m + i *8 ]=*temp;

temp ++;

}

//3des 的加密算法第一个参数为密码，第二个参数为明文，第三个参数为输出的密文，第四个参数为明文的位数

void DESCryptoServiceProvider :: FinalD3desEncryption ( unsigned char * key , unsigned char *inblock , unsigned char * outbolck , int n )

{

unsigned char out [8 ];

unsigned char f_key [24 ];

unsigned char o [8 ];

unsigned char i ;

int j ;

if (( n -1 )%8== 0)

{

j = n /8 ;

}

else

j =( n -1 )/8+ 1;

int m ;

unsigned char * test ;

unsigned char * temp ;

for ( m =0 ;m<24; m ++)

{

f_key [ m ]=* key ;

key ++;

}

des3key ( f_key ,0 );

for ( i =0 ;i<j;i++)

{

test = inblock ;

for ( m =0 ;m<8; m ++)

{

o [ m ]=*( test + i *8 );

if ( o [ m ]== 0xcc)

{

o [ m ]=0x00 ;

}

++ test ;

}

Ddes ( o , out );

temp = out ;

for ( m =0 ;m<8; m ++)

{

outbolck [ m + i *8 ]=*temp;

temp ++;

}

#include "DESCryptoServiceProvider.h"

#include <stdio.h>

#include <iostream>

using namespace std ;

void main ()

{

int i ;

unsigned char input []= "adsfasdfajsdlfkja";

unsigned char key []= "asdfsasfdsasasdfsasfdsas";

//output 里面的数据具体要几位，得看 input 的数据，假设 input 为个字节，那么 output 为个字节， input 为个字节， output 为个字节

//input 为个字节， output 为个字节， output 得是 input8 的整数倍在加

unsigned char output [((( sizeof ( input )-1 )/8)+ 1)*8 +1];

unsigned char o [(( sizeof ( input )/8 )+1)* 8+1 ];

/*DESCryptoServiceProvider t;

t.FinalD3desEncryption(key,input,output,sizeof(input));*/

DESCryptoServiceProvider :: FinalD3desEncryption ( key , input , output , sizeof ( input ));

printf (" 经过加密后的数据 \n" );

for ( i =0 ;i<((sizeof(input)-2)/ 8+1 )*8; i ++)

{

printf ("%02X" ,output[i]);

}

printf ("\n" );

printf (" 经过解密后的数据 \n" );

DESCryptoServiceProvider :: FinalD3desDecryption ( key , output , o , sizeof ( output ));

//t.FinalD3desDecryption(key,output,o,sizeof(output));

for ( i =0 ;i<sizeof(input);i++)

{

printf ("%c" ,o[i]);

}

system ("pause" );

}

public static string TripleDESDecrypt ( string pToDecrypt , string sKey )

{

TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider ();

des . Mode = CipherMode . ECB ;

des . Padding = PaddingMode . Zeros ;

byte [] inputByteArray = new byte [ pToDecrypt . Length / 2];

for ( int x = 0; x < pToDecrypt.Length / 2; x ++)

{

int i = ( Convert . ToInt32 ( pToDecrypt . Substring ( x * 2, 2 ), 16));

inputByteArray [ x ] = ( byte ) i ;

}

des . Key = ASCIIEncoding . ASCII . GetBytes ( sKey );

MemoryStream ms = new MemoryStream ();

CryptoStream cs = new CryptoStream ( ms , des . CreateDecryptor (), CryptoStreamMode . Write );

cs . Write ( inputByteArray , 0 , inputByteArray.Length);

cs . FlushFinalBlock ();

StringBuilder ret = new StringBuilder ();

return System . Text . Encoding . Default . GetString ( ms . ToArray ());

}

public static string TripleDESEncrypt ( string pToEncrypt , string sKey ) // 加密

{

try

{

TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider ();

des . Key = ASCIIEncoding . ASCII . GetBytes ( sKey );

des . Mode = CipherMode . ECB ;

des . Padding = PaddingMode . Zeros ;

MemoryStream ms = new MemoryStream ();

CryptoStream cs = new CryptoStream ( ms , des . CreateEncryptor (), CryptoStreamMode . Write );

byte [] inputByteArray = Encoding . Default . GetBytes ( pToEncrypt );

cs . Write ( inputByteArray , 0 , inputByteArray.Length);

cs . FlushFinalBlock (); ;

StringBuilder ret = new StringBuilder ();

foreach ( byte b in ms . ToArray ())

{

ret . AppendFormat ("{0:X2}" , b);

}

ret . ToString ();

return ret . ToString ();

}

catch ( Exception ex )

{

return ex . Message ;

}

转载于:https://www.cnblogs.com/codingking/p/4535162.html

weixin_30752699

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
3des算法c实现和c#实现

Single-length key, single-length plaintext -* Key : 0123 4567 89ab cdef* Plain : 0123 4567 89ab cde7* Cipher : c957 4425 6a5e d31d** Double-length key, single-length plaintext -* K...
复制链接

扫一扫

3des算法c实现和c#实现

“相关推荐”对你有帮助么？