des加密算法源代码（DES加密算法的简单实现）

本篇文章给大家谈谈des加密算法源代码，以及DES加密算法的简单实现对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、DES加密算法C语言实现
• 2、des加密算法(c/c++)
• 3、用c++实现DES的加密解密的源代码
• 4、des算法源代码

DES加密算法C语言实现

#includeiostream.h

class SubKey{ //定义子密钥为一个类

public:

int key[8][6];

}subkey[16]; //定义子密钥对象数组

class DES{

int encipher_decipher; //判断加密还是解密

int key_in[8][8]; //用户原始输入的64位二进制数

int key_out[8][7]; //除去每行的最后一位校验位

int c0_d0[8][7]; //存储经PC-1转换后的56位数据

int c0[4][7],d0[4][7]; //分别存储c0,d0

int text[8][8]; //64位明文

int text_ip[8][8]; //经IP转换过后的明文

int A[4][8],B[4][8]; //A,B分别存储经IP转换过后明文的两部分,便于交换

int temp[8][6]; //存储经扩展置换后的48位二进制值

int temp1[8][6]; //存储和子密钥异或后的结果

int s_result[8][4]; //存储经S变换后的32位值

int text_p[8][4]; //经P置换后的32位结果

int secret_ip[8][8]; //经逆IP转换后的密文

public:

void Key_Putting();

void PC_1();

int function(int,int); //异或

void SubKey_Production();

void IP_Convert();

void f();

void _IP_Convert();

void Out_secret();

};

void DES::Key_Putting() //得到密钥中对算法有用的56位

{

cout"请输入64位的密钥(8行8列且每行都得有奇数个1):\n";

for(int i=0;i8;i++)

for(int j=0;j8;j++){

cinkey_in[i][j];

if(j!=7) key_out[i][j]=key_in[i][j];

}

}

void DES::PC_1() //PC-1置换函数

{

int pc_1[8][7]={ //PC-1

{57, 49, 41, 33, 25, 17, 9},

{1, 58, 50, 42, 34, 26, 18},

{10, 2, 59, 51, 43, 35, 27},

{19, 11, 3, 60, 52, 44, 36},

{63, 55, 47, 39, 31, 23, 15},

{7, 62, 54, 46, 38, 30, 22},

{14, 6, 61, 53, 45, 37, 29},

{21, 13, 5, 28, 20, 12, 4}

};

int i,j;

for(i=0;i8;i++)

for(j=0;j7;j++)

c0_d0[i][j]=key_out[ (pc_1[i][j]-1)/8 ][ (pc_1[i][j]-1)%8 ];

}

int DES::function(int a,int b) //模拟二进制数的异或运算,a和b为整型的0和1,返回值为整型的0或1

{

if(a!=b)return 1;

else return 0;

}

void DES::SubKey_Production() //生成子密钥

{

int move[16][2]={ //循环左移的位数

1 , 1 , 2 , 1 ,

3 , 2 , 4 , 2 ,

5 , 2 , 6 , 2 ,

7 , 2 , 8 , 2 ,

9 , 1, 10 , 2,

11 , 2, 12 , 2,

13 , 2, 14 , 2,

15 , 2, 16 , 1

};

int pc_2[8][6]={ //PC-2

14, 17 ,11 ,24 , 1 , 5,

3 ,28 ,15 , 6 ,21 ,10,

23, 19, 12, 4, 26, 8,

16, 7, 27, 20 ,13 , 2,

41, 52, 31, 37, 47, 55,

30, 40, 51, 45, 33, 48,

44, 49, 39, 56, 34, 53,

46, 42, 50, 36, 29, 32

};

for(int i=0;i16;i++) //生成子密钥

{

int j,k;

int a[2],b[2];

int bb[28],cc[28];

for(j=0;j4;j++)

for(k=0;k7;k++)

c0[j][k]=c0_d0[j][k];

for(j=4;j8;j++)

for(k=0;k7;k++)

d0[j-4][k]=c0_d0[j][k];

for(j=0;j4;j++)

for(k=0;k7;k++){

bb[7*j+k]=c0[j][k];

cc[7*j+k]=d0[j][k];

}

for(j=0;jmove[i][1];j++){

a[j]=bb[j];

b[j]=cc[j];

}

for(j=0;j28-move[i][1];j++){

bb[j]=bb[j+1];

cc[j]=cc[j+1];

}

for(j=0;jmove[i][1];j++){

bb[27-j]=a[j];

cc[27-j]=b[j];

}

for(j=0;j28;j++){

c0[j/7][j%7]=bb[j];

d0[j/7][j%7]=cc[j];

}

for(j=0;j4;j++) //L123--L128是把c0,d0合并成c0_d0

for(k=0;k7;k++)

c0_d0[j][k]=c0[j][k];

for(j=4;j8;j++)

for(k=0;k7;k++)

c0_d0[j][k]=d0[j-4][k];

for(j=0;j8;j++) //对Ci,Di进行PC-2置换

for(k=0;k6;k++)

subkey[i].key[j][k]=c0_d0[ (pc_2[j][k]-1)/7 ][ (pc_2[j][k]-1)%7 ];

}

}

void DES::IP_Convert()

