cdes加密解密代码（des加密算法的加密解密过程）

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

本文目录一览：

• 1、DES加密算法C语言实现
• 2、java的 DES 加密解密方法 求对应php的加密解密方法!!!!急切
• 3、des加密算法
• 4、如何使用JAVA实现对字符串的DES加密和解密
• 5、求C语言编写的DES加密解密源代码
• 6、用c++实现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 ];

}

java的 DES 加密解密方法 求对应php的加密解密方法!!!!急切

DES是一种标准的数据加密算法，关于这个算法的详细介绍可以参考wiki和百度百科：

php中有一个扩展可以支持DES的加密算法，是：extension=php_mcrypt.dll

在配置文件中将这个扩展打开还不能够在windows环境下使用

需要将PHP文件夹下的 libmcrypt.dll 拷贝到系统的 system32 目录下，这是通过phpinfo可以查看到mcrypt表示这个模块可以正常试用了。

下面是PHP中使用DES加密解密的一个例子：

    //$input - stuff to decrypt

    //$key - the secret key to use

    function do_mencrypt($input, $key)

    {

        $input = str_replace(""n", "", $input);

        $input = str_replace(""t", "", $input);

        $input = str_replace(""r", "", $input);

        $key = substr(md5($key), 0, 24);

        $td = mcrypt_module_open('tripledes', '', 'ecb', '');

        $iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);

        mcrypt_generic_init($td, $key, $iv);

        $encrypted_data = mcrypt_generic($td, $input);

        mcrypt_generic_deinit($td);

        mcrypt_module_close($td);

        return trim(chop(base64_encode($encrypted_data)));

    }

    //$input - stuff to decrypt

    //$key - the secret key to use

    function do_mdecrypt($input, $key)

    {

        $input = str_replace(""n", "", $input);

        $input = str_replace(""t", "", $input);

        $input = str_replace(""r", "", $input);

        $input = trim(chop(base64_decode($input)));

        $td = mcrypt_module_open('tripledes', '', 'ecb', '');

        $key = substr(md5($key), 0, 24);

        $iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);

        mcrypt_generic_init($td, $key, $iv);

        $decrypted_data = mdecrypt_generic($td, $input);

        mcrypt_generic_deinit($td);

        mcrypt_module_close($td);

        return trim(chop($decrypted_data));

    }

参考自：

des加密算法

des加密算法如下：

一、DES加密算法简介

DES(Data Encryption Standard)是目前最为流行的加密算法之一。DES是对称的，也就是说它使用同一个密钥来加密和解密数据。

DES还是一种分组加密算法，该算法每次处理固定长度的数据段，称之为分组。DES分组的大小是64位，如果加密的数据长度不是64位的倍数，可以按照某种具体的规则来填充位。

从本质上来说，DES的安全性依赖于虚假表象，从密码学的术语来讲就是依赖于“混乱和扩散”的原则。混乱的目的是为隐藏任何明文同密文、或者密钥之间的关系，而扩散的目的是使明文中的有效位和密钥一起组成尽可能多的密文。两者结合到一起就使得安全性变得相对较高。

DES算法具体通过对明文进行一系列的排列和替换操作来将其加密。过程的关键就是从给定的初始密钥中得到16个子密钥的函数。要加密一组明文，每个子密钥按照顺序（1-16）以一系列的位操作施加于数据上，每个子密钥一次，一共重复16次。每一次迭代称之为一轮。要对密文进行解密可以采用同样的步骤，只是子密钥是按照逆向的顺序（16-1）对密文进行处理。

二、DES加密算法加密原理

DES是采用分组加密。使用64位的分组长度和56位的密钥长度，将64位的输入经过一系列变换得到64位的输出。DES算法利用多次组合替代算法和换位算法，通过混淆和扩散的相互作用，把明文编辑成密码强度很高的密文。解密则使用了相同的步骤和相同的密钥。

64位数据为一组进行加密；

初始置换根据一张8*8的置换表，将64位的明文打乱

与56位的密钥经16轮次迭代运算形成的初始密文

最后经过初始逆置换得到分组的最终密文

如何使用JAVA实现对字符串的DES加密和解密

java加密字符串可以使用des加密算法，实例如下：

package test;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.security.*;

import javax.crypto.Cipher;

import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey;

/**

* 加密解密

*

* @author shy.qiu

* @since

*/

public class CryptTest {

/**

* 进行MD5加密

*

* @param info

* 要加密的信息

* @return String 加密后的字符串

*/

public String encryptToMD5(String info) {

byte[] digesta = null;

try {

// 得到一个md5的消息摘要

MessageDigest alga = MessageDigest.getInstance("MD5");

// 添加要进行计算摘要的信息

alga.update(info.getBytes());

// 得到该摘要

digesta = alga.digest();

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

// 将摘要转为字符串

String rs = byte2hex(digesta);

return rs;

}

/**

* 进行SHA加密

*

* @param info

* 要加密的信息

* @return String 加密后的字符串

*/

public String encryptToSHA(String info) {

byte[] digesta = null;

try {

// 得到一个SHA-1的消息摘要

MessageDigest alga = MessageDigest.getInstance("SHA-1");

// 添加要进行计算摘要的信息

alga.update(info.getBytes());

// 得到该摘要

digesta = alga.digest();

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

// 将摘要转为字符串

String rs = byte2hex(digesta);

return rs;

}

// //////////////////////////////////////////////////////////////////////////

/**

* 创建密匙

*

* @param algorithm

* 加密算法,可用 DES,DESede,Blowfish

* @return SecretKey 秘密（对称）密钥

*/

public SecretKey createSecretKey(String algorithm) {

// 声明KeyGenerator对象

KeyGenerator keygen;

// 声明 密钥对象

SecretKey deskey = null;

try {

// 返回生成指定算法的秘密密钥的 KeyGenerator 对象

keygen = KeyGenerator.getInstance(algorithm);

// 生成一个密钥

deskey = keygen.generateKey();

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

// 返回密匙

return deskey;

}

/**

* 根据密匙进行DES加密

*

* @param key

* 密匙

* @param info

* 要加密的信息

* @return String 加密后的信息

*/

public String encryptToDES(SecretKey key, String info) {

// 定义 加密算法,可用 DES,DESede,Blowfish

String Algorithm = "DES";

// 加密随机数生成器 (RNG),(可以不写)

SecureRandom sr = new SecureRandom();

// 定义要生成的密文

byte[] cipherByte = null;

try {

// 得到加密/解密器

Cipher c1 = Cipher.getInstance(Algorithm);

// 用指定的密钥和模式初始化Cipher对象

// 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)

c1.init(Cipher.ENCRYPT_MODE, key, sr);

// 对要加密的内容进行编码处理,

cipherByte = c1.doFinal(info.getBytes());

} catch (Exception e) {

e.printStackTrace();

}

// 返回密文的十六进制形式

return byte2hex(cipherByte);

}

/**

* 根据密匙进行DES解密

*

* @param key

* 密匙

* @param sInfo

* 要解密的密文

* @return String 返回解密后信息

*/

public String decryptByDES(SecretKey key, String sInfo) {

// 定义 加密算法,

String Algorithm = "DES";

// 加密随机数生成器 (RNG)

SecureRandom sr = new SecureRandom();

byte[] cipherByte = null;

try {

// 得到加密/解密器

Cipher c1 = Cipher.getInstance(Algorithm);

// 用指定的密钥和模式初始化Cipher对象

c1.init(Cipher.DECRYPT_MODE, key, sr);

// 对要解密的内容进行编码处理

cipherByte = c1.doFinal(hex2byte(sInfo));

} catch (Exception e) {

e.printStackTrace();

}

// return byte2hex(cipherByte);

return new String(cipherByte);

}

// /////////////////////////////////////////////////////////////////////////////

/**

* 创建密匙组，并将公匙，私匙放入到指定文件中

*

* 默认放入mykeys.bat文件中

*/

public void createPairKey() {

try {

// 根据特定的算法一个密钥对生成器

KeyPairGenerator keygen = KeyPairGenerator.getInstance("DSA");

// 加密随机数生成器 (RNG)

SecureRandom random = new SecureRandom();

// 重新设置此随机对象的种子

random.setSeed(1000);

// 使用给定的随机源（和默认的参数集合）初始化确定密钥大小的密钥对生成器

keygen.initialize(512, random);// keygen.initialize(512);

// 生成密钥组

KeyPair keys = keygen.generateKeyPair();

// 得到公匙

PublicKey pubkey = keys.getPublic();

// 得到私匙

PrivateKey prikey = keys.getPrivate();

// 将公匙私匙写入到文件当中

doObjToFile("mykeys.bat", new Object[] { prikey, pubkey });

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

}

/**

* 利用私匙对信息进行签名 把签名后的信息放入到指定的文件中

*

* @param info

* 要签名的信息

* @param signfile

* 存入的文件

*/

public void signToInfo(String info, String signfile) {

// 从文件当中读取私匙

PrivateKey myprikey = (PrivateKey) getObjFromFile("mykeys.bat", 1);

// 从文件中读取公匙

PublicKey mypubkey = (PublicKey) getObjFromFile("mykeys.bat", 2);

try {

// Signature 对象可用来生成和验证数字签名

Signature signet = Signature.getInstance("DSA");

// 初始化签署签名的私钥

signet.initSign(myprikey);

// 更新要由字节签名或验证的数据

signet.update(info.getBytes());

// 签署或验证所有更新字节的签名，返回签名

byte[] signed = signet.sign();

// 将数字签名,公匙,信息放入文件中

doObjToFile(signfile, new Object[] { signed, mypubkey, info });

} catch (Exception e) {

e.printStackTrace();

}

}

/**

* 读取数字签名文件 根据公匙，签名，信息验证信息的合法性

*

* @return true 验证成功 false 验证失败

*/

public boolean validateSign(String signfile) {

// 读取公匙

PublicKey mypubkey = (PublicKey) getObjFromFile(signfile, 2);

// 读取签名

byte[] signed = (byte[]) getObjFromFile(signfile, 1);

// 读取信息

String info = (String) getObjFromFile(signfile, 3);

try {

// 初始一个Signature对象,并用公钥和签名进行验证

Signature signetcheck = Signature.getInstance("DSA");

// 初始化验证签名的公钥

signetcheck.initVerify(mypubkey);

// 使用指定的 byte 数组更新要签名或验证的数据

signetcheck.update(info.getBytes());

System.out.println(info);

// 验证传入的签名

return signetcheck.verify(signed);

} catch (Exception e) {

e.printStackTrace();

return false;

}

}

/**

* 将二进制转化为16进制字符串

*

* @param b

* 二进制字节数组

* @return String

*/

public String byte2hex(byte[] b) {

String hs = "";

String stmp = "";

for (int n = 0; n b.length; n++) {

stmp = (java.lang.Integer.toHexString(b[n] 0XFF));

if (stmp.length() == 1) {

hs = hs + "0" + stmp;

} else {

hs = hs + stmp;

}

}

return hs.toUpperCase();

}

/**

* 十六进制字符串转化为2进制

*

* @param hex

* @return

*/

public byte[] hex2byte(String hex) {

byte[] ret = new byte[8];

byte[] tmp = hex.getBytes();

for (int i = 0; i 8; i++) {

ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);

}

return ret;

}

/**

* 将两个ASCII字符合成一个字节； 如："EF"-- 0xEF

*

* @param src0

* byte

* @param src1

* byte

* @return byte

*/

public static byte uniteBytes(byte src0, byte src1) {

byte _b0 = Byte.decode("0x" + new String(new byte[] { src0 }))

.byteValue();

_b0 = (byte) (_b0 4);

byte _b1 = Byte.decode("0x" + new String(new byte[] { src1 }))

.byteValue();

byte ret = (byte) (_b0 ^ _b1);

return ret;

}

/**

* 将指定的对象写入指定的文件

*

* @param file

* 指定写入的文件

* @param objs

* 要写入的对象

*/

public void doObjToFile(String file, Object[] objs) {

ObjectOutputStream oos = null;

try {

FileOutputStream fos = new FileOutputStream(file);

oos = new ObjectOutputStream(fos);

for (int i = 0; i objs.length; i++) {

oos.writeObject(objs[i]);

}

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

oos.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

/**

* 返回在文件中指定位置的对象

*

* @param file

* 指定的文件

* @param i

* 从1开始

* @return

*/

public Object getObjFromFile(String file, int i) {

ObjectInputStream ois = null;

Object obj = null;

try {

FileInputStream fis = new FileInputStream(file);

ois = new ObjectInputStream(fis);

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

obj = ois.readObject();

}

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

ois.close();

} catch (IOException e) {

e.printStackTrace();

}

}

return obj;

}

/**

* 测试

*

* @param args

*/

public static void main(String[] args) {

CryptTest jiami = new CryptTest();

// 执行MD5加密"Hello world!"

System.out.println("Hello经过MD5:" + jiami.encryptToMD5("Hello"));

// 生成一个DES算法的密匙

SecretKey key = jiami.createSecretKey("DES");

// 用密匙加密信息"Hello world!"

String str1 = jiami.encryptToDES(key, "Hello");

System.out.println("使用des加密信息Hello为:" + str1);

// 使用这个密匙解密

String str2 = jiami.decryptByDES(key, str1);

System.out.println("解密后为：" + str2);

// 创建公匙和私匙

jiami.createPairKey();

// 对Hello world!使用私匙进行签名

jiami.signToInfo("Hello", "mysign.bat");

// 利用公匙对签名进行验证。

if (jiami.validateSign("mysign.bat")) {

System.out.println("Success!");

} else {

System.out.println("Fail!");

}

}

}

求C语言编写的DES加密解密源代码

从别的地方抄来的

#include "stdio.h"

#include "time.h"

#include "stdlib.h"

#define PLAIN_FILE_OPEN_ERROR -1

#define KEY_FILE_OPEN_ERROR -2

#define CIPHER_FILE_OPEN_ERROR -3

#define OK 1;

typedef char ElemType;

/* 初始置换表IP */

int IP_Table[64] = { 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,

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

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

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

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

/* 逆初始置换表IP^-1 */

int IP_1_Table[64] = {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,

32,0,40,8,48,16,56,24};

/* 扩充置换表E */

int E_Table[48] = {31, 0, 1, 2, 3, 4,

3, 4, 5, 6, 7, 8,

7, 8,9,10,11,12,

11,12,13,14,15,16,

15,16,17,18,19,20,

19,20,21,22,23,24,

23,24,25,26,27,28,

27,28,29,30,31, 0};

/* 置换函数P */

int P_Table[32] = {15,6,19,20,28,11,27,16,

0,14,22,25,4,17,30,9,

1,7,23,13,31,26,2,8,

18,12,29,5,21,10,3,24};

/* S盒 */

int S[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}}};

/* 置换选择1 */

int PC_1[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};

/* 置换选择2 */

int PC_2[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,46,43,48,38,55,

33,52,45,41,49,35,28,31};

/* 对左移次数的规定 */

int MOVE_TIMES[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};

int ByteToBit(ElemType ch,ElemType bit[8]);

int BitToByte(ElemType bit[8],ElemType *ch);

int Char8ToBit64(ElemType ch[8],ElemType bit[64]);

int Bit64ToChar8(ElemType bit[64],ElemType ch[8]);

int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]);

int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]);

int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]);

