mirror of
https://git.savannah.gnu.org/git/coreutils.git
synced 2026-11-19 03:33:43 +03:00
Previously the string from strerror would only be printed for some
algorithms:
$ cksum -a sha2 -l 256 /dev/null > /dev/full
cksum: write error: No space left on device
$ cksum -a sysv /dev/null > /dev/full
cksum: write error
This patch fixes it so that the error information is always printed:
$ ./src/cksum -a sha2 -l 256 /dev/null > /dev/full
cksum: write error: No space left on device
$ ./src/cksum -a sysv /dev/null > /dev/full
cksum: write error: No space left on device
* src/cksum.c (output_file): Don't check for a write error here.
(main): Check for it here instead.
* tests/misc/io-errors.sh: Add a 'cksum' invocation for each supported
algorithm.
https://github.com/coreutils/coreutils/issues/258
1896 lines
51 KiB
C
1896 lines
51 KiB
C
/* Compute checksums of files or strings.
|
|
Copyright (C) 1995-2026 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 "assure.h"
|
|
#include "system.h"
|
|
#include "argmatch.h"
|
|
#include "c-ctype.h"
|
|
#include "quote.h"
|
|
#include "xdectoint.h"
|
|
#include "xstrtol.h"
|
|
|
|
#ifndef HASH_ALGO_CKSUM
|
|
# define HASH_ALGO_CKSUM 0
|
|
#endif
|
|
|
|
#if HASH_ALGO_SUM || HASH_ALGO_CKSUM
|
|
# include "sum.h"
|
|
#endif
|
|
#if HASH_ALGO_CKSUM
|
|
# include "cksum.h"
|
|
# include "cksum_crc.h"
|
|
# include "base64.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 "sha3.h"
|
|
#endif
|
|
#if HASH_ALGO_CKSUM
|
|
# include "sm3.h"
|
|
#endif
|
|
#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 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_CKSUM
|
|
# define PROGRAM_NAME (!legacy_mode ? "cksum" \
|
|
: cksum_algorithm == md5 ? "md5sum" \
|
|
: cksum_algorithm == sha1 ? "sha1sum" \
|
|
: cksum_algorithm == sha224 ? "sha224sum" \
|
|
: cksum_algorithm == sha256 ? "sha256sum" \
|
|
: cksum_algorithm == sha384 ? "sha384sum" \
|
|
: cksum_algorithm == sha512 ? "sha512sum" \
|
|
: "cksum")
|
|
#endif
|
|
|
|
#if HASH_ALGO_SUM
|
|
# define AUTHORS \
|
|
proper_name ("Kayvan Aghaiepour"), \
|
|
proper_name ("David MacKenzie")
|
|
#elif HASH_ALGO_CKSUM
|
|
# define AUTHORS \
|
|
proper_name_lite ("Padraig Brady", "P\303\241draig Brady"), \
|
|
proper_name ("Q. Frank Xia")
|
|
#elif HASH_ALGO_BLAKE2
|
|
# define AUTHORS \
|
|
proper_name_lite ("Padraig Brady", "P\303\241draig 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 raw, bool tagged, unsigned char delim, bool args,
|
|
intmax_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 idx_t min_digest_line_length;
|
|
|
|
/* Set to the length of a digest hex string for the selected algorithm. */
|
|
static idx_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_CKSUM
|
|
/* If true, print base64-encoded digests, not hex. */
|
|
static bool base64_digest = false;
|
|
#endif
|
|
|
|
/* If true, print binary digests, not hex. */
|
|
static bool raw_digest = false;
|
|
|
|
/* blake2b and sha3 allow the -l option. Luckily they both have the same
|
|
maximum digest size. */
|
|
#if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
|
|
# if HASH_ALGO_CKSUM
|
|
static_assert (BLAKE2B_OUTBYTES == SHA3_512_DIGEST_SIZE);
|
|
# endif
|
|
# define DIGEST_MAX_LEN BLAKE2B_OUTBYTES
|
|
static idx_t digest_length;
|
|
#endif /* HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM */
|
|
|
|
typedef void (*digest_output_fn)(char const *, int, void const *, bool,
|
|
bool, unsigned char, bool, intmax_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, MAYBE_UNUSED intmax_t *length)
|
|
{
|
|
return md5_stream (stream, resstream);
|
|
}
|
|
static int
|
|
sha1_sum_stream (FILE *stream, void *resstream, MAYBE_UNUSED intmax_t *length)
|
|
{
|
|
return sha1_stream (stream, resstream);
|
|
}
|
|
static int
|
|
sha224_sum_stream (FILE *stream, void *resstream,
|
|
MAYBE_UNUSED intmax_t *length)
|
|
{
|
|
return sha224_stream (stream, resstream);
|
|
}
|
|
static int
|
|
sha256_sum_stream (FILE *stream, void *resstream,
|
|
MAYBE_UNUSED intmax_t *length)
|
|
{
|
|
return sha256_stream (stream, resstream);
|
|
}
|
|
static int
|
|
sha384_sum_stream (FILE *stream, void *resstream,
|
|
MAYBE_UNUSED intmax_t *length)
|
|
{
|
|
return sha384_stream (stream, resstream);
|
|
}
|
|
static int
|
|
sha512_sum_stream (FILE *stream, void *resstream,
|
|
MAYBE_UNUSED intmax_t *length)
|
|
{
|
|
return sha512_stream (stream, resstream);
|
|
}
|
|
static int
|
|
sha2_sum_stream (FILE *stream, void *resstream, intmax_t *length)
|
|
{
|
|
switch (*length)
|
|
{
|
|
case SHA224_DIGEST_SIZE:
|
|
return sha224_stream (stream, resstream);
|
|
case SHA256_DIGEST_SIZE:
|
|
return sha256_stream (stream, resstream);
|
|
case SHA384_DIGEST_SIZE:
|
|
return sha384_stream (stream, resstream);
|
|
case SHA512_DIGEST_SIZE:
|
|
return sha512_stream (stream, resstream);
|
|
default:
|
|
affirm (false);
|
|
}
|
|
}
|
|
static int
|
|
sha3_sum_stream (FILE *stream, void *resstream, intmax_t *length)
|
|
{
|
|
switch (*length)
|
|
{
|
|
case SHA3_224_DIGEST_SIZE:
|
|
return sha3_224_stream (stream, resstream);
|
|
case SHA3_256_DIGEST_SIZE:
|
|
return sha3_256_stream (stream, resstream);
|
|
case SHA3_384_DIGEST_SIZE:
|
|
return sha3_384_stream (stream, resstream);
|
|
case SHA3_512_DIGEST_SIZE:
|
|
return sha3_512_stream (stream, resstream);
|
|
default:
|
|
affirm (false);
|
|
}
|
|
}
|
|
static int
|
|
blake2b_sum_stream (FILE *stream, void *resstream, intmax_t *length)
|
|
{
|
|
return blake2b_stream (stream, resstream, *length);
|
|
}
|
|
static int
|
|
sm3_sum_stream (FILE *stream, void *resstream, MAYBE_UNUSED intmax_t *length)
|
|
{
|
|
return sm3_stream (stream, resstream);
|
|
}
|
|
|
|
static char const *const algorithm_args[] =
|
|
{
|
|
"bsd", "sysv", "crc", "crc32b", "md5", "sha1",
|
|
"sha224", "sha256", "sha384", "sha512", /* Legacy naming */
|
|
"sha2", "sha3", "blake2b", "sm3", NULL
|
|
};
|
|
static enum Algorithm const algorithm_types[] =
|
|
{
|
|
bsd, sysv, crc, crc32b, md5, sha1,
|
|
sha224, sha256, sha384, sha512,
|
|
sha2, sha3, blake2b, sm3,
|
|
};
|
|
ARGMATCH_VERIFY (algorithm_args, algorithm_types);
|
|
|
|
static char const *const algorithm_tags[] =
|
|
{
|
|
"BSD", "SYSV", "CRC", "CRC32B", "MD5", "SHA1",
|
|
"SHA224", "SHA256", "SHA384", "SHA512",
|
|
"SHA2", "SHA3", "BLAKE2b", "SM3", NULL
|
|
};
|
|
static int const algorithm_bits[] =
|
|
{
|
|
16, 16, 32, 32, 128, 160,
|
|
224, 256, 384, 512,
|
|
512, 512, 512, 256, 0
|
|
};
|
|
|
|
static_assert (countof (algorithm_bits) == countof (algorithm_args));
|
|
|
|
static bool algorithm_specified = false;
|
|
static bool legacy_mode = false;
|
|
enum Algorithm cksum_algorithm = crc;
|
|
|
|
static sumfn cksumfns[]=
|
|
{
|
|
bsd_sum_stream,
|
|
sysv_sum_stream,
|
|
crc_sum_stream,
|
|
crc32b_sum_stream,
|
|
md5_sum_stream,
|
|
sha1_sum_stream,
|
|
sha224_sum_stream,
|
|
sha256_sum_stream,
|
|
sha384_sum_stream,
|
|
sha512_sum_stream,
|
|
sha2_sum_stream,
|
|
sha3_sum_stream,
|
|
blake2b_sum_stream,
|
|
sm3_sum_stream,
|
|
};
|
|
static digest_output_fn cksum_output_fns[]=
|
|
{
|
|
output_bsd,
|
|
output_sysv,
|
|
output_crc,
|
|
output_crc,
|
|
output_file,
|
|
output_file,
|
|
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,
|
|
RAW_OPTION,
|
|
BASE64_OPTION,
|
|
};
|
|
|
|
#if HASH_ALGO_CKSUM
|
|
static struct option const legacy_long_options[] =
|
|
{
|
|
{ "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' },
|
|
|
|
{ "binary", no_argument, NULL, 'b' }, /* Deprecated. */
|
|
{ "text", no_argument, NULL, 't' }, /* Deprecated. */
|
|
|
|
{ GETOPT_HELP_OPTION_DECL },
|
|
{ GETOPT_VERSION_OPTION_DECL },
|
|
{ NULL, 0, NULL, 0 }
|
|
};
|
|
#endif
|
|
|
|
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'},
|
|
{ "base64", no_argument, NULL, BASE64_OPTION },
|
|
{ "debug", no_argument, NULL, DEBUG_PROGRAM_OPTION},
|
|
{ "raw", no_argument, NULL, RAW_OPTION},
|
|
{ "untagged", no_argument, NULL, UNTAG_OPTION },
|
|
# endif
|
|
{ "binary", no_argument, NULL, 'b' }, /* Deprecated. */
|
|
{ "text", no_argument, NULL, 't' }, /* Deprecated. */
|
|
|
|
#else
|
|
{"sysv", no_argument, NULL, 's'}, /* Not in cksum. */
|
|
#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
|
|
if (legacy_mode)
|
|
{
|
|
printf (_("\
|
|
Print or check %s checksums.\n\
|
|
"), DIGEST_TYPE_STRING);
|
|
fputs (_("\
|
|
Legacy interface to the cksum(1) utility.\n\
|
|
"), stdout);
|
|
}
|
|
else
|
|
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);
|
|
fputs (_("\
|
|
Legacy interface to the cksum(1) utility.\n\
|
|
"), stdout);
|
|
#endif
|
|
|
|
emit_stdin_note ();
|
|
#if HASH_ALGO_SUM
|
|
oputs (_("\
|
|
-r\n\
|
|
use BSD sum algorithm (the default), use 1K blocks\n\
|
|
"));
|
|
oputs (_("\
|
|
-s, --sysv\n\
|
|
use System V sum algorithm, use 512 bytes blocks\n\
|
|
"));
|
|
#endif
|
|
#if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
|
|
emit_mandatory_arg_note ();
|
|
#endif
|
|
#if HASH_ALGO_CKSUM
|
|
if (! legacy_mode)
|
|
oputs (_("\
|
|
-a, --algorithm=TYPE\n\
|
|
select the digest type to use. See DIGEST below\n\
|
|
"));
|
|
if (! legacy_mode)
|
|
oputs (_("\
|
|
--base64\n\
|
|
emit base64-encoded digests, not hexadecimal\n\
|
|
"));
|
|
#endif
|
|
#if !HASH_ALGO_SUM
|
|
# if HASH_ALGO_CKSUM
|
|
if (legacy_mode)
|
|
{
|
|
# endif
|
|
if (O_BINARY)
|
|
oputs (_("\
|
|
-b, --binary\n\
|
|
read in binary mode (default unless reading tty stdin)\n\
|
|
"));
|
|
else
|
|
oputs (_("\
|
|
-b, --binary\n\
|
|
read in binary mode\n\
|
|
"));
|
|
# if HASH_ALGO_CKSUM
|
|
}
|
|
# endif
|
|
oputs (_("\
|
|
-c, --check\n\
|
|
read checksums from the FILEs and check them\n\
|
|
"));
|
|
# if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
|
|
# if HASH_ALGO_CKSUM
|
|
if (! legacy_mode)
|
|
# endif
|
|
oputs (_("\
|
|
-l, --length=BITS\n\
|
|
digest length in bits; must not exceed the max size\n\
|
|
and must be a multiple of 8 for blake2b;\n\
|
|
must be 224, 256, 384, or 512 for sha2 or sha3\n\
|
|
"));
|
|
# endif
|
|
# if HASH_ALGO_CKSUM
|
|
if (! legacy_mode)
|
|
oputs (_("\
|
|
--raw\n\
|
|
emit a raw binary digest, not hexadecimal\n\
|
|
"));
|
|
if (legacy_mode)
|
|
oputs (_("\
|
|
--tag\n\
|
|
create a BSD-style checksum\n\
|
|
"));
|
|
else
|
|
oputs (_("\
|
|
--tag\n\
|
|
create a BSD-style checksum (the default)\n\
|
|
"));
|
|
if (! legacy_mode)
|
|
oputs (_("\
|
|
--untagged\n\
|
|
create a reversed style checksum, without digest type\n\
|
|
"));
|
|
# else
|
|
oputs (_("\
|
|
--tag\n\
|
|
create a BSD-style checksum\n\
|
|
"));
|
|
# endif
|
|
# if HASH_ALGO_CKSUM
|
|
if (legacy_mode)
|
|
{
|
|
# endif
|
|
if (O_BINARY)
|
|
oputs (_("\
|
|
-t, --text\n\
|
|
read in text mode (default if reading tty stdin)\n\
|
|
"));
|
|
else
|
|
oputs (_("\
|
|
-t, --text\n\
|
|
read in text mode (default)\n\
|
|
"));
|
|
# if HASH_ALGO_CKSUM
|
|
}
|
|
# endif
|
|
oputs (_("\
|
|
-z, --zero\n\
|
|
end each output line with NUL, not newline,\n\
|
|
and disable file name escaping\n\
|
|
"));
|
|
fputs (_("\
|
|
\n\
|
|
The following five options are useful only when verifying checksums:\n\
|
|
"), stdout);
|
|
oputs (_("\
|
|
--ignore-missing\n\
|
|
don't fail or report status for missing files\n\
|
|
"));
|
|
oputs (_("\
|
|
--quiet\n\
|
|
don't print OK for each successfully verified file\n\
|
|
"));
|
|
oputs (_("\
|
|
--status\n\
|
|
don't output anything, status code shows success\n\
|
|
"));
|
|
oputs (_("\
|
|
--strict\n\
|
|
exit non-zero for improperly formatted checksum lines\n\
|
|
"));
|
|
oputs (_("\
|
|
-w, --warn\n\
|
|
warn about improperly formatted checksum lines\n\
|
|
"));
|
|
#endif
|
|
#if HASH_ALGO_CKSUM
|
|
if (! legacy_mode)
|
|
oputs (_("\
|
|
--debug\n\
|
|
indicate which implementation used\n\
|
|
"));
|
|
#endif
|
|
oputs (HELP_OPTION_DESCRIPTION);
|
|
oputs (VERSION_OPTION_DESCRIPTION);
|
|
#if HASH_ALGO_CKSUM
|
|
if (! legacy_mode)
|
|
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\
|
|
crc32b (only available through cksum)\n\
|
|
md5 (equivalent to md5sum)\n\
|
|
sha1 (equivalent to sha1sum)\n\
|
|
sha2 (equivalent to sha{224,256,384,512}sum)\n\
|
|
sha3 (only available through cksum)\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\
|
|
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);
|
|
}
|
|
|
|
#if !HASH_ALGO_SUM
|
|
/* Given a string S, return TRUE if it contains problematic characters
|
|
that need escaping. Note we escape '\' itself to provide some forward
|
|
compat to introduce escaping of other characters. */
|
|
|
|
ATTRIBUTE_PURE
|
|
static bool
|
|
problematic_chars (char const *s)
|
|
{
|
|
idx_t length = strcspn (s, "\\\n\r");
|
|
return s[length] != '\0';
|
|
}
|
|
#endif
|
|
|
|
/* 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, idx_t s_len)
|
|
{
|
|
char *dst = s;
|
|
|
|
for (idx_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 LEN-byte NUL-terminated string of hex or base64
|
|
digits and has the expected length. Otherwise, return false. */
|
|
ATTRIBUTE_PURE
|
|
static bool
|
|
valid_digits (unsigned char const *s, idx_t len)
|
|
{
|
|
#if HASH_ALGO_CKSUM
|
|
if (len == BASE64_LENGTH (digest_length >> 3))
|
|
{
|
|
idx_t i;
|
|
for (i = 0; i < len - digest_length % 3; i++)
|
|
{
|
|
if (!isbase64 (*s))
|
|
return false;
|
|
++s;
|
|
}
|
|
for ( ; i < len; i++)
|
|
{
|
|
if (*s != '=')
|
|
return false;
|
|
++s;
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
if (len == digest_hex_bytes)
|
|
{
|
|
for (idx_t i = 0; i < digest_hex_bytes; i++)
|
|
{
|
|
if (!c_isxdigit (*s))
|
|
return false;
|
|
++s;
|
|
}
|
|
}
|
|
else
|
|
return false;
|
|
|
|
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. Set *D_LEN to the length of the digest string.
|
|
Return true if successful. */
|
|
|
|
static bool
|
|
bsd_split_3 (char *s, idx_t s_len,
|
|
unsigned char **digest, idx_t *d_len,
|
|
char **file_name, bool escaped_filename)
|
|
{
|
|
if (s_len == 0)
|
|
return false;
|
|
|
|
/* Find end of filename. */
|
|
idx_t 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 (c_isblank (s[i]))
|
|
i++;
|
|
|
|
if (s[i] != '=')
|
|
return false;
|
|
|
|
i++;
|
|
|
|
while (c_isblank (s[i]))
|
|
i++;
|
|
|
|
*digest = (unsigned char *) &s[i];
|
|
|
|
*d_len = s_len - i;
|
|
return valid_digits (*digest, *d_len);
|
|
}
|
|
|
|
#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 idx_t max_tag_len;
|
|
if (! max_tag_len)
|
|
{
|
|
char const * const * tag = algorithm_tags;
|
|
while (*tag)
|
|
{
|
|
idx_t tag_len = strlen (*tag++);
|
|
max_tag_len = MAX (tag_len, max_tag_len);
|
|
}
|
|
}
|
|
|
|
idx_t i = 0;
|
|
|
|
/* Find end of tag */
|
|
while (i <= max_tag_len && s[i] && ! c_isblank (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. Set *D_LEN to the length of the digest string.
|
|
Return true if successful. */
|
|
|
|
static bool
|
|
split_3 (char *s, idx_t s_len,
|
|
unsigned char **digest, idx_t *d_len, int *binary, char **file_name)
|
|
{
|
|
bool escaped_filename = false;
|
|
idx_t algo_name_len;
|
|
|
|
idx_t i = 0;
|
|
while (c_isblank (s[i]))
|
|
++i;
|
|
|
|
if (s[i] == '\\')
|
|
{
|
|
++i;
|
|
escaped_filename = true;
|
|
}
|
|
|
|
/* Check for BSD-style checksum line. */
|
|
|
|
#if HASH_ALGO_CKSUM
|
|
if (! algorithm_specified || cksum_algorithm == sha2)
|
|
{
|
|
ptrdiff_t algo_tag = algorithm_from_tag (s + i);
|
|
if (! algorithm_specified)
|
|
{
|
|
if (algo_tag >= 0)
|
|
{
|
|
if (algo_tag <= crc32b)
|
|
return false; /* We don't support checking these formats. */
|
|
cksum_algorithm = algo_tag;
|
|
}
|
|
else
|
|
return false; /* We only support tagged format without -a. */
|
|
}
|
|
else
|
|
{
|
|
if (cksum_algorithm == sha2 && (algo_tag == sha2
|
|
|| algo_tag == sha224 || algo_tag == sha256
|
|
|| algo_tag == sha384 || algo_tag == sha512))
|
|
cksum_algorithm = algo_tag;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* Try to parse BSD or OpenSSL tagged format. I.e.:
|
|
openssl: MD5(f)= d41d8cd98f00b204e9800998ecf8427e
|
|
bsd: MD5 (f) = d41d8cd98f00b204e9800998ecf8427e */
|
|
|
|
idx_t parse_offset = i;
|
|
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
|
|
|
|
# if HASH_ALGO_BLAKE2
|
|
digest_length = DIGEST_MAX_LEN * 8;
|
|
# else
|
|
digest_length = algorithm_bits[cksum_algorithm];
|
|
# endif
|
|
if (s[i] == '-') /* length specified. Not base64 */
|
|
{
|
|
++i;
|
|
intmax_t length;
|
|
char *siend;
|
|
if (!c_isdigit (s[i])
|
|
|| xstrtoimax (s + i, &siend, 0, &length, NULL) != LONGINT_OK)
|
|
return false;
|
|
# if HASH_ALGO_CKSUM
|
|
else if (cksum_algorithm == sha2 || cksum_algorithm == sha3)
|
|
{
|
|
if (length != SHA224_DIGEST_SIZE * 8
|
|
&& length != SHA256_DIGEST_SIZE * 8
|
|
&& length != SHA384_DIGEST_SIZE * 8
|
|
&& length != SHA512_DIGEST_SIZE * 8)
|
|
return false;
|
|
}
|
|
# endif
|
|
else if (!(0 < length && length <= digest_length && length % 8 == 0))
|
|
return false;
|
|
|
|
i = siend - s;
|
|
digest_length = length;
|
|
}
|
|
digest_hex_bytes = digest_length >> 2;
|
|
#endif
|
|
if (s[i] == ' ')
|
|
++i;
|
|
if (s[i] == '(') /* not base64 */
|
|
{
|
|
++i;
|
|
*binary = 0;
|
|
return bsd_split_3 (s + i, s_len - i,
|
|
digest, d_len, file_name, escaped_filename);
|
|
}
|
|
|
|
/* Note with --base64 --untagged format, we may have matched a "tag".
|
|
Even very short digests with: cksum -a blake2b -l24 --untagged --base64
|
|
So fallback to checking untagged format if issues detecting tags. */
|
|
i = parse_offset;
|
|
}
|
|
|
|
/* 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;
|
|
|
|
*digest = (unsigned char *) &s[i];
|
|
|
|
#if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
|
|
/* Auto determine length. */
|
|
# if HASH_ALGO_CKSUM
|
|
if (cksum_algorithm == blake2b
|
|
|| cksum_algorithm == sha2 || cksum_algorithm == sha3) {
|
|
# endif
|
|
unsigned char const *hp = *digest;
|
|
digest_hex_bytes = 0;
|
|
for (; c_isxdigit (*hp); ++hp, ++digest_hex_bytes)
|
|
;
|
|
# if HASH_ALGO_CKSUM
|
|
/* Check the number of base64 characters. This works because the hexadecimal
|
|
character set is a subset of the base64 character set.
|
|
Note there is the ambiguity that all characters are hex when they
|
|
are actually base64 encoded, which could be ambiguous with:
|
|
cksum -a sha2 -l 384 --base64 --untagged
|
|
cksum -a sha2 -l 256 --untagged
|
|
Similarly for sha3 and blake2b.
|
|
However at this length the chances are exceedingly rare (1 in 480R),
|
|
and smaller blake2b lengths aren't practical for verification anyway. */
|
|
idx_t digest_base64_bytes = digest_hex_bytes;
|
|
idx_t trailing_equals = 0;
|
|
for (; isubase64 (*hp); ++hp, ++digest_base64_bytes)
|
|
;
|
|
for (; *hp == '='; ++hp, ++trailing_equals)
|
|
;
|
|
if ((cksum_algorithm == sha2 || cksum_algorithm == sha3)
|
|
&& digest_hex_bytes >> 1 != SHA224_DIGEST_SIZE
|
|
&& digest_hex_bytes >> 1 != SHA256_DIGEST_SIZE
|
|
&& digest_hex_bytes >> 1 != SHA384_DIGEST_SIZE
|
|
&& digest_hex_bytes >> 1 != SHA512_DIGEST_SIZE)
|
|
{
|
|
if (digest_base64_bytes + trailing_equals
|
|
== BASE64_LENGTH (SHA224_DIGEST_SIZE))
|
|
digest_hex_bytes = SHA224_DIGEST_SIZE * 2;
|
|
else if (digest_base64_bytes + trailing_equals
|
|
== BASE64_LENGTH (SHA256_DIGEST_SIZE))
|
|
digest_hex_bytes = SHA256_DIGEST_SIZE * 2;
|
|
else if (digest_base64_bytes + trailing_equals
|
|
== BASE64_LENGTH (SHA384_DIGEST_SIZE))
|
|
digest_hex_bytes = SHA384_DIGEST_SIZE * 2;
|
|
else if (digest_base64_bytes + trailing_equals
|
|
== BASE64_LENGTH (SHA512_DIGEST_SIZE))
|
|
digest_hex_bytes = SHA512_DIGEST_SIZE * 2;
|
|
else
|
|
return false;
|
|
}
|
|
else if (cksum_algorithm == blake2b
|
|
&& digest_hex_bytes < digest_base64_bytes)
|
|
{
|
|
for (int j = 8; j <= DIGEST_MAX_LEN * 8; j += 8)
|
|
{
|
|
if (BASE64_LENGTH (j / 8) == digest_base64_bytes + trailing_equals
|
|
&& j % 3 == trailing_equals)
|
|
{
|
|
digest_hex_bytes = j / 4;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
# endif
|
|
if (digest_hex_bytes < 2 || digest_hex_bytes % 2
|
|
|| DIGEST_MAX_LEN * 2 < digest_hex_bytes)
|
|
return false;
|
|
digest_length = digest_hex_bytes * 4;
|
|
# if HASH_ALGO_CKSUM
|
|
}
|
|
# endif
|
|
#endif
|
|
|
|
/* This field must be the hexadecimal or base64 representation
|
|
of the message digest. */
|
|
while (s[i] && !c_isblank (s[i]))
|
|
i++;
|
|
|
|
/* The digest must be followed by at least one whitespace character. */
|
|
if (i == s_len)
|
|
return false;
|
|
|
|
*d_len = &s[i] - (char *) *digest;
|
|
s[i++] = '\0';
|
|
|
|
if (! valid_digits (*digest, *d_len))
|
|
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 !HASH_ALGO_SUM
|
|
/* 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++;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* 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 intmax_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" : "rt") : "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
|
|
|| cksum_algorithm == sha2 || cksum_algorithm == sha3)
|
|
*length = digest_length >> 3;
|
|
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 >> 3);
|
|
#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,
|
|
MAYBE_UNUSED bool raw, bool tagged, unsigned char delim,
|
|
MAYBE_UNUSED bool args, MAYBE_UNUSED intmax_t length)
|
|
{
|
|
# if HASH_ALGO_CKSUM
|
|
if (raw)
|
|
{
|
|
fwrite (digest, 1, digest_length >> 3, stdout);
|
|
return;
|
|
}
|
|
# endif
|
|
|
|
unsigned char const *bin_buffer = digest;
|
|
|
|
/* Output a leading backslash if the file name contains problematic chars. */
|
|
bool needs_escape = delim == '\n' && problematic_chars (file);
|
|
|
|
if (needs_escape)
|
|
putchar ('\\');
|
|
|
|
if (tagged)
|
|
{
|
|
# if HASH_ALGO_CKSUM
|
|
if (cksum_algorithm == sha2)
|
|
printf ("SHA%u", (unsigned int) digest_length);
|
|
else
|
|
# endif
|
|
fputs (DIGEST_TYPE_STRING, stdout);
|
|
# if HASH_ALGO_BLAKE2
|
|
if (digest_length < DIGEST_MAX_LEN * 8)
|
|
printf ("-%u", (unsigned int) digest_length);
|
|
# elif HASH_ALGO_CKSUM
|
|
if (cksum_algorithm == sha3)
|
|
printf ("-%u", (unsigned int) digest_length);
|
|
if (cksum_algorithm == blake2b)
|
|
{
|
|
if (digest_length < DIGEST_MAX_LEN * 8)
|
|
printf ("-%u", (unsigned int) digest_length);
|
|
}
|
|
# endif
|
|
fputs (" (", stdout);
|
|
print_filename (file, needs_escape);
|
|
fputs (") = ", stdout);
|
|
}
|
|
|
|
# if HASH_ALGO_CKSUM
|
|
if (base64_digest)
|
|
{
|
|
char b64[BASE64_LENGTH (DIGEST_BIN_BYTES) + 1];
|
|
base64_encode ((char const *) bin_buffer, digest_length >> 3,
|
|
b64, sizeof b64);
|
|
fputs (b64, stdout);
|
|
}
|
|
else
|
|
# endif
|
|
{
|
|
for (idx_t i = 0; i < (digest_hex_bytes >> 1); ++i)
|
|
printf ("%02x", bin_buffer[i]);
|
|
}
|
|
|
|
if (!tagged)
|
|
{
|
|
putchar (' ');
|
|
putchar (binary_file ? '*' : ' ');
|
|
print_filename (file, needs_escape);
|
|
}
|
|
|
|
putchar (delim);
|
|
}
|
|
#endif
|
|
|
|
#if HASH_ALGO_CKSUM
|
|
/* Return true if B64_DIGEST is the same as the base64 digest of the
|
|
DIGEST_LENGTH/8 bytes at BIN_BUFFER. */
|
|
static bool
|
|
b64_equal (unsigned char const *b64_digest, unsigned char const *bin_buffer)
|
|
{
|
|
idx_t b64_n_bytes = BASE64_LENGTH (digest_length >> 3);
|
|
char b64[BASE64_LENGTH (DIGEST_BIN_BYTES) + 1];
|
|
base64_encode ((char const *) bin_buffer, digest_length >> 3,
|
|
b64, sizeof b64);
|
|
return memeq (b64_digest, b64, b64_n_bytes + 1);
|
|
}
|
|
#endif
|
|
|
|
/* Return true if HEX_DIGEST is the same as the hex-encoded digest of the
|
|
DIGEST_LENGTH/8 bytes at BIN_BUFFER. */
|
|
static bool
|
|
hex_equal (unsigned char const *hex_digest, unsigned char const *bin_buffer)
|
|
{
|
|
static const char bin2hex[] = { '0', '1', '2', '3',
|
|
'4', '5', '6', '7',
|
|
'8', '9', 'a', 'b',
|
|
'c', 'd', 'e', 'f' };
|
|
idx_t digest_bin_bytes = digest_hex_bytes >> 1;
|
|
|
|
/* Compare generated binary number with text representation
|
|
in check file. Ignore case of hex digits. */
|
|
idx_t cnt;
|
|
for (cnt = 0; cnt < digest_bin_bytes; ++cnt)
|
|
{
|
|
if (c_tolower (hex_digest[2 * cnt])
|
|
!= bin2hex[bin_buffer[cnt] >> 4]
|
|
|| (c_tolower (hex_digest[2 * cnt + 1])
|
|
!= (bin2hex[bin_buffer[cnt] & 0xf])))
|
|
break;
|
|
}
|
|
return cnt == digest_bin_bytes;
|
|
}
|
|
|
|
static bool
|
|
digest_check (char const *checkfile_name)
|
|
{
|
|
FILE *checkfile_stream;
|
|
intmax_t n_misformatted_lines = 0;
|
|
intmax_t n_mismatched_checksums = 0;
|
|
intmax_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);
|
|
intmax_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 *digest;
|
|
ssize_t line_length;
|
|
|
|
++line_number;
|
|
if (line_number == 0)
|
|
error (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';
|
|
|
|
idx_t d_len;
|
|
if (! (split_3 (line, line_length, &digest, &d_len, &binary, &filename)
|
|
&& ! (is_stdin && streq (filename, "-"))))
|
|
{
|
|
++n_misformatted_lines;
|
|
|
|
if (warn)
|
|
{
|
|
error (0, 0,
|
|
_("%s: %jd"
|
|
": improperly formatted %s checksum line"),
|
|
quotef (checkfile_name), line_number,
|
|
DIGEST_TYPE_STRING);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool ok;
|
|
bool missing;
|
|
|
|
properly_formatted_lines = true;
|
|
|
|
intmax_t length;
|
|
ok = digest_file (filename, &binary, bin_buffer, &missing, &length);
|
|
|
|
if (!ok)
|
|
{
|
|
++n_open_or_read_failures;
|
|
if (!status_only)
|
|
printf ("%s: %s\n", quotef (filename),_("FAILED open or read"));
|
|
}
|
|
else if (ignore_missing && missing)
|
|
{
|
|
/* Ignore missing files with --ignore-missing. */
|
|
;
|
|
}
|
|
else
|
|
{
|
|
bool match = false;
|
|
#if HASH_ALGO_CKSUM
|
|
if (d_len == BASE64_LENGTH (digest_length >> 3))
|
|
match = b64_equal (digest, bin_buffer);
|
|
else
|
|
#endif
|
|
if (d_len == digest_hex_bytes)
|
|
match = hex_equal (digest, bin_buffer);
|
|
|
|
if (match)
|
|
matched_checksums = true;
|
|
else
|
|
++n_mismatched_checksums;
|
|
|
|
if (!status_only)
|
|
{
|
|
if (! match || ! quiet)
|
|
fputs (quotef (filename), stdout);
|
|
|
|
if (! match)
|
|
printf (": %s\n", _("FAILED"));
|
|
else if (!quiet)
|
|
printf (": %s\n", _("OK"));
|
|
}
|
|
}
|
|
|
|
if (ferror (stdout))
|
|
write_error ();
|
|
}
|
|
}
|
|
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: %jd line is improperly formatted",
|
|
"WARNING: %jd lines are improperly formatted",
|
|
select_plural (n_misformatted_lines))),
|
|
n_misformatted_lines);
|
|
|
|
if (n_open_or_read_failures != 0)
|
|
error (0, 0,
|
|
(ngettext
|
|
("WARNING: %jd listed file could not be read",
|
|
"WARNING: %jd 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: %jd computed checksum did NOT match",
|
|
"WARNING: %jd 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_misformatted_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;
|
|
int binary = -1;
|
|
int prefix_tag = -1;
|
|
struct option const *long_opts = long_options;
|
|
|
|
#if HASH_ALGO_CKSUM
|
|
if (cksum_algorithm != crc)
|
|
{
|
|
legacy_mode = true;
|
|
prefix_tag = 0;
|
|
algorithm_specified = true;
|
|
long_opts = legacy_long_options;
|
|
}
|
|
#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 = legacy_mode ? "bctwz" : "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_opts, 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 = xnumtoimax (optarg, 10, 0, IDX_MAX, "",
|
|
_("invalid length"), 0,
|
|
XTOINT_MAX_QUIET);
|
|
digest_length_str = optarg;
|
|
break;
|
|
#endif
|
|
#if !HASH_ALGO_SUM
|
|
case 'c':
|
|
do_check = true;
|
|
break;
|
|
case STATUS_OPTION:
|
|
status_only = true;
|
|
warn = false;
|
|
quiet = false;
|
|
break;
|
|
case 'b':
|
|
binary = 1;
|
|
break;
|
|
case 't':
|
|
binary = 0;
|
|
break;
|
|
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 BASE64_OPTION:
|
|
base64_digest = true;
|
|
break;
|
|
case RAW_OPTION:
|
|
raw_digest = true;
|
|
break;
|
|
case UNTAG_OPTION:
|
|
prefix_tag = 0;
|
|
break;
|
|
# endif
|
|
case TAG_OPTION:
|
|
prefix_tag = 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
|
|
&& cksum_algorithm != sha2
|
|
&& cksum_algorithm != sha3))
|
|
error (EXIT_FAILURE, 0,
|
|
_("--length is only supported with --algorithm "
|
|
"blake2b, sha2, or sha3"));
|
|
if (cksum_algorithm == sha2 || cksum_algorithm == sha3)
|
|
{
|
|
/* Do not require --length with --check. */
|
|
if (digest_length == 0 && *digest_length_str == '\0' && ! do_check)
|
|
error (EXIT_FAILURE, 0, _("--algorithm=%s requires specifying "
|
|
"--length 224, 256, 384, or 512"),
|
|
algorithm_args[cksum_algorithm]);
|
|
/* If --check and --length are used we verify the digest length. */
|
|
if ((! do_check || *digest_length_str != '\0')
|
|
&& digest_length != SHA224_DIGEST_SIZE * 8
|
|
&& digest_length != SHA256_DIGEST_SIZE * 8
|
|
&& digest_length != SHA384_DIGEST_SIZE * 8
|
|
&& digest_length != SHA512_DIGEST_SIZE * 8)
|
|
{
|
|
error (0, 0, _("invalid length: %s"), quote (digest_length_str));
|
|
error (EXIT_FAILURE, 0, _("digest length for %s must be "
|
|
"224, 256, 384, or 512"),
|
|
quote (DIGEST_TYPE_STRING));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* If the digest length checks for SHA-3 are satisfied, the less strict
|
|
checks for BLAKE2 will also be. */
|
|
# else
|
|
{
|
|
# endif
|
|
if (digest_length > DIGEST_MAX_LEN * 8)
|
|
{
|
|
error (0, 0, _("invalid length: %s"), quote (digest_length_str));
|
|
error (EXIT_FAILURE, 0,
|
|
_("maximum digest length for %s is %d bits"),
|
|
quote (DIGEST_TYPE_STRING),
|
|
DIGEST_MAX_LEN * 8);
|
|
}
|
|
if (digest_length % 8 != 0)
|
|
{
|
|
error (0, 0, _("invalid length: %s"), quote (digest_length_str));
|
|
error (EXIT_FAILURE, 0, _("length is not a multiple of 8"));
|
|
}
|
|
}
|
|
if (digest_length == 0)
|
|
{
|
|
# if HASH_ALGO_BLAKE2
|
|
digest_length = DIGEST_MAX_LEN * 8;
|
|
# else
|
|
digest_length = algorithm_bits[cksum_algorithm];
|
|
# endif
|
|
}
|
|
digest_hex_bytes = digest_length >> 2;
|
|
#else
|
|
digest_hex_bytes = DIGEST_HEX_BYTES;
|
|
#endif
|
|
|
|
#if HASH_ALGO_CKSUM
|
|
switch (+cksum_algorithm)
|
|
{
|
|
case bsd:
|
|
case sysv:
|
|
case crc:
|
|
case crc32b:
|
|
if (do_check && algorithm_specified)
|
|
error (EXIT_FAILURE, 0,
|
|
_("--check is not supported with "
|
|
"--algorithm={bsd,sysv,crc,crc32b}"));
|
|
break;
|
|
}
|
|
|
|
if (base64_digest && raw_digest)
|
|
{
|
|
error (0, 0, _("--base64 and --raw are mutually exclusive"));
|
|
usage (EXIT_FAILURE);
|
|
}
|
|
#endif
|
|
|
|
if (digest_delim != '\n' && do_check)
|
|
{
|
|
error (0, 0, _("the --zero option is not supported when "
|
|
"verifying checksums"));
|
|
usage (EXIT_FAILURE);
|
|
}
|
|
if (1 <= prefix_tag && do_check)
|
|
{
|
|
/* Note we allow --untagged with --check to more
|
|
seamlessly support --untagged in an emulation wrapper. */
|
|
error (0, 0, _("the --tag option is meaningless when "
|
|
"verifying checksums"));
|
|
usage (EXIT_FAILURE);
|
|
}
|
|
|
|
if (0 <= binary && do_check)
|
|
{
|
|
error (0, 0, _("the --binary and --text options are meaningless when "
|
|
"verifying checksums"));
|
|
usage (EXIT_FAILURE);
|
|
}
|
|
|
|
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 (prefix_tag == -1)
|
|
prefix_tag = HASH_ALGO_CKSUM;
|
|
|
|
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. */
|
|
#if !HASH_ALGO_CKSUM
|
|
error (0, 0, _("--tag does not support --text mode"));
|
|
#else
|
|
error (0, 0, _("--text mode is only supported with --untagged"));
|
|
#endif
|
|
usage (EXIT_FAILURE);
|
|
}
|
|
|
|
if (!O_BINARY && binary < 0)
|
|
binary = 0;
|
|
else if (prefix_tag)
|
|
binary = 1;
|
|
|
|
char **operand_lim = argv + argc;
|
|
if (optind == argc)
|
|
*operand_lim++ = bad_cast ("-");
|
|
else if (1 < argc - optind && raw_digest)
|
|
error (EXIT_FAILURE, 0,
|
|
_("the --raw option is not supported with multiple files"));
|
|
|
|
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;
|
|
intmax_t length;
|
|
|
|
if (! digest_file (file, &binary_file, bin_buffer, &missing, &length))
|
|
ok = false;
|
|
else
|
|
{
|
|
DIGEST_OUT (file, binary_file, bin_buffer, raw_digest, prefix_tag,
|
|
digest_delim, optind != argc, length);
|
|
if (ferror (stdout))
|
|
write_error ();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (have_read_stdin && fclose (stdin) == EOF)
|
|
error (EXIT_FAILURE, errno, _("standard input"));
|
|
|
|
return ok ? EXIT_SUCCESS : EXIT_FAILURE;
|
|
}
|