void config_parse(config_file_entry_t * entries, int level)
{
static char* name;
static char* orig_hex_bytes;
static char* patch_hex_bytes;
static char* orig_string;
static char* patch_string;
static int architecture;
static int global_os;
static char* type;
static unsigned char* t0, *p0;
static size_t t0s, p0s;
config_file_entry_t * e, *s;
e = entries;
while (e != NULL)
{
if(level == 2) {
name = e->varname;
SAFE_FIND("OriginalHexBytes", orig_hex_bytes);
SAFE_FIND("PatchedHexBytes", patch_hex_bytes);
SAFE_FIND("OriginalString", orig_string);
SAFE_FIND("PatchedString", patch_string);
SAFE_FIND("Type", type);
SAFE_FIND_INT("GlobalOperatingSystem", global_os);
SAFE_FIND_INT("Architecture", architecture);
if(orig_string && patch_string) {
t0s = strlen(orig_string);
p0s = strlen(patch_string);
t0 = (unsigned char*)orig_string;
p0 = (unsigned char*)patch_string;
if(t0s != p0s) {
printf("Patches must be the same size. Aborting.\n");
}
} else if(orig_hex_bytes && patch_hex_bytes) {
hexToBytes(orig_hex_bytes, &t0, &t0s);
hexToBytes(patch_hex_bytes, &p0, &p0s);
if(t0s != p0s) {
printf("Patches must be the same size. Aborting.\n");
}
}
if(!strcasecmp(type, "BootLoader"))
patch_node_add(name, t0, p0, t0s, architecture, global_os, patch_node_create(), iboot_patches);
else if(!strcasecmp(type, "Kernel"))
patch_node_add(name, t0, p0, t0s, architecture, global_os, patch_node_create(), kernel_patches);
else
printf("Unknown patch type \"%s\".\n", name);
orig_hex_bytes = patch_hex_bytes = orig_string = patch_string = NULL;
architecture = global_os = t0s = p0s = 0;
t0 = p0 = type = NULL;
}
if (e->entries != NULL)
config_parse(e->entries, level+1);
e = e->next;
}
}
/// 字符模式解码
/// 数据源是ASCII 字符(16进制字符串),解码成功后得到的rsp仍然是二进制数据(已经转换)
static void decodeAsc(const void* start, size_t size, ParseStatus& parseStatus, RdResponse& rsp)
{
////
if (!preCheckAsc(start, size, parseStatus)) {
return;
}
if (size % 2 != 0) {
parseStatus.bytes = 1;
parseStatus.status = ParseStatus::kParseMoreData;
return;
}
Buffer binary;
binary.ensure_write_space(size); // (size/2 + size%2) is good enough
if (!hexToBytes(start, size, binary.wt_ptr())) {
parseStatus.bytes = size;
parseStatus.status = ParseStatus::kParseInvalidData;
return;
}
else {
binary.has_written(size / 2);
}
decode(binary.rd_ptr(), binary.readable_bytes(), parseStatus,rsp);
parseStatus.bytes = parseStatus.bytes * 2;
}
char *decode(EncodeFormat format, const char *src, size_t srclen, size_t &dstlen)
{
switch (format)
{
case ENCODE_BASE64:
default:
return b64_decode(src, srclen, dstlen);
case ENCODE_HEX:
return (char *) hexToBytes(src, srclen, dstlen);
}
}
int main(void){
int idx = 0;
while ( number[++idx] != '\0' );
unsigned char result[(idx+1)/2];
char base64res[idx];
hexToBytes(number,idx,result);
bytesToBase64(result,(idx+1)/2,base64res);
reverseArray( base64res );
printf("%s %d \n", base64res, strcmp(base64res,answer));
return 0;
}
size_t ConvertHexaCFString(CFStringRef s, uint8_t** bytes)
{
uint32_t len = CFStringGetLength(s);
uint8_t* hex = malloc(len+1);
if(hex == NULL)
return 0;
if(!CFStringGetCString(s, hex, len+1, kCFStringEncodingASCII))
{
free(hex);
return 0;
}
size_t size = 0;
hexToBytes(hex, bytes, &size);
free(hex);
return size;
}
static error_t cmd_aes(int argc, char** argv)
{
uint8_t* key = NULL;
uint8_t* iv = NULL;
uint8_t* data = NULL;
uint8_t* buff = NULL;
uint32_t keyType;
uint32_t keyLength;
uint32_t ivLength;
uint32_t dataLength;
if(argc < 4) {
bufferPrintf("Usage: %s <enc/dec> <gid/uid/key> [data] [iv]\r\n", argv[0]);
return -1;
}
if(strcmp(argv[2], "gid") == 0)
{
keyType = 512;
}
else if(strcmp(argv[2], "uid") == 0)
{
keyType = 513;
}
else
{
hexToBytes(argv[2], &key, (int*)&keyLength);
switch(keyLength*8)
{
case 128:
keyType = 0 << 28;
break;
case 192:
keyType = 1 << 28;
break;
case 256:
keyType = 2 << 28;
break;
default:
bufferPrintf("Usage: %s <enc/dec> <gid/uid/key> [data] [iv]\r\n", argv[0]);
goto return_free;
}
}
hexToBytes(argv[3], &data, (int*)&dataLength);
buff = memalign(DMA_ALIGN, dataLength);
if (!buff) {
bufferPrintf("out of memory.\r\n");
goto return_free;
}
memcpy(buff, data, dataLength);
free(data);
data = NULL;
if(argc > 4)
{
hexToBytes(argv[4], &iv, (int*)&ivLength);
}
if(strcmp(argv[1], "enc") == 0)
aes_crypto_cmd(0x10, buff, buff, dataLength, keyType, key, iv);
else if(strcmp(argv[1], "dec") == 0)
aes_crypto_cmd(0x11, buff, buff, dataLength, keyType, key, iv);
else
{
bufferPrintf("Usage: %s <enc/dec> <gid/uid/key> [data] [iv]\r\n", argv[0]);
goto return_free;
}
bytesToHex(buff, dataLength);
bufferPrintf("\r\n");
return_free:
if (data)
free(data);
if (iv)
free(iv);
if (key)
free(key);
if (buff)
free(buff);
return 0;
}
int run_tests() {
int numBytes;
unsigned char *asHex;
//
// fromBase58() - bad input
//
asHex = fromBase58("Lbwb5yufe3TCSvjwoAUrk9FORe7aeJ62YTo6ABDiFts7ovY8tcak");
assert(asHex == NULL);
//
// fromBase58() - good input
//
asHex = fromBase58("Lbwb5yufe3TCSvjwoAUrk9FzRe7aeJ62YTo6ABDiFts7ovY8tcak");
assert(asHex != NULL);
assert(strlen(asHex) == 76);
assert(strncmp(
"84835d5042486a38e5e93345649ace3943efddc643b3c0ecc3d144e654113682ce7d4882f799",
asHex, 76) == 0);
unsigned char keyHex[65];
memcpy (keyHex, asHex + 2, 64);
keyHex[64] = '\0';
free(asHex);
//
// bytesToHex(hexToBytes(str)) == str
//
char *inputHex =
"0450863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B2355";
unsigned char* inputBytes =
hexToBytes((unsigned char*) inputHex, &numBytes);
unsigned char* outputHex = bytesToHex(inputBytes, numBytes);
assert (inputBytes != NULL);
assert (outputHex != NULL);
assert (strncmp((char*)inputHex, (char*) outputHex, strlen(inputHex)) == 0);
free(inputBytes);
free(outputHex);
//
// hexToBytes - bad input
//
unsigned char* secret;
secret = hexToBytes("A", &numBytes);
assert(secret == NULL);
secret = hexToBytes("AG", &numBytes);
assert(secret == NULL);
//
// hexToBytes - good input
//
secret = hexToBytes(keyHex, &numBytes);
assert(secret != NULL);
assert(numBytes == 32);
unsigned char *privateB58U;
unsigned char *publicB58U;
unsigned char *privateB58C;
unsigned char *publicB58C;
privateB58U = secretBytesToPrivate(secret, 32, 0);
publicB58U = secretBytesToPublic(secret, 32, 0);
assert(privateB58U != NULL);
assert(publicB58U != NULL);
assert(strncmp(privateB58U,
"5Jp97RMBQfEy5xDCuz59HQzL8TMPGmrsVvzT37zAotrE53brxHx",
strlen(privateB58U)) == 0);
assert(strncmp(publicB58U,
"1LEyj89YU4qGfFk7dc1jpGAYX5DhQm9moP",
strlen(publicB58U)) == 0);
privateB58C = secretBytesToPrivate(secret, 32, 1);
publicB58C = secretBytesToPublic(secret, 32, 1);
assert(privateB58C != NULL);
assert(publicB58C != NULL);
assert(strncmp(privateB58C,
"L1d4oLU4wRneYrgsaruHZSt3RuJyJd17thJZvMqLHyrGgMq74H5L",
strlen(privateB58C)) == 0);
assert(strncmp(publicB58C,
"1PaJnioooVnq5oMgF4wYNer6rVyxZLaTqf",
strlen(publicB58C)) == 0);
free(secret);
free(privateB58U);
free(publicB58U);
free(privateB58C);
free(publicB58C);
return 0;
}
void cmd_aes(int argc, char** argv)
{
AESKeyType keyType;
uint8_t* data = NULL;
uint8_t* key = NULL;
uint8_t* iv = NULL;
int dataLength;
int keyLength;
int ivLength;
if(argc < 4)
{
bufferPrintf("Usage: %s <enc/dec> <gid/uid/key> [data] [iv]\r\n", argv[0]);
return;
}
if(strcmp(argv[2], "gid") == 0)
{
keyType = AESGID;
}
else if(strcmp(argv[2], "uid") == 0)
{
keyType = AESUID;
}
else
{
hexToBytes(argv[2], &key, &keyLength);
keyType = AESCustom;
}
hexToBytes(argv[3], &data, &dataLength);
if(argc > 4)
{
hexToBytes(argv[4], &iv, &ivLength);
}
if(strcmp(argv[1], "enc") == 0)
{
aes_encrypt(data, dataLength, keyType, key, iv);
bytesToHex(data, dataLength);
bufferPrintf("\r\n");
}
else if(strcmp(argv[1], "dec") == 0)
{
aes_decrypt(data, dataLength, keyType, key, iv);
bytesToHex(data, dataLength);
bufferPrintf("\r\n");
}
else
{
bufferPrintf("Usage: %s <enc/dec> <GID/UID/key> [data] [iv]\r\n", argv[0]);
}
if(data)
free(data);
if(iv)
free(iv);
if(key)
free(key);
}