{

int IP[8][8]={ //初始置换IP矩阵

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

};

cout"你好,你要加密还是解密?加密请按1号键(输入1),解密请按2号键,并确定."'\n';

cinencipher_decipher;

char * s;

if(encipher_decipher==1) s="明文";

else s="密文";

cout"请输入64位"s"(二进制):\n";

int i,j;

for(i=0;i8;i++)

for(j=0;j8;j++)

cintext[i][j];

for(i=0;i8;i++) //进行IP变换

for(j=0;j8;j++)

text_ip[i][j]=text[ (IP[i][j]-1)/8 ][ (IP[i][j]-1)%8 ];

}

des加密算法(c/c++)

des.h文件：

#ifndef CRYPTOPP_DES_H

#define CRYPTOPP_DES_H

#include "cryptlib.h"

#include "misc.h"

NAMESPACE_BEGIN(CryptoPP)

class DES : public BlockTransformation

{

public:

DES(const byte *userKey, CipherDir);

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const

{DES::ProcessBlock(inoutBlock, inoutBlock);}

enum {KEYLENGTH=8, BLOCKSIZE=8};

unsigned int BlockSize() const {return BLOCKSIZE;}

protected:

static const word32 Spbox[8][64];

SecBlockword32 k;

};

class DESEncryption : public DES

{

public:

DESEncryption(const byte * userKey)

: DES (userKey, ENCRYPTION) {}

};

class DESDecryption : public DES

{

public:

DESDecryption(const byte * userKey)

: DES (userKey, DECRYPTION) {}

};

class DES_EDE_Encryption : public BlockTransformation

{

public:

DES_EDE_Encryption(const byte * userKey)

: e(userKey, ENCRYPTION), d(userKey + DES::KEYLENGTH, DECRYPTION) {}

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const;

enum {KEYLENGTH=16, BLOCKSIZE=8};

unsigned int BlockSize() const {return BLOCKSIZE;}

private:

DES e, d;

};

class DES_EDE_Decryption : public BlockTransformation

{

public:

DES_EDE_Decryption(const byte * userKey)

: d(userKey, DECRYPTION), e(userKey + DES::KEYLENGTH, ENCRYPTION) {}

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const;

enum {KEYLENGTH=16, BLOCKSIZE=8};

unsigned int BlockSize() const {return BLOCKSIZE;}

private:

DES d, e;

};

class TripleDES_Encryption : public BlockTransformation

{

public:

TripleDES_Encryption(const byte * userKey)

: e1(userKey, ENCRYPTION), d(userKey + DES::KEYLENGTH, DECRYPTION),

e2(userKey + 2*DES::KEYLENGTH, ENCRYPTION) {}

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const;

enum {KEYLENGTH=24, BLOCKSIZE=8};

unsigned int BlockSize() const {return BLOCKSIZE;}

private:

DES e1, d, e2;

};

class TripleDES_Decryption : public BlockTransformation

{

public:

TripleDES_Decryption(const byte * userKey)

: d1(userKey + 2*DES::KEYLENGTH, DECRYPTION), e(userKey + DES::KEYLENGTH, ENCRYPTION),

d2(userKey, DECRYPTION) {}

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const;

enum {KEYLENGTH=24, BLOCKSIZE=8};

unsigned int BlockSize() const {return BLOCKSIZE;}

private:

DES d1, e, d2;

};

NAMESPACE_END

#endif

des.cpp文件：

// des.cpp - modified by Wei Dai from:

/*

* This is a major rewrite of my old public domain DES code written

* circa 1987, which in turn borrowed heavily from Jim Gillogly's 1977

* public domain code. I pretty much kept my key scheduling code, but

* the actual encrypt/decrypt routines are taken from from Richard

* Outerbridge's DES code as printed in Schneier's "Applied Cryptography."

*

* This code is in the public domain. I would appreciate bug reports and

* enhancements.

*

* Phil Karn KA9Q, karn@unix.ka9q.ampr.org, August 1994.

*/

#include "pch.h"

#include "misc.h"

#include "des.h"

NAMESPACE_BEGIN(CryptoPP)

/* Tables defined in the Data Encryption Standard documents

* Three of these tables, the initial permutation, the final

* permutation and the expansion operator, are regular enough that

* for speed, we hard-code them. They're here for reference only.

* Also, the S and P boxes are used by a separate program, gensp.c,

* to build the combined SP box, Spbox[]. They're also here just

* for reference.

*/

#ifdef notdef

/* initial permutation IP */

static byte ip[] = {

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

};

/* final permutation IP^-1 */

static byte fp[] = {

40, 8, 48, 16, 56, 24, 64, 32,

39, 7, 47, 15, 55, 23, 63, 31,

38, 6, 46, 14, 54, 22, 62, 30,

37, 5, 45, 13, 53, 21, 61, 29,

36, 4, 44, 12, 52, 20, 60, 28,

35, 3, 43, 11, 51, 19, 59, 27,

34, 2, 42, 10, 50, 18, 58, 26,

33, 1, 41, 9, 49, 17, 57, 25

};

/* expansion operation matrix */

static byte ei[] = {

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

};

/* The (in)famous S-boxes */

static byte sbox[8][64] = {

/* S1 */

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,

/* S2 */

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,

/* S3 */

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,

/* S4 */

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,

/* S5 */

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,

/* S6 */

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,

/* S7 */

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,

/* S8 */

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

};

