C++ 128位 AES加密算法

最新推荐文章于 2023-03-30 20:20:35 发布
最新推荐文章于 2023-03-30 20:20:35 发布
阅读量1.2w 收藏 25
点赞数 1
分类专栏： VC 加密 文章标签： AES加密算法 AES 加密
VC 同时被 2 个专栏收录
23 篇文章 0 订阅
订阅专栏
加密
4 篇文章 0 订阅
订阅专栏
本文详细介绍了AES加密算法的实现细节，包括初始化、加密、解密等关键步骤，并通过实例展示了如何使用AES进行数据加密与解密。此外，文章还提供了AES算法核心功能的解释与应用案例，帮助读者理解并掌握这一重要的现代加密技术。
摘要由CSDN通过智能技术生成

转自：xelz’s blog

  • 声明文件 AES.h
#ifndef _AES_H_
#define _AES_H_

#include <Windows.h>

class CAES
{
public:
    /*
    * 功  能：初始化
    * 参  数：key — 密钥，必须是16字节(128bit)
    */
    CAES(const BYTE key[16]);
    ~CAES();

    /*
     * 功  能：加密，加密后的字节串长度只会是16字节的整数倍
     * 参  数：src_data — 需要加密的字节串，不允许为空
     *        src_len — src_data长度，不允许为0
     *        dst_data — 指向加密后字节串的指针，如果该指针为空或者dst_len小于加密后所需的字节长度，函数内部会自动分配空间
     *        dst_len — dst_data长度
     *        release_dst — 函数内部自动分配空间时是否删除现有空间
     * 返回值: 加密字节串长度
     */
    size_t Encrypt(IN const void* const src_data, IN size_t src_len, OUT void*& dst_data, IN size_t dst_len, IN bool release_dst = false);

    /*
    * 功  能：解密
    * 参  数：data — [IN] 需要解密的字节串，不允许为空
    *                [OUT]解密后的字节串
    *        len — 字节串长度，该长度必须是16字节(128bit)的整数倍
    */
    void Decrypt(IN OUT void* data, IN size_t len);

    /*
    * 功  能: 获取待加密的字节串被加密后字节长度
    * 参  数: src_len — 需要加密的字节串长度
    * 返回值: 加密后字节串长度 
    */
    size_t GetEncryptDataLen(IN size_t src_len) const;

private:
    // 对data前16字节进行加密
    void Encrypt(BYTE* data);
    // 对data前16字节进行解密
    void Decrypt(BYTE* data);
    // 密钥扩展
    void KeyExpansion(const BYTE* key);
    BYTE FFmul(BYTE a, BYTE b);
    // 轮密钥加变换
    void AddRoundKey(BYTE data[][4], BYTE key[][4]);
    // 加密字节替代
    void EncryptSubBytes(BYTE data[][4]);
    // 解密字节替代
    void DecryptSubBytes(BYTE data[][4]);
    // 加密行移位变换
    void EncryptShiftRows(BYTE data[][4]);
    // 解密行移位变换
    void DecryptShiftRows(BYTE data[][4]);
    // 加密列混淆变换
    void EncryptMixColumns(BYTE data[][4]);
    // 解密列混淆变换
    void DecryptMixColumns(BYTE data[][4]);

private:
    BYTE* encrypt_permutation_table_;   // 加密置换表
    BYTE* decrypt_permutation_table_;   // 解密置换表
    BYTE round_key_[11][4][4];          // 轮密钥
};

#endif // !_AES_H_
  • 实现文件 AES.cpp
#include "AES.h"
#include <assert.h>

