mosskoi/Champions-Reborn-Server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Big Refactor.

Browse Source 
General support for encryption and decryption.
Game Session creation.
Discovery Server.

Still broken as hell, but less so?
This commit is contained in:
HikikoMarmy
2024-12-25 01:20:12 +00:00
parent 8b154e614f
commit a0a363b7d0
88 changed files with 4595 additions and 1600 deletions
Download Patch File Download Diff File Expand all files Collapse all files

454
misc/AES.cpp
View File

@@ -1,454 +0,0 @@
#include "AES.h"
AES::AES(const AESKeyLength keyLength) {
switch (keyLength) {
case AESKeyLength::AES_128:
this->Nk = 4;
this->Nr = 10;
break;
case AESKeyLength::AES_192:
this->Nk = 6;
this->Nr = 12;
break;
case AESKeyLength::AES_256:
this->Nk = 8;
this->Nr = 14;
break;
}
}
unsigned char *AES::EncryptECB(const unsigned char in[], unsigned int inLen,
const unsigned char key[]) {
CheckLength(inLen);
unsigned char *out = new unsigned char[inLen];
unsigned char *roundKeys = new unsigned char[4 * Nb * (Nr + 1)];
KeyExpansion(key, roundKeys);
for (unsigned int i = 0; i < inLen; i += blockBytesLen) {
EncryptBlock(in + i, out + i, roundKeys);
}
delete[] roundKeys;
return out;
}
unsigned char *AES::DecryptECB(const unsigned char in[], unsigned int inLen,
const unsigned char key[]) {
CheckLength(inLen);
unsigned char *out = new unsigned char[inLen];
unsigned char *roundKeys = new unsigned char[4 * Nb * (Nr + 1)];
KeyExpansion(key, roundKeys);
for (unsigned int i = 0; i < inLen; i += blockBytesLen) {
DecryptBlock(in + i, out + i, roundKeys);
}
delete[] roundKeys;
return out;
}
unsigned char *AES::EncryptCBC(const unsigned char in[], unsigned int inLen,
const unsigned char key[],
const unsigned char *iv) {
CheckLength(inLen);
unsigned char *out = new unsigned char[inLen];
unsigned char block[blockBytesLen];
unsigned char *roundKeys = new unsigned char[4 * Nb * (Nr + 1)];
KeyExpansion(key, roundKeys);
memcpy(block, iv, blockBytesLen);
for (unsigned int i = 0; i < inLen; i += blockBytesLen) {
XorBlocks(block, in + i, block, blockBytesLen);
EncryptBlock(block, out + i, roundKeys);
memcpy(block, out + i, blockBytesLen);
}
delete[] roundKeys;
return out;
}
unsigned char *AES::DecryptCBC(const unsigned char in[], unsigned int inLen,
const unsigned char key[],
const unsigned char *iv) {
CheckLength(inLen);
unsigned char *out = new unsigned char[inLen];
unsigned char block[blockBytesLen];
unsigned char *roundKeys = new unsigned char[4 * Nb * (Nr + 1)];
KeyExpansion(key, roundKeys);
memcpy(block, iv, blockBytesLen);
for (unsigned int i = 0; i < inLen; i += blockBytesLen) {
DecryptBlock(in + i, out + i, roundKeys);
XorBlocks(block, out + i, out + i, blockBytesLen);
memcpy(block, in + i, blockBytesLen);
}
delete[] roundKeys;
return out;
}
unsigned char *AES::EncryptCFB(const unsigned char in[], unsigned int inLen,
const unsigned char key[],
const unsigned char *iv) {
CheckLength(inLen);
unsigned char *out = new unsigned char[inLen];
unsigned char block[blockBytesLen];
unsigned char encryptedBlock[blockBytesLen];
unsigned char *roundKeys = new unsigned char[4 * Nb * (Nr + 1)];
KeyExpansion(key, roundKeys);
memcpy(block, iv, blockBytesLen);
for (unsigned int i = 0; i < inLen; i += blockBytesLen) {
EncryptBlock(block, encryptedBlock, roundKeys);
XorBlocks(in + i, encryptedBlock, out + i, blockBytesLen);
memcpy(block, out + i, blockBytesLen);
}
delete[] roundKeys;
return out;
}
unsigned char *AES::DecryptCFB(const unsigned char in[], unsigned int inLen,
const unsigned char key[],
const unsigned char *iv) {
CheckLength(inLen);
unsigned char *out = new unsigned char[inLen];
unsigned char block[blockBytesLen];
unsigned char encryptedBlock[blockBytesLen];
unsigned char *roundKeys = new unsigned char[4 * Nb * (Nr + 1)];
KeyExpansion(key, roundKeys);
memcpy(block, iv, blockBytesLen);
for (unsigned int i = 0; i < inLen; i += blockBytesLen) {
EncryptBlock(block, encryptedBlock, roundKeys);
XorBlocks(in + i, encryptedBlock, out + i, blockBytesLen);
memcpy(block, in + i, blockBytesLen);
}
delete[] roundKeys;
return out;
}
void AES::CheckLength(unsigned int len) {
if (len % blockBytesLen != 0) {
throw std::length_error("Plaintext length must be divisible by " +
std::to_string(blockBytesLen));
}
}
void AES::EncryptBlock(const unsigned char in[], unsigned char out[],
unsigned char *roundKeys) {
unsigned char state[4][Nb];
unsigned int i, j, round;
for (i = 0; i < 4; i++) {
for (j = 0; j < Nb; j++) {
state[i][j] = in[i + 4 * j];
}
}
AddRoundKey(state, roundKeys);
for (round = 1; round <= Nr - 1; round++) {
SubBytes(state);
ShiftRows(state);
MixColumns(state);
AddRoundKey(state, roundKeys + round * 4 * Nb);
}
SubBytes(state);
ShiftRows(state);
AddRoundKey(state, roundKeys + Nr * 4 * Nb);
for (i = 0; i < 4; i++) {
for (j = 0; j < Nb; j++) {
out[i + 4 * j] = state[i][j];
}
}
}
void AES::DecryptBlock(const unsigned char in[], unsigned char out[],
unsigned char *roundKeys) {
unsigned char state[4][Nb];
unsigned int i, j, round;
for (i = 0; i < 4; i++) {
for (j = 0; j < Nb; j++) {
state[i][j] = in[i + 4 * j];
}
}
AddRoundKey(state, roundKeys + Nr * 4 * Nb);
for (round = Nr - 1; round >= 1; round--) {
InvSubBytes(state);
InvShiftRows(state);
AddRoundKey(state, roundKeys + round * 4 * Nb);
InvMixColumns(state);
}
InvSubBytes(state);
InvShiftRows(state);
AddRoundKey(state, roundKeys);
for (i = 0; i < 4; i++) {
for (j = 0; j < Nb; j++) {
out[i + 4 * j] = state[i][j];
}
}
}
void AES::SubBytes(unsigned char state[4][Nb]) {
unsigned int i, j;
unsigned char t;
for (i = 0; i < 4; i++) {
for (j = 0; j < Nb; j++) {
t = state[i][j];
state[i][j] = sbox[t / 16][t % 16];
}
}
}
void AES::ShiftRow(unsigned char state[4][Nb], unsigned int i,
unsigned int n) // shift row i on n write_positions
{
unsigned char tmp[Nb];
for (unsigned int j = 0; j < Nb; j++) {
tmp[j] = state[i][(j + n) % Nb];
}
memcpy(state[i], tmp, Nb * sizeof(unsigned char));
}
void AES::ShiftRows(unsigned char state[4][Nb]) {
ShiftRow(state, 1, 1);
ShiftRow(state, 2, 2);
ShiftRow(state, 3, 3);
}
unsigned char AES::xtime(unsigned char b) // multiply on x
{
return (b << 1) ^ (((b >> 7) & 1) * 0x1b);
}
void AES::MixColumns(unsigned char state[4][Nb]) {
unsigned char temp_state[4][Nb];
for (size_t i = 0; i < 4; ++i) {
memset(temp_state[i], 0, 4);
}
for (size_t i = 0; i < 4; ++i) {
for (size_t k = 0; k < 4; ++k) {
for (size_t j = 0; j < 4; ++j) {
if (CMDS[i][k] == 1)
temp_state[i][j] ^= state[k][j];
else
temp_state[i][j] ^= GF_MUL_TABLE[CMDS[i][k]][state[k][j]];
}
}
}
for (size_t i = 0; i < 4; ++i) {
memcpy(state[i], temp_state[i], 4);
}
}
void AES::AddRoundKey(unsigned char state[4][Nb], unsigned char *key) {
unsigned int i, j;
for (i = 0; i < 4; i++) {
for (j = 0; j < Nb; j++) {
state[i][j] = state[i][j] ^ key[i + 4 * j];
}
}
}
void AES::SubWord(unsigned char *a) {
int i;
for (i = 0; i < 4; i++) {
a[i] = sbox[a[i] / 16][a[i] % 16];
}
}
void AES::RotWord(unsigned char *a) {
unsigned char c = a[0];
a[0] = a[1];
a[1] = a[2];
a[2] = a[3];
a[3] = c;
}
void AES::XorWords(unsigned char *a, unsigned char *b, unsigned char *c) {
int i;
for (i = 0; i < 4; i++) {
c[i] = a[i] ^ b[i];
}
}
void AES::Rcon(unsigned char *a, unsigned int n) {
unsigned int i;
unsigned char c = 1;
for (i = 0; i < n - 1; i++) {
c = xtime(c);
}
a[0] = c;
a[1] = a[2] = a[3] = 0;
}
void AES::KeyExpansion(const unsigned char key[], unsigned char w[]) {
unsigned char temp[4];
unsigned char rcon[4];
unsigned int i = 0;
while (i < 4 * Nk) {
w[i] = key[i];
i++;
}
i = 4 * Nk;
while (i < 4 * Nb * (Nr + 1)) {
temp[0] = w[i - 4 + 0];
temp[1] = w[i - 4 + 1];
temp[2] = w[i - 4 + 2];
temp[3] = w[i - 4 + 3];
if (i / 4 % Nk == 0) {
RotWord(temp);
SubWord(temp);
Rcon(rcon, i / (Nk * 4));
XorWords(temp, rcon, temp);
} else if (Nk > 6 && i / 4 % Nk == 4) {
SubWord(temp);
}
w[i + 0] = w[i - 4 * Nk] ^ temp[0];
w[i + 1] = w[i + 1 - 4 * Nk] ^ temp[1];
w[i + 2] = w[i + 2 - 4 * Nk] ^ temp[2];
w[i + 3] = w[i + 3 - 4 * Nk] ^ temp[3];
i += 4;
}
}
void AES::InvSubBytes(unsigned char state[4][Nb]) {
unsigned int i, j;
unsigned char t;
for (i = 0; i < 4; i++) {
for (j = 0; j < Nb; j++) {
t = state[i][j];
state[i][j] = inv_sbox[t / 16][t % 16];
}
}
}
void AES::InvMixColumns(unsigned char state[4][Nb]) {
unsigned char temp_state[4][Nb];
for (size_t i = 0; i < 4; ++i) {
memset(temp_state[i], 0, 4);
}
for (size_t i = 0; i < 4; ++i) {
for (size_t k = 0; k < 4; ++k) {
for (size_t j = 0; j < 4; ++j) {
temp_state[i][j] ^= GF_MUL_TABLE[INV_CMDS[i][k]][state[k][j]];
}
}
}
for (size_t i = 0; i < 4; ++i) {
memcpy(state[i], temp_state[i], 4);
}
}
void AES::InvShiftRows(unsigned char state[4][Nb]) {
ShiftRow(state, 1, Nb - 1);
ShiftRow(state, 2, Nb - 2);
ShiftRow(state, 3, Nb - 3);
}
void AES::XorBlocks(const unsigned char *a, const unsigned char *b,
unsigned char *c, unsigned int len) {
for (unsigned int i = 0; i < len; i++) {
c[i] = a[i] ^ b[i];
}
}
void AES::printHexArray(unsigned char a[], unsigned int n) {
for (unsigned int i = 0; i < n; i++) {
printf("%02x ", a[i]);
}
}
void AES::printHexVector(std::vector<unsigned char> a) {
for (unsigned int i = 0; i < a.size(); i++) {
printf("%02x ", a[i]);
}
}
std::vector<unsigned char> AES::ArrayToVector(unsigned char *a,
unsigned int len) {
std::vector<unsigned char> v(a, a + len * sizeof(unsigned char));
return v;
}
unsigned char *AES::VectorToArray(std::vector<unsigned char> &a) {
return a.data();
}
std::vector<unsigned char> AES::EncryptECB(std::vector<unsigned char> in,
std::vector<unsigned char> key) {
unsigned char *out = EncryptECB(VectorToArray(in), (unsigned int)in.size(),
VectorToArray(key));
std::vector<unsigned char> v = ArrayToVector(out, in.size());
delete[] out;
return v;
}
std::vector<unsigned char> AES::DecryptECB(std::vector<unsigned char> in,
std::vector<unsigned char> key) {
unsigned char *out = DecryptECB(VectorToArray(in), (unsigned int)in.size(),
VectorToArray(key));
std::vector<unsigned char> v = ArrayToVector(out, (unsigned int)in.size());
delete[] out;
return v;
}
std::vector<unsigned char> AES::EncryptCBC(std::vector<unsigned char> in,
std::vector<unsigned char> key,
std::vector<unsigned char> iv) {
unsigned char *out = EncryptCBC(VectorToArray(in), (unsigned int)in.size(),
VectorToArray(key), VectorToArray(iv));
std::vector<unsigned char> v = ArrayToVector(out, in.size());
delete[] out;
return v;
}
std::vector<unsigned char> AES::DecryptCBC(std::vector<unsigned char> in,
std::vector<unsigned char> key,
std::vector<unsigned char> iv) {
unsigned char *out = DecryptCBC(VectorToArray(in), (unsigned int)in.size(),
VectorToArray(key), VectorToArray(iv));
std::vector<unsigned char> v = ArrayToVector(out, (unsigned int)in.size());
delete[] out;
return v;
}
std::vector<unsigned char> AES::EncryptCFB(std::vector<unsigned char> in,
std::vector<unsigned char> key,
std::vector<unsigned char> iv) {
unsigned char *out = EncryptCFB(VectorToArray(in), (unsigned int)in.size(),
VectorToArray(key), VectorToArray(iv));
std::vector<unsigned char> v = ArrayToVector(out, in.size());
delete[] out;
return v;
}
std::vector<unsigned char> AES::DecryptCFB(std::vector<unsigned char> in,
std::vector<unsigned char> key,
std::vector<unsigned char> iv) {
unsigned char *out = DecryptCFB(VectorToArray(in), (unsigned int)in.size(),
VectorToArray(key), VectorToArray(iv));
std::vector<unsigned char> v = ArrayToVector(out, (unsigned int)in.size());
delete[] out;
return v;
}