/* 32-bit permutation function P used on the output of the S-boxes */

static byte p32i[] = {

16, 7, 20, 21,

29, 12, 28, 17,

1, 15, 23, 26,

5, 18, 31, 10,

2, 8, 24, 14,

32, 27, 3, 9,

19, 13, 30, 6,

22, 11, 4, 25

};

#endif

/* permuted choice table (key) */

static const byte pc1[] = {

57, 49, 41, 33, 25, 17, 9,

1, 58, 50, 42, 34, 26, 18,

10, 2, 59, 51, 43, 35, 27,

19, 11, 3, 60, 52, 44, 36,

63, 55, 47, 39, 31, 23, 15,

7, 62, 54, 46, 38, 30, 22,

14, 6, 61, 53, 45, 37, 29,

21, 13, 5, 28, 20, 12, 4

};

/* number left rotations of pc1 */

static const byte totrot[] = {

1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28

};

/* permuted choice key (table) */

static const byte pc2[] = {

14, 17, 11, 24, 1, 5,

3, 28, 15, 6, 21, 10,

23, 19, 12, 4, 26, 8,

16, 7, 27, 20, 13, 2,

41, 52, 31, 37, 47, 55,

30, 40, 51, 45, 33, 48,

44, 49, 39, 56, 34, 53,

46, 42, 50, 36, 29, 32

};

/* End of DES-defined tables */

/* bit 0 is left-most in byte */

static const int bytebit[] = {

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

};

/* Set key (initialize key schedule array) */

DES::DES(const byte *key, CipherDir dir)

: k(32)

{

SecByteBlock buffer(56+56+8);

byte *const pc1m=buffer; /* place to modify pc1 into */

byte *const pcr=pc1m+56; /* place to rotate pc1 into */

byte *const ks=pcr+56;

register int i,j,l;

int m;

for (j=0; j56; j++) { /* convert pc1 to bits of key */

l=pc1[j]-1; /* integer bit location */

m = l  07; /* find bit */

pc1m[j]=(key[l3]  /* find which key byte l is in */

bytebit[m]) /* and which bit of that byte */

? 1 : 0; /* and store 1-bit result */

}

for (i=0; i16; i++) { /* key chunk for each iteration */

memset(ks,0,8); /* Clear key schedule */

for (j=0; j56; j++) /* rotate pc1 the right amount */

pcr[j] = pc1m[(l=j+totrot[i])(j28? 28 : 56) ? l: l-28];

/* rotate left and right halves independently */

for (j=0; j48; j++){ /* select bits individually */

/* check bit that goes to ks[j] */

if (pcr[pc2[j]-1]){

/* mask it in if it's there */

l= j % 6;

ks[j/6] |= bytebit[l]  2;

}

}

/* Now convert to odd/even interleaved form for use in F */

k[2*i] = ((word32)ks[0]  24)

| ((word32)ks[2]  16)

| ((word32)ks[4]  8)

| ((word32)ks[6]);

k[2*i+1] = ((word32)ks[1]  24)

| ((word32)ks[3]  16)

| ((word32)ks[5]  8)

| ((word32)ks[7]);

}

if (dir==DECRYPTION) // reverse key schedule order

for (i=0; i16; i+=2)

{

std::swap(k[i], k[32-2-i]);

std::swap(k[i+1], k[32-1-i]);

}

}

/* End of C code common to both versions */

/* C code only in portable version */

// Richard Outerbridge's initial permutation algorithm

/*

inline void IPERM(word32 left, word32 right)

{

word32 work;

work = ((left  4) ^ right)  0x0f0f0f0f;

right ^= work;

left ^= work  4;

work = ((left  16) ^ right)  0xffff;

right ^= work;

left ^= work  16;

work = ((right  2) ^ left)  0x33333333;

left ^= work;

right ^= (work  2);

work = ((right  8) ^ left)  0xff00ff;

left ^= work;

right ^= (work  8);

right = rotl(right, 1);

work = (left ^ right)  0xaaaaaaaa;

left ^= work;

right ^= work;

left = rotl(left, 1);

}

inline void FPERM(word32 left, word32 right)

{

word32 work;

right = rotr(right, 1);

work = (left ^ right)  0xaaaaaaaa;

left ^= work;

right ^= work;

left = rotr(left, 1);

work = ((left  8) ^ right)  0xff00ff;

right ^= work;

left ^= work  8;

work = ((left  2) ^ right)  0x33333333;

right ^= work;

left ^= work  2;

work = ((right  16) ^ left)  0xffff;

left ^= work;

right ^= work  16;

work = ((right  4) ^ left)  0x0f0f0f0f;

left ^= work;

right ^= work  4;

}

*/

// Wei Dai's modification to Richard Outerbridge's initial permutation

// algorithm, this one is faster if you have access to rotate instructions

// (like in MSVC)

inline void IPERM(word32 left, word32 right)

{

word32 work;

right = rotl(right, 4U);

work = (left ^ right)  0xf0f0f0f0;

left ^= work;

right = rotr(right^work, 20U);

work = (left ^ right)  0xffff0000;

left ^= work;

right = rotr(right^work, 18U);

work = (left ^ right)  0x33333333;

left ^= work;

right = rotr(right^work, 6U);

work = (left ^ right)  0x00ff00ff;

left ^= work;

right = rotl(right^work, 9U);

work = (left ^ right)  0xaaaaaaaa;

left = rotl(left^work, 1U);

right ^= work;

}

