CBC模式的DES加密算法(加密字符串、加密文件)

最新推荐文章于 2024-08-26 07:39:49 发布

斷點1

最新推荐文章于 2024-08-26 07:39:49 发布

阅读量8.9k

点赞数 1

分类专栏：加解密代码

本文链接：https://blog.csdn.net/a_tu_/article/details/77119532

版权

加解密代码专栏收录该内容

0 篇文章 0 订阅

订阅专栏

a) 所有协议数据采用标准的CBC模式的DES加密算法；

b) 密钥长度为8位，可以为空（为空时，默认是8个0）

c) 所有协议数据采用8位初始向量（VI）做互斥运算

d) 所有协议数据的明文需要在尾部加上原始数据长度（int大端字节数4字节），再加上“ABCD”4个字母，然后按64位进行分组，不足64位的以“\0”补足，分组后的明文采用统一的加密方式生成密文，即采用 “明文+密钥+初始化向量（VI）”

1、加密文件：

*/*******************************************************************/

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <unistd.h>

#include <openssl/des.h>

#define READ_BLOCK_SIZE 65536
#define MIN(a,b) ((a) > (b) ? (b) : (a))

static int crypt_block(FILE * fp, const uint8_t * buf, int buf_size,
DES_key_schedule * key_sch, DES_cblock * ivec, int enc)
{
int i;
uint8_t tmp[8];

assert(buf_size % 8 == 0);

for (i = 0; i < buf_size / 8; i++)
{
DES_ncbc_encrypt(buf + i * 8, tmp, 8, key_sch, ivec, enc);
fwrite(tmp, 8, 1, fp);
}
return 0;
}

static int fread_while(uint8_t * buff, int buff_len, FILE * fp)
{
int count = 0;
int real_len = 0;

while (!feof(fp))
{
real_len = fread(buff + count, 1, buff_len - count, fp);
if (real_len < 0)
{
return -1;
}

count += real_len;

if (count >= buff_len)
{
break;
}
}

return count;
}

static bool is_zero(const uint8_t * buff, int buff_len)
{
int i;

for (i = 0; i < buff_len; i++)
{
if (buff[i] != 0)
{
return false;
}
}

return true;
}