CAES::CAES(const BYTE key[16])
    :encrypt_permutation_table_(new BYTE[256]),
    decrypt_permutation_table_(new BYTE[256])
{
    const BYTE encrypt_permutation_table[] = {
        0x63,0x7C,0x77,0x7B,0xF2,0x6B,0x6F,0xC5,0x30,0x01,0x67,0x2B,0xFE,0xD7,0xAB,0x76,
        0xCA,0x82,0xC9,0x7D,0xFA,0x59,0x47,0xF0,0xAD,0xD4,0xA2,0xAF,0x9C,0xA4,0x72,0xC0,
        0xB7,0xFD,0x93,0x26,0x36,0x3F,0xF7,0xCC,0x34,0xA5,0xE5,0xF1,0x71,0xD8,0x31,0x15,
        0x04,0xC7,0x23,0xC3,0x18,0x96,0x05,0x9A,0x07,0x12,0x80,0xE2,0xEB,0x27,0xB2,0x75,
        0x09,0x83,0x2C,0x1A,0x1B,0x6E,0x5A,0xA0,0x52,0x3B,0xD6,0xB3,0x29,0xE3,0x2F,0x84,
        0x53,0xD1,0x00,0xED,0x20,0xFC,0xB1,0x5B,0x6A,0xCB,0xBE,0x39,0x4A,0x4C,0x58,0xCF,
        0xD0,0xEF,0xAA,0xFB,0x43,0x4D,0x33,0x85,0x45,0xF9,0x02,0x7F,0x50,0x3C,0x9F,0xA8,
        0x51,0xA3,0x40,0x8F,0x92,0x9D,0x38,0xF5,0xBC,0xB6,0xDA,0x21,0x10,0xFF,0xF3,0xD2,
        0xCD,0x0C,0x13,0xEC,0x5F,0x97,0x44,0x17,0xC4,0xA7,0x7E,0x3D,0x64,0x5D,0x19,0x73,
        0x60,0x81,0x4F,0xDC,0x22,0x2A,0x90,0x88,0x46,0xEE,0xB8,0x14,0xDE,0x5E,0x0B,0xDB,
        0xE0,0x32,0x3A,0x0A,0x49,0x06,0x24,0x5C,0xC2,0xD3,0xAC,0x62,0x91,0x95,0xE4,0x79,
        0xE7,0xC8,0x37,0x6D,0x8D,0xD5,0x4E,0xA9,0x6C,0x56,0xF4,0xEA,0x65,0x7A,0xAE,0x08,
        0xBA,0x78,0x25,0x2E,0x1C,0xA6,0xB4,0xC6,0xE8,0xDD,0x74,0x1F,0x4B,0xBD,0x8B,0x8A,
        0x70,0x3E,0xB5,0x66,0x48,0x03,0xF6,0x0E,0x61,0x35,0x57,0xB9,0x86,0xC1,0x1D,0x9E,
        0xE1,0xF8,0x98,0x11,0x69,0xD9,0x8E,0x94,0x9B,0x1E,0x87,0xE9,0xCE,0x55,0x28,0xDF,
        0x8C,0xA1,0x89,0x0D,0xBF,0xE6,0x42,0x68,0x41,0x99,0x2D,0x0F,0xB0,0x54,0xBB,0x16
    };

    const BYTE decrypt_permutation_table[256] = {
        0x52,0x09,0x6A,0xD5,0x30,0x36,0xA5,0x38,0xBF,0x40,0xA3,0x9E,0x81,0xF3,0xD7,0xFB,
        0x7C,0xE3,0x39,0x82,0x9B,0x2F,0xFF,0x87,0x34,0x8E,0x43,0x44,0xC4,0xDE,0xE9,0xCB,
        0x54,0x7B,0x94,0x32,0xA6,0xC2,0x23,0x3D,0xEE,0x4C,0x95,0x0B,0x42,0xFA,0xC3,0x4E,
        0x08,0x2E,0xA1,0x66,0x28,0xD9,0x24,0xB2,0x76,0x5B,0xA2,0x49,0x6D,0x8B,0xD1,0x25,
        0x72,0xF8,0xF6,0x64,0x86,0x68,0x98,0x16,0xD4,0xA4,0x5C,0xCC,0x5D,0x65,0xB6,0x92,
        0x6C,0x70,0x48,0x50,0xFD,0xED,0xB9,0xDA,0x5E,0x15,0x46,0x57,0xA7,0x8D,0x9D,0x84,
        0x90,0xD8,0xAB,0x00,0x8C,0xBC,0xD3,0x0A,0xF7,0xE4,0x58,0x05,0xB8,0xB3,0x45,0x06,
        0xD0,0x2C,0x1E,0x8F,0xCA,0x3F,0x0F,0x02,0xC1,0xAF,0xBD,0x03,0x01,0x13,0x8A,0x6B,
        0x3A,0x91,0x11,0x41,0x4F,0x67,0xDC,0xEA,0x97,0xF2,0xCF,0xCE,0xF0,0xB4,0xE6,0x73,
        0x96,0xAC,0x74,0x22,0xE7,0xAD,0x35,0x85,0xE2,0xF9,0x37,0xE8,0x1C,0x75,0xDF,0x6E,
        0x47,0xF1,0x1A,0x71,0x1D,0x29,0xC5,0x89,0x6F,0xB7,0x62,0x0E,0xAA,0x18,0xBE,0x1B,
        0xFC,0x56,0x3E,0x4B,0xC6,0xD2,0x79,0x20,0x9A,0xDB,0xC0,0xFE,0x78,0xCD,0x5A,0xF4,
        0x1F,0xDD,0xA8,0x33,0x88,0x07,0xC7,0x31,0xB1,0x12,0x10,0x59,0x27,0x80,0xEC,0x5F,
        0x60,0x51,0x7F,0xA9,0x19,0xB5,0x4A,0x0D,0x2D,0xE5,0x7A,0x9F,0x93,0xC9,0x9C,0xEF,
        0xA0,0xE0,0x3B,0x4D,0xAE,0x2A,0xF5,0xB0,0xC8,0xEB,0xBB,0x3C,0x83,0x53,0x99,0x61,
        0x17,0x2B,0x04,0x7E,0xBA,0x77,0xD6,0x26,0xE1,0x69,0x14,0x63,0x55,0x21,0x0C,0x7D
    };

    memcpy(encrypt_permutation_table_, encrypt_permutation_table, 256);
    memcpy(decrypt_permutation_table_, decrypt_permutation_table, 256);
    KeyExpansion(key);
}

