kit

hash.c (6939B)

---

 #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;
 } 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;
 }
 
 void driver_help_hash(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit hash — hash files with SHA-256, BLAKE2b, 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"
           "\n"
           "OPTIONS\n"
           "  -a ALGO    sha256 (default) | blake2b | crc32\n"
           "  -h, --help show this help\n"
           "\n"
           "ALIASES\n"
           "  Invoked as sha256sum, b2sum, or crc32 the algorithm is fixed to\n"
           "  SHA-256, BLAKE2b-256, or CRC-32 respectively and -a is rejected.\n"
           "  (GNU b2sum defaults to BLAKE2b-512; this BLAKE2b is 256-bit.)\n"
           "\n"
           "EXIT CODES\n"
           "  0   success           1   I/O error           2   bad usage\n")));
 }
 
 /* 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) {
   KitHasher* h = NULL;
   uint8_t digest[KIT_HASH_MAX_LEN];
   char hex[KIT_HASH_MAX_LEN * 2 + 1];
   size_t dlen = 0, i;
 
   if (kit_hasher_new(ctx, opts->algo, &h) != KIT_OK) {
     driver_errf(tool, "failed to start hasher");
     return 1;
   }
   kit_hasher_update(h, data, len);
   kit_hasher_final(h, digest, &dlen);
   kit_hasher_free(h);
 
   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;
 }
 
 static int hash_main(int argc, char** argv, const HashPersona* persona) {
   DriverEnv env;
   KitContext ctx;
   HashOpts opts;
   int i, rc = 1, any_input = 0;
 
   if (driver_argv_wants_help(argc, argv, 1)) {
     driver_help_hash();
     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 (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 (driver_streq(a, "-")) {
       any_input = 1;
       continue;
     }
     if (a[0] == '-' && a[1] != '\0') {
       driver_errf(persona->name, "unknown option: %s", a);
       rc = 2;
       goto done;
     }
     any_input = 1;
   }
 
   /* 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;
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     if (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);
 }