static int file_decrypt(FILE * src_fp, FILE * dst_fp, uint32_t src_file_len,
DES_key_schedule * key_sch, DES_cblock * ivec)
{
int i = 0;
uint8_t buff[READ_BLOCK_SIZE];
int real_len = 0;
int read_len = 0;
int count = 0;
int body_len = src_file_len - 16; // 保留最后两个分组

if (src_file_len % 8 != 0)
{
printf
("source file is not 3011 CBC DES file; [src_file_len mod 8 !=0] \n");
return -1;
}

/* 1. 保留最后两个分组，其它所有的分组都在这里解密，并写到文件中 */
for (i = 0; body_len > 0 && i * sizeof(buff) < body_len && !feof(src_fp);
i++)
{
memset(buff, 0, sizeof(buff));

if (body_len >= (i + 1) * sizeof(buff))
{
read_len = sizeof(buff);
}
else
{
read_len = body_len % sizeof(buff);
}

real_len = fread_while(buff, read_len, src_fp);
if (real_len <= 0)
{
printf("read file 1[Fail]\n");
return -1;
}
count += real_len;

/* 读取一整块，可以直接进行加密了 */
if (real_len == sizeof(buff))
{
crypt_block(dst_fp, buff, real_len, key_sch, ivec, DES_DECRYPT);
continue;
}

/* 到达这里，表示文件一定是结束了 */
if (read_len != read_len)
{
printf("read file 2 [Fail]\n");
return -1;
}

crypt_block(dst_fp, buff, real_len, key_sch, ivec, DES_DECRYPT);
break;
}

/* 2. 因为在加密过程中，是如下处理 :
将最后一个不足64位的分组，加上原始数据长度（int大端字节数4字节），再加上
“ABCD”4个字母，然后按64位进行分组，不足64位的以“\0”补足;
所以在这里必须进行相反的操作。即在解密后，去掉最后的0，并且去掉ABCD和
文件大小; */
uint8_t tmp[16];
int tmp_len = 0;
uint32_t file_len = 0;
uint8_t post_fix[] = { 'A', 'B', 'C', 'D' };

// 明文文件为空时，这里src_file_len 为 8；
tmp_len = MIN(src_file_len, 16);

// 读取最后分组，并解密
real_len = fread_while(buff, tmp_len, src_fp);
if (real_len != tmp_len)
{
printf("read file 3 [Fail]\n");
return -1;
}
DES_ncbc_encrypt(buff, tmp, 8, key_sch, ivec, DES_DECRYPT);
if (tmp_len == 16)
{
DES_ncbc_encrypt(buff + 8, tmp + 8, 8, key_sch, ivec, DES_DECRYPT);
}

// find 'ABCD'
uint8_t *pos_abcd = memmem(tmp, tmp_len, post_fix, sizeof(post_fix));
printf("tmp====%s\n",tmp);
if (pos_abcd == NULL)
{
printf("source file is not 3011 CBC DES file; [pos_abcd == NULL] \n");
return -1;
}

// 确认ABCD后面都是为0
if (!is_zero
(pos_abcd + sizeof(post_fix),
tmp_len - (pos_abcd - tmp) - sizeof(post_fix)))
{
printf("source file is not 3011 CBC DES file; [!is_zero()] \n");
return -1;
}

// 至少在ABCD前有4个字节，并且确认这里的文件大小与原来的文件大小一样
if ((pos_abcd - tmp) < 4)
{
printf
("source file is not 3011 CBC DES file; [file size filed is not exist] \n");
return -1;
}

// 最后一个分组去掉最后的0，并且去掉ABCD和文件大小后，写入文件中
memcpy(&file_len, pos_abcd - 4, 4);
file_len = ntohl(file_len);
count += pos_abcd - 4 - tmp;
if (count != file_len)
{
printf
("source file is not 3011 CBC DES file; [src_file_len != file_len] \n");
return -1;
}

fwrite(tmp, pos_abcd - 4 - tmp, 1, dst_fp);
return 0;
}

static int file_encrypt(FILE * src_fp, FILE * dst_fp, uint32_t src_file_len,
DES_key_schedule * key_sch, DES_cblock * ivec)
{
int i = 0;
uint8_t buff[READ_BLOCK_SIZE];
int real_len = 0;
int remain_len = 0;
int read_len = 0;

/* 1.如果最后一个不足64位的分组，那么除了这个分组外，其它所有的分组都在这里加密 */
for (i = 0; i * sizeof(buff) < src_file_len && !feof(src_fp); i++)
{
remain_len = 0;
memset(buff, 0, sizeof(buff));

if (src_file_len >= (i + 1) * sizeof(buff))
{
read_len = sizeof(buff);
}
else
{
read_len = src_file_len % sizeof(buff);
}

real_len = fread_while(buff, read_len, src_fp);
if (real_len <= 0)
{
printf("read file 1[Fail]\n");
return -1;
}

/* 读取一整块，可以直接进行加密了 */
if (real_len == sizeof(buff))
{
crypt_block(dst_fp, buff, real_len, key_sch, ivec, DES_ENCRYPT);
continue;
}

/* 到达这里，表示文件一定是结束了 */
if (read_len != read_len)
{
printf("read file 2 [Fail]\n");
return -1;
}

/* 这里的分组有可能不被整除，所以需要计算最后一个分组的大小remain_len */
remain_len = real_len % 8;
crypt_block(dst_fp, buff, real_len - remain_len, key_sch, ivec,
DES_ENCRYPT);
break;
}

/* 2. 将最后一个不足64位的分组，加上原始数据长度（int大端字节数4字节），再加上
“ABCD”4个字母，然后按64位进行分组，不足64位的以“\0”补足;

如果文件的大小刚好被8整除，那么tmp_len 的长度就为8，否则为16 */
uint8_t tmp[16];
int tmp_len = 0;
uint32_t file_len = htonl(src_file_len);
uint8_t post_fix[] = { 'A', 'B', 'C', 'D' };

memset(tmp, 0, sizeof(tmp));
memcpy(tmp, buff + real_len - remain_len, remain_len);
tmp_len = remain_len;
memcpy(tmp + tmp_len, &file_len, sizeof(file_len));
tmp_len += sizeof(file_len);
memcpy(tmp + tmp_len, &post_fix, sizeof(post_fix));
tmp_len += sizeof(post_fix);

tmp_len = tmp_len == 8 ? 8 : 16;

for(i=0;i<tmp_len;i++)
{
printf("tmp[%d]=%02x\n",i,tmp[i]);

}
crypt_block(dst_fp, tmp, tmp_len, key_sch, ivec, DES_ENCRYPT);

return 0;
}