int DES_ROL(ElemType data[56], int time);

int DES_IP_Transform(ElemType data[64]);

int DES_IP_1_Transform(ElemType data[64]);

int DES_E_Transform(ElemType data[48]);

int DES_P_Transform(ElemType data[32]);

int DES_SBOX(ElemType data[48]);

int DES_XOR(ElemType R[48], ElemType L[48],int count);

int DES_Swap(ElemType left[32],ElemType right[32]);

int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]);

int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48], ElemType plainBlock[8]);

int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile);

int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile);

/* 字节转换成二进制 */

int ByteToBit(ElemType ch, ElemType bit[8]){

int cnt;

for(cnt = 0;cnt 8; cnt++){

*(bit+cnt) = (chcnt)1;

}

return 0;

}

/* 二进制转换成字节 */

int BitToByte(ElemType bit[8],ElemType *ch){

int cnt;

for(cnt = 0;cnt 8; cnt++){

*ch |= *(bit + cnt)cnt;

}

return 0;

}

/* 将长度为8的字符串转为二进制位串 */

int Char8ToBit64(ElemType ch[8],ElemType bit[64]){

int cnt;

for(cnt = 0; cnt 8; cnt++){

ByteToBit(*(ch+cnt),bit+(cnt3));

}

return 0;

}