inline void FPERM(word32 left, word32 right)

{

word32 work;

right = rotr(right, 1U);

work = (left ^ right)  0xaaaaaaaa;

right ^= work;

left = rotr(left^work, 9U);

work = (left ^ right)  0x00ff00ff;

right ^= work;

left = rotl(left^work, 6U);

work = (left ^ right)  0x33333333;

right ^= work;

left = rotl(left^work, 18U);

work = (left ^ right)  0xffff0000;

right ^= work;

left = rotl(left^work, 20U);

work = (left ^ right)  0xf0f0f0f0;

right ^= work;

left = rotr(left^work, 4U);

}

// Encrypt or decrypt a block of data in ECB mode

void DES::ProcessBlock(const byte *inBlock, byte * outBlock) const

{

word32 l,r,work;

#ifdef IS_LITTLE_ENDIAN

l = byteReverse(*(word32 *)inBlock);

r = byteReverse(*(word32 *)(inBlock+4));

#else

l = *(word32 *)inBlock;

r = *(word32 *)(inBlock+4);

#endif

IPERM(l,r);

const word32 *kptr=k;

for (unsigned i=0; i8; i++)

{

work = rotr(r, 4U) ^ kptr[4*i+0];

l ^= Spbox[6][(work)  0x3f]

^ Spbox[4][(work  8)  0x3f]

^ Spbox[2][(work  16)  0x3f]

^ Spbox[0][(work  24)  0x3f];

work = r ^ kptr[4*i+1];

l ^= Spbox[7][(work)  0x3f]

^ Spbox[5][(work  8)  0x3f]

^ Spbox[3][(work  16)  0x3f]

^ Spbox[1][(work  24)  0x3f];

work = rotr(l, 4U) ^ kptr[4*i+2];

r ^= Spbox[6][(work)  0x3f]

^ Spbox[4][(work  8)  0x3f]

^ Spbox[2][(work  16)  0x3f]

^ Spbox[0][(work  24)  0x3f];

work = l ^ kptr[4*i+3];

r ^= Spbox[7][(work)  0x3f]

^ Spbox[5][(work  8)  0x3f]

^ Spbox[3][(work  16)  0x3f]

^ Spbox[1][(work  24)  0x3f];

}

FPERM(l,r);

#ifdef IS_LITTLE_ENDIAN

*(word32 *)outBlock = byteReverse(r);

*(word32 *)(outBlock+4) = byteReverse(l);

#else

*(word32 *)outBlock = r;

*(word32 *)(outBlock+4) = l;

#endif

}

void DES_EDE_Encryption::ProcessBlock(byte *inoutBlock) const

{

e.ProcessBlock(inoutBlock);

d.ProcessBlock(inoutBlock);

e.ProcessBlock(inoutBlock);

}

void DES_EDE_Encryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

{

e.ProcessBlock(inBlock, outBlock);

d.ProcessBlock(outBlock);

e.ProcessBlock(outBlock);

}

void DES_EDE_Decryption::ProcessBlock(byte *inoutBlock) const

{

d.ProcessBlock(inoutBlock);

e.ProcessBlock(inoutBlock);

d.ProcessBlock(inoutBlock);

}

void DES_EDE_Decryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

{

d.ProcessBlock(inBlock, outBlock);

e.ProcessBlock(outBlock);

d.ProcessBlock(outBlock);

}

void TripleDES_Encryption::ProcessBlock(byte *inoutBlock) const

{

e1.ProcessBlock(inoutBlock);

d.ProcessBlock(inoutBlock);

e2.ProcessBlock(inoutBlock);

}

void TripleDES_Encryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

{

e1.ProcessBlock(inBlock, outBlock);

d.ProcessBlock(outBlock);

e2.ProcessBlock(outBlock);

}

void TripleDES_Decryption::ProcessBlock(byte *inoutBlock) const

{

d1.ProcessBlock(inoutBlock);

e.ProcessBlock(inoutBlock);

d2.ProcessBlock(inoutBlock);

}

void TripleDES_Decryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

{

d1.ProcessBlock(inBlock, outBlock);

e.ProcessBlock(outBlock);

d2.ProcessBlock(outBlock);

}

NAMESPACE_END

程序运行如下：

用c++实现DES的加密解密的源代码

#include iostream

#include fstream

#include bitset

#include string

using namespace std;

bitset64 key;                

bitset48 subKey[16];        

int IP[] = {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};

int IP_1[] = {40, 8, 48, 16, 56, 24, 64, 32,

  39, 7, 47, 15, 55, 23, 63, 31,

  38, 6, 46, 14, 54, 22, 62, 30,

  37, 5, 45, 13, 53, 21, 61, 29,

  36, 4, 44, 12, 52, 20, 60, 28,

  35, 3, 43, 11, 51, 19, 59, 27,

  34, 2, 42, 10, 50, 18, 58, 26,

  33, 1, 41,  9, 49, 17, 57, 25};