/*
*函数功能：完成基于3011规范的CBC 加密；即所有协议数据的明文需要在尾部加上原始数
据长度（int大端字节数4字节），再加上“ABCD”4个字母，然后按64位进行
分组，不足64位的以“\0”补足，分组后的明文采用统一的加密方式生成密文，
即采用 “明文+密钥+初始化向量（VI）”

*参数：
src_fi;e : 输入文件名
dst_file : 输出文件名
key : 密码
key_len : 密码的长度
iv: 初始向量
iv_len ：初始向量的长度

enc ：是执行加密还是解密操作，加密：DES_ENCRYPT ，解密：DES_DECRYPT

*返回值：
0 ：成功
<0 : 失败

*其它说明：
*/
static int dec_cbc_crypt_file(const char *src_file, const char *dst_file,
const uint8_t * key, int key_len,
const uint8_t * iv, int iv_len, int enc)
{
int ret = 0;
FILE *src_fp;
FILE *dst_fp;
DES_cblock ivec;
DES_key_schedule key_sch;
struct stat stat_buf;

if ((key == NULL) || key_len <= 0 || key_len % 8 != 0)
{
printf(" key is error \n");
return -1;
}

if ((iv == NULL) || iv_len <= 0 || iv_len % 8 != 0)
{
printf(" initial verctor is error \n");
return -1;
}

memcpy(ivec, iv, sizeof(ivec));
DES_set_key_unchecked((const_DES_cblock *) key, &key_sch);

src_fp = fopen(src_file, "r");
if (src_fp == NULL)
{
printf(" %s file do not open\n", src_file);
return -1;
}

dst_fp = fopen(dst_file, "w");
if (src_fp == NULL)
{
fclose(src_fp);
printf(" %s file do not write\n", dst_file);
return -1;
}

if (stat(src_file, &stat_buf) != 0)
{
printf("check file(%s) fail\n", src_file);
fclose(src_fp);
fclose(dst_fp);
return -1;
}

if (enc == DES_DECRYPT)
{
ret = file_decrypt(src_fp, dst_fp, stat_buf.st_size, &key_sch, &ivec);
}
else
{
ret = file_encrypt(src_fp, dst_fp, stat_buf.st_size, &key_sch, &ivec);
}

fclose(src_fp);
fclose(dst_fp);
return ret;
}

