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); }