CAES::~CAES()
{
    if (encrypt_permutation_table_)
    {
        delete[]encrypt_permutation_table_;
        encrypt_permutation_table_ = 0;
    }

    if (decrypt_permutation_table_)
    {
        delete[]decrypt_permutation_table_;
        decrypt_permutation_table_ = 0;
    }
}

size_t CAES::Encrypt(IN const void *const src_data, IN size_t src_len, OUT void* &dst_data, IN size_t dst_len, IN bool release_dst)
{
    if (0 == src_data)
    {
        assert(src_data);
        return 0;
    }

    if (0 == src_len)
    {
        return 0;
    }

    const size_t len = GetEncryptDataLen(src_len);
    if (0 == dst_data)
    {
        dst_data = new BYTE[len];
    }
    else if (len > dst_len)
    {
        if (release_dst)
        {
            delete[]dst_data;
        }
        dst_data = new BYTE[len];
    }

    dst_len = len;

    memset(dst_data, 0, dst_len);
    memcpy(dst_data, src_data, src_len);

    for (size_t i = 0; i < dst_len; i += 16)
    {
        Encrypt(reinterpret_cast<BYTE*>(dst_data) + i);
    }

    return dst_len;
}

void CAES::Decrypt(IN OUT void* data, IN size_t len)
{
    if (0 == data || len % 16 != 0)
    {
        assert(data);
        assert(len % 16);
        return;
    }

    for (size_t i = 0; i < len; i += 16)
    {
        Decrypt(reinterpret_cast<BYTE*>(data) + i);
    }
}

size_t CAES::GetEncryptDataLen(IN size_t src_len) const
{
    if (src_len % 16 == 0)
    {
        return src_len;
    }
    else
    {
        return src_len + 16 - (src_len % 16);
    }
}

void CAES::Encrypt(BYTE* data)
{
    BYTE encrypt_data[4][4];
    for (int row_index = 0; row_index < 4; row_index++)
    {
        for (int col_index = 0; col_index < 4; col_index++)
        {
            encrypt_data[row_index][col_index] = data[col_index * 4 + row_index];
        }
    }

    AddRoundKey(encrypt_data, round_key_[0]);

    for (int i = 1; i <= 10; i++)
    {
        EncryptSubBytes(encrypt_data);
        EncryptShiftRows(encrypt_data);
        if (i != 10)
        {
            EncryptMixColumns(encrypt_data);
        }
        AddRoundKey(encrypt_data, round_key_[i]);
    }

    for (int row_index = 0; row_index < 4; row_index++)
    {
        for (int col_index = 0; col_index < 4; col_index++)
        {
            data[col_index * 4 + row_index] = encrypt_data[row_index][col_index];
        }
    }
}

