diff options
Diffstat (limited to 'src/digest.c')
| -rw-r--r-- | src/digest.c | 1518 |
1 files changed, 1518 insertions, 0 deletions
diff --git a/src/digest.c b/src/digest.c new file mode 100644 index 0000000..737a829 --- /dev/null +++ b/src/digest.c @@ -0,0 +1,1518 @@ +/* Compute checksums of files or strings. + Copyright (C) 1995-2022 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <https://www.gnu.org/licenses/>. */ + +/* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>. */ + +#include <config.h> + +#include <getopt.h> +#include <sys/types.h> + +#include "system.h" +#include "argmatch.h" +#include "quote.h" +#include "xdectoint.h" +#include "xstrtol.h" + +#if HASH_ALGO_SUM || HASH_ALGO_CKSUM +# include "sum.h" +#endif +#if HASH_ALGO_CKSUM +# include "cksum.h" +#endif +#if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM +# include "blake2/b2sum.h" +#endif +#if HASH_ALGO_MD5 || HASH_ALGO_CKSUM +# include "md5.h" +#endif +#if HASH_ALGO_SHA1 || HASH_ALGO_CKSUM +# include "sha1.h" +#endif +#if HASH_ALGO_SHA256 || HASH_ALGO_SHA224 || HASH_ALGO_CKSUM +# include "sha256.h" +#endif +#if HASH_ALGO_SHA512 || HASH_ALGO_SHA384 || HASH_ALGO_CKSUM +# include "sha512.h" +#endif +#if HASH_ALGO_CKSUM +# include "sm3.h" +#endif +#include "die.h" +#include "error.h" +#include "fadvise.h" +#include "stdio--.h" +#include "xbinary-io.h" + +/* The official name of this program (e.g., no 'g' prefix). */ +#if HASH_ALGO_SUM +# define PROGRAM_NAME "sum" +# define DIGEST_TYPE_STRING "BSD" +# define DIGEST_STREAM sumfns[sum_algorithm] +# define DIGEST_OUT sum_output_fns[sum_algorithm] +# define DIGEST_BITS 16 +# define DIGEST_ALIGN 4 +#elif HASH_ALGO_CKSUM +# define MAX_DIGEST_BITS 512 +# define MAX_DIGEST_ALIGN 8 +# define PROGRAM_NAME "cksum" +# define DIGEST_TYPE_STRING algorithm_tags[cksum_algorithm] +# define DIGEST_STREAM cksumfns[cksum_algorithm] +# define DIGEST_OUT cksum_output_fns[cksum_algorithm] +# define DIGEST_BITS MAX_DIGEST_BITS +# define DIGEST_ALIGN MAX_DIGEST_ALIGN +#elif HASH_ALGO_MD5 +# define PROGRAM_NAME "md5sum" +# define DIGEST_TYPE_STRING "MD5" +# define DIGEST_STREAM md5_stream +# define DIGEST_BITS 128 +# define DIGEST_REFERENCE "RFC 1321" +# define DIGEST_ALIGN 4 +#elif HASH_ALGO_BLAKE2 +# define PROGRAM_NAME "b2sum" +# define DIGEST_TYPE_STRING "BLAKE2b" +# define DIGEST_STREAM blake2b_stream +# define DIGEST_BITS 512 +# define DIGEST_REFERENCE "RFC 7693" +# define DIGEST_ALIGN 8 +#elif HASH_ALGO_SHA1 +# define PROGRAM_NAME "sha1sum" +# define DIGEST_TYPE_STRING "SHA1" +# define DIGEST_STREAM sha1_stream +# define DIGEST_BITS 160 +# define DIGEST_REFERENCE "FIPS-180-1" +# define DIGEST_ALIGN 4 +#elif HASH_ALGO_SHA256 +# define PROGRAM_NAME "sha256sum" +# define DIGEST_TYPE_STRING "SHA256" +# define DIGEST_STREAM sha256_stream +# define DIGEST_BITS 256 +# define DIGEST_REFERENCE "FIPS-180-2" +# define DIGEST_ALIGN 4 +#elif HASH_ALGO_SHA224 +# define PROGRAM_NAME "sha224sum" +# define DIGEST_TYPE_STRING "SHA224" +# define DIGEST_STREAM sha224_stream +# define DIGEST_BITS 224 +# define DIGEST_REFERENCE "RFC 3874" +# define DIGEST_ALIGN 4 +#elif HASH_ALGO_SHA512 +# define PROGRAM_NAME "sha512sum" +# define DIGEST_TYPE_STRING "SHA512" +# define DIGEST_STREAM sha512_stream +# define DIGEST_BITS 512 +# define DIGEST_REFERENCE "FIPS-180-2" +# define DIGEST_ALIGN 8 +#elif HASH_ALGO_SHA384 +# define PROGRAM_NAME "sha384sum" +# define DIGEST_TYPE_STRING "SHA384" +# define DIGEST_STREAM sha384_stream +# define DIGEST_BITS 384 +# define DIGEST_REFERENCE "FIPS-180-2" +# define DIGEST_ALIGN 8 +#else +# error "Can't decide which hash algorithm to compile." +#endif +#if !HASH_ALGO_SUM && !HASH_ALGO_CKSUM +# define DIGEST_OUT output_file +#endif + +#if HASH_ALGO_SUM +# define AUTHORS \ + proper_name ("Kayvan Aghaiepour"), \ + proper_name ("David MacKenzie") +#elif HASH_ALGO_CKSUM +# define AUTHORS \ + proper_name ("Padraig Brady"), \ + proper_name ("Q. Frank Xia") +#elif HASH_ALGO_BLAKE2 +# define AUTHORS \ + proper_name ("Padraig Brady"), \ + proper_name ("Samuel Neves") +#else +# define AUTHORS \ + proper_name ("Ulrich Drepper"), \ + proper_name ("Scott Miller"), \ + proper_name ("David Madore") +#endif +#if !HASH_ALGO_BLAKE2 && !HASH_ALGO_CKSUM +# define DIGEST_HEX_BYTES (DIGEST_BITS / 4) +#endif +#define DIGEST_BIN_BYTES (DIGEST_BITS / 8) + +/* The minimum length of a valid digest line. This length does + not include any newline character at the end of a line. */ +#if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM +# define MIN_DIGEST_LINE_LENGTH 3 /* With -l 8. */ +#else +# define MIN_DIGEST_LINE_LENGTH \ + (DIGEST_HEX_BYTES /* length of hexadecimal message digest */ \ + + 1 /* blank */ \ + + 1 /* minimum filename length */ ) +#endif + +#if !HASH_ALGO_SUM +static void +output_file (char const *file, int binary_file, void const *digest, + bool tagged, unsigned char delim, bool args, + uintmax_t length); +#endif + +/* True if any of the files read were the standard input. */ +static bool have_read_stdin; + +/* The minimum length of a valid checksum line for the selected algorithm. */ +static size_t min_digest_line_length; + +/* Set to the length of a digest hex string for the selected algorithm. */ +static size_t digest_hex_bytes; + +/* With --check, don't generate any output. + The exit code indicates success or failure. */ +static bool status_only = false; + +/* With --check, print a message to standard error warning about each + improperly formatted checksum line. */ +static bool warn = false; + +/* With --check, ignore missing files. */ +static bool ignore_missing = false; + +/* With --check, suppress the "OK" printed for each verified file. */ +static bool quiet = false; + +/* With --check, exit with a non-zero return code if any line is + improperly formatted. */ +static bool strict = false; + +/* Whether a BSD reversed format checksum is detected. */ +static int bsd_reversed = -1; + +/* line delimiter. */ +static unsigned char digest_delim = '\n'; + +#if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM +# define BLAKE2B_MAX_LEN BLAKE2B_OUTBYTES +static uintmax_t digest_length; +#endif /* HASH_ALGO_BLAKE2 */ + +typedef void (*digest_output_fn)(char const *, int, void const *, + bool, unsigned char, bool, uintmax_t); +#if HASH_ALGO_SUM +enum Algorithm +{ + bsd, + sysv, +}; + +static enum Algorithm sum_algorithm; +static sumfn sumfns[]= +{ + bsd_sum_stream, + sysv_sum_stream, +}; +static digest_output_fn sum_output_fns[]= +{ + output_bsd, + output_sysv, +}; +#endif + +#if HASH_ALGO_CKSUM +static int +md5_sum_stream (FILE *stream, void *resstream, uintmax_t *length) +{ + return md5_stream (stream, resstream); +} +static int +sha1_sum_stream (FILE *stream, void *resstream, uintmax_t *length) +{ + return sha1_stream (stream, resstream); +} +static int +sha224_sum_stream (FILE *stream, void *resstream, uintmax_t *length) +{ + return sha224_stream (stream, resstream); +} +static int +sha256_sum_stream (FILE *stream, void *resstream, uintmax_t *length) +{ + return sha256_stream (stream, resstream); +} +static int +sha384_sum_stream (FILE *stream, void *resstream, uintmax_t *length) +{ + return sha384_stream (stream, resstream); +} +static int +sha512_sum_stream (FILE *stream, void *resstream, uintmax_t *length) +{ + return sha512_stream (stream, resstream); +} +static int +blake2b_sum_stream (FILE *stream, void *resstream, uintmax_t *length) +{ + return blake2b_stream (stream, resstream, *length); +} +static int +sm3_sum_stream (FILE *stream, void *resstream, uintmax_t *length) +{ + return sm3_stream (stream, resstream); +} + +enum Algorithm +{ + bsd, + sysv, + crc, + md5, + sha1, + sha224, + sha256, + sha384, + sha512, + blake2b, + sm3, +}; + +static char const *const algorithm_args[] = +{ + "bsd", "sysv", "crc", "md5", "sha1", "sha224", + "sha256", "sha384", "sha512", "blake2b", "sm3", NULL +}; +static enum Algorithm const algorithm_types[] = +{ + bsd, sysv, crc, md5, sha1, sha224, + sha256, sha384, sha512, blake2b, sm3, +}; +ARGMATCH_VERIFY (algorithm_args, algorithm_types); + +static char const *const algorithm_tags[] = +{ + "BSD", "SYSV", "CRC", "MD5", "SHA1", "SHA224", + "SHA256", "SHA384", "SHA512", "BLAKE2b", "SM3", NULL +}; +static int const algorithm_bits[] = +{ + 16, 16, 32, 128, 160, 224, + 256, 384, 512, 512, 256, 0 +}; + +verify (ARRAY_CARDINALITY (algorithm_bits) + == ARRAY_CARDINALITY (algorithm_args)); + +static bool algorithm_specified = false; +static enum Algorithm cksum_algorithm = crc; +static sumfn cksumfns[]= +{ + bsd_sum_stream, + sysv_sum_stream, + crc_sum_stream, + md5_sum_stream, + sha1_sum_stream, + sha224_sum_stream, + sha256_sum_stream, + sha384_sum_stream, + sha512_sum_stream, + blake2b_sum_stream, + sm3_sum_stream, +}; +static digest_output_fn cksum_output_fns[]= +{ + output_bsd, + output_sysv, + output_crc, + output_file, + output_file, + output_file, + output_file, + output_file, + output_file, + output_file, + output_file, +}; +bool cksum_debug; +#endif + +/* For long options that have no equivalent short option, use a + non-character as a pseudo short option, starting with CHAR_MAX + 1. */ + +enum +{ + IGNORE_MISSING_OPTION = CHAR_MAX + 1, + STATUS_OPTION, + QUIET_OPTION, + STRICT_OPTION, + TAG_OPTION, + UNTAG_OPTION, + DEBUG_PROGRAM_OPTION, +}; + +static struct option const long_options[] = +{ +#if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM + { "length", required_argument, NULL, 'l'}, +#endif + +#if !HASH_ALGO_SUM + { "check", no_argument, NULL, 'c' }, + { "ignore-missing", no_argument, NULL, IGNORE_MISSING_OPTION}, + { "quiet", no_argument, NULL, QUIET_OPTION }, + { "status", no_argument, NULL, STATUS_OPTION }, + { "warn", no_argument, NULL, 'w' }, + { "strict", no_argument, NULL, STRICT_OPTION }, + { "tag", no_argument, NULL, TAG_OPTION }, + { "zero", no_argument, NULL, 'z' }, + +# if HASH_ALGO_CKSUM + { "algorithm", required_argument, NULL, 'a'}, + { "debug", no_argument, NULL, DEBUG_PROGRAM_OPTION}, + { "untagged", no_argument, NULL, UNTAG_OPTION }, +# else + { "binary", no_argument, NULL, 'b' }, + { "text", no_argument, NULL, 't' }, +# endif + +#else + {"sysv", no_argument, NULL, 's'}, +#endif + + { GETOPT_HELP_OPTION_DECL }, + { GETOPT_VERSION_OPTION_DECL }, + { NULL, 0, NULL, 0 } +}; + +void +usage (int status) +{ + if (status != EXIT_SUCCESS) + emit_try_help (); + else + { + printf (_("\ +Usage: %s [OPTION]... [FILE]...\n\ +"), program_name); +#if HASH_ALGO_CKSUM + fputs (_("\ +Print or verify checksums.\n\ +By default use the 32 bit CRC algorithm.\n\ +"), stdout); +#else + printf (_("\ +Print or check %s (%d-bit) checksums.\n\ +"), + DIGEST_TYPE_STRING, + DIGEST_BITS); +#endif + + emit_stdin_note (); +#if HASH_ALGO_SUM + fputs (_("\ +\n\ + -r use BSD sum algorithm (the default), use 1K blocks\n\ + -s, --sysv use System V sum algorithm, use 512 bytes blocks\n\ +"), stdout); +#endif +#if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM + emit_mandatory_arg_note (); +#endif +#if HASH_ALGO_CKSUM + fputs (_("\ + -a, --algorithm=TYPE select the digest type to use. See DIGEST below.\ +\n\ +"), stdout); +#endif +#if !HASH_ALGO_SUM +# if !HASH_ALGO_CKSUM + if (O_BINARY) + fputs (_("\ + -b, --binary read in binary mode (default unless reading tty stdin)\ +\n\ +"), stdout); + else + fputs (_("\ + -b, --binary read in binary mode\n\ +"), stdout); +# endif + fputs (_("\ + -c, --check read checksums from the FILEs and check them\n\ +"), stdout); +# if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM + fputs (_("\ + -l, --length=BITS digest length in bits; must not exceed the max for\n\ + the blake2 algorithm and must be a multiple of 8\n\ +"), stdout); +# endif +# if HASH_ALGO_CKSUM + fputs (_("\ + --tag create a BSD-style checksum (the default)\n\ +"), stdout); + fputs (_("\ + --untagged create a reversed style checksum, without digest type\n\ +"), stdout); +# else + fputs (_("\ + --tag create a BSD-style checksum\n\ +"), stdout); +# endif +# if !HASH_ALGO_CKSUM + if (O_BINARY) + fputs (_("\ + -t, --text read in text mode (default if reading tty stdin)\n\ +"), stdout); + else + fputs (_("\ + -t, --text read in text mode (default)\n\ +"), stdout); +# endif + fputs (_("\ + -z, --zero end each output line with NUL, not newline,\n\ + and disable file name escaping\n\ +"), stdout); + fputs (_("\ +\n\ +The following five options are useful only when verifying checksums:\n\ + --ignore-missing don't fail or report status for missing files\n\ + --quiet don't print OK for each successfully verified file\n\ + --status don't output anything, status code shows success\n\ + --strict exit non-zero for improperly formatted checksum lines\n\ + -w, --warn warn about improperly formatted checksum lines\n\ +\n\ +"), stdout); +#endif +#if HASH_ALGO_CKSUM + fputs (_("\ + --debug indicate which implementation used\n\ +"), stdout); +#endif + fputs (HELP_OPTION_DESCRIPTION, stdout); + fputs (VERSION_OPTION_DESCRIPTION, stdout); +#if HASH_ALGO_CKSUM + fputs (_("\ +\n\ +DIGEST determines the digest algorithm and default output format:\n\ + sysv (equivalent to sum -s)\n\ + bsd (equivalent to sum -r)\n\ + crc (equivalent to cksum)\n\ + md5 (equivalent to md5sum)\n\ + sha1 (equivalent to sha1sum)\n\ + sha224 (equivalent to sha224sum)\n\ + sha256 (equivalent to sha256sum)\n\ + sha384 (equivalent to sha384sum)\n\ + sha512 (equivalent to sha512sum)\n\ + blake2b (equivalent to b2sum)\n\ + sm3 (only available through cksum)\n\ +\n"), stdout); +#endif +#if !HASH_ALGO_SUM && !HASH_ALGO_CKSUM + printf (_("\ +\n\ +The sums are computed as described in %s.\n"), DIGEST_REFERENCE); + fputs (_("\ +When checking, the input should be a former output of this program.\n\ +The default mode is to print a line with: checksum, a space,\n\ +a character indicating input mode ('*' for binary, ' ' for text\n\ +or where binary is insignificant), and name for each FILE.\n\ +\n\ +Note: There is no difference between binary mode and text mode on GNU systems.\ +\n"), stdout); +#endif +#if HASH_ALGO_CKSUM + fputs (_("\ +When checking, the input should be a former output of this program,\n\ +or equivalent standalone program.\ +\n"), stdout); +#endif + emit_ancillary_info (PROGRAM_NAME); + } + + exit (status); +} + +#define ISWHITE(c) ((c) == ' ' || (c) == '\t') + +/* Given a file name, S of length S_LEN, that is not NUL-terminated, + modify it in place, performing the equivalent of this sed substitution: + 's/\\n/\n/g;s/\\r/\r/g;s/\\\\/\\/g' i.e., replacing each "\\n" string + with a newline, each "\\r" string with a carriage return, + and each "\\\\" with a single backslash, NUL-terminate it and return S. + If S is not a valid escaped file name, i.e., if it ends with an odd number + of backslashes or if it contains a backslash followed by anything other + than "n" or another backslash, return NULL. */ + +static char * +filename_unescape (char *s, size_t s_len) +{ + char *dst = s; + + for (size_t i = 0; i < s_len; i++) + { + switch (s[i]) + { + case '\\': + if (i == s_len - 1) + { + /* File name ends with an unescaped backslash: invalid. */ + return NULL; + } + ++i; + switch (s[i]) + { + case 'n': + *dst++ = '\n'; + break; + case 'r': + *dst++ = '\r'; + break; + case '\\': + *dst++ = '\\'; + break; + default: + /* Only '\', 'n' or 'r' may follow a backslash. */ + return NULL; + } + break; + + case '\0': + /* The file name may not contain a NUL. */ + return NULL; + + default: + *dst++ = s[i]; + break; + } + } + if (dst < s + s_len) + *dst = '\0'; + + return s; +} + +/* Return true if S is a NUL-terminated string of DIGEST_HEX_BYTES hex digits. + Otherwise, return false. */ +ATTRIBUTE_PURE +static bool +hex_digits (unsigned char const *s) +{ + for (unsigned int i = 0; i < digest_hex_bytes; i++) + { + if (!isxdigit (*s)) + return false; + ++s; + } + return *s == '\0'; +} + +/* Split the checksum string S (of length S_LEN) from a BSD 'md5' or + 'sha1' command into two parts: a hexadecimal digest, and the file + name. S is modified. Return true if successful. */ + +static bool +bsd_split_3 (char *s, size_t s_len, unsigned char **hex_digest, + char **file_name, bool escaped_filename) +{ + size_t i; + + if (s_len == 0) + return false; + + /* Find end of filename. */ + i = s_len - 1; + while (i && s[i] != ')') + i--; + + if (s[i] != ')') + return false; + + *file_name = s; + + if (escaped_filename && filename_unescape (s, i) == NULL) + return false; + + s[i++] = '\0'; + + while (ISWHITE (s[i])) + i++; + + if (s[i] != '=') + return false; + + i++; + + while (ISWHITE (s[i])) + i++; + + *hex_digest = (unsigned char *) &s[i]; + + return hex_digits (*hex_digest); +} + +#if HASH_ALGO_CKSUM +/* Return the corresponding Algorithm for the string S, + or -1 for no match. */ + +static ptrdiff_t +algorithm_from_tag (char *s) +{ + /* Limit check size to this length for perf reasons. */ + static size_t max_tag_len; + if (! max_tag_len) + { + char const * const * tag = algorithm_tags; + while (*tag) + { + size_t tag_len = strlen (*tag++); + max_tag_len = MAX (tag_len, max_tag_len); + } + } + + size_t i = 0; + + /* Find end of tag */ + while (i <= max_tag_len && s[i] && ! ISWHITE (s[i]) + && s[i] != '-' && s[i] != '(') + ++i; + + if (i > max_tag_len) + return -1; + + /* Terminate tag, and lookup. */ + char sep = s[i]; + s[i] = '\0'; + ptrdiff_t algo = argmatch_exact (s, algorithm_tags); + s[i] = sep; + + return algo; +} +#endif + +/* Split the string S (of length S_LEN) into three parts: + a hexadecimal digest, binary flag, and the file name. + S is modified. Return true if successful. */ + +static bool +split_3 (char *s, size_t s_len, + unsigned char **hex_digest, int *binary, char **file_name) +{ + bool escaped_filename = false; + size_t algo_name_len; + + size_t i = 0; + while (ISWHITE (s[i])) + ++i; + + if (s[i] == '\\') + { + ++i; + escaped_filename = true; + } + + /* Check for BSD-style checksum line. */ + +#if HASH_ALGO_CKSUM + if (! algorithm_specified) + { + ptrdiff_t algo_tag = algorithm_from_tag (s + i); + if (algo_tag >= 0) + { + if (algo_tag <= crc) + return false; /* We don't support checking these older formats. */ + cksum_algorithm = algo_tag; + } + else + return false; /* We only support tagged format without -a. */ + } +#endif + + algo_name_len = strlen (DIGEST_TYPE_STRING); + if (STREQ_LEN (s + i, DIGEST_TYPE_STRING, algo_name_len)) + { + i += algo_name_len; +#if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM + /* Terminate and match algorithm name. */ + char const *algo_name = &s[i - algo_name_len]; + bool length_specified = s[i] == '-'; + bool openssl_format = s[i] == '('; /* and no length_specified */ + s[i++] = '\0'; + if (!STREQ (algo_name, DIGEST_TYPE_STRING)) + return false; + if (openssl_format) + s[--i] = '('; + +# if HASH_ALGO_BLAKE2 + digest_length = BLAKE2B_MAX_LEN * 8; +# else + digest_length = algorithm_bits[cksum_algorithm]; +# endif + if (length_specified) + { + uintmax_t length; + char *siend; + if (! (xstrtoumax (s + i, &siend, 0, &length, NULL) == LONGINT_OK + && 0 < length && length <= digest_length + && length % 8 == 0)) + return false; + + i = siend - s; + digest_length = length; + } + digest_hex_bytes = digest_length / 4; +#endif + if (s[i] == ' ') + ++i; + if (s[i] == '(') + { + ++i; + *binary = 0; + return bsd_split_3 (s + i, s_len - i, + hex_digest, file_name, escaped_filename); + } + return false; + } + + /* Ignore this line if it is too short. + Each line must have at least 'min_digest_line_length - 1' (or one more, if + the first is a backslash) more characters to contain correct message digest + information. */ + if (s_len - i < min_digest_line_length + (s[i] == '\\')) + return false; + + *hex_digest = (unsigned char *) &s[i]; + +#if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM + /* Auto determine length. */ +# if HASH_ALGO_CKSUM + if (cksum_algorithm == blake2b) { +# endif + unsigned char const *hp = *hex_digest; + digest_hex_bytes = 0; + while (isxdigit (*hp++)) + digest_hex_bytes++; + if (digest_hex_bytes < 2 || digest_hex_bytes % 2 + || BLAKE2B_MAX_LEN * 2 < digest_hex_bytes) + return false; + digest_length = digest_hex_bytes * 4; +# if HASH_ALGO_CKSUM + } +# endif +#endif + + /* The first field has to be the n-character hexadecimal + representation of the message digest. If it is not followed + immediately by a white space it's an error. */ + i += digest_hex_bytes; + if (!ISWHITE (s[i])) + return false; + + s[i++] = '\0'; + + if (! hex_digits (*hex_digest)) + return false; + + /* If "bsd reversed" format detected. */ + if ((s_len - i == 1) || (s[i] != ' ' && s[i] != '*')) + { + /* Don't allow mixing bsd and standard formats, + to minimize security issues with attackers + renaming files with leading spaces. + This assumes that with bsd format checksums + that the first file name does not have + a leading ' ' or '*'. */ + if (bsd_reversed == 0) + return false; + bsd_reversed = 1; + } + else if (bsd_reversed != 1) + { + bsd_reversed = 0; + *binary = (s[i++] == '*'); + } + + /* All characters between the type indicator and end of line are + significant -- that includes leading and trailing white space. */ + *file_name = &s[i]; + + if (escaped_filename) + return filename_unescape (&s[i], s_len - i) != NULL; + + return true; +} + +/* If ESCAPE is true, then translate each: + NEWLINE byte to the string, "\\n", + CARRIAGE RETURN byte to the string, "\\r", + and each backslash to "\\\\". */ +static void +print_filename (char const *file, bool escape) +{ + if (! escape) + { + fputs (file, stdout); + return; + } + + while (*file) + { + switch (*file) + { + case '\n': + fputs ("\\n", stdout); + break; + + case '\r': + fputs ("\\r", stdout); + break; + + case '\\': + fputs ("\\\\", stdout); + break; + + default: + putchar (*file); + break; + } + file++; + } +} + +/* An interface to the function, DIGEST_STREAM. + Operate on FILENAME (it may be "-"). + + *BINARY indicates whether the file is binary. BINARY < 0 means it + depends on whether binary mode makes any difference and the file is + a terminal; in that case, clear *BINARY if the file was treated as + text because it was a terminal. + + Put the checksum in *BIN_RESULT, which must be properly aligned. + Put true in *MISSING if the file can't be opened due to ENOENT. + Return true if successful. */ + +static bool +digest_file (char const *filename, int *binary, unsigned char *bin_result, + bool *missing, MAYBE_UNUSED uintmax_t *length) +{ + FILE *fp; + int err; + bool is_stdin = STREQ (filename, "-"); + + *missing = false; + + if (is_stdin) + { + have_read_stdin = true; + fp = stdin; + if (O_BINARY && *binary) + { + if (*binary < 0) + *binary = ! isatty (STDIN_FILENO); + if (*binary) + xset_binary_mode (STDIN_FILENO, O_BINARY); + } + } + else + { + fp = fopen (filename, (O_BINARY && *binary ? "rb" : "r")); + if (fp == NULL) + { + if (ignore_missing && errno == ENOENT) + { + *missing = true; + return true; + } + error (0, errno, "%s", quotef (filename)); + return false; + } + } + + fadvise (fp, FADVISE_SEQUENTIAL); + +#if HASH_ALGO_CKSUM + if (cksum_algorithm == blake2b) + *length = digest_length / 8; + err = DIGEST_STREAM (fp, bin_result, length); +#elif HASH_ALGO_SUM + err = DIGEST_STREAM (fp, bin_result, length); +#elif HASH_ALGO_BLAKE2 + err = DIGEST_STREAM (fp, bin_result, digest_length / 8); +#else + err = DIGEST_STREAM (fp, bin_result); +#endif + err = err ? errno : 0; + if (is_stdin) + clearerr (fp); + else if (fclose (fp) != 0 && !err) + err = errno; + + if (err) + { + error (0, err, "%s", quotef (filename)); + return false; + } + + return true; +} + +#if !HASH_ALGO_SUM +static void +output_file (char const *file, int binary_file, void const *digest, + bool tagged, unsigned char delim, MAYBE_UNUSED bool args, + MAYBE_UNUSED uintmax_t length) +{ + unsigned char const *bin_buffer = digest; + + /* Output a leading backslash if the file name contains problematic chars. + Note we escape '\' itself to provide some forward compat to introduce + escaping of other characters. */ + bool needs_escape = delim == '\n' && (strchr (file, '\\') + || strchr (file, '\n') + || strchr (file, '\r')); + if (needs_escape) + putchar ('\\'); + + if (tagged) + { + fputs (DIGEST_TYPE_STRING, stdout); +# if HASH_ALGO_BLAKE2 + if (digest_length < BLAKE2B_MAX_LEN * 8) + printf ("-%"PRIuMAX, digest_length); +# elif HASH_ALGO_CKSUM + if (cksum_algorithm == blake2b) + { + if (digest_length < BLAKE2B_MAX_LEN * 8) + printf ("-%"PRIuMAX, digest_length); + } +# endif + fputs (" (", stdout); + print_filename (file, needs_escape); + fputs (") = ", stdout); + } + + for (size_t i = 0; i < (digest_hex_bytes / 2); ++i) + printf ("%02x", bin_buffer[i]); + + if (!tagged) + { + putchar (' '); + +# if HASH_ALGO_CKSUM + /* Simplify output as always in binary mode. */ + putchar (' '); +# else + putchar (binary_file ? '*' : ' '); +# endif + + print_filename (file, needs_escape); + } + + putchar (delim); +} +#endif + +static bool +digest_check (char const *checkfile_name) +{ + FILE *checkfile_stream; + uintmax_t n_misformatted_lines = 0; + uintmax_t n_improperly_formatted_lines = 0; + uintmax_t n_mismatched_checksums = 0; + uintmax_t n_open_or_read_failures = 0; + bool properly_formatted_lines = false; + bool matched_checksums = false; + unsigned char bin_buffer_unaligned[DIGEST_BIN_BYTES + DIGEST_ALIGN]; + /* Make sure bin_buffer is properly aligned. */ + unsigned char *bin_buffer = ptr_align (bin_buffer_unaligned, DIGEST_ALIGN); + uintmax_t line_number; + char *line; + size_t line_chars_allocated; + bool is_stdin = STREQ (checkfile_name, "-"); + + if (is_stdin) + { + have_read_stdin = true; + checkfile_name = _("standard input"); + checkfile_stream = stdin; + } + else + { + checkfile_stream = fopen (checkfile_name, "r"); + if (checkfile_stream == NULL) + { + error (0, errno, "%s", quotef (checkfile_name)); + return false; + } + } + + line_number = 0; + line = NULL; + line_chars_allocated = 0; + do + { + char *filename; + int binary; + unsigned char *hex_digest; + ssize_t line_length; + + ++line_number; + if (line_number == 0) + die (EXIT_FAILURE, 0, _("%s: too many checksum lines"), + quotef (checkfile_name)); + + line_length = getline (&line, &line_chars_allocated, checkfile_stream); + if (line_length <= 0) + break; + + /* Ignore comment lines, which begin with a '#' character. */ + if (line[0] == '#') + continue; + + /* Remove any trailing newline. */ + line_length -= line[line_length - 1] == '\n'; + /* Remove any trailing carriage return. */ + line_length -= line[line_length - (0 < line_length)] == '\r'; + + /* Ignore empty lines. */ + if (line_length == 0) + continue; + + line[line_length] = '\0'; + + if (! (split_3 (line, line_length, &hex_digest, &binary, &filename) + && ! (is_stdin && STREQ (filename, "-")))) + { + ++n_misformatted_lines; + + if (warn) + { + error (0, 0, + _("%s: %" PRIuMAX + ": improperly formatted %s checksum line"), + quotef (checkfile_name), line_number, + DIGEST_TYPE_STRING); + } + + ++n_improperly_formatted_lines; + } + else + { + static const char bin2hex[] = { '0', '1', '2', '3', + '4', '5', '6', '7', + '8', '9', 'a', 'b', + 'c', 'd', 'e', 'f' }; + bool ok; + bool missing; + /* Only escape in the edge case producing multiple lines, + to ease automatic processing of status output. */ + bool needs_escape = ! status_only && strchr (filename, '\n'); + + properly_formatted_lines = true; + + uintmax_t length; + ok = digest_file (filename, &binary, bin_buffer, &missing, &length); + + if (!ok) + { + ++n_open_or_read_failures; + if (!status_only) + { + if (needs_escape) + putchar ('\\'); + print_filename (filename, needs_escape); + printf (": %s\n", _("FAILED open or read")); + } + } + else if (ignore_missing && missing) + { + /* Ignore missing files with --ignore-missing. */ + ; + } + else + { + size_t digest_bin_bytes = digest_hex_bytes / 2; + size_t cnt; + + /* Compare generated binary number with text representation + in check file. Ignore case of hex digits. */ + for (cnt = 0; cnt < digest_bin_bytes; ++cnt) + { + if (tolower (hex_digest[2 * cnt]) + != bin2hex[bin_buffer[cnt] >> 4] + || (tolower (hex_digest[2 * cnt + 1]) + != (bin2hex[bin_buffer[cnt] & 0xf]))) + break; + } + if (cnt != digest_bin_bytes) + ++n_mismatched_checksums; + else + matched_checksums = true; + + if (!status_only) + { + if (cnt != digest_bin_bytes || ! quiet) + { + if (needs_escape) + putchar ('\\'); + print_filename (filename, needs_escape); + } + + if (cnt != digest_bin_bytes) + printf (": %s\n", _("FAILED")); + else if (!quiet) + printf (": %s\n", _("OK")); + } + } + } + } + while (!feof (checkfile_stream) && !ferror (checkfile_stream)); + + free (line); + + int err = ferror (checkfile_stream) ? 0 : -1; + if (is_stdin) + clearerr (checkfile_stream); + else if (fclose (checkfile_stream) != 0 && err < 0) + err = errno; + + if (0 <= err) + { + error (0, err, err ? "%s" : _("%s: read error"), + quotef (checkfile_name)); + return false; + } + + if (! properly_formatted_lines) + { + /* Warn if no tests are found. */ + error (0, 0, _("%s: no properly formatted checksum lines found"), + quotef (checkfile_name)); + } + else + { + if (!status_only) + { + if (n_misformatted_lines != 0) + error (0, 0, + (ngettext + ("WARNING: %" PRIuMAX " line is improperly formatted", + "WARNING: %" PRIuMAX " lines are improperly formatted", + select_plural (n_misformatted_lines))), + n_misformatted_lines); + + if (n_open_or_read_failures != 0) + error (0, 0, + (ngettext + ("WARNING: %" PRIuMAX " listed file could not be read", + "WARNING: %" PRIuMAX " listed files could not be read", + select_plural (n_open_or_read_failures))), + n_open_or_read_failures); + + if (n_mismatched_checksums != 0) + error (0, 0, + (ngettext + ("WARNING: %" PRIuMAX " computed checksum did NOT match", + "WARNING: %" PRIuMAX " computed checksums did NOT match", + select_plural (n_mismatched_checksums))), + n_mismatched_checksums); + + if (ignore_missing && ! matched_checksums) + error (0, 0, _("%s: no file was verified"), + quotef (checkfile_name)); + } + } + + return (properly_formatted_lines + && matched_checksums + && n_mismatched_checksums == 0 + && n_open_or_read_failures == 0 + && (!strict || n_improperly_formatted_lines == 0)); +} + +int +main (int argc, char **argv) +{ + unsigned char bin_buffer_unaligned[DIGEST_BIN_BYTES + DIGEST_ALIGN]; + /* Make sure bin_buffer is properly aligned. */ + unsigned char *bin_buffer = ptr_align (bin_buffer_unaligned, DIGEST_ALIGN); + bool do_check = false; + int opt; + bool ok = true; +#if HASH_ALGO_CKSUM + int binary = 1; + bool prefix_tag = true; +#else + int binary = -1; + bool prefix_tag = false; +#endif + + /* Setting values of global variables. */ + initialize_main (&argc, &argv); + set_program_name (argv[0]); + setlocale (LC_ALL, ""); + bindtextdomain (PACKAGE, LOCALEDIR); + textdomain (PACKAGE); + + atexit (close_stdout); + + /* Line buffer stdout to ensure lines are written atomically and immediately + so that processes running in parallel do not intersperse their output. */ + setvbuf (stdout, NULL, _IOLBF, 0); + +#if HASH_ALGO_SUM + char const *short_opts = "rs"; +#elif HASH_ALGO_CKSUM + char const *short_opts = "a:l:bctwz"; + char const *digest_length_str = ""; +#elif HASH_ALGO_BLAKE2 + char const *short_opts = "l:bctwz"; + char const *digest_length_str = ""; +#else + char const *short_opts = "bctwz"; +#endif + + while ((opt = getopt_long (argc, argv, short_opts, long_options, NULL)) != -1) + switch (opt) + { +#if HASH_ALGO_CKSUM + case 'a': + cksum_algorithm = XARGMATCH_EXACT ("--algorithm", optarg, + algorithm_args, algorithm_types); + algorithm_specified = true; + break; + + case DEBUG_PROGRAM_OPTION: + cksum_debug = true; + break; +#endif +#if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM + case 'l': + digest_length = xdectoumax (optarg, 0, UINTMAX_MAX, "", + _("invalid length"), 0); + digest_length_str = optarg; + if (digest_length % 8 != 0) + { + error (0, 0, _("invalid length: %s"), quote (digest_length_str)); + die (EXIT_FAILURE, 0, _("length is not a multiple of 8")); + } + break; +#endif +#if !HASH_ALGO_SUM + case 'c': + do_check = true; + break; + case STATUS_OPTION: + status_only = true; + warn = false; + quiet = false; + break; +# if !HASH_ALGO_CKSUM + case 'b': + binary = 1; + break; + case 't': + binary = 0; + break; +# endif + case 'w': + status_only = false; + warn = true; + quiet = false; + break; + case IGNORE_MISSING_OPTION: + ignore_missing = true; + break; + case QUIET_OPTION: + status_only = false; + warn = false; + quiet = true; + break; + case STRICT_OPTION: + strict = true; + break; +# if HASH_ALGO_CKSUM + case UNTAG_OPTION: + prefix_tag = false; + break; +# endif + case TAG_OPTION: + prefix_tag = true; + binary = 1; + break; + case 'z': + digest_delim = '\0'; + break; +#endif +#if HASH_ALGO_SUM + case 'r': /* For SysV compatibility. */ + sum_algorithm = bsd; + break; + + case 's': + sum_algorithm = sysv; + break; +#endif + case_GETOPT_HELP_CHAR; + case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS); + default: + usage (EXIT_FAILURE); + } + + min_digest_line_length = MIN_DIGEST_LINE_LENGTH; +#if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM +# if HASH_ALGO_CKSUM + if (digest_length && cksum_algorithm != blake2b) + die (EXIT_FAILURE, 0, + _("--length is only supported with --algorithm=blake2b")); +# endif + if (digest_length > BLAKE2B_MAX_LEN * 8) + { + error (0, 0, _("invalid length: %s"), quote (digest_length_str)); + die (EXIT_FAILURE, 0, + _("maximum digest length for %s is %d bits"), + quote (DIGEST_TYPE_STRING), + BLAKE2B_MAX_LEN * 8); + } + if (digest_length == 0) + { +# if HASH_ALGO_BLAKE2 + digest_length = BLAKE2B_MAX_LEN * 8; +# else + digest_length = algorithm_bits[cksum_algorithm]; +# endif + } + digest_hex_bytes = digest_length / 4; +#else + digest_hex_bytes = DIGEST_HEX_BYTES; +#endif + +#if HASH_ALGO_CKSUM + switch (cksum_algorithm) + { + case bsd: + case sysv: + case crc: + if (do_check && algorithm_specified) + die (EXIT_FAILURE, 0, + _("--check is not supported with --algorithm={bsd,sysv,crc}")); + break; + default: + break; + } + +#endif + + if (prefix_tag && !binary) + { + /* This could be supported in a backwards compatible way + by prefixing the output line with a space in text mode. + However that's invasive enough that it was agreed to + not support this mode with --tag, as --text use cases + are adequately supported by the default output format. */ + error (0, 0, _("--tag does not support --text mode")); + usage (EXIT_FAILURE); + } + + if (digest_delim != '\n' && do_check) + { + error (0, 0, _("the --zero option is not supported when " + "verifying checksums")); + usage (EXIT_FAILURE); + } +#if !HASH_ALGO_CKSUM + if (prefix_tag && do_check) + { + error (0, 0, _("the --tag option is meaningless when " + "verifying checksums")); + usage (EXIT_FAILURE); + } +#endif + +#if !HASH_ALGO_CKSUM + if (0 <= binary && do_check) + { + error (0, 0, _("the --binary and --text options are meaningless when " + "verifying checksums")); + usage (EXIT_FAILURE); + } +#endif + + if (ignore_missing && !do_check) + { + error (0, 0, + _("the --ignore-missing option is meaningful only when " + "verifying checksums")); + usage (EXIT_FAILURE); + } + + if (status_only && !do_check) + { + error (0, 0, + _("the --status option is meaningful only when verifying checksums")); + usage (EXIT_FAILURE); + } + + if (warn && !do_check) + { + error (0, 0, + _("the --warn option is meaningful only when verifying checksums")); + usage (EXIT_FAILURE); + } + + if (quiet && !do_check) + { + error (0, 0, + _("the --quiet option is meaningful only when verifying checksums")); + usage (EXIT_FAILURE); + } + + if (strict & !do_check) + { + error (0, 0, + _("the --strict option is meaningful only when verifying checksums")); + usage (EXIT_FAILURE); + } + + if (!O_BINARY && binary < 0) + binary = 0; + + char **operand_lim = argv + argc; + if (optind == argc) + *operand_lim++ = bad_cast ("-"); + + for (char **operandp = argv + optind; operandp < operand_lim; operandp++) + { + char *file = *operandp; + if (do_check) + ok &= digest_check (file); + else + { + int binary_file = binary; + bool missing; + uintmax_t length; + + if (! digest_file (file, &binary_file, bin_buffer, &missing, &length)) + ok = false; + else + { + DIGEST_OUT (file, binary_file, bin_buffer, prefix_tag, + digest_delim, optind != argc, length); + } + } + } + + if (have_read_stdin && fclose (stdin) == EOF) + die (EXIT_FAILURE, errno, _("standard input")); + + return ok ? EXIT_SUCCESS : EXIT_FAILURE; +} |