From e375fe33195bd8369c6b9ff8cacacfe439af1ffb Mon Sep 17 00:00:00 2001 From: mdw Date: Sat, 15 Jul 2000 20:52:34 +0000 Subject: [PATCH] Useful replacement for `md5sum' with support for many different hash functions and for reading filename lists from `find'. --- hashsum.c | 700 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 700 insertions(+) create mode 100644 hashsum.c diff --git a/hashsum.c b/hashsum.c new file mode 100644 index 0000000..73ad9dc --- /dev/null +++ b/hashsum.c @@ -0,0 +1,700 @@ +/* -*-c-*- + * + * $Id: hashsum.c,v 1.1 2000/07/15 20:52:34 mdw Exp $ + * + * Hash files using some secure hash function + * + * (c) 2000 Straylight/Edgeware + */ + +/*----- Licensing notice --------------------------------------------------* + * + * This file is part of Catacomb. + * + * Catacomb is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * Catacomb is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with Catacomb; if not, write to the Free + * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, + * MA 02111-1307, USA. + */ + +/*----- Revision history --------------------------------------------------* + * + * $Log: hashsum.c,v $ + * Revision 1.1 2000/07/15 20:52:34 mdw + * Useful replacement for `md5sum' with support for many different hash + * functions and for reading filename lists from `find'. + * + */ + +/*----- Header files ------------------------------------------------------*/ + +#include "config.h" + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "ghash.h" + +#include "md4.h" +#include "md5.h" +#include "rmd128.h" +#include "rmd160.h" +#include "rmd256.h" +#include "rmd320.h" +#include "sha.h" +#include "tiger.h" + +/*----- Static variables --------------------------------------------------*/ + +static const gchash *hashtab[] = { + &md5, &md4, &sha, &rmd128, &rmd160, &rmd256, &rmd320, &tiger, + 0 +}; + +enum { + f_binary = 1, + f_bogus = 2, + f_verbose = 4, + f_check = 8, + f_files = 16, + f_raw = 32, + f_oddhash = 64, + f_escape = 128 +}; + +/*----- Support functions -------------------------------------------------*/ + +/* --- @fhash@ --- * + * + * Arguments: @const char *file@ = file name to be hashed (null for stdin) + * @unsigned f@ = flags to set + * @const gchash *gch@ = pointer to hash function to use + * @void *buf@ = pointer to hash output buffer + * + * Returns: Zero if it worked, nonzero on error. + * + * Use: Hashes a file. + */ + +static int fhash(const char *file, unsigned f, const gchash *gch, void *buf) +{ + FILE *fp; + char fbuf[BUFSIZ]; + size_t sz; + ghash *h; + int e; + + if (!file) + fp = stdin; + else if ((fp = fopen(file, f & f_binary ? "rb" : "r")) == 0) + return (-1); + + h = gch->init(); + while ((sz = fread(fbuf, 1, sizeof(fbuf), fp)) > 0) + h->ops->hash(h, fbuf, sz); + h->ops->done(h, buf); + h->ops->destroy(h); + e = ferror(fp); + if (file) + fclose(fp); + return (e ? -1 : 0); +} + +/* --- @puthex@ --- * + * + * Arguments: @const octet *buf@ = pointer to a binary buffer + * @size_t sz@ = size of the buffer + * @FILE *fp@ = pointer to output file handle + * + * Returns: --- + * + * Use: Writes a hex dump of a block of memory. + */ + +static void puthex(const octet *buf, size_t sz, FILE *fp) +{ + while (sz) { + fprintf(fp, "%02x", *buf++); + sz--; + } +} + +/* --- @gethex@ --- * + * + * Arguments: @const char *p@ = pointer to input string + * @octet *q@ = pointer to output buffer + * @size_t sz@ = size of the output buffer + * @char **pp@ = where to put the end pointer + * + * Returns: The number of bytes written to the buffer. + * + * Use: Reads hex dumps from the input string. + */ + +static size_t gethex(const char *p, octet *q, size_t sz, char **pp) +{ + size_t i = 0; + while (sz > 0 && + isxdigit((unsigned char)p[0]) && + isxdigit((unsigned char)p[1])) { + char buf[3]; + buf[0] = p[0]; + buf[1] = p[1]; + buf[2] = 0; + *q++ = strtoul(buf, 0, 16); + sz--; + p += 2; + i++; + } + if (pp) + *pp = (char *)p; + return (i); +} + +/* --- @gethash@ --- * + * + * Arguments: @const char *name@ = pointer to name string + * + * Returns: Pointer to appropriate hash class. + * + * Use: Chooses a hash function by name. + */ + +static const gchash *gethash(const char *name) +{ + const gchash **g, *gg = 0; + size_t sz = strlen(name); + for (g = hashtab; *g; g++) { + if (strncmp(name, (*g)->name, sz) == 0) { + if ((*g)->name[sz] == 0) { + gg = *g; + break; + } else if (gg) + return (0); + else + gg = *g; + } + } + return (gg); +} + +/* --- @getstring@ --- * + * + * Arguments: @FILE *fp@ = stream from which to read + * @const char *p@ = string to read from instead + * @dstr *d@ = destination string + * @unsigned raw@ = raw or cooked read + * + * Returns: Zero if OK, nonzero on end-of-file. + * + * Use: Reads a filename (or something similar) from a stream. + */ + +static int getstring(FILE *fp, const char *p, dstr *d, unsigned raw) +{ + int ch; + int q = 0; + + /* --- Raw: just read exactly what's written up to a null byte --- */ + +#define NEXTCH (fp ? getc(fp) : *p++) +#define EOFCH (fp ? EOF : 0) + + if (raw) { + if ((ch = NEXTCH) == EOFCH) + return (EOF); + for (;;) { + if (!ch) + break; + DPUTC(d, ch); + if ((ch = NEXTCH) == EOFCH) + break; + } + DPUTZ(d); + return (0); + } + + /* --- Skip as far as whitespace --- * + * + * Also skip past comments. + */ + +again: + ch = NEXTCH; + while (isspace((unsigned char)ch)) + ch = NEXTCH; + if (ch == '#') { + do ch = NEXTCH; while (ch != '\n' && ch != EOFCH); + goto again; + } + if (ch == EOFCH) + return (EOF); + + /* --- If the character is a quote then read a quoted string --- */ + + switch (ch) { + case '`': + ch = '\''; + case '\'': + case '\"': + q = ch; + ch = NEXTCH; + break; + } + + /* --- Now read all sorts of interesting things --- */ + + for (;;) { + + /* --- Handle an escaped thing --- */ + + if (ch == '\\') { + ch = NEXTCH; + if (ch == EOFCH) + break; + switch (ch) { + case 'a': ch = '\a'; break; + case 'b': ch = '\b'; break; + case 'f': ch = '\f'; break; + case 'n': ch = '\n'; break; + case 'r': ch = '\r'; break; + case 't': ch = '\t'; break; + case 'v': ch = '\v'; break; + } + DPUTC(d, ch); + ch = NEXTCH; + continue; + } + + /* --- If it's a quote or some other end marker then stop --- */ + + if (ch == q) + break; + if (!q && isspace((unsigned char)ch)) + break; + + /* --- Otherwise contribute and continue --- */ + + DPUTC(d, ch); + if ((ch = NEXTCH) == EOFCH) + break; + } + + /* --- Done --- */ + + DPUTZ(d); + return (0); + +#undef NEXTCH +#undef EOFCH +} + +/* --- @putstring@ --- * + * + * Arguments: @FILE *fp@ = stream to write on + * @const char *p@ = pointer to text + * @unsigned raw@ = whether the string is to be written raw + * + * Returns: --- + * + * Use: Emits a string to a stream. + */ + +static void putstring(FILE *fp, const char *p, unsigned raw) +{ + size_t sz = strlen(p); + unsigned qq; + const char *q; + + /* --- Just write the string null terminated if raw --- */ + + if (raw) { + fwrite(p, 1, sz + 1, fp); + return; + } + + /* --- Check for any dodgy characters --- */ + + qq = 0; + for (q = p; *q; q++) { + if (isspace((unsigned char)*q)) { + qq = '\"'; + break; + } + } + + if (qq) + putc(qq, fp); + + /* --- Emit the string --- */ + + for (q = p; *q; q++) { + switch (*q) { + case '\a': fputc('\\', fp); fputc('a', fp); break; + case '\b': fputc('\\', fp); fputc('b', fp); break; + case '\f': fputc('\\', fp); fputc('f', fp); break; + case '\n': fputc('\\', fp); fputc('n', fp); break; + case '\r': fputc('\\', fp); fputc('r', fp); break; + case '\t': fputc('\\', fp); fputc('t', fp); break; + case '\v': fputc('\\', fp); fputc('v', fp); break; + case '`': fputc('\\', fp); fputc('`', fp); break; + case '\'': fputc('\\', fp); fputc('\'', fp); break; + case '\"': fputc('\\', fp); fputc('\"', fp); break; + case '#': fputc('\\', fp); fputc('#', fp); break; + default: + putc(*q, fp); + break; + } + } + + /* --- Done --- */ + + if (qq) + putc(qq, fp); +} + +/*----- Guts --------------------------------------------------------------*/ + +static int checkhash(const char *file, unsigned f, const gchash *gch) +{ + int rc; + FILE *fp; + dstr d = DSTR_INIT; + dstr dd = DSTR_INIT; + unsigned long n = 0, nfail = 0; + octet *buf = xmalloc(2 * gch->hashsz); + + if (!file) + fp = stdin; + else if ((fp = fopen(file, f & f_raw ? "r" : "rb")) == 0) { + moan("couldn't open `%s': %s", file, strerror(errno)); + return (EXIT_FAILURE); + } + + while (DRESET(&d), dstr_putline(&d, fp) != EOF) { + char *p = d.buf; + char *q; + unsigned ff = f; + + /* --- Handle a directive --- */ + + if (*p == '#') { + p++; + if ((q = str_getword(&p)) == 0) + continue; + if (strcmp(q, "hash") == 0) { + const gchash *g; + if ((q = str_getword(&p)) == 0) + continue; + if ((g = gethash(q)) == 0) + continue; + gch = g; + xfree(buf); + buf = xmalloc(2 * gch->hashsz); + } else if (strcmp(q, "escape") == 0) + f |= f_escape; + continue; + } + + /* --- Otherwise it's a hex thing --- */ + + if ((q = str_getword(&p)) == 0) + continue; + if (gethex(q, buf, gch->hashsz, 0) < gch->hashsz) + continue; + while (isspace((unsigned char)*p)) + p++; + if (*p == '*') { + p++; + ff |= f_binary; + } + if (!*p) + continue; + + if (f & f_escape) { + DRESET(&dd); + getstring(0, p, &dd, 0); + p = dd.buf; + } + + if (fhash(p, ff, gch, buf + gch->hashsz)) { + moan("couldn't read `%s': %s", p, strerror(errno)); + rc = EXIT_FAILURE; + continue; + } + if (memcmp(buf, buf + gch->hashsz, gch->hashsz) != 0) { + if (ff & f_verbose) + fprintf(stderr, "FAIL %s\n", p); + else + moan("%s check failed for `%s'", gch->name, p); + nfail++; + rc = EXIT_FAILURE; + } else { + if (ff & f_verbose) + fprintf(stderr, "OK %s\n", p); + } + n++; + } + + dstr_destroy(&d); + dstr_destroy(&dd); + xfree(buf); + if ((f & f_verbose) && nfail) + moan("%lu of %lu file(s) failed %s check", nfail, n, gch->name); + else if (!n) + moan("no files checked"); + return (0); +} + +static int dohash(const char *file, unsigned f, const gchash *gch) +{ + int rc = 0; + octet *p = xmalloc(gch->hashsz); + + if (fhash(file, f, gch, p)) { + moan("couldn't read `%s': %s", file ? file : "", strerror(errno)); + rc = EXIT_FAILURE; + } else { + puthex(p, gch->hashsz, stdout); + if (file) { + fputc(' ', stdout); + fputc(f & f_binary ? '*' : ' ', stdout); + if (f & f_escape) + putstring(stdout, file, 0); + else + fputs(file, stdout); + } + fputc('\n', stdout); + } + + xfree(p); + return (rc); +} + +static int hashfiles(const char *file, unsigned f, const gchash *gch) +{ + FILE *fp; + dstr d = DSTR_INIT; + int rc = 0; + int rrc; + + if (!file) + fp = stdin; + else if ((fp = fopen(file, f & f_raw ? "r" : "rb")) == 0) { + moan("couldn't open `%s': %s", file, strerror(errno)); + return (EXIT_FAILURE); + } + + for (;;) { + DRESET(&d); + if (getstring(fp, 0, &d, f & f_raw)) + break; + if ((rrc = dohash(d.buf, f, gch)) != 0) + rc = rrc; + } + + return (rc); +} + +static int hashsum(const char *file, unsigned f, const gchash *gch) +{ + if (f & f_check) + return (checkhash(file, f, gch)); + if (f & f_files) + return (hashfiles(file, f, gch)); + return (dohash(file, f, gch)); +} + +/*----- Main driver -------------------------------------------------------*/ + +static void version(FILE *fp) +{ + pquis(fp, "$, Catacomb version " VERSION "\n"); +} + +static void usage(FILE *fp) +{ + pquis(fp, "Usage: $ [-f0bcv] [-a algorithm] [files...]\n"); +} + +static void help(FILE *fp, const gchash *gch) +{ + version(fp); + fputc('\n', fp); + usage(fp); + pquis(fp, "\n\ +Generates or checks message digests on files. Options available:\n\ +\n\ +-h, --help Display this help message.\n\ +-V, --version Display program's version number.\n\ +-u, --usage Display a terse usage message.\n\ +\n\ +-a, --algorithm=ALG Use the message digest algorithm ALG.\n\ +\n\ +-f, --files Read a list of file names from standard input.\n\ +-0, --null File names are null terminated, not plain text.\n\ +\n\ +-e, --escape Escape funny characters in filenames.\n\ +-c, --check Check message digests rather than emitting them.\n\ +-b, --binary When reading files, treat them as binary.\n\ +-v, --verbose Be verbose when checking digests.\n\ +\n\ +For a list of supported message digest algorithms, type `$ --list'.\n\ +"); + if (gch) + fprintf(fp, "The default message digest algorithm is %s.\n", gch->name); +} + +int main(int argc, char *argv[]) +{ + unsigned f = 0; + const gchash *gch = 0; + int rc; + + /* --- Initialization --- */ + + ego(argv[0]); + sub_init(); + + /* --- Choose a hash function from the name --- */ + + { + char *q = xstrdup(QUIS); + size_t len = strlen(q); + if (len > 3 && strcmp(q + len - 3, "sum") == 0) { + q[len - 3] = 0; + gch = gethash(q); + } + if (!gch) + gch = hashtab[0]; + xfree(q); + } + + /* --- Read options --- */ + + for (;;) { + static struct option opts[] = { + { "help", 0, 0, 'h' }, + { "verbose", 0, 0, 'V' }, + { "usage", 0, 0, 'u' }, + + { "algorithm", OPTF_ARGREQ, 0, 'a' }, + { "hash", OPTF_ARGREQ, 0, 'a' }, + { "list", 0, 0, 'l' }, + + { "files", 0, 0, 'f' }, + { "find", 0, 0, 'f' }, + { "null", 0, 0, '0' }, + + { "escape", 0, 0, 'e' }, + { "check", 0, 0, 'c' }, + { "binary", 0, 0, 'b' }, + { "verbose", 0, 0, 'v' }, + + { 0, 0, 0, 0 } + }; + int i = mdwopt(argc, argv, "hVu a:l f0 ecbv", opts, 0, 0, 0); + if (i < 0) + break; + + switch (i) { + case 'h': + help(stdout, gch); + exit(0); + case 'V': + version(stdout); + exit(0); + case 'u': + usage(stdout); + exit(0); + case 'a': + if ((gch = gethash(optarg)) == 0) + die(EXIT_FAILURE, "unknown hash algorithm `%s'", optarg); + f |= f_oddhash; + break; + case 'l': { + unsigned j; + for (j = 0; hashtab[j]; j++) { + if (j) + fputc(' ', stdout); + printf("%s", hashtab[j]->name); + } + fputc('\n', stdout); + exit(0); + } break; + case 'f': + f |= f_files; + break; + case '0': + f |= f_raw; + break; + case 'e': + f |= f_escape; + break; + case 'c': + f |= f_check; + break; + case 'b': + f |= f_binary; + break; + case 'v': + f |= f_verbose; + break; + default: + f |= f_bogus; + break; + } + } + + if (f & f_bogus) { + usage(stderr); + exit(EXIT_FAILURE); + } + argv += optind; + argc -= optind; + + /* --- Generate output --- */ + + if (!(f & f_check)) { + if (f & f_oddhash) + printf("#hash %s\n", gch->name); + if (f & f_escape) + fputs("#escape\n", stdout); + } + + if (argc) { + int i; + int rrc; + rc = 0; + for (i = 0; i < argc; i++) { + if ((rrc = hashsum(argv[i], f, gch)) != 0) + rc = rrc; + } + } else + rc = hashsum(0, f, gch); + + return (rc); +} + +/*----- That's all, folks -------------------------------------------------*/ -- 2.11.0