kit

hash.c (18560B)

---

 #include <kit/core.h>
 #include <kit/hash.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "driver.h"
 #include "env.h"
 
 /* `kit hash` — print the SHA-256, BLAKE2b-256, or CRC-32 digest of each
  * input. Output is coreutils-style ("<hex>  <name>"), so it diffs cleanly
  * against sha256sum / b2sum / cksum -a output. With no FILE, or with `-`,
  * reads stdin. Drives the streaming kit_hasher_* API (the one-shot
  * kit_hash stays for library callers).
  *
  * The same core also backs the standard-named aliases, each of which pins the
  * algorithm so the tool is a drop-in for the matching command:
  *   sha256sum -> SHA-256      b2sum -> BLAKE2b-256      crc32 -> CRC-32
  * (Note: GNU b2sum defaults to BLAKE2b-512; kit's BLAKE2b is 256-bit, so the
  * digests differ in width.) The aliases reject -a, since their algorithm is
  * fixed; the generic `hash` tool keeps -a for selecting any of the three. */
 
 static const char HASH_HEX[] = "0123456789abcdef";
 
 /* Invocation personality: which algorithm, and whether the name pins it. */
 typedef struct HashPersona {
   const char* name; /* tool name for diagnostics: hash/sha256sum/... */
   KitHashAlgo algo; /* default (and, when locked, the only) algorithm */
   int locked;       /* alias pins the algorithm: -a is rejected */
 } HashPersona;
 
 static const HashPersona HASH_GENERIC = {"hash", KIT_HASH_SHA256, 0};
 static const HashPersona HASH_SHA256SUM = {"sha256sum", KIT_HASH_SHA256, 1};
 static const HashPersona HASH_B2SUM = {"b2sum", KIT_HASH_BLAKE2B, 1};
 static const HashPersona HASH_CRC32 = {"crc32", KIT_HASH_CRC32, 1};
 
 typedef struct HashOpts {
   KitHashAlgo algo;
   int check;
   int quiet;
   int status_only;
 } HashOpts;
 
 static const char* hash_algo_name(KitHashAlgo algo) {
   switch (algo) {
     case KIT_HASH_SHA256:
       return "sha256";
     case KIT_HASH_BLAKE2B:
       return "blake2b";
     case KIT_HASH_CRC32:
       return "crc32";
   }
   return "?";
 }
 
 static int hash_parse_algo(const char* s, KitHashAlgo* out) {
   if (driver_streq(s, "sha256")) {
     *out = KIT_HASH_SHA256;
     return 0;
   }
   if (driver_streq(s, "blake2b")) {
     *out = KIT_HASH_BLAKE2B;
     return 0;
   }
   if (driver_streq(s, "crc32")) {
     *out = KIT_HASH_CRC32;
     return 0;
   }
   return 1;
 }
 
 static void hash_help(const HashPersona* persona) {
   if (!persona->locked) {
     driver_printf(
         "%.*s",
         KIT_SLICE_ARG(KIT_SLICE_LIT(
             "kit hash — hash files with SHA-256, BLAKE2b-256, or CRC-32\n"
             "\n"
             "USAGE\n"
             "  kit hash [-a ALGO] [FILE...]\n"
             "\n"
             "DESCRIPTION\n"
             "  Prints one line per input: the lowercase-hex digest, two spaces,\n"
             "  then the file name (`-` for stdin). With no FILE, reads stdin.\n"
             "  Multiple files are processed in command-line order.\n"
             "\n"
             "OPTIONS\n"
             "  -a ALGO     sha256 (default) | blake2b | crc32\n"
             "  -h, --help  show this help and exit\n"
             "\n"
             "ALIASES\n"
             "  sha256sum, b2sum, and crc32 fix the algorithm and reject -a.\n"
             "  sha256sum and b2sum also verify manifests with -c/--check.\n"
             "\n"
             "PATHS\n"
             "  Use -- before a leading-dash file name.\n"
             "\n"
             "EXAMPLES\n"
             "  kit hash README.txt\n"
             "  kit hash -a blake2b archive.a\n"
             "  kit hash -a crc32 one.bin two.bin\n"
             "  printf 'hello\\n' | kit hash -a sha256\n"
             "\n"
             "EXIT CODES\n"
             "  0   success           1   I/O error           2   bad usage\n")));
     return;
   }
 
   if (persona->algo == KIT_HASH_SHA256) {
     driver_printf(
         "sha256sum — SHA-256 of files or standard input\n"
         "\n"
         "USAGE\n"
         "  sha256sum [FILE...]\n"
         "  sha256sum -c [--quiet|--status] [MANIFEST...]\n"
         "\n"
         "DESCRIPTION\n"
         "  Prints lowercase SHA-256, two spaces, then the file name. With no\n"
         "  FILE, or with -, reads stdin. The algorithm is fixed; -a is rejected.\n"
         "  -c verifies standard SHA-256 manifest lines.\n"
         "\n"
         "OPTIONS\n"
         "  -c, --check verify manifests\n"
         "  --quiet     omit OK rows while checking\n"
         "  --status    print no check rows; status only\n"
         "  -h, --help  show this help and exit\n"
         "\n"
         "PATHS\n"
         "  Use -- before a leading-dash file name.\n"
         "\n"
         "EXAMPLES\n"
         "  sha256sum release.kpkg\n"
         "  printf 'hello\\n' | sha256sum\n"
         "\n"
         "EXIT CODES\n"
         "  0   success           1   I/O error           2   bad usage\n");
   } else if (persona->algo == KIT_HASH_BLAKE2B) {
     driver_printf(
         "b2sum — BLAKE2b-256 of files or standard input\n"
         "\n"
         "USAGE\n"
         "  b2sum [FILE...]\n"
         "  b2sum -c [--quiet|--status] [MANIFEST...]\n"
         "\n"
         "DESCRIPTION\n"
         "  Prints lowercase BLAKE2b-256, two spaces, then the file name. GNU\n"
         "  b2sum defaults to BLAKE2b-512, so its default digest is twice as\n"
         "  wide. The algorithm is fixed; -a is rejected. Kit verifies only\n"
         "  256-bit BLAKE2b manifests. With no FILE, reads stdin.\n"
         "\n"
         "OPTIONS\n"
         "  -c, --check verify BLAKE2b-256 manifests\n"
         "  --quiet     omit OK rows while checking\n"
         "  --status    print no check rows; status only\n"
         "  -h, --help  show this help and exit\n"
         "\n"
         "PATHS\n"
         "  Use -- before a leading-dash file name.\n"
         "\n"
         "EXAMPLES\n"
         "  b2sum tree.manifest\n"
         "  printf 'hello\\n' | b2sum\n"
         "\n"
         "EXIT CODES\n"
         "  0   success           1   I/O error           2   bad usage\n");
   } else {
     driver_printf(
         "crc32 — CRC-32 of files or standard input\n"
         "\n"
         "USAGE\n"
         "  crc32 [FILE...]\n"
         "\n"
         "DESCRIPTION\n"
         "  Prints an eight-digit lowercase CRC-32, two spaces, then the file\n"
         "  name. With no FILE, or with -, reads stdin. The algorithm is fixed;\n"
         "  -a is rejected.\n"
         "\n"
         "OPTIONS\n"
         "  -h, --help  show this help and exit\n"
         "\n"
         "PATHS\n"
         "  Use -- before a leading-dash file name.\n"
         "\n"
         "EXAMPLES\n"
         "  crc32 image.bin\n"
         "  printf 'hello\\n' | crc32\n"
         "\n"
         "EXIT CODES\n"
         "  0   success           1   I/O error           2   bad usage\n");
   }
 }
 
 void driver_help_hash(void) { hash_help(&HASH_GENERIC); }
 void driver_help_sha256sum(void) { hash_help(&HASH_SHA256SUM); }
 void driver_help_b2sum(void) { hash_help(&HASH_B2SUM); }
 void driver_help_crc32(void) { hash_help(&HASH_CRC32); }
 
 static int hash_bytes(const KitContext* ctx, KitHashAlgo algo,
                       const uint8_t* data, size_t len, uint8_t* digest,
                       size_t* dlen) {
   KitHasher* h = NULL;
   if (kit_hasher_new(ctx, algo, &h) != KIT_OK) return 1;
   kit_hasher_update(h, data, len);
   kit_hasher_final(h, digest, dlen);
   kit_hasher_free(h);
   return 0;
 }
 
 /* Hash data[0..len) with opts->algo and print "<hex>  <name>". Returns 0 on
  * success, 1 on failure (error already reported under `tool`). */
 static int hash_one(const KitContext* ctx, const HashOpts* opts,
                     const char* tool, const uint8_t* data, size_t len,
                     const char* name) {
   uint8_t digest[KIT_HASH_MAX_LEN];
   char hex[KIT_HASH_MAX_LEN * 2 + 1];
   size_t dlen = 0, i;
 
   if (hash_bytes(ctx, opts->algo, data, len, digest, &dlen) != 0) {
     driver_errf(tool, "failed to start hasher");
     return 1;
   }
 
   for (i = 0; i < dlen; ++i) {
     hex[i * 2] = HASH_HEX[digest[i] >> 4];
     hex[i * 2 + 1] = HASH_HEX[digest[i] & 0x0f];
   }
   hex[dlen * 2] = '\0';
   driver_printf("%s  %s\n", hex, name);
   return 0;
 }
 
 typedef struct HashCheckState {
   DriverEnv* env;
   KitContext* ctx;
   const HashOpts* opts;
   const HashPersona* persona;
   uint8_t* stdin_data;
   size_t stdin_len;
   int stdin_loaded;
 } HashCheckState;
 
 /* Decode one coreutils manifest line. Returns 0 on success, 1 for malformed
  * syntax, 2 for a GNU BLAKE2b-512 row, and 3 for allocation failure. */
 static int hash_manifest_line(DriverEnv* env, const HashPersona* persona,
                               const uint8_t* line, size_t len,
                               uint8_t expected[32], char** out_name,
                               size_t* out_name_size) {
   size_t off = 0, hex_len = 0, i, w = 0;
   int escaped = 0;
   char* name;
 
   if (len && line[len - 1] == '\r') --len;
   if (len && line[0] == '\\') {
     escaped = 1;
     off = 1;
   }
   while (off + hex_len < len && driver_hex_nibble((char)line[off + hex_len]) >= 0)
     ++hex_len;
   if (persona->algo == KIT_HASH_BLAKE2B && hex_len == 128)
     return 2;
   if (hex_len != 64 || off + 66 > len || line[off + 64] != ' ' ||
       (line[off + 65] != ' ' && line[off + 65] != '*') || off + 66 == len)
     return 1;
   for (i = 0; i < 32; ++i) {
     int hi = driver_hex_nibble((char)line[off + i * 2]);
     int lo = driver_hex_nibble((char)line[off + i * 2 + 1]);
     if (hi < 0 || lo < 0) return 1;
     expected[i] = (uint8_t)((hi << 4) | lo);
   }
 
   name = driver_alloc(env, len - (off + 66) + 1);
   if (!name) return 3;
   for (i = off + 66; i < len; ++i) {
     uint8_t c = line[i];
     if (c == '\0') {
       driver_free(env, name, len - (off + 66) + 1);
       return 1;
     }
     if (escaped && c == '\\') {
       if (++i >= len) {
         driver_free(env, name, len - (off + 66) + 1);
         return 1;
       }
       if (line[i] == '\\')
         c = '\\';
       else if (line[i] == 'n')
         c = '\n';
       else if (line[i] == 'r')
         c = '\r';
       else {
         driver_free(env, name, len - (off + 66) + 1);
         return 1;
       }
     }
     name[w++] = (char)c;
   }
   name[w] = '\0';
   *out_name = name;
   *out_name_size = len - (off + 66) + 1;
   return 0;
 }
 
 static int hash_check_payload(HashCheckState* st, const char* name,
                               const uint8_t expected[32]) {
   DriverLoad ld = {0};
   KitSlice input = KIT_SLICE_NULL;
   uint8_t digest[KIT_HASH_MAX_LEN];
   size_t dlen = 0;
   int loaded = 0, ok = 0;
 
   if (driver_streq(name, "-")) {
     if (!st->stdin_loaded) {
       if (!driver_read_stdin(st->env, &st->stdin_data, &st->stdin_len)) {
         driver_errf(st->persona->name, "failed to read stdin payload");
         goto done;
       }
       st->stdin_loaded = 1;
     }
     input.data = st->stdin_data;
     input.len = st->stdin_len;
   } else {
     if (driver_load_bytes(&st->env->file_io, st->persona->name, name, &ld,
                           &input) != 0)
       goto done;
     loaded = 1;
   }
   if (hash_bytes(st->ctx, st->opts->algo, input.data, input.len, digest,
                  &dlen) != 0) {
     driver_errf(st->persona->name, "%s: failed to compute checksum", name);
     goto done;
   }
   ok = dlen == 32 && memcmp(digest, expected, 32) == 0;
 
 done:
   if (!st->opts->status_only && (!ok || !st->opts->quiet))
     driver_printf("%s: %s\n", name, ok ? "OK" : "FAILED");
   if (loaded) driver_release_bytes(&st->env->file_io, &ld);
   return ok ? 0 : 1;
 }
 
 static int hash_check_manifest(HashCheckState* st, const char* manifest) {
   DriverLoad ld = {0};
   KitSlice text = KIT_SLICE_NULL;
   uint8_t* stdin_manifest = NULL;
   size_t stdin_manifest_len = 0;
   size_t off = 0, line_no = 0, valid = 0;
   int loaded = 0, rc = 0;
   int manifest_is_stdin = driver_streq(manifest, "-");
 
   if (manifest_is_stdin) {
     if (!driver_read_stdin(st->env, &stdin_manifest, &stdin_manifest_len)) {
       driver_errf(st->persona->name, "failed to read checksum manifest stdin");
       return 1;
     }
     text.data = stdin_manifest;
     text.len = stdin_manifest_len;
   } else {
     if (driver_load_bytes(&st->env->file_io, st->persona->name, manifest, &ld,
                           &text) != 0)
       return 1;
     loaded = 1;
   }
 
   while (off < text.len) {
     size_t end = off;
     uint8_t expected[32];
     char* name = NULL;
     size_t name_size = 0;
     int prc;
     while (end < text.len && text.data[end] != '\n') ++end;
     ++line_no;
     if (end == off || (end == off + 1 && text.data[off] == '\r')) {
       off = end < text.len ? end + 1 : end;
       continue;
     }
     prc = hash_manifest_line(st->env, st->persona, text.data + off, end - off,
                              expected, &name, &name_size);
     if (prc != 0) {
       if (prc == 2)
         driver_errf(st->persona->name,
                     "%s:%llu: BLAKE2b-512 manifest is incompatible with "
                     "Kit's BLAKE2b-256 contract",
                     manifest, (unsigned long long)line_no);
       else if (prc == 3)
         driver_errf(st->persona->name, "out of memory");
       else
         driver_errf(st->persona->name, "%s:%llu: malformed checksum line",
                     manifest, (unsigned long long)line_no);
       rc = 1;
       off = end < text.len ? end + 1 : end;
       continue;
     }
     ++valid;
     if (manifest_is_stdin && driver_streq(name, "-")) {
       driver_errf(st->persona->name,
                   "manifest and payload cannot both read standard input");
       if (!st->opts->status_only)
         driver_printf("%s: FAILED\n", name);
       rc = 1;
     } else if (hash_check_payload(st, name, expected) != 0) {
       rc = 1;
     }
     driver_free(st->env, name, name_size);
     off = end < text.len ? end + 1 : end;
   }
   if (!valid) {
     driver_errf(st->persona->name, "%s: no properly formatted checksum lines",
                 manifest);
     rc = 1;
   }
   if (loaded) driver_release_bytes(&st->env->file_io, &ld);
   if (stdin_manifest)
     driver_free(st->env, stdin_manifest, stdin_manifest_len);
   return rc;
 }
 
 static int hash_main(int argc, char** argv, const HashPersona* persona) {
   DriverEnv env;
   KitContext ctx;
   HashOpts opts;
   HashCheckState check;
   int i, rc = 1, any_input = 0, options = 1;
 
   if (driver_argv_wants_help(argc, argv, 1)) {
     hash_help(persona);
     return 0;
   }
 
   memset(&opts, 0, sizeof opts);
   opts.algo = persona->algo;
   driver_env_init(&env);
   ctx = driver_env_to_context(&env);
 
   /* First pass: options. */
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     if (options && driver_streq(a, "--")) {
       options = 0;
       continue;
     }
     if (options && driver_streq(a, "-a")) {
       if (persona->locked) {
         driver_errf(persona->name, "-a is not accepted; %s always uses %s",
                     persona->name, hash_algo_name(persona->algo));
         rc = 2;
         goto done;
       }
       if (i + 1 >= argc || hash_parse_algo(argv[++i], &opts.algo) != 0) {
         driver_errf(persona->name, "-a requires sha256, blake2b, or crc32");
         rc = 2;
         goto done;
       }
       continue;
     }
     if (options && (driver_streq(a, "-c") || driver_streq(a, "--check"))) {
       if (!persona->locked || persona->algo == KIT_HASH_CRC32) {
         driver_errf(persona->name,
                     "checksum manifests are supported by sha256sum and b2sum");
         rc = 2;
         goto done;
       }
       opts.check = 1;
       continue;
     }
     if (options && driver_streq(a, "--quiet")) {
       opts.quiet = 1;
       continue;
     }
     if (options && driver_streq(a, "--status")) {
       opts.status_only = 1;
       continue;
     }
     if (driver_streq(a, "-")) {
       any_input = 1;
       continue;
     }
     if (options && a[0] == '-' && a[1] != '\0') {
       driver_errf(persona->name, "unknown option: %s", a);
       rc = 2;
       goto done;
     }
     any_input = 1;
   }
 
   if ((opts.quiet || opts.status_only) && !opts.check) {
     driver_errf(persona->name, "--quiet and --status require --check");
     rc = 2;
     goto done;
   }
 
   if (opts.check) {
     memset(&check, 0, sizeof check);
     check.env = &env;
     check.ctx = &ctx;
     check.opts = &opts;
     check.persona = persona;
     rc = 0;
     if (!any_input) {
       rc = hash_check_manifest(&check, "-");
     } else {
       options = 1;
       for (i = 1; i < argc; ++i) {
         const char* a = argv[i];
         if (options && driver_streq(a, "--")) {
           options = 0;
           continue;
         }
         if (options && (driver_streq(a, "-c") ||
                         driver_streq(a, "--check") ||
                         driver_streq(a, "--quiet") ||
                         driver_streq(a, "--status")))
           continue;
         if (hash_check_manifest(&check, a) != 0) rc = 1;
       }
     }
     if (check.stdin_data)
       driver_free(&env, check.stdin_data, check.stdin_len);
     goto done;
   }
 
   /* No file operands: hash stdin. */
   if (!any_input) {
     uint8_t* buf = NULL;
     size_t n = 0;
     if (!driver_read_stdin(&env, &buf, &n)) {
       driver_errf(persona->name, "failed to read stdin");
       rc = 1;
       goto done;
     }
     rc = hash_one(&ctx, &opts, persona->name, buf, n, "-");
     driver_free(&env, buf, n);
     goto done;
   }
 
   /* Second pass: inputs, in argv order. */
   rc = 0;
   options = 1;
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     if (options && driver_streq(a, "--")) {
       options = 0;
       continue;
     }
     if (options && driver_streq(a, "-a")) {
       ++i; /* skip its value (only reachable for the generic, unlocked tool) */
       continue;
     }
     if (driver_streq(a, "-")) {
       uint8_t* buf = NULL;
       size_t n = 0;
       if (!driver_read_stdin(&env, &buf, &n)) {
         driver_errf(persona->name, "failed to read stdin");
         rc = 1;
         continue;
       }
       if (hash_one(&ctx, &opts, persona->name, buf, n, "-") != 0) rc = 1;
       driver_free(&env, buf, n);
       continue;
     }
     {
       DriverLoad ld = {0};
       KitSlice input;
       if (driver_load_bytes(&env.file_io, persona->name, a, &ld, &input) != 0) {
         rc = 1;
         continue;
       }
       if (hash_one(&ctx, &opts, persona->name, input.data, input.len, a) != 0)
         rc = 1;
       driver_release_bytes(&env.file_io, &ld);
     }
   }
 
 done:
   driver_env_fini(&env);
   return rc;
 }
 
 int driver_hash(int argc, char** argv) {
   return hash_main(argc, argv, &HASH_GENERIC);
 }
 
 int driver_sha256sum(int argc, char** argv) {
   return hash_main(argc, argv, &HASH_SHA256SUM);
 }
 
 int driver_b2sum(int argc, char** argv) {
   return hash_main(argc, argv, &HASH_B2SUM);
 }
 
 int driver_crc32(int argc, char** argv) {
   return hash_main(argc, argv, &HASH_CRC32);
 }