Des source code _c language for four encryption algorithms in C + +

The DES algorithm is one of the most general symmetric key algorithms, because the algorithm itself is public, so its security lies in the security of the key. There are usually two kinds of algorithms based on key: symmetric algorithm and public key algorithm. Symmetry of the symmetric algorithm is reflected in the encryption key can be inferred from the decryption key, and vice versa.

In most symmetric algorithms, the encryption keys are the same, as is Des. It can be seen that the encryption key of the symmetric key algorithm is confidential. The encryption key of the public key algorithm is public and the decryption key is confidential.

Des specific algorithms are as follows:

/* Provided by Zhu Mengbin, national University of Technology email:zmbtsubasa@gmailcom This product are free for use *////////////////////////////////////// #ifndef des_h #define DES_H//!  
 Enum Bool{false,true};  
 /*! 
 If BOOL is not supported,use this or just replace with char and use 1 for true,0 to false; 
 @see enum {encrypt,decrypt}; 
 */enum {encrypt,decrypt}; /* @brief 16 Circle key/static bool subkey[2][16][48];//16 Circle Key/* @brief 3 des flag/static bool is3des;//3 times des flag static 
 Char tmp[256]; 
 static Char deskey[16]; 
  
 typedef BOOL (*PSUBKEY) [16][48]; 
   Class _declspec (dllexport) Des {public:des (); 
   ~des (); //! 
   Type-encrypt: Encrypting, DECRYPT: Decrypting/*! The length of the output buffer (out) is >= ((datalen+7)/8) *8, that is, the smallest positive integer in can = out, which is larger than the datalen and is 8 multiples, at which time the contents of the input buffer (in) will be overwritten when the system automatically makes Use 3 des plus/decrypt, otherwise use standard des Plus/decrypt more than 16 bytes to take only the first 16 bytes @Des_go (char *out,char *in,long datalen,const char *key,int keylen,bool Type = ENCRYPT); 
  
 * * BOOL Des_go (char *out,char *in,long datalen,const char *key,int keylen,bool Type = ENCRYPT); Private:/*! 
   @brief Standard DES Add/decrypt @see static void DES (char out[8], char in[8], const psubkey Psubkey, bool Type); /static void DES (char out[8], char in[8], const psubkey Psubkey, bool Type);/standard DES plus/decrypt/*! 
   @brief set the key @see static void Setkey (const char* key, int len); */static void Setkey (const char* key, int len);//Set Key/*! 
   @brief set the subkey @see static void Setsubkey (Psubkey psubkey, const char key[8]); */static void Setsubkey (Psubkey psubkey, const char key[8]);//Set the child key/*! 
   @brief f function @see static void F_func (BOOL in[32], const BOOL KI[48]); */static void F_func (BOOL in[32], const BOOL KI[48]);/F function/*! 
   @brief S box replaces @see static void S_func (BOOL out[32], const BOOL IN[48]); */static void S_func (bool OUT[32], const BOOL IN[48]);/S box instead of/*! 
   @brief transform @see static void Transform (bool *out, bool *in, const char *table, int len); */static void Transform (bool *out, bool *in, const char *table, int len);/Transform/*! 
   @brief exclusive or @see static void Xor (bool *ina, const BOOL *INB, int len); */static void Xor (bool *ina, const BOOL *INB, int len);/XOR or/*! 
   The @brief loop moves left @see static void Rotatel (bool *in, int len, int loop); */static void Rotatel (bool *in, int len, int loop);/Loop left move/*! 
   @brief byte group is converted to a bit group @see static void Bytetobit (bool *out, const char *in, int bits); */static void Bytetobit (bool *out, const char *in, int bits);//byte group convert to bit group/*! 
   @brief-bit group is converted into a byte group @see static void Bittobyte (char *out, const bool *in, int bits); 
 */static void Bittobyte (char *out, const bool *in, int bits);//bit group converted to byte group}; ////////////////////////////////////////////////////////////////////////// 
 ///////////////////////////////////// ///#endif 
 

DES.cpp file:

/* Provided by Zhu Mengbin, national University of Technology email:zmbtsubasa@gmailcom This product are free for use *////////////////////////////////////// #include "Memoryh" #include "Desh"///////////////////////////////////// Initial permutation IP const static char ip_table[64] = {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 , 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, 
 7}; Final permutation ip^-1 const static char ipr_table[64] = {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, 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 const char E_TABLE[48] = {32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9, 8, 9, 10, 1  1.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, 
 30, 31, 32, 1};  32-bit permutation function P used on the output of the s-boxes const static char p_table[32] = {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}; permuted Choice Table (key) const static char pc1_table[56] = {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, 
 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4}; permuted Choice Key (table) const static char pc2_table[48] = {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, 5 
 6, 34, 53, 46, 42, 50, 36, 29, 32}; 
 Number left rotations of pc1 const static char loop_table[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1}; The (in) famous s-boxes const static char s_box[8][4][16] = {//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 , 5, 0, 8, 2, 4, 9, 1, 7, 5, one, 3,, 0, 6,,//S2 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 1 2, 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, 2, 8, 1, 3, 4, 2, one, 6, 7,, 0, 5, 9,//S3 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 1 1, 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, 5, 7, 1, 0, 6, 9, 8, 7, 4, 3, 5,//S4 2, 7, 13, 14, 3, 0, 6, 9, 10, 1, 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 4, 5, 2, 8, 4, 3, 0, 6, 1, 8, 9, one, 4, 5,,//S5 7, 2, 2, 12, 4, 1, 7, 10, 11, 6, 8  , 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, 6, 3, 0, 8, 7, 1, 6, 2, 0, 9, 4, 5,///S6 3, 12, 1, 10, 15, 9, 2, 6, 8, 0, 13 , 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 , A, 6, 4, 3, 2, 9, 5, 1, 7, 6, 0, 8,///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, 0, 5, 9, 2, 6, 11, 13, 8, 1, 4, 7, 9, 5, 0, A, 2, 3,,//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, 
  
 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11}; Code starts://///////////////////// Des::D es () {} des::~des () {} bool Des::D es_go (Ch Ar *out, char *in, long datalen, const char *key, int keylen, bool Type) {if (!) ( 
   Out && in && Key && (datalen= (datalen+7) &0xfffffff8))-return false; 
   Setkey (Key, Keylen); if (!  Is3des) {//1 des for-(Long i=0,j=datalen>>3; i<j; ++i,out+=8,in+=8) des (out, in, &subkey[0), 
   Type); else{//3 des encryption: Add (KEY0)-Solution (Key1)-Add (Key0) Decrypt:: Solution (KEY0)-Add (Key1)-Solution (KEY0) for (Long I=0,j=datalen>>3; i<j; 
       ++i,out+=8,in+=8) {DES (out, in, &subkey[0], Type); DES (out, out, &subkey[1],! 
       Type); 
     DES (out, out, &subkey[0], Type); 
 } return true; 
   } void Des::setkey (const char* Key, int len) {memset (Deskey, 0, 16); 
   memcpy (Deskey, Key, Len>16?16:len); 
   Setsubkey (&subkey[0], &deskey[0]); Is3des = len>8? 
 (Setsubkey (&subkey[1], &deskey[8]), true): false; } void Des::D es (char out[8], char in[8], const psubkey Psubkey, bool Type) {static bool m[64], tmp[32], *li=& 
   M[0], *ri=&m[32]; 
   Bytetobit (M, in, 64); 
   Transform (M, M, Ip_table, 64); 
       if (Type = = ENCRYPT) {for (int i=0; i<16; ++i) {memcpy (TMP, Ri, 32); 
       F_func (Ri, (*psubkey) [i]); 
       Xor (Ri, Li, 32); 
     memcpy (Li, TMP, 32); 
       }}else{for (int i=15; i>=0;-I.) {memcpy (TMP, Li, 32); 
       F_func (Li, (*psubkey) [i]); 
       Xor (Li, Ri, 32); Memcpy (Ri, TMP, 32); 
   } Transform (M, M, Ipr_table, 64); 
 Bittobyte (out, M, 64); 
   } void Des::setsubkey (Psubkey psubkey, const char key[8]) {static bool k[64], *kl=&k[0], *kr=&k[28]; 
   Bytetobit (K, Key, 64); 
   Transform (k, K, pc1_table, 56); 
     for (int i=0; i<16; ++i) {Rotatel (KL, loop_table[i]); 
     Rotatel (KR, loop_table[i]); 
   Transform ((*psubkey) [i], K, pc2_table, 48); 
   } void Des::f_func (bool in[32], const BOOL KI[48]) {static bool mr[48]; 
   Transform (MR, in, E_table, 48); 
   Xor (MR, Ki, 48); 
   S_func (in, MR); 
 Transform (in, in, P_table, 32); } void Des::s_func (bool out[32], const BOOL IN[48]) {for (char i=0,j,k; i<8; ++i,in+=6,out+=4) {j = (in[ 
     0]<<1) + in[5]; 
     K = (in[1]<<3) + (IN[2]&LT;&LT;2) + (in[3]<<1) + in[4]; 
   Bytetobit (out, &s_box[i][j][k], 4); } void Des::transform (bool *out, bool *in, const char *table, int len) {for (iNT I=0; i<len; 
   ++i) Tmp[i] = in[table[i]-1]; 
 memcpy (out, TMP, Len); 
 } void Des::xor (bool *ina, const BOOL *INB, int len) {for (int i=0; i<len; ++i) ina[i] ^= inb[i]; 
   } void Des::rotatel (bool *in, int len, int loop) {memcpy (TMP, in, loop); 
   memcpy (in, In+loop, Len-loop); 
 memcpy (In+len-loop, Tmp, loop); } void Des::bytetobit (bool *out, const char *in, int bits) {for (int i=0; i<bits; ++i) out[i] = (in[i> 
 >3]>> (i&7)) & 1; 
   } void Des::bittobyte (char *out, const bool *in, int bits) {memset (out, 0, bits>>3); 
 for (int i=0; i<bits; ++i) out[i>>3] |= in[i]<< (i&7); }////////////////////////////////////////////////////////////////////////////Code ends///////////////////////// 
 /////////////////////////////////////////////////

The above is the entire content of this article, I hope to help you learn, but also hope that we support the cloud habitat community.