void CAES::Decrypt(BYTE* data)
{
    BYTE decrypt_data[4][4];
    for (int row_index = 0; row_index < 4; row_index++)
    {
        for (int col_index = 0; col_index < 4; col_index++)
        {
            decrypt_data[row_index][col_index] = data[col_index * 4 + row_index];
        }
    }

    AddRoundKey(decrypt_data, round_key_[10]);

    for (int i = 9; i >= 0; i--)
    {
        DecryptShiftRows(decrypt_data);
        DecryptSubBytes(decrypt_data);
        AddRoundKey(decrypt_data, round_key_[i]);

        if (i)
        {
            DecryptMixColumns(decrypt_data);
        }
    }

    for (int row_index = 0; row_index < 4; row_index++)
    {
        for (int col_index = 0; col_index < 4; col_index++)
        {
            data[col_index * 4 + row_index] = decrypt_data[row_index][col_index];
        }
    }
}

void CAES::KeyExpansion(const BYTE* key)
{
    for (int row_index = 0; row_index < 4; row_index++)
    {
        for (int col_index = 0; col_index < 4; col_index++)
        {
            round_key_[0][row_index][col_index] = key[row_index + col_index * 4];
        }
    }

    // 轮常量
    const BYTE round_const_value[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36 };

    for (int i = 1; i <= 10; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            BYTE tmp[4];
            for (int row_index = 0; row_index < 4; row_index++)
            {
                tmp[row_index] = j ? round_key_[i][row_index][j - 1] : round_key_[i - 1][row_index][3];
            }

            if (j == 0)
            {
                BYTE table_index = tmp[0];
                for (int row_index = 0; row_index < 3; row_index++)
                {
                    tmp[row_index] = encrypt_permutation_table_[tmp[(row_index + 1) % 4]];
                }

                tmp[3] = encrypt_permutation_table_[table_index];
                tmp[0] ^= round_const_value[i - 1];
            }

            for (int row_index = 0; row_index < 4; row_index++)
            {
                round_key_[i][row_index][j] = round_key_[i - 1][row_index][j] ^ tmp[row_index];
            }
        }
    }
}

BYTE CAES::FFmul(BYTE a, BYTE b)
{
    BYTE b_power[4] = {b, 0, 0, 0};
    for (int i = 1; i < 4; i++)
    {
        b_power[i] = b_power[i - 1] << 1;
        if (b_power[i - 1] & 0x80)
        {
            b_power[i] ^= 0x1B;
        }
    }

    BYTE value = 0;
    for (int i = 0; i < 4; i++)
    {
        if ((a >> i) & 0x01)
        {
            value ^= b_power[i];
        }
    }

    return value;
}

void CAES::EncryptSubBytes(BYTE data[][4])
{
    for (int row_index = 0; row_index < 4; row_index++)
    {
        for (int col_index = 0; col_index < 4; col_index++)
        {
            data[row_index][col_index] = encrypt_permutation_table_[data[row_index][col_index]];
        }
    }
}

void CAES::EncryptShiftRows(BYTE data[][4])
{
    BYTE tmp[4];
    for (int row_index = 1; row_index < 4; row_index++)
    {
        for (int col_index = 0; col_index < 4; col_index++)
        {
            tmp[col_index] = data[row_index][(col_index + row_index) % 4];
        }

        for (int col_index = 0; col_index < 4; col_index++)
        {
            data[row_index][col_index] = tmp[col_index];
        }
    }
}

void CAES::EncryptMixColumns(BYTE data[][4])
{
    BYTE tmp[4];
    for (int col_index = 0; col_index < 4; col_index++)
    {
        for (int row_index = 0; row_index < 4; row_index++)
        {
            tmp[row_index] = data[row_index][col_index];
        }

        for (int row_index = 0; row_index < 4; row_index++)
        {
            data[row_index][col_index] = FFmul(0x02, tmp[row_index])
                ^ FFmul(0x03, tmp[(row_index + 1) % 4])
                ^ FFmul(0x01, tmp[(row_index + 2) % 4])
                ^ FFmul(0x01, tmp[(row_index + 3) % 4]);
        }
    }
}