/* 将二进制位串转为长度为8的字符串 */

int Bit64ToChar8(ElemType bit[64],ElemType ch[8]){

int cnt;

memset(ch,0,8);

for(cnt = 0; cnt 8; cnt++){

BitToByte(bit+(cnt3),ch+cnt);

}

return 0;

}

/* 生成子密钥 */

int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]){

ElemType temp[56];

int cnt;

DES_PC1_Transform(key,temp);/* PC1置换 */

for(cnt = 0; cnt 16; cnt++){/* 16轮跌代，产生16个子密钥 */

DES_ROL(temp,MOVE_TIMES[cnt]);/* 循环左移 */

DES_PC2_Transform(temp,subKeys[cnt]);/* PC2置换，产生子密钥 */

}

return 0;

}

/* 密钥置换1 */

int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]){

int cnt;

for(cnt = 0; cnt 56; cnt++){

tempbts[cnt] = key[PC_1[cnt]];

}

return 0;

}

/* 密钥置换2 */

int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]){

int cnt;

for(cnt = 0; cnt 48; cnt++){

tempbts[cnt] = key[PC_2[cnt]];

}

return 0;

}

/* 循环左移 */

int DES_ROL(ElemType data[56], int time){

ElemType temp[56];

/* 保存将要循环移动到右边的位 */

memcpy(temp,data,time);

memcpy(temp+time,data+28,time);

/* 前28位移动 */

memcpy(data,data+time,28-time);

memcpy(data+28-time,temp,time);

/* 后28位移动 */

memcpy(data+28,data+28+time,28-time);

memcpy(data+56-time,temp+time,time);

return 0;

}