int PC_1[] = {57, 49, 41, 33, 25, 17, 9,

   1, 58, 50, 42, 34, 26, 18,

  10,  2, 59, 51, 43, 35, 27,

  19, 11,  3, 60, 52, 44, 36,

  63, 55, 47, 39, 31, 23, 15,

   7, 62, 54, 46, 38, 30, 22,

  14,  6, 61, 53, 45, 37, 29,

  21, 13,  5, 28, 20, 12,  4}; 

int PC_2[] = {14, 17, 11, 24,  1,  5,

   3, 28, 15,  6, 21, 10,

  23, 19, 12,  4, 26,  8,

  16,  7, 27, 20, 13,  2,

  41, 52, 31, 37, 47, 55,

  30, 40, 51, 45, 33, 48,

  44, 49, 39, 56, 34, 53,

  46, 42, 50, 36, 29, 32};

int shiftBits[] = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};

int E[] = {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};

int S_BOX[8][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} 

},

{  

{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}  

}, 

{  

{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}  

}, 

{  

{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}  

},

{  

{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}  

},

{  

{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}  

}, 

{  

{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}  

}, 

{  

{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}  

} 

};

int P[] = {16,  7, 20, 21,

   29, 12, 28, 17,

    1, 15, 23, 26,

    5, 18, 31, 10,

    2,  8, 24, 14,

   32, 27,  3,  9,

   19, 13, 30,  6,

   22, 11,  4, 25 };

bitset32 f(bitset32 R, bitset48 k)

{

bitset48 expandR;

// 第一步：扩展置换，32 - 48

for(int i=0; i48; ++i)

expandR[47-i] = R[32-E[i]];

// 第二步：异或

expandR = expandR ^ k;

// 第三步：查找S_BOX置换表

bitset32 output;

int x = 0;

for(int i=0; i48; i=i+6)

{

int row = expandR[47-i]*2 + expandR[47-i-5];

int col = expandR[47-i-1]*8 + expandR[47-i-2]*4 + expandR[47-i-3]*2 + expandR[47-i-4];

int num = S_BOX[i/6][row][col];

bitset4 binary(num);

output[31-x] = binary[3];

output[31-x-1] = binary[2];

output[31-x-2] = binary[1];

output[31-x-3] = binary[0];

x += 4;

}

// 第四步：P-置换，32 - 32

bitset32 tmp = output;

for(int i=0; i32; ++i)

output[31-i] = tmp[32-P[i]];

return output;

}

bitset28 leftShift(bitset28 k, int shift)

{

bitset28 tmp = k;

for(int i=27; i=0; --i)

{

if(i-shift0)

k[i] = tmp[i-shift+28];

else

k[i] = tmp[i-shift];

}

return k;

}

void generateKeys() 

{

bitset56 realKey;

bitset28 left;

bitset28 right;

bitset48 compressKey;

// 去掉奇偶标记位，将64位密钥变成56位

for (int i=0; i56; ++i)

realKey[55-i] = key[64 - PC_1[i]];

// 生成子密钥，保存在 subKeys[16] 中

for(int round=0; round16; ++round) 

{

// 前28位与后28位

for(int i=28; i56; ++i)

left[i-28] = realKey[i];

for(int i=0; i28; ++i)

right[i] = realKey[i];

// 左移

left = leftShift(left, shiftBits[round]);

right = leftShift(right, shiftBits[round]);

// 压缩置换，由56位得到48位子密钥

for(int i=28; i56; ++i)

realKey[i] = left[i-28];

for(int i=0; i28; ++i)

realKey[i] = right[i];

for(int i=0; i48; ++i)

compressKey[47-i] = realKey[56 - PC_2[i]];

subKey[round] = compressKey;

}

}

bitset64 charToBitset(const char s[8])

{

bitset64 bits;

for(int i=0; i8; ++i)

for(int j=0; j8; ++j)

bits[i*8+j] = ((s[i]j)  1);

return bits;

}

bitset64 encrypt(bitset64 plain)

{

bitset64 cipher;

bitset64 currentBits;

bitset32 left;

bitset32 right;

bitset32 newLeft;

// 第一步：初始置换IP

for(int i=0; i64; ++i)

currentBits[63-i] = plain[64-IP[i]];

// 第二步：获取 Li 和 Ri

for(int i=32; i64; ++i)

left[i-32] = currentBits[i];

for(int i=0; i32; ++i)

right[i] = currentBits[i];

// 第三步：共16轮迭代

for(int round=0; round16; ++round)

{

newLeft = right;

right = left ^ f(right,subKey[round]);

left = newLeft;

}

// 第四步：合并L16和R16，注意合并为 R16L16

for(int i=0; i32; ++i)

cipher[i] = left[i];

for(int i=32; i64; ++i)

cipher[i] = right[i-32];

// 第五步：结尾置换IP-1

currentBits = cipher;

for(int i=0; i64; ++i)

cipher[63-i] = currentBits[64-IP_1[i]];

// 返回密文

return cipher;

}

bitset64 decrypt(bitset64 cipher)

