精华内容
下载资源
问答
  • 而我们本篇文章讨论的是DES加密算法。希望大家能够将这两个名词区别开来,很多时候我们说的DES都是在指DES算法,而不是DES数据加密标准。DES算法是一种典型的分组密码,即将固定长度的明文通过一系列复杂的操作...
  • DES加密算法C语言

    2018-07-07 13:40:08
    C语言写的DES加解密源码,单片机上、上位机兼可以用。
  • 3DES加密算法C语言实现

    热门讨论 2013-09-26 18:45:04
    利用C语言编写的3DES加密算法,能够对任意长度的字符数组进行加解密。通过编写相应的JNI接口文件能够很容易移植到Android平台,从而解决不同平台DES加解密结果不一致的问题。
  • DES,DES加密算法,DES算法源码。用C写的DES加密算法。 DES,DES加密算法,DES算法源码。 DES加密算法c语言实现) (本程序可以直接使用)
  • 采用C语言实现的DES加密算法,支持文件的加解密,其中包含源代码及可执行程序。
  • 调试通过的代码,适合用于密码学,C语言等课程的小作业
  • DES和3DES加密算法C语言实现

    万次阅读 热门讨论 2017-09-20 17:58:45
    DES和3DES加密算法C语言实现 记录DES和3DES加密算法最简洁易懂的C语言源码 typedef struct { uint32_t sk[32]; /*!< DES subkeys */ } des_context;/** * \brief Triple-DES context structure */ ...

    DES和3DES加密算法C语言实现
    记录DES和3DES加密算法最简洁易懂的C语言源码
    主要是要用到CBC这部分的算法,后边也有一个工具可以提供验证,因为网上的工具含有CBC的很少,也方便大家吧
    之前代码缺少一个头文件,有失严谨,这次更新一下,去掉头文件,将头文件部分内容加入到c文件头部

    #include <stddef.h>
    #include <stdint.h>
    #include <string.h>
    #include <stdlib.h>
    #include <stdio.h>
    
    #define DES_ENCRYPT     1
    #define DES_DECRYPT     0
    
    #define ERR_DES_INVALID_INPUT_LENGTH              -0x0032  /**< The data input has an invalid length. */
    
    #define DES_KEY_SIZE         (8)  
    #define DES3_KEY2_SIZE       (16)  
    #define DES3_KEY3_SIZE       (24) 
    
    typedef struct
    {
        uint32_t sk[32];            /*!<  DES subkeys       */
    }des_context;
    
    /**
     * \brief          Triple-DES context structure
     */
    typedef struct
    {
        uint32_t sk[96];            /*!<  3DES subkeys      */
    }des3_context;
    
    #define DES_C
    
    #if defined(DES_C)
    
    
    
    #if !defined(DES_ALT)
    
    /* Implementation that should never be optimized out by the compiler */
    static void zeroize( void *v, size_t n ) {
        volatile unsigned char *p = (unsigned char*)v; while( n-- ) *p++ = 0;
    }
    
    /*
     * 32-bit integer manipulation macros (big endian)
     */
    #ifndef GET_UINT32_BE
    #define GET_UINT32_BE(n,b,i)                            \
    {                                                       \
        (n) = ( (uint32_t) (b)[(i)    ] << 24 )             \
            | ( (uint32_t) (b)[(i) + 1] << 16 )             \
            | ( (uint32_t) (b)[(i) + 2] <<  8 )             \
            | ( (uint32_t) (b)[(i) + 3]       );            \
    }
    #endif
    
    #ifndef PUT_UINT32_BE
    #define PUT_UINT32_BE(n,b,i)                            \
    {                                                       \
        (b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
        (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
        (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
        (b)[(i) + 3] = (unsigned char) ( (n)       );       \
    }
    #endif
    
    /*
     * Expanded DES S-boxes
     */
    static const uint32_t SB1[64] =
    {
        0x01010400, 0x00000000, 0x00010000, 0x01010404,
        0x01010004, 0x00010404, 0x00000004, 0x00010000,
        0x00000400, 0x01010400, 0x01010404, 0x00000400,
        0x01000404, 0x01010004, 0x01000000, 0x00000004,
        0x00000404, 0x01000400, 0x01000400, 0x00010400,
        0x00010400, 0x01010000, 0x01010000, 0x01000404,
        0x00010004, 0x01000004, 0x01000004, 0x00010004,
        0x00000000, 0x00000404, 0x00010404, 0x01000000,
        0x00010000, 0x01010404, 0x00000004, 0x01010000,
        0x01010400, 0x01000000, 0x01000000, 0x00000400,
        0x01010004, 0x00010000, 0x00010400, 0x01000004,
        0x00000400, 0x00000004, 0x01000404, 0x00010404,
        0x01010404, 0x00010004, 0x01010000, 0x01000404,
        0x01000004, 0x00000404, 0x00010404, 0x01010400,
        0x00000404, 0x01000400, 0x01000400, 0x00000000,
        0x00010004, 0x00010400, 0x00000000, 0x01010004
    };
    
    static const uint32_t SB2[64] =
    {
        0x80108020, 0x80008000, 0x00008000, 0x00108020,
        0x00100000, 0x00000020, 0x80100020, 0x80008020,
        0x80000020, 0x80108020, 0x80108000, 0x80000000,
        0x80008000, 0x00100000, 0x00000020, 0x80100020,
        0x00108000, 0x00100020, 0x80008020, 0x00000000,
        0x80000000, 0x00008000, 0x00108020, 0x80100000,
        0x00100020, 0x80000020, 0x00000000, 0x00108000,
        0x00008020, 0x80108000, 0x80100000, 0x00008020,
        0x00000000, 0x00108020, 0x80100020, 0x00100000,
        0x80008020, 0x80100000, 0x80108000, 0x00008000,
        0x80100000, 0x80008000, 0x00000020, 0x80108020,
        0x00108020, 0x00000020, 0x00008000, 0x80000000,
        0x00008020, 0x80108000, 0x00100000, 0x80000020,
        0x00100020, 0x80008020, 0x80000020, 0x00100020,
        0x00108000, 0x00000000, 0x80008000, 0x00008020,
        0x80000000, 0x80100020, 0x80108020, 0x00108000
    };
    
    static const uint32_t SB3[64] =
    {
        0x00000208, 0x08020200, 0x00000000, 0x08020008,
        0x08000200, 0x00000000, 0x00020208, 0x08000200,
        0x00020008, 0x08000008, 0x08000008, 0x00020000,
        0x08020208, 0x00020008, 0x08020000, 0x00000208,
        0x08000000, 0x00000008, 0x08020200, 0x00000200,
        0x00020200, 0x08020000, 0x08020008, 0x00020208,
        0x08000208, 0x00020200, 0x00020000, 0x08000208,
        0x00000008, 0x08020208, 0x00000200, 0x08000000,
        0x08020200, 0x08000000, 0x00020008, 0x00000208,
        0x00020000, 0x08020200, 0x08000200, 0x00000000,
        0x00000200, 0x00020008, 0x08020208, 0x08000200,
        0x08000008, 0x00000200, 0x00000000, 0x08020008,
        0x08000208, 0x00020000, 0x08000000, 0x08020208,
        0x00000008, 0x00020208, 0x00020200, 0x08000008,
        0x08020000, 0x08000208, 0x00000208, 0x08020000,
        0x00020208, 0x00000008, 0x08020008, 0x00020200
    };
    
    static const uint32_t SB4[64] =
    {
        0x00802001, 0x00002081, 0x00002081, 0x00000080,
        0x00802080, 0x00800081, 0x00800001, 0x00002001,
        0x00000000, 0x00802000, 0x00802000, 0x00802081,
        0x00000081, 0x00000000, 0x00800080, 0x00800001,
        0x00000001, 0x00002000, 0x00800000, 0x00802001,
        0x00000080, 0x00800000, 0x00002001, 0x00002080,
        0x00800081, 0x00000001, 0x00002080, 0x00800080,
        0x00002000, 0x00802080, 0x00802081, 0x00000081,
        0x00800080, 0x00800001, 0x00802000, 0x00802081,
        0x00000081, 0x00000000, 0x00000000, 0x00802000,
        0x00002080, 0x00800080, 0x00800081, 0x00000001,
        0x00802001, 0x00002081, 0x00002081, 0x00000080,
        0x00802081, 0x00000081, 0x00000001, 0x00002000,
        0x00800001, 0x00002001, 0x00802080, 0x00800081,
        0x00002001, 0x00002080, 0x00800000, 0x00802001,
        0x00000080, 0x00800000, 0x00002000, 0x00802080
    };
    
    static const uint32_t SB5[64] =
    {
        0x00000100, 0x02080100, 0x02080000, 0x42000100,
        0x00080000, 0x00000100, 0x40000000, 0x02080000,
        0x40080100, 0x00080000, 0x02000100, 0x40080100,
        0x42000100, 0x42080000, 0x00080100, 0x40000000,
        0x02000000, 0x40080000, 0x40080000, 0x00000000,
        0x40000100, 0x42080100, 0x42080100, 0x02000100,
        0x42080000, 0x40000100, 0x00000000, 0x42000000,
        0x02080100, 0x02000000, 0x42000000, 0x00080100,
        0x00080000, 0x42000100, 0x00000100, 0x02000000,
        0x40000000, 0x02080000, 0x42000100, 0x40080100,
        0x02000100, 0x40000000, 0x42080000, 0x02080100,
        0x40080100, 0x00000100, 0x02000000, 0x42080000,
        0x42080100, 0x00080100, 0x42000000, 0x42080100,
        0x02080000, 0x00000000, 0x40080000, 0x42000000,
        0x00080100, 0x02000100, 0x40000100, 0x00080000,
        0x00000000, 0x40080000, 0x02080100, 0x40000100
    };
    
    static const uint32_t SB6[64] =
    {
        0x20000010, 0x20400000, 0x00004000, 0x20404010,
        0x20400000, 0x00000010, 0x20404010, 0x00400000,
        0x20004000, 0x00404010, 0x00400000, 0x20000010,
        0x00400010, 0x20004000, 0x20000000, 0x00004010,
        0x00000000, 0x00400010, 0x20004010, 0x00004000,
        0x00404000, 0x20004010, 0x00000010, 0x20400010,
        0x20400010, 0x00000000, 0x00404010, 0x20404000,
        0x00004010, 0x00404000, 0x20404000, 0x20000000,
        0x20004000, 0x00000010, 0x20400010, 0x00404000,
        0x20404010, 0x00400000, 0x00004010, 0x20000010,
        0x00400000, 0x20004000, 0x20000000, 0x00004010,
        0x20000010, 0x20404010, 0x00404000, 0x20400000,
        0x00404010, 0x20404000, 0x00000000, 0x20400010,
        0x00000010, 0x00004000, 0x20400000, 0x00404010,
        0x00004000, 0x00400010, 0x20004010, 0x00000000,
        0x20404000, 0x20000000, 0x00400010, 0x20004010
    };
    
    static const uint32_t SB7[64] =
    {
        0x00200000, 0x04200002, 0x04000802, 0x00000000,
        0x00000800, 0x04000802, 0x00200802, 0x04200800,
        0x04200802, 0x00200000, 0x00000000, 0x04000002,
        0x00000002, 0x04000000, 0x04200002, 0x00000802,
        0x04000800, 0x00200802, 0x00200002, 0x04000800,
        0x04000002, 0x04200000, 0x04200800, 0x00200002,
        0x04200000, 0x00000800, 0x00000802, 0x04200802,
        0x00200800, 0x00000002, 0x04000000, 0x00200800,
        0x04000000, 0x00200800, 0x00200000, 0x04000802,
        0x04000802, 0x04200002, 0x04200002, 0x00000002,
        0x00200002, 0x04000000, 0x04000800, 0x00200000,
        0x04200800, 0x00000802, 0x00200802, 0x04200800,
        0x00000802, 0x04000002, 0x04200802, 0x04200000,
        0x00200800, 0x00000000, 0x00000002, 0x04200802,
        0x00000000, 0x00200802, 0x04200000, 0x00000800,
        0x04000002, 0x04000800, 0x00000800, 0x00200002
    };
    
    static const uint32_t SB8[64] =
    {
        0x10001040, 0x00001000, 0x00040000, 0x10041040,
        0x10000000, 0x10001040, 0x00000040, 0x10000000,
        0x00040040, 0x10040000, 0x10041040, 0x00041000,
        0x10041000, 0x00041040, 0x00001000, 0x00000040,
        0x10040000, 0x10000040, 0x10001000, 0x00001040,
        0x00041000, 0x00040040, 0x10040040, 0x10041000,
        0x00001040, 0x00000000, 0x00000000, 0x10040040,
        0x10000040, 0x10001000, 0x00041040, 0x00040000,
        0x00041040, 0x00040000, 0x10041000, 0x00001000,
        0x00000040, 0x10040040, 0x00001000, 0x00041040,
        0x10001000, 0x00000040, 0x10000040, 0x10040000,
        0x10040040, 0x10000000, 0x00040000, 0x10001040,
        0x00000000, 0x10041040, 0x00040040, 0x10000040,
        0x10040000, 0x10001000, 0x10001040, 0x00000000,
        0x10041040, 0x00041000, 0x00041000, 0x00001040,
        0x00001040, 0x00040040, 0x10000000, 0x10041000
    };
    
    /*
     * PC1: left and right halves bit-swap
     */
    static const uint32_t LHs[16] =
    {
        0x00000000, 0x00000001, 0x00000100, 0x00000101,
        0x00010000, 0x00010001, 0x00010100, 0x00010101,
        0x01000000, 0x01000001, 0x01000100, 0x01000101,
        0x01010000, 0x01010001, 0x01010100, 0x01010101
    };
    
    static const uint32_t RHs[16] =
    {
        0x00000000, 0x01000000, 0x00010000, 0x01010000,
        0x00000100, 0x01000100, 0x00010100, 0x01010100,
        0x00000001, 0x01000001, 0x00010001, 0x01010001,
        0x00000101, 0x01000101, 0x00010101, 0x01010101,
    };
    
    /*
     * Initial Permutation macro
     */
    #define DES_IP(X,Y)                                             \
    {                                                               \
        T = ((X >>  4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T <<  4);   \
        T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16);   \
        T = ((Y >>  2) ^ X) & 0x33333333; X ^= T; Y ^= (T <<  2);   \
        T = ((Y >>  8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T <<  8);   \
        Y = ((Y << 1) | (Y >> 31)) & 0xFFFFFFFF;                    \
        T = (X ^ Y) & 0xAAAAAAAA; Y ^= T; X ^= T;                   \
        X = ((X << 1) | (X >> 31)) & 0xFFFFFFFF;                    \
    }
    
    /*
     * Final Permutation macro
     */
    #define DES_FP(X,Y)                                             \
    {                                                               \
        X = ((X << 31) | (X >> 1)) & 0xFFFFFFFF;                    \
        T = (X ^ Y) & 0xAAAAAAAA; X ^= T; Y ^= T;                   \
        Y = ((Y << 31) | (Y >> 1)) & 0xFFFFFFFF;                    \
        T = ((Y >>  8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T <<  8);   \
        T = ((Y >>  2) ^ X) & 0x33333333; X ^= T; Y ^= (T <<  2);   \
        T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16);   \
        T = ((X >>  4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T <<  4);   \
    }
    
    /*
     * DES round macro
     */
    #define DES_ROUND(X,Y)                          \
    {                                               \
        T = *SK++ ^ X;                              \
        Y ^= SB8[ (T      ) & 0x3F ] ^              \
             SB6[ (T >>  8) & 0x3F ] ^              \
             SB4[ (T >> 16) & 0x3F ] ^              \
             SB2[ (T >> 24) & 0x3F ];               \
                                                    \
        T = *SK++ ^ ((X << 28) | (X >> 4));         \
        Y ^= SB7[ (T      ) & 0x3F ] ^              \
             SB5[ (T >>  8) & 0x3F ] ^              \
             SB3[ (T >> 16) & 0x3F ] ^              \
             SB1[ (T >> 24) & 0x3F ];               \
    }
    
    #define SWAP(a,b) { uint32_t t = a; a = b; b = t; t = 0; }
    
    void des_init( des_context *ctx )
    {
        memset( ctx, 0, sizeof( des_context ) );
    }
    
    void des_free( des_context *ctx )
    {
        if( ctx == NULL )
            return;
    
        zeroize( ctx, sizeof( des_context ) );
    }
    
    void des3_init( des3_context *ctx )
    {
        memset( ctx, 0, sizeof( des3_context ) );
    }
    
    void des3_free( des3_context *ctx )
    {
        if( ctx == NULL )
            return;
    
        zeroize( ctx, sizeof( des3_context ) );
    }
    
    static const unsigned char odd_parity_table[128] = { 1,  2,  4,  7,  8,
            11, 13, 14, 16, 19, 21, 22, 25, 26, 28, 31, 32, 35, 37, 38, 41, 42, 44,
            47, 49, 50, 52, 55, 56, 59, 61, 62, 64, 67, 69, 70, 73, 74, 76, 79, 81,
            82, 84, 87, 88, 91, 93, 94, 97, 98, 100, 103, 104, 107, 109, 110, 112,
            115, 117, 118, 121, 122, 124, 127, 128, 131, 133, 134, 137, 138, 140,
            143, 145, 146, 148, 151, 152, 155, 157, 158, 161, 162, 164, 167, 168,
            171, 173, 174, 176, 179, 181, 182, 185, 186, 188, 191, 193, 194, 196,
            199, 200, 203, 205, 206, 208, 211, 213, 214, 217, 218, 220, 223, 224,
            227, 229, 230, 233, 234, 236, 239, 241, 242, 244, 247, 248, 251, 253,
            254 };
    
    void des_key_set_parity( unsigned char key[DES_KEY_SIZE] )
    {
        int i;
    
        for( i = 0; i < DES_KEY_SIZE; i++ )
            key[i] = odd_parity_table[key[i] / 2];
    }
    
    /*
     * Check the given key's parity, returns 1 on failure, 0 on SUCCESS
     */
    int des_key_check_key_parity( const unsigned char key[DES_KEY_SIZE] )
    {
        int i;
    
        for( i = 0; i < DES_KEY_SIZE; i++ )
            if( key[i] != odd_parity_table[key[i] / 2] )
                return( 1 );
    
        return( 0 );
    }
    
    /*
     * Table of weak and semi-weak keys
     *
     * Source: http://en.wikipedia.org/wiki/Weak_key
     *
     * Weak:
     * Alternating ones + zeros (0x0101010101010101)
     * Alternating 'F' + 'E' (0xFEFEFEFEFEFEFEFE)
     * '0xE0E0E0E0F1F1F1F1'
     * '0x1F1F1F1F0E0E0E0E'
     *
     * Semi-weak:
     * 0x011F011F010E010E and 0x1F011F010E010E01
     * 0x01E001E001F101F1 and 0xE001E001F101F101
     * 0x01FE01FE01FE01FE and 0xFE01FE01FE01FE01
     * 0x1FE01FE00EF10EF1 and 0xE01FE01FF10EF10E
     * 0x1FFE1FFE0EFE0EFE and 0xFE1FFE1FFE0EFE0E
     * 0xE0FEE0FEF1FEF1FE and 0xFEE0FEE0FEF1FEF1
     *
     */
    
    #define WEAK_KEY_COUNT 16
    
    static const unsigned char weak_key_table[WEAK_KEY_COUNT][DES_KEY_SIZE] =
    {
        { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
        { 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE },
        { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E },
        { 0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1 },
    
        { 0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E },
        { 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01 },
        { 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1 },
        { 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01 },
        { 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE },
        { 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01 },
        { 0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1 },
        { 0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E },
        { 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE },
        { 0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E },
        { 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE },
        { 0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1 }
    };
    
    int des_key_check_weak( const unsigned char key[DES_KEY_SIZE] )
    {
        int i;
    
        for( i = 0; i < WEAK_KEY_COUNT; i++ )
            if( memcmp( weak_key_table[i], key, DES_KEY_SIZE) == 0 )
                return( 1 );
    
        return( 0 );
    }
    
    
    void des_setkey( uint32_t SK[32], const unsigned char key[DES_KEY_SIZE] )
    {
        int i;
        uint32_t X, Y, T;
    
        GET_UINT32_BE( X, key, 0 );
        GET_UINT32_BE( Y, key, 4 );
    
        /*
         * Permuted Choice 1
         */
        T =  ((Y >>  4) ^ X) & 0x0F0F0F0F;  X ^= T; Y ^= (T <<  4);
        T =  ((Y      ) ^ X) & 0x10101010;  X ^= T; Y ^= (T      );
    
        X =   (LHs[ (X      ) & 0xF] << 3) | (LHs[ (X >>  8) & 0xF ] << 2)
            | (LHs[ (X >> 16) & 0xF] << 1) | (LHs[ (X >> 24) & 0xF ]     )
            | (LHs[ (X >>  5) & 0xF] << 7) | (LHs[ (X >> 13) & 0xF ] << 6)
            | (LHs[ (X >> 21) & 0xF] << 5) | (LHs[ (X >> 29) & 0xF ] << 4);
    
        Y =   (RHs[ (Y >>  1) & 0xF] << 3) | (RHs[ (Y >>  9) & 0xF ] << 2)
            | (RHs[ (Y >> 17) & 0xF] << 1) | (RHs[ (Y >> 25) & 0xF ]     )
            | (RHs[ (Y >>  4) & 0xF] << 7) | (RHs[ (Y >> 12) & 0xF ] << 6)
            | (RHs[ (Y >> 20) & 0xF] << 5) | (RHs[ (Y >> 28) & 0xF ] << 4);
    
        X &= 0x0FFFFFFF;
        Y &= 0x0FFFFFFF;
    
        /*
         * calculate subkeys
         */
        for( i = 0; i < 16; i++ )
        {
            if( i < 2 || i == 8 || i == 15 )
            {
                X = ((X <<  1) | (X >> 27)) & 0x0FFFFFFF;
                Y = ((Y <<  1) | (Y >> 27)) & 0x0FFFFFFF;
            }
            else
            {
                X = ((X <<  2) | (X >> 26)) & 0x0FFFFFFF;
                Y = ((Y <<  2) | (Y >> 26)) & 0x0FFFFFFF;
            }
    
            *SK++ =   ((X <<  4) & 0x24000000) | ((X << 28) & 0x10000000)
                    | ((X << 14) & 0x08000000) | ((X << 18) & 0x02080000)
                    | ((X <<  6) & 0x01000000) | ((X <<  9) & 0x00200000)
                    | ((X >>  1) & 0x00100000) | ((X << 10) & 0x00040000)
                    | ((X <<  2) & 0x00020000) | ((X >> 10) & 0x00010000)
                    | ((Y >> 13) & 0x00002000) | ((Y >>  4) & 0x00001000)
                    | ((Y <<  6) & 0x00000800) | ((Y >>  1) & 0x00000400)
                    | ((Y >> 14) & 0x00000200) | ((Y      ) & 0x00000100)
                    | ((Y >>  5) & 0x00000020) | ((Y >> 10) & 0x00000010)
                    | ((Y >>  3) & 0x00000008) | ((Y >> 18) & 0x00000004)
                    | ((Y >> 26) & 0x00000002) | ((Y >> 24) & 0x00000001);
    
            *SK++ =   ((X << 15) & 0x20000000) | ((X << 17) & 0x10000000)
                    | ((X << 10) & 0x08000000) | ((X << 22) & 0x04000000)
                    | ((X >>  2) & 0x02000000) | ((X <<  1) & 0x01000000)
                    | ((X << 16) & 0x00200000) | ((X << 11) & 0x00100000)
                    | ((X <<  3) & 0x00080000) | ((X >>  6) & 0x00040000)
                    | ((X << 15) & 0x00020000) | ((X >>  4) & 0x00010000)
                    | ((Y >>  2) & 0x00002000) | ((Y <<  8) & 0x00001000)
                    | ((Y >> 14) & 0x00000808) | ((Y >>  9) & 0x00000400)
                    | ((Y      ) & 0x00000200) | ((Y <<  7) & 0x00000100)
                    | ((Y >>  7) & 0x00000020) | ((Y >>  3) & 0x00000011)
                    | ((Y <<  2) & 0x00000004) | ((Y >> 21) & 0x00000002);
        }
    }
    
    
    /*
     * DES key schedule (56-bit, encryption)
     */
    int des_setkey_enc( des_context *ctx, const unsigned char key[DES_KEY_SIZE] )
    {
        des_setkey( ctx->sk, key );
    
        return( 0 );
    }
    
    /*
     * DES key schedule (56-bit, decryption)
     */
    int des_setkey_dec( des_context *ctx, const unsigned char key[DES_KEY_SIZE] )
    {
        int i;
    
        des_setkey( ctx->sk, key );
    
        for( i = 0; i < 16; i += 2 )
        {
            SWAP( ctx->sk[i    ], ctx->sk[30 - i] );
            SWAP( ctx->sk[i + 1], ctx->sk[31 - i] );
        }
    
        return( 0 );
    }
    
    static void des3_set2key( uint32_t esk[96],
                              uint32_t dsk[96],
                              const unsigned char key[DES_KEY_SIZE*2] )
    {
        int i;
    
        des_setkey( esk, key );
        des_setkey( dsk + 32, key + 8 );
    
        for( i = 0; i < 32; i += 2 )
        {
            dsk[i     ] = esk[30 - i];
            dsk[i +  1] = esk[31 - i];
    
            esk[i + 32] = dsk[62 - i];
            esk[i + 33] = dsk[63 - i];
    
            esk[i + 64] = esk[i    ];
            esk[i + 65] = esk[i + 1];
    
            dsk[i + 64] = dsk[i    ];
            dsk[i + 65] = dsk[i + 1];
        }
    }
    
    /*
     * Triple-DES key schedule (112-bit, encryption)
     */
    int des3_set2key_enc( des3_context *ctx,
                          const unsigned char key[DES_KEY_SIZE * 2] )
    {
        uint32_t sk[96];
    
        des3_set2key( ctx->sk, sk, key );
        zeroize( sk,  sizeof( sk ) );
    
        return( 0 );
    }
    
    /*
     * Triple-DES key schedule (112-bit, decryption)
     */
    int des3_set2key_dec( des3_context *ctx,
                          const unsigned char key[DES_KEY_SIZE * 2] )
    {
        uint32_t sk[96];
    
        des3_set2key( sk, ctx->sk, key );
        zeroize( sk,  sizeof( sk ) );
    
        return( 0 );
    }
    
    static void des3_set3key( uint32_t esk[96],
                              uint32_t dsk[96],
                              const unsigned char key[24] )
    {
        int i;
    
        des_setkey( esk, key );
        des_setkey( dsk + 32, key +  8 );
        des_setkey( esk + 64, key + 16 );
    
        for( i = 0; i < 32; i += 2 )
        {
            dsk[i     ] = esk[94 - i];
            dsk[i +  1] = esk[95 - i];
    
            esk[i + 32] = dsk[62 - i];
            esk[i + 33] = dsk[63 - i];
    
            dsk[i + 64] = esk[30 - i];
            dsk[i + 65] = esk[31 - i];
        }
    }
    
    /*
     * Triple-DES key schedule (168-bit, encryption)
     */
    int des3_set3key_enc( des3_context *ctx,
                          const unsigned char key[DES_KEY_SIZE * 3] )
    {
        uint32_t sk[96];
    
        des3_set3key( ctx->sk, sk, key );
        zeroize( sk,  sizeof( sk ) );
    
        return( 0 );
    }
    
    /*
     * Triple-DES key schedule (168-bit, decryption)
     */
    int des3_set3key_dec( des3_context *ctx,
                          const unsigned char key[DES_KEY_SIZE * 3] )
    {
        uint32_t sk[96];
    
        des3_set3key( sk, ctx->sk, key );
        zeroize( sk,  sizeof( sk ) );
    
        return( 0 );
    }
    
    /*
     * DES-ECB block encryption/decryption
     */
    
    int des_crypt_ecb( des_context *ctx,
                        const unsigned char input[8],
                        unsigned char output[8] )
    {
        int i;
        uint32_t X, Y, T, *SK;
    
        SK = ctx->sk;
    
        GET_UINT32_BE( X, input, 0 );
        GET_UINT32_BE( Y, input, 4 );
    
        DES_IP( X, Y );
    
        for( i = 0; i < 8; i++ )
        {
            DES_ROUND( Y, X );
            DES_ROUND( X, Y );
        }
    
        DES_FP( Y, X );
    
        PUT_UINT32_BE( Y, output, 0 );
        PUT_UINT32_BE( X, output, 4 );
    
        return( 0 );
    }
    
    
    
    /*
     * DES-CBC buffer encryption/decryption
     */
    int des_crypt_cbc( des_context *ctx,
                        int mode,
                        size_t length,
                        unsigned char iv[8],
                        const unsigned char *input,
                        unsigned char *output )
    {
        int i;
        unsigned char temp[8];
    
        if( length % 8 )
            return( ERR_DES_INVALID_INPUT_LENGTH );
    
        if( mode == DES_ENCRYPT )
        {
            while( length > 0 )
            {
                for( i = 0; i < 8; i++ )
                    output[i] = (unsigned char)( input[i] ^ iv[i] );
    
                des_crypt_ecb( ctx, output, output );
                memcpy( iv, output, 8 );
    
                input  += 8;
                output += 8;
                length -= 8;
            }
        }
        else /* DES_DECRYPT */
        {
            while( length > 0 )
            {
                memcpy( temp, input, 8 );
                des_crypt_ecb( ctx, input, output );
    
                for( i = 0; i < 8; i++ )
                    output[i] = (unsigned char)( output[i] ^ iv[i] );
    
                memcpy( iv, temp, 8 );
    
                input  += 8;
                output += 8;
                length -= 8;
            }
        }
    
        return( 0 );
    }
    
    
    /*
     * 3DES-ECB block encryption/decryption
     */
    
    int des3_crypt_ecb( des3_context *ctx,
                         const unsigned char input[8],
                         unsigned char output[8] )
    {
        int i;
        uint32_t X, Y, T, *SK;
    
        SK = ctx->sk;
    
        GET_UINT32_BE( X, input, 0 );
        GET_UINT32_BE( Y, input, 4 );
    
        DES_IP( X, Y );
    
        for( i = 0; i < 8; i++ )
        {
            DES_ROUND( Y, X );
            DES_ROUND( X, Y );
        }
    
        for( i = 0; i < 8; i++ )
        {
            DES_ROUND( X, Y );
            DES_ROUND( Y, X );
        }
    
        for( i = 0; i < 8; i++ )
        {
            DES_ROUND( Y, X );
            DES_ROUND( X, Y );
        }
    
        DES_FP( Y, X );
    
        PUT_UINT32_BE( Y, output, 0 );
        PUT_UINT32_BE( X, output, 4 );
    
        return( 0 );
    }
    
    
    
    /*
     * 3DES-CBC buffer encryption/decryption
     */
    int des3_crypt_cbc( des3_context *ctx,
                         int mode,
                         size_t length,
                         unsigned char iv[8],
                         const unsigned char *input,
                         unsigned char *output )
    {
        int i;
        unsigned char temp[8];
    
        if( length % 8 )
            return( ERR_DES_INVALID_INPUT_LENGTH );
    
        if( mode == DES_ENCRYPT )
        {
            while( length > 0 )
            {
                for( i = 0; i < 8; i++ )
                    output[i] = (unsigned char)( input[i] ^ iv[i] );
    
                des3_crypt_ecb( ctx, output, output );
                memcpy( iv, output, 8 );
    
                input  += 8;
                output += 8;
                length -= 8;
            }
        }
        else /* DES_DECRYPT */
        {
            while( length > 0 )
            {
                memcpy( temp, input, 8 );
                des3_crypt_ecb( ctx, input, output );
    
                for( i = 0; i < 8; i++ )
                    output[i] = (unsigned char)( output[i] ^ iv[i] );
    
                memcpy( iv, temp, 8 );
    
                input  += 8;
                output += 8;
                length -= 8;
            }
        }
    
        return( 0 );
    }
    
    
    #endif /* !DES_ALT */
    
    #endif /* DES_C */
    
    /*
     * DES-ECB buffer encryption API
     */
    unsigned int des_ecb_encrypt(unsigned char *pout,
    							 unsigned char *pdata,
    							 unsigned int nlen,
    							 unsigned char *pkey)
    {
        unsigned char *tmp;
        unsigned int len,i;
        unsigned char ch = '\0';
        des_context ctx;
    
        des_setkey_enc( &ctx, pkey );
    
        len = (nlen / 8 + (nlen % 8 ? 1: 0)) * 8;
    
    	//ch = 8 - nlen % 8;
        for(i = 0;i < nlen;i += 8)
        {
            des_crypt_ecb( &ctx, (pdata + i), (pout + i) );
        }
        if(len > nlen)
        {
    		tmp = (unsigned char *)malloc(len);
            i -= 8;
            memcpy(tmp,pdata + i,nlen - i);
            memset(tmp + nlen % 8, ch, (8 - nlen % 8) % 8);
            des_crypt_ecb( &ctx, tmp, (pout + i));
    		free(tmp);
        }
    	
        des_free( &ctx );
        return len;
    
    
    }
    /*
     * DES-ECB buffer decryption API
     */
    unsigned int des_ecb_decrypt(unsigned char *pout,
    							 unsigned char *pdata,
    							 unsigned int nlen,
    							 unsigned char *pkey)
    {
    
        unsigned int i;
        des_context ctx;
    
    	if(nlen % 8)
            return 1;
    
        des_setkey_dec( &ctx, pkey );
    
    
        for(i = 0;i < nlen;i += 8)
        {
            des_crypt_ecb(&ctx, (pdata + i), (pout + i));
        }
        des_free( &ctx );
        return 0;
    
    }
    
    /*
     * DES-CBC buffer encryption API
     */
    unsigned int des_cbc_encrypt(unsigned char *pout,
    							 unsigned char *pdata,
    							 unsigned int nlen,
    							 unsigned char *pkey,
    							 unsigned char *piv)
    {
        des_context ctx;
        unsigned char iv[8] = {0};
        unsigned char *pivb;
    
        if(piv == NULL)
    		pivb = iv;
        else
        	pivb = piv;
    
        des_setkey_enc( &ctx, pkey );
    
        des_crypt_cbc( &ctx, 1, nlen, pivb, pdata, (pout));
    	
        des_free( &ctx );
        
        return nlen;
    
    
    }
    /*
     * DES-CBC buffer decryption API
     */
    unsigned int des_cbc_decrypt(unsigned char *pout,
    							 unsigned char *pdata,
    							 unsigned int nlen,
    							 unsigned char *pkey,
    							 unsigned char *piv)
    {
    
        des_context ctx;
        unsigned char iv[8] = {0};
        unsigned char *pivb;
    
        if(piv == NULL)
    		pivb = iv;
        else
        	pivb = piv;
    
        des_setkey_dec( &ctx, pkey );
    
        des_crypt_cbc( &ctx, 0, nlen, pivb, pdata, (pout));
    	
        des_free( &ctx );
        
        return 0;
    
    }
    /*
     * 3DES-ECB buffer encryption API
     */
    unsigned int des3_ecb_encrypt(unsigned char *pout,
    							  unsigned char *pdata,
    							  unsigned int nlen,
    							  unsigned char *pkey,
    							  unsigned int klen)
    {
        unsigned char *tmp;
        unsigned int len,i;
        unsigned char ch = '\0';
        des3_context ctx3;
    
    	if(klen == DES3_KEY2_SIZE)//16字节
    		des3_set2key_enc( &ctx3, pkey );//根据长度设置key
    	else if(klen == DES3_KEY3_SIZE)//24字节
    		des3_set3key_enc( &ctx3, pkey );
    
        len = (nlen / 8 + (nlen % 8 ? 1: 0)) * 8;
    
    	//ch = 8 - nlen % 8;//可以设置补齐内容,常用0或0xFF
        for(i = 0;i < nlen;i += 8)
        {
            des3_crypt_ecb( &ctx3, (pdata + i), (pout + i) );
        }
        if(len > nlen)//不足8字节补齐
        {
    		tmp = (unsigned char *)malloc(len);
            i -= 8;
            memcpy(tmp,pdata + i,nlen - i);
            memset(tmp + nlen % 8, ch, (8 - nlen % 8) % 8);
            des3_crypt_ecb( &ctx3, tmp, (pout + i));
    		free(tmp);
        }
    	
        des3_free( &ctx3 );
        return len;
    
    
    }
    /*
     * 3DES-ECB buffer decryption API
     */
    unsigned int des3_ecb_decrypt(unsigned char *pout,
    							  unsigned char *pdata,
    							  unsigned int nlen,
    							  unsigned char *pkey,
    							  unsigned int klen)
    {
    
        unsigned int i;
        des3_context ctx3;
    
    	if(nlen % 8)
            return 1;
    
        if(klen == DES3_KEY2_SIZE)
    		des3_set2key_dec( &ctx3, pkey );
    	else if(klen == DES3_KEY3_SIZE)
    		des3_set3key_dec( &ctx3, pkey );
    
    
        for(i = 0;i < nlen;i += 8)
        {
            des3_crypt_ecb(&ctx3, (pdata + i), (pout + i));
        }
        des3_free( &ctx3 );
        return 0;
    
    }
    /*
     * 3DES-CBC buffer encryption API
     */
    unsigned int des3_cbc_encrypt(unsigned char *pout,
    							  unsigned char *pdata,
    							  unsigned int nlen,
    							  unsigned char *pkey,
    							  unsigned int klen,
    							  unsigned char *piv)
    {
        des3_context ctx;
        unsigned char iv[8] = {0};
        unsigned char *pivb;
        unsigned char *tmp;
        unsigned int len;
    
        if(piv == NULL)
    		pivb = iv;
        else
        	pivb = piv;
    
        if(klen == DES3_KEY2_SIZE)
    		des3_set2key_enc( &ctx, pkey );
    	else if(klen == DES3_KEY3_SIZE)
    		des3_set3key_enc( &ctx, pkey );
    
        if(nlen % 8)
    	{
    		len = nlen + 8 - nlen % 8;
    		tmp = (unsigned char *)calloc(1, len);
    		memcpy(tmp, pdata, nlen);
    		des3_crypt_cbc( &ctx, 1, len, pivb, tmp, (pout));
    		free(tmp);
    	}
    	else
    	{
    		des3_crypt_cbc( &ctx, 1, nlen, pivb, pdata, (pout));
    	}
    	
        des3_free( &ctx );
        
        return nlen;
    
    
    }
    /*
     * 3DES-CBC buffer decryption API
     */
    unsigned int des3_cbc_decrypt(unsigned char *pout,
    							  unsigned char *pdata,
    							  unsigned int nlen,
    							  unsigned char *pkey,
    							  unsigned int klen,
    							  unsigned char *piv)
    {
    
        des3_context ctx;
        unsigned char iv[8] = {0};
        unsigned char *pivb;
    
    	if(nlen % 8)
    		return 1;
    		
        if(piv == NULL)
    		pivb = iv;
        else
        	pivb = piv;
    
    
        if(klen == DES3_KEY2_SIZE)
    		des3_set2key_dec( &ctx, pkey );
    	else if(klen == DES3_KEY3_SIZE)
    		des3_set3key_dec( &ctx, pkey );
    
        des3_crypt_cbc( &ctx, 0, nlen, pivb, pdata, (pout));
    	
        des3_free( &ctx );
        
        return 0;
    
    }
    

    这些函数接口可以直接调用,很方便,代码内容也比较清晰,结合DES的算法原理很容易理解

    //main函数测试
    int des_test_self()
    {
    	unsigned char buff[1024] = {0};
    	unsigned char data[1024] = {0x3F,0x12,0xE7,0xC0,0x2D,0x66,0x5A,0xB0,0xC4,0x2E,0x58,0xF1};
    	int ret,len,i;
    	
    //	len = MyStrToHex("3F12E7C02D665AB0C42E58F1", data);//不满8字节
    	len = strlen((char*)data);
    	for(i = 0;i < len;i++)
        {
            printf("%02X",data[i]);
        }
        printf("\r\n");
    
    	unsigned char key[16] = {0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF};
    	//DES ECB 加密
    	printf("DES ECB ENC::\r\n");
    	ret = des_ecb_encrypt(buff,data,len,key);
    	for(i = 0;i < ret;i++)
        {
            printf("%02X",buff[i]);
        }
        printf("\r\n");
    	//DES ECB 解密
    	printf("DES ECB DEC::\r\n");
    	memset(data,0,sizeof(data));
    	des_ecb_decrypt(data,buff,ret,key);
    	for(i = 0;i < ret;i++)
        {
            printf("%02X",data[i]);
        }
        printf("\r\n");
    
    	//DES CBC 加密
    	printf("DES CBC ENC::\r\n");
    	memset(buff,0,sizeof(buff));
    	des_cbc_encrypt(buff,data,ret,key,NULL);
    	for(i = 0;i < ret;i++)
        {
            printf("%02X",buff[i]);
        }
        printf("\r\n");
    
    	//DES CBC 解密
    	printf("DES CBC DEC::\r\n");
    	memset(data,0,sizeof(data));
    	des_cbc_decrypt(data,buff,ret,key,NULL);
    	for(i = 0;i < ret;i++)
        {
            printf("%02X",data[i]);
        }
        printf("\r\n");
    	printf("\r\n");
    
    
    	//3DES ECB 加密
    	printf("3DES ECB ENC::\r\n");
    	ret = des3_ecb_encrypt(buff,data,len,key,16);
    	for(i = 0;i < ret;i++)
        {
            printf("%02X",buff[i]);
        }
        printf("\r\n");
    	//3DES ECB 解密
    	printf("3DES ECB DEC::\r\n");
    	memset(data,0,sizeof(data));
    	des3_ecb_decrypt(data,buff,ret,key,16);
    	for(i = 0;i < ret;i++)
        {
            printf("%02X",data[i]);
        }
        printf("\r\n");
    
    	//3DES CBC 加密
    	printf("3DES CBC ENC::\r\n");
    	memset(buff,0,sizeof(buff));
    	des3_cbc_encrypt(buff,data,ret,key,16,NULL);
    	for(i = 0;i < ret;i++)
        {
            printf("%02X",buff[i]);
        }
        printf("\r\n");
    
    	//3DES CBC 解密
    	printf("3DES CBC DEC::\r\n");
    	memset(data,0,sizeof(data));
    	des3_cbc_decrypt(data,buff,ret,key,16,NULL);
    	for(i = 0;i < ret;i++)
        {
            printf("%02X",data[i]);
        }
        printf("\r\n");
    
    
    	return 0;
    }
    

    具体验证使用这个工具,内含DES和3DES的CBC算法的计算,和后边的博客中提到的其他算法的工具合集
    加密解密算法工具集

    展开全文
  • 3des加密算法C语言实现

    热门讨论 2013-10-25 18:10:14
    3DES加密算法C语言实现代码,很好很实用.
  • 用vs2012写的,可以直接运行想要代码的话,都在一个cpp文件中
  • c语言写的des加密算法程序,控制台,直接输入明文密钥,得出密文,再由密文密钥得到明文,可直接运行。void Char_to_Int(unsigned char in[],int out[],int len){for(int i=0;iout[i]=int(in[i]);}void Int_to_Char(int ...

    c语言写的des加密算法程序,控制台,直接输入明文密钥,得出密文,再由密文密钥得到明文,可直接运行。

    void Char_to_Int(unsigned char in[],int out[],int len)

    {

    for(int i=0;i

    out[i]=int(in[i]);

    }

    void Int_to_Char(int in[],unsigned char out[],int len)

    {

    for(int i=0;i

    out[i]=char(in[i]);

    }

    void B_to_H(int in[],unsigned char out[])

    {

    for(int i=0;i<16;i++)

    {

    int temp=in[i*4]*8+in[i*4+1]*4+in[i*4+2]*2+in[i*4+3];

    switch(temp)

    {

    case 10 :out[i]='A';break;

    case 11 :out[i]='B';break;

    case 12 :out[i]='C';break;

    case 13 :out[i]='D';break;

    case 14 :out[i]='E';break;

    case 15 :out[i]='F';break;

    default :out[i]=unsigned char(temp+48);break;

    }

    }

    }

    void H_to_B(unsigned char in[],int out[])

    {

    for(int i=0;i<16;i++)

    switch(in[i])

    {

    case 'A':out[i*4]=1;out[i*4+1]=0;out[i*4+2]=1;out[i*4+3]=0;break;

    case 'B':out[i*4]=1;out[i*4+1]=0;out[i*4+2]=1;out[i*4+3]=1;break;

    case 'C':out[i*4]=1;out[i*4+1]=1;out[i*4+2]=0;out[i*4+3]=0;break;

    case 'D':out[i*4]=1;out[i*4+1]=1;out[i*4+2]=0;out[i*4+3]=1;break;

    case 'E':out[i*4]=1;out[i*4+1]=1;out[i*4+2]=1;out[i*4+3]=0;break;

    case 'F':out[i*4]=1;out[i*4+1]=1;out[i*4+2]=1;out[i*4+3]=1;break;

    case '0':out[i*4]=0;out[i*4+1]=0;out[i*4+2]=0;out[i*4+3]=0;break;

    case '1':out[i*4]=0;out[i*4+1]=0;out[i*4+2]=0;out[i*4+3]=1;break;

    case '2':out[i*4]=0;out[i*4+1]=0;out[i*4+2]=1;out[i*4+3]=0;break;

    case '3':out[i*4]=0;out[i*4+1]=0;out[i*4+2]=1;out[i*4+3]=1;break;

    展开全文
  • DES加密算法C语言源码

    2018-06-06 09:12:58
    CPU卡读写时有外部认证,认证要用到3DES加密 CPU卡加密算法
  • #include<iostream.h> int IP[64] = { 58,50,42,34,26,18,10,2, 60,52,44,36,28,20,12,4, 62,54,46,38,30,22,14,6, 64,56,48,40,32,24,16,8, 57,49,41,33,25,17,9,1, 59,51,43,35,27,19,11,3, 61,53,45,37,29,21,13
  • AES、DES均为对称加密算法。文件中分别对应两个加密算法的C源码模块,可直接调用,有相关的注释。
  • DES-加密解密语言算法C语言实现文档带有完整的源代码,可加密字符串或者文件,已通过测试使用。
  • #includeint IP[64] = {58,50,42,34,26,18,10,2,60,52,44,36,28,20,12,4,62,54,46,38,30,22,14,6,64,56,48,40,32,24,16,8,57,49,41,33,25,17,9,1,59,51,43,35,27,19,11,3,61,53,45,37,29,21,13,5,63,55,47,39,31,23,...

    #include

    int IP[64] = {

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

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

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

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

    57,49,41,33,25,17,9,1,

    59,51,43,35,27,19,11,3,

    61,53,45,37,29,21,13,5,

    63,55,47,39,31,23,15,7

    };

    int IP_1[64] = {

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

    39,7,47,15,55,23,63,31,

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

    37,5,45,13,53,21,61,29,

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

    35,3,43,11,51,19,59,27,

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

    33,1,41,9,49,17,57,25

    };

    int E[48] = {

    32,1, 2, 3, 4, 5,

    4, 5, 6, 7, 8, 9,

    8, 9, 10,11,12,13,

    12,13,14,15,16,17,

    16,17,18,19,20,21,

    20,21,22,23,24,25,

    24,25,26,27,28,29,

    28,29,30,31,32,1

    };

    int P[32]={16 ,7 , 20 , 21 ,

    29,12 ,28 , 17 ,

    1, 15 ,23 , 26 ,

    5, 18 ,31 , 10 ,

    2, 8 , 24 , 14 ,

    32,27, 3 , 9 ,

    19,13, 30 , 6 ,

    22,11 ,4 , 25 };

    void Char_to_Int(unsigned char in[],int out[],int len)

    {

    for(int i=0;i

    out[i]=int(in[i]);

    }

    void Int_to_Char(int in[],unsigned char out[],int len)

    {

    for(int i=0;i

    out[i]=char(in[i]);

    }

    void B_to_H(int in[],unsigned char out[])

    {

    for(int i=0;i<16;i++)

    {

    int temp=in[i*4]*8+in[i*4+1]*4+in[i*4+2]*2+in[i*4+3];

    switch(temp)

    {

    case 10:out[i]='A';break;

    case 11:out[i]='B';break;

    case 12:out[i]='C';break;

    case 13:out[i]='D';break;

    case 14:out[i]='E';break;

    case 15:out[i]='F';break;

    default :out[i]=unsigned char(temp+48);break;

    }

    }

    }

    void H_to_B(unsigned char in[],int out[])

    {

    for(int i=0;i<16;i++)

    switch(in[i])

    {

    case 'A':out[i*4]=1;out[i*4+1]=0;out[i*4+2]=1;out[i*4+3]=0;break;

    case 'B':out[i*4]=1;out[i*4+1]=0;out[i*4+2]=1;out[i*4+3]=1;break;

    case 'C':out[i*4]=1;out[i*4+1]=1;out[i*4+2]=0;out[i*4+3]=0;break;

    case 'D':out[i*4]=1;out[i*4+1]=1;out[i*4+2]=0;ou

    展开全文
  • DES加密算法C语言实现

    2021-05-20 05:29:25
    DES加密算法C语言实现DES加密算法C语言实现更多更新更免费论文网,专业毕业设计论文,课程设计源代码,上机实习报告,实验报告请点击www.751com.cnDES加密算法C实现mac.c#include #include /** 程序描述: 加/解密公用...

    DES加密算法C语言实现

    DES加密算法C语言实现

    更多更新更免费论文网,专业毕业设计论文,课程设计源代码,上机实习报告,实验报告请点击www.751com.cn

    DES加密算法C实现

    mac.c

    #include  

    #include  

    /*

    * 程序描述:      加/解密公用函数

    *            decrypt / encrypt routine

    *

    */

    #define      u_char      unsigned char

    void FDES(u_char *key,u_char *text,u_char *mtext);

    void _FDES(u_char *key,u_char *mtext,u_char *text);

    void Fencrypt0(u_char *text,u_char *mtext);

    void Fdiscrypt0(u_char *mtext,u_char *text);

    void Fexpand0(u_char *in,u_char *out);

    void Fcompress0(u_char *out,u_char *in);

    void Fcompress016(u_char *out,u_char *in);

    void Fsetkeystar(u_char bits[64]);

    void FLS(u_char *bits,u_char *buffer,int count);

    void Fson(u_char *cc,u_char *dd,u_char *kk);

    void Fiip(u_char *text,u_char *ll,u_char *rr);

    void _Fiip(u_char *text,u_char *ll,u_char *rr);

    void FF(int n,u_char *ll,u_char *rr,u_char *LL,u_char *RR);

    void Fs_box(u_char *aa,u_char *bb);

    u_char C[17][28],D[17][28],K[17][48];

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

    * function:      DES

    * parameter:      u_char * key      ; key for encrypt

    *            u_char * text      ; plain text

    *            u_char * mtext      ; encipher result

    * return:      none

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

    void FDES(u_char *key,u_char *text,u_char *mtext)

    {

    u_char tmp[64];

    Fexpand0(key,tmp);

    Fsetkeystar(tmp);

    Fencrypt0(text,mtext);

    }

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

    * function:      DES

    * parameter:      u_char * key      ; key for encrypt

    *            u_char * mtext      ; encipher data

    *            u_char * text      ; plain data

    * return:      none

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

    void _FDES(u_char *key,u_char *mtext,u_char *text)

    {

    u_char tmp[64];

    Fexpand0(key,tmp);

    Fsetkeystar(tmp);

    Fdiscrypt0(mtext,text);

    }

    void Fencrypt0(u_char *text,u_char *mtext)

    {

    u_char ll[64],rr[64],LL[64],RR[64];

    u_char tmp[64];

    int i,j;

    Fiip(text,ll,rr);

    for (i=1;i<17;i++)

    {

    FF(i,ll,rr,LL,RR);

    for (j=0;j<32;j++)

    {

    ll[j]=LL[j];

    rr[j]=RR[j];

    }

    }

    _Fiip(tmp,rr,ll);

    Fcompress0(tmp,mtext);

    }

    void Fdiscrypt0(u_char *mtext,u_char *text)

    {

    u_char ll[64],rr[64],LL[64],RR[64];

    u_char tmp[64];

    int i,j;

    Fiip(mtext,ll,rr);

    for (i=16;i>0;i--)

    {

    FF(i,ll,rr,LL,RR);

    for (j=0;j<32;j++)

    {

    ll[j]=LL[j];

    rr[j]=RR[j];

    }

    }

    _Fiip(tmp,rr,ll);

    Fcompress0(tmp,text);

    }

    void Fexpand0(u_char *in,u_char *out)

    {

    int divide;

    int i,j;

    for (i=0;i<8;i++)

    {

    divide=0x80;

    for (j=0;j<8;j++)

    {

    *out++=(in/divide)&1;

    divide/=2;

    }

    }

    }

    void Fcompress0(u_char *out,u_char *in)

    {

    int times;

    int i,j;

    for (i=0;i<8;i++)

    {

    times=0x80;

    in=0;

    for (j=0;j<8;j++)

    {

    in+=(*out++)*times;

    times/=2;

    }

    }

    }

    void Fcompress016(u_char *out,u_char *in)

    {

    int times;

    int i,j;

    for (i=0;i<16;i++)

    {

    times=0x8;

    in='0';

    for (j=0;j<4;j++)

    {

    in+=(*out++)*times;

    times/=2;

    }

    }

    }

    int pc_1_cp[28]={

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

    int pc_1_dp[28]={

    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_2p[48]={

    14,17,11,24,1,5,

    3,28,15,6,21,10,

    23,19,12,4,26,8,

    16,7,27,20,13,2,

    41,52,31,37,47,55,

    30,40,51,45,33,48,

    44,49,39,56,34,53,

    46,42,50,36,29,32};

    int ls_countp[16]={

    1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};

    void Fsetkeystar(u_char bits[64])

    {

    int i,j;

    for (i=0;i<28;i++)

    C[0]=bits[pc_1_cp-1];

    for (i=0;i<28;i++)

    D[0]=bits[pc_1_dp-1];

    for (j=0;j<16;j++)

    {

    FLS(C[j],C[j+1],ls_countp[j]);

    FLS(D[j],D[j+1],ls_countp[j]);

    Fson(C[j+1],D[j+1],K[j+1]);

    }

    }

    void FLS(u_char *bits,u_char *buffer,int count)

    {

    int i,j;

    for (i=0;i<28;i++)

    {

    buffer=bits[(i+count)%28];

    }

    }

    void Fson(u_char *cc,u_char *dd,u_char *kk)

    {

    int i,j;

    u_char buffer[56];

    for (i=0;i<28;i++)

    buffer=*cc++;

    for (i=28;i<56;i++)

    buffer=*dd++;

    for (i=0;i<48;i++)

    *kk++=buffer[pc_2p-1];

    }

    int iip_tab_p[64]={

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

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

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

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

    57,49,41,33,25,17,9,1,

    59,51,43,35,27,19,11,3,

    61,53,45,37,29,21,13,5,

    63,55,47,39,31,23,15,7};

    int _iip_tab_p[64]={

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

    39,7,47,15,55,23,63,31,

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

    37,5,45,13,53,21,61,29,

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

    35,3,43,11,51,19,59,27,

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

    33,1,41,9,49,17,57,25};

    void Fiip(u_char *text,u_char *ll,u_char *rr)

    {

    int i,j;

    u_char buffer[64];

    u_char tmp[64];

    Fexpand0(text,buffer);

    for (i=0;i<32;i++)

    ll=buffer[iip_tab_p-1];

    for (i=0;i<32;i++)

    rr=buffer[iip_tab_p[i+32]-1];

    }

    void _Fiip(u_char *text,u_char *ll,u_char *rr)

    {

    int i,j;

    u_char tmp[64];

    for (i=0;i<32;i++)

    tmp=ll;

    for (i=32;i<64;i++)

    tmp=rr[i-32];

    for (i=0;i<64;i++)

    text=tmp[_iip_tab_p-1];

    }

    int e_r_p[48]={

    32,1,2,3,4,5,4,5,6,7,8,9,

    8,9,10,11,12,13,12,13,14,15,16,17,

    16,17,18,19,20,21,20,21,22,23,24,25,

    24,25,26,27,28,29,28,29,30,31,32,1};

    int local_PP[32]={

    16,7,20,21,29,12,28,17,

    1,15,23,26,5,18,31,10,

    2,8,24,14,32,27,3,9,

    19,13,30,6,22,11,4,25};

    int ccom_SSS_p[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,/* err on */

    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, /* err on */

    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, /* err on */

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

    void FF(int n,u_char *ll,u_char *rr,u_char *LL,u_char *RR)

    {

    int i,j;

    u_char buffer[64],tmp[64];

    for (i=0;i<48;i++)

    buffer=rr[e_r_p-1];

    for (i=0;i<48;i++)

    buffer=(buffer+K[n])&1;

    Fs_box(buffer,tmp);

    for (i=0;i<32;i++)

    buffer=tmp[local_PP-1];

    for (i=0;i<32;i++)

    RR=(buffer+ll)&1;

    for (i=0;i<32;i++)

    LL=rr;

    }

    void Fs_box(u_char *aa,u_char *bb)

    {

    int i,j,k,m;

    int y,z;

    u_char ss[8];

    m=0;

    for (i=0;i<8;i++)

    {

    j=6*i;

    y=aa[j]*2+aa[j+5];

    z=aa[j+1]*8+aa[j+2]*4+aa[j+3]*2+aa[j+4];

    ss=ccom_SSS_p[y][z];

    y=0x08;

    for (k=0;k<4;k++)

    {

    bb[m++]=(ss/y)&1;

    y/=2;

    }

    }

    }

    展开全文
  • des加密算法 c语言

    2011-05-28 12:16:33
    des加密算法 const static char ip[] = { //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,...
  • 转自:... 版权声明:本文为博主原创文章,未经博主允许不得转载。... DES和3DES加密算法C语言实现 记录DES和3DES加密算法最简洁易懂的C语言源码 主要是要用到C...
  • 它的出现主要是为了取代DES加密算法的,因为我们都知道DES算法的密钥长度是56Bit,因此算法的理论安全强度是2的56次方。 AES密码与分组密码Rijndael基本上完全一致,Rijndael分组大小和密钥大小都可以为128位、192...
  • Word格式完美整理DES实验报告实验目的实现DES算法。实验过程按照DES算法流程设计,具体实施详见附件。使用方法首先输入密钥,八位ASCII长,否则报错。然后输入读入文件名和写入文件名,必须以ASCII编码,否则不能...
  • DES加密解密算法 C语言源代码,STM32 51单片机可用。提高产品的安全性,RAM占用小。 /* DES加密,binput:明文,boutput:密文, bkey:密钥 */
  • des加密算法 C语言源码 基于对称密码学的加密算法 网络安全加密
  • NULL 博文链接:https://enefry.iteye.com/blog/1178394
  • 3DES Encryption algorithm Design and Implementation1、Hohai UniversityAbstract:The Data Encryption Standard DES is released in 1977 with the American National Standards Bureau, for the past 20 years,...
  • des加密算法c语言版)

    万次阅读 多人点赞 2018-06-27 17:04:02
    #include&amp;amp;amp;amp;amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;amp;amp;amp;amp;gt; //选择置换表PC-1 char PC1[8][7]= { {57,49,41,33,25,17,9}, {1,58,50,42,34,26,18}, ... {63,55,47,39,31,23

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,002
精华内容 1,200
关键字:

des加密算法c语言

c语言 订阅
友情链接: basicvectorclass.rar