#include #include #include #include #include "ccdjit.h" typedef struct Ops { enum Way { Encrypt, Decrypt } way; const char *language; } Ops; typedef char *(*lang_fn)(const char *); typedef struct Lang { ccdjit_context *ctx; ccdjit_module *module; lang_fn encrypt; lang_fn decrypt; } Lang; typedef struct Crypt { Ops *options; Lang *lang; char *input_text; char *output_text; } Crypt; Ops* create_ops(void); Lang* lang_load(const char *name); void lang_unload(Lang *lang); Crypt* create_crypt(Ops *options, Lang *lang, const char *input_text); int crypt_run(Crypt *crypt); void free_crypt(Crypt *crypt); Ops* create_ops(void) { Ops *ops = malloc(sizeof(Ops)); if (!ops) return NULL; ops->way = Encrypt; ops->language = "english"; return ops; } // Only allow [a-z0-9_] so "../../etc/foo" can't escape langs/. static int valid_lang_name(const char *name) { if (!*name) return 0; for (const char *p = name; *p; p++) if (!islower((unsigned char)*p) && !isdigit((unsigned char)*p) && *p != '_') return 0; return 1; } // Reads path and appends a stub main() so CCDJIT accepts it as a module. static char *load_plugin_source(const char *path) { static const char stub[] = "\nint main(void) { return 0; }\n"; FILE *f = fopen(path, "rb"); if (!f) return NULL; if (fseek(f, 0, SEEK_END) != 0) { fclose(f); return NULL; } long n = ftell(f); if (n < 0) { fclose(f); return NULL; } rewind(f); char *buf = malloc((size_t)n + sizeof stub); if (!buf) { fclose(f); return NULL; } if (fread(buf, 1, (size_t)n, f) != (size_t)n) { free(buf); fclose(f); return NULL; } fclose(f); memcpy(buf + n, stub, sizeof stub); // includes the NUL terminator return buf; } Lang* lang_load(const char *name) { if (!valid_lang_name(name)) { fprintf(stderr, "Invalid language name: %s\n", name); return NULL; } Lang *lang = calloc(1, sizeof(Lang)); if (!lang) return NULL; ccdjit_options opts = { .allow_filesystem_includes = 1, .allow_system_includes = 1, .allow_executable_memory = 1, }; lang->ctx = ccdjit_context_new(&opts); if (!lang->ctx) goto fail; ccdjit_context_add_include_path(lang->ctx, "."); // finds lang.h char path[256]; snprintf(path, sizeof path, "langs/%s.c", name); char *src = load_plugin_source(path); if (!src) { fprintf(stderr, "Cannot read %s\n", path); goto fail; } if (ccdjit_compile_string(lang->ctx, src, path, &lang->module) != 0) { const ccdjit_diagnostic *d = ccdjit_context_last_error(lang->ctx); fprintf(stderr, "[%s] %s:%d:%d: %s\n", d->phase, d->filename, d->line, d->column, d->message); free(src); goto fail; } free(src); lang->encrypt = (lang_fn)ccdjit_module_symbol(lang->module, "lang_encrypt"); lang->decrypt = (lang_fn)ccdjit_module_symbol(lang->module, "lang_decrypt"); if (!lang->encrypt || !lang->decrypt) { fprintf(stderr, "%s must define lang_encrypt and lang_decrypt\n", path); goto fail; } return lang; fail: lang_unload(lang); return NULL; } void lang_unload(Lang *lang) { if (!lang) return; if (lang->module) ccdjit_module_free(lang->module); if (lang->ctx) ccdjit_context_free(lang->ctx); free(lang); } Crypt* create_crypt(Ops *options, Lang *lang, const char *input_text) { Crypt *crypt = calloc(1, sizeof(Crypt)); if (!crypt) return NULL; crypt->options = options; crypt->lang = lang; crypt->input_text = strdup(input_text); if (!crypt->input_text) { free(crypt); return NULL; } return crypt; } int crypt_run(Crypt *crypt) { lang_fn fn = crypt->options->way == Encrypt ? crypt->lang->encrypt : crypt->lang->decrypt; crypt->output_text = fn(crypt->input_text); return crypt->output_text ? 0 : -1; } void free_crypt(Crypt *crypt) { if (!crypt) return; free(crypt->options); lang_unload(crypt->lang); free(crypt->input_text); free(crypt->output_text); free(crypt); } static void print_usage(const char *prog) { fprintf(stderr, "Usage: %s [-e | -d] [-l ] \n", prog); } int main(int argc, char **argv) { Ops *ops = create_ops(); if (!ops) return EXIT_FAILURE; const char *text = NULL; for (int i = 1; i < argc; i++) { if (strcmp(argv[i], "-e") == 0) ops->way = Encrypt; else if (strcmp(argv[i], "-d") == 0) ops->way = Decrypt; else if (strcmp(argv[i], "-l") == 0 && i + 1 < argc) ops->language = argv[++i]; else if (argv[i][0] != '-' && !text) text = argv[i]; else { print_usage(argv[0]); free(ops); return EXIT_FAILURE; } } if (!text) { print_usage(argv[0]); free(ops); return EXIT_FAILURE; } Lang *lang = lang_load(ops->language); if (!lang) { free(ops); return EXIT_FAILURE; } Crypt *crypt = create_crypt(ops, lang, text); if (!crypt) { lang_unload(lang); free(ops); return EXIT_FAILURE; } int rc = crypt_run(crypt); if (rc == 0) printf("%s\n", crypt->output_text); else fprintf(stderr, "Operation failed\n"); free_crypt(crypt); return rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE; }