基于ECB模式-AES算法文件加解密工具（C语言实现、含图形化界面设计）

最新推荐文章于 2024-07-11 16:07:10 发布
最新推荐文章于 2024-07-11 16:07:10 发布
阅读量424 收藏 4
点赞数 3
分类专栏： 密码学 文章标签： c语言 密码学 个人开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_74968000/article/details/139951103
版权

编程语言以及库的使用

C语言、图形化界面设计使用EasyX库实现。

工具实现的功能

用户可以选择任意一文件上传到工具并对这个文件进行加密或者解密操作，输入任意128bits加解密密钥。加密或者解密结果的结果会保存在一个新创建的文件中，新创建的文件保存位置和名称都由使用者确定。

源代码

#define _CRT_SECURE_NO_WARNINGS
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
#include <ctype.h>
#include <windows.h>
#include <stdlib.h>

#define BUTTON_WIDTH 300
#define BUTTON_HEIGHT 60
#define BUTTON_SPACING 20
#define WIN_WIDTH 880
#define WIN_HEIGHT 660

RECT uploadButton = { 50, 50, 50 + 300, 50 + 60 };
RECT encodeButton = { 50, 150, 50+300, 150 + 60 };
RECT decodeButton = { 450, 150, 450+300, 150 + 60 };
RECT saveButton = { 450, 50, 450 + 300, 50 + 60 };
RECT keyButton = {600, 280, 600+150 , 280+40 };

char inputFilePath[MAX_PATH] = "";
char outputFilePath[MAX_PATH] = "";