/*
*函数功能：完成基于3011规范的CBC 加密；即所有协议数据的明文需要在尾部加上原始数
据长度（int大端字节数4字节），再加上“ABCD”4个字母，然后按64位进行
分组，不足64位的以“\0”补足，分组后的明文采用统一的加密方式生成密文，
即采用 “明文+密钥+初始化向量（VI）”

*参数：
src_fi;e : 输入文件名
dst_file : 输出文件名
str_key : 密码，一个以0结束的字符串
enc ：是执行加密还是解密操作，加密：DES_ENCRYPT ，解密：DES_DECRYPT

*返回值：
0 ：成功
<0 : 失败

*其它说明：这里的初始向量是固定的
*/
static int des_cbc_crypt(const char *src_file, const char *dst_file,
const char *str_key, int enc)
{
uint8_t key[8];
int min_len = MIN(sizeof(key), strlen(str_key));

/* 设置秘钥，如果密码不足8个字节，补充0 */
memset(key, 0, sizeof(key));
memcpy(key, str_key, min_len);

/* 固定初始向量 */
uint8_t iv[] = { 'q', 'a', 'z', 'w', 's', 'x', 'e', 'd' };
//memset(iv, 0x30, sizeof(iv));

/* 加密 */
return dec_cbc_crypt_file(src_file, dst_file, key, sizeof(key), iv,
sizeof(iv), enc);
}

static void print_usage(int argc, char *argv[])
{
printf("Usage: %s -[d/e] <src_file> <dst_file> <key> \n", argv[0]);
printf("-d : decrypt file\n");
printf("-e : encrypt file\n\n");
printf("Example: \n");
printf("Decrypt file: %s -d <src_file> <dst_file> <key> \n", argv[0]);
printf("Encrypt file: %s -e <src_file> <dst_file> <key> \n", argv[0]);

}

int main(int argc, char *argv[])
{
int i;
char read_buf[64]={0};
if (argc < 4)
{
print_usage(argc, argv);
return -1;
}

if (strcmp(argv[1], "-e") == 0)
{
des_cbc_crypt(argv[2], argv[3], argv[4], DES_ENCRYPT);
}
else if (strcmp(argv[1], "-d") == 0)
{
return des_cbc_crypt(argv[2], argv[3], argv[4], DES_DECRYPT);
}
else
{
print_usage(argc, argv);
return -1;
}

}

2、加密字符串

/*********************************************************************/

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <unistd.h>

#include <openssl/des.h>
#include "des.h"

#define READ_BLOCK_SIZE 65536
#define MIN(a,b) ((a) > (b) ? (b) : (a))

int dst_str_len=0;
static int crypt_block(char * dst_str, const uint8_t * buf, int buf_size,
DES_key_schedule * key_sch, DES_cblock * ivec, int enc)
{
int i;
uint8_t tmp[8];

assert(buf_size % 8 == 0);

for (i = 0; i < buf_size / 8; i++)
{
DES_ncbc_encrypt(buf + i * 8, tmp, 8, key_sch, ivec, enc);
// if(enc==DES_DECRYPT)
// {
// printf("strlen(dst_str)=%d dst_str_len=%d\n",strlen(dst_str),dst_str_len );
// for (j = 0; j < 8 ;j++)
// {
// printf("[[[[[[[[[src_str[%d]=%02x \n", j,tmp[j]);
// }

// }
memcpy(dst_str+dst_str_len,tmp,8);

dst_str_len+=8;
// for (j = 0; j < dst_str_len ;j++)
// {
// printf("[[[[[[[[[dst_str[%d]=%02x \n", j,dst_str[j]);
// }
// else
// {
// memcpy(dst_str+strlen(dst_str),tmp,8);
// }

//printf("strlen(dst_str)=%d\n",strlen(dst_str));
}
return 0;
}
/*
static int fread_while(uint8_t * buff, int buff_len, FILE * fp)
{
int count = 0;
int real_len = 0;

while (!feof(fp))
{
real_len = fread(buff + count, 1, buff_len - count, fp);
if (real_len < 0)
{
return -1;
}

count += real_len;

if (count >= buff_len)
{
break;
}
}

return count;
}
*/

static bool is_zero(const uint8_t * buff, int buff_len)
{
int i;

for (i = 0; i < buff_len; i++)
{
if (buff[i] != 0)
{
return false;
}
}

return true;
}

