DES加密算法的C语言实现

最新推荐文章于 2024-04-20 20:18:23 发布
最新推荐文章于 2024-04-20 20:18:23 发布
阅读量1.7k 收藏 1
点赞数
分类专栏： Program language 文章标签： 加密 算法 语言 c encryption include

#include <stdio.h>

/* DES VERSION 0.4 CREATED BY SIMPLE SOURCE AT 2007.3 */

/* COMPETENCE :

 * P4 3.0G 512M

 * 3000000 TIMES ENCRYPTION WITH CREATED SUBKEYS

 * 26.784 SECONDS (ABOUT 0.85M/S)*/

static __int64 g_arrayMask[64] =
{
    0x0000000000000001, 0x0000000000000002, 0x0000000000000004, 0x0000000000000008,
    0x0000000000000010, 0x0000000000000020, 0x0000000000000040, 0x0000000000000080,
    0x0000000000000100, 0x0000000000000200, 0x0000000000000400, 0x0000000000000800,
    0x0000000000001000, 0x0000000000002000, 0x0000000000004000, 0x0000000000008000,
    0x0000000000010000, 0x0000000000020000, 0x0000000000040000, 0x0000000000080000,
    0x0000000000100000, 0x0000000000200000, 0x0000000000400000, 0x0000000000800000,
    0x0000000001000000, 0x0000000002000000, 0x0000000004000000, 0x0000000008000000,
    0x0000000010000000, 0x0000000020000000, 0x0000000040000000, 0x0000000080000000,
    0x0000000100000000, 0x0000000200000000, 0x0000000400000000, 0x0000000800000000,
    0x0000001000000000, 0x0000002000000000, 0x0000004000000000, 0x0000008000000000,
    0x0000010000000000, 0x0000020000000000, 0x0000040000000000, 0x0000080000000000,
    0x0000100000000000, 0x0000200000000000, 0x0000400000000000, 0x0000800000000000,
    0x0001000000000000, 0x0002000000000000, 0x0004000000000000, 0x0008000000000000,
    0x0010000000000000, 0x0020000000000000, 0x0040000000000000, 0x0080000000000000,
    0x0100000000000000, 0x0200000000000000, 0x0400000000000000, 0x0800000000000000,
    0x1000000000000000, 0x2000000000000000, 0x4000000000000000, 0x8000000000000000
};

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