void drawButton(RECT rect, const char* text, int isHovered) {
    int borderColor = isHovered ? LIGHTBLUE : DARKGRAY;
    int fillColor = isHovered ? LIGHTCYAN : LIGHTGRAY;

    setlinecolor(borderColor);
    setfillcolor(fillColor);
    fillroundrect(rect.left, rect.top, rect.right, rect.bottom, 10, 10);
    rectangle(rect.left, rect.top, rect.right, rect.bottom);

    settextstyle(24, 0, "Arial");
    settextcolor(BLACK);
    drawtext(text, &rect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
}

unsigned char SBOX[256] = {
    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
};
unsigned char R_SBOX[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
};
unsigned char Rcon[10] = {
    0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36
};
unsigned char RoundKey[11 * 16];
void encrypt(unsigned char* text);
void decrypt(unsigned char* text);
void AES_encrypt(unsigned char* RoundText);
void AES_decrypt(unsigned char* RoundText);
void keyExpansion(unsigned char* key);
void AddRoundKey(unsigned char* RoundText, int round);
void ByteSub(unsigned char* RoundText);
void ShiftRow(unsigned char* RoundText);
void MixColumn(unsigned char* RoundText);
void InvByteSub(unsigned char* RoundText);
void InvShiftRow(unsigned char* RoundText);
void InvMixColumn(unsigned char* RoundText);
unsigned char hexCharToByte(char high, char low);
void encodefile(FILE* input_file, FILE* output_file);
void decodefile(FILE* input_file, FILE* output_file);
BOOL openFileDialog(char* filePath);
BOOL saveFileDialog(char* filePath);
void drawciphertext();
void drawcleartext();
void textprint(FILE* file, int size1, int size2);
unsigned char xtime2(unsigned char x);
unsigned char xtime3(unsigned char x);
unsigned char xtime4(unsigned char x);
unsigned char xtime8(unsigned char x);
unsigned char xtime9(unsigned char x);
unsigned char xtimeB(unsigned char x);
unsigned char xtimeD(unsigned char x);
unsigned char xtimeE(unsigned char x);
char high, low;
unsigned char key[16];
int choice, read_size;
unsigned char text[16];
unsigned char  temp[16];
char input_filename[256];
char output_filename[256];
int main()
{
   
    initgraph(WIN_WIDTH,WIN_HEIGHT);
    setbkcolor(RGB(255,255,255));
    cleardevice();
    drawciphertext();
    drawcleartext();
    int isHoveredUpload = 0;
    int isHoveredEncode = 0;
    int isHoveredDecode = 0;
    int isHoveredSave = 0;
    int isHoveredKey = 0;
    while (1) 
    { 
        BeginBatchDraw();
        if (MouseHit()) {
            MOUSEMSG msg = GetMouseMsg();
            POINT pt = { msg.x, msg.y };

            if (msg.uMsg == WM_MOUSEMOVE) {
                isHoveredUpload = PtInRect(&uploadButton, pt);
                isHoveredEncode = PtInRect(&encodeButton, pt);
                isHoveredDecode = PtInRect(&decodeButton, pt);
                isHoveredSave = PtInRect(&saveButton, pt);
                isHoveredKey = PtInRect(&keyButton, pt);
            }

            if (msg.uMsg == WM_LBUTTONDOWN) {
                if (PtInRect(&uploadButton, pt)) {
                    if (openFileDialog(inputFilePath)) {
                        
                        FILE* input_file = fopen(inputFilePath, "rb");
                        textprint(input_file,55 , 290 );
                    }
                }
                else if (PtInRect(&saveButton, pt)) {
                    if (saveFileDialog(outputFilePath)) {
                        
                    }

                }
                else if (PtInRect(&encodeButton, pt)) {
                    if (inputFilePath[0] != '\0' && outputFilePath[0] != '\0') {
                        FILE* input_file = fopen(inputFilePath, "rb");
                        FILE* output_file = fopen(outputFilePath, "wb+");
                        encodefile(input_file,output_file);
                        rewind(output_file);
                        textprint(output_file,55,460);
                        fclose(input_file);
                        fclose(output_file);
                    }
                    else {
                        MessageBox(NULL, "Please select input and output files first!", "Error", MB_OK);
                    }
                }
                else if (PtInRect(&decodeButton, pt)) {
                    if (inputFilePath[0] != '\0' && outputFilePath[0] != '\0') {
                        FILE* input_file = fopen(inputFilePath, "rb");
                        FILE* output_file = fopen(outputFilePath, "wb+");
                        decodefile(input_file,output_file);
                        rewind(output_file);
                        textprint(output_file, 55, 460);
                        fclose(input_file);
                        fclose(output_file);
                    }
                    else {
                        MessageBox(NULL, "Please select input and output files first!", "Error", MB_OK);
                    }
                }
                else if (PtInRect(&keyButton, pt)) {
                    InputBox((char*)key, 100, "请输入128bits加解密密钥");
                    keyExpansion(key);
                }
            }
        }
        drawButton(uploadButton, "选择上传文件", isHoveredUpload);
        drawButton(saveButton, "选择保存文件", isHoveredSave);
        drawButton(encodeButton, "文件加密", isHoveredEncode);
        drawButton(decodeButton, "文件解密", isHoveredDecode);
        drawButton(keyButton, "输入密钥", isHoveredKey);
        EndBatchDraw(); 
    }
    closegraph();
    return 0;
}
void drawciphertext() {
    setcolor(RGB(0,0,0));
    rectangle(50, 280, 50 + 500, 280 + 100);
    settextcolor(RGB(0,0,0));
    outtextxy(50,260,"上传文件的前200bits");
}
void drawcleartext() {
    setcolor(RGB(0, 0, 0));
    rectangle(50, 450, 50 + 500, 450 + 100);
    settextcolor(RGB(0, 0, 0));
    outtextxy(50, 430, "加解密文件的前200bits");
}
void textprint(FILE* file, int size1, int size2)
{
    char temptext[26], tempc[1];
    int rsize, i = 0;
    while ((rsize = fread(tempc, 1, 1, file)) == 1 && i < 25) {
        temptext[i] = tempc[0];
        i++;
    }
    temptext[i] = '\0';
    settextcolor(RGB(0, 0, 0));
    outtextxy(size1, size2, temptext);
}
BOOL openFileDialog(char* filePath)
{
    OPENFILENAME ofn;
    ZeroMemory(&ofn, sizeof(ofn));
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = NULL;
    ofn.lpstrFile = filePath;
    ofn.lpstrFile[0] = '\0';
    ofn.nMaxFile = MAX_PATH;
    ofn.lpstrFilter = "All\0*.*\0Text\0*.TXT\0";
    ofn.nFilterIndex = 1;
    ofn.lpstrFileTitle = NULL;
    ofn.nMaxFileTitle = 0;
    ofn.lpstrInitialDir = NULL;
    ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
    return GetOpenFileName(&ofn);
}
BOOL saveFileDialog(char* filePath) {
    OPENFILENAME ofn;
    ZeroMemory(&ofn, sizeof(ofn));
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = NULL;
    ofn.lpstrFile = filePath;
    ofn.lpstrFile[0] = '\0';
    ofn.nMaxFile = MAX_PATH;
    ofn.lpstrFilter = "All\0*.*\0Text\0*.TXT\0";
    ofn.nFilterIndex = 1;
    ofn.lpstrFileTitle = NULL;
    ofn.nMaxFileTitle = 0;
    ofn.lpstrInitialDir = NULL;
    ofn.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
    return GetSaveFileName(&ofn);
}
void encodefile(FILE* input_file, FILE* output_file)
{
    while ((read_size = fread(temp, 1, 16, input_file)) == 16) {
        for (int i = 0; i < 16; i++)
        {
            text[i] = temp[i];
        }

        encrypt(text);

        for (int i = 0; i < 16; i++)
        {
            fprintf(output_file, "%02x", text[i]);
        }
    }
    if (read_size < 16 && read_size != 0)
    {
        for (int i = read_size; i < 15; i++)
        {
            temp[i] = 0x00;
        }
        temp[15] = (unsigned char)(16 - read_size);
        for (int i = 0; i < 16; i++)
        {
            text[i] = temp[i];
        }

        encrypt(text);

        for (int i = 0; i < 16; i++)
        {
            fprintf(output_file, "%02x", text[i]);
        }
    }
}

void decodefile(FILE* input_file, FILE* output_file)
{
    unsigned char detext[16];
    size_t detext_index = 0;
    while (fscanf(input_file, "%1[0-9a-fA-F]%1[0-9a-fA-F]", &high, &low) == 2) {
        detext[detext_index++] = hexCharToByte(high, low);
        if (detext_index == 16)
        {
            decrypt(detext);
            for (int i = 0; i < 16; i++)
            {
                if (detext[i] == 0x00)
                {
                    break;
                }
                fprintf(output_file, "%c", detext[i]);
            }
            detext_index = 0;
        }
    }
}
unsigned char hexCharToByte(char high, char low) {
    unsigned char byte = 0;

    if (isdigit(high)) {
        byte |= (high - '0') << 4;
    }
    else if (isxdigit(high)) {
        byte |= (toupper(high) - 'A' + 10) << 4;
    }

    if (isdigit(low)) {
        byte |= (low - '0');
    }
    else if (isxdigit(low)) {
        byte |= (toupper(low) - 'A' + 10);
    }

    return byte;
}
void encrypt(unsigned char* text)
{
    AES_encrypt(text);

}
void decrypt(unsigned char* text)
{
    AES_decrypt(text);

}
void keyExpansion(unsigned char* key)
{
    int i, j;
    unsigned char temp[4], t;
    for (i = 0; i < 4; i++)
        for (j = 0; j < 4; j++)
            RoundKey[i * 4 + j] = key[i * 4 + j];
    while (i < 4 * 11)
    {
        for (j = 0; j < 4; j++)
            temp[j] = RoundKey[4 * (i - 1) + j];
        if (i % 4 == 0)
        {
            t = temp[0]; temp[0] = temp[1]; temp[1] = temp[2]; temp[2] = temp[3]; temp[3] = t;
            for (j = 0; j < 4; j++)
                temp[j] = SBOX[temp[j]];
            temp[0] ^= Rcon[i / 4 - 1];
        }
        for (j = 0; j < 4; j++)
            RoundKey[4 * i + j] = RoundKey[4 * (i - 4) + j] ^ temp[j];
        i++;
    }
}
void ByteSub(unsigned char* RoundText)
{
    for (int i = 0; i < 16; i++)
        RoundText[i] = SBOX[RoundText[i]];
}
void InvByteSub(unsigned char* RoundText)
{
    for (int i = 0; i < 16; i++)
        RoundText[i] = R_SBOX[RoundText[i]];
}
void ShiftRow(unsigned char* RoundText)
{
    unsigned char t;
    //row1
    t = RoundText[1]; RoundText[1] = RoundText[5]; RoundText[5] = RoundText[9]; RoundText[9] = RoundText[13]; RoundText[13] = t;
    //row2
    t = RoundText[2]; RoundText[2] = RoundText[10]; RoundText[10] = t;
    t = RoundText[6]; RoundText[6] = RoundText[14]; RoundText[14] = t;
    //row3
    t = RoundText[15]; RoundText[15] = RoundText[11]; RoundText[11] = RoundText[7]; RoundText[7] = RoundText[3]; RoundText[3] = t;
}
void InvShiftRow(unsigned char* RoundText)
{
    unsigned char t;
    //row1
    t = RoundText[13]; RoundText[13] = RoundText[9]; RoundText[9] = RoundText[5]; RoundText[5] = RoundText[1]; RoundText[1] = t;
    //row2
    t = RoundText[2]; RoundText[2] = RoundText[10]; RoundText[10] = t;
    t = RoundText[6]; RoundText[6] = RoundText[14]; RoundText[14] = t;
    //row3
    t = RoundText[3]; RoundText[3] = RoundText[7]; RoundText[7] = RoundText[11]; RoundText[11] = RoundText[15]; RoundText[15] = t;
}
unsigned char xtime2(unsigned char x)
{
    if (x & 0x80)
        return (((x << 1) ^ 0x1B) & 0xFF);
    return x << 1;
}
unsigned char xtime3(unsigned char x)
{
    return (xtime2(x) ^ x);
}
unsigned char xtime4(unsigned char x)
{
    return (xtime2(xtime2(x)));
}
unsigned char xtime8(unsigned char x)
{
    return (xtime2(xtime2(xtime2(x))));
}
unsigned char xtime9(unsigned char x)
{
    return (xtime8(x) ^ x);
}
unsigned char xtimeB(unsigned char x)
{
    return (xtime8(x) ^ xtime2(x) ^ x);
}
unsigned char xtimeD(unsigned char x)
{
    return (xtime8(x) ^ xtime4(x) ^ x);
}
unsigned char xtimeE(unsigned char x)
{
    return (xtime8(x) ^ xtime4(x) ^ xtime2(x));
}
void MixColumn(unsigned char* RoundText)
{
    unsigned char temp[4];
    for (int i = 0; i < 4; i++)
    {
        temp[0] = xtime2(RoundText[4 * i]) ^ xtime3(RoundText[1 + 4 * i]) ^ RoundText[2 + 4 * i] ^ RoundText[3 + 4 * i];
        temp[1] = RoundText[4 * i] ^ xtime2(RoundText[1 + 4 * i]) ^ xtime3(RoundText[2 + 4 * i]) ^ RoundText[3 + 4 * i];
        temp[2] = RoundText[4 * i] ^ RoundText[1 + 4 * i] ^ xtime2(RoundText[2 + 4 * i]) ^ xtime3(RoundText[3 + 4 * i]);
        temp[3] = xtime3(RoundText[4 * i]) ^ RoundText[1 + 4 * i] ^ RoundText[2 + 4 * i] ^ xtime2(RoundText[3 + 4 * i]);
        RoundText[4 * i] = temp[0];
        RoundText[1 + 4 * i] = temp[1];
        RoundText[2 + 4 * i] = temp[2];
        RoundText[3 + 4 * i] = temp[3];
    }
}
void InvMixColumn(unsigned char* RoundText)
{
    unsigned char temp[4];
    for (int i = 0; i < 4; i++)
    {
        temp[0] = xtimeE(RoundText[4 * i]) ^ xtimeB(RoundText[1 + 4 * i]) ^ xtimeD(RoundText[2 + 4 * i]) ^ xtime9(RoundText[3 + 4 * i]);
        temp[1] = xtime9(RoundText[4 * i]) ^ xtimeE(RoundText[1 + 4 * i]) ^ xtimeB(RoundText[2 + 4 * i]) ^ xtimeD(RoundText[3 + 4 * i]);
        temp[2] = xtimeD(RoundText[4 * i]) ^ xtime9(RoundText[1 + 4 * i]) ^ xtimeE(RoundText[2 + 4 * i]) ^ xtimeB(RoundText[3 + 4 * i]);
        temp[3] = xtimeB(RoundText[4 * i]) ^ xtimeD(RoundText[1 + 4 * i]) ^ xtime9(RoundText[2 + 4 * i]) ^ xtimeE(RoundText[3 + 4 * i]);
        RoundText[4 * i] = temp[0];
        RoundText[1 + 4 * i] = temp[1];
        RoundText[2 + 4 * i] = temp[2];
        RoundText[3 + 4 * i] = temp[3];
    }
}
void AddRoundKey(unsigned char* RoundText, int round)
{
    for (int i = 0; i < 16; i++)
        RoundText[i] ^= RoundKey[round * 16 + i];
}
void AES_encrypt(unsigned char* RoundText)
{
    int round = 0;
    AddRoundKey(RoundText, round);
    for (round = 1; round < 10; round++)
    {
        ByteSub(RoundText);
        ShiftRow(RoundText);
        MixColumn(RoundText);
        AddRoundKey(RoundText, round);
    }
    ByteSub(RoundText);
    ShiftRow(RoundText);
    AddRoundKey(RoundText, round);
}
void AES_decrypt(unsigned char* RoundText)
{
    int round = 10;
    AddRoundKey(RoundText, round);
    InvShiftRow(RoundText);
    InvByteSub(RoundText);
    for (round = 9; round > 0; round--)
    {
        AddRoundKey(RoundText, round);
        InvMixColumn(RoundText);
        InvShiftRow(RoundText);
        InvByteSub(RoundText);
    }
    AddRoundKey(RoundText, round);
}

程序的调试

因为程序中使用到了EasyX库，需要对项目的属性进行调整。在项目的属性中，把高级选项中的字符集改为使用多字节字符集。

工具的局限性

该工具只能实现对txt文件的加解密操作，更多功能有待开发。

AES_ECB算法原理及C语言实现
qq_45561717的博客
07-20 2567
AES 128 ECB算法原理及C语言实现。
AES加密解密（ECB模式）
2401_84121485的博客
04-14 3505
希望本文对你有所启发，有任何面试上的建议也欢迎留言分享给大家。好了，今天的分享就到这里，如果你对在面试中遇到的问题，或者刚毕业及工作几年迷茫不知道该如何准备面试并突破现状提升自己，对于自己的未来还不够了解不知道给如何规划，来看看同行们都是如何突破现状，怎么学习的，来吸收他们的面试以及工作经验完善自己的之后的面试计划及职业规划。好了~如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。
DES加解密工具（DES/ECB、DES/CBC）
chenfan的博客
12-07 5832
DES加解密算法（DES/ECB、DES/CBC）
java使用ECB模式生成AES加密解密工具（base64编码），大白菜程序猿
m0_50641264的博客
07-11 655
【代码】java使用ECB模式生成AES加密解密工具（base64编码），大白菜程序猿。
AES128 ECB、CBC模式加密解密函数（C语言实现 -单片机/嵌入式）
04-24
AES128是一种广泛使用的对称加密算法，全称为Advanced Encryption Standard，128表示其块大小为128位。...提供的压缩包文件“AES128”可能包含了实现这些功能的C语言源代码，可以进一步学习和研究。
AES.rar_AES 加密_AES 解密_C语言AES_C语言加密算法_加密解密实现
07-15
AES算法的工作模式主要有四种：ECB（Electronic Codebook）、CBC（Cipher Block Chaining）、CFB（Cipher Feedback）和OFB（Output Feedback）。其中，ECB是最基本的模式，但不安全，因为它可能会导致相同的明文块...
单片机AES128 ECB与CBC模式加密解密C语言实现
最新发布
05-27
AES128是一种广受欢迎的对称加密算法，其全称为高级加密标准（Advanced Encryption Standard），其中“128”指的是加密的块大小为128位。在嵌入式系统和单片机应用中，AES128因其高效性和安全性而被广泛应用。ECB...
AES-128加密算法，C语言实现
04-25
在ECB（电子密码本）模式下，每个明文块独立进行加密，不考虑前后块的关联，这使得ECB模式简单且易于实现，但不适用于保护大量重复数据的安全。 在给定的文件中，`AES128.c`和`AES128.h`分别代表了C语言的源代码...
AES加解密软算法（C语言实现）
03-05
在提供的压缩包中，`AES.c`文件应该包含了AES算法的基本实现，包括轮函数、状态矩阵变换等核心部分，可能使用了Rijndael的128位版本。`Test.c`文件则是用于测试这些实现的程序，可能包含了一些示例输入，用于演示...
AES加解密工具
12-02
参考FIPS-197规范开发，平台选用VS2013 MFC。支持AES 16、24、32字节长密钥的ECB CBC加解密
DES/ECB加解密算法
04-24
NULL 博文链接：https://jiage17.iteye.com/blog/2421908
AES 加密工具（ECB,CBC,CMAC）
06-25
AES工具，支持ECB，CBC加解密运算，以及CMAC运算。支持多种PADDING
AES的C#实现（用ECB和CBC模式分别完成加密解密）
12-17
用C#编写，用ECB和CBC模式分别实现了加解密，是我们的信息安全的课程实验，解密部分是解密老师给的一个文档,出于隐私保密，我修改了其中的一部分东西，所以解密后是乱码。大家可以改为一段正常的话。
AES自动生成base64密钥加密解密
热门推荐
黄孝果的博客
09-20 3万+
高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有
Qt实现DES ECB加密解密
qq_18822805的博客
05-19 2327
使用MinGW编译OpenSSL，通过Qt实现DES ECB模式加密解密。
C语言实现AES算法加密/解密算法---以前写的，整理下
JUST DO IT.
11-16 1万+
自已写的，代码质量肯定不是很高，存在优化空间是肯定的，可能也存在隐藏的漏洞。     以下代码侧重于对数据的加密和解密的算法部分，其他部分的问题没处理，仅供参考。   编译器用的是:C-Free 5.0     直接源代码： //AES #include #include #include #include #include using name
AES在线加解密工具
封神之路~
05-05 5867
总的来说，AES加密/解密工具为业内提供了一个简单易用、免费开放的在线工具，让大家无需安装软件或下载工具，只要有一个网络连接就能完成AES加密过程。AES加密/解密工具操作简单明了，只需要输入明文和密钥，就能快速进行加密和解密操作。此外，AES加密/解密工具还提供了多种加密模式，如CBC、ECB、CFB、OFB等，可以让用户充分自由选择最适合自己情况的加密模式，以尽量保护加密信息的安全性。现在，有一款免费的在线AES加密工具——AES加密/解密工具来帮助大家快速实现AES加密，让加密变得简单易用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值