可以相互解密的C#版及C++版DES算法代码(包括ECB、CBC模式，Zeros、PKCS7填充，以及Base64编解码)

最新推荐文章于 2024-05-03 13:24:36 发布
最新推荐文章于 2024-05-03 13:24:36 发布
阅读量6.3k 收藏 6
点赞数
分类专栏： 技术应用 文章标签： DES算法 加密 CBC PKCS7 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/powerants/article/details/39188515
版权

由于C#中对于DES算法有标准类，所以使用起来特别简单；但C++就有点费劲了，经过整合网上资源并修改bug，现在放出完整C++DES算法代码，已测试通过。这里要特别感谢http://blog.csdn.net/bengold1979/article/details/2208930，他的代码中大部分都没问题，但是在PKCS7填充算法的加密解密中有一些问题，经过调整，目前ECB、CBC模式，Zeros、PKCS7填充算法都以可以正常运行，还有其他填充算法尚待补充。

本文所使用的加密思路是先进行DES加密然后进行Base64编码。解密反之。

1.先放出DES加密解密C#代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.IO;
using System.IO.Compression;
using System.Xml;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Reflection;
using System.ComponentModel;
using System.Security.Cryptography;
using DES.Core;
using System.Globalization;

namespace DESConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            //加密示例 /E /Stext /Y
            //解密示例 /D /Stext /Y
            if (args.Length == 0) return;
            string param1 = args[0];
            string param2 = "/S";
            bool IncludeLocalInfo = false;            
            Tools ToolObj = new Tools();

            if (param1 == "/E")
            {
                if (args.Length >= 2)
                    param2 = args[1];
                if (param2.Substring(0, 2) == "/S")
                    param2 = param2.Substring(2, param2.Length - 2);
                if (args.Length >= 3)
                    IncludeLocalInfo = (args[2] == "Y");
                Console.WriteLine("加密:{0}", Tools.Encrypt(param2, IncludeLocalInfo));    
            }
            else if (param1 == "/D")
            {
                if (args.Length >= 2)
                    param2 = args[1];
                if (param2.Substring(0, 2) == "/S")
                    param2 = param2.Substring(2, param2.Length - 2);
                if (args.Length >= 3)
                    IncludeLocalInfo = (args[2] == "Y");
                Console.WriteLine("解密:{0}", Tools.Decipher(param2, IncludeLocalInfo));
            }            
        }
    }
}


namespace DES.Core
{
    /// <summary>
    /// 核心模塊的公用涵數類別。
    /// </summary>
    [Serializable]
    public class Tools
    {
        /// <summary>
        /// 常量。
        /// </summary>
        private static String _ConstValue = "HELLOYOU"; //8碼
        /// <summary>
        /// 使用DES加密
        /// </summary>
        /// <param name="Str">待加密的字符串</param>
        /// <param name="IncludeLocalInfo">是否包含本地硬件訊息。</param>
        /// <returns>加密后的字符串</returns>
        public static String Encrypt(String Str, bool IncludeLocalInfo)
        {
            
            try
            {
                SymmetricAlgorithm sa = new DESCryptoServiceProvider();
                String _Key = _ConstValue;
                sa.Key = Encoding.UTF8.GetBytes(_Key);
                sa.IV = Encoding.UTF8.GetBytes(_ConstValue);
                //指定加密的运算模式
                sa.Mode = System.Security.Cryptography.CipherMode.CBC;
                //获取或设置加密算法的填充模式
                sa.Padding = System.Security.Cryptography.PaddingMode.PKCS7;

                ICryptoTransform ct = sa.CreateEncryptor();

                byte[] byt = Encoding.UTF8.GetBytes(Str);

                MemoryStream ms = new MemoryStream();
                CryptoStream cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
                cs.Write(byt, 0, byt.Length);
                cs.FlushFinalBlock();
                cs.Close();
                return Convert.ToBase64String(ms.ToArray());
            }
            catch { }
            return "";
        }
        /// <summary>
        /// 使用DES解密
        /// </summary>
        /// <param name="Str">待解密的字符串</param>
        /// <param name="IncludeLocalInfo">是否包含本地硬件訊息。</param>
        /// <returns>解密后的字符串</returns>
        public static String Decipher(String Str, bool IncludeLocalInfo)
        {
            if (null == Str || 0 == Str.Length) return "";
            try
            {
                SymmetricAlgorithm sa = new DESCryptoServiceProvider();
                String _Key = _ConstValue;
                sa.Key = Encoding.UTF8.GetBytes(_Key);
                sa.IV = Encoding.UTF8.GetBytes(_ConstValue);
                ICryptoTransform ct = sa.CreateDecryptor();

                byte[] byt = Convert.FromBase64String(Str);

                MemoryStream ms = new MemoryStream();
                CryptoStream cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
                cs.Write(byt, 0, byt.Length);
                cs.FlushFinalBlock();
                cs.Close();
                return Encoding.UTF8.GetString(ms.ToArray());
            }
            catch { }
            return "";
        }              
    }
}