static int g_arrayE[64] =
{
    31,  0,  1,  2,  3,  4, -1, -1,
     3,  4,  5,  6,  7,  8, -1, -1,
     7,  8,  9, 10, 11, 12, -1, -1,
    11, 12, 13, 14, 15, 16, -1, -1,
    15, 16, 17, 18, 19, 20, -1, -1,
    19, 20, 21, 22, 23, 24, -1, -1,
    23, 24, 25, 26, 27, 28, -1, -1,
    27, 28, 29, 30, 31, 30, -1, -1
};
static char g_matrixNSBox[8][64] =
{
    {
        14,  4,  3, 15,  2, 13,  5,  3,
        13, 14,  6,  9, 11,  2,  0,  5,
         4,  1, 10, 12, 15,  6,  9, 10,
         1,  8, 12,  7,  8, 11,  7,  0,
         0, 15, 10,  5, 14,  4,  9, 10,
         7,  8, 12,  3, 13,  1,  3,  6,
        15, 12,  6, 11,  2,  9,  5,  0,
         4,  2, 11, 14,  1,  7,  8, 13
    },
    {
        15,  0,  9,  5,  6, 10, 12,  9,
         8,  7,  2, 12,  3, 13,  5,  2,
         1, 14,  7,  8, 11,  4,  0,  3,
        14, 11, 13,  6,  4,  1, 10, 15,
         3, 13, 12, 11, 15,  3,  6,  0,
         4, 10,  1,  7,  8,  4, 11, 14,
        13,  8,  0,  6,  2, 15,  9,  5,
         7,  1, 10, 12, 14,  2,  5,  9
    },
    {
        10, 13,  1, 11,  6,  8, 11,  5,
         9,  4, 12,  2, 15,  3,  2, 14,
         0,  6, 13,  1,  3, 15,  4, 10,
        14,  9,  7, 12,  5,  0,  8,  7,
        13,  1,  2,  4,  3,  6, 12, 11,
         0, 13,  5, 14,  6,  8, 15,  2,
         7, 10,  8, 15,  4,  9, 11,  5,
         9,  0, 14,  3, 10,  7,  1, 12
    },
    {
         7, 10,  1, 15,  0, 12, 11,  5,
        14,  9,  8,  3,  9,  7,  4,  8,
        13,  6,  2,  1,  6, 11, 12,  2,
         3,  0,  5, 14, 10, 13, 15,  4,
        13,  3,  4,  9,  6, 10,  1, 12,
        11,  0,  2,  5,  0, 13, 14,  2,
         8, 15,  7,  4, 15,  1, 10,  7,
         5,  6, 12, 11,  3,  8,  9, 14
    },
    {
         2,  4,  8, 15,  7, 10, 13,  6,
         4,  1,  3, 12, 11,  7, 14,  0,
        12,  2,  5,  9, 10, 13,  0,  3,
         1, 11, 15,  5,  6,  8,  9, 14,
        14, 11,  5,  6,  4,  1,  3, 10,
         2, 12, 15,  0, 13,  2,  8,  5,
        11,  8,  0, 15,  7, 14,  9,  4,
        12,  7, 10,  9,  1, 13,  6,  3
    },
    {
        12,  9,  0,  7,  9,  2, 14,  1,
        10, 15,  3,  4,  6, 12,  5, 11,
         1, 14, 13,  0,  2,  8,  7, 13,
        15,  5,  4, 10,  8,  3, 11,  6,
        10,  4,  6, 11,  7,  9,  0,  6,
         4,  2, 13,  1,  9, 15,  3,  8,
        15,  3,  1, 14, 12,  5, 11,  0,
         2, 12, 14,  7,  5, 10,  8, 13
    },
    {
         4,  1,  3, 10, 15, 12,  5,  0,
         2, 11,  9,  6,  8,  7,  6,  9,
        11,  4, 12, 15,  0,  3, 10,  5,
        14, 13,  7,  8, 13, 14,  1,  2,
        13,  6, 14,  9,  4,  1,  2, 14,
        11, 13,  5,  0,  1, 10,  8,  3,
         0, 11,  3,  5,  9,  4, 15,  2,
         7,  8, 12, 15, 10,  7,  6, 12
    },
    {
        13,  7, 10,  0,  6,  9,  5, 15,
         8,  4,  3, 10, 11, 14, 12,  5,
         2, 11,  9,  6, 15, 12,  0,  3,
         4,  1, 14, 13,  1,  2,  7,  8,
         1,  2, 12, 15, 10,  4,  0,  3,
        13, 14,  6,  9,  7,  8,  9,  6,
        15,  1,  5, 12,  3, 10, 14,  5,
         8,  7, 11,  0,  4, 13,  2, 11
    },
};

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

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

static int g_arrayPC_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
};

static int g_arrayPC_2[64] =
{
    13, 16, 10, 23,  0,  4, -1, -1,
     2, 27, 14,  5, 20,  9, -1, -1,
    22, 18, 11,  3, 25,  7, -1, -1,
    15,  6, 26, 19, 12,  1, -1, -1,
    40, 51, 30, 36, 46, 54, -1, -1,
    29, 39, 50, 44, 32, 47, -1, -1,
    43, 48, 38, 55, 33, 52, -1, -1,
    45, 41, 49, 35, 28, 31, -1, -1
};

static int g_arrayLs[16] = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
static __int64 g_arrayLsMask[3] =
{
    0x0000000000000000,
    0x0000000000100001,
    0x0000000000300003
};

#define BitTransform(array, len, source, dest) /
{/
    __int64 bts = source;/
    int bti;/
    dest = 0;/
    for(bti = 0; bti < len; bti++)/
    {/
        if(array[bti] >= 0 && (bts & g_arrayMask[array[bti]]))/
        {/
            dest |= g_arrayMask[bti];/
        }/
    }/
}

#define DES_MODE_ENCRYPT        0
#define DES_MODE_DECRYPT        1

void DESSubKeys(__int64 key, __int64 K[16], int mode);

__int64 DES64(__int64 subkeys[16], __int64 data);

 

void DESSubKeys(__int64 key, __int64 K[16], int mode)
{
    __int64 temp;
    int j;
    /* PC-1变换 */
    BitTransform(g_arrayPC_1, 56, key, temp);
    for(j = 0; j < 16; j++)
    {
        /* 循环左移 */
        {
            __int64 source = temp;
            temp = ((source & g_arrayLsMask[g_arrayLs[j]]) << (28 - g_arrayLs[j])) | ((source & ~g_arrayLsMask[g_arrayLs[j]]) >> g_arrayLs[j]);
        }
        /* PC-2变换 */
        BitTransform(g_arrayPC_2, 64, temp, K[j]);
    }
    if(mode == DES_MODE_DECRYPT) /* 如果解密则反转子密钥顺序 */
    {
        __int64 t;
        for(j = 0; j < 8; j++)
        {
            t = K[j];
            K[j] = K[15 - j];
            K[15 - j] = t;
        }
    }
}

