C++中四种加密算法之DES源代码

2024-03-23 12:41:05

DES算法是一种最通用的对称密钥算法，因为算法本身是公开的，所以其安全性在于密钥的安全性。基于密钥的算法通常有两类：对称算法和公开密钥算法。对称算法的对称性体现在加密密钥能够从解密密钥推算出来，反之亦然。

在大多数对称算法中，加解密的密钥是相同的，DES就是这样。可见，对称密钥算法的加解密密钥都是保密的。而公开密钥算法的加密密钥是公开的，解密密钥是保密的。

DES具体算法如下：

//////////////////////////////////////////////////////////////////////////
 /*
   Provided by 朱孟斌, National University Of Technology
   Email: zmbtsubasa@gmailcom
   This product is 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 for false;
 @see enum  {ENCRYPT,DECRYPT};
 */
 enum  {ENCRYPT,DECRYPT};
 /*@brief 16圈子密钥*/
 static bool SubKey[2][16][48];// 16圈子密钥
 /*@brief 3次DES标志*/
 static bool Is3DES;// 3次DES标志
 static char Tmp[256];
 static char deskey[16];
 typedef bool  (*PSubKey)[16][48]; 

 class _declspec(dllexport) Des
 {
 public:
   Des();
   ~Des();
   //! Type—ENCRYPT:加密,DECRYPT:解密
   /*!
   输出缓冲区(Out)的长度 >= ((datalen+7)/8)*8,即比datalen大的且是8的倍数的最小正整数
   In 可以= Out,此时加/解密后将覆盖输入缓冲区(In)的内容
   当keylen>8时系统自动使用3次DES加/解密,否则使用标准DES加/解密超过16字节后只取前16字节
   @see bool 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 标准DES加/解密
   @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);//标准DES加/解密
   /*! @brief 设置密钥
   @see static void SetKey(const char* Key, int len);
   */
   static void SetKey(const char* Key, int len);// 设置密钥
   /*! @brief 设置子密钥
   @see static void SetSubKey(PSubKey pSubKey, const char Key[8]);
   */
   static void SetSubKey(PSubKey pSubKey, const char Key[8]);// 设置子密钥
   /*! @brief f 函数
   @see static void F_func(bool In[32], const bool Ki[48]);
   */
   static void F_func(bool In[32], const bool Ki[48]);// f 函数
   /*! @brief S 盒代替
   @see static void S_func(bool Out[32], const bool In[48]);
   */
   static void S_func(bool Out[32], const bool In[48]);// S 盒代替
   /*! @brief 变换
   @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);// 变换
   /*! @brief 异或
   @see static void Xor(bool *InA, const bool *InB, int len);
   */
   static void Xor(bool *InA, const bool *InB, int len);// 异或
   /*! @brief 循环左移
   @see static void RotateL(bool *In, int len, int loop);
   */
   static void RotateL(bool *In, int len, int loop);// 循环左移
   /*! @brief 字节组转换成位组
   @see static void ByteToBit(bool *Out, const char *In, int bits);
   */
   static void ByteToBit(bool *Out, const char *In, int bits);// 字节组转换成位组
   /*! @brief 位组转换成字节组
   @see static void BitToByte(char *Out, const bool *In, int bits);
   */
   static void BitToByte(char *Out, const bool *In, int bits);// 位组转换成字节组 

 };
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 #endif

DES.cpp文件：

//////////////////////////////////////////////////////////////////////////
 /*
   Provided by 朱孟斌, National University Of Technology
   Email: zmbtsubasa@gmailcom
   This product is 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, 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
 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, 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 const char E_Table[48] = {
   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
 };
 // 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, 46, 38, 30, 22,
   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, 56, 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, 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
 }; 

 //////////////////////////////////////////////////////////////////////////
 // Code starts:
 //////////////////////////////////////////////////////////////////////////
 Des::Des()
 { 

 }
 Des::~Des()
 { 

 }
 bool Des::Des_Go(char *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 加密:加(key0)-解(key1)-加(key0) 解密::解(key0)-加(key1)-解(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::DES(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, 28, LOOP_Table[i]);
     RotateL(KR, 28, 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]<<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
 //////////////////////////////////////////////////////////////////////////

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。

C++实现DES加密算法实例解析

本文所述实例是一个实现DES加密算法的程序代码,在C++中,DES加密是比较常用的加密算法了,且应用非常广泛.本CPP类文件可满足你的DES加密需要,代码中附带了丰富的注释,相信对于大家理解DES可以起到很大的帮助. 具体实现代码如下: #include "memory.h" #include "stdio.h" enum {encrypt,decrypt};//ENCRYPT:加密,DECRYPT:解密 void des_run(char out[8],char
C++加密解密php代码的方法

本文实例讲述了C++加密解密php代码的方法.分享给大家供大家参考.具体实现方法如下: #include "php.h" #include "php_ini.h" #include "ext/standard/info.h" #include "string.h" char * key = "abcd"; PHP_FUNCTION(encode){ long key_len = strlen(key); c
Java与C++实现相同的MD5加密算法简单实例

1.Java版 package com.lyz.utils.common; import java.io.UnsupportedEncodingException; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; /** * MD5加密 * @author liuyazhuang */ public class MD5Hash { public static String md5
C语言使用openSSL库DES模块实现加密功能详解

本文实例讲述了C语言使用openSSL库DES模块实现加密功能.分享给大家供大家参考,具体如下: 在通讯过程中为了防止普通的玩家截取协议修改内容并且发送,我们是有必要对协议进行加密的.当前这样的加密手段都已经是变成世界里面的基础设施了.我们只需要将其引入到工程中就好.本文将会基于OpenSSL来编写一个加密.解密的实例.时下流行的加密解密方式有DES/AES.先我们来聊聊历史吧. 历史介绍 DES(Data Encryption Standard) DES一度是电子数据对称加密的主导者.他影响了
C++中四种加密算法之AES源代码

摘要:作为新一代的加密标准,AES 旨在取代 DES(请看<DES加密算法的C++实现>),以适应当今分布式开放网络对数据加密安全性的要求.本文在分析了 AES 加密原理的基础上着重说明了算法实现的具体步骤,并用 C++ 实现了对文件的加密和解密. 一.AES 介绍 AES(高级加密标准,Advanced Encryption Standard),在密码学中又称 Rijndael 加密法,是美国联邦政府采用的一种分组加密标准.这个标准用来替代原先的 DES,目前已经广为全世界所使用,成为对称密
基于C语言实现的aes256加密算法示例

本文实例讲述了基于C语言实现的aes256加密算法.分享给大家供大家参考,具体如下: aes256.h: #ifndef uint8_t #define uint8_t unsigned char #endif #ifdef __cplusplus extern "C" { #endif typedef struct { uint8_t key[32]; uint8_t enckey[32]; uint8_t deckey[32]; } aes256_context; void aes
C语言使用openSSL库AES模块实现加密功能详解

本文实例讲述了C语言使用openSSL库AES模块实现加密功能.分享给大家供大家参考,具体如下: 概述在密码学里面一共有3中分类: 1.对称加密/解密对称加密比较常见的有DES/AES.加密方和解密方都持有相同的密钥.对称的意思就是加密和解密都是用相同的密钥. 2.非对称加密/解密常见的加密算法DSA/RSA.如果做过Google Pay的话,应该不会陌生.非对称意味着加密和解密使用的密钥不是相同的.这种应用的场合是需要保持发起方的权威性,比如Google中一次支付行为,只能Google通
C++中四种加密算法之DES源代码

DES算法是一种最通用的对称密钥算法,因为算法本身是公开的,所以其安全性在于密钥的安全性.基于密钥的算法通常有两类:对称算法和公开密钥算法.对称算法的对称性体现在加密密钥能够从解密密钥推算出来,反之亦然. 在大多数对称算法中,加解密的密钥是相同的,DES就是这样.可见,对称密钥算法的加解密密钥都是保密的.而公开密钥算法的加密密钥是公开的,解密密钥是保密的. DES具体算法如下: ///////////////////////////////////////////////////////////
Java中四种遍历List的方法总结(推荐)

实例如下: package com.ietree.basic.collection.loop; import java.util.ArrayList; import java.util.Iterator; import java.util.List; /** * List遍历 * * @author Dylan */ public class ListLoop { public static void main(String[] args) { // 初始化一个长度为10的ArrayList L
jsp中四种传递参数的方法

今天老师讲了jsp中四种传递参数的方法,我觉得总结一下,挺好的,以备后用! 1.form表单 2.request.setAttribute();和request.getAttribute(); 3.超链接:<a herf="index.jsp"?a=a&b=b&c=c>name</a> 4.<jsp:param> 下面一一举例说明: 1.form表单 form.jsp: <%@page contentType="tex
Java中四种访问权限资料整理

Java中四种访问权限总结一.Java中有四种访问权限, 其中三种有访问权限修饰符,分别为private.public.protected,还有一种不带任何修饰符(default). 1. private: Java语言中对访问权限限制的最窄的修饰符,一般称之为"私有的".被其修饰的属性以及方法只能被该类的对象访问,其子类不能访问,更不能允许跨包访问. 2. default:即不加任何访问修饰符,通常称为"默认访问权限"或者"包访问权限".
Java中四种线程池的使用示例详解

在什么情况下使用线程池? 1.单个任务处理的时间比较短 2.将需处理的任务的数量大使用线程池的好处: 1.减少在创建和销毁线程上所花的时间以及系统资源的开销 2.如不使用线程池,有可能造成系统创建大量线程而导致消耗完系统内存以及"过度切换". 本文详细的给大家介绍了关于Java中四种线程池的使用,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍: FixedThreadPool 由Executors的newFixedThreadPool方法创建.它是一种线程数量固定的线程
浅谈java面向对象中四种权限

俗话说没有规矩就没有方圆,java作为一门严谨的面向对象的高级编程语言,自然对权限整个重要的问题有严格的控制. Java中,可以通过一些Java关键字,来设置访问控制权限: 主要有 private(私有), package(包访问权限),protected(子类访问权限),public(公共访问权限) 在java里,这些语句都可以修饰类中的成员变量和方法,但是只有public和友好型可以修饰类.举个例子: 接下来就详细解释一下这几种权限的差别(博客最后有表格)按权限由低到高:(高权限有低权限所有
浅谈MySQL中四种常用存储引擎

MySQL常用的四种引擎的介绍 (1):MyISAM存储引擎: 不支持事务.也不支持外键,优势是访问速度快,对事务完整性没有要求或者以select,insert为主的应用基本上可以用这个引擎来创建表支持3种不同的存储格式,分别是:静态表:动态表:压缩表静态表:表中的字段都是非变长字段,这样每个记录都是固定长度的,优点存储非常迅速,容易缓存,出现故障容易恢复:缺点是占用的空间通常比动态表多(因为存储时会按照列的宽度定义补足空格)ps:在取数据的时候,默认会把字段后面的空格去掉,如果不注意会把
Java中四种9*9乘法表的实现方式(附代码)

前言: 初学java,实现99乘法表是必学必会的内容. 需求 : 分别写出上下左右,对应四个角的乘法表. 思路: 可以先打印出*星星,形成一个直角三角形,然后再替换成乘法公式. 代码如下: public class Demo { public static void main(String[] args) { for (int i = 1; i <=5 ; i++) { for (int j = 1; j <=i; j++) { System.out.print("* ")
JVM中四种GC算法案例详解

目录介绍引用计数算法(Reference counting) 算法思想: 核心思想: 优点: 缺点: 例子如图: 标记–清除算法(Mark-Sweep) 算法思想: 优点缺点例子如图标记–整理算法算法思想优点缺点例子复制算法算法思想优点缺点总结介绍程序在运行过程中,会产生大量的内存垃圾(一些没有引用指向的内存对象都属于内存垃圾,因为这些对象已经无法访问,程序用不了它们了,对程序而言它们已经死亡),为了确保程序运行时的性能,java虚拟机在程序运行的过程中不断地进行

C++中四种加密算法之DES源代码

相关推荐

随机推荐