{

bitset64 plain;

bitset64 currentBits;

bitset32 left;

bitset32 right;

bitset32 newLeft;

// 第一步：初始置换IP

for(int i=0; i64; ++i)

currentBits[63-i] = cipher[64-IP[i]];

// 第二步：获取 Li 和 Ri

for(int i=32; i64; ++i)

left[i-32] = currentBits[i];

for(int i=0; i32; ++i)

right[i] = currentBits[i];

// 第三步：共16轮迭代（子密钥逆序应用）

for(int round=0; round16; ++round)

{

newLeft = right;

right = left ^ f(right,subKey[15-round]);

left = newLeft;

}

// 第四步：合并L16和R16，注意合并为 R16L16

for(int i=0; i32; ++i)

plain[i] = left[i];

for(int i=32; i64; ++i)

plain[i] = right[i-32];

// 第五步：结尾置换IP-1

currentBits = plain;

for(int i=0; i64; ++i)

plain[63-i] = currentBits[64-IP_1[i]];

// 返回明文

return plain;

}

int main() {

string s = "romantic";

string k = "12345678";

bitset64 plain = charToBitset(s.c_str());

key = charToBitset(k.c_str());

// 生成16个子密钥

generateKeys();   

bitset64 cipher = encrypt(plain);

fstream file1;

file1.open("D://a.txt", ios::binary | ios::out);

file1.write((char*)cipher,sizeof(cipher));

file1.close();

bitset64 temp;

file1.open("D://a.txt", ios::binary | ios::in);

file1.read((char*)temp, sizeof(temp));

file1.close();

bitset64 temp_plain = decrypt(temp);

file1.open("D://b.txt", ios::binary | ios::out);

file1.write((char*)temp_plain,sizeof(temp_plain));

file1.close();

return 0;

}

des算法源代码

des.h文件：

#ifndef CRYPTOPP_DES_H

#define CRYPTOPP_DES_H

#include "cryptlib.h"

#include "misc.h"

NAMESPACE_BEGIN(CryptoPP)

class DES : public BlockTransformation

{

public:

DES(const byte *userKey, CipherDir);

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const

{DES::ProcessBlock(inoutBlock, inoutBlock);}

enum {KEYLENGTH=8, BLOCKSIZE=8};

unsigned int BlockSize() const {return BLOCKSIZE;}

protected:

static const word32 Spbox[8][64];

SecBlockword32 k;

};

class DESEncryption : public DES

{

public:

DESEncryption(const byte * userKey)

: DES (userKey, ENCRYPTION) {}

};

class DESDecryption : public DES

{

public:

DESDecryption(const byte * userKey)

: DES (userKey, DECRYPTION) {}

};

class DES_EDE_Encryption : public BlockTransformation

{

public:

DES_EDE_Encryption(const byte * userKey)

: e(userKey, ENCRYPTION), d(userKey + DES::KEYLENGTH, DECRYPTION) {}

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const;

enum {KEYLENGTH=16, BLOCKSIZE=8};

unsigned int BlockSize() const {return BLOCKSIZE;}

private:

DES e, d;

};

class DES_EDE_Decryption : public BlockTransformation

{

public:

DES_EDE_Decryption(const byte * userKey)

: d(userKey, DECRYPTION), e(userKey + DES::KEYLENGTH, ENCRYPTION) {}

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const;

enum {KEYLENGTH=16, BLOCKSIZE=8};

unsigned int BlockSize() const {return BLOCKSIZE;}

private:

DES d, e;

};

class TripleDES_Encryption : public BlockTransformation

{

public:

TripleDES_Encryption(const byte * userKey)

: e1(userKey, ENCRYPTION), d(userKey + DES::KEYLENGTH, DECRYPTION),

e2(userKey + 2*DES::KEYLENGTH, ENCRYPTION) {}

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const;

enum {KEYLENGTH=24, BLOCKSIZE=8};

unsigned int BlockSize() const {return BLOCKSIZE;}

private:

DES e1, d, e2;

};

class TripleDES_Decryption : public BlockTransformation

{

public:

TripleDES_Decryption(const byte * userKey)

: d1(userKey + 2*DES::KEYLENGTH, DECRYPTION), e(userKey + DES::KEYLENGTH, ENCRYPTION),

d2(userKey, DECRYPTION) {}

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const;

enum {KEYLENGTH=24, BLOCKSIZE=8};

unsigned int BlockSize() const {return BLOCKSIZE;}

private:

DES d1, e, d2;

};

NAMESPACE_END

#endif

des.cpp文件：

// des.cpp - modified by Wei Dai from:

/*

* This is a major rewrite of my old public domain DES code written

* circa 1987, which in turn borrowed heavily from Jim Gillogly's 1977

* public domain code. I pretty much kept my key scheduling code, but

* the actual encrypt/decrypt routines are taken from from Richard

* Outerbridge's DES code as printed in Schneier's "Applied Cryptography."

*

* This code is in the public domain. I would appreciate bug reports and

* enhancements.

*

* Phil Karn KA9Q, karn@unix.ka9q.ampr.org, August 1994.

*/

#include "pch.h"

#include "misc.h"

#include "des.h"

NAMESPACE_BEGIN(CryptoPP)

/* Tables defined in the Data Encryption Standard documents

* Three of these tables, the initial permutation, the final

* permutation and the expansion operator, are regular enough that

* for speed, we hard-code them. They're here for reference only.

* Also, the S and P boxes are used by a separate program, gensp.c,

* to build the combined SP box, Spbox[]. They're also here just

* for reference.

*/

#ifdef notdef

/* initial permutation IP */

static byte ip[] = {

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

};

/* final permutation IP^-1 */