static int file_decrypt(char * src_str, char * dst_str,uint32_t src_file_len , DES_key_schedule * key_sch, DES_cblock * ivec)
{
int i = 0;
uint8_t buff[READ_BLOCK_SIZE];
int real_len = 0;
int read_len = 0;
int count = 0;
int body_len = src_file_len - 16; // 保留最后两个分组



/* 1. 保留最后两个分组，其它所有的分组都在这里解密，并写到文件中 */
for (i = 0; body_len > 0 && i * sizeof(buff) < body_len;i++)
{
memset(buff, 0, sizeof(buff));

if (body_len >= (i + 1) * sizeof(buff))
{
read_len = sizeof(buff);
}
else
{
read_len = body_len % sizeof(buff);
}

real_len =read_len;
memcpy(buff,src_str+i*read_len,read_len);
if (real_len <= 0)
{
printf("read file 1[Fail]\n");
return -1;
}
count += real_len;

/* 读取一整块，可以直接进行加密了 */
if (real_len == sizeof(buff))
{
crypt_block(dst_str, buff, real_len, key_sch, ivec, DES_DECRYPT);
continue;
}

/* 到达这里，表示文件一定是结束了 */
if (read_len != read_len)
{
printf("read file 2 [Fail]\n");
return -1;
}

crypt_block(dst_str, buff, real_len, key_sch, ivec, DES_DECRYPT);

break;
}

/* 2. 因为在加密过程中，是如下处理 :
将最后一个不足64位的分组，加上原始数据长度（int大端字节数4字节），再加上
“ABCD”4个字母，然后按64位进行分组，不足64位的以“\0”补足;
所以在这里必须进行相反的操作。即在解密后，去掉最后的0，并且去掉ABCD和
文件大小; */
uint8_t tmp[16];
int tmp_len = 0;
uint32_t file_len = 0;
uint8_t post_fix[] = { 'A', 'B', 'C', 'D' };

// 明文文件为空时，这里src_file_len 为 8；
tmp_len = MIN(src_file_len, 16);

// 读取最后分组，并解密
//real_len = fread_while(buff, tmp_len, src_fp);
//real_len=src_file_len-i*read_len;
memcpy(buff,src_str+count,tmp_len);
// if (real_len != tmp_len)
// {
// printf("read file 3 [Fail]\n");
// return -1;
// }
DES_ncbc_encrypt(buff, tmp, 8, key_sch, ivec, DES_DECRYPT);
if (tmp_len == 16)
{
DES_ncbc_encrypt(buff + 8, tmp + 8, 8, key_sch, ivec, DES_DECRYPT);
}

// find 'ABCD'
uint8_t *pos_abcd = memmem(tmp, tmp_len, post_fix, sizeof(post_fix));

if (pos_abcd == NULL)
{
printf("tmp=%s post_fix=%c\n",tmp,post_fix[0] );
printf("source file is not 3011 CBC DES file; [pos_abcd == NULL] \n");
return -1;
}

// 确认ABCD后面都是为0
if (!is_zero
(pos_abcd + sizeof(post_fix),
tmp_len - (pos_abcd - tmp) - sizeof(post_fix)))
{
printf("source file is not 3011 CBC DES file; [!is_zero()] \n");
return -1;
}

// 至少在ABCD前有4个字节，并且确认这里的文件大小与原来的文件大小一样
if ((pos_abcd - tmp) < 4)
{
printf
("source file is not 3011 CBC DES file; [file size filed is not exist] \n");
return -1;
}

// 最后一个分组去掉最后的0，并且去掉ABCD和文件大小后，写入文件中
memcpy(&file_len, pos_abcd - 4, 4);

file_len = ntohl(file_len);
printf("count=%d file_len=%d \n",count,file_len );

count += pos_abcd - 4 - tmp;
if (count != file_len)
{
printf("count=%d file_len=%d \n",count,file_len );
printf
("source file is not 3011 CBC DES file; [src_file_len != file_len] \n");
return -1;
}
memcpy(dst_str+dst_str_len,tmp,pos_abcd - 4 - tmp);
//fwrite(tmp, pos_abcd - 4 - tmp, 1, dst_fp);
return 0;
}