348
misc/AES.h
View File

@@ -1,348 +0,0 @@
#ifndef _AES_H_
#define _AES_H_
#include <cstdio>
#include <cstring>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
enum class AESKeyLength { AES_128, AES_192, AES_256 };
class AES {
private:
static constexpr unsigned int Nb = 4;
static constexpr unsigned int blockBytesLen = 4 * Nb * sizeof(unsigned char);
unsigned int Nk;
unsigned int Nr;
void SubBytes(unsigned char state[4][Nb]);
void ShiftRow(unsigned char state[4][Nb], unsigned int i,
unsigned int n); // shift row i on n write_positions
void ShiftRows(unsigned char state[4][Nb]);
unsigned char xtime(unsigned char b); // multiply on x
void MixColumns(unsigned char state[4][Nb]);
void AddRoundKey(unsigned char state[4][Nb], unsigned char *key);
void SubWord(unsigned char *a);
void RotWord(unsigned char *a);
void XorWords(unsigned char *a, unsigned char *b, unsigned char *c);
void Rcon(unsigned char *a, unsigned int n);
void InvSubBytes(unsigned char state[4][Nb]);
void InvMixColumns(unsigned char state[4][Nb]);
void InvShiftRows(unsigned char state[4][Nb]);
void CheckLength(unsigned int len);
void KeyExpansion(const unsigned char key[], unsigned char w[]);
void EncryptBlock(const unsigned char in[], unsigned char out[],
unsigned char *roundKeys);
void DecryptBlock(const unsigned char in[], unsigned char out[],
unsigned char *roundKeys);
void XorBlocks(const unsigned char *a, const unsigned char *b,
unsigned char *c, unsigned int len);
std::vector<unsigned char> ArrayToVector(unsigned char *a, unsigned int len);
unsigned char *VectorToArray(std::vector<unsigned char> &a);
public:
explicit AES(const AESKeyLength keyLength = AESKeyLength::AES_256);
unsigned char *EncryptECB(const unsigned char in[], unsigned int inLen,
const unsigned char key[]);
unsigned char *DecryptECB(const unsigned char in[], unsigned int inLen,
const unsigned char key[]);
unsigned char *EncryptCBC(const unsigned char in[], unsigned int inLen,
const unsigned char key[], const unsigned char *iv);
unsigned char *DecryptCBC(const unsigned char in[], unsigned int inLen,
const unsigned char key[], const unsigned char *iv);
unsigned char *EncryptCFB(const unsigned char in[], unsigned int inLen,
const unsigned char key[], const unsigned char *iv);
unsigned char *DecryptCFB(const unsigned char in[], unsigned int inLen,
const unsigned char key[], const unsigned char *iv);
std::vector<unsigned char> EncryptECB(std::vector<unsigned char> in,
std::vector<unsigned char> key);
std::vector<unsigned char> DecryptECB(std::vector<unsigned char> in,
std::vector<unsigned char> key);
std::vector<unsigned char> EncryptCBC(std::vector<unsigned char> in,
std::vector<unsigned char> key,
std::vector<unsigned char> iv);
std::vector<unsigned char> DecryptCBC(std::vector<unsigned char> in,
std::vector<unsigned char> key,
std::vector<unsigned char> iv);
std::vector<unsigned char> EncryptCFB(std::vector<unsigned char> in,
std::vector<unsigned char> key,
std::vector<unsigned char> iv);
std::vector<unsigned char> DecryptCFB(std::vector<unsigned char> in,
std::vector<unsigned char> key,
std::vector<unsigned char> iv);
void printHexArray(unsigned char a[], unsigned int n);
void printHexVector(std::vector<unsigned char> a);
};
const unsigned char 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}};
const unsigned char inv_sbox[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}};
/// Galois Multiplication lookup tables
static const unsigned char GF_MUL_TABLE[15][256] = {
{},
{},
// mul 2
{0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16,
0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e,
0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46,
0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e,
0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76,
0x78, 0x7a, 0x7c, 0x7e, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e,
0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa4, 0xa6,
0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe,
0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6,
0xd8, 0xda, 0xdc, 0xde, 0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee,
0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, 0x1b, 0x19, 0x1f, 0x1d,
0x13, 0x11, 0x17, 0x15, 0x0b, 0x09, 0x0f, 0x0d, 0x03, 0x01, 0x07, 0x05,
0x3b, 0x39, 0x3f, 0x3d, 0x33, 0x31, 0x37, 0x35, 0x2b, 0x29, 0x2f, 0x2d,
0x23, 0x21, 0x27, 0x25, 0x5b, 0x59, 0x5f, 0x5d, 0x53, 0x51, 0x57, 0x55,
0x4b, 0x49, 0x4f, 0x4d, 0x43, 0x41, 0x47, 0x45, 0x7b, 0x79, 0x7f, 0x7d,
0x73, 0x71, 0x77, 0x75, 0x6b, 0x69, 0x6f, 0x6d, 0x63, 0x61, 0x67, 0x65,
0x9b, 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d,
0x83, 0x81, 0x87, 0x85, 0xbb, 0xb9, 0xbf, 0xbd, 0xb3, 0xb1, 0xb7, 0xb5,
0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5, 0xdb, 0xd9, 0xdf, 0xdd,
0xd3, 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5,
0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed,
0xe3, 0xe1, 0xe7, 0xe5},
// mul 3
{0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09, 0x18, 0x1b, 0x1e, 0x1d,
0x14, 0x17, 0x12, 0x11, 0x30, 0x33, 0x36, 0x35, 0x3c, 0x3f, 0x3a, 0x39,
0x28, 0x2b, 0x2e, 0x2d, 0x24, 0x27, 0x22, 0x21, 0x60, 0x63, 0x66, 0x65,
0x6c, 0x6f, 0x6a, 0x69, 0x78, 0x7b, 0x7e, 0x7d, 0x74, 0x77, 0x72, 0x71,
0x50, 0x53, 0x56, 0x55, 0x5c, 0x5f, 0x5a, 0x59, 0x48, 0x4b, 0x4e, 0x4d,
0x44, 0x47, 0x42, 0x41, 0xc0, 0xc3, 0xc6, 0xc5, 0xcc, 0xcf, 0xca, 0xc9,
0xd8, 0xdb, 0xde, 0xdd, 0xd4, 0xd7, 0xd2, 0xd1, 0xf0, 0xf3, 0xf6, 0xf5,
0xfc, 0xff, 0xfa, 0xf9, 0xe8, 0xeb, 0xee, 0xed, 0xe4, 0xe7, 0xe2, 0xe1,
0xa0, 0xa3, 0xa6, 0xa5, 0xac, 0xaf, 0xaa, 0xa9, 0xb8, 0xbb, 0xbe, 0xbd,
0xb4, 0xb7, 0xb2, 0xb1, 0x90, 0x93, 0x96, 0x95, 0x9c, 0x9f, 0x9a, 0x99,
0x88, 0x8b, 0x8e, 0x8d, 0x84, 0x87, 0x82, 0x81, 0x9b, 0x98, 0x9d, 0x9e,
0x97, 0x94, 0x91, 0x92, 0x83, 0x80, 0x85, 0x86, 0x8f, 0x8c, 0x89, 0x8a,
0xab, 0xa8, 0xad, 0xae, 0xa7, 0xa4, 0xa1, 0xa2, 0xb3, 0xb0, 0xb5, 0xb6,
0xbf, 0xbc, 0xb9, 0xba, 0xfb, 0xf8, 0xfd, 0xfe, 0xf7, 0xf4, 0xf1, 0xf2,
0xe3, 0xe0, 0xe5, 0xe6, 0xef, 0xec, 0xe9, 0xea, 0xcb, 0xc8, 0xcd, 0xce,
0xc7, 0xc4, 0xc1, 0xc2, 0xd3, 0xd0, 0xd5, 0xd6, 0xdf, 0xdc, 0xd9, 0xda,
0x5b, 0x58, 0x5d, 0x5e, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46,
0x4f, 0x4c, 0x49, 0x4a, 0x6b, 0x68, 0x6d, 0x6e, 0x67, 0x64, 0x61, 0x62,
0x73, 0x70, 0x75, 0x76, 0x7f, 0x7c, 0x79, 0x7a, 0x3b, 0x38, 0x3d, 0x3e,
0x37, 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2f, 0x2c, 0x29, 0x2a,
0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16,
0x1f, 0x1c, 0x19, 0x1a},
{},
{},
{},
{},
{},
// mul 9
{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},
{},
// mul 11
{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},
{},
// mul 13
{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},
// mul 14
{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}};
/// circulant MDS matrix
static const unsigned char CMDS[4][4] = {
{2, 3, 1, 1}, {1, 2, 3, 1}, {1, 1, 2, 3}, {3, 1, 1, 2}};
/// Inverse circulant MDS matrix
static const unsigned char INV_CMDS[4][4] = {
{14, 11, 13, 9}, {9, 14, 11, 13}, {13, 9, 14, 11}, {11, 13, 9, 14}};
#endif

