kit

strip.c (21028B)

---

 #include <kit/archive.h>
 #include <kit/core.h>
 #include <kit/object.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "driver.h"
 #include "objedit.h"
 
 /* `kit strip` — drop debug sections and / or unwanted symbols from an object,
  * linked image, or static archive, then write the result back.
  *
  * Operations (the last one wins; default is --strip-all):
  *   --strip-debug        drop sections whose kind is KIT_SEC_DEBUG
  *   --strip-unneeded     drop debug + symbols not referenced by any reloc
  *   --strip-all          drop debug + every non-essential symbol (default)
  *
  * Filters applied on top of the operation:
  *   --keep-symbol=NAME, -K NAME    keep NAME even if the operation would drop
  * it
  *   --strip-symbol=NAME, -N NAME   always drop NAME
  *
  * I/O:
  *   -o PATH              write output to PATH (else rewrite the input in place)
  */
 
 #define STRIP_TOOL "strip"
 
 void driver_help_strip(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit strip — drop debug sections and/or symbols\n"
           "\n"
           "USAGE\n"
           "  kit strip [OPTIONS] FILE\n"
           "\n"
           "DESCRIPTION\n"
           "  Copies an object, linked executable/shared library, or static\n"
           "  archive while removing selected debug sections and symbols. By\n"
           "  default FILE is replaced in place; use -o PATH to preserve it.\n"
           "\n"
           "OPTIONS\n"
           "  -h, --help            Show this help and exit\n"
           "\n"
           "OPERATIONS (last one wins; default is --strip-all)\n"
           "  --strip-debug         remove debug-info sections\n"
           "  --strip-unneeded      remove debug + symbols not needed by "
           "relocs\n"
           "  --strip-all           remove debug + all non-essential symbols\n"
           "  --remove-signature    allow a signed linked image to be changed;\n"
           "                        the result must be signed again\n"
           "\n"
           "SYMBOL FILTERS (may repeat)\n"
           "  --keep-symbol=NAME, -K NAME   keep NAME even when the operation\n"
           "                                would otherwise drop it\n"
           "  --strip-symbol=NAME, -N NAME  always drop NAME\n"
           "\n"
           "OUTPUT\n"
           "  -o PATH               write to PATH (default: rewrite FILE in "
           "place)\n"
           "\n"
           "LINKED IMAGES\n"
           "  ELF, Mach-O, and PE executables/shared libraries are rewritten in\n"
           "  place at the format layer without relinking. Loader-required\n"
           "  metadata and executable permissions are preserved. Signed images\n"
           "  fail unchanged unless --remove-signature is explicit. Symbol\n"
           "  keep/drop filters apply only to relocatable inputs.\n"
           "\n"
           "EXAMPLES\n"
           "  kit strip --strip-debug -o foo.stripped.o foo.o\n"
           "  kit strip --strip-debug -o app.stripped app\n"
           "  kit objdump -h foo.stripped.o\n"
           "  kit strip --strip-unneeded -o libfoo.stripped.a libfoo.a\n"
           "  kit nm -g libfoo.stripped.a\n"
           "\n"
           "EXIT CODES\n"
           "  0   success           1   I/O or strip error           2   bad "
           "usage\n")));
 }
 
 typedef enum StripOp {
   STRIP_OP_DEBUG,
   STRIP_OP_UNNEEDED,
   STRIP_OP_ALL,
 } StripOp;
 
 typedef struct StripOpts {
   StripOp op;
   const char** keep;
   uint32_t nkeep;
   uint32_t cap_keep;
   const char** strip;
   uint32_t nstrip;
   uint32_t cap_strip;
   const char* output;
   const char* input;
   int remove_signature;
 } StripOpts;
 
 static int push_name(DriverEnv* env, const char*** arr, uint32_t* n,
                      uint32_t* cap, const char* name) {
   if (*n >= *cap) {
     uint32_t newcap = *cap ? *cap * 2u : 8u;
     const char** nb =
         (const char**)driver_alloc_zeroed(env, (size_t)newcap * sizeof(*nb));
     if (!nb) {
       driver_errf(STRIP_TOOL, "out of memory");
       return -1;
     }
     if (*arr) {
       memcpy(nb, *arr, (size_t)(*n) * sizeof(*nb));
       driver_free(env, (void*)*arr, (size_t)(*cap) * sizeof(*nb));
     }
     *arr = nb;
     *cap = newcap;
   }
   (*arr)[(*n)++] = name;
   return 0;
 }
 
 static int parse_name_arg(int* i, int argc, char** argv, const char* flag,
                           const char* short_flag, const char** out) {
   const char* a = argv[*i];
   size_t flen = kit_slice_cstr(flag).len;
   /* --flag=NAME ; prefix match */
   if (driver_strneq(a, flag, flen) && a[flen] == '=') {
     *out = a + flen + 1;
     return 1;
   }
   /* --flag NAME (no '='): treat as "next argv" form, used when --flag is
    * passed without value. Not standard; skip. */
   if (driver_streq(a, flag)) {
     if (*i + 1 >= argc) return -1;
     *out = argv[++(*i)];
     return 1;
   }
   /* -K NAME / -N NAME */
   if (short_flag && driver_streq(a, short_flag)) {
     if (*i + 1 >= argc) return -1;
     *out = argv[++(*i)];
     return 1;
   }
   return 0;
 }
 
 /* The core strip pass: drop debug sections + prune symbols per the level and
  * keep-list (kit_obj_builder_strip in libkit), then layer the driver-only
  * --strip-symbol explicit drops on top. Running the explicit drops last is
  * what makes --strip-symbol win over --keep-symbol when a name is on both
  * lists. Mutations are issued against the builder; the emit-time sweep cleans
  * up cascades (orphan relocs against removed sections, etc.). */
 static int strip_one_builder(DriverEnv* env, KitObjFile* of, KitObjBuilder* b,
                              const StripOpts* opts, const char* input_name) {
   KitSlice* keep = NULL;
   int level = opts->op == STRIP_OP_DEBUG      ? KIT_STRIP_DEBUG
               : opts->op == STRIP_OP_UNNEEDED ? KIT_STRIP_UNNEEDED
                                               : KIT_STRIP_ALL;
   uint32_t i;
   int rc = 1;
 
   /* Adapt the --keep-symbol C-string list to the KitSlice keep_names shape. */
   if (opts->nkeep) {
     keep =
         (KitSlice*)driver_alloc_zeroed(env, (size_t)opts->nkeep * sizeof(*keep));
     if (!keep) {
       driver_errf(STRIP_TOOL, "%s: out of memory", input_name);
       return 1;
     }
     for (i = 0; i < opts->nkeep; ++i) keep[i] = kit_slice_cstr(opts->keep[i]);
   }
 
   if (kit_obj_builder_strip(b, level, keep, opts->nkeep) != KIT_OK) {
     driver_errf(STRIP_TOOL, "%s: strip failed", input_name);
     goto done;
   }
 
   /* --strip-symbol: always drop the named symbols (overrides keep + policy). */
   if (opts->nstrip) {
     KitObjSymIter* sit = NULL;
     if (kit_obj_symiter_new(of, &sit) != KIT_OK) {
       driver_errf(STRIP_TOOL, "%s: out of memory", input_name);
       goto done;
     }
     for (;;) {
       KitObjSymInfo si;
       KitIterResult ir = kit_obj_symiter_next(sit, &si);
       if (ir != KIT_ITER_ITEM) break;
       if (driver_name_in_list(si.name, opts->strip, opts->nstrip))
         kit_obj_builder_remove_symbol(b, si.id);
     }
     kit_obj_symiter_free(sit);
   }
   rc = 0;
 
 done:
   if (keep) driver_free(env, keep, (size_t)opts->nkeep * sizeof(*keep));
   return rc;
 }
 
 static int strip_object_bytes(DriverEnv* env, const KitContext* ctx,
                               const KitSlice* input, const StripOpts* opts,
                               const char* input_name, uint8_t** out_data,
                               size_t* out_size) {
   KitObjFile* of = NULL;
   KitObjBuilder* b;
   KitWriter* w = NULL;
   KitStatus st;
   size_t n = 0;
   const uint8_t* data;
   uint8_t* copy;
   int rc = 1;
 
   *out_data = NULL;
   *out_size = 0;
 
   if (kit_obj_open(ctx, kit_slice_cstr(input_name), input, &of) != KIT_OK) {
     driver_errf(STRIP_TOOL, "%s: not a recognized object", input_name);
     return 1;
   }
   if (kit_writer_mem(env->heap, &w) != KIT_OK || !w) {
     driver_errf(STRIP_TOOL, "%s: out of memory", input_name);
     kit_obj_free(of);
     return 1;
   }
   if (kit_obj_kind(of) != KIT_OBJ_KIND_REL) {
     KitLinkedRewriteOptions rewrite_opts = {0};
     if (opts->nkeep || opts->nstrip) {
       driver_errf(STRIP_TOOL,
                   "%s: symbol keep/drop filters are unsupported for linked "
                   "images",
                   input_name);
       kit_writer_close(w);
       kit_obj_free(of);
       return 1;
     }
     rewrite_opts.strip_level = opts->op == STRIP_OP_DEBUG
                                    ? KIT_LINKED_STRIP_DEBUG
                                    : KIT_LINKED_STRIP_ALL;
     rewrite_opts.remove_signature = opts->remove_signature != 0;
     st = kit_obj_rewrite_linked(ctx, kit_slice_cstr(input_name), input,
                                 &rewrite_opts, w, NULL);
     if (st != KIT_OK) {
       if (st == KIT_NOMEM)
         driver_errf(STRIP_TOOL, "%s: out of memory", input_name);
       else if (st == KIT_IO)
         driver_errf(STRIP_TOOL, "%s: rewrite output failed", input_name);
       kit_writer_close(w);
       kit_obj_free(of);
       return 1;
     }
   } else {
     b = kit_obj_file_builder(of);
     if (!b) {
       driver_errf(STRIP_TOOL, "%s: no builder for object", input_name);
       kit_writer_close(w);
       kit_obj_free(of);
       return 1;
     }
     if (strip_one_builder(env, of, b, opts, input_name) != 0) {
       kit_writer_close(w);
       kit_obj_free(of);
       return 1;
     }
     if (kit_obj_builder_emit(b, w) != KIT_OK) {
       driver_errf(STRIP_TOOL, "%s: emit failed", input_name);
       kit_writer_close(w);
       kit_obj_free(of);
       return 1;
     }
   }
   data = kit_writer_mem_bytes(w, &n);
   copy = (uint8_t*)driver_alloc(env, n ? n : 1u);
   if (!copy) {
     driver_errf(STRIP_TOOL, "%s: out of memory", input_name);
     kit_writer_close(w);
     kit_obj_free(of);
     return 1;
   }
   if (n) memcpy(copy, data, n);
   kit_writer_close(w);
   kit_obj_free(of);
 
   *out_data = copy;
   *out_size = n;
   rc = 0;
   return rc;
 }
 
 /* Strip every object member of an archive, write a fresh archive with
  * a refreshed System-V symbol index. Non-object members pass through
  * unchanged. */
 static int strip_archive(DriverEnv* env, const KitContext* ctx,
                          const KitSlice* input, const StripOpts* opts,
                          const char* output_path) {
   KitArIter* it = NULL;
   KitArMember m;
   KitArInput* members = NULL;
   uint8_t** owned_data = NULL;
   size_t* owned_size = NULL;
   char* name_storage = NULL;
   size_t name_bytes_total = 0;
   uint32_t nmembers = 0, k;
   KitArMemberSymbols* msyms = NULL;
   void** sym_allocs = NULL;
   KitWriter* out = NULL;
   KitArWriteOptions opts_ar = {0};
   int rc = 1;
 
   /* Pass 1: count members + total name bytes. */
   if (kit_ar_iter_new(ctx, input, &it) != KIT_OK) {
     driver_errf(STRIP_TOOL, "%s: not a recognized archive", opts->input);
     return 1;
   }
   for (;;) {
     KitIterResult r = kit_ar_iter_next(it, &m);
     if (r != KIT_ITER_ITEM) break;
     nmembers++;
     name_bytes_total += m.name.len + 1;
   }
   kit_ar_iter_free(it);
   it = NULL;
 
   if (nmembers) {
     members = (KitArInput*)driver_alloc_zeroed(
         env, (size_t)nmembers * sizeof(*members));
     owned_data = (uint8_t**)driver_alloc_zeroed(
         env, (size_t)nmembers * sizeof(*owned_data));
     owned_size = (size_t*)driver_alloc_zeroed(
         env, (size_t)nmembers * sizeof(*owned_size));
     if (!members || !owned_data || !owned_size) {
       driver_errf(STRIP_TOOL, "out of memory");
       goto done;
     }
   }
   if (name_bytes_total) {
     name_storage = (char*)driver_alloc_zeroed(env, name_bytes_total);
     if (!name_storage) {
       driver_errf(STRIP_TOOL, "out of memory");
       goto done;
     }
   }
 
   /* Pass 2: walk members; strip object members, pass others through. */
   if (kit_ar_iter_new(ctx, input, &it) != KIT_OK) {
     driver_errf(STRIP_TOOL, "iter re-open failed");
     goto done;
   }
   {
     size_t cursor = 0;
     k = 0;
     while (k < nmembers) {
       KitIterResult r = kit_ar_iter_next(it, &m);
       size_t j;
       char* dst;
       KitBinFmt fmt;
       KitSlice mbytes;
       char* member_name = NULL;
       size_t member_name_size = 0;
       if (r != KIT_ITER_ITEM) break;
       dst = name_storage + cursor;
       for (j = 0; j < m.name.len; ++j) *dst++ = m.name.s[j];
       *dst++ = '\0';
       members[k].name.s = name_storage + cursor;
       members[k].name.len = m.name.len;
       cursor = (size_t)(dst - name_storage);
 
       mbytes.data = m.data;
       mbytes.len = m.size;
       fmt = kit_detect_fmt(m.data, m.size);
       if (fmt == KIT_BIN_ELF || fmt == KIT_BIN_COFF || fmt == KIT_BIN_MACHO ||
           fmt == KIT_BIN_WASM) {
         uint8_t* sd = NULL;
         size_t ss = 0;
         size_t archive_len = strlen(opts->input);
         member_name_size = archive_len + m.name.len + 3u;
         member_name = (char*)driver_alloc(env, member_name_size);
         if (!member_name) {
           driver_errf(STRIP_TOOL, "%s(%.*s): out of memory", opts->input,
                       (int)m.name.len, m.name.s);
           kit_ar_iter_free(it);
           it = NULL;
           goto done;
         }
         memcpy(member_name, opts->input, archive_len);
         member_name[archive_len] = '(';
         memcpy(member_name + archive_len + 1u, m.name.s, m.name.len);
         member_name[archive_len + 1u + m.name.len] = ')';
         member_name[member_name_size - 1u] = '\0';
         if (strip_object_bytes(env, ctx, &mbytes, opts, member_name, &sd, &ss) !=
             0) {
           driver_free(env, member_name, member_name_size);
           kit_ar_iter_free(it);
           it = NULL;
           goto done;
         }
         driver_free(env, member_name, member_name_size);
         owned_data[k] = sd;
         owned_size[k] = ss;
         members[k].bytes.data = sd;
         members[k].bytes.len = ss;
       } else {
         members[k].bytes.data = m.data;
         members[k].bytes.len = m.size;
       }
       k++;
     }
   }
   kit_ar_iter_free(it);
   it = NULL;
 
   /* Pass 3: rebuild the System-V symbol index from the new bytes. */
   if (nmembers) {
     msyms = (KitArMemberSymbols*)driver_alloc_zeroed(
         env, (size_t)nmembers * sizeof(*msyms));
     sym_allocs = (void**)driver_alloc_zeroed(
         env, (size_t)nmembers * sizeof(*sym_allocs));
     if (!msyms || !sym_allocs) {
       driver_errf(STRIP_TOOL, "out of memory");
       goto done;
     }
     for (k = 0; k < nmembers; ++k) {
       if (kit_obj_global_syms(ctx, &members[k].bytes, &msyms[k],
                               &sym_allocs[k]) != KIT_OK) {
         driver_errf(STRIP_TOOL, "out of memory");
         goto done;
       }
     }
   }
 
   if (ctx->file_io->open_writer(ctx->file_io->user, output_path, &out) !=
       KIT_OK) {
     driver_errf(STRIP_TOOL, "failed to open: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(output_path)));
     goto done;
   }
   opts_ar.epoch = driver_epoch_from_env();
   opts_ar.long_names = 1;
   opts_ar.symbol_index = 1;
   opts_ar.member_symbols = msyms;
   rc = kit_ar_write(out, members, nmembers, &opts_ar) == KIT_OK ? 0 : 1;
   if (rc == 0 && kit_writer_status(out) != KIT_OK) rc = 1;
 
 done:
   if (out) {
     if (rc != 0) driver_writer_abort(out);
     kit_writer_close(out);
   }
   if (it) kit_ar_iter_free(it);
   if (sym_allocs) {
     for (k = 0; k < nmembers; ++k) {
       if (sym_allocs[k]) kit_obj_global_syms_free(ctx, sym_allocs[k]);
     }
     driver_free(env, sym_allocs, (size_t)nmembers * sizeof(*sym_allocs));
   }
   if (msyms) driver_free(env, msyms, (size_t)nmembers * sizeof(*msyms));
   if (owned_data) {
     for (k = 0; k < nmembers; ++k) {
       if (owned_data[k]) driver_free(env, owned_data[k], owned_size[k]);
     }
     driver_free(env, owned_data, (size_t)nmembers * sizeof(*owned_data));
   }
   if (owned_size)
     driver_free(env, owned_size, (size_t)nmembers * sizeof(*owned_size));
   if (members) driver_free(env, members, (size_t)nmembers * sizeof(*members));
   if (name_storage) driver_free(env, name_storage, name_bytes_total);
   return rc;
 }
 
 int driver_strip(int argc, char** argv) {
   DriverEnv env;
   KitContext ctx;
   StripOpts opts;
   KitFileData input_fd = {0};
   KitSlice input;
   KitWriter* w = NULL;
   uint8_t* out_data = NULL;
   size_t out_size = 0;
   int have_input = 0;
   int have_input_mode = 0;
   int options_done = 0;
   int rc = 1;
   int i;
   uint32_t input_mode = 0;
   const char* final_output = NULL;
 
   if (argc < 2) {
     driver_help_strip();
     return 0;
   }
 
   memset(&opts, 0, sizeof opts);
   opts.op = STRIP_OP_ALL;
   driver_env_init(&env);
   ctx = driver_env_to_context(&env);
 
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     const char* val = NULL;
     int matched;
     if (!options_done && driver_streq(a, "--")) {
       options_done = 1;
       continue;
     }
     if (!options_done &&
         (driver_streq(a, "-h") || driver_streq(a, "--help"))) {
       driver_help_strip();
       rc = 0;
       goto done;
     }
     if (!options_done && driver_streq(a, "--strip-debug")) {
       opts.op = STRIP_OP_DEBUG;
       continue;
     }
     if (!options_done && driver_streq(a, "--strip-unneeded")) {
       opts.op = STRIP_OP_UNNEEDED;
       continue;
     }
     if (!options_done &&
         (driver_streq(a, "--strip-all") || driver_streq(a, "-s"))) {
       opts.op = STRIP_OP_ALL;
       continue;
     }
     if (!options_done && driver_streq(a, "--remove-signature")) {
       opts.remove_signature = 1;
       continue;
     }
     if (!options_done && driver_streq(a, "-o")) {
       if (i + 1 >= argc) {
         driver_errf(STRIP_TOOL, "-o requires a path");
         rc = 2;
         goto done;
       }
       opts.output = argv[++i];
       continue;
     }
     matched = options_done
                   ? 0
                   : parse_name_arg(&i, argc, argv, "--keep-symbol", "-K",
                                    &val);
     if (matched < 0) {
       driver_errf(STRIP_TOOL, "%.*s requires a symbol name",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       rc = 2;
       goto done;
     }
     if (matched) {
       if (push_name(&env, &opts.keep, &opts.nkeep, &opts.cap_keep, val) != 0) {
         rc = 1;
         goto done;
       }
       continue;
     }
     matched = options_done
                   ? 0
                   : parse_name_arg(&i, argc, argv, "--strip-symbol", "-N",
                                    &val);
     if (matched < 0) {
       driver_errf(STRIP_TOOL, "%.*s requires a symbol name",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       rc = 2;
       goto done;
     }
     if (matched) {
       if (push_name(&env, &opts.strip, &opts.nstrip, &opts.cap_strip, val) !=
           0) {
         rc = 1;
         goto done;
       }
       continue;
     }
     if (!options_done && a[0] == '-' && a[1] != '\0') {
       driver_errf(STRIP_TOOL, "unknown option: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       rc = 2;
       goto done;
     }
     if (opts.input) {
       driver_errf(STRIP_TOOL, "only one input file is supported");
       rc = 2;
       goto done;
     }
     opts.input = a;
   }
 
   if (!opts.input) {
     driver_errf(STRIP_TOOL, "missing input file");
     rc = 2;
     goto done;
   }
 
   if (ctx.file_io->read_all(ctx.file_io->user, opts.input, &input_fd) !=
       KIT_OK) {
     driver_errf(STRIP_TOOL, "failed to read: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(opts.input)));
     goto done;
   }
   have_input = 1;
   if (driver_path_mode_get(opts.input, &input_mode) != 0) {
     driver_errf(STRIP_TOOL, "failed to read input mode: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(opts.input)));
     goto done;
   }
   have_input_mode = 1;
   input.data = input_fd.data;
   input.len = input_fd.size;
 
   {
     KitBinFmt fmt = kit_detect_fmt(input.data, input.len);
     const char* out_path = opts.output ? opts.output : opts.input;
     final_output = out_path;
     if (fmt == KIT_BIN_AR) {
       rc = strip_archive(&env, &ctx, &input, &opts, out_path);
       goto done;
     }
     if (strip_object_bytes(&env, &ctx, &input, &opts, opts.input, &out_data,
                            &out_size) != 0) {
       goto done;
     }
     if (ctx.file_io->open_writer(ctx.file_io->user, out_path, &w) != KIT_OK) {
       driver_errf(STRIP_TOOL, "failed to open: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(out_path)));
       goto done;
     }
     kit_writer_write(w, out_data, out_size);
     if (kit_writer_status(w) != KIT_OK) {
       driver_errf(STRIP_TOOL, "write failed: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(out_path)));
       goto done;
     }
     rc = 0;
   }
 
 done:
   if (w) {
     if (rc != 0) driver_writer_abort(w);
     kit_writer_close(w);
     w = NULL;
   }
   if (rc == 0 && final_output && have_input_mode &&
       driver_path_mode_set(final_output, input_mode) != 0) {
     driver_errf(STRIP_TOOL, "failed to preserve mode: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(final_output)));
     rc = 1;
   }
   if (out_data) driver_free(&env, out_data, out_size);
   if (have_input) ctx.file_io->release(ctx.file_io->user, &input_fd);
   if (opts.keep)
     driver_free(&env, (void*)opts.keep,
                 (size_t)opts.cap_keep * sizeof(*opts.keep));
   if (opts.strip)
     driver_free(&env, (void*)opts.strip,
                 (size_t)opts.cap_strip * sizeof(*opts.strip));
   driver_env_fini(&env);
   return rc;
 }