static byte fp[] = {

40, 8, 48, 16, 56, 24, 64, 32,

39, 7, 47, 15, 55, 23, 63, 31,

38, 6, 46, 14, 54, 22, 62, 30,

37, 5, 45, 13, 53, 21, 61, 29,

36, 4, 44, 12, 52, 20, 60, 28,

35, 3, 43, 11, 51, 19, 59, 27,

34, 2, 42, 10, 50, 18, 58, 26,

33, 1, 41, 9, 49, 17, 57, 25

};

/* expansion operation matrix */

static byte ei[] = {

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

};

/* The (in)famous S-boxes */

static byte sbox[8][64] = {

/* S1 */

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,

/* S2 */

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,

/* S3 */

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,

/* S4 */

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,

/* S5 */

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,

/* S6 */

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,

/* S7 */

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,

/* S8 */

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

};

/* 32-bit permutation function P used on the output of the S-boxes */

static byte p32i[] = {

16, 7, 20, 21,

29, 12, 28, 17,

1, 15, 23, 26,

5, 18, 31, 10,

2, 8, 24, 14,

32, 27, 3, 9,

19, 13, 30, 6,

22, 11, 4, 25

};

#endif

/* permuted choice table (key) */

static const byte pc1[] = {

57, 49, 41, 33, 25, 17, 9,

1, 58, 50, 42, 34, 26, 18,

10, 2, 59, 51, 43, 35, 27,

19, 11, 3, 60, 52, 44, 36,

63, 55, 47, 39, 31, 23, 15,

7, 62, 54, 46, 38, 30, 22,

14, 6, 61, 53, 45, 37, 29,

21, 13, 5, 28, 20, 12, 4

};

/* number left rotations of pc1 */

static const byte totrot[] = {

1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28

};

/* permuted choice key (table) */

static const byte pc2[] = {

14, 17, 11, 24, 1, 5,

3, 28, 15, 6, 21, 10,

23, 19, 12, 4, 26, 8,

16, 7, 27, 20, 13, 2,

41, 52, 31, 37, 47, 55,

30, 40, 51, 45, 33, 48,

44, 49, 39, 56, 34, 53,

46, 42, 50, 36, 29, 32

};

/* End of DES-defined tables */

/* bit 0 is left-most in byte */

static const int bytebit[] = {

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

};

/* Set key (initialize key schedule array) */

DES::DES(const byte *key, CipherDir dir)

: k(32)

{

SecByteBlock buffer(56+56+8);

byte *const pc1m=buffer; /* place to modify pc1 into */

byte *const pcr=pc1m+56; /* place to rotate pc1 into */

byte *const ks=pcr+56;

register int i,j,l;

int m;

for (j=0; j56; j++) { /* convert pc1 to bits of key */

l=pc1[j]-1; /* integer bit location */

m = l 07; /* find bit */

pc1m[j]=(key[l3] /* find which key byte l is in */

bytebit[m]) /* and which bit of that byte */

? 1 : 0; /* and store 1-bit result */

}

for (i=0; i16; i++) { /* key chunk for each iteration */

memset(ks,0,8); /* Clear key schedule */

for (j=0; j56; j++) /* rotate pc1 the right amount */

pcr[j] = pc1m[(l=j+totrot[i])(j28? 28 : 56) ? l: l-28];

/* rotate left and right halves independently */

for (j=0; j48; j++){ /* select bits individually */

/* check bit that goes to ks[j] */

if (pcr[pc2[j]-1]){

/* mask it in if it's there */

l= j % 6;

ks[j/6] |= bytebit[l] 2;

}

}

/* Now convert to odd/even interleaved form for use in F */

k[2*i] = ((word32)ks[0] 24)

| ((word32)ks[2] 16)

| ((word32)ks[4] 8)

| ((word32)ks[6]);

k[2*i+1] = ((word32)ks[1] 24)

| ((word32)ks[3] 16)

| ((word32)ks[5] 8)

| ((word32)ks[7]);

}

if (dir==DECRYPTION) // reverse key schedule order

for (i=0; i16; i+=2)

{

std::swap(k[i], k[32-2-i]);

std::swap(k[i+1], k[32-1-i]);

}

}

/* End of C code common to both versions */

/* C code only in portable version */

// Richard Outerbridge's initial permutation algorithm

/*

inline void IPERM(word32 left, word32 right)

{

word32 work;

work = ((left 4) ^ right) 0x0f0f0f0f;

right ^= work;

left ^= work 4;

work = ((left 16) ^ right) 0xffff;

right ^= work;

left ^= work 16;

work = ((right 2) ^ left) 0x33333333;

left ^= work;

right ^= (work 2);

work = ((right 8) ^ left) 0xff00ff;

left ^= work;

right ^= (work 8);

right = rotl(right, 1);

work = (left ^ right) 0xaaaaaaaa;

left ^= work;

right ^= work;

left = rotl(left, 1);

}

inline void FPERM(word32 left, word32 right)

{

word32 work;

right = rotr(right, 1);

work = (left ^ right) 0xaaaaaaaa;

left ^= work;

right ^= work;

left = rotr(left, 1);

work = ((left 8) ^ right) 0xff00ff;

right ^= work;

left ^= work 8;

work = ((left 2) ^ right) 0x33333333;

right ^= work;

left ^= work 2;

work = ((right 16) ^ left) 0xffff;

left ^= work;

right ^= work 16;

work = ((right 4) ^ left) 0x0f0f0f0f;

left ^= work;

right ^= work 4;

}

*/