/* IP置换 */

int DES_IP_Transform(ElemType data[64]){

int cnt;

ElemType temp[64];

for(cnt = 0; cnt 64; cnt++){

temp[cnt] = data[IP_Table[cnt]];

}

memcpy(data,temp,64);

return 0;

}

/* IP逆置换 */

int DES_IP_1_Transform(ElemType data[64]){

int cnt;

ElemType temp[64];

for(cnt = 0; cnt 64; cnt++){

temp[cnt] = data[IP_1_Table[cnt]];

}

memcpy(data,temp,64);

return 0;

}

/* 扩展置换 */

int DES_E_Transform(ElemType data[48]){

int cnt;

ElemType temp[48];

for(cnt = 0; cnt 48; cnt++){

temp[cnt] = data[E_Table[cnt]];

}

memcpy(data,temp,48);

return 0;

}

/* P置换 */

int DES_P_Transform(ElemType data[32]){

int cnt;

ElemType temp[32];

for(cnt = 0; cnt 32; cnt++){

temp[cnt] = data[P_Table[cnt]];

}

memcpy(data,temp,32);

return 0;

}

/* 异或 */

int DES_XOR(ElemType R[48], ElemType L[48] ,int count){

int cnt;

for(cnt = 0; cnt count; cnt++){

R[cnt] ^= L[cnt];

}

return 0;

}