static int file_encrypt(char * src_str, char * dst_str,uint32_t src_file_len, DES_key_schedule * key_sch, DES_cblock * ivec)
{
int i = 0;
uint8_t buff[READ_BLOCK_SIZE];
int real_len = 0;
int remain_len = 0;
int read_len = 0;

/* 1.如果最后一个不足64位的分组，那么除了这个分组外，其它所有的分组都在这里加密 */
for (i = 0; i * sizeof(buff) < src_file_len ;i++)
{
remain_len = 0;
memset(buff, 0, sizeof(buff));

if (src_file_len >= (i + 1) * sizeof(buff))
{
read_len = sizeof(buff);
}
else
{
read_len = src_file_len % sizeof(buff);
}

real_len =read_len;
memcpy(buff,src_str+i*read_len,read_len);

if (real_len <= 0)
{
printf("read file 1[Fail]\n");
return -1;
}

/* 读取一整块，可以直接进行加密了 */
if (real_len == sizeof(buff))
{
crypt_block(dst_str, buff, real_len, key_sch, ivec, DES_ENCRYPT);
continue;
}

/* 到达这里，表示文件一定是结束了 */
if (read_len != read_len)
{
printf("read file 2 [Fail]\n");
return -1;
}

/* 这里的分组有可能不被整除，所以需要计算最后一个分组的大小remain_len */
remain_len = real_len % 8;
crypt_block(dst_str, buff, real_len - remain_len, key_sch, ivec,
DES_ENCRYPT);
break;
}


/* 2. 将最后一个不足64位的分组，加上原始数据长度（int大端字节数4字节），再加上
“ABCD”4个字母，然后按64位进行分组，不足64位的以“\0”补足;

如果文件的大小刚好被8整除，那么tmp_len 的长度就为8，否则为16 */
uint8_t tmp[16];
int tmp_len = 0;
uint32_t file_len = htonl(src_file_len);
uint8_t post_fix[] = { 'A', 'B', 'C', 'D' };

memset(tmp, 0, sizeof(tmp));
memcpy(tmp, buff + real_len - remain_len, remain_len);
tmp_len = remain_len;
memcpy(tmp + tmp_len, &file_len, sizeof(file_len));
tmp_len += sizeof(file_len);
memcpy(tmp + tmp_len, &post_fix, sizeof(post_fix));
tmp_len += sizeof(post_fix);

tmp_len = tmp_len == 8 ? 8 : 16;
for(i=0;i<tmp_len;i++)
{
//printf("3333333333[%d]=%02x\n", i,tmp[i]);
}
crypt_block(dst_str, tmp, tmp_len, key_sch, ivec, DES_ENCRYPT);

return 0;
}

/*
*函数功能：完成基于3011规范的CBC 加密；即所有协议数据的明文需要在尾部加上原始数
据长度（int大端字节数4字节），再加上“ABCD”4个字母，然后按64位进行
分组，不足64位的以“\0”补足，分组后的明文采用统一的加密方式生成密文，
即采用 “明文+密钥+初始化向量（VI）”

*参数：
src_fi;e : 输入文件名
dst_file : 输出文件名
key : 密码
key_len : 密码的长度
iv: 初始向量
iv_len ：初始向量的长度

enc ：是执行加密还是解密操作，加密：DES_ENCRYPT ，解密：DES_DECRYPT

*返回值：
0 ：成功
<0 : 失败

*其它说明：
*/
static int dec_cbc_crypt_file(char *src_str, char *dst_str,uint32_t src_file_len ,const uint8_t * key, int key_len,
const uint8_t * iv, int iv_len, int enc)
{
int ret = 0;
//FILE *src_fp;
//FILE *dst_fp;
DES_cblock ivec;
DES_key_schedule key_sch;
//struct stat stat_buf;
//printf("key_len========%d iv_len=%d\n", key_len,iv_len);
if ((key == NULL) || key_len <= 0 || key_len % 8 != 0)
{
printf(" key is error \n");
return -1;
}

if ((iv == NULL) || iv_len <= 0 || iv_len % 8 != 0)
{
printf(" initial verctor is error \n");
return -1;
}

memcpy(ivec, iv, sizeof(ivec));
DES_set_key_unchecked((const_DES_cblock *) key, &key_sch);

if (enc == DES_DECRYPT)
{
ret = file_decrypt(src_str, dst_str,src_file_len, &key_sch, &ivec);
}
else
{
ret = file_encrypt(src_str, dst_str,src_file_len,&key_sch, &ivec);
}

//fclose(src_fp);
//fclose(dst_fp);
return ret;
}

