aes_cpp.txt

AES加密算法的具体实现

//  写了一个AES的C++实现，仅支持128位密钥， 写得匆忙，不够规范，仅供参考。

//    AES.h

#ifndef AES_H_
#define AES_H_

#include <bitset>
#include <utility>

using namespace std;

class AES
{
public:
    typedef unsigned char    byte;
    static const int KEY_SIZE = 16;    //    密钥长度为128位
    static const int N_ROUND = 11;
    byte plainText[16];    //    明文
    byte state[16];    //    当前分组。
    byte cipherKey[16];    //    密钥
    byte roundKey[N_ROUND][16];    //轮密钥
    byte cipherText[16];    //密文
    byte SBox[16][16];    //    S盒
    byte InvSBox[16][16];    //    逆S盒    
    void EncryptionProcess();    
    void DecryptionProcess();
    void Round(const int& round);
    void InvRound(const int& round);
    void FinalRound();
    void InvFinalRound();
    void KeyExpansion();
    void AddRoundKey(const int& round);    
    void SubBytes();    
    void InvSubBytes();
    void ShiftRows();    
    void InvShiftRows();
    void MixColumns();    
    void InvMixColumns();
    void BuildSBox();
    void BuildInvSBox();
    void InitialState(const byte* text);
    void InitialCipherText();    
    void InitialplainText();        
    byte GFMultplyByte(const byte& left, const byte& right);
    const byte* GFMultplyBytesMatrix(const byte* left, const byte* right);
public:    
    AES();    
    const byte* Cipher(const byte* text, const byte* key, const int& keySize);    
    const byte* InvCipher(const byte* text, const byte* key, const int& keySize);
};


void AES::EncryptionProcess()
{    //    加密过程
    InitialState(plainText);
    KeyExpansion();    //    密钥扩展
    AddRoundKey(0);    //    轮密钥加
    for(int i = 1; i < N_ROUND-1; ++i)
    {            
        Round(i);
    }
    FinalRound();
    InitialCipherText();
}

void AES::DecryptionProcess()
{    //    解密过程
    InitialState(cipherText);
    KeyExpansion();
    InvFinalRound();
    for(int i = N_ROUND-2; i > 0 ; --i)
    {            
        InvRound(i);
    }
    AddRoundKey(0);
    InitialplainText();
}

void AES::Round(const int& round)
{    //    正常轮
    SubBytes();
    ShiftRows();
    MixColumns();
    AddRoundKey(round);        
}

void AES::InvRound(const int& round)
{    //    正常轮的逆
    AddRoundKey(round);    
    InvMixColumns();
    InvShiftRows();
    InvSubBytes();            
}

void AES::FinalRound()
{    //    最后轮
    SubBytes();
    ShiftRows();
    AddRoundKey(N_ROUND - 1);
}

void AES::InvFinalRound()
{    //    最后轮的逆
    AddRoundKey(N_ROUND - 1);        
    InvShiftRows();
    InvSubBytes();        
}

void AES::KeyExpansion()
{    //    密钥扩展
    const byte rcon[N_ROUND][4] = { 
        {0x00, 0x00, 0x00, 0x00},  
        {0x01, 0x00, 0x00, 0x00},
        {0x02, 0x00, 0x00, 0x00},
        {0x04, 0x00, 0x00, 0x00},
        {0x08, 0x00, 0x00, 0x00},
        {0x10, 0x00, 0x00, 0x00},
        {0x20, 0x00, 0x00, 0x00},
        {0x40, 0x00, 0x00, 0x00},
        {0x80, 0x00, 0x00, 0x00},
        {0x1b, 0x00, 0x00, 0x00},
        {0x36, 0x00, 0x00, 0x00} };        
        for(int i = 0; i < 16; ++i)
        {
            roundKey[0][i] = cipherKey[i];
        }
        for(int i = 0; i < 4; ++i)
        {    //  roundKey[0][16]为cipherKey的转置矩阵
            for(int j = 0; j < 4; ++j)
            {
                roundKey[0][4*i + j] = cipherKey[4*j + i];
            }
        }
        for(int roundIndex = 1; roundIndex < N_ROUND; ++roundIndex)
        {
            byte rotWord[4] = {0x00};
            rotWord[0] = roundKey[roundIndex - 1][3];
            rotWord[1] = roundKey[roundIndex - 1][7];
            rotWord[2] = roundKey[roundIndex - 1][11];
            rotWord[3] = roundKey[roundIndex - 1][15];
            std::swap<byte>(rotWord[0], rotWord[1]);
            std::swap<byte>(rotWord[1], rotWord[2]);
            std::swap<byte>(rotWord[2], rotWord[3]);        
            for(int i = 0; i < 4; ++i)
            {
                rotWord[i] = SBox[ rotWord[i] >> 4][ rotWord[i] & 0x0f ];
                roundKey[roundIndex][4*i] = roundKey[roundIndex - 1][4*i] ^ rotWord[i] ^ rcon[roundIndex][i];
            }
            for(int j = 1; j < 4; ++j)
            {
                for(int i = 0; i < 4; ++i)
                {
                    roundKey[roundIndex][4*i + j] = roundKey[roundIndex - 1][4*i + j] ^ roundKey[roundIndex][4*i + j - 1];
                }
            }
        }
}