206
misc/ByteStream.cpp
View File

@@ -1,41 +1,42 @@
#include <codecvt>
#include "ByteStream.h"
#include <span>
ByteStream::ByteStream( const std::vector< uint8_t > &data )
{
this->data = data;
this->write_position = 0;
this->position = 0;
}
ByteStream::ByteStream( const std::string &data )
{
this->data = std::vector< uint8_t >( data.begin(), data.end() );
this->write_position = 0;
this->position = 0;
}
ByteStream::ByteStream( const uint8_t *data, size_t length )
ByteStream::ByteStream( const uint8_t *data, uint32_t length )
{
this->data = std::vector< uint8_t >( data, data + length );
this->write_position = 0;
this->position = 0;
}
ByteStream::ByteStream( size_t length )
ByteStream::ByteStream( uint32_t length )
{
this->data = std::vector< uint8_t >( length, 0 );
this->write_position = 0;
this->position = 0;
}
ByteStream::ByteStream()
{
this->write_position = 0;
this->position = 0;
}
ByteStream::~ByteStream()
{
}
void ByteStream::resize( size_t size )
void ByteStream::resize( uint32_t size )
{
data.resize( size );
}
@@ -54,19 +55,22 @@ void ByteStream::write( T value )
template < typename T >
T ByteStream::read()
{
T value = *( T * )&data[ write_position ];
write_position += sizeof( T );
T value = *( T * )&data[ position ];
position += sizeof( T );
return value;
}
void ByteStream::write_utf8( const std::string &value )
{
write_u32( value.size() );
write_bytes( std::vector< uint8_t >( value.begin(), value.end() ) );
}
void ByteStream::write_utf16( const std::wstring &value )
{
write_u32( value.size() );
std::vector< uint8_t > utf16;
for( auto c : value )
{
@@ -79,16 +83,50 @@ void ByteStream::write_utf16( const std::wstring &value )
void ByteStream::write_sz_utf8( const std::string &value )
{
write_utf8( value );
write_bytes( std::vector< uint8_t >( value.begin(), value.end() ) );
write< uint8_t >( 0 );
}
void ByteStream::write_sz_utf16( const std::wstring &value )
{
write_utf16( value );
std::vector< uint8_t > utf16;
for( auto c : value )
{
utf16.push_back( c & 0xFF );
utf16.push_back( ( c >> 8 ) & 0xFF );
}
write_bytes( utf16 );
write<uint16_t>( 0 );
}
void ByteStream::write_encrypted_utf8( const std::string &value )
{
auto encrypted = RealmCrypt::encryptSymmetric( std::vector< uint8_t >( value.begin(), value.end() ) );
write_u32( encrypted.size() + 4 );
write_u32( value.size() );
write_bytes( encrypted );
}
void ByteStream::write_encrypted_utf16( const std::wstring &value )
{
std::vector< uint8_t > utf16;
for( auto c : value )
{
utf16.push_back( c & 0xFF );
utf16.push_back( ( c >> 8 ) & 0xFF );
}
auto encrypted = RealmCrypt::encryptSymmetric( utf16 );
write_u32( encrypted.size() + 4 );
write_u32( value.size() * 2 );
write_bytes( encrypted );
}
uint8_t ByteStream::read_u8()
{
return read< uint8_t >();
@@ -126,29 +164,29 @@ float_t ByteStream::read_f32()
std::string ByteStream::read_utf8()
{
uint32_t length = read_u32();
auto length = read_u32();
std::string value;
for( size_t i = 0; i < length; i++ )
{
value.push_back( data[ write_position + i ] );
value.push_back( data[ position + i ] );
}
write_position += length;
position += length;
return value;
}
std::wstring ByteStream::read_utf16()
{
auto length = read_u32() * 2;
std::wstring value;
uint32_t length = read_u32() * 2;
for( size_t i = 0; i < length; i += 2 )
{
value.push_back( data[ write_position + i ] | ( data[ write_position + i + 1 ] << 8 ) );
value.push_back( data[ position + i ] | ( data[ position + i + 1 ] << 8 ) );
}
write_position += length;
position += length;
return value;
}
@@ -156,13 +194,13 @@ std::wstring ByteStream::read_utf16()
std::string ByteStream::read_sz_utf8()
{
std::string value;
while( data[ write_position ] != 0 )
while( data[ position ] != 0 )
{
value.push_back( data[ write_position ] );
write_position++;
value.push_back( data[ position ] );
position++;
}
write_position++;
position++;
return value;
}
@@ -170,63 +208,151 @@ std::string ByteStream::read_sz_utf8()
std::wstring ByteStream::read_sz_utf16()
{
std::wstring value;
while( data[ write_position ] != 0 || data[ write_position + 1 ] != 0 )
while( data[ position ] != 0 || data[ position + 1 ] != 0 )
{
value.push_back( data[ write_position ] | ( data[ write_position + 1 ] << 8 ) );
write_position += 2;
value.push_back( data[ position ] | ( data[ position + 1 ] << 8 ) );
position += 2;
}
write_position += 2;
position += 2;
return value;
}
std::string ByteStream::read_encrypted_utf8( bool hasBlockLength )
{
uint32_t encryptedLength = 0;
uint32_t decryptedLength = 0;
if( hasBlockLength )
{
uint32_t blockLength = read_u32() * 2;
decryptedLength = read_u32();
encryptedLength = blockLength - 4;
}
else
{
decryptedLength = read_u32();
encryptedLength = Math::round_up( decryptedLength, 16 );
}
std::span< const uint8_t > encryptedBuffer( data.data() + position, encryptedLength );
position += encryptedLength;
if( decryptedLength == 0 )
{
return "";
}
// Decrypt the buffer
std::vector< uint8_t > decryptedBuffer = RealmCrypt::decryptSymmetric( encryptedBuffer );
std::string result( decryptedBuffer.begin(), decryptedBuffer.end() );
return result;
}
std::wstring ByteStream::read_encrypted_utf16( bool hasBlockLength )
{
uint32_t encryptedLength = 0;
uint32_t decryptedLength = 0;
if( hasBlockLength )
{
uint32_t blockLength = read_u32() * 2;
decryptedLength = read_u32(); // This length is already multiplied by sizeof(wchar_t)
encryptedLength = blockLength - 4;
}
else
{
decryptedLength = read_u32();
encryptedLength = Math::round_up( decryptedLength, 16 );
}
std::span< const uint8_t > encryptedBuffer( data.data() + position, encryptedLength );
position += encryptedLength;
if( decryptedLength == 0 )
{
return L"";
}
// Decrypt the buffer
std::vector< uint8_t > decryptedBuffer = RealmCrypt::decryptSymmetric( encryptedBuffer );
std::wstring result( decryptedLength / 2, L'\0' );
std::memcpy( result.data(), decryptedBuffer.data(), decryptedLength );
return result;
}
void ByteStream::write_bytes( const std::vector< uint8_t > &value )
{
std::copy( value.begin(), value.end(), std::back_inserter( data ) );
write_position += value.size();
position += value.size();
}
void ByteStream::write_bytes( const uint8_t *value, size_t length )
void ByteStream::write_bytes( const uint8_t *value, uint32_t length )
{
std::copy( value, value + length, std::back_inserter( data ) );
write_position += length;
position += length;
}
std::vector<uint8_t> ByteStream::read_bytes( size_t length )
void ByteStream::write_encrypted_bytes( const std::vector<uint8_t> &value )
{
auto encrypted = RealmCrypt::encryptSymmetric( value );
write_u32( encrypted.size() + 4 );
write_u32( value.size() );
write_bytes( encrypted );
}
std::vector<uint8_t> ByteStream::read_bytes( uint32_t length )
{
std::vector<uint8_t> value( length, 0 );
std::copy( data.begin() + write_position, data.begin() + write_position + length, value.begin() );
std::copy( data.begin() + position, data.begin() + position + length, value.begin() );
write_position += length;
position += length;
return value;
}
std::vector<uint8_t> ByteStream::read_encrypted_bytes( uint32_t length )
{
std::vector< uint8_t > encrypted = read_bytes( length );
auto decrypted = RealmCrypt::decryptSymmetric( encrypted );
return decrypted;
}
std::vector<uint8_t> ByteStream::get_data() const
{
return data;
}
size_t ByteStream::get_length() const
uint32_t ByteStream::get_length() const
{
return data.size();
}
void ByteStream::set_write_position( size_t write_position )
void ByteStream::set_position( uint32_t where )
{
if( write_position > data.size() )
if( where > data.size() )
{
write_position = data.size();
where = data.size();
}
this->write_position = write_position;
this->position = where;
}
size_t ByteStream::get_write_position() const
uint32_t ByteStream::get_position() const
{
return this->write_position;
return this->position;
}
void ByteStream::write_u8( uint8_t value )

36
misc/ByteStream.h
View File

@@ -5,18 +5,20 @@
#include <memory>
#include <iterator>
class ByteStream
{
#include "math.h"
#include "RealmCrypt.h"
class ByteStream {
public:
ByteStream( const std::vector< uint8_t > &data );
ByteStream( const std::string &data );
ByteStream( const uint8_t *data, size_t length );
ByteStream( size_t length );
ByteStream( const uint8_t *data, uint32_t length );
ByteStream( uint32_t length );
ByteStream();
~ByteStream();
void resize( size_t size );
void resize( uint32_t size );
void shrink_to_fit();
template < typename T >
@@ -37,6 +39,8 @@ public:
void write_utf16( const std::wstring &value );
void write_sz_utf8( const std::string &value );
void write_sz_utf16( const std::wstring &value );
void write_encrypted_utf8( const std::string &value );
void write_encrypted_utf16( const std::wstring &value );
uint8_t read_u8();
uint16_t read_u16();
@@ -50,18 +54,24 @@ public:
std::wstring read_utf16();
std::string read_sz_utf8();
std::wstring read_sz_utf16();
std::string read_encrypted_utf8( bool hasBlockLength = true );
std::wstring read_encrypted_utf16( bool hasBlockLength = true );
void write_bytes( const std::vector< uint8_t > &value );
void write_bytes( const uint8_t *value, size_t length );
void write_bytes( const uint8_t *value, uint32_t length );
void write_encrypted_bytes( const std::vector< uint8_t > &value );
std::vector< uint8_t > read_bytes( uint32_t length );
std::vector< uint8_t > read_encrypted_bytes( uint32_t length );
std::vector< uint8_t > read_bytes( size_t length );
std::vector< uint8_t > get_data() const;
size_t get_length() const;
void set_write_position( size_t write_position );
size_t get_write_position() const;
uint32_t get_length() const;
uint32_t get_position() const;
void set_position( uint32_t pos );
std::vector< uint8_t > data;
size_t write_position;
};
uint32_t position;
};
typedef std::shared_ptr< ByteStream > sptr_byte_stream;

153
misc/Encryptor.cpp
View File

@@ -1,153 +0,0 @@
#include "Encryptor.h"
#include <ctime>
#include <array>
#include "AES.h"
bool Encryptor::ms_initialized = false;
Encryptor::Encryptor()
{
// Initialize the private key
m_privateKey = ""; // Default initialization
// Initialize basic_str_b
basic_str_b = "";
// Initialize the symmetric key
m_symmetricKey.assign( default_sym_key );
// Static initialization logic
if( !ms_initialized )
{
ms_initialized = true;
std::srand( static_cast< unsigned >( std::time( nullptr ) ) );
Encryptor::test();
}
}
std::string Encryptor::generateSymmetricKey( void )
{
constexpr size_t KEY_LENGTH = 32;
std::array<unsigned char, KEY_LENGTH> keyData{ 0 };
// Generate 32 random bytes
for( size_t i = 0; i < KEY_LENGTH; ++i )
{
keyData[ i ] = static_cast< unsigned char >( rand() % 255 );
}
// Replace the symmetric key with the generated key
m_symmetricKey.assign( reinterpret_cast< char * >( keyData.data() ), KEY_LENGTH );
return m_symmetricKey;
}
std::string Encryptor::generatePrivateSymKey( void )
{
constexpr size_t KEY_LENGTH = 32;
std::array<unsigned char, KEY_LENGTH> keyData{ 0 };
// Generate 32 random bytes
for( size_t i = 0; i < KEY_LENGTH; ++i )
{
keyData[ i ] = static_cast< unsigned char >( rand() % 255 );
}
// Replace the symmetric key with the generated key
m_privateKey.assign( reinterpret_cast< char * >( keyData.data() ), KEY_LENGTH );
// Print the private key as bytes
printf( "Private Sym Key: " );
for( auto c : m_privateKey )
{
printf( "%02X", (uint8_t)c );
}
printf( "\n" );
// Encrypt the private key
AES aes( AESKeyLength::AES_128 );
auto c = aes.EncryptECB(
reinterpret_cast< const uint8_t * >( m_privateKey.c_str() ),
m_privateKey.size(),
reinterpret_cast< const uint8_t * >( default_public_key.c_str() ) );
m_encryptedPrivateKey = std::string( reinterpret_cast< const char * >( c ), m_privateKey.size() );
// Print the encrypted key as bytes
printf( "Encrypted Sym Key: " );
for( auto c : m_encryptedPrivateKey )
{
printf( "%02X", ( uint8_t )c );
}
printf( "\n" );
return m_encryptedPrivateKey;
}
std::string Encryptor::encryptSymmetric( const std::string &input )
{
AES aes( AESKeyLength::AES_128 );
auto result = aes.EncryptECB( reinterpret_cast< const uint8_t * >( input.c_str() ), input.size(), reinterpret_cast< const uint8_t * >( m_privateKey.c_str() ) );
return std::string( reinterpret_cast< const char * >( result ), input.size() );
}
std::string Encryptor::decryptSymmetric( const std::string &input )
{
AES aes( AESKeyLength::AES_128 );
auto result = aes.DecryptECB( reinterpret_cast< const uint8_t * >( input.c_str() ), input.size(), reinterpret_cast< const uint8_t * >( m_privateKey.c_str() ) );
return std::string( reinterpret_cast< const char * >( result ), input.size() );
}
void Encryptor::test()
{
/*std::string inputStr = "HelloWorld"; // Input string to encrypt and decrypt
std::string intermediateEncryptedStr; // Encrypted intermediate result
std::string intermediateDecryptedStr; // Decrypted intermediate result
// Generate symmetric key
std::string symmetricKey;
generateSymmetricKey( symmetricKey );
// Encrypt the input string using the symmetric key
encryptor.encryptSymmetric( intermediateEncryptedStr, inputStr );
// Log intermediate encryption result
std::cout << "Encrypted string: " << intermediateEncryptedStr << std::endl;
// Decrypt the encrypted string using the symmetric key
encryptor.decryptSymmetric( intermediateDecryptedStr, intermediateEncryptedStr );
// Log final decryption result
std::cout << "Decrypted string: " << intermediateDecryptedStr << std::endl;
// Check if decryption matches the original input
if( inputStr == intermediateDecryptedStr )
{
std::cout << "Test passed: Decryption matches original input." << std::endl;
}
else
{
std::cout << "Test failed: Decryption does not match original input." << std::endl;
}*/
}
int decryptBuffer( const uint8_t *input, int32_t dataSize, uint8_t *output, const uint8_t *symKey )
{
if( dataSize <= 0 )
{
return false; // No data to decrypt
}
AES aes( AESKeyLength::AES_128 );
output = aes.DecryptECB( input, dataSize, symKey );
return true;
}

39
misc/Encryptor.h
View File

@@ -1,39 +0,0 @@
#pragma once
#include <string>
int decryptBuffer( const uint8_t *input, int64_t dataSize, uint8_t *output, const uint8_t *symKey );
class Encryptor
{
public:
const static inline std::string default_public_key = "25B946EBC0B361734A63910E1FF3C9E1";
const static inline std::string default_sym_key = "dlfk qs';r+t iqe4t9ueerjKDJ wdaj";
Encryptor(); // Constructor
std::string generateSymmetricKey( void );
std::string generatePrivateSymKey( void );
std::string encryptSymmetric( const std::string &input );
std::string decryptSymmetric( const std::string &input );
void setSymmetricKey( const std::string &key );
std::string getSymmetricKey( void ) const;
void setPublicKey( const std::string &key );
std::string getPublicKey( void ) const;
void setPrivateKey( const std::string &key );
std::string getPrivateKey( void ) const;
static void test();
std::string m_privateKey, m_encryptedPrivateKey;
std::string m_symmetricKey;
std::string basic_str_b;
static bool ms_initialized;
};

167
misc/RealmCrypt.cpp Normal file
View File

@@ -0,0 +1,167 @@
#include <ctime>
#include <array>
#include "../misc/math.h"
#include "../Crypto/NorrathCrypt.h"
#include "RealmCrypt.h"
bool RealmCrypt::ms_initialized = false;
RealmCrypt::RealmCrypt()
{
if( !ms_initialized )
{
ms_initialized = true;
std::srand( static_cast< unsigned >( std::time( nullptr ) ) );
RealmCrypt::test();
}
}
std::vector< uint8_t > RealmCrypt::generateSymmetricKey( void )
{
constexpr size_t KEY_LENGTH = 32;
std::vector< uint8_t > keyData( KEY_LENGTH, 0 );
// Generate 32 random bytes
for( size_t i = 0; i < KEY_LENGTH; ++i )
{
keyData[ i ] = static_cast< uint8_t >( rand() % 255 );
}
return keyData;
}
std::vector<uint8_t> RealmCrypt::getSymmetricKey( void )
{
return default_sym_key;
}
std::string RealmCrypt::encryptString( std::string &input )
{
if( input.size() % 16 != 0 )
{
input.append( 16 - ( input.size() % 16 ), '\0' );
}
rijndael aes( KeyLength::_256 );
auto result = aes.EncryptECB( reinterpret_cast< const uint8_t * >( input.c_str() ), input.size(), default_sym_key.data() );
return std::string( reinterpret_cast< const char * >( result ), input.size() );
}
std::string RealmCrypt::decryptString( std::string &input )
{
if( input.size() % 16 != 0 )
{
input.append( 16 - ( input.size() % 16 ), '\0' );
}
rijndael aes( KeyLength::_256 );
auto result = aes.DecryptECB( reinterpret_cast< const uint8_t * >( input.c_str() ), input.size(), default_sym_key.data() );
return std::string( reinterpret_cast< const char * >( result ), input.size() );
}
std::wstring RealmCrypt::encryptString( std::wstring &input )
{
if( input.size() % 16 != 0 )
{
input.append( 16 - ( input.size() % 16 ), L'\0' );
}
rijndael aes( KeyLength::_256 );
auto result = aes.EncryptECB( reinterpret_cast< const uint8_t * >( input.c_str() ), input.size(), default_sym_key.data() );
return std::wstring( reinterpret_cast< const wchar_t * >( result ), input.size() );
}
std::wstring RealmCrypt::decryptString( std::wstring &input )
{
if( input.size() % 16 != 0 )
{
input.append( 16 - ( input.size() % 16 ), L'\0' );
}
rijndael aes( KeyLength::_256 );
auto result = aes.DecryptECB( reinterpret_cast< const uint8_t * >( input.c_str() ), input.size(), default_sym_key.data() );
return std::wstring( reinterpret_cast< const wchar_t * >( result ), input.size() );
}
std::vector< uint8_t > RealmCrypt::encryptSymmetric( std::vector< const uint8_t > &input )
{
return std::vector< uint8_t >();
}
std::vector< uint8_t > RealmCrypt::decryptSymmetric( std::vector< const uint8_t > &input )
{
return std::vector< uint8_t >();
}
std::vector< uint8_t > RealmCrypt::encryptSymmetric( std::span< const uint8_t > input )
{
if( input.size() % 16 != 0 )
{
std::vector< uint8_t > paddedInput( input.begin(), input.end() );
paddedInput.resize( ( ( input.size() / 16 ) + 1 ) * 16, 0 );
input = paddedInput;
}
rijndael aes( KeyLength::_256 );
auto result = aes.EncryptECB( reinterpret_cast< const uint8_t * >( input.data() ), input.size(), default_sym_key.data() );
return std::vector< uint8_t >( result, result + input.size() );
}
std::vector< uint8_t > RealmCrypt::decryptSymmetric( std::span< const uint8_t > input )
{
if( input.size() % 16 != 0 )
{
std::vector< uint8_t > paddedInput( input.begin(), input.end() );
paddedInput.resize( ( ( input.size() / 16 ) + 1 ) * 16, 0 );
input = paddedInput;
}
rijndael aes( KeyLength::_256 );
auto result = aes.DecryptECB( reinterpret_cast< const uint8_t * >( input.data() ), input.size(), default_sym_key.data() );
return std::vector< uint8_t >( result, result + input.size() );
}
void RealmCrypt::test()
{
std::string inputStr = "HelloWorldThisIsATest"; // Input string to encrypt and decrypt
// Generate symmetric key
auto symmetricKey = generateSymmetricKey();
// Encrypt the input string using the symmetric key
auto intermediateEncryptedStr = encryptString( inputStr );
// Log intermediate encryption result
std::cout << "Encrypted string: " << intermediateEncryptedStr << std::endl;
// Decrypt the encrypted string using the symmetric key
auto intermediateDecryptedStr = decryptString( intermediateEncryptedStr );
// Log final decryption result
std::cout << "Decrypted string: " << intermediateDecryptedStr << std::endl;
// Check if decryption matches the original input
if( inputStr == intermediateDecryptedStr )
{
std::cout << "Test passed: Decryption matches original input." << std::endl;
}
else
{
std::cout << "Test failed: Decryption does not match original input." << std::endl;
}
}

88
misc/RealmCrypt.h Normal file
View File

@@ -0,0 +1,88 @@
#pragma once
#include <string>
#include <vector>
#include <span>
// This class is based on the games Encryptor class,
// and is a wrapper around the rijndael ECB implementation.
//
// Normally CoN would generate a random symmetric key for each user,
// but for the sake of simplicity we will just use the games default key,
// since we have nothing to hide.
class RealmCrypt {
private:
// Byte array of dlfk qs';r+t iqe4t9ueerjKDJ wdaj
const static inline std::vector< uint8_t > default_sym_key =
{
0x64, 0x6c, 0x66, 0x6b, 0x20, 0x71, 0x73, 0x27,
0x3b, 0x72, 0x2b, 0x74, 0x20, 0x69, 0x71, 0x65,
0x34, 0x74, 0x39, 0x75, 0x65, 0x65, 0x72, 0x6a,
0x4b, 0x44, 0x4a, 0x20, 0x77, 0x64, 0x61, 0x6a
};
public:
RealmCrypt();
// Generate a new symmetric key for the user.
static std::vector< uint8_t > generateSymmetricKey( void );
static std::vector< uint8_t > getSymmetricKey( void );
// Encrypt and decrypt strings.
static std::string encryptString( std::string &input );
static std::string decryptString( std::string &input );
static std::wstring encryptString( std::wstring &input );
static std::wstring decryptString( std::wstring &input );
// Encrypt and decrypt byte arrays.
static std::vector< uint8_t > encryptSymmetric( std::vector< const uint8_t > &input );
static std::vector< uint8_t > decryptSymmetric( std::vector< const uint8_t > &input );
static std::vector< uint8_t > encryptSymmetric( std::span< const uint8_t > input );
static std::vector< uint8_t > decryptSymmetric( std::span< const uint8_t > input );
// Test to make sure the encryption and decryption works.
void test();
// Initializer state for srand.
static bool ms_initialized;
};
/*class Encryptor {
private:
// "dlfk qs';r+t iqe4t9ueerjKDJ wdaj";
const static inline std::vector< uint8_t > default_sym_key =
{
0x64, 0x6c, 0x66, 0x6b, 0x20, 0x71, 0x73, 0x27,
0x3b, 0x72, 0x2b, 0x74, 0x20, 0x69, 0x71, 0x65,
0x34, 0x74, 0x39, 0x75, 0x65, 0x65, 0x72, 0x6a,
0x4b, 0x44, 0x4a, 0x20, 0x77, 0x64, 0x61, 0x6a
};
public:
Encryptor();
std::vector< uint8_t > generateSymmetricKey( void );
std::string encryptString( std::string &input );
std::string decryptString( std::string &input );
std::wstring encryptString( std::wstring &input );
std::wstring decryptString( std::wstring &input );
std::vector< uint8_t > encryptSymmetric( std::vector< const uint8_t > &input );
std::vector< uint8_t > decryptSymmetric( std::vector< const uint8_t > &input );
std::vector< uint8_t > encryptSymmetric( std::span< const uint8_t > input );
std::vector< uint8_t > decryptSymmetric( std::span< const uint8_t > input );
void setSymmetricKey( const std::vector< uint8_t > &input );
std::vector< uint8_t > getSymmetricKey( void ) const;
void test();
std::vector< uint8_t > m_symKey;
static bool ms_initialized;
};*/

99
misc/Timer.h
View File

@@ -1,58 +1,59 @@
#pragma once
#include <Windows.h>
#include <chrono>
class CTimer {
int m_stopped;
int m_inited;
int m_usingQPF;
double m_lastElapsedTime;
double m_baseTime;
double m_stopTime;
double m_currSysTime;
double m_currElapsedTime;
double m_baseMilliTime;
double m_currSysMilliTime;
double m_currElapsedMilliTime;
long long m_QPFTicksPerSec;
long long m_QPFStopTime;
long long m_QPFLastElapsedTime;
long long m_QPFBaseTime;
LARGE_INTEGER m_QPFTime;
class Timer {
private:
std::chrono::high_resolution_clock::time_point m_startTime;
std::chrono::high_resolution_clock::time_point m_stopTime;
bool m_running;
public:
Timer() : m_running(false) {}
CTimer();
~CTimer();
void Start() {
if (!m_running) {
m_startTime = std::chrono::high_resolution_clock::now();
m_running = true;
}
}
void Start();
void Stop();
void Advance();
void Reset();
double Tick();
inline double GetAppTime()
{
return ( m_currSysTime - m_baseTime );
}
inline double GetElapsedTime()
{
return m_currElapsedTime;
}
inline double GetSysTime()
{
return m_currSysTime;
}
inline double GetAppMilliTime()
{
return ( m_currSysMilliTime - m_baseMilliTime );
}
inline double GetElapsedMilliTime()
{
return m_currElapsedMilliTime;
}
void Stop() {
if (m_running) {
m_stopTime = std::chrono::high_resolution_clock::now();
m_running = false;
}
}
double GetAbsoluteTime();
void Reset() {
m_startTime = std::chrono::high_resolution_clock::now();
m_stopTime = m_startTime;
m_running = false;
}
double GetElapsedTime() const
{
if (m_running) {
auto currentTime = std::chrono::high_resolution_clock::now();
return std::chrono::duration<double>(currentTime - m_startTime).count();
}
else {
return std::chrono::duration<double>(m_stopTime - m_startTime).count();
}
}
long long GetElapsedTimeMilliseconds() const
{
if( m_running )
{
auto currentTime = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast< std::chrono::milliseconds >( currentTime - m_startTime );
return duration.count();
}
else
{
auto duration = std::chrono::duration_cast< std::chrono::milliseconds >( m_stopTime - m_startTime );
return duration.count();
}
}
};