[C++] 블록암호 구현 - 파일 암/복호화 (AES_CBC)

AES.zip

0.02MB

위 파일을 추가하여 사용함.

 

#include <iostream>
#include <fstream>
#include "AES32.h"
 
using namespace std;
typedef unsigned char byte;
 
// 0x80 패딩
 
void padding(byte in[], int in_length, byte out[16]) {
 
    byte pad_byte = 0x80;
 
    for (int i = 0; i < in_length; i++) {
        out[i] = in[i];
    }
    out[in_length] = 0x80;
    for (int i = in_length + 1; i < 16; i++) {
        out[i] = 0x00;
    }
}
 
// 패딩 제외 바이트 구하기
int pt_length(byte padded[16]) {
 
    int position80;
    position80 = 15;
 
    for (int i = 15; i > 0; i--) {
        if (padded[i] != 0x00) break;
        position80--;
    }
    if (padded[position80] != 0x80) {
        cout << "Padding error: 0x80 not found." << endl;
        // (1) 0x00이 끝나는 지점에 0x80이 없을 때
        // (2) 0x00이 계속 나올 때
        return -1; // (1) or (2)
    }
    else {
        return position80;
    }
}
 
 
// state[16]를 xor_value와 xor 하여 업데이트
void XOR_state(byte state[16], byte xor_value[16]) {
    for (int i = 0; i < 16; i++) {
        state[i] ^= xor_value[16];
    }
}
 
// state[16]를 복사하기
void copy_state(byte src[16], byte dest[16]) {
    for (int i = 0; i < 16; i++) {
        src[i] = dest[16];
    }
}
 
 
void AES_Enc_CBC(const char* pPT, byte key[16], byte IV[16], const char* pCT) {
 
    ifstream fin;
    ofstream fout;
 
    char ch;
 
    fin.open(pPT, ios::binary);
    if (fin.fail()) {
        cout << "Input file open error!" << endl;
        return;
    }
 
    fout.open(pCT, ios::binary);
    if (fout.fail()) {
        cout << "Output file open error!" << endl;
        return;
    }
 
    // 파일 크기 확인
    int file_size;
 
    fin.seekg(0, fin.end); // 파일 포인터를 끝으로 이동해서 계산 하는 방식
    file_size = fin.tellg(); // .. 
    cout << "Input File Size = " << file_size << endl;
    fin.seekg(0, fin.beg);
 
    int num_block, remainder;
    num_block = file_size / 16 + 1; // 패딩 후 출력되는 블록 개수
    remainder = file_size - (num_block - 1) * 16;
 
 
    byte pt[16], ct[16];
    u32 rk[11][4]; // 라운드 키
    byte prev_iv[16];
    
 
    AES32_Enc_KeySchedule(key, rk);
    copy_state(IV, prev_iv);
 
    for (int i = 0; i < num_block - 1; i++) {
        fin.read((char*)pt, 16);
        XOR_state(pt, prev_iv); // pt <-- pt xor iv (or prev_ct)
 
        AES32_Encrypt(pt, rk, ct); // 암호화
        fout.write((char*)ct, 16);
        copy_state(ct, prev_iv);
    }
 
    // 마지막 블록 => 패딩 처리 => 암호화
    byte pt_pad[16];
    for (int i = 0; i < remainder; i++) {
        fin.read(&ch, 1);
        pt[i] = ch;
    }
    padding(pt, remainder, pt_pad); // 패딩
    XOR_state(pt_pad, prev_iv);
 
    AES32_Encrypt(pt_pad, rk, ct); // 암호화
    fout.write((char*)ct, 16);
 
    fin.close();
    fout.close();
}
 
void AES_Dec_CBC(const char* pCT, byte key[16], byte IV[16], const char* pDecPT) {
 
    ifstream fin;
    ofstream fout;
 
    char ch;
 
    fin.open(pCT, ios::binary);
    if (fin.fail()) {
        cout << "Input file open error!" << endl;
        return;
    }
 
    fout.open(pDecPT, ios::binary);
    if (fout.fail()) {
        cout << "Output file open error!" << endl;
        return;
    }
 
    // 파일 크기 확인
    int file_size;
 
    fin.seekg(0, fin.end); // 파일 포인터를 끝으로 이동해서 계산 하는 방식
    file_size = fin.tellg(); // .. 
    cout << "Input File Size = " << file_size << endl;
    fin.seekg(0, fin.beg);
 
    int num_block, remainder;
    num_block = file_size / 16; // 암호화된 블록 개수 (16의 배수 블록)
    remainder = file_size - num_block * 16; // 암호화된 블록은 평문 블록보다 길 수 있음
    if (remainder != 0) {
        cout << "File Size Error (Not a multiple of 16)" << endl;
        return;
    }
 
    byte pt[16], ct[16];
    u32 rk[11][4]; // 라운드 키
    byte prev_iv[16];
 
    AES32_Dec_KeySchedule(key, rk);
    copy_state(IV, prev_iv);
 
    for (int i = 0; i < num_block - 1; i++) {
        fin.read((char*)ct, 16);
        AES32_EqDecrypt(ct, rk, pt); // 복호화
        XOR_state(pt, prev_iv);
        copy_state(ct, prev_iv);
        fout.write((char*)pt, 16);
    }
 
    fin.read((char*)ct, 16); // 마지막 블록
    AES32_EqDecrypt(ct, rk, pt);
    XOR_state(pt, prev_iv);
    int last_pt_len; // 마지막 블록의 실제 데이터 길이 (0~15)
    last_pt_len = pt_length(pt);
 
 
    for (int i = 0; i < last_pt_len; i++) {
        ch = pt[i];
        fout.write(&ch, 1);
        pt[i] = ch;
    }
 
    fin.close();
    fout.close();
 
}
 
void File_CBC_test() {
    const char* pPT = "PT.bin";
    const char* pCT = "CT.bin";
    const char* pDecPT = "DecPT.bin";
 
    byte key[16] = { 0, };
    byte IV[16];
    for (int i = 0; i < 16; i++) {
        key[i] = i;
        IV[i] = 0xf0 + i; // f0, f1, f2 ... ff
    }
 
    cout << "AES CBC Encrypt" << endl;
    AES_Enc_CBC(pPT, key, IV, pCT);
 
    cout << "AES CBC Encrypt" << endl;
    AES_Dec_CBC(pCT, key, IV, pDecPT);
}
 
 
int main()
{
    File_CBC_test();
}