/* S盒置换 */

int DES_SBOX(ElemType data[48]){

int cnt;

int line,row,output;

int cur1,cur2;

for(cnt = 0; cnt 8; cnt++){

cur1 = cnt*6;

cur2 = cnt2;

/* 计算在S盒中的行与列 */

line = (data[cur1]1) + data[cur1+5];

row = (data[cur1+1]3) + (data[cur1+2]2)

+ (data[cur1+3]1) + data[cur1+4];

output = S[cnt][line][row];

/* 化为2进制 */

data[cur2] = (output0X08)3;

data[cur2+1] = (output0X04)2;

data[cur2+2] = (output0X02)1;

data[cur2+3] = output0x01;

}

return 0;

}

/* 交换 */

int DES_Swap(ElemType left[32], ElemType right[32]){

ElemType temp[32];

memcpy(temp,left,32);

memcpy(left,right,32);

memcpy(right,temp,32);

return 0;

}

/* 加密单个分组 */

int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]){

ElemType plainBits[64];

ElemType copyRight[48];

int cnt;

Char8ToBit64(plainBlock,plainBits);

/* 初始置换（IP置换） */

DES_IP_Transform(plainBits);

/* 16轮迭代 */

for(cnt = 0; cnt 16; cnt++){

memcpy(copyRight,plainBits+32,32);

/* 将右半部分进行扩展置换，从32位扩展到48位 */

DES_E_Transform(copyRight);

/* 将右半部分与子密钥进行异或操作 */

DES_XOR(copyRight,subKeys[cnt],48);

/* 异或结果进入S盒，输出32位结果 */

DES_SBOX(copyRight);

/* P置换 */

DES_P_Transform(copyRight);

/* 将明文左半部分与右半部分进行异或 */

DES_XOR(plainBits,copyRight,32);

if(cnt != 15){

/* 最终完成左右部的交换 */

DES_Swap(plainBits,plainBits+32);

}

}

/* 逆初始置换（IP^1置换） */

DES_IP_1_Transform(plainBits);

Bit64ToChar8(plainBits,cipherBlock);

return 0;

}

/* 解密单个分组 */