/*
*函数功能：完成基于3011规范的CBC 加密；即所有协议数据的明文需要在尾部加上原始数
据长度（int大端字节数4字节），再加上“ABCD”4个字母，然后按64位进行
分组，不足64位的以“\0”补足，分组后的明文采用统一的加密方式生成密文，
即采用 “明文+密钥+初始化向量（VI）”

*参数：
src_fi;e : 输入文件名
dst_file : 输出文件名
str_key : 密码，一个以0结束的字符串
enc ：是执行加密还是解密操作，加密：DES_ENCRYPT ，解密：DES_DECRYPT

*返回值：
0 ：成功
<0 : 失败

*其它说明：这里的初始向量是固定的
*/
static int des_cbc_crypt(char *src_str, char *dst_str,uint32_t src_file_len, const char *str_key, char *init_vector,int enc)
{
uint8_t key[8];
int min_len = MIN(sizeof(key), strlen(str_key));

/* 设置秘钥，如果密码不足8个字节，补充0 */
memset(key, 0, sizeof(key));
memcpy(key, str_key, min_len);

/* 固定初始向量 */
uint8_t iv[8] = {0};
memcpy(iv,init_vector,sizeof(iv));
//memset(iv, 0x30, sizeof(iv));

/* 加密 */
return dec_cbc_crypt_file(src_str, dst_str,src_file_len,key, sizeof(key), iv,
sizeof(iv), enc);
}

/*

static void print_usage(int argc, char *argv[])
{
printf("Usage: %s -[d/e] <src_file> <dst_file> <key> \n", argv[0]);
printf("-d : decrypt file\n");
printf("-e : encrypt file\n\n");
printf("Example: \n");
printf("Decrypt file: %s -d <src_file> <dst_file> <key> \n", argv[0]);
printf("Encrypt file: %s -e <src_file> <dst_file> <key> \n", argv[0]);

}
*/

void des_encryption(char *src_str,char *dst_str,uint32_t src_file_len,char *key,char *init_vector)
{
dst_str_len=0;
des_cbc_crypt(src_str, dst_str,src_file_len, key,init_vector, DES_ENCRYPT);
}

void des_decryption(char *src_str,char *dst_str,uint32_t src_file_len,char *key,char *init_vector)
{
dst_str_len=0;
des_cbc_crypt(src_str, dst_str, src_file_len,key,init_vector, DES_DECRYPT);
}

#if 0
int main(int argc, char *argv[])
{
char src_str[]="1234567891234554321";
char dst_str[1024]={0};
char src_str2[1024]={0};
char *key="";
int i;

des_encryption(src_str,dst_str,strlen(src_str),key);

for(i=0;i<strlen(dst_str);i++)
{
printf("dst_str[%d]=%02x\n", i,dst_str[i]);
}
printf("strlen(dst_str)=========%d\n",strlen(dst_str) );
des_decryption(dst_str,src_str2,strlen(dst_str),key);
//printf("src_str====%s dst_str======%s\n", src_str,dst_str);
for(i=0;i<strlen(src_str2);i++)
{
printf("src_str[%d]=%02x\n", i,src_str2[i]);
}
}
#endif