void AES::AddRoundKey(const int& round)
{    //    轮密钥加
    for(int i = 0; i < 16; ++i)
    {    //    利用当前分组state和第round组扩展密钥进行按位异或
        state[i] ^= roundKey[round][i];
    }
}

void AES::SubBytes()
{    //    字节代换
    for(int i = 0; i < 16; ++i)
    {
        state[i] = SBox[ state[i] >> 4][ state[i] & 0x0f ];
    }
}

void AES::InvSubBytes()
{    //    逆字节代换
    for(int i = 0; i < 16; ++i)
    {
        state[i] = InvSBox[ state[i] >> 4][ state[i] & 0x0f ];
    }
}

void AES::ShiftRows()
{    //    行变换
    //state第一行保持不变
    // Do nothing.
    //state第二行循环左移一个字节
    std::swap<byte>(state[4], state[5]);
    std::swap<byte>(state[5], state[6]);
    std::swap<byte>(state[6], state[7]);        
    //state第三行循环左移两个字节
    std::swap<byte>(state[8], state[10]);
    std::swap<byte>(state[9], state[11]);
    //state第三行循环左移三个字节
    std::swap<byte>(state[14], state[15]);
    std::swap<byte>(state[13], state[14]);
    std::swap<byte>(state[12], state[13]);    
}

void AES::InvShiftRows()
{    //    行变换反演
    //state第一行保持不变
    // Do nothing.
    //state第二行循环右移一个字节
    std::swap<byte>(state[6], state[7]);
    std::swap<byte>(state[5], state[6]);
    std::swap<byte>(state[4], state[5]);        
    //state第三行循环右移两个字节
    std::swap<byte>(state[9], state[11]);
    std::swap<byte>(state[8], state[10]);
    //state第三行循环右移三个字节
    std::swap<byte>(state[12], state[13]);
    std::swap<byte>(state[13], state[14]);        
    std::swap<byte>(state[14], state[15]);    
}

void AES::MixColumns()
{    //    列混淆
    byte matrix[4][4] = {
        {0x02, 0x03, 0x01, 0x01},
        {0x01, 0x02, 0x03, 0x01},
        {0x01, 0x01, 0x02, 0x03},
        {0x03, 0x01, 0x01, 0x02}};
        const byte* temp = GFMultplyBytesMatrix((byte*)matrix, state);
        for(int i = 0; i < 16; ++i)
        {
            state[i] = temp[i];
        }
        delete[] temp;
}

void AES::InvMixColumns()
{    //    列混淆反演
    byte matrix[4][4] = {
        {0x0e, 0x0b, 0x0d, 0x09},
        {0x09, 0x0e, 0x0b, 0x0d},
        {0x0d, 0x09, 0x0e, 0x0b},
        {0x0b, 0x0d, 0x09, 0x0e} };
        const byte* temp = GFMultplyBytesMatrix((byte*)matrix, state);
        for(int i = 0; i < 16; ++i)
        {
            state[i] = temp[i];
        }
        delete[] temp;
}

void AES::BuildSBox()
{    //    构建S盒
    byte box[16][16] = 
    {