1557 lines
31 KiB
C++
1557 lines
31 KiB
C++
/*
|
|
* This file is a part of Tito - a cryptography library
|
|
* and is distributed under the 2-Clause BSD licence.
|
|
* Author: Tomasz Sowa <t.sowa@ttmath.org>
|
|
*/
|
|
|
|
/*
|
|
* Copyright (c) 2012-2022, Tomasz Sowa
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include "aes.h"
|
|
|
|
|
|
namespace Tito
|
|
{
|
|
|
|
|
|
|
|
AES::uint8 AES::sbox[16][16] = {
|
|
{ 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 }};
|
|
|
|
|
|
AES::uint8 AES::invsbox[16][16] = {
|
|
{ 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 }};
|
|
|
|
|
|
|
|
int AES::mixcolumntab[4][4] = {
|
|
{2, 3, 1, 1},
|
|
{1, 2, 3, 1},
|
|
{1, 1, 2, 3},
|
|
{3, 1, 1, 2}};
|
|
|
|
|
|
int AES::invmixcolumntab[4][4] = {
|
|
{14, 11, 13, 9},
|
|
{9, 14, 11, 13},
|
|
{13, 9, 14, 11},
|
|
{11, 13, 9, 14}};
|
|
|
|
|
|
|
|
AES::uint8 AES::Rcon[10] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36};
|
|
|
|
|
|
|
|
AES::uint8 AES::gf_mul9[16][16] = {
|
|
{ 0x00,0x09,0x12,0x1b,0x24,0x2d,0x36,0x3f,0x48,0x41,0x5a,0x53,0x6c,0x65,0x7e,0x77 },
|
|
{ 0x90,0x99,0x82,0x8b,0xb4,0xbd,0xa6,0xaf,0xd8,0xd1,0xca,0xc3,0xfc,0xf5,0xee,0xe7 },
|
|
{ 0x3b,0x32,0x29,0x20,0x1f,0x16,0x0d,0x04,0x73,0x7a,0x61,0x68,0x57,0x5e,0x45,0x4c },
|
|
{ 0xab,0xa2,0xb9,0xb0,0x8f,0x86,0x9d,0x94,0xe3,0xea,0xf1,0xf8,0xc7,0xce,0xd5,0xdc },
|
|
{ 0x76,0x7f,0x64,0x6d,0x52,0x5b,0x40,0x49,0x3e,0x37,0x2c,0x25,0x1a,0x13,0x08,0x01 },
|
|
{ 0xe6,0xef,0xf4,0xfd,0xc2,0xcb,0xd0,0xd9,0xae,0xa7,0xbc,0xb5,0x8a,0x83,0x98,0x91 },
|
|
{ 0x4d,0x44,0x5f,0x56,0x69,0x60,0x7b,0x72,0x05,0x0c,0x17,0x1e,0x21,0x28,0x33,0x3a },
|
|
{ 0xdd,0xd4,0xcf,0xc6,0xf9,0xf0,0xeb,0xe2,0x95,0x9c,0x87,0x8e,0xb1,0xb8,0xa3,0xaa },
|
|
{ 0xec,0xe5,0xfe,0xf7,0xc8,0xc1,0xda,0xd3,0xa4,0xad,0xb6,0xbf,0x80,0x89,0x92,0x9b },
|
|
{ 0x7c,0x75,0x6e,0x67,0x58,0x51,0x4a,0x43,0x34,0x3d,0x26,0x2f,0x10,0x19,0x02,0x0b },
|
|
{ 0xd7,0xde,0xc5,0xcc,0xf3,0xfa,0xe1,0xe8,0x9f,0x96,0x8d,0x84,0xbb,0xb2,0xa9,0xa0 },
|
|
{ 0x47,0x4e,0x55,0x5c,0x63,0x6a,0x71,0x78,0x0f,0x06,0x1d,0x14,0x2b,0x22,0x39,0x30 },
|
|
{ 0x9a,0x93,0x88,0x81,0xbe,0xb7,0xac,0xa5,0xd2,0xdb,0xc0,0xc9,0xf6,0xff,0xe4,0xed },
|
|
{ 0x0a,0x03,0x18,0x11,0x2e,0x27,0x3c,0x35,0x42,0x4b,0x50,0x59,0x66,0x6f,0x74,0x7d },
|
|
{ 0xa1,0xa8,0xb3,0xba,0x85,0x8c,0x97,0x9e,0xe9,0xe0,0xfb,0xf2,0xcd,0xc4,0xdf,0xd6 },
|
|
{ 0x31,0x38,0x23,0x2a,0x15,0x1c,0x07,0x0e,0x79,0x70,0x6b,0x62,0x5d,0x54,0x4f,0x46 }};
|
|
|
|
|
|
AES::uint8 AES::gf_mul11[16][16] = {
|
|
{ 0x00,0x0b,0x16,0x1d,0x2c,0x27,0x3a,0x31,0x58,0x53,0x4e,0x45,0x74,0x7f,0x62,0x69 },
|
|
{ 0xb0,0xbb,0xa6,0xad,0x9c,0x97,0x8a,0x81,0xe8,0xe3,0xfe,0xf5,0xc4,0xcf,0xd2,0xd9 },
|
|
{ 0x7b,0x70,0x6d,0x66,0x57,0x5c,0x41,0x4a,0x23,0x28,0x35,0x3e,0x0f,0x04,0x19,0x12 },
|
|
{ 0xcb,0xc0,0xdd,0xd6,0xe7,0xec,0xf1,0xfa,0x93,0x98,0x85,0x8e,0xbf,0xb4,0xa9,0xa2 },
|
|
{ 0xf6,0xfd,0xe0,0xeb,0xda,0xd1,0xcc,0xc7,0xae,0xa5,0xb8,0xb3,0x82,0x89,0x94,0x9f },
|
|
{ 0x46,0x4d,0x50,0x5b,0x6a,0x61,0x7c,0x77,0x1e,0x15,0x08,0x03,0x32,0x39,0x24,0x2f },
|
|
{ 0x8d,0x86,0x9b,0x90,0xa1,0xaa,0xb7,0xbc,0xd5,0xde,0xc3,0xc8,0xf9,0xf2,0xef,0xe4 },
|
|
{ 0x3d,0x36,0x2b,0x20,0x11,0x1a,0x07,0x0c,0x65,0x6e,0x73,0x78,0x49,0x42,0x5f,0x54 },
|
|
{ 0xf7,0xfc,0xe1,0xea,0xdb,0xd0,0xcd,0xc6,0xaf,0xa4,0xb9,0xb2,0x83,0x88,0x95,0x9e },
|
|
{ 0x47,0x4c,0x51,0x5a,0x6b,0x60,0x7d,0x76,0x1f,0x14,0x09,0x02,0x33,0x38,0x25,0x2e },
|
|
{ 0x8c,0x87,0x9a,0x91,0xa0,0xab,0xb6,0xbd,0xd4,0xdf,0xc2,0xc9,0xf8,0xf3,0xee,0xe5 },
|
|
{ 0x3c,0x37,0x2a,0x21,0x10,0x1b,0x06,0x0d,0x64,0x6f,0x72,0x79,0x48,0x43,0x5e,0x55 },
|
|
{ 0x01,0x0a,0x17,0x1c,0x2d,0x26,0x3b,0x30,0x59,0x52,0x4f,0x44,0x75,0x7e,0x63,0x68 },
|
|
{ 0xb1,0xba,0xa7,0xac,0x9d,0x96,0x8b,0x80,0xe9,0xe2,0xff,0xf4,0xc5,0xce,0xd3,0xd8 },
|
|
{ 0x7a,0x71,0x6c,0x67,0x56,0x5d,0x40,0x4b,0x22,0x29,0x34,0x3f,0x0e,0x05,0x18,0x13 },
|
|
{ 0xca,0xc1,0xdc,0xd7,0xe6,0xed,0xf0,0xfb,0x92,0x99,0x84,0x8f,0xbe,0xb5,0xa8,0xa3 }};
|
|
|
|
|
|
AES::uint8 AES::gf_mul13[16][16] = {
|
|
{ 0x00,0x0d,0x1a,0x17,0x34,0x39,0x2e,0x23,0x68,0x65,0x72,0x7f,0x5c,0x51,0x46,0x4b },
|
|
{ 0xd0,0xdd,0xca,0xc7,0xe4,0xe9,0xfe,0xf3,0xb8,0xb5,0xa2,0xaf,0x8c,0x81,0x96,0x9b },
|
|
{ 0xbb,0xb6,0xa1,0xac,0x8f,0x82,0x95,0x98,0xd3,0xde,0xc9,0xc4,0xe7,0xea,0xfd,0xf0 },
|
|
{ 0x6b,0x66,0x71,0x7c,0x5f,0x52,0x45,0x48,0x03,0x0e,0x19,0x14,0x37,0x3a,0x2d,0x20 },
|
|
{ 0x6d,0x60,0x77,0x7a,0x59,0x54,0x43,0x4e,0x05,0x08,0x1f,0x12,0x31,0x3c,0x2b,0x26 },
|
|
{ 0xbd,0xb0,0xa7,0xaa,0x89,0x84,0x93,0x9e,0xd5,0xd8,0xcf,0xc2,0xe1,0xec,0xfb,0xf6 },
|
|
{ 0xd6,0xdb,0xcc,0xc1,0xe2,0xef,0xf8,0xf5,0xbe,0xb3,0xa4,0xa9,0x8a,0x87,0x90,0x9d },
|
|
{ 0x06,0x0b,0x1c,0x11,0x32,0x3f,0x28,0x25,0x6e,0x63,0x74,0x79,0x5a,0x57,0x40,0x4d },
|
|
{ 0xda,0xd7,0xc0,0xcd,0xee,0xe3,0xf4,0xf9,0xb2,0xbf,0xa8,0xa5,0x86,0x8b,0x9c,0x91 },
|
|
{ 0x0a,0x07,0x10,0x1d,0x3e,0x33,0x24,0x29,0x62,0x6f,0x78,0x75,0x56,0x5b,0x4c,0x41 },
|
|
{ 0x61,0x6c,0x7b,0x76,0x55,0x58,0x4f,0x42,0x09,0x04,0x13,0x1e,0x3d,0x30,0x27,0x2a },
|
|
{ 0xb1,0xbc,0xab,0xa6,0x85,0x88,0x9f,0x92,0xd9,0xd4,0xc3,0xce,0xed,0xe0,0xf7,0xfa },
|
|
{ 0xb7,0xba,0xad,0xa0,0x83,0x8e,0x99,0x94,0xdf,0xd2,0xc5,0xc8,0xeb,0xe6,0xf1,0xfc },
|
|
{ 0x67,0x6a,0x7d,0x70,0x53,0x5e,0x49,0x44,0x0f,0x02,0x15,0x18,0x3b,0x36,0x21,0x2c },
|
|
{ 0x0c,0x01,0x16,0x1b,0x38,0x35,0x22,0x2f,0x64,0x69,0x7e,0x73,0x50,0x5d,0x4a,0x47 },
|
|
{ 0xdc,0xd1,0xc6,0xcb,0xe8,0xe5,0xf2,0xff,0xb4,0xb9,0xae,0xa3,0x80,0x8d,0x9a,0x97 }};
|
|
|
|
|
|
AES::uint8 AES::gf_mul14[16][16] = {
|
|
{ 0x00,0x0e,0x1c,0x12,0x38,0x36,0x24,0x2a,0x70,0x7e,0x6c,0x62,0x48,0x46,0x54,0x5a },
|
|
{ 0xe0,0xee,0xfc,0xf2,0xd8,0xd6,0xc4,0xca,0x90,0x9e,0x8c,0x82,0xa8,0xa6,0xb4,0xba },
|
|
{ 0xdb,0xd5,0xc7,0xc9,0xe3,0xed,0xff,0xf1,0xab,0xa5,0xb7,0xb9,0x93,0x9d,0x8f,0x81 },
|
|
{ 0x3b,0x35,0x27,0x29,0x03,0x0d,0x1f,0x11,0x4b,0x45,0x57,0x59,0x73,0x7d,0x6f,0x61 },
|
|
{ 0xad,0xa3,0xb1,0xbf,0x95,0x9b,0x89,0x87,0xdd,0xd3,0xc1,0xcf,0xe5,0xeb,0xf9,0xf7 },
|
|
{ 0x4d,0x43,0x51,0x5f,0x75,0x7b,0x69,0x67,0x3d,0x33,0x21,0x2f,0x05,0x0b,0x19,0x17 },
|
|
{ 0x76,0x78,0x6a,0x64,0x4e,0x40,0x52,0x5c,0x06,0x08,0x1a,0x14,0x3e,0x30,0x22,0x2c },
|
|
{ 0x96,0x98,0x8a,0x84,0xae,0xa0,0xb2,0xbc,0xe6,0xe8,0xfa,0xf4,0xde,0xd0,0xc2,0xcc },
|
|
{ 0x41,0x4f,0x5d,0x53,0x79,0x77,0x65,0x6b,0x31,0x3f,0x2d,0x23,0x09,0x07,0x15,0x1b },
|
|
{ 0xa1,0xaf,0xbd,0xb3,0x99,0x97,0x85,0x8b,0xd1,0xdf,0xcd,0xc3,0xe9,0xe7,0xf5,0xfb },
|
|
{ 0x9a,0x94,0x86,0x88,0xa2,0xac,0xbe,0xb0,0xea,0xe4,0xf6,0xf8,0xd2,0xdc,0xce,0xc0 },
|
|
{ 0x7a,0x74,0x66,0x68,0x42,0x4c,0x5e,0x50,0x0a,0x04,0x16,0x18,0x32,0x3c,0x2e,0x20 },
|
|
{ 0xec,0xe2,0xf0,0xfe,0xd4,0xda,0xc8,0xc6,0x9c,0x92,0x80,0x8e,0xa4,0xaa,0xb8,0xb6 },
|
|
{ 0x0c,0x02,0x10,0x1e,0x34,0x3a,0x28,0x26,0x7c,0x72,0x60,0x6e,0x44,0x4a,0x58,0x56 },
|
|
{ 0x37,0x39,0x2b,0x25,0x0f,0x01,0x13,0x1d,0x47,0x49,0x5b,0x55,0x7f,0x71,0x63,0x6d },
|
|
{ 0xd7,0xd9,0xcb,0xc5,0xef,0xe1,0xf3,0xfd,0xa7,0xa9,0xbb,0xb5,0x9f,0x91,0x83,0x8d }};
|
|
|
|
|
|
|
|
AES::AES()
|
|
{
|
|
plog = nullptr;
|
|
}
|
|
|
|
|
|
void AES::CopyToData(const AES::uint8 * state)
|
|
{
|
|
int x, y, index = 0;
|
|
|
|
for(x=0 ; x<4 ; ++x)
|
|
for(y=0 ; y<4 ; ++y)
|
|
data[y][x] = state[index++];
|
|
}
|
|
|
|
|
|
void AES::XorCopyToData(const AES::uint8 * state, const AES::uint8 * iv)
|
|
{
|
|
int x, y, index = 0;
|
|
|
|
for(x=0 ; x<4 ; ++x)
|
|
{
|
|
for(y=0 ; y<4 ; ++y)
|
|
{
|
|
data[y][x] = (state[index] ^ iv[index]);
|
|
index += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void AES::CopyFromData(AES::uint8 * state)
|
|
{
|
|
int x, y, index = 0;
|
|
|
|
for(x=0 ; x<4 ; ++x)
|
|
for(y=0 ; y<4 ; ++y)
|
|
state[index++] = data[y][x];
|
|
}
|
|
|
|
|
|
void AES::XorCopyFromData(AES::uint8 * state, const AES::uint8 * iv)
|
|
{
|
|
int x, y, index = 0;
|
|
|
|
for(x=0 ; x<4 ; ++x)
|
|
{
|
|
for(y=0 ; y<4 ; ++y)
|
|
{
|
|
state[index] = (data[y][x] ^ iv[index]);
|
|
index += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void AES::CopyFromData(std::vector<uint8> & out, bool clear)
|
|
{
|
|
int x, y;
|
|
|
|
if( clear )
|
|
out.clear();
|
|
|
|
if( out.size() + 16 > out.capacity() )
|
|
out.reserve(out.size() + 16);
|
|
|
|
for(x=0 ; x<4 ; ++x)
|
|
for(y=0 ; y<4 ; ++y)
|
|
out.push_back(data[y][x]);
|
|
}
|
|
|
|
|
|
|
|
void AES::PrintData()
|
|
{
|
|
int x, y;
|
|
char buf[20];
|
|
|
|
if( plog )
|
|
{
|
|
for(y=0 ; y<4 ; ++y)
|
|
{
|
|
for(x=0 ; x<4 ; ++x)
|
|
{
|
|
sprintf(buf, "%02x ", data[y][x]);
|
|
(*plog) << pt::Log::log4 << buf;
|
|
}
|
|
|
|
(*plog) << pt::Log::logend;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void AES::PrintKey(AES::uint8 * key_src, int key_length)
|
|
{
|
|
char buf[20];
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << "AES key, key_length: " << key_length << pt::Log::logend;
|
|
|
|
for(int i=0 ; i < key_length ; ++i)
|
|
{
|
|
sprintf(buf, "%02x", key_src[i]);
|
|
(*plog) << pt::Log::log4 << buf << " ";
|
|
}
|
|
|
|
(*plog) << pt::Log::logend;
|
|
}
|
|
}
|
|
|
|
|
|
void AES::PrintKey(int xs)
|
|
{
|
|
int x, y;
|
|
char buf[20];
|
|
|
|
if( plog )
|
|
{
|
|
for(y=0 ; y<4 ; ++y)
|
|
{
|
|
for(x=xs ; x<xs+key_col ; ++x)
|
|
{
|
|
sprintf(buf, "%02x ", key[y][x]);
|
|
(*plog) << pt::Log::log4 << buf << " ";
|
|
}
|
|
|
|
(*plog) << pt::Log::logend;
|
|
}
|
|
}
|
|
}
|
|
|
|
void AES::PrintKey2(int xs)
|
|
{
|
|
int x, y;
|
|
char buf[20];
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << "PrintKey2, xs=" << xs << pt::Log::logend;
|
|
|
|
for(x=xs ; x<xs+key_col ; ++x)
|
|
{
|
|
for(y=0 ; y<4 ; ++y)
|
|
{
|
|
sprintf(buf, "%02x", key[y][x]);
|
|
(*plog) << pt::Log::log4 << buf << " ";
|
|
}
|
|
|
|
(*plog) << pt::Log::logend;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void AES::PrintKey3(int x)
|
|
{
|
|
int y;
|
|
char buf[20];
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << "PrintKey3" << pt::Log::logend;
|
|
(*plog) << pt::Log::log4 << x << " ";
|
|
|
|
for(y=0 ; y<4 ; ++y)
|
|
{
|
|
sprintf(buf, "%02x", key[y][x]);
|
|
(*plog) << pt::Log::log4 << buf << " ";
|
|
}
|
|
|
|
(*plog) << pt::Log::logend;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
AES::uint8 AES::SubBytes(AES::uint8 v)
|
|
{
|
|
int y = int(v) >> 4;
|
|
int x = (v & 0x0f);
|
|
|
|
return sbox[y][x];
|
|
}
|
|
|
|
|
|
|
|
void AES::SubBytes()
|
|
{
|
|
int x, y;
|
|
|
|
for(y=0 ; y<4 ; ++y)
|
|
for(x=0 ; x<4 ; ++x)
|
|
data[y][x] = SubBytes(data[y][x]);
|
|
}
|
|
|
|
|
|
|
|
void AES::ShiftRows1(AES::uint8 tab[4])
|
|
{
|
|
uint8 temp = tab[0];
|
|
|
|
tab[0] = tab[1];
|
|
tab[1] = tab[2];
|
|
tab[2] = tab[3];
|
|
tab[3] = temp;
|
|
}
|
|
|
|
|
|
|
|
void AES::ShiftRows2(AES::uint8 tab[4])
|
|
{
|
|
uint8 temp1 = tab[0];
|
|
uint8 temp2 = tab[1];
|
|
|
|
tab[0] = tab[2];
|
|
tab[1] = tab[3];
|
|
tab[2] = temp1;
|
|
tab[3] = temp2;
|
|
}
|
|
|
|
|
|
|
|
void AES::ShiftRows3(AES::uint8 tab[4])
|
|
{
|
|
uint8 temp = tab[3];
|
|
|
|
tab[3] = tab[2];
|
|
tab[2] = tab[1];
|
|
tab[1] = tab[0];
|
|
tab[0] = temp;
|
|
}
|
|
|
|
|
|
|
|
void AES::ShiftRows()
|
|
{
|
|
ShiftRows1(data[1]);
|
|
ShiftRows2(data[2]);
|
|
ShiftRows3(data[3]);
|
|
}
|
|
|
|
|
|
|
|
AES::uint8 AES::MixColumns2(AES::uint8 v)
|
|
{
|
|
bool high_bit = (v & 0x80) != 0;
|
|
|
|
v = v << 1;
|
|
|
|
if( high_bit )
|
|
v = v ^ 0x1b;
|
|
|
|
return v;
|
|
}
|
|
|
|
|
|
|
|
AES::uint8 AES::MixColumns3(AES::uint8 v)
|
|
{
|
|
bool high_bit = (v & 0x80) != 0;
|
|
|
|
AES::uint8 vold = v;
|
|
|
|
v = (v << 1) ^ vold;
|
|
|
|
if( high_bit )
|
|
v = v ^ 0x1b;
|
|
|
|
return v;
|
|
}
|
|
|
|
|
|
|
|
AES::uint8 AES::MixColumns(int type, AES::uint8 value)
|
|
{
|
|
switch(type)
|
|
{
|
|
case 2:
|
|
return MixColumns2(value);
|
|
|
|
case 3:
|
|
return MixColumns3(value);
|
|
|
|
case 1:
|
|
default:
|
|
return value;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void AES::MixColumns()
|
|
{
|
|
int x, y, i;
|
|
uint8 v;
|
|
uint8 temp[4];
|
|
|
|
for(x=0 ; x<4 ; ++x)
|
|
{
|
|
for(y=0 ; y<4 ; ++y)
|
|
{
|
|
v = 0;
|
|
|
|
for(i=0 ; i<4 ; ++i)
|
|
v ^= MixColumns(mixcolumntab[y][i], data[i][x]);
|
|
|
|
temp[y] = v;
|
|
}
|
|
|
|
for(y=0 ; y<4 ; ++y)
|
|
data[y][x] = temp[y];
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
bool AES::Key(AES::uint8 * key_src, int key_length)
|
|
{
|
|
int x, y, index = 0;
|
|
|
|
PrintKey(key_src, key_length);
|
|
key_len = key_length;
|
|
|
|
if( key_len == 16 )
|
|
{
|
|
key_col = 4;
|
|
round = 10;
|
|
}
|
|
else
|
|
if( key_len == 24 )
|
|
{
|
|
key_col = 6;
|
|
round = 12;
|
|
}
|
|
else
|
|
if( key_len == 32 )
|
|
{
|
|
key_col = 8;
|
|
round = 14;
|
|
}
|
|
else
|
|
{
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log2 << "AES: I cannot initialize the AES key, incorrect key size: " << key_length
|
|
<< ", expected: 16, 24 or 32 " << pt::Log::logend;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
for(x=0 ; x<key_col ; ++x)
|
|
for(y=0 ; y<4 ; ++y)
|
|
key[y][x] = key_src[index++];
|
|
|
|
KeyExpansion();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
void AES::RotKey(int i)
|
|
{
|
|
uint8 temp = key[0][i];
|
|
key[0][i] = key[1][i];
|
|
key[1][i] = key[2][i];
|
|
key[2][i] = key[3][i];
|
|
key[3][i] = temp;
|
|
}
|
|
|
|
|
|
void AES::SubWordKey(int i)
|
|
{
|
|
for(int y=0 ; y<4 ; ++y)
|
|
key[y][i] = SubBytes(key[y][i]);
|
|
}
|
|
|
|
|
|
void AES::KeyExpansion()
|
|
{
|
|
int i, y;
|
|
int rcon_index = 0;
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << "AES key expansion" << pt::Log::logend;
|
|
}
|
|
|
|
for(i=key_col ; i < 4*(round+1) ; ++i)
|
|
{
|
|
for(y=0 ; y<4 ; ++y)
|
|
key[y][i] = key[y][i-1];
|
|
|
|
if( i % key_col == 0 )
|
|
{
|
|
RotKey(i);
|
|
SubWordKey(i);
|
|
key[0][i] ^= Rcon[rcon_index++];
|
|
}
|
|
else
|
|
if( key_col > 6 && i % key_col == 4 )
|
|
{
|
|
SubWordKey(i);
|
|
}
|
|
|
|
for(y=0 ; y<4 ; ++y)
|
|
key[y][i] ^= key[y][i-key_col];
|
|
|
|
|
|
if( plog )
|
|
{
|
|
PrintKey3(i);
|
|
|
|
if( i % key_col == 0 )
|
|
{
|
|
(*plog) << pt::Log::log4 << " ---- " << (rcon_index-1) << pt::Log::logend;
|
|
PrintKey2(i-key_col);
|
|
}
|
|
}
|
|
}
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << " ---- " << rcon_index << pt::Log::logend;
|
|
PrintKey2(i-key_col);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void AES::AddRoundKey(int xs)
|
|
{
|
|
int x, y;
|
|
|
|
for(y=0 ; y<4 ; ++y)
|
|
for(x=0 ; x<4 ; ++x)
|
|
data[y][x] ^= key[y][xs+x];
|
|
}
|
|
|
|
|
|
|
|
void AES::EncodeData()
|
|
{
|
|
int i;
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << " input data " << pt::Log::logend;
|
|
PrintData();
|
|
}
|
|
|
|
AddRoundKey(0);
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << " first round key " << pt::Log::logend;
|
|
PrintData();
|
|
}
|
|
|
|
for(i=0 ; i<round ; ++i)
|
|
{
|
|
SubBytes();
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << " after sub bytes, i= " << i+1 << pt::Log::logend;
|
|
PrintData();
|
|
}
|
|
|
|
ShiftRows();
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << " after shift rows, i= " << i+1 << pt::Log::logend;
|
|
PrintData();
|
|
}
|
|
|
|
if( i != round-1 )
|
|
{
|
|
MixColumns();
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << " after mix columns, i= " << i+1 << pt::Log::logend;
|
|
PrintData();
|
|
}
|
|
}
|
|
|
|
AddRoundKey((i+1)*4);
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << " after add round key, i= " << i+1 << pt::Log::logend;
|
|
PrintData();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* inverse */
|
|
|
|
|
|
|
|
void AES::InvShiftRows1(AES::uint8 tab[4])
|
|
{
|
|
return ShiftRows3(tab);
|
|
}
|
|
|
|
|
|
|
|
void AES::InvShiftRows2(AES::uint8 tab[4])
|
|
{
|
|
return ShiftRows2(tab);
|
|
}
|
|
|
|
|
|
|
|
void AES::InvShiftRows3(AES::uint8 tab[4])
|
|
{
|
|
return ShiftRows1(tab);
|
|
}
|
|
|
|
|
|
|
|
void AES::InvShiftRows()
|
|
{
|
|
InvShiftRows1(data[1]);
|
|
InvShiftRows2(data[2]);
|
|
InvShiftRows3(data[3]);
|
|
}
|
|
|
|
|
|
|
|
AES::uint8 AES::InvSubBytes(AES::uint8 v)
|
|
{
|
|
int y = int(v) >> 4;
|
|
int x = (v & 0x0f);
|
|
|
|
return invsbox[y][x];
|
|
}
|
|
|
|
|
|
|
|
void AES::InvSubBytes()
|
|
{
|
|
int x, y;
|
|
|
|
for(y=0 ; y<4 ; ++y)
|
|
for(x=0 ; x<4 ; ++x)
|
|
data[y][x] = InvSubBytes(data[y][x]);
|
|
}
|
|
|
|
|
|
|
|
AES::uint8 AES::InvMixColumns(AES::uint8 gf_mul[16][16], AES::uint8 v)
|
|
{
|
|
int y = int(v) >> 4;
|
|
int x = (v & 0x0f);
|
|
|
|
return gf_mul[y][x];
|
|
}
|
|
|
|
|
|
AES::uint8 AES::InvMixColumns(int type, AES::uint8 value)
|
|
{
|
|
switch(type)
|
|
{
|
|
case 9:
|
|
return InvMixColumns(gf_mul9, value);
|
|
|
|
case 11:
|
|
return InvMixColumns(gf_mul11, value);
|
|
|
|
case 13:
|
|
return InvMixColumns(gf_mul13, value);
|
|
}
|
|
|
|
return InvMixColumns(gf_mul14, value);
|
|
}
|
|
|
|
|
|
|
|
void AES::InvMixColumns()
|
|
{
|
|
int x, y, i;
|
|
uint8 v;
|
|
uint8 temp[4];
|
|
|
|
for(x=0 ; x<4 ; ++x)
|
|
{
|
|
for(y=0 ; y<4 ; ++y)
|
|
{
|
|
v = 0;
|
|
|
|
for(i=0 ; i<4 ; ++i)
|
|
v ^= InvMixColumns(invmixcolumntab[y][i], data[i][x]);
|
|
|
|
temp[y] = v;
|
|
}
|
|
|
|
for(y=0 ; y<4 ; ++y)
|
|
data[y][x] = temp[y];
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void AES::DecodeData()
|
|
{
|
|
int i;
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << " input data " << pt::Log::logend;
|
|
PrintData();
|
|
}
|
|
|
|
AddRoundKey(round*4);
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << " first round key " << pt::Log::logend;
|
|
PrintData();
|
|
}
|
|
|
|
for(i=round-1 ; i>=0 ; --i)
|
|
{
|
|
InvShiftRows();
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << " after invshiftrows, i= " << i << pt::Log::logend;
|
|
PrintData();
|
|
}
|
|
|
|
InvSubBytes();
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << " after invsubbutes, i= " << i << pt::Log::logend;
|
|
PrintData();
|
|
}
|
|
|
|
AddRoundKey(i*4);
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << " after add round key, i= " << i << pt::Log::logend;
|
|
PrintData();
|
|
}
|
|
|
|
if( i != 0 )
|
|
{
|
|
InvMixColumns();
|
|
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << " after inv mix columns, i= " << i << pt::Log::logend;
|
|
PrintData();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
*/
|
|
|
|
bool AES::Encode(AES::uint8 * block, size_t len)
|
|
{
|
|
if( len % 16 != 0 )
|
|
return false;
|
|
|
|
while( len > 0 )
|
|
{
|
|
CopyToData(block);
|
|
EncodeData();
|
|
CopyFromData(block);
|
|
|
|
len -= 16;
|
|
block += 16;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool AES::Decode(AES::uint8 * block, size_t len)
|
|
{
|
|
if( len % 16 != 0 )
|
|
return false;
|
|
|
|
while( len > 0 )
|
|
{
|
|
CopyToData(block);
|
|
DecodeData();
|
|
CopyFromData(block);
|
|
|
|
len -= 16;
|
|
block += 16;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
*
|
|
* iv - initialization vector
|
|
*/
|
|
bool AES::EncodeCBC(AES::uint8 * block, size_t len, const AES::uint8 * iv)
|
|
{
|
|
if( len % 16 != 0 )
|
|
return false;
|
|
|
|
while( len > 0 )
|
|
{
|
|
XorCopyToData(block, iv);
|
|
EncodeData();
|
|
CopyFromData(block);
|
|
|
|
iv = block;
|
|
|
|
len -= 16;
|
|
block += 16;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool AES::DecodeCBC(AES::uint8 * block, size_t len, const AES::uint8 * iv)
|
|
{
|
|
AES::uint8 cipher_copy[16];
|
|
AES::uint8 cipher_copy2[16];
|
|
bool use_first = true;
|
|
|
|
if( len % 16 != 0 )
|
|
return false;
|
|
|
|
while( len > 0 )
|
|
{
|
|
if( use_first )
|
|
{
|
|
for(size_t i=0 ; i < 16 ; ++i)
|
|
cipher_copy[i] = block[i];
|
|
}
|
|
else
|
|
{
|
|
for(size_t i=0 ; i < 16 ; ++i)
|
|
cipher_copy2[i] = block[i];
|
|
}
|
|
|
|
CopyToData(block);
|
|
DecodeData();
|
|
XorCopyFromData(block, iv);
|
|
|
|
if( use_first )
|
|
iv = cipher_copy;
|
|
else
|
|
iv = cipher_copy2;
|
|
|
|
len -= 16;
|
|
block += 16;
|
|
use_first = !use_first;
|
|
}
|
|
|
|
for(size_t i=0 ; i < 16 ; ++i)
|
|
{
|
|
cipher_copy[i] = 0;
|
|
cipher_copy2[i] = 0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
bool AES::EncodeCBC_PKCS7(std::vector<uint8> & content, const AES::uint8 * iv)
|
|
{
|
|
size_t remainder = content.size() % 16;
|
|
size_t pad = 16 - remainder;
|
|
size_t i = content.size();
|
|
|
|
content.resize(content.size() + pad);
|
|
|
|
for( ; i < content.size() ; ++i)
|
|
content[i] = pad;
|
|
|
|
return EncodeCBC(content.data(), content.size(), iv);
|
|
}
|
|
|
|
|
|
bool AES::DecodeCBC_PKCS7(std::vector<uint8> & content, const AES::uint8 * iv)
|
|
{
|
|
// there has to be at least one block (block from padding if the original content was empty)
|
|
if( content.empty() )
|
|
return false;
|
|
|
|
if( !DecodeCBC(content.data(), content.size(), iv) )
|
|
return false;
|
|
|
|
size_t pad = content[content.size()-1];
|
|
|
|
if( pad > 16 || content.size() < pad )
|
|
return false;
|
|
|
|
for(size_t i = content.size() - pad ; i < content.size() ; ++i)
|
|
{
|
|
if( content[i] != pad )
|
|
return false;
|
|
}
|
|
|
|
content.resize(content.size() - pad);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
void AES::IntToBuf(AES::uint8 * buf, AES::uint16 value)
|
|
{
|
|
buf[0] = value & 0xff;
|
|
buf[1] = (value >> 8) & 0xff;
|
|
}
|
|
|
|
void AES::IntToBuf(AES::uint8 * buf, AES::uint32 value)
|
|
{
|
|
buf[0] = value & 0xff;
|
|
buf[1] = (value >> 8) & 0xff;
|
|
buf[2] = (value >> 16) & 0xff;
|
|
buf[3] = (value >> 24) & 0xff;
|
|
}
|
|
|
|
|
|
void AES::CreateHeader(TiHeader & header, const AES::uint8 * block, size_t len, const std::string & name, bool use_rand_first_padding)
|
|
{
|
|
header.signature = int('t') + (int('i') << 8);
|
|
|
|
// first padding from 3 to 9
|
|
if( use_rand_first_padding )
|
|
header.pad1 = (6 * rand()) / RAND_MAX + 3;
|
|
else
|
|
header.pad1 = 3;
|
|
|
|
header.all_len = 12 + header.pad1 + name.size() + len;
|
|
|
|
header.pad2 = 0;
|
|
|
|
if( (header.all_len % 16) != 0 )
|
|
header.pad2 = 16 - (header.all_len % 16);
|
|
|
|
header.all_len += header.pad2;
|
|
header.checksum_before = Checksum(block, len);
|
|
header.checksum_after = 0;
|
|
header.name_len = name.size();
|
|
}
|
|
|
|
|
|
void AES::PutHeader(const TiHeader & header, std::vector<AES::uint8> & out)
|
|
{
|
|
uint8 buf[16];
|
|
|
|
IntToBuf(buf, header.signature);
|
|
out.push_back(buf[0]);
|
|
out.push_back(buf[1]);
|
|
|
|
// space for checksum after encoding
|
|
out.push_back(0);
|
|
out.push_back(0);
|
|
out.push_back(0);
|
|
out.push_back(0);
|
|
|
|
IntToBuf(buf, header.pad1);
|
|
IntToBuf(buf+2, header.pad2);
|
|
IntToBuf(buf+4, header.checksum_before);
|
|
IntToBuf(buf+8, header.name_len);
|
|
|
|
for(int i=12 ; i<16 ; ++i)
|
|
buf[i] = 0;
|
|
|
|
CopyToData(buf);
|
|
}
|
|
|
|
|
|
void AES::PutChecksumAfter(std::vector<AES::uint8> & out)
|
|
{
|
|
if( out.size() < 7 )
|
|
return; // something wrong
|
|
|
|
// checksum starting from 6th byte
|
|
AES::uint32 checksum_after = Checksum(&out[6], out.size()-6);
|
|
IntToBuf(&out[2], checksum_after);
|
|
}
|
|
|
|
|
|
AES::uint32 AES::Checksum(const uint8 * block, size_t len)
|
|
{
|
|
uint32 sum = 0;
|
|
|
|
for(size_t i=0 ; i<len ; ++i)
|
|
sum += block[i];
|
|
|
|
return sum;
|
|
}
|
|
|
|
|
|
|
|
void AES::EncodePad(int & y, int & x, AES::uint16 pad, std::vector<AES::uint8> & out)
|
|
{
|
|
AES::uint16 index = 0;
|
|
|
|
while( true )
|
|
{
|
|
for( ; x<4 ; ++x)
|
|
{
|
|
for(; y<4 ; ++y)
|
|
{
|
|
if( index < pad )
|
|
{
|
|
data[y][x] = (rand() * 255) / RAND_MAX;
|
|
index += 1;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
y = 0;
|
|
}
|
|
|
|
x = 0;
|
|
EncodeData();
|
|
CopyFromData(out, false);
|
|
}
|
|
}
|
|
|
|
|
|
void AES::EncodeName(int & y, int & x, const std::string & name, std::vector<AES::uint8> & out)
|
|
{
|
|
size_t index = 0;
|
|
|
|
while( true )
|
|
{
|
|
for( ; x<4 ; ++x)
|
|
{
|
|
for(; y<4 ; ++y)
|
|
{
|
|
if( index < name.size() )
|
|
{
|
|
data[y][x] = name[index];
|
|
index += 1;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
y = 0;
|
|
}
|
|
|
|
x = 0;
|
|
EncodeData();
|
|
CopyFromData(out, false);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void AES::EncodeData(int & y, int & x, const AES::uint8 * block, size_t len, std::vector<AES::uint8> & out)
|
|
{
|
|
size_t index = 0;
|
|
|
|
while( true )
|
|
{
|
|
for( ; x<4 ; ++x)
|
|
{
|
|
for(; y<4 ; ++y)
|
|
{
|
|
if( index < len )
|
|
{
|
|
data[y][x] = block[index];
|
|
index += 1;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
y = 0;
|
|
}
|
|
|
|
x = 0;
|
|
EncodeData();
|
|
CopyFromData(out, false);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
(not encrypted)
|
|
2 bytes: signature "ti"
|
|
4 bytes: data checksum after encoding
|
|
---
|
|
6 bytes
|
|
(encrypted)
|
|
2 bytes: first padding length (from 3 to 9)
|
|
2 bytes: last padding length (can be zero)
|
|
4 bytes: data checksum before encoding
|
|
4 bytes: name string length (it can be a name of a file or just zero means an empty string)
|
|
---
|
|
12 bytes (18 bytes alltogether)
|
|
|
|
... bytes: first padding
|
|
... bytes: name string
|
|
... bytes: data
|
|
... bytes: last padding
|
|
*/
|
|
bool AES::Encode(const AES::uint8 * block, size_t len, const std::string & name, std::vector<AES::uint8> & out)
|
|
{
|
|
TiHeader header;
|
|
|
|
out.clear();
|
|
CreateHeader(header, block, len, name);
|
|
PutHeader(header, out);
|
|
|
|
if( out.capacity() < header.all_len )
|
|
out.reserve(header.all_len);
|
|
|
|
// skipping first 12 bytes from 'data'
|
|
int y = 0;
|
|
int x = 3;
|
|
|
|
EncodePad (y, x, header.pad1, out);
|
|
EncodeName(y, x, name, out);
|
|
EncodeData(y, x, block, len, out);
|
|
EncodePad (y, x, header.pad2, out);
|
|
PutChecksumAfter(out);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool AES::Encode(const std::vector<AES::uint8> & block, const std::string & name, std::vector<AES::uint8> & out)
|
|
{
|
|
if( block.empty() )
|
|
return Encode(0, 0, name, out);
|
|
else
|
|
return Encode(&block[0], block.size(), name, out);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
*/
|
|
void AES::ReadHeader(TiHeader & header, const AES::uint8 * block)
|
|
{
|
|
header.signature = (uint16(block[1]) << 8) + uint16(block[0]);
|
|
header.checksum_after = (uint32(block[5]) << 24) + (uint32(block[4]) << 16) + (uint32(block[3]) << 8) + uint32(block[2]);
|
|
|
|
header.pad1 = (uint16(data[1][0]) << 8) + uint16(data[0][0]);
|
|
header.pad2 = (uint16(data[3][0]) << 8) + uint16(data[2][0]);
|
|
header.checksum_before = (uint32(data[3][1]) << 24) + (uint32(data[2][1]) << 16) + (uint32(data[1][1]) << 8) + uint32(data[0][1]);
|
|
header.name_len = (uint32(data[3][2]) << 24) + (uint32(data[2][2]) << 16) + (uint32(data[1][2]) << 8) + uint32(data[0][2]);
|
|
}
|
|
|
|
|
|
|
|
void AES::DecodePad(int & y, int & x, const AES::uint8 * & block, size_t & len, AES::uint16 pad)
|
|
{
|
|
AES::uint16 index = 0;
|
|
|
|
while( true )
|
|
{
|
|
for( ; x<4 ; ++x)
|
|
{
|
|
for( ; y<4 ; ++y)
|
|
{
|
|
if( index < pad )
|
|
{
|
|
index += 1;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
y = 0;
|
|
}
|
|
|
|
x = 0;
|
|
|
|
if( len > 0 )
|
|
{
|
|
CopyToData(block);
|
|
DecodeData();
|
|
block += 16;
|
|
len -= 16;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void AES::DecodeName(int & y, int & x, const AES::uint8 * & block, size_t & len, AES::uint32 name_len, std::string & name)
|
|
{
|
|
AES::uint32 index = 0;
|
|
|
|
while( true )
|
|
{
|
|
for( ; x<4 ; ++x)
|
|
{
|
|
for( ; y<4 ; ++y)
|
|
{
|
|
if( index < name_len )
|
|
{
|
|
index += 1;
|
|
name += static_cast<char>(data[y][x]);
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
y = 0;
|
|
}
|
|
|
|
x = 0;
|
|
|
|
if( len > 0 )
|
|
{
|
|
CopyToData(block);
|
|
DecodeData();
|
|
block += 16;
|
|
len -= 16;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void AES::DecodeData(int & y, int & x, const AES::uint8 * & block, size_t & len, size_t data_len, std::vector<AES::uint8> & out)
|
|
{
|
|
size_t index = 0;
|
|
|
|
while( true )
|
|
{
|
|
for( ; x<4 ; ++x)
|
|
{
|
|
for( ; y<4 ; ++y)
|
|
{
|
|
if( index < data_len )
|
|
{
|
|
index += 1;
|
|
out.push_back(data[y][x]);
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
y = 0;
|
|
}
|
|
|
|
x = 0;
|
|
|
|
if( len > 0 )
|
|
{
|
|
CopyToData(block);
|
|
DecodeData();
|
|
block += 16;
|
|
len -= 16;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
bool AES::CheckSignatureAndChecksumAfter(const TiHeader & header, const AES::uint8 * block, size_t len)
|
|
{
|
|
if( ((header.signature >> 8) & 0xff) != 'i' || (header.signature & 0xff) != 't' )
|
|
return false;
|
|
|
|
AES::uint32 ch_after = Checksum(block+6, len-6);
|
|
|
|
return ch_after == header.checksum_after;
|
|
}
|
|
|
|
|
|
bool AES::CheckChecksumBefore(const TiHeader & header, std::vector<AES::uint8> & out)
|
|
{
|
|
AES::uint32 ch_before = 0;
|
|
|
|
if( !out.empty() )
|
|
ch_before = Checksum(&out[0], out.size());
|
|
|
|
return ch_before == header.checksum_before;
|
|
}
|
|
|
|
|
|
bool AES::Decode(const AES::uint8 * block, size_t len, std::string & name, std::vector<AES::uint8> & out)
|
|
{
|
|
TiHeader header;
|
|
|
|
name.clear();
|
|
out.clear();
|
|
|
|
// incorrect size
|
|
if( len < 18 || (len - 6) % 16 != 0)
|
|
return false;
|
|
|
|
CopyToData(block+6);
|
|
DecodeData();
|
|
ReadHeader(header, block);
|
|
|
|
if( !CheckSignatureAndChecksumAfter(header, block, len) )
|
|
return false;
|
|
|
|
size_t min_size = 18 + header.pad1 + header.name_len + header.pad2;
|
|
|
|
if( len < min_size )
|
|
return false;
|
|
|
|
size_t data_len = len - 18 - header.pad1 - header.name_len - header.pad2;
|
|
int y = 0;
|
|
int x = 3;
|
|
|
|
// skipping non encrypted part and first block
|
|
block += (6 + 16);
|
|
len -= (6 + 16);
|
|
|
|
DecodePad (y, x, block, len, header.pad1);
|
|
DecodeName(y, x, block, len, header.name_len, name);
|
|
DecodeData(y, x, block, len, data_len, out);
|
|
|
|
return CheckChecksumBefore(header, out);
|
|
}
|
|
|
|
|
|
bool AES::Decode(const std::vector<AES::uint8> & block, std::string & name, std::vector<AES::uint8> & out)
|
|
{
|
|
if( block.empty() )
|
|
return Decode(0, 0, name, out);
|
|
else
|
|
return Decode(&block[0], block.size(), name, out);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
algorithm description: http://www.samiam.org/galois.html
|
|
*/
|
|
AES::uint8 AES::GaloisMultiply(AES::uint8 a, AES::uint8 b)
|
|
{
|
|
int i;
|
|
uint8 p = 0;
|
|
|
|
for(i=0; i<8 ;++i)
|
|
{
|
|
if(b & 1)
|
|
p ^= a;
|
|
|
|
bool a_high_bit = (a & 0x80) != 0;
|
|
|
|
a = a << 1;
|
|
|
|
if( a_high_bit )
|
|
a ^= 0x1b;
|
|
|
|
b = b >> 1;
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
|
|
bool AES::CheckGFTable(int value, AES::uint8 gf_mul[16][16])
|
|
{
|
|
int x,y;
|
|
bool ok = true;
|
|
|
|
for(y=0 ; y<16 ; ++y)
|
|
{
|
|
for(x=0 ; x<16 ; ++x)
|
|
{
|
|
int v1 = gf_mul[y][x];
|
|
int v2 = GaloisMultiply(value, y*16 + x);
|
|
|
|
if( v1 != v2 )
|
|
{
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log2 << "error: y: " << y << ", x: " << x << ", v1: " << v1 << ", v2: " << v2 << pt::Log::logend;
|
|
}
|
|
|
|
ok = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
|
|
bool AES::CheckGFTables()
|
|
{
|
|
bool ok9, ok11, ok13, ok14;
|
|
|
|
ok9 = CheckGFTable(9, gf_mul9);
|
|
ok11 = CheckGFTable(11, gf_mul11);
|
|
ok13 = CheckGFTable(13, gf_mul13);
|
|
ok14 = CheckGFTable(14, gf_mul14);
|
|
|
|
bool ok = ok9 && ok11 && ok13 && ok14;
|
|
|
|
if( ok )
|
|
{
|
|
if( plog )
|
|
{
|
|
(*plog) << pt::Log::log4 << "All GF tables are good" << pt::Log::logend;
|
|
}
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
|
|
void AES::set_logger(pt::Log * plog)
|
|
{
|
|
this->plog = plog;
|
|
}
|
|
|
|
|
|
|
|
} // namespace Tito
|
|
|
|
|