void CAES::AddRoundKey(BYTE data[][4], BYTE key[][4])
{
    for (int col_index = 0; col_index < 4; col_index++)
    {
        for (int row_index = 0; row_index < 4; row_index++)
        {
            data[row_index][col_index] ^= key[row_index][col_index];
        }
    }
}

void CAES::DecryptSubBytes(BYTE data[][4])
{
    for (int row_index = 0; row_index < 4; row_index++)
    {
        for (int col_index = 0; col_index < 4; col_index++)
        {
            data[row_index][col_index] = decrypt_permutation_table_[data[row_index][col_index]];
        }
    }
}

void CAES::DecryptShiftRows(BYTE data[][4])
{
    BYTE tmp[4];
    for (int row_index = 1; row_index < 4; row_index++)
    {
        for (int col_index = 0; col_index < 4; col_index++)
        {
            tmp[col_index] = data[row_index][(col_index - row_index + 4) % 4];
        }

        for (int col_index = 0; col_index < 4; col_index++)
        {
            data[row_index][col_index] = tmp[col_index];
        }
    }
}

void CAES::DecryptMixColumns(BYTE data[][4])
{
    BYTE tmp[4];
    for (int col_index = 0; col_index < 4; col_index++)
    {
        for (int row_index = 0; row_index < 4; row_index++)
        {
            tmp[row_index] = data[row_index][col_index];
        }

        for (int row_index = 0; row_index < 4; row_index++)
        {
            data[row_index][col_index] = FFmul(0x0e, tmp[row_index])
                ^ FFmul(0x0b, tmp[(row_index + 1) % 4])
                ^ FFmul(0x0d, tmp[(row_index + 2) % 4])
                ^ FFmul(0x09, tmp[(row_index + 3) % 4]);
        }
    }
}
  • 应用举例

#include "AES.h"

int main()
{
    byte key[] = { 0x6E, 0x66, 0xAE, 0x0B,
        0xE7, 0x29, 0x41, 0xEB,
        0xA6, 0x53, 0x10, 0x21,
        0x13, 0x76, 0x08, 0x2E
    };

    char src[] = "my test";
    printf("data before encryption. len = [%u]:\n", strlen(src));
    for (UINT i = 0; i < strlen(src); i++)
    {
        printf("0x%02X ", src[i]);
    }
    printf("\n\n");

    void* dst = 0;
    CAES aes(key);
    const UINT dst_len = aes.Encrypt(reinterpret_cast<void*>(src), sizeof(src), dst, 0);
    printf("encrypted data. len = [%u]:\n", dst_len);
    for (UINT i = 0; i < dst_len; i++)
    {
        printf("0x%02X ", reinterpret_cast<BYTE*>(dst)[i]);
    }
    printf("\n\n");

    aes.Decrypt(dst, dst_len);
    printf("decrypted data:\n");
    for (UINT i = 0; i < dst_len; i++)
    {
        printf("0x%02X ", reinterpret_cast<BYTE*>(dst)[i]);
    }
    printf("\n\n");

    delete[]dst;

    return 0;
}

data before encryption. len = [7]:
0x6D 0x79 0x20 0x74 0x65 0x73 0x74

encrypted data. len = [16]:
0x89 0xA7 0x21 0x86 0xBD 0xA3 0xDC 0x5E 0x9A 0x5A 0x8D 0x0B 0x43 0xB2 0xBC 0xBD

decrypted data:
0x6D 0x79 0x20 0x74 0x65 0x73 0x74 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

tobelove`默
关注
专栏目录
AES加密算法(C++实现,附源码)
04-24
AES加密算法(C++实现,附源码) 更多免费资源： http://cleopard.download.csdn.net
AES-128加密解密源码及算法详解。
09-24
一份非常不错的AES加密解密原理及算法学习的资料。所附源码经本人实测，完全无误。并且可移植性强，可移植到任意平台运行，从而为系统添加AES加密解密的功能。
封装成C++类的AES128位加密算法
11-02
封装成C++类的AES128位加密算法，自己把AES128位加密算法封装成一个C++类，包括加密算法和解密算法，并写了一个例子，方便使用！
AES-128算法实现（附C++源码）
物联黄同学的博客
05-11 7436
针对AES-128 算法的C++实现做一个简单的报告
AES（128bit十六进制的加密）
qq_45031509的博客
06-11 7891
AES加密算法的实现过程
AES的C++实现(128位密钥)
Voice of Veiz♨来自Veiz的声音
06-18 4664
//  写了一个AES的C++实现，仅支持128位密钥， 写得匆忙，不够规范，仅供参考。//    AES.h#ifndef AES_H_#define AES_H_#include #include using namespace std;class AES{public:    typedef unsigned char    byte;    static const int KEY_SIZ
密码学——128位AES算法（C/C++实现）
Rayme629的博客
03-30 6455
使用C/C++实现128位AES算法
[密码学] C++ 实现 AES128 加密算法
weixin_30784945的博客
12-20 421
概述 清理邮箱的时候翻出来的。 很久以前写的，理解加密算法用的，当时记得是还撸了两天晚上撸出来的代码，放上来留个纪念好啦。 补上Tutorial，就当考古吧。 写代码时候毕竟年轻，问题也不少，但现在这东西还能用！ 文件link，utf-8编码。 编译 使用gcc编译(g++也可以)即可，需要头文件为： #include <cstdio> #include <cstring&gt...
AES 128位加解密C++源码(加盐)
01-22
AES 128位加解密C++源码(加盐)
AES-128加密算法，C语言实现
04-25
该文件是AES加密算法C语言的实现，在STM32平台验证通过，ECB加密方式，方便移植。
C++ AES算法ECB模式包含128,192,256三种密钥
11-09
C++ AES算法ECB模式包含128,192,256三种密钥
128位AES算法对文件进行加密解密（秘钥库自动生成的秘钥来加密）
04-12
用JAVA写得简单文件加密解密程序，不需要用户输入加密密码，自动生成秘钥来对文件加密，但没有设置文件保存位置的功能，加密后的文件只能与原文件在同一位置，解密后文件的保存位置只能保存在加密文件所在的位置
AES128位加密过程详解
09-25
好东西来VCKBASE好长时间了，从没做过贡献，今天用到AES加密算法，在GOOGLE里好像还没找到C++的AES代码，所以就由C#版照搬了一个类出来，只为方便大家使用，大家不要骂我抄袭哦，版权还是人家C#版的，有BUG mail:jruinet@163.com,在VC7.1下编译调试成功，下面是源代码，你们自已看着办吧~：） http://blog.vckbase.com/Files/jruinet/aesCPP.rar 也可从这里下载
128位AES加密算法C语言实现
11-26
用C语言实现的128位AES加密算法，可以运行在JAVA的JNI 中AIS加密算法c语言实现代码 nt cnt for(ent =0: cnt< 8: cnt++) BvtcToBit(*(ch+cnt), bit+(ent<<3)) return /将二进制位串转为长度为8的字符串水 int Bit64ToChar8 (ElemType bitL64, ElemType ch18) int cnt memset(ch, 0, 8) for(ent-0: cnt<8: cnt++i BitToByte(bit+(cnt<<3), ch+cnt) return 0 /*生成子密钥 int DES Make Subkeys(ElemType key _64, ElemType subkeys [16][48]) ElemType temp 56 int cnt DES PCI Transform(key,temp):/*PCI置换* for(cnt=0;cnt<16;cnt+-){*16轮跌代,产生16个子密钥米 DES ROL(tenp, MOVE TIMES[cnt]);循坏左移* DES PC2 Transform(temp, subkeys cnt]);/PC2置换,产生子密钥体 return o /*密钥置換1*/ int DES PCI Transform(ElemType key [64, ElemType tempts[56])t int cnt for(cnt=0: cnt( 56 cnt++) )empts[cnt]= key[ Ilant] r巳turn /*密钥置換2* int DES PC2 Transform(Elem Type key [56], ElemType tempts[48])i t cnt for(ent =0: cnt< 48: cnt+)I )pbts [cnt]= key [PC 2[cnt]] return /*循环左移*/ int DES ROL (Elem Type data[56], int time)t Elem l'ype temp _56 /*保存将要循环栘动到右边的位* memcpy(temp, data, time) memcpy(temg-time, data+28, time) /*前28位移动 (data-28-time, temp, time) /*后28位移动* memcpy(data 28, data+28+time, 28-time memcpy (data-56-time, temp+time, time) return o /*P置换*/ int DES IP) Iransform(Elemlype data[64)[ ElemType temp _64]: for(cnt templet- datalIP Tablelcnt」」 memcpy(data, temp, 64) return o 第3页 AIS加密算法c语言实现代码 /*IP逆置換* int DES IP 1 Transform(ElemType data[64)( int cnt ElemType temp _64 for(cnt =0: cnt 64: cnt+-)i templet」- dataLIP1 Tablelcrt]」 memcpy(data, temp, 64) return o /*扩展置换*/ int DES E Transform(ElemType data[48])( Int cn ElemType temp48」 for(ent-0: cnt 48: cnt-) temp lent= datale Tablelent memcpy( data, temp, 48 return o P置换 int DES P Transform(ElemType data[32])( t ElemType temp_32] for(ent =0; cnt 32; cnt+-) temp ent-datalP Tablel 11 me.mcpy(data, temp, 32) return 0 /水异或* int DES XOR(Elem Type R[48, Elem Type L[48], int count)I int cnt for(cnt-0: cnt< count: cnt++)i RIant]= lent] return 0 /*S盒置换*/ int DES SBOX (Elem Type data[48]) int cnt int line, row, output int curl, cur for(ent=0; cnt( 8: cnt++i curl cnt:6 cur2= cnt<<2 /*计算在S盒中的行与列来 line=(data cur1<<1)+ data[ cur1+5 row=(data[cur1+1]<<3)+(data[cur1+2]<<2) +(data「cur1-31<<1)+data「cur1+41 output s[cnt][line]trow] /*化为2进制*/ data[cur2]=(output&0X08)>>3 data[cur2+1]=(output&0X04)>>2 data (output&0X02)>1 datalcur 2+3= output&0x01 return o 交换 int DES Swap(ElemType left[32], ElemType right [32]) memcpy(temp, left, 32 memcpy(left, right, 32 memcpy (right, temp, 32 return o 第4页 AIS加密算法c语言实现代码 /*加密单个分组 int DES EncryptBlockElem Type plainBlock[8, ElemType subKeys[l6][48, ElemType cipherBlock[8])I ElemT'ype plainTs [54] ElemType copyRight[48] int cnt Char8ToBit64(plainBlock, plairBits) /米初始置换(IP置换)* DES IP Transform(plainBits /*16轮迭代* for(cnt=0: cnt< 16: cnt+-) memcpy(copyRight, plainBits- 32, 32 /*将右半部分进行扩展置换,从32位扩展到48位*/ DES E Trans form(copyRight) /*将右半部分与子密钥进行异或操作 DES XOR (copy Righ 48) /*异或结果进入S盒,输出32位结果*/ DES SBOX (copyRight) /P置换 DES P Transform(copyRight) /*将明文左半部分与右半部分进行异或* DES XOR (plainBits, copyRight, 32) 最终完成左右部的交换* DES Swap(plainBits, plainBits-32) /逆初始置换(IPI置换)* DES IP 1 Transform (plainBits) Bit64ToChar8(plainBits, cipherBlock) turn o /*解密单个分组 int DES DecryptBlock(ElemType cipherBlock[8, ElemType subKeys[16] 18], ElemType plainBlock [81) ElemType cipherBits[ 641 Elem Type copy Right [48] int cnt Char8ToBit64(cipherBlock, cipherBits) /初始置换(IP置换)* DES IP Transform(cipherBits /*16轮迭代*/ for(cnt-15: cnt >-0: cnt--)i memcpy(copyRight, cipherBits+32, 32 /*将右半部分进行扩展置换,从32位扩展到48位 DES T Trans form(copyright) /*将右半部分与子密钥进行异或操作 DES XOR(copy Right, subKeys [ent], 48) /*异或结果进入S盒,输出32位结果* DES SBOX(copyRight) /米P置换* DES P Transform(copyright) /*将明文h半部分与右半部分进行异或* DES XOR (cipherBits, copy Right, 32) f(cnt /米最终完成左右部的交换* DES Swap(cipherBits, cipherBits+32) /*逆初始置换(IP1置换)* DES IP 1 Transform(cipherBits) Bit64ToChar8(cipherBits, plainBlock) return 0: *加密文件 int DES Encrypt (char xplainFile, char *keyStr, char *cipherFile)t FILE xplain, i*cipher; int count ElcmType plainBlock[81, ciphcrBlock [8, keyBlock 8 第5页 AIS加密算法c语言实现代码 Elem Type bEy 64] ElemType subKeys[16][18] if((plain- fopen(plainFilc, " rb"))--NULL) return Plain FILe OPEN ERROR return CIPHER FILE OPEN ERROR: ))== NULL)( if ((cipher fopen(cipherFile, wb /设置密钥 memcpy (keyBlock, key Str, 8) 将密钥转换为二进制流* Char8ToBit64(keyBlock, bKcy /牛成子密钥* DES Make SubKeys(bEy, subKeys while(!feof plain))( /*每次读8个字节,并返回成功读取的字节数* if((count- fread(plainBlock, sizeof(char),8, plain)) 8){ DES EncryptBlock (plainBlock, subKeys, cipherBlock f(count)[ /*填充*/ memset(plainBlock ount, \0, 7- count) /*最后一个字符休存包括最后一个字符在内的所填充的字符数量水 plainblockl7-8-count DES EncryptBlock (plainBlock, subkeys, cipherBlock fwrite(cipherBlock, sizeof (char), 8, cipher) fclose (plain) f'c. lose(cipher return oK /*解密文件* int DES Decrypt(char *cipherFile, char *key Str, char xplainFile)i FILE* plain,米 cipher int count, times 0 long fileLen Eleml'ype plainBlock [8], cipherBlock[8], keyBlock[8 ElemType bEy _6 ElemType subKeys[16][48] if ((cipher fopen(cipherFile, rb ))= NULL)[ return CIPHEr FILe OPEN ERROR if((plain= fopen(plainFile, wb" ))= NULL) rcturn plain FIle OPEN ERROR /*设置密钥* memcpy(key Block, keyStr, 8) /将密钥转换为二进制流* Char8ToBit64 (keyBlock, bKey) /水生成子密钥* ES Make SubKeys(bKey subKeys) /取文什长度*/ fseek( cipher,0, SEEK END);/将文件指针置尾 fi lelen= ftel l( cipher);/*取文件指针当前位置*/ rewind( CIpher);/*将文件指针重指向文件头* while(1)i 密文的字节数一定是8的整数倍* fread(cipherBlock, sizeof(char), 8, cipher DES DecryptBlock(cipherBlock, subKeys, plainBlock) times +-8 if(times< fileLen fwrite(plainBlock, sizeof(char), 8, plain) /*判断末尾是否被填充米 if(plainBlock 71< 8)i 第6页 AIS加密算法c语言实现代码 for(count=8- plainBlock[7]; count< 7; count++)( if(plainBlock[ count!='\0i break if( count==7){/*有填充* fwrite(plairBlock, sizeof (char), 8- plainBlockL7, plain) else{/*无填充 fwrite(plainBlock, sizeof(char), 8, plain) t'close ( plain) fclose(cipher) return OK int main() clock t a, b a= clockO DES Encrypt( 1. txt, key. txt, 2. txt b=clock o printf("加密消耗%毫秒Ⅶn",b-a); system("pause") a= clock( DES Decrypt( 2. txt, key. txt", 3. txt") printf("解密消耗%毫秒、n",o-a) getcharo return 第7页
c++语言实现AES加密算法代码.zip
最新发布
11-10
SummerMVP2020-04-16 17:32:30原c++语言实现AES加密算法代码分享 项目描述 AES的实现 1. 只要求实现块长为 128 位、密钥长为 128 位的 AES，分别实现 ECB、CBC、CFB、OFB 这四种操作 模式。每种操作模式都有一组...
AESjiami.rar_AES 算法_AES加密_AES加密算法_AES加密算法c++_AES算法
09-24
AES（Advanced Encryption ...总之，AES加密算法是现代密码学中的重要组成部分，其在C++中的实现需要理解加密原理，并合理运用第三方库。通过学习和实践，你可以掌握这一强大的工具，为你的项目提供坚实的安全保障。
AES加密算法(C++实现,附源码)（2）.pdf
07-10
密钥扩展是AES加密算法中的一个重要部分，它将用户提供的原始密钥（128位、192位或256位）扩展为足够数量的128位轮密钥，以进行多轮加密操作。在C++代码中，`AES::KeyExpansion`函数负责这个任务。首先，原始密钥被...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值