int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48],ElemType plainBlock[8]){

ElemType cipherBits[64];

ElemType copyRight[48];

int cnt;

Char8ToBit64(cipherBlock,cipherBits);

/* 初始置换（IP置换） */

DES_IP_Transform(cipherBits);

/* 16轮迭代 */

for(cnt = 15; cnt = 0; cnt--){

memcpy(copyRight,cipherBits+32,32);

/* 将右半部分进行扩展置换，从32位扩展到48位 */

DES_E_Transform(copyRight);

/* 将右半部分与子密钥进行异或操作 */

DES_XOR(copyRight,subKeys[cnt],48);

/* 异或结果进入S盒，输出32位结果 */

DES_SBOX(copyRight);

/* P置换 */

DES_P_Transform(copyRight);

/* 将明文左半部分与右半部分进行异或 */

DES_XOR(cipherBits,copyRight,32);

if(cnt != 0){

/* 最终完成左右部的交换 */

DES_Swap(cipherBits,cipherBits+32);

}

}

/* 逆初始置换（IP^1置换） */

DES_IP_1_Transform(cipherBits);

Bit64ToChar8(cipherBits,plainBlock);

return 0;

}

/* 加密文件 */

int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile){

FILE *plain,*cipher;

int count;

ElemType plainBlock[8],cipherBlock[8],keyBlock[8];

ElemType bKey[64];

ElemType subKeys[16][48];

if((plain = fopen(plainFile,"rb")) == NULL){

return PLAIN_FILE_OPEN_ERROR;

}

if((cipher = fopen(cipherFile,"wb")) == NULL){

return CIPHER_FILE_OPEN_ERROR;

}

/* 设置密钥 */

memcpy(keyBlock,keyStr,8);

/* 将密钥转换为二进制流 */

Char8ToBit64(keyBlock,bKey);

/* 生成子密钥 */

DES_MakeSubKeys(bKey,subKeys);

while(!feof(plain)){

/* 每次读8个字节，并返回成功读取的字节数 */

if((count = fread(plainBlock,sizeof(char),8,plain)) == 8){

DES_EncryptBlock(plainBlock,subKeys,cipherBlock);

fwrite(cipherBlock,sizeof(char),8,cipher);

}

}

if(count){

/* 填充 */

memset(plainBlock + count,'\0',7 - count);

/* 最后一个字符保存包括最后一个字符在内的所填充的字符数量 */

plainBlock[7] = 8 - count;

DES_EncryptBlock(plainBlock,subKeys,cipherBlock);

fwrite(cipherBlock,sizeof(char),8,cipher);

}

fclose(plain);

fclose(cipher);

return OK;

}

/* 解密文件 */

int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile){

FILE *plain, *cipher;

int count,times = 0;

long fileLen;

ElemType plainBlock[8],cipherBlock[8],keyBlock[8];

ElemType bKey[64];

ElemType subKeys[16][48];

if((cipher = fopen(cipherFile,"rb")) == NULL){

return CIPHER_FILE_OPEN_ERROR;

}

if((plain = fopen(plainFile,"wb")) == NULL){

return PLAIN_FILE_OPEN_ERROR;

}

/* 设置密钥 */

memcpy(keyBlock,keyStr,8);

/* 将密钥转换为二进制流 */

Char8ToBit64(keyBlock,bKey);

/* 生成子密钥 */

DES_MakeSubKeys(bKey,subKeys);

/* 取文件长度 */

fseek(cipher,0,SEEK_END); /* 将文件指针置尾 */

fileLen = ftell(cipher); /* 取文件指针当前位置 */

rewind(cipher); /* 将文件指针重指向文件头 */

while(1){

/* 密文的字节数一定是8的整数倍 */

fread(cipherBlock,sizeof(char),8,cipher);

DES_DecryptBlock(cipherBlock,subKeys,plainBlock);

times += 8;

if(times fileLen){

fwrite(plainBlock,sizeof(char),8,plain);

}

else{

break;

}

}

/* 判断末尾是否被填充 */

if(plainBlock[7] 8){

for(count = 8 - plainBlock[7]; count 7; count++){

if(plainBlock[count] != '\0'){

break;

}

}

}

if(count == 7){/* 有填充 */

fwrite(plainBlock,sizeof(char),8 - plainBlock[7],plain);

}

else{/* 无填充 */

fwrite(plainBlock,sizeof(char),8,plain);

}

fclose(plain);

fclose(cipher);

return OK;

}

int main()

{ DES_Encrypt("1.txt","key.txt","2.txt");

system("pause");

DES_Decrypt("2.txt","key.txt","3.txt");

getchar();

return 0;

}

用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;

}

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