__int64 DES64(__int64 subkeys[16], __int64 data)
{
    static __int64 out;
    static __int64 source;
    static __int64 L, R;
    static __int32 * pSource;
    static char * pR;
    static int i;
    static __int32 SOut;
    static __int32 t;
    static int sbi;
    pSource = (__int32 *)&out;
    pR = (char *)&R;
    /* IP变换 */
    {
        BitTransform(g_arrayIP, 64, data, out);
    }
    /* 主迭代 */
    {
        //source = out;
        for(i = 0; i < 16; i++)
        {
            R = pSource[1];
            /* F变换开始 */
            {
                /* E变换 */
                {
                    BitTransform(g_arrayE, 64, R, R);
                }
                /* 与子密钥异或 */
                R ^= subkeys[i];
                /* S盒变换 */
                {
                    SOut = 0;
                    for(sbi = 7; sbi >= 0; sbi--)
                    {
                        SOut <<= 4;
                        SOut |= g_matrixNSBox[sbi][pR[sbi]];
                    }
                    R = SOut;
                }
                /* P变换 */
                {
                    BitTransform(g_arrayP, 32, R, R);
                }
            }
            /* f变换完成 */
            L = pSource[0];
            pSource[0] = pSource[1];
            pSource[1] = (__int32)(L ^ R);
        }
        /* 交换高低32位 */
        {
            t = pSource[0];
            pSource[0] = pSource[1];
            pSource[1] = t;
        }
    }

    /* IP-1变换 */
    {
        BitTransform(g_arrayIP_1, 64, out, out);
    }
    return out;
}

 
menuconfig
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
DES加密解密算法 C语言源代码
05-17
DES加密解密算法 C语言源代码，STM32 51单片机可用。提高产品的安全性，RAM占用小。 /* DES加密,binput：明文，boutput:密文, bkey:密钥 */
DES加密实现（C语言）
weixin_47627174的博客
11-07 8659
DES加密实现（C语言） 最近上完密码学的课，实验要求实现des加密，作为菜鸟参考了好多文章才写出来，记录一下 参考博客： https://blog.csdn.net/m0_37962600/article/details/79912654 https://blog.csdn.net/qq_34838643/article/details/80007992 数据加密标准（Data Encryption Standard, DES）是迄今为止世界上最为广泛使用和流行的一种分组密码算法。 原理：该算法是一个利用
DES算法详解及实现（C语言）
zytjulie的博客
02-23 1万+
DES算法详解及C语言实现
des加密的c语言程序,DES加密算法的C语言实现
weixin_39886612的博客
05-18 170
DES加密算法的C语言实现#include /*DES VERSION0.4 CREATED BY SIMPLE SOURCE AT 2007.3 *//*COMPETENCE :* P4 3.0G 512M*3000000 TIMES ENCRYPTION WITH CREATEDSUBKEYS*26.784 SECONDS(ABOUT 0.85M/S)*/static __int...
c语言实现des加密算法的实验报告,DES加密算法的C语言实现
weixin_42298727的博客
05-18 325
#include /*DES VERSION0.4 CREATED BY SIMPLE SOURCE AT 2007.3 *//*COMPETENCE :* P4 3.0G 512M*3000000 TIMES ENCRYPTION WITH CREATEDSUBKEYS*26.784 SECONDS(ABOUT 0.85M/S)*/static __int64 g_arrayMas...
解析 DES 加密算法(C语言)：
沐一 · 林 的博客
06-13 7238
目录解析 DES 加密算法(C语言)：DES 简介：DES 算法整体流程：DES 解密：C 语言代码实现加密解密逻辑：内容修改自博客：DES加密算法解析与实现 - luogi - 博客园DES 全称为 Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法。DES 算法就是一个把 8 字节 64 位的明文输入块变为 64 位密文输出块的算法，它所使用的密钥也是 64 位（其实只使用到了 56 位，其余 8 位为奇偶校验位）算法特点：分组比较短、密钥太短、密码生命周期短、
DES加密算法实现（加解密代码C++）
CH_whale的博客
03-06 1万+
参考博客：加密算法------DES加密算法详解_柯南的博客-CSDN博客_des加密算法 一、算法流程 二、数据定义 数据名称 数据类型 数据描述 ExchangeRules Int[56] 交换规则表 ShiftTable Int[16] 移位表 PC_2 Int[48] .
DES加密算法原理及代码实现
u012391423的博客
05-10 1万+
目录 一、简要描述 二、名词解释 数据填充 分组加密 算法特点 置换 三、加密运算 1、加密运算流程图 2、初始置换 ​ 3、生成子秘钥 PC-1置换 ​ PC-2置换 4、迭代的过程（f函数） f函数 E-盒扩展 ​ S-盒替代 ​ P-盒置换 ​ 左右交换 5、逆置换 四、解密流程 五、代码实现 六、总结 一、简要描述 DES ...
信息安全实验一：DES加密算法的实现
一顿吃不饱的博客
06-28 6391
一、实验目的及要求1．熟悉加密、解密算法；懂得加密在通信中的重要作用；2．对输入的十六进制数加密（把输入的字符转化成整数），比较输入和输出，当把输入的数改变一个比特时，比较输出的变化，说明原因。3．实现对一个文件进行加解密，提交程序代码和执行结果。二、实验内容本实验通过用DES算法对实际的数据进行加密和解密来深刻了解DES的运行原理。根据所提供的程序分析DES算法的实现过程。在分析密钥生成函数、加密函数（8字节）、解密函数、测试函数和密钥长度检验函数的基础上，用C/VC++或Java语言编写程序实现对文本文
DES加密与解密原理及C++代码实现
热门推荐
2020
08-17 4万+
一.DES算法简介 DES(Data Encryption Standard)是目前最为流行的加密算法之一。 对称性:DES是对称的，也就是说它使用同一个密钥来加密和解密数据。与此相对的是RSA加密算法,是一种非对称加密算法 分组性:DES还是一种分组加密算法，该算法每次处理固定长度的数据段，称之为分组。DES分组的大小是64位，如果加密的数据长度不是64位的倍数，可以按照某种具体的规则来填...
DES的C语言算法（附源代码）
04-10
DES算法的C语言代码及实现 首先新建头文件des_encode.H 内容如下： void EncodeMain(); //EncodeMain function void DecodeMain(); //Sorry ,it has not used void Decode(int *str,int *keychar); //decode :input 8 chars,8 keychars void Encode(int *str,int *keychar); //encode: input 8 chars,8 keychars void keyBuild(int *keychar); //create key array void StrtoBin(int *midkey,int *keychar); //change into binary void keyCreate(int *midkey2,int movebit,int i); //call by keyBuild void EncodeData(int *lData,int *rData,int *srt); //encodedata function void F(int *rData,int *key); //F function void Expand(int *rData,int *rDataP); //Expand function void ExchangeS(int *rDataP,int *rData); //S-diagram change void ExchangeP(int *rData); //P change void FillBin(int *rData,int n,int s); // data to binary;call by S-Diagram change function void DecodeData(int *str,int *lData,int *rData); //DecodeData from binary int IP1[]={58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, //initial change 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 IP2[]={40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31, //opp initial change 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 s[][4][16]={{ //S-diagram array {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 Ex[48]={ 32,1,2,3,4,5, //Expand array 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 P[32]={16,7,20,21, //P-change 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 }; int PC1[56]={57,49,41,33,25,17,9, //PC-1 in keyBuild 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,33,15, 7,62,54,46,38,30,22, 14,6,61,53,45,37,29, 21,13,5,28,20,12,4 }; int PC2[48]={14,17,11,24,1,5, //PC-2 in keyBuild 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 }; 再创建des.cpp 内容如下： #include<stdio.h> #include<string.h> #include"des_encode.h" int key[16][48]; char str[8]; void main() //main function { EncodeMain(); } void EncodeMain() //EncodeMain function { int i; char keychar[8]; int key2[8]; int strkey[8]; printf("请输入8个要加密的字符：\n"); for(i=0;i<8;i++) scanf("%c",&str[i]); getchar(); for(i=0;i<8;i++) strkey[i]=str[i]; printf("\n输入明文的十六进制为:\n"); for(i=0;i<8;i++) printf("%10x",strkey[i]); printf("\n请输入密钥(8个字符):\n"); for(i=0;i<8;i++) scanf("%c",&keychar[i]); for(i=0;i<8;i++) key2[i]=keychar[i]; getchar(); // printf("%c",keychar[i]); Encode(strkey,key2); printf("\n加密后十六进制密文是:\n"); for(i=0;i<8;i++) printf("%10x",strkey[i]); printf("\n\n清输入解密密码\n"); for(i=0;i<8;i++) scanf("%c",&keychar[i]); for(i=0;i<8;i++) key2[i]=keychar[i]; Decode(strkey,key2); for(i=0;i<8;i++) printf("%10x",strkey[i]); for(i=0;i<8;i++) str[i]=strkey[i]; printf("\n明文为：\t"); for(i=0;i<8;i++) printf("%c",str[i]); printf("\n\n"); } void keyBuild(int *keychar){ //create key array int i,j; int movebit[]={1,1,2,2,2,2,2,2, 1,2,2,2,2,2,2,1}; int midkey2[56]; int midkey[64]; StrtoBin(midkey,keychar); for(i=0;i<56;i++) midkey2[i]=midkey[PC1[i]-1]; for(i=0;i<16;i++) keyCreate(midkey2,movebit[i],i); } void StrtoBin(int *midkey,int *keychar){ //change into binary int trans[8],i,j,k,n; n=0; for(i=0;i<8;i++){ j=0; while(keychar[i]!=0){ trans[j]=keychar[i]%2; keychar[i]=keychar[i]/2; j++; } for(k=j;k<8;k++)trans[k]=0; for(k=0;k<8;k++) midkey[n++]=trans[7-k]; } } void keyCreate(int *midkey2,int movebit,int n){ int i,temp[4]; temp[0]=midkey2[0]; temp[1]=midkey2[1]; temp[2]=midkey2[28]; temp[3]=midkey2[29]; if(movebit==2){ for(i=0;i<26;i++){ midkey2[i]=midkey2[i+2]; midkey2[i+28]=midkey2[i+30]; } midkey2[26]=temp[0];midkey2[27]=temp[1]; midkey2[54]=temp[2];midkey2[55]=temp[3]; } else { for(i=0;i<27;i++){ midkey2[i]=midkey2[i+1]; midkey2[i+28]=midkey2[i+29]; } midkey2[27]=temp[0];midkey2[55]=temp[2]; } for(i=0;i<48;i++) key[n][i]=midkey2[PC2[i]-1]; } void EncodeData(int *lData,int *rData,int *str){ //encodedata function int i,j,temp[8],lint,rint;//int h; int data[64]; lint=0,rint=0; for(i=0;i<4;i++){ j=0; while(str[i]!=0){ temp[j]=str[i]%2; str[i]=str[i]/2; j++; } while(j<8)temp[j++]=0; for(j=0;j<8;j++) lData[lint++]=temp[7-j]; j=0; while(str[i+4]!=0){ temp[j]=str[i+4]%2; str[i+4]=str[i+4]/2; j++; } while(j<8)temp[j++]=0; for(j=0;j<8;j++)rData[rint++]=temp[7-j]; } for(i=0;i<32;i++){ data[i]=lData[i]; data[i+32]=rData[i]; } for(i=0;i<32;i++){ lData[i]=data[IP1[i]-1];//printf("P1:%5d:%5d,%5d\n",IP1[i],lData[i],data[IP1[i]-1]); rData[i]=data[IP1[i+32]-1]; } } void F(int *rData,int *key){ //F function int i,rDataP[48]; Expand(rData,rDataP); for(i=0;i<48;i++){ rDataP[i]=rDataP[i]^key[i];// printf("%10d",rDataP[i]);if((i+1)%6==0)printf("\n"); } ExchangeS(rDataP,rData); ExchangeP(rData); } void Expand(int *rData,int *rDataP){ //Expand function int i; for(i=0;i<48;i++) rDataP[i]=rData[Ex[i]-1]; } void ExchangeS(int *rDataP,int *rData){ //S-diagram change int i,n,linex,liney; linex=liney=0; for(i=0;i<48;i+=6){ n=i/6; //printf("%10d\n",(rDataP[i]<<1)); linex=(rDataP[i]<<1)+rDataP[i+5]; liney=(rDataP[i+1]<<3)+(rDataP[i+2]<<2)+(rDataP[i+3]<<1)+rDataP[i+4]; FillBin(rData,n,s[n][linex][liney]); } } void ExchangeP(int *rData){ //P change int i,temp[32]; for(i=0;i<32;i++) temp[i]=rData[i]; for(i=0;i<32;i++) rData[i]=temp[P[i]-1]; } void FillBin(int *rData,int n,int s){ // data to binary;call by S-Diagram change function int temp[4],i; for(i=0;i<4;i++){ temp[i]=s%2; s=s/2; } for(i=0;i<4;i++) rData[n*4+i]=temp[3-i]; } void DecodeData(int *str,int *lData,int *rData){ //DecodeData from binary int i;int a,b;int data[64]; a=0,b=0; for(i=0;i<32;i++){ data[i]=lData[i]; data[i+32]=rData[i]; } for(i=0;i<32;i++){ lData[i]=data[IP2[i]-1]; rData[i]=data[IP2[i+32]-1]; } for(i=0;i<32;i++){ a=(lData[i]&0x1)+(a<<1); b=(rData[i]&0x1)+(b<<1); if((i+1)%8==0){ str[i/8]=a;a=0;//printf("%d",i/8); str[i/8+4]=b;b=0;//printf("%d",i/8+4); } } } void Encode(int *str,int *keychar){ //encode: input 8 chars,8 keychars int lData[32],rData[32],temp[32],rDataP[48]; int i,j; keyBuild(keychar); EncodeData(lData,rData,str); for(i=0;i<16;i++){ for(j=0;j<32;j++) temp[j]=rData[j]; F(rData,key[i]); for(j=0;j<32;j++){ rData[j]=rData[j]^lData[j]; } for(j=0;j<32;j++) lData[j]=temp[j]; } DecodeData(str,rData,lData); } void Decode(int *str,int *keychar){ //decode :input 8 chars,8 keychars int lData[32],rData[32],temp[32],rDataP[48]; int i,j; keyBuild(keychar); EncodeData(lData,rData,str); //这个位置 for(i=0;i<16;i++){ for(j=0;j<32;j++) temp[j]=rData[j]; F(rData,key[15-i]); for(j=0;j<32;j++){ rData[j]=rData[j]^lData[j]; } for(j=0;j<32;j++){ lData[j]=temp[j]; } } DecodeData(str,rData,lData); }
DES加密算法（c语言实现）
06-11
DES，DES加密算法，DES算法源码。用C写的DES加密算法。 DES，DES加密算法，DES算法源码。 DES加密算法（c语言实现） （本程序可以直接使用）
DES加密算法C语言代码实现
09-26
而我们本篇文章讨论的是DES的加密算法。希望大家能够将这两个名词区别开来，很多时候我们说的DES都是在指DES算法，而不是DES数据加密标准。DES算法是一种典型的分组密码，即将固定长度的明文通过一系列复杂的操作...
DES加密算法C语言实现.zip
02-27
DES加密算法C语言实现
3des加密算法C语言实现
07-17
3DES加密算法的C语言实现代码，很好很实用.亲测可用.
Leetcode 41. 缺失的第一个正数和Leetcode 155. 最小栈
最新发布
2301_79614379的博客
04-20 1033
定义一个结构体，数组 data 用于存放推进的数据，数组 min 用于存放最小值，变量 top 存放最后进入的数在 data 的下标，变量 mintop 记录最小值在 min 中的下标。循环遍历数组 nums ，如果该位置的值大于 0 并且不小于数组长度，让哈希表 table 在该值的位置自加。获取堆栈中的最小元素时，根据 mintop 的值返回数组 miin 中的元素。返回栈顶元素时，根据 top 的值返回数组 data 中的元素。--> 返回 -3.输入：nums = [3,4,-1,1]
FloodFill算法简介（用BFS、DFS算法解决）
2301_76197086的博客
04-18 423
FloodFill算法简介
力扣---从中序与后序遍历序列构造二叉树
m0_71536793的博客
04-20 393
力扣 中序遍历 后序遍历 建树
DFS与回溯专题：路径总和问题
孤舟一叶～的博客
04-19 740
对二叉树进行dfs搜索，递归计算每条路径的节点值之和，当某个节点的左右子节点都为空时，说明已经搜索完成某一条路径，将它与目标值进行比较，若相等，则为true。路径恢复： 向上回溯前，需要将当前节点从路径 list 中删除，即执行list.remove(list.size() - 1)。为什么要写list_all.add(new ArrayList(list))，而不是list_all.add(list)？注意：解释里面的sum.add(path)就是list_all.add(list)
DES加密算法c语言实现
10-13
DES加密算法是一种对称加密算法，其实现过程比较复杂。以下是一个简单的C语言实现： ```c #include #include #include #include <openssl/des.h> void des_encrypt(char *key, char *msg, char *result) { DES...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值