韩国国家加密算法ARIA，Cpp实现
constant.h
aira.h
test.cpp
constant.h
#ifndef _CONSTANT_H_
#define _CONSTANT_H_
namespace triod
{
const static unsigned short NUM_OF_ROUND_KEY = 18 ;
const static unsigned short SECTION_LEN = 128 / 8 ;
const static unsigned short MAX_KEY_WIDTH = 256 / 8 ;
const static unsigned short DIFFUSE_TIMES = 16 ;
const static unsigned short DIFFUSE_XOR_OPRAND_TIMES = 7 ;
const static unsigned short CK_NUM = 4 ;
const static unsigned short CK_SECTION_LENGTH = 128 / 8 ;
const static unsigned short SBOX_TYPES = 4 ;
const static unsigned short SBOX_ELEMENTS_NUM = 0x100 ;
const static unsigned short ERROR_AFFECTED_BYTE_NUM = 7 ;
const static unsigned short SUB_SECTION_LEN = 2 ;
enum { SBOX1, SBOX2, SBOX1_REVERSE, SBOX2_REVERSE };
enum { LEFT, RIGHT, NOP };
enum { MIN_LEN = 16 , MID_LEN = 24 , MAX_LEN = 32 };
enum { MIN_ROUND = 12 , MID_ROUND = 14 , MAX_ROUND = 16 };
const static unsigned char SBOX[SBOX_TYPES][SBOX_ELEMENTS_NUM] =
{
{
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
},
{
0xe2 , 0x4e , 0x54 , 0xfc , 0x94 , 0xc2 , 0x4a , 0xcc , 0x62 , 0x0d , 0x6a , 0x46 , 0x3c , 0x4d , 0x8b , 0xd1 ,
0x5e , 0xfa , 0x64 , 0xcb , 0xb4 , 0x97 , 0xbe , 0x2b , 0xbc , 0x77 , 0x2e , 0x03 , 0xd3 , 0x19 , 0x59 , 0xc1 ,
0x1d , 0x06 , 0x41 , 0x6b , 0x55 , 0xf0 , 0x99 , 0x69 , 0xea , 0x9c , 0x18 , 0xae , 0x63 , 0xdf , 0xe7 , 0xbb ,
0x00 , 0x73 , 0x66 , 0xfb , 0x96 , 0x4c , 0x85 , 0xe4 , 0x3a , 0x09 , 0x45 , 0xaa , 0x0f , 0xee , 0x10 , 0xeb ,
0x2d , 0x7f , 0xf4 , 0x29 , 0xac , 0xcf , 0xad , 0x91 , 0x8d , 0x78 , 0xc8 , 0x95 , 0xf9 , 0x2f , 0xce , 0xcd ,
0x08 , 0x7a , 0x88 , 0x38 , 0x5c , 0x83 , 0x2a , 0x28 , 0x47 , 0xdb , 0xb8 , 0xc7 , 0x93 , 0xa4 , 0x12 , 0x53 ,
0xff , 0x87 , 0x0e , 0x31 , 0x36 , 0x21 , 0x58 , 0x48 , 0x01 , 0x8e , 0x37 , 0x74 , 0x32 , 0xca , 0xe9 , 0xb1 ,
0xb7 , 0xab , 0x0c , 0xd7 , 0xc4 , 0x56 , 0x42 , 0x26 , 0x07 , 0x98 , 0x60 , 0xd9 , 0xb6 , 0xb9 , 0x11 , 0x40 ,
0xec , 0x20 , 0x8c , 0xbd , 0xa0 , 0xc9 , 0x84 , 0x04 , 0x49 , 0x23 , 0xf1 , 0x4f , 0x50 , 0x1f , 0x13 , 0xdc ,
0xd8 , 0xc0 , 0x9e , 0x57 , 0xe3 , 0xc3 , 0x7b , 0x65 , 0x3b , 0x02 , 0x8f , 0x3e , 0xe8 , 0x25 , 0x92 , 0xe5 ,
0x15 , 0xdd , 0xfd , 0x17 , 0xa9 , 0xbf , 0xd4 , 0x9a , 0x7e , 0xc5 , 0x39 , 0x67 , 0xfe , 0x76 , 0x9d , 0x43 ,
0xa7 , 0xe1 , 0xd0 , 0xf5 , 0x68 , 0xf2 , 0x1b , 0x34 , 0x70 , 0x05 , 0xa3 , 0x8a , 0xd5 , 0x79 , 0x86 , 0xa8 ,
0x30 , 0xc6 , 0x51 , 0x4b , 0x1e , 0xa6 , 0x27 , 0xf6 , 0x35 , 0xd2 , 0x6e , 0x24 , 0x16 , 0x82 , 0x5f , 0xda ,
0xe6 , 0x75 , 0xa2 , 0xef , 0x2c , 0xb2 , 0x1c , 0x9f , 0x5d , 0x6f , 0x80 , 0x0a , 0x72 , 0x44 , 0x9b , 0x6c ,
0x90 , 0x0b , 0x5b , 0x33 , 0x7d , 0x5a , 0x52 , 0xf3 , 0x61 , 0xa1 , 0xf7 , 0xb0 , 0xd6 , 0x3f , 0x7c , 0x6d ,
0xed , 0x14 , 0xe0 , 0xa5 , 0x3d , 0x22 , 0xb3 , 0xf8 , 0x89 , 0xde , 0x71 , 0x1a , 0xaf , 0xba , 0xb5 , 0x81
},
{
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
},
{
0x30 , 0x68 , 0x99 , 0x1b , 0x87 , 0xb9 , 0x21 , 0x78 , 0x50 , 0x39 , 0xdb , 0xe1 , 0x72 , 0x09 , 0x62 , 0x3c ,
0x3e , 0x7e , 0x5e , 0x8e , 0xf1 , 0xa0 , 0xcc , 0xa3 , 0x2a , 0x1d , 0xfb , 0xb6 , 0xd6 , 0x20 , 0xc4 , 0x8d ,
0x81 , 0x65 , 0xf5 , 0x89 , 0xcb , 0x9d , 0x77 , 0xc6 , 0x57 , 0x43 , 0x56 , 0x17 , 0xd4 , 0x40 , 0x1a , 0x4d ,
0xc0 , 0x63 , 0x6c , 0xe3 , 0xb7 , 0xc8 , 0x64 , 0x6a , 0x53 , 0xaa , 0x38 , 0x98 , 0x0c , 0xf4 , 0x9b , 0xed ,
0x7f , 0x22 , 0x76 , 0xaf , 0xdd , 0x3a , 0x0b , 0x58 , 0x67 , 0x88 , 0x06 , 0xc3 , 0x35 , 0x0d , 0x01 , 0x8b ,
0x8c , 0xc2 , 0xe6 , 0x5f , 0x02 , 0x24 , 0x75 , 0x93 , 0x66 , 0x1e , 0xe5 , 0xe2 , 0x54 , 0xd8 , 0x10 , 0xce ,
0x7a , 0xe8 , 0x08 , 0x2c , 0x12 , 0x97 , 0x32 , 0xab , 0xb4 , 0x27 , 0x0a , 0x23 , 0xdf , 0xef , 0xca , 0xd9 ,
0xb8 , 0xfa , 0xdc , 0x31 , 0x6b , 0xd1 , 0xad , 0x19 , 0x49 , 0xbd , 0x51 , 0x96 , 0xee , 0xe4 , 0xa8 , 0x41 ,
0xda , 0xff , 0xcd , 0x55 , 0x86 , 0x36 , 0xbe , 0x61 , 0x52 , 0xf8 , 0xbb , 0x0e , 0x82 , 0x48 , 0x69 , 0x9a ,
0xe0 , 0x47 , 0x9e , 0x5c , 0x04 , 0x4b , 0x34 , 0x15 , 0x79 , 0x26 , 0xa7 , 0xde , 0x29 , 0xae , 0x92 , 0xd7 ,
0x84 , 0xe9 , 0xd2 , 0xba , 0x5d , 0xf3 , 0xc5 , 0xb0 , 0xbf , 0xa4 , 0x3b , 0x71 , 0x44 , 0x46 , 0x2b , 0xfc ,
0xeb , 0x6f , 0xd5 , 0xf6 , 0x14 , 0xfe , 0x7c , 0x70 , 0x5a , 0x7d , 0xfd , 0x2f , 0x18 , 0x83 , 0x16 , 0xa5 ,
0x91 , 0x1f , 0x05 , 0x95 , 0x74 , 0xa9 , 0xc1 , 0x5b , 0x4a , 0x85 , 0x6d , 0x13 , 0x07 , 0x4f , 0x4e , 0x45 ,
0xb2 , 0x0f , 0xc9 , 0x1c , 0xa6 , 0xbc , 0xec , 0x73 , 0x90 , 0x7b , 0xcf , 0x59 , 0x8f , 0xa1 , 0xf9 , 0x2d ,
0xf2 , 0xb1 , 0x00 , 0x94 , 0x37 , 0x9f , 0xd0 , 0x2e , 0x9c , 0x6e , 0x28 , 0x3f , 0x80 , 0xf0 , 0x3d , 0xd3 ,
0x25 , 0x8a , 0xb5 , 0xe7 , 0x42 , 0xb3 , 0xc7 , 0xea , 0xf7 , 0x4c , 0x11 , 0x33 , 0x03 , 0xa2 , 0xac , 0x60
}
};
const static unsigned char DIFFUSE_OPERATION[DIFFUSE_TIMES][DIFFUSE_XOR_OPRAND_TIMES] =
{
{ 0x03 , 0x04 , 0x06 , 0x08 , 0x09 , 0x0D , 0x0E },
{ 0x02 , 0x05 , 0x07 , 0x08 , 0x09 , 0x0C , 0x0F },
{ 0x01 , 0x04 , 0x06 , 0x0A , 0x0B , 0x0C , 0x0F },
{ 0x00 , 0x05 , 0x07 , 0x0A , 0x0B , 0x0D , 0x0E },
{ 0x00 , 0x02 , 0x05 , 0x08 , 0x0B , 0x0E , 0x0F },
{ 0x01 , 0x03 , 0x04 , 0x09 , 0x0A , 0x0E , 0x0F },
{ 0x00 , 0x02 , 0x07 , 0x09 , 0x0A , 0x0C , 0x0D },
{ 0x01 , 0x03 , 0x06 , 0x08 , 0x0B , 0x0C , 0x0D },
{ 0x00 , 0x01 , 0x04 , 0x07 , 0x0A , 0x0D , 0x0F },
{ 0x00 , 0x01 , 0x05 , 0x06 , 0x0B , 0x0C , 0x0E },
{ 0x02 , 0x03 , 0x05 , 0x06 , 0x08 , 0x0D , 0x0F },
{ 0x02 , 0x03 , 0x04 , 0x07 , 0x09 , 0x0C , 0x0E },
{ 0x01 , 0x02 , 0x06 , 0x07 , 0x09 , 0x0B , 0x0C },
{ 0x00 , 0x03 , 0x06 , 0x07 , 0x08 , 0x0A , 0x0D },
{ 0x00 , 0x03 , 0x04 , 0x05 , 0x09 , 0x0B , 0x0E },
{ 0x01 , 0x02 , 0x04 , 0x05 , 0x08 , 0x0A , 0x0F }
};
// 为了和文档兼容，这里增加了一个 0 行
const static unsigned char CK[CK_NUM][CK_SECTION_LENGTH] =
{
{ 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 },
{ 0x51 , 0x7c , 0xc1 , 0xb7 , 0x27 , 0x22 , 0x0a , 0x94 , 0xfe , 0x13 , 0xab , 0xe8 , 0xfa , 0x9a , 0x6e , 0xe0 },
{ 0x6d , 0xb1 , 0x4a , 0xcc , 0x9e , 0x21 , 0xc8 , 0x20 , 0xff , 0x28 , 0xb1 , 0xd5 , 0xef , 0x5d , 0xe2 , 0xb0 },
{ 0xdb , 0x92 , 0x37 , 0x1d , 0x21 , 0x26 , 0xe9 , 0x70 , 0x03 , 0x24 , 0x97 , 0x75 , 0x04 , 0xe8 , 0xc9 , 0x0e }
};
const static unsigned char CK_ORDER[ 4 ][ 3 ] =
{
{ 0 , 0 , 0 },
{ 1 , 2 , 3 },
{ 2 , 3 , 1 },
{ 3 , 1 , 2 }
};
const static unsigned char ROUNDS_BY_KEY_LENGTH[] = { 0 , MIN_ROUND, MID_ROUND, MAX_ROUND };
const static unsigned short ROUND_KEY_OP_ARRAY[NUM_OF_ROUND_KEY][ 6 ] =
{
{ NOP, 0 , 0 , NOP, 0 , 0 }, // 0
{ NOP, 0 , 0 , RIGHT, 1 , 19 }, // 1
{ NOP, 1 , 0 , RIGHT, 2 , 19 }, // 2
{ NOP, 2 , 0 , RIGHT, 3 , 19 }, // 3
{ RIGHT, 0 , 19 , NOP, 3 , 0 }, // 4
{ NOP, 0 , 0 , RIGHT, 1 , 31 }, // 5
{ NOP, 1 , 0 , RIGHT, 2 , 31 }, // 6
{ NOP, 2 , 0 , RIGHT, 3 , 31 }, // 7
{ RIGHT, 0 , 31 , NOP, 3 , 0 }, // 8
{ NOP, 0 , 0 , LEFT, 1 , 61 }, // 9
{ NOP, 1 , 0 , LEFT, 2 , 61 }, // 10
{ NOP, 2 , 0 , LEFT, 3 , 61 }, // 11
{ LEFT, 0 , 61 , NOP, 3 , 0 }, // 12
{ NOP, 0 , 0 , LEFT, 1 , 31 }, // 13
{ NOP, 1 , 0 , LEFT, 2 , 31 }, // 14
{ NOP, 2 , 0 , LEFT, 3 , 31 }, // 15
{ LEFT, 0 , 31 , NOP, 3 , 0 }, // 16
{ NOP, 0 , 0 , LEFT, 1 , 19 } // 17
/*
{ RIGHT, 0, 7, LEFT, 1, 11 },
{ LEFT, 1, 22, NOP, 2, 0 },
{ RIGHT, 2, 17, LEFT, 3, 16 },
{ RIGHT, 0, 14, LEFT, 3, 32 },
{ RIGHT, 0, 21, RIGHT, 2, 34 },
{ LEFT, 1, 33, LEFT, 3, 48 },
{ LEFT, 1, 44, RIGHT, 2, 51 },
{ RIGHT, 0, 28, LEFT, 3, 64 },
{ LEFT, 1, 55, LEFT, 3, 80 },
{ RIGHT, 0, 35, RIGHT, 2, 68 },
{ RIGHT, 0, 42, LEFT, 1, 66 },
{ LEFT, 1, 77, RIGHT, 2, 85 },
{ RIGHT, 0, 49, RIGHT, 2, 102 },
{ RIGHT, 2, 119, LEFT, 3, 112 },
{ RIGHT, 0, 56, LEFT, 1, 8 }
*/
};
const static unsigned char ODD_LAYER_BOX[] =
{
SBOX1, SBOX2, SBOX1_REVERSE, SBOX2_REVERSE,
SBOX1, SBOX2, SBOX1_REVERSE, SBOX2_REVERSE,
SBOX1, SBOX2, SBOX1_REVERSE, SBOX2_REVERSE,
SBOX1, SBOX2, SBOX1_REVERSE, SBOX2_REVERSE
};
const static unsigned char EVEN_LAYER_BOX[] =
{
SBOX1_REVERSE, SBOX2_REVERSE, SBOX1, SBOX2,
SBOX1_REVERSE, SBOX2_REVERSE, SBOX1, SBOX2,
SBOX1_REVERSE, SBOX2_REVERSE, SBOX1, SBOX2,
SBOX1_REVERSE, SBOX2_REVERSE, SBOX1, SBOX2
};
const static size_t ERROR_AT[SECTION_LEN][ERROR_AFFECTED_BYTE_NUM] =
{
{ 3 , 4 , 6 , 8 , 9 , 13 , 14 },
{ 2 , 5 , 7 , 8 , 9 , 12 , 15 },
{ 1 , 4 , 6 , 10 , 11 , 12 , 15 },
{ 0 , 5 , 7 , 10 , 11 , 13 , 14 },
{ 0 , 2 , 5 , 8 , 11 , 14 , 15 },
{ 1 , 3 , 4 , 9 , 10 , 14 , 15 },
{ 0 , 2 , 7 , 9 , 10 , 12 , 13 },
{ 1 , 3 , 6 , 8 , 11 , 12 , 13 },
{ 0 , 1 , 4 , 7 , 10 , 13 , 15 },
{ 0 , 1 , 5 , 6 , 11 , 12 , 14 },
{ 2 , 3 , 5 , 6 , 8 , 13 , 15 },
{ 2 , 3 , 4 , 7 , 9 , 12 , 14 },
{ 1 , 2 , 6 , 7 , 9 , 11 , 12 },
{ 0 , 3 , 6 , 7 , 8 , 10 , 13 },
{ 0 , 3 , 4 , 5 , 9 , 11 , 14 },
{ 1 , 2 , 4 , 5 , 8 , 10 , 15 }
};
}
#endif
#define _CONSTANT_H_
namespace triod
{
const static unsigned short NUM_OF_ROUND_KEY = 18 ;
const static unsigned short SECTION_LEN = 128 / 8 ;
const static unsigned short MAX_KEY_WIDTH = 256 / 8 ;
const static unsigned short DIFFUSE_TIMES = 16 ;
const static unsigned short DIFFUSE_XOR_OPRAND_TIMES = 7 ;
const static unsigned short CK_NUM = 4 ;
const static unsigned short CK_SECTION_LENGTH = 128 / 8 ;
const static unsigned short SBOX_TYPES = 4 ;
const static unsigned short SBOX_ELEMENTS_NUM = 0x100 ;
const static unsigned short ERROR_AFFECTED_BYTE_NUM = 7 ;
const static unsigned short SUB_SECTION_LEN = 2 ;
enum { SBOX1, SBOX2, SBOX1_REVERSE, SBOX2_REVERSE };
enum { LEFT, RIGHT, NOP };
enum { MIN_LEN = 16 , MID_LEN = 24 , MAX_LEN = 32 };
enum { MIN_ROUND = 12 , MID_ROUND = 14 , MAX_ROUND = 16 };
const static unsigned char SBOX[SBOX_TYPES][SBOX_ELEMENTS_NUM] =
{
{
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
},
{
0xe2 , 0x4e , 0x54 , 0xfc , 0x94 , 0xc2 , 0x4a , 0xcc , 0x62 , 0x0d , 0x6a , 0x46 , 0x3c , 0x4d , 0x8b , 0xd1 ,
0x5e , 0xfa , 0x64 , 0xcb , 0xb4 , 0x97 , 0xbe , 0x2b , 0xbc , 0x77 , 0x2e , 0x03 , 0xd3 , 0x19 , 0x59 , 0xc1 ,
0x1d , 0x06 , 0x41 , 0x6b , 0x55 , 0xf0 , 0x99 , 0x69 , 0xea , 0x9c , 0x18 , 0xae , 0x63 , 0xdf , 0xe7 , 0xbb ,
0x00 , 0x73 , 0x66 , 0xfb , 0x96 , 0x4c , 0x85 , 0xe4 , 0x3a , 0x09 , 0x45 , 0xaa , 0x0f , 0xee , 0x10 , 0xeb ,
0x2d , 0x7f , 0xf4 , 0x29 , 0xac , 0xcf , 0xad , 0x91 , 0x8d , 0x78 , 0xc8 , 0x95 , 0xf9 , 0x2f , 0xce , 0xcd ,
0x08 , 0x7a , 0x88 , 0x38 , 0x5c , 0x83 , 0x2a , 0x28 , 0x47 , 0xdb , 0xb8 , 0xc7 , 0x93 , 0xa4 , 0x12 , 0x53 ,
0xff , 0x87 , 0x0e , 0x31 , 0x36 , 0x21 , 0x58 , 0x48 , 0x01 , 0x8e , 0x37 , 0x74 , 0x32 , 0xca , 0xe9 , 0xb1 ,
0xb7 , 0xab , 0x0c , 0xd7 , 0xc4 , 0x56 , 0x42 , 0x26 , 0x07 , 0x98 , 0x60 , 0xd9 , 0xb6 , 0xb9 , 0x11 , 0x40 ,
0xec , 0x20 , 0x8c , 0xbd , 0xa0 , 0xc9 , 0x84 , 0x04 , 0x49 , 0x23 , 0xf1 , 0x4f , 0x50 , 0x1f , 0x13 , 0xdc ,
0xd8 , 0xc0 , 0x9e , 0x57 , 0xe3 , 0xc3 , 0x7b , 0x65 , 0x3b , 0x02 , 0x8f , 0x3e , 0xe8 , 0x25 , 0x92 , 0xe5 ,
0x15 , 0xdd , 0xfd , 0x17 , 0xa9 , 0xbf , 0xd4 , 0x9a , 0x7e , 0xc5 , 0x39 , 0x67 , 0xfe , 0x76 , 0x9d , 0x43 ,
0xa7 , 0xe1 , 0xd0 , 0xf5 , 0x68 , 0xf2 , 0x1b , 0x34 , 0x70 , 0x05 , 0xa3 , 0x8a , 0xd5 , 0x79 , 0x86 , 0xa8 ,
0x30 , 0xc6 , 0x51 , 0x4b , 0x1e , 0xa6 , 0x27 , 0xf6 , 0x35 , 0xd2 , 0x6e , 0x24 , 0x16 , 0x82 , 0x5f , 0xda ,
0xe6 , 0x75 , 0xa2 , 0xef , 0x2c , 0xb2 , 0x1c , 0x9f , 0x5d , 0x6f , 0x80 , 0x0a , 0x72 , 0x44 , 0x9b , 0x6c ,
0x90 , 0x0b , 0x5b , 0x33 , 0x7d , 0x5a , 0x52 , 0xf3 , 0x61 , 0xa1 , 0xf7 , 0xb0 , 0xd6 , 0x3f , 0x7c , 0x6d ,
0xed , 0x14 , 0xe0 , 0xa5 , 0x3d , 0x22 , 0xb3 , 0xf8 , 0x89 , 0xde , 0x71 , 0x1a , 0xaf , 0xba , 0xb5 , 0x81
},
{
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
},
{
0x30 , 0x68 , 0x99 , 0x1b , 0x87 , 0xb9 , 0x21 , 0x78 , 0x50 , 0x39 , 0xdb , 0xe1 , 0x72 , 0x09 , 0x62 , 0x3c ,
0x3e , 0x7e , 0x5e , 0x8e , 0xf1 , 0xa0 , 0xcc , 0xa3 , 0x2a , 0x1d , 0xfb , 0xb6 , 0xd6 , 0x20 , 0xc4 , 0x8d ,
0x81 , 0x65 , 0xf5 , 0x89 , 0xcb , 0x9d , 0x77 , 0xc6 , 0x57 , 0x43 , 0x56 , 0x17 , 0xd4 , 0x40 , 0x1a , 0x4d ,
0xc0 , 0x63 , 0x6c , 0xe3 , 0xb7 , 0xc8 , 0x64 , 0x6a , 0x53 , 0xaa , 0x38 , 0x98 , 0x0c , 0xf4 , 0x9b , 0xed ,
0x7f , 0x22 , 0x76 , 0xaf , 0xdd , 0x3a , 0x0b , 0x58 , 0x67 , 0x88 , 0x06 , 0xc3 , 0x35 , 0x0d , 0x01 , 0x8b ,
0x8c , 0xc2 , 0xe6 , 0x5f , 0x02 , 0x24 , 0x75 , 0x93 , 0x66 , 0x1e , 0xe5 , 0xe2 , 0x54 , 0xd8 , 0x10 , 0xce ,
0x7a , 0xe8 , 0x08 , 0x2c , 0x12 , 0x97 , 0x32 , 0xab , 0xb4 , 0x27 , 0x0a , 0x23 , 0xdf , 0xef , 0xca , 0xd9 ,
0xb8 , 0xfa , 0xdc , 0x31 , 0x6b , 0xd1 , 0xad , 0x19 , 0x49 , 0xbd , 0x51 , 0x96 , 0xee , 0xe4 , 0xa8 , 0x41 ,
0xda , 0xff , 0xcd , 0x55 , 0x86 , 0x36 , 0xbe , 0x61 , 0x52 , 0xf8 , 0xbb , 0x0e , 0x82 , 0x48 , 0x69 , 0x9a ,
0xe0 , 0x47 , 0x9e , 0x5c , 0x04 , 0x4b , 0x34 , 0x15 , 0x79 , 0x26 , 0xa7 , 0xde , 0x29 , 0xae , 0x92 , 0xd7 ,
0x84 , 0xe9 , 0xd2 , 0xba , 0x5d , 0xf3 , 0xc5 , 0xb0 , 0xbf , 0xa4 , 0x3b , 0x71 , 0x44 , 0x46 , 0x2b , 0xfc ,
0xeb , 0x6f , 0xd5 , 0xf6 , 0x14 , 0xfe , 0x7c , 0x70 , 0x5a , 0x7d , 0xfd , 0x2f , 0x18 , 0x83 , 0x16 , 0xa5 ,
0x91 , 0x1f , 0x05 , 0x95 , 0x74 , 0xa9 , 0xc1 , 0x5b , 0x4a , 0x85 , 0x6d , 0x13 , 0x07 , 0x4f , 0x4e , 0x45 ,
0xb2 , 0x0f , 0xc9 , 0x1c , 0xa6 , 0xbc , 0xec , 0x73 , 0x90 , 0x7b , 0xcf , 0x59 , 0x8f , 0xa1 , 0xf9 , 0x2d ,
0xf2 , 0xb1 , 0x00 , 0x94 , 0x37 , 0x9f , 0xd0 , 0x2e , 0x9c , 0x6e , 0x28 , 0x3f , 0x80 , 0xf0 , 0x3d , 0xd3 ,
0x25 , 0x8a , 0xb5 , 0xe7 , 0x42 , 0xb3 , 0xc7 , 0xea , 0xf7 , 0x4c , 0x11 , 0x33 , 0x03 , 0xa2 , 0xac , 0x60
}
};
const static unsigned char DIFFUSE_OPERATION[DIFFUSE_TIMES][DIFFUSE_XOR_OPRAND_TIMES] =
{
{ 0x03 , 0x04 , 0x06 , 0x08 , 0x09 , 0x0D , 0x0E },
{ 0x02 , 0x05 , 0x07 , 0x08 , 0x09 , 0x0C , 0x0F },
{ 0x01 , 0x04 , 0x06 , 0x0A , 0x0B , 0x0C , 0x0F },
{ 0x00 , 0x05 , 0x07 , 0x0A , 0x0B , 0x0D , 0x0E },
{ 0x00 , 0x02 , 0x05 , 0x08 , 0x0B , 0x0E , 0x0F },
{ 0x01 , 0x03 , 0x04 , 0x09 , 0x0A , 0x0E , 0x0F },
{ 0x00 , 0x02 , 0x07 , 0x09 , 0x0A , 0x0C , 0x0D },
{ 0x01 , 0x03 , 0x06 , 0x08 , 0x0B , 0x0C , 0x0D },
{ 0x00 , 0x01 , 0x04 , 0x07 , 0x0A , 0x0D , 0x0F },
{ 0x00 , 0x01 , 0x05 , 0x06 , 0x0B , 0x0C , 0x0E },
{ 0x02 , 0x03 , 0x05 , 0x06 , 0x08 , 0x0D , 0x0F },
{ 0x02 , 0x03 , 0x04 , 0x07 , 0x09 , 0x0C , 0x0E },
{ 0x01 , 0x02 , 0x06 , 0x07 , 0x09 , 0x0B , 0x0C },
{ 0x00 , 0x03 , 0x06 , 0x07 , 0x08 , 0x0A , 0x0D },
{ 0x00 , 0x03 , 0x04 , 0x05 , 0x09 , 0x0B , 0x0E },
{ 0x01 , 0x02 , 0x04 , 0x05 , 0x08 , 0x0A , 0x0F }
};
// 为了和文档兼容，这里增加了一个 0 行
const static unsigned char CK[CK_NUM][CK_SECTION_LENGTH] =
{
{ 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 },
{ 0x51 , 0x7c , 0xc1 , 0xb7 , 0x27 , 0x22 , 0x0a , 0x94 , 0xfe , 0x13 , 0xab , 0xe8 , 0xfa , 0x9a , 0x6e , 0xe0 },
{ 0x6d , 0xb1 , 0x4a , 0xcc , 0x9e , 0x21 , 0xc8 , 0x20 , 0xff , 0x28 , 0xb1 , 0xd5 , 0xef , 0x5d , 0xe2 , 0xb0 },
{ 0xdb , 0x92 , 0x37 , 0x1d , 0x21 , 0x26 , 0xe9 , 0x70 , 0x03 , 0x24 , 0x97 , 0x75 , 0x04 , 0xe8 , 0xc9 , 0x0e }
};
const static unsigned char CK_ORDER[ 4 ][ 3 ] =
{
{ 0 , 0 , 0 },
{ 1 , 2 , 3 },
{ 2 , 3 , 1 },
{ 3 , 1 , 2 }
};
const static unsigned char ROUNDS_BY_KEY_LENGTH[] = { 0 , MIN_ROUND, MID_ROUND, MAX_ROUND };
const static unsigned short ROUND_KEY_OP_ARRAY[NUM_OF_ROUND_KEY][ 6 ] =
{
{ NOP, 0 , 0 , NOP, 0 , 0 }, // 0
{ NOP, 0 , 0 , RIGHT, 1 , 19 }, // 1
{ NOP, 1 , 0 , RIGHT, 2 , 19 }, // 2
{ NOP, 2 , 0 , RIGHT, 3 , 19 }, // 3
{ RIGHT, 0 , 19 , NOP, 3 , 0 }, // 4
{ NOP, 0 , 0 , RIGHT, 1 , 31 }, // 5
{ NOP, 1 , 0 , RIGHT, 2 , 31 }, // 6
{ NOP, 2 , 0 , RIGHT, 3 , 31 }, // 7
{ RIGHT, 0 , 31 , NOP, 3 , 0 }, // 8
{ NOP, 0 , 0 , LEFT, 1 , 61 }, // 9
{ NOP, 1 , 0 , LEFT, 2 , 61 }, // 10
{ NOP, 2 , 0 , LEFT, 3 , 61 }, // 11
{ LEFT, 0 , 61 , NOP, 3 , 0 }, // 12
{ NOP, 0 , 0 , LEFT, 1 , 31 }, // 13
{ NOP, 1 , 0 , LEFT, 2 , 31 }, // 14
{ NOP, 2 , 0 , LEFT, 3 , 31 }, // 15
{ LEFT, 0 , 31 , NOP, 3 , 0 }, // 16
{ NOP, 0 , 0 , LEFT, 1 , 19 } // 17
/*
{ RIGHT, 0, 7, LEFT, 1, 11 },
{ LEFT, 1, 22, NOP, 2, 0 },
{ RIGHT, 2, 17, LEFT, 3, 16 },
{ RIGHT, 0, 14, LEFT, 3, 32 },
{ RIGHT, 0, 21, RIGHT, 2, 34 },
{ LEFT, 1, 33, LEFT, 3, 48 },
{ LEFT, 1, 44, RIGHT, 2, 51 },
{ RIGHT, 0, 28, LEFT, 3, 64 },
{ LEFT, 1, 55, LEFT, 3, 80 },
{ RIGHT, 0, 35, RIGHT, 2, 68 },
{ RIGHT, 0, 42, LEFT, 1, 66 },
{ LEFT, 1, 77, RIGHT, 2, 85 },
{ RIGHT, 0, 49, RIGHT, 2, 102 },
{ RIGHT, 2, 119, LEFT, 3, 112 },
{ RIGHT, 0, 56, LEFT, 1, 8 }
*/
};
const static unsigned char ODD_LAYER_BOX[] =
{
SBOX1, SBOX2, SBOX1_REVERSE, SBOX2_REVERSE,
SBOX1, SBOX2, SBOX1_REVERSE, SBOX2_REVERSE,
SBOX1, SBOX2, SBOX1_REVERSE, SBOX2_REVERSE,
SBOX1, SBOX2, SBOX1_REVERSE, SBOX2_REVERSE
};
const static unsigned char EVEN_LAYER_BOX[] =
{
SBOX1_REVERSE, SBOX2_REVERSE, SBOX1, SBOX2,
SBOX1_REVERSE, SBOX2_REVERSE, SBOX1, SBOX2,
SBOX1_REVERSE, SBOX2_REVERSE, SBOX1, SBOX2,
SBOX1_REVERSE, SBOX2_REVERSE, SBOX1, SBOX2
};
const static size_t ERROR_AT[SECTION_LEN][ERROR_AFFECTED_BYTE_NUM] =
{
{ 3 , 4 , 6 , 8 , 9 , 13 , 14 },
{ 2 , 5 , 7 , 8 , 9 , 12 , 15 },
{ 1 , 4 , 6 , 10 , 11 , 12 , 15 },
{ 0 , 5 , 7 , 10 , 11 , 13 , 14 },
{ 0 , 2 , 5 , 8 , 11 , 14 , 15 },
{ 1 , 3 , 4 , 9 , 10 , 14 , 15 },
{ 0 , 2 , 7 , 9 , 10 , 12 , 13 },
{ 1 , 3 , 6 , 8 , 11 , 12 , 13 },
{ 0 , 1 , 4 , 7 , 10 , 13 , 15 },
{ 0 , 1 , 5 , 6 , 11 , 12 , 14 },
{ 2 , 3 , 5 , 6 , 8 , 13 , 15 },
{ 2 , 3 , 4 , 7 , 9 , 12 , 14 },
{ 1 , 2 , 6 , 7 , 9 , 11 , 12 },
{ 0 , 3 , 6 , 7 , 8 , 10 , 13 },
{ 0 , 3 , 4 , 5 , 9 , 11 , 14 },
{ 1 , 2 , 4 , 5 , 8 , 10 , 15 }
};
}
#endif
aira.h
#ifndef _ARIA_H_
#define _ARIA_H_
#include < cstdio >
#include < cstring >
#include " constant.h "
#define TEST 0
namespace triod
{
template < int key_length >
class ARIA
{
public :
typedef const unsigned char ( & const_block) [key_length];
typedef unsigned char ( & block) [key_length];
ARIA( const_block key );
void encrypt( const_block text, block cipher ); // 注意rounds_比实际的加密需要的轮数少一轮，用于最后一步的不做diffuse的运算
void decrypt( const_block cipher, block text );
/* ---------------------------------------------------------------------------------------- */
protected :
virtual void function ( size_t round, block input, const_block round_key );
virtual void function_last_round ( block input, const_block round_key );
void generate_round_key(); // 生成轮密钥函数
void diffuse( block input ); // The Diffusion Layer Function
static void key_xor ( const_block lhs, const_block rhs, block output ); // 针对 128 bit 的序列专门设计的异或函数
static void rotate_key ( unsigned short types, const_block input, size_t move_bits, block output ); // 针对 128 bit 的序列专门设计的循环移位函数
static void print_block( const_block text );
static bool compare_section( const unsigned char * lhs, const unsigned char * rhs, size_t len );
unsigned char key_[MAX_KEY_WIDTH]; // 主密钥, 256 bit
unsigned char encrypt_round_key_[NUM_OF_ROUND_KEY][SECTION_LEN]; // 16 个加密轮密钥，每个 128 bit
unsigned char decrypt_round_key_[NUM_OF_ROUND_KEY][SECTION_LEN]; // 16 个解密轮密钥，每个 128 bit
size_t rounds_;
};
}
/* -------------------------------------------------------------------------------------------------------------------------------- */
namespace triod
{
template < int key_length >
ARIA < key_length > ::ARIA( const_block key )
{
// 一个小小技巧，用于在编译期防止 key_length 非法
char guard[(key_length == MIN_LEN || key_length == MID_LEN || key_length == MAX_LEN) ? 1 : - 1 ] = { 0 };
// 另一个技巧，计算加密解密轮数
rounds_ = ROUNDS_BY_KEY_LENGTH[key_length / 10 ];
memset( key_, 0 , MAX_KEY_WIDTH );
for ( size_t i = 0 ; i < NUM_OF_ROUND_KEY; ++ i )
{
memset( encrypt_round_key_[i], 0 , SECTION_LEN );
memset( decrypt_round_key_[i], 0 , SECTION_LEN );
}
// 不用 memcpy
for ( size_t i = 0 ; i < key_length; ++ i )
key_[i] = key[i];
this -> generate_round_key();
}
template < int key_length >
void ARIA < key_length > ::encrypt( const_block text, block cipher ) // 注意rounds_比实际的加密需要的轮数少一轮，用于最后一步的不做diffuse的运算
{
memcpy ( cipher, text, SECTION_LEN );
for ( size_t i = 1 ; i < rounds_; ++ i )
{
this -> function( i, cipher, encrypt_round_key_[i] );
#if TEST
this -> print_block( cipher );
#endif
}
this -> function_last_round( cipher, encrypt_round_key_[rounds_] );
this -> key_xor( cipher, encrypt_round_key_[rounds_ + 1 ], cipher );
#if TEST
this -> print_block( cipher );
printf( " Encrypt TEXT\n\n " );
#endif
}
template < int key_length >
void ARIA < key_length > ::decrypt( const_block cipher, block text )
{
// 注意rounds_比实际的加密需要的轮数少一轮，用于最后一步的不做diffuse的运算
memcpy ( text, cipher, SECTION_LEN );
for ( size_t i = 1 ; i < rounds_; ++ i )
{
this -> function( i % 2 == 1 , text, decrypt_round_key_[i] );
#if TEST
for ( size_t j = 0 ; j < SECTION_LEN; ++ j )
printf( " %02x " , text[j] );
printf( " \n " );
#endif
}
this -> function_last_round( text, decrypt_round_key_[rounds_] );
this -> key_xor( text, decrypt_round_key_[rounds_ + 1 ], text );
#if TEST
for ( size_t j = 0 ; j < SECTION_LEN; ++ j )
printf( " %02x " , text[j] );
printf( " \nDecrypt TEXT\n\n " );
#endif
}
/* ---------------------------------------------------------------------------------------- */
template < int key_length >
void ARIA < key_length > ::function ( size_t round, block input, const_block round_key )
{
bool is_odd_layer = ( round % 2 == 1 );
// 第一步，XOR
this -> key_xor( input, round_key, input );
// 第二步，S-box layer
for ( size_t i = 0 ; i < SECTION_LEN; ++ i )
{
input[i] = SBOX[ is_odd_layer ? ODD_LAYER_BOX[i] : EVEN_LAYER_BOX[i] ][ input[i] ];
}
// 第三步，diffusion layer
this -> diffuse( input );
}
template < int key_length >
void ARIA < key_length > ::function_last_round ( block input, const_block round_key )
{
this -> key_xor( input, round_key, input ); // 第一步，XOR
for ( size_t i = 0 ; i < SECTION_LEN; ++ i ) // 第二步，S-box layer
input[i] = SBOX[EVEN_LAYER_BOX[i]][input[i]];
}
template < int key_length >
void ARIA < key_length > ::generate_round_key() // 生成轮密钥函数
{
// W 共有 4 个，每个 128 bit
unsigned char W[ 4 ][SECTION_LEN];
// kR，即 main key 的右 128 bits
unsigned char KR[SECTION_LEN];
memcpy ( KR, key_ + SECTION_LEN, SECTION_LEN );
/* ------------------- 首先初始化 W 数组 ------------------- */
// W[0] = KL，即 main key 的左 128 bits
memcpy ( W[ 0 ], key_, SECTION_LEN );
// 这里采用查表的方法:CK[ CK_ORDER[key_length / 10][0] ]
// 来处理密钥长度不同时，CK不同的情况
memcpy( W[ 1 ], W[ 0 ], SECTION_LEN );
this -> function( true , W[ 1 ], CK[ CK_ORDER[key_length / 10 ][ 0 ] ] );
this -> key_xor( W[ 1 ], KR, W[ 1 ] );
memcpy( W[ 2 ], W[ 1 ], SECTION_LEN );
this -> function( false , W[ 2 ], CK[ CK_ORDER[key_length / 10 ][ 1 ] ] );
this -> key_xor( W[ 2 ], W[ 0 ], W[ 2 ] );
memcpy( W[ 3 ], W[ 2 ], SECTION_LEN );
this -> function( true , W[ 3 ], CK[ CK_ORDER[key_length / 10 ][ 2 ] ] );
this -> key_xor( W[ 3 ], W[ 1 ], W[ 3 ] );
#if TEST // 测试输出 W[k]
for ( size_t i = 0 ; i < 4 ; ++ i )
{
for ( size_t j = 0 ; j < 16 ; ++ j )
printf( " %02x " , W[i][j]);
printf( " \n " );
}
printf( " W[k] END\n\n " );
#endif
/* ------------------- 然后计算 encrypt_round_key_ ------------------- */
// 中间操作需要两个临时的数组
unsigned char temp[ 2 ][SECTION_LEN];
for ( size_t i = 1 ; i < NUM_OF_ROUND_KEY; ++ i )
{
this -> rotate_key( ROUND_KEY_OP_ARRAY[i][ 0 ], W[ ROUND_KEY_OP_ARRAY[i][ 1 ] ], ROUND_KEY_OP_ARRAY[i][ 2 ], temp[ 0 ] );
this -> rotate_key( ROUND_KEY_OP_ARRAY[i][ 3 ], W[ ROUND_KEY_OP_ARRAY[i][ 4 ] ], ROUND_KEY_OP_ARRAY[i][ 5 ], temp[ 1 ] );
this -> key_xor( temp[ 0 ], temp[ 1 ], encrypt_round_key_[i] );
}
#if TEST // 测试输出 encrypt round key
for ( size_t i = 1 ; i < NUM_OF_ROUND_KEY; ++ i )
{
for ( size_t j = 0 ; j < SECTION_LEN; ++ j )
printf( " %02x " , encrypt_round_key_[i][j]);
printf( " \n " );
}
printf( " ENCRYPT ROUND KEY END\n\n " );
#endif
/* ------------------- 然后计算 decrypt_round_key_ ------------------- */
memcpy( decrypt_round_key_[ 1 ], encrypt_round_key_[rounds_ + 1 ], SECTION_LEN );
memcpy( decrypt_round_key_[rounds_ + 1 ], encrypt_round_key_[ 1 ], SECTION_LEN );
for ( size_t i = 2 ; i <= rounds_; ++ i )
{
memcpy( decrypt_round_key_[i], encrypt_round_key_[rounds_ + 2 - i], SECTION_LEN );
this -> diffuse( decrypt_round_key_[i] );
}
#if TEST // 测试输出 decrypt round key
for ( size_t i = 1 ; i < NUM_OF_ROUND_KEY; ++ i )
{
for ( size_t j = 0 ; j < SECTION_LEN; ++ j )
printf( " %02x " , decrypt_round_key_[i][j]);
printf( " \n " );
}
printf( " DECRYPT ROUND KEY END\n\n " );
#endif
}
template < int key_length >
void ARIA < key_length > ::diffuse( block input ) // The Diffusion Layer Function
{
unsigned char temp[SECTION_LEN];
memcpy ( temp, input, SECTION_LEN );
for ( size_t i = 0 ; i < SECTION_LEN; ++ i )
{
input[i] =
temp[ DIFFUSE_OPERATION[i][ 0 ] ] ^
temp[ DIFFUSE_OPERATION[i][ 1 ] ] ^
temp[ DIFFUSE_OPERATION[i][ 2 ] ] ^
temp[ DIFFUSE_OPERATION[i][ 3 ] ] ^
temp[ DIFFUSE_OPERATION[i][ 4 ] ] ^
temp[ DIFFUSE_OPERATION[i][ 5 ] ] ^
temp[ DIFFUSE_OPERATION[i][ 6 ] ];
}
}
/* ------------------- 下面是一些针对内存块的功能函数 ------------------- */
template < int key_length >
void ARIA < key_length > ::key_xor ( const_block lhs, const_block rhs, block output ) // 针对 128 bit 的序列专门设计的异或函数
{
for ( size_t i = 0 ; i < SECTION_LEN; ++ i )
output[i] = lhs[i] ^ rhs[i];
}
template < int key_length >
void ARIA < key_length > ::rotate_key ( unsigned short types, const_block input, size_t move_bits, block output ) // 针对 128 bit 的序列专门设计的循环移位函数
{
size_t move_bytes = move_bits / 8 ;
size_t remain_bits = move_bits % 8 ;
unsigned char higher_bit;
unsigned char lower_bit;
if ( LEFT == types )
{
memcpy ( output, input + move_bytes, SECTION_LEN - move_bytes );
memcpy ( output + SECTION_LEN - move_bytes, input, move_bytes );
for ( size_t i = 0 ; i < remain_bits; ++ i )
{
higher_bit = (output[ 0 ] & 0x80 ) >> 7 ; // 保存最高位
for ( size_t j = 0 ; j < SECTION_LEN - 1 ; ++ j )
{
output[j] <<= 1 ; // 左移之后，最低位用 0 补齐
lower_bit = (output[j + 1 ] & 0x80 ) >> 7 ;
output[j] |= lower_bit; // 0 | lower_bit = lower_bit
}
output[SECTION_LEN - 1 ] <<= 1 ;
output[SECTION_LEN - 1 ] |= higher_bit;
}
return ;
}
if ( RIGHT == types )
{
memcpy ( output, input + SECTION_LEN - move_bytes, move_bytes );
memcpy ( output + move_bytes, input, SECTION_LEN - move_bytes );
for ( size_t i = 0 ; i < remain_bits; ++ i )
{
lower_bit = (output[ 0 ] & 0x01 ) << 7 ;
higher_bit = (output[SECTION_LEN - 1 ] & 0x01 ) << 7 ; // 保存最低位
output[ 0 ] >>= 1 ; // 右移之后，最高位用 0 补齐
output[ 0 ] |= higher_bit; // 0 | lower_bit = lower_bit
for ( size_t j = 1 ; j < SECTION_LEN; ++ j )
{
higher_bit = lower_bit;
lower_bit = (output[j] & 0x01 ) << 7 ;
output[j] >>= 1 ; // 右移之后，最高位用 0 补齐
output[j] |= higher_bit; // 0 | higher_bit = higher_bit
}
}
}
if ( NOP == types )
{
memcpy ( output, input, SECTION_LEN );
}
}
template < int key_length >
void ARIA < key_length > ::print_block( const_block text )
{
for ( size_t i = 0 ; i < SECTION_LEN; ++ i )
{
printf( " %02x " , text[i] );
}
printf( " \n " );
}
template < int key_length >
bool ARIA < key_length > ::compare_section( const unsigned char * lhs, const unsigned char * rhs, size_t len )
{
for ( size_t i = 0 ; i < len; ++ i )
{
if ( lhs[i] != rhs[i] )
return false ;
}
return true ;
}
/* -------------------------------------------------------------------------------------------------------------------------------- */
}
#endif
#define _ARIA_H_
#include < cstdio >
#include < cstring >
#include " constant.h "
#define TEST 0
namespace triod
{
template < int key_length >
class ARIA
{
public :
typedef const unsigned char ( & const_block) [key_length];
typedef unsigned char ( & block) [key_length];
ARIA( const_block key );
void encrypt( const_block text, block cipher ); // 注意rounds_比实际的加密需要的轮数少一轮，用于最后一步的不做diffuse的运算
void decrypt( const_block cipher, block text );
/* ---------------------------------------------------------------------------------------- */
protected :
virtual void function ( size_t round, block input, const_block round_key );
virtual void function_last_round ( block input, const_block round_key );
void generate_round_key(); // 生成轮密钥函数
void diffuse( block input ); // The Diffusion Layer Function
static void key_xor ( const_block lhs, const_block rhs, block output ); // 针对 128 bit 的序列专门设计的异或函数
static void rotate_key ( unsigned short types, const_block input, size_t move_bits, block output ); // 针对 128 bit 的序列专门设计的循环移位函数
static void print_block( const_block text );
static bool compare_section( const unsigned char * lhs, const unsigned char * rhs, size_t len );
unsigned char key_[MAX_KEY_WIDTH]; // 主密钥, 256 bit
unsigned char encrypt_round_key_[NUM_OF_ROUND_KEY][SECTION_LEN]; // 16 个加密轮密钥，每个 128 bit
unsigned char decrypt_round_key_[NUM_OF_ROUND_KEY][SECTION_LEN]; // 16 个解密轮密钥，每个 128 bit
size_t rounds_;
};
}
/* -------------------------------------------------------------------------------------------------------------------------------- */
namespace triod
{
template < int key_length >
ARIA < key_length > ::ARIA( const_block key )
{
// 一个小小技巧，用于在编译期防止 key_length 非法
char guard[(key_length == MIN_LEN || key_length == MID_LEN || key_length == MAX_LEN) ? 1 : - 1 ] = { 0 };
// 另一个技巧，计算加密解密轮数
rounds_ = ROUNDS_BY_KEY_LENGTH[key_length / 10 ];
memset( key_, 0 , MAX_KEY_WIDTH );
for ( size_t i = 0 ; i < NUM_OF_ROUND_KEY; ++ i )
{
memset( encrypt_round_key_[i], 0 , SECTION_LEN );
memset( decrypt_round_key_[i], 0 , SECTION_LEN );
}
// 不用 memcpy
for ( size_t i = 0 ; i < key_length; ++ i )
key_[i] = key[i];
this -> generate_round_key();
}
template < int key_length >
void ARIA < key_length > ::encrypt( const_block text, block cipher ) // 注意rounds_比实际的加密需要的轮数少一轮，用于最后一步的不做diffuse的运算
{
memcpy ( cipher, text, SECTION_LEN );
for ( size_t i = 1 ; i < rounds_; ++ i )
{
this -> function( i, cipher, encrypt_round_key_[i] );
#if TEST
this -> print_block( cipher );
#endif
}
this -> function_last_round( cipher, encrypt_round_key_[rounds_] );
this -> key_xor( cipher, encrypt_round_key_[rounds_ + 1 ], cipher );
#if TEST
this -> print_block( cipher );
printf( " Encrypt TEXT\n\n " );
#endif
}
template < int key_length >
void ARIA < key_length > ::decrypt( const_block cipher, block text )
{
// 注意rounds_比实际的加密需要的轮数少一轮，用于最后一步的不做diffuse的运算
memcpy ( text, cipher, SECTION_LEN );
for ( size_t i = 1 ; i < rounds_; ++ i )
{
this -> function( i % 2 == 1 , text, decrypt_round_key_[i] );
#if TEST
for ( size_t j = 0 ; j < SECTION_LEN; ++ j )
printf( " %02x " , text[j] );
printf( " \n " );
#endif
}
this -> function_last_round( text, decrypt_round_key_[rounds_] );
this -> key_xor( text, decrypt_round_key_[rounds_ + 1 ], text );
#if TEST
for ( size_t j = 0 ; j < SECTION_LEN; ++ j )
printf( " %02x " , text[j] );
printf( " \nDecrypt TEXT\n\n " );
#endif
}
/* ---------------------------------------------------------------------------------------- */
template < int key_length >
void ARIA < key_length > ::function ( size_t round, block input, const_block round_key )
{
bool is_odd_layer = ( round % 2 == 1 );
// 第一步，XOR
this -> key_xor( input, round_key, input );
// 第二步，S-box layer
for ( size_t i = 0 ; i < SECTION_LEN; ++ i )
{
input[i] = SBOX[ is_odd_layer ? ODD_LAYER_BOX[i] : EVEN_LAYER_BOX[i] ][ input[i] ];
}
// 第三步，diffusion layer
this -> diffuse( input );
}
template < int key_length >
void ARIA < key_length > ::function_last_round ( block input, const_block round_key )
{
this -> key_xor( input, round_key, input ); // 第一步，XOR
for ( size_t i = 0 ; i < SECTION_LEN; ++ i ) // 第二步，S-box layer
input[i] = SBOX[EVEN_LAYER_BOX[i]][input[i]];
}
template < int key_length >
void ARIA < key_length > ::generate_round_key() // 生成轮密钥函数
{
// W 共有 4 个，每个 128 bit
unsigned char W[ 4 ][SECTION_LEN];
// kR，即 main key 的右 128 bits
unsigned char KR[SECTION_LEN];
memcpy ( KR, key_ + SECTION_LEN, SECTION_LEN );
/* ------------------- 首先初始化 W 数组 ------------------- */
// W[0] = KL，即 main key 的左 128 bits
memcpy ( W[ 0 ], key_, SECTION_LEN );
// 这里采用查表的方法:CK[ CK_ORDER[key_length / 10][0] ]
// 来处理密钥长度不同时，CK不同的情况
memcpy( W[ 1 ], W[ 0 ], SECTION_LEN );
this -> function( true , W[ 1 ], CK[ CK_ORDER[key_length / 10 ][ 0 ] ] );
this -> key_xor( W[ 1 ], KR, W[ 1 ] );
memcpy( W[ 2 ], W[ 1 ], SECTION_LEN );
this -> function( false , W[ 2 ], CK[ CK_ORDER[key_length / 10 ][ 1 ] ] );
this -> key_xor( W[ 2 ], W[ 0 ], W[ 2 ] );
memcpy( W[ 3 ], W[ 2 ], SECTION_LEN );
this -> function( true , W[ 3 ], CK[ CK_ORDER[key_length / 10 ][ 2 ] ] );
this -> key_xor( W[ 3 ], W[ 1 ], W[ 3 ] );
#if TEST // 测试输出 W[k]
for ( size_t i = 0 ; i < 4 ; ++ i )
{
for ( size_t j = 0 ; j < 16 ; ++ j )
printf( " %02x " , W[i][j]);
printf( " \n " );
}
printf( " W[k] END\n\n " );
#endif
/* ------------------- 然后计算 encrypt_round_key_ ------------------- */
// 中间操作需要两个临时的数组
unsigned char temp[ 2 ][SECTION_LEN];
for ( size_t i = 1 ; i < NUM_OF_ROUND_KEY; ++ i )
{
this -> rotate_key( ROUND_KEY_OP_ARRAY[i][ 0 ], W[ ROUND_KEY_OP_ARRAY[i][ 1 ] ], ROUND_KEY_OP_ARRAY[i][ 2 ], temp[ 0 ] );
this -> rotate_key( ROUND_KEY_OP_ARRAY[i][ 3 ], W[ ROUND_KEY_OP_ARRAY[i][ 4 ] ], ROUND_KEY_OP_ARRAY[i][ 5 ], temp[ 1 ] );
this -> key_xor( temp[ 0 ], temp[ 1 ], encrypt_round_key_[i] );
}
#if TEST // 测试输出 encrypt round key
for ( size_t i = 1 ; i < NUM_OF_ROUND_KEY; ++ i )
{
for ( size_t j = 0 ; j < SECTION_LEN; ++ j )
printf( " %02x " , encrypt_round_key_[i][j]);
printf( " \n " );
}
printf( " ENCRYPT ROUND KEY END\n\n " );
#endif
/* ------------------- 然后计算 decrypt_round_key_ ------------------- */
memcpy( decrypt_round_key_[ 1 ], encrypt_round_key_[rounds_ + 1 ], SECTION_LEN );
memcpy( decrypt_round_key_[rounds_ + 1 ], encrypt_round_key_[ 1 ], SECTION_LEN );
for ( size_t i = 2 ; i <= rounds_; ++ i )
{
memcpy( decrypt_round_key_[i], encrypt_round_key_[rounds_ + 2 - i], SECTION_LEN );
this -> diffuse( decrypt_round_key_[i] );
}
#if TEST // 测试输出 decrypt round key
for ( size_t i = 1 ; i < NUM_OF_ROUND_KEY; ++ i )
{
for ( size_t j = 0 ; j < SECTION_LEN; ++ j )
printf( " %02x " , decrypt_round_key_[i][j]);
printf( " \n " );
}
printf( " DECRYPT ROUND KEY END\n\n " );
#endif
}
template < int key_length >
void ARIA < key_length > ::diffuse( block input ) // The Diffusion Layer Function
{
unsigned char temp[SECTION_LEN];
memcpy ( temp, input, SECTION_LEN );
for ( size_t i = 0 ; i < SECTION_LEN; ++ i )
{
input[i] =
temp[ DIFFUSE_OPERATION[i][ 0 ] ] ^
temp[ DIFFUSE_OPERATION[i][ 1 ] ] ^
temp[ DIFFUSE_OPERATION[i][ 2 ] ] ^
temp[ DIFFUSE_OPERATION[i][ 3 ] ] ^
temp[ DIFFUSE_OPERATION[i][ 4 ] ] ^
temp[ DIFFUSE_OPERATION[i][ 5 ] ] ^
temp[ DIFFUSE_OPERATION[i][ 6 ] ];
}
}
/* ------------------- 下面是一些针对内存块的功能函数 ------------------- */
template < int key_length >
void ARIA < key_length > ::key_xor ( const_block lhs, const_block rhs, block output ) // 针对 128 bit 的序列专门设计的异或函数
{
for ( size_t i = 0 ; i < SECTION_LEN; ++ i )
output[i] = lhs[i] ^ rhs[i];
}
template < int key_length >
void ARIA < key_length > ::rotate_key ( unsigned short types, const_block input, size_t move_bits, block output ) // 针对 128 bit 的序列专门设计的循环移位函数
{
size_t move_bytes = move_bits / 8 ;
size_t remain_bits = move_bits % 8 ;
unsigned char higher_bit;
unsigned char lower_bit;
if ( LEFT == types )
{
memcpy ( output, input + move_bytes, SECTION_LEN - move_bytes );
memcpy ( output + SECTION_LEN - move_bytes, input, move_bytes );
for ( size_t i = 0 ; i < remain_bits; ++ i )
{
higher_bit = (output[ 0 ] & 0x80 ) >> 7 ; // 保存最高位
for ( size_t j = 0 ; j < SECTION_LEN - 1 ; ++ j )
{
output[j] <<= 1 ; // 左移之后，最低位用 0 补齐
lower_bit = (output[j + 1 ] & 0x80 ) >> 7 ;
output[j] |= lower_bit; // 0 | lower_bit = lower_bit
}
output[SECTION_LEN - 1 ] <<= 1 ;
output[SECTION_LEN - 1 ] |= higher_bit;
}
return ;
}
if ( RIGHT == types )
{
memcpy ( output, input + SECTION_LEN - move_bytes, move_bytes );
memcpy ( output + move_bytes, input, SECTION_LEN - move_bytes );
for ( size_t i = 0 ; i < remain_bits; ++ i )
{
lower_bit = (output[ 0 ] & 0x01 ) << 7 ;
higher_bit = (output[SECTION_LEN - 1 ] & 0x01 ) << 7 ; // 保存最低位
output[ 0 ] >>= 1 ; // 右移之后，最高位用 0 补齐
output[ 0 ] |= higher_bit; // 0 | lower_bit = lower_bit
for ( size_t j = 1 ; j < SECTION_LEN; ++ j )
{
higher_bit = lower_bit;
lower_bit = (output[j] & 0x01 ) << 7 ;
output[j] >>= 1 ; // 右移之后，最高位用 0 补齐
output[j] |= higher_bit; // 0 | higher_bit = higher_bit
}
}
}
if ( NOP == types )
{
memcpy ( output, input, SECTION_LEN );
}
}
template < int key_length >
void ARIA < key_length > ::print_block( const_block text )
{
for ( size_t i = 0 ; i < SECTION_LEN; ++ i )
{
printf( " %02x " , text[i] );
}
printf( " \n " );
}
template < int key_length >
bool ARIA < key_length > ::compare_section( const unsigned char * lhs, const unsigned char * rhs, size_t len )
{
for ( size_t i = 0 ; i < len; ++ i )
{
if ( lhs[i] != rhs[i] )
return false ;
}
return true ;
}
/* -------------------------------------------------------------------------------------------------------------------------------- */
}
#endif
test.cpp
#include
"
ARIA.h
"
#define NUM 16
int main()
{
using triod::ARIA;
// unsigned char key[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
unsigned char key[] = { 0x00 , 0x11 , 0x22 , 0x33 , 0x44 , 0x55 , 0x66 , 0x77 , 0x88 , 0x99 , 0xaa , 0xbb , 0xcc , 0xdd , 0xee , 0xff };
unsigned char plaintext[] = { 0x11 , 0x11 , 0x11 , 0x11 , 0xaa , 0xaa , 0xaa , 0xaa , 0x11 , 0x11 , 0x11 , 0x11 , 0xbb , 0xbb , 0xbb , 0xbb };
unsigned char plaintest[] = { 0x30 , 0x26 , 0xB2 , 0x75 , 0x8E , 0x66 , 0xCF , 0x11 , 0xA6 , 0xD9 , 0xAA , 0x00 , 0x62 , 0xCE , 0x6C , 0xD4 };
/*
unsigned char key[] =
{
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
};
*/
/*
unsigned char key[] =
{
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff
};
*/
ARIA < sizeof (key) > test(key);
unsigned char cipher[ 2 ][NUM];
test.encrypt( plaintext, cipher[ 0 ] );
test.encrypt( plaintest, cipher[ 1 ] );
unsigned char t[NUM];
test.decrypt( cipher[ 1 ], t );
for ( size_t j = 0 ; j < NUM; ++ j )
printf( " %2x " , t[j] );
return 0 ;
}
#define NUM 16
int main()
{
using triod::ARIA;
// unsigned char key[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
unsigned char key[] = { 0x00 , 0x11 , 0x22 , 0x33 , 0x44 , 0x55 , 0x66 , 0x77 , 0x88 , 0x99 , 0xaa , 0xbb , 0xcc , 0xdd , 0xee , 0xff };
unsigned char plaintext[] = { 0x11 , 0x11 , 0x11 , 0x11 , 0xaa , 0xaa , 0xaa , 0xaa , 0x11 , 0x11 , 0x11 , 0x11 , 0xbb , 0xbb , 0xbb , 0xbb };
unsigned char plaintest[] = { 0x30 , 0x26 , 0xB2 , 0x75 , 0x8E , 0x66 , 0xCF , 0x11 , 0xA6 , 0xD9 , 0xAA , 0x00 , 0x62 , 0xCE , 0x6C , 0xD4 };
/*
unsigned char key[] =
{
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
};
*/
/*
unsigned char key[] =
{
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff
};
*/
ARIA < sizeof (key) > test(key);
unsigned char cipher[ 2 ][NUM];
test.encrypt( plaintext, cipher[ 0 ] );
test.encrypt( plaintest, cipher[ 1 ] );
unsigned char t[NUM];
test.decrypt( cipher[ 1 ], t );
for ( size_t j = 0 ; j < NUM; ++ j )
printf( " %2x " , t[j] );
return 0 ;
}