// Wei Dai's modification to Richard Outerbridge's initial permutation

// algorithm, this one is faster if you have access to rotate instructions

// (like in MSVC)

inline void IPERM(word32 left, word32 right)

{

word32 work;

right = rotl(right, 4U);

work = (left ^ right) 0xf0f0f0f0;

left ^= work;

right = rotr(right^work, 20U);

work = (left ^ right) 0xffff0000;

left ^= work;

right = rotr(right^work, 18U);

work = (left ^ right) 0x33333333;

left ^= work;

right = rotr(right^work, 6U);

work = (left ^ right) 0x00ff00ff;

left ^= work;

right = rotl(right^work, 9U);

work = (left ^ right) 0xaaaaaaaa;

left = rotl(left^work, 1U);

right ^= work;

}

inline void FPERM(word32 left, word32 right)

{

word32 work;

right = rotr(right, 1U);

work = (left ^ right) 0xaaaaaaaa;

right ^= work;

left = rotr(left^work, 9U);

work = (left ^ right) 0x00ff00ff;

right ^= work;

left = rotl(left^work, 6U);

work = (left ^ right) 0x33333333;

right ^= work;

left = rotl(left^work, 18U);

work = (left ^ right) 0xffff0000;

right ^= work;

left = rotl(left^work, 20U);

work = (left ^ right) 0xf0f0f0f0;

right ^= work;

left = rotr(left^work, 4U);

}

// Encrypt or decrypt a block of data in ECB mode

void DES::ProcessBlock(const byte *inBlock, byte * outBlock) const

{

word32 l,r,work;

#ifdef IS_LITTLE_ENDIAN

l = byteReverse(*(word32 *)inBlock);

r = byteReverse(*(word32 *)(inBlock+4));

#else

l = *(word32 *)inBlock;

r = *(word32 *)(inBlock+4);

#endif

IPERM(l,r);

const word32 *kptr=k;

for (unsigned i=0; i8; i++)

{

work = rotr(r, 4U) ^ kptr[4*i+0];

l ^= Spbox[6][(work) 0x3f]

^ Spbox[4][(work 8) 0x3f]

^ Spbox[2][(work 16) 0x3f]

^ Spbox[0][(work 24) 0x3f];

work = r ^ kptr[4*i+1];

l ^= Spbox[7][(work) 0x3f]

^ Spbox[5][(work 8) 0x3f]

^ Spbox[3][(work 16) 0x3f]

^ Spbox[1][(work 24) 0x3f];

work = rotr(l, 4U) ^ kptr[4*i+2];

r ^= Spbox[6][(work) 0x3f]

^ Spbox[4][(work 8) 0x3f]

^ Spbox[2][(work 16) 0x3f]

^ Spbox[0][(work 24) 0x3f];

work = l ^ kptr[4*i+3];

r ^= Spbox[7][(work) 0x3f]

^ Spbox[5][(work 8) 0x3f]

^ Spbox[3][(work 16) 0x3f]

^ Spbox[1][(work 24) 0x3f];

}

FPERM(l,r);

#ifdef IS_LITTLE_ENDIAN

*(word32 *)outBlock = byteReverse(r);

*(word32 *)(outBlock+4) = byteReverse(l);

#else

*(word32 *)outBlock = r;

*(word32 *)(outBlock+4) = l;

#endif

}

void DES_EDE_Encryption::ProcessBlock(byte *inoutBlock) const

{

e.ProcessBlock(inoutBlock);

d.ProcessBlock(inoutBlock);

e.ProcessBlock(inoutBlock);

}

void DES_EDE_Encryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

{

e.ProcessBlock(inBlock, outBlock);

d.ProcessBlock(outBlock);

e.ProcessBlock(outBlock);

}

void DES_EDE_Decryption::ProcessBlock(byte *inoutBlock) const

{

d.ProcessBlock(inoutBlock);

e.ProcessBlock(inoutBlock);

d.ProcessBlock(inoutBlock);

}

void DES_EDE_Decryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

{

d.ProcessBlock(inBlock, outBlock);

e.ProcessBlock(outBlock);

d.ProcessBlock(outBlock);

}

void TripleDES_Encryption::ProcessBlock(byte *inoutBlock) const

{

e1.ProcessBlock(inoutBlock);

d.ProcessBlock(inoutBlock);

e2.ProcessBlock(inoutBlock);

}

void TripleDES_Encryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

{

e1.ProcessBlock(inBlock, outBlock);

d.ProcessBlock(outBlock);

e2.ProcessBlock(outBlock);

}

void TripleDES_Decryption::ProcessBlock(byte *inoutBlock) const

{

d1.ProcessBlock(inoutBlock);

e.ProcessBlock(inoutBlock);

d2.ProcessBlock(inoutBlock);

}

void TripleDES_Decryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

{

d1.ProcessBlock(inBlock, outBlock);

e.ProcessBlock(outBlock);

d2.ProcessBlock(outBlock);

}

NAMESPACE_END

关于des加密算法源代码和DES加密算法的简单实现的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。