2.C++代码（BCB编写）此部分请参照http://blog.csdn.net/bengold1979/article/details/2208930，我调整了DES算法函数及填充函数，其他变化不大，另外我增加了Base64编码类

（1）头文件DES.H

声明DES类及Base64编码类

//---------------------------------------------------------------------------

#ifndef DESH
#define DESH
#include <vcl.h>
//---------------------------------------------------------------------------

//
//                                                                  //
// DES.h: declaration of the TDES、TBase64、TBase64DES class.     //
//                                                                  //
//

/* TDES类说明
 *
 * 该类是DES和3DES算法类
 *
 */
class TDES
{
public:
    TDES();
    virtual ~TDES();

    //加密解密
	enum
	{
		ENCRYPT = 0,    // 加密
		DECRYPT,        // 解密
	};

	//DES算法的模式
	enum
	{
		ECB     = 0,    // ECB模式
		CBC             // CBC模式
	};

	typedef bool (*PSubKey)[16][48];

	//Pad填充的模式
	enum
	{
		PAD_ISO_1 = 0,  // ISO_1填充：数据长度不足8比特的倍数，以0x00补足，如果为8比特的倍数，补8个0x00
		PAD_ISO_2,      // ISO_2填充：数据长度不足8比特的倍数，以0x80,0x00..补足，如果为8比特的倍数，补0x80,0x00..0x00
		PAD_PKCS_7      // PKCS7填充：数据长度除8余数为n,以(8-n)补足为8的倍数，如果为8比特的倍数，补8个0x08
	};

	/* 执行DES算法对文本加解密
	 *
	 * Description    : 执行DES算法对文本加解密
	 * @param bType   : 类型：加密ENCRYPT，解密DECRYPT
	 * @param bMode   : 模式：ECB,CBC
	 * @param In      : 待加密串指针
	 * @param Out     : 待输出串指针
	 * @param datalen : 待加密串的长度，同时Out的缓冲区大小应大于或者等于datalen
	 * @param Key     : 密钥(可为8位,16位,24位)支持3密钥
	 * @param keylen  : 密钥长度，多出24位部分将被自动裁减
	 * @return true--成功；false--失败；
	 */
	static bool RunDES(bool bType, bool bMode, int PaddingMode, const unsigned char* IV, const unsigned char* In,
		unsigned char* Out, unsigned datalen, const unsigned char* Key, unsigned keylen);

protected:
	//计算并填充子密钥到SubKey数据中
	static void SetSubKey(PSubKey pSubKey, const unsigned char Key[8]);

	//DES单元运算
	static void DES(unsigned char Out[8], const unsigned char In[8], const PSubKey pSubKey, bool Type);

	/* 补足8位数据
	 *
	 * Description    : 根据协议对加密前的数据进行填充
	 * @param nType   : 类型：PAD类型
	 * @param In      : 数据串指针
	 * @param Out     : 填充输出串指针
	 * @param datalen : 数据的长度
	 * @param padlen  : (in,out)输出buffer的长度，填充后的长度
	 * @return true--成功；false--失败；
	 */
	static bool RunPad(bool bType, int nType, const unsigned char* In,
		unsigned datalen, unsigned char* Out, unsigned& padlen);
};
//---------------------------------------------------------------------------

/* TBase64类说明
 *
 * 该类是Base64编码类
 *
 */
class TBase64
{
public:
	static char* Base64_Encode(const char* src);
	static char* Base64_Decode(const char* src);
protected:
	static void Base64_Encode(unsigned char* src,unsigned char* dest, int srclen);
	static void Base64_Decode(unsigned char* src, unsigned char* dest, int srclen);
	static int GetLenEncode(const char* src);
	static int GetLenDecode(const char* src);
};
//---------------------------------------------------------------------------
#endif


（2）DES.CPP文件请参考http://blog.csdn.net/bengold1979/article/details/2208930，我将有变动的部分贴出来。

//---------------------------------------------------------------------------


#pragma hdrstop

#include "DES.h"
#include <iostream>
using namespace std;
//---------------------------------------------------------------------------

#pragma package(smart_init)
///
//                                                                               //
// DES.cpp: implementation of the TDES and TBase64 class.                      //
//                                                                               //
// Date: 2014.09.10                                                              //
// Description:                                                                  //
//    DES类，支持ECB、CBC算法，PAD_ISO_1、PAD_ISO_2、PKCS7填充模式               //
//    BASE64类，支持将BYTE转为Base64编码                                         //
//                                                                               //
///

const char _ConstValue[] = {"HELLOYOU"};//8碼
。。。。。。。。。部分代码请参考上文提到的链接。。。。。。。。。。。。。。。。
/*使用示例：

*/
bool TDES::RunDES(bool bType, bool bMode, int PaddingMode, const unsigned char* Iv, const unsigned char* In,
		unsigned char* Out, unsigned datalen, const unsigned char* Key, unsigned keylen)
{
	memset(Out, 0x00, strlen(Out));
	unsigned char* outbuf = Out;
    //判断输入合法性
	if(!(/*In && */outbuf && Key && /*datalen &&*/ keylen>=8)) // 空字符串加密的时候In和datalen都为0,应该去掉此判断
		return false;

	unsigned char* inbuf = new unsigned char[datalen + 8];
	memset(inbuf, 0x00, datalen + 8);
	memcpy(inbuf, In, datalen);
	unsigned padlen = datalen;
	// 根据填充模式填充
	if (!RunPad(bType, PaddingMode, In, datalen, inbuf, padlen))
	{
		delete []inbuf; inbuf = NULL;
		return false;
	}
	unsigned char* tempBuf = inbuf;

    bool m_SubKey[3][16][48];        //密钥
    //构造并生成SubKeys
	unsigned char nKey = (keylen>>3)>=3 ? 3: (keylen>>3);
    for(int i=0;i<nKey;i++)
    {
        SetSubKey(&m_SubKey[i],&Key[i<<3]);
    }

    if(bMode == ECB)    //ECB模式
    {
        if(nKey ==  1)  //单Key
        {
            int j = padlen>>3;
            for(int i=0,j = padlen>>3;i<j;++i,outbuf+=8,tempBuf+=8)
            {
                DES(outbuf,tempBuf,&m_SubKey[0],bType);
            }
        }
        else
        if(nKey == 2)   //3DES 2Key
        {
            for(int i=0,j = padlen>>3;i<j;++i,outbuf+=8,tempBuf+=8)
            {
                DES(outbuf,tempBuf,&m_SubKey[0],bType);
                DES(outbuf,outbuf,&m_SubKey[1],!bType);
                DES(outbuf,outbuf,&m_SubKey[0],bType);
            }
        }
        else            //3DES 3Key
        {
            for(int i=0,j=padlen>>3;i<j;++i,outbuf+=8,tempBuf+=8)
            {
                DES(outbuf,tempBuf,&m_SubKey[bType? 2 : 0],bType);
                DES(outbuf,outbuf,&m_SubKey[1],!bType);
                DES(outbuf,outbuf,&m_SubKey[bType? 0 : 2],bType);
            }
        }
    }
    else                //CBC模式
	{
		unsigned char   cvec[8] =   ""; // 扭转向量
		unsigned char   cvin[8] =   ""; // 中间变量
		memcpy(cvec, Iv, 8);

        if(nKey == 1)   //单Key
        {
			for(int i=0,j=padlen>>3;i<j;++i,outbuf+=8,tempBuf+=8)
            {
				if(bType    ==  TDES::ENCRYPT)
                {
                    for(int j=0;j<8;++j)     //将输入与扭转变量异或
                    {
                        cvin[j] =   tempBuf[j] ^ cvec[j];
                    }
                }
                else
                {
                    memcpy(cvin,tempBuf,8);
                }

                DES(outbuf,cvin,&m_SubKey[0],bType);

                if(bType    ==  TDES::ENCRYPT)
                {
                    memcpy(cvec,outbuf,8);         //将输出设定为扭转变量
                }
                else
                {
					for(int j=0;j<8;++j)     //将输出与扭转变量异或
                    {
						outbuf[j]  =   outbuf[j] ^ cvec[j];
                    }
                    memcpy(cvec,cvin,8);            //将输入设定为扭转变量
                }
			}
		}
        else
        if(nKey == 2)   //3DES CBC 2Key
        {
            for(int i=0,j=padlen>>3;i<j;++i,outbuf+=8,tempBuf+=8)
            {
                if(bType    ==  TDES::ENCRYPT)
                {
                    for(int j=0;j<8;++j)     //将输入与扭转变量异或
                    {
						cvin[j] =   tempBuf[j] ^ cvec[j];
                    }
				}
                else
                {
                    memcpy(cvin,tempBuf,8);
                }

                DES(outbuf,cvin,&m_SubKey[0],bType);
                DES(outbuf,outbuf,&m_SubKey[1],!bType);
                DES(outbuf,outbuf,&m_SubKey[0],bType);

                if(bType    ==  TDES::ENCRYPT)
                {
                    memcpy(cvec,outbuf,8);         //将输出设定为扭转变量
                }
                else
                {
                    for(int j=0;j<8;++j)     //将输出与扭转变量异或
                    {
                        outbuf[j]  =   outbuf[j] ^ cvec[j];
                    }
                    memcpy(cvec,cvin,8);            //将输入设定为扭转变量
                }
            }
        }
        else            //3DES CBC 3Key
        {
            for(int i=0,j=padlen >>3;i<j;++i,outbuf+=8,tempBuf+=8)
            {
                if(bType    ==  TDES::ENCRYPT)
                {
                    for(int j=0;j<8;++j)     //将输入与扭转变量异或
                    {
                        cvin[j] =   tempBuf[j] ^ cvec[j];
                    }
                }
                else
                {
                    memcpy(cvin,tempBuf,8);
                }

                DES(outbuf,cvin,&m_SubKey[bType ? 2 : 0],bType);
                DES(outbuf,outbuf,&m_SubKey[1],!bType);
                DES(outbuf,outbuf,&m_SubKey[bType ? 0 : 2],bType);

                if(bType    ==  TDES::ENCRYPT)
				{
                    memcpy(cvec,outbuf,8);         //将输出设定为扭转变量
                }
                else
                {
                    for(int j=0;j<8;++j)     //将输出与扭转变量异或
                    {
						outbuf[j]  =   outbuf[j] ^ cvec[j];
                    }
                    memcpy(cvec,cvin,8);            //将输入设定为扭转变量
                }
			}
        }
	}
	if(inbuf)
	{
		delete []inbuf;
		inbuf = NULL;
	}
	if(bType == TDES::DECRYPT)
	{
		if(PaddingMode    ==  PAD_ISO_1)
		{
			//待补充
		}
		else
		if(PaddingMode    ==  PAD_ISO_2)
		{
			//待补充
		}
		else
		if(PaddingMode    ==  PAD_PKCS_7)
		{
			unsigned int l_Out = strlen(Out);
			unsigned int l_num = Out[l_Out-1];
			if (l_num <= 8) // 非法密文會造成此處出問題，加以保護
				memset(Out+l_Out-l_num, 0x00, l_num);
		}
	}

	return true;
}




/*******************************************************************/
  /*
  函 数 名 称:  RunPad
  功 能 描 述： 根据协议对加密前的数据进行填充
  参 数 说 明： bType   :类型：PAD类型
				In      :数据串指针
				Out     :填充输出串指针
				datalen :数据的长度
				padlen  :(in,out)输出buffer的长度，填充后的长度

  返回值 说明： bool    :是否填充成功
  修 改 历 史：
		2014.09.10 修改PKCS7填充算法；修改明文是8byte的整倍数时加密解密算法；修改解密算法
  更 新 日 期：  2014.09.10
  */
/*******************************************************************/
bool TDES::RunPad(bool bType, int nType, const unsigned char* In,
		 unsigned datalen, unsigned char* Out, unsigned& padlen)
{
    if (nType < PAD_ISO_1 || nType > PAD_PKCS_7)
        return false;

	if (In == NULL || datalen < 0 || Out == NULL)
        return false;
	int res = (datalen & 0x07);

	if(bType == TDES::DECRYPT)
	{
		padlen = datalen;
		memcpy(Out, In, datalen);
		return true;
	}

	padlen = (datalen+8-res);
	memcpy(Out,In,datalen);

	if(nType    ==  PAD_ISO_1)
	{
		memset(Out+datalen,0x00,8-res);
    }
    else
    if(nType    ==  PAD_ISO_2)
    {
        memset(Out+datalen,0x80,1);
        memset(Out+datalen,0x00,7-res);
    }
    else
    if(nType    ==  PAD_PKCS_7)
    {
		memset(Out+datalen,8-res,8-res);
	}
	else
	{
		// 其他填充模式尚待补充
        return false;
    }

    return true;
}

//转换前 aaaaaabb ccccdddd eeffffff
//转换后 00aaaaaa 00bbcccc 00ddddee 00ffffff
void TBase64::Base64_Encode(unsigned char* src,unsigned char* dest, int srclen)
{
	//编码函数
	unsigned char EncodeIndex[] =
	{
		//编码索引表
		'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
		'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
		'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
	 	'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/','='
	};

	 int sign = 0;
	 for (int i = 0; i!= srclen; i++,src++,dest++)
	 {
		  switch(sign)
		  {
			  case 0://编码第1字节
			   *(dest) = EncodeIndex[*src >> 2];
			   break;
			  case 1://编码第2字节
			   *dest = EncodeIndex[((*(src-1)  & 0x03) << 4) | (((*src) & 0xF0) >> 4)];
			   break;
			  case 2://编码第3字节
			   *dest = EncodeIndex[((*(src-1) &0x0F) << 2) | ((*(src) & 0xC0) >> 6)];
			   *(++dest) = EncodeIndex[(*(src) &0x3F)];//编码第4字节
			   break;
		  }
		  (sign == 2)?(sign = 0):(sign++);
	 }

	 switch(sign)
	 {
	 	//3的余数字节，后补=处理
		 case 0:
		  break;
		 case 1:
		 // *(dest++) = EncodeIndex[((*(src-1)  & 0x03) << 4) | (((*src) & 0xF0) >> 4)];
		  *(dest++) = EncodeIndex[((*(src-1)  & 0x03) << 4) ];
		  *(dest++) = '=';
		  *(dest++) = '=';
		  break;
		 case 2:
		 // *(dest++) = EncodeIndex[((*(src-1) &0x0F) << 2) | ((*(src) & 0xC0) >> 6)];
		  *(dest++) = EncodeIndex[((*(src-1) &0x0F) << 2)];
		  *(dest++) = '=';
		  break;
		 default:
		  break;
	 }
}
//---------------------------------------------------------------------------

void TBase64::Base64_Decode(unsigned char* src, unsigned char* dest, int srclen)
{
	unsigned char DecodeIndex[] =
	{
		//解码索引表
		0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,//0  00-15
		0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,//1  16-31
		0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x3E,0x40,0x40,0x40,0x3F,//2  32-47    43[+](0x38)  47[/](0x39)
		0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x40,0x40,0x40,0x40,0x40,0x40,//3  48-63    48[0](0x34)- 57[9](0x3D)  61[=](0x40)
		0x40,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,//4  64-79    65[A](0x00)- 79[O](0x0E)
		0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x40,0x40,0x40,0x40,0x40,//5  80-95    80[P](0x0F)- 90[Z](0x19)
		0x40,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,//6  96-111   97[a](0x1A)-111[o](0x28)
		0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x40,0x40,0x40,0x40,0x40 //7 112-127  122[p](0x29)-122[z](0x33)
	};

	//解码处理函数 //len%4 == 0总为true;
	for (int i = 0; i != srclen/4; i++)//对于不足4个的不作计算
	{
		//每个字符,通过数组直接得到其值,比较快
		*dest = (DecodeIndex[*src] << 2) | ((DecodeIndex[*(src+1)] & 0x30) >> 4);
		*(dest+1) = (DecodeIndex[*(src+1)] << 4) | ((DecodeIndex[*(src+2)] &0x3C) >> 2);
		*(dest+2) = ((DecodeIndex[*(src+2)] & 0x03) << 6) | (DecodeIndex[*(src+3)] & 0x3F);
		src += 4;
		dest += 3;
	}
}
//---------------------------------------------------------------------------
//*/
int TBase64::GetLenEncode(const char* src)
{
	//求编码后的长度
	int len = strlen((char*)src);
	return (len + (len%3 == 0? 0:(3-len%3)))/3*4 + 1;
}
//---------------------------------------------------------------------------
int TBase64::GetLenDecode(const char* src)
{
	//求解码后的长度
	int len = strlen(src);
	return len/4*3 + 1;
}
//---------------------------------------------------------------------------
char* TBase64::Base64_Encode(const char* src)
{
	int src_len = strlen(src);
	int lenEncode = GetLenEncode(src);
	unsigned char* Base64Out = new unsigned char[lenEncode];
	memset(Base64Out, 0x00, lenEncode);
	Base64_Encode((unsigned char *)src, (unsigned char *)Base64Out, src_len);//原字符长度
	return Base64Out;
}
//---------------------------------------------------------------------------
char* TBase64::Base64_Decode(const char* src)
{
	int lenEncode = strlen(src);
	int lenDecode = GetLenDecode((const char *)src);//获得编码后字符串的再解码的长度
	unsigned char* pDecodeStr = new unsigned char[lenDecode];
	memset(pDecodeStr, 0x00, lenDecode);
	Base64_Decode((unsigned char *)src, pDecodeStr, lenEncode);//编码后的字符长度
	return pDecodeStr;
}
//---------------------------------------------------------------------------


（3）测试代码头文件Base64DES.H

//---------------------------------------------------------------------------

#ifndef Base64DESH
#define Base64DESH
#include "DES.h"
//---------------------------------------------------------------------------
extern "C" __declspec(dllexport) WINAPI void MainTest();

#endif


（4）测试代码Base64DES.CPP文件

//---------------------------------------------------------------------------


#pragma hdrstop

#include "Base64DES.h"
#include <iostream>
using namespace std;
//---------------------------------------------------------------------------

#pragma package(smart_init)
extern const char _ConstValue[];

/*
测试代码1
*/

extern "C" __declspec(dllexport) WINAPI void MainTest()
{
	puts("Testing RunDES......");

	char In[1024] = {0};
	char Out[1024] = {0};
	char Key[8] = {0};
	memcpy(Key, _ConstValue, 8);
	char IV[8] = {0};
	memcpy(IV, _ConstValue, 8);
	puts("please input your words");
	gets(In);

	// 对str进行DES加密，CBC + PKCS7模式
	memset(Out, 0x00, 1024);
	TDES::RunDES(TDES::ENCRYPT, TDES::CBC, TDES::PAD_PKCS_7, IV, In, Out, strlen(In), Key, strlen(Key));
	puts("after encrypting:");
	puts(Out);

	// 将加密后的strout进行Base64编码
	char* Base64Out =  TBase64::Base64_Encode(Out);
	printf("Base64编码之后，您的文件经过DES加密后的密文是：\n");
	printf("%s\n", Base64Out);

	// 对Base64编码的pEncodeStr进行解码
	char* ByteIn =  TBase64::Base64_Decode(Base64Out);
	printf("Base64解码之后的明文是：\n");
	puts(ByteIn);

	// 用Base64解码后的pDecodeStr进行DES解密，CBC + PKCS7模式
	memset(In, 0x00, 1024);
	TDES::RunDES(TDES::DECRYPT, TDES::CBC, TDES::PAD_PKCS_7, IV, ByteIn, In, strlen(ByteIn), Key, strlen(Key));
	printf("Base64解码之后，您的文件经过DES解密后的明文是：\n");
	puts(In);

	// 用未经编码的strout直接DES解密，CBC + PKCS7模式
	puts("after decrypting:");
	memset(In, 0x00, 1024);
	TDES::RunDES(TDES::DECRYPT, TDES::CBC, TDES::PAD_PKCS_7, IV, Out, In, strlen(Out), Key, strlen(Key));
	puts(In);

	delete []Base64Out; Base64Out=NULL;
	delete []ByteIn; ByteIn=NULL;
}
// ---------------------------------------------------------------------------


经过测试，此部分C++DES算法可以和C#代码相互解密。如有不妥之处，欢迎大家提出宝贵意见。

powerants
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
DES/ECB加解密算法
04-24
NULL 博文链接：https://jiage17.iteye.com/blog/2421908
C#实现3DES算法的加密和解密过程
10-31
在.NET环境中，C#语言提供了丰富的加密库，其中包括对3DES（Triple Data Encryption Standard）算法的支持。3DES是一种对称加密算法，它基于DES（Data Encryption Standard）算法，通过三次迭代来提高安全性。本篇...
[ delphi ] AES-256-ECB 加密、解密算法控件说明
sensor_WU 博客
03-18 3500
AES-256加密、解密算法控件说明前言1. 控件属性1.1 SourceEncodingType：源字符串的编码方式1.2 AlgoMode: 算法模式1.3 KeyBit: 密钥长度1.4 KeyStr: 当前密钥1.5 PaddingType：补齐方式1.6 InitVector：初始向量1.7 SourceStr：源字符串2. 公共方法2.1 Bytes2HexStr：字节流转16进制字符...
JAVA——DES/ECB/PKCS7Padding加密算法[Cannot find any provider supporting DESEDE/CBC/PKCS7Padding]解决方案
最新发布
竹林幽深
05-03 380
这是一个迭代的分组密码，使用称为 Feistel 的技术，其中将加密的文本块分成两半。明文按64位进行分组，密钥长64位，密钥事实上是56位参与DES运算（第8、16、24、32、40、48、56、64位是校验位， 使得每个密钥都有奇数个1）分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。DES/ECB/PKCS7Padding加密算法：在Java开发中，用到的DES的ECB加密模式、PKCS7Padding填充方式，Java目前仅支持PKCS5Padding填充模式，
【Delphi】AES、DES、Blowfish、RC等加密解密控件（含源代码、演示程序，帮助文件）
sensor_WU 博客
12-13 1996
1. 对称加密解密控件 Cipher_Component 介绍 对称加密(也叫私钥加密)指加密和解密使用相同密钥的加密算法。有时又叫传统密码算法，就是加密密钥能够从解密密钥中推算出来，同时解密密钥也可以从加密密钥中推算出来。而在大多数的对称算法中，加密密钥和解密密钥是相同的，所以也称这种加密算法为秘密密钥算法或单密钥算法。它要求发送方和接收方在安全通信之前，商定一个密钥。对称算法的安全性依赖于密钥，泄漏密钥就意味着任何人都可以对他们发送或接收的消息解密，所以密钥的保密性对通信的安全性至关重要。 但是Delp
DES加密算法详解（ECB）
weixin_45605787的博客
06-24 438
https://blog.csdn.net/qq2489021103/article/details/112994887
分组加密模式浅析[整理]
蓬篙人的专栏
03-30 4700
互联网的软件设计一定少不了加密算法，并且大量使用的都会是对称加密，比较常见的对称加密有：DES、3DES、RC4、AES等等；加密算法都有几个共同的要点：密钥长度；（关系到密钥的强度） 加密模式；（ecb、cbc等等） 块加密算法里的填充方式区分； 对于加密模式，很多同学还不清楚，比如DES，也会有ECB、CBC等不同的区分，它们都是标准的；      Window
DES 加密解密程序及源代码 C#版
12-31
6. **模式(Padding)**：DES支持几种填充模式，如PKCS7、Zeros、ISO10126等，用于处理输入数据长度不是8字节整数倍的情况。默认是PKCS7，确保填充后的数据长度是8字节的倍数。 7. **示例代码**： ```csharp using ...
new_zeros() pytorch版本的转换方式
09-17
在PyTorch 0.4以及更新的版本中，你可以使用以下代码来创建一个全零张量，该张量与已有的`logprobs`张量具有相同的形状： ```python logprobs.new_zeros(logprobs.size()) ``` 这里的`new_zeros()` 方法首先通过`...
c# des加密解密小程序
07-18
2. **设置模式和填充方式**：可以设置加密模式（如CBC或ECB）和填充方式（如PKCS7或Zeros），以满足不同的安全需求。 3. **加密操作**：使用`CreateEncryptor()`方法获取加密变换流，然后通过`TransformFinalBlock()...
DELPHI、PHP、C#通用DES编码解码单元 (DELPHI下使用的代码)
gykthh的专栏
10-18 2724
unit uDES; {*********************************************************} {* DELPHI、PHP、C#通用DES编码解码单元 *} {* blessed 2016-10-18 *} {****************************************
c++,c#互通DES加密算法（支持中文）
08-17
实际项目提取，开箱即用，完美支持中文
java delphi des加密解密_Delphi小技巧（五）——Des加密算法（上）
weixin_39869693的博客
02-16 151
//好东西呀，喜欢~~~~//unit DESCrypt;interfaceusesSysUtils;function EnCrypt(aStr: string;acKey: string ): string;//加密字符串-------------------------------function DeCrypt(aStr: string; acKey: string ): string;//...
DELPHI 使用indy实现DES/ECB加解密
tangbin_88的博客
12-24 1250
使用indy实现DES/ECB加解密 最近在使用indy的，时候发现新的indy封装很多加解密的方法，苦于说明的资料太少，大家基本还是在用第三方写的函数库。结合前端时间实现RSA加密的方法，我写了个DES的例子，试了下，base64的编码返回和网上在线加解密的结果是一样的。 还有个问题是，目前只能实现字符串的加密，字节流和字节数组还不会搞… function DES_Encrypt(key, St...
delphi DES加密算法
weixin_30399155的博客
07-09 351
type TKeyByte = array[0..5] of Byte; TDesMode = (dmEncry, dmDecry); function EncryStr(Str, Key: String): String; function DecryStr(Str, Key: String): String; function EncryStrHex(St...
Delphi, C#, Java 三者兼容的DES字节流加密/解密
ksgimi
07-02 599
来源：http://hi.baidu.com/spacetimer/item/65d5a13f4af069be124b1479 网络传数据时一般要经过加密, 较简单的DES对称加密(CRC模式，PKCS7) ================================================================================== C#(客户端):...
DES ECB CBC and 3DES
08-07 1409
这一篇文章要解决数据加密——数据补位的问题、DES算法的两种模式ECB和CBC问题以及更加安全的算法——3DES算法。 一、数据补位 DES数据加解密就是将数据按照8个字节一段进行DES加密或解密得到一段8个字节的密文或者明文，最后一段不足8个字节，按照需求补足8个字节（通常补00或者FF，根据实际要求不同）进行计算，之后按照顺序将计算所得的数据连在一起即可。 这里有个问题就是为什么要进行数据
AES 加密位： 128位，加密模式：CBC， 填充模式：Zeros
ColorWaterer的专栏
08-17 6060
AES 加密位： 128位，加密模式：CBC， 填充模式：Zeros
AES-128-ECB-zeropadding填充加解密openssl标准库使用 linux C语言
季春贰柒的博客
09-19 3568
背景：openwrt环境下使用openssl标准库进行aes-128-ecb-zerospadding加解密。 一、接口及头文件 openssl的aes头文件 #include <openssl/aes.h> 1.AES_ecb_encrypt接口原型 简介：openssl标准库将加解密函数统一封装成AES_ecb_encrypt函数，通过第四个参数来选择调用加密程序或者解密程序，需要注意的是第三个参数需要通过AES_set_decrypt_key、AES_set_encrypt_key来生成
AES的填充方式的PKCS7和ZEROS
07-08
AES的填充方式有多种，其中包括PKCS7和ZEROS。这两种填充方式的主要区别在于对明文块长度不足时的填充方式。 1. PKCS7：PKCS7填充是一种常用的填充方式，它会在明文块末尾添加一个字节，该字节的值等于需要填充的字节数。例如，如果明文块长度不足，需要填充3个字节，则会在末尾添加3个字节，每个字节的值都是3。 2. ZEROS：ZEROS填充方式是一种简单的填充方式，它会使用0字节将明文块的长度扩展到加密算法所需的块长度。例如，如果明文块长度不足，需要填充3个字节，则会在末尾添加3个0字节。 在使用AES进行加解密时，需要指定填充方式。PKCS7填充方式在常见的加密库中较为常用，因为它是一种标准的填充方式。ZEROS填充方式相对简单，但不够安全，因为填充的内容是可预测的。 在选择填充方式时，建议使用PKCS7填充方式以确保数据的安全性。

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值