1 /* Compute checksums of files or strings.
2 Copyright (C) 1995-2023 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
17 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>. */
22 #include <sys/types.h>
27 #include "xdectoint.h"
30 #if HASH_ALGO_SUM || HASH_ALGO_CKSUM
37 #if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
38 # include "blake2/b2sum.h"
40 #if HASH_ALGO_MD5 || HASH_ALGO_CKSUM
43 #if HASH_ALGO_SHA1 || HASH_ALGO_CKSUM
46 #if HASH_ALGO_SHA256 || HASH_ALGO_SHA224 || HASH_ALGO_CKSUM
49 #if HASH_ALGO_SHA512 || HASH_ALGO_SHA384 || HASH_ALGO_CKSUM
59 #include "xbinary-io.h"
61 /* The official name of this program (e.g., no 'g' prefix). */
63 # define PROGRAM_NAME "sum"
64 # define DIGEST_TYPE_STRING "BSD"
65 # define DIGEST_STREAM sumfns[sum_algorithm]
66 # define DIGEST_OUT sum_output_fns[sum_algorithm]
67 # define DIGEST_BITS 16
68 # define DIGEST_ALIGN 4
70 # define MAX_DIGEST_BITS 512
71 # define MAX_DIGEST_ALIGN 8
72 # define PROGRAM_NAME "cksum"
73 # define DIGEST_TYPE_STRING algorithm_tags[cksum_algorithm]
74 # define DIGEST_STREAM cksumfns[cksum_algorithm]
75 # define DIGEST_OUT cksum_output_fns[cksum_algorithm]
76 # define DIGEST_BITS MAX_DIGEST_BITS
77 # define DIGEST_ALIGN MAX_DIGEST_ALIGN
79 # define PROGRAM_NAME "md5sum"
80 # define DIGEST_TYPE_STRING "MD5"
81 # define DIGEST_STREAM md5_stream
82 # define DIGEST_BITS 128
83 # define DIGEST_REFERENCE "RFC 1321"
84 # define DIGEST_ALIGN 4
85 #elif HASH_ALGO_BLAKE2
86 # define PROGRAM_NAME "b2sum"
87 # define DIGEST_TYPE_STRING "BLAKE2b"
88 # define DIGEST_STREAM blake2b_stream
89 # define DIGEST_BITS 512
90 # define DIGEST_REFERENCE "RFC 7693"
91 # define DIGEST_ALIGN 8
93 # define PROGRAM_NAME "sha1sum"
94 # define DIGEST_TYPE_STRING "SHA1"
95 # define DIGEST_STREAM sha1_stream
96 # define DIGEST_BITS 160
97 # define DIGEST_REFERENCE "FIPS-180-1"
98 # define DIGEST_ALIGN 4
99 #elif HASH_ALGO_SHA256
100 # define PROGRAM_NAME "sha256sum"
101 # define DIGEST_TYPE_STRING "SHA256"
102 # define DIGEST_STREAM sha256_stream
103 # define DIGEST_BITS 256
104 # define DIGEST_REFERENCE "FIPS-180-2"
105 # define DIGEST_ALIGN 4
106 #elif HASH_ALGO_SHA224
107 # define PROGRAM_NAME "sha224sum"
108 # define DIGEST_TYPE_STRING "SHA224"
109 # define DIGEST_STREAM sha224_stream
110 # define DIGEST_BITS 224
111 # define DIGEST_REFERENCE "RFC 3874"
112 # define DIGEST_ALIGN 4
113 #elif HASH_ALGO_SHA512
114 # define PROGRAM_NAME "sha512sum"
115 # define DIGEST_TYPE_STRING "SHA512"
116 # define DIGEST_STREAM sha512_stream
117 # define DIGEST_BITS 512
118 # define DIGEST_REFERENCE "FIPS-180-2"
119 # define DIGEST_ALIGN 8
120 #elif HASH_ALGO_SHA384
121 # define PROGRAM_NAME "sha384sum"
122 # define DIGEST_TYPE_STRING "SHA384"
123 # define DIGEST_STREAM sha384_stream
124 # define DIGEST_BITS 384
125 # define DIGEST_REFERENCE "FIPS-180-2"
126 # define DIGEST_ALIGN 8
128 # error "Can't decide which hash algorithm to compile."
130 #if !HASH_ALGO_SUM && !HASH_ALGO_CKSUM
131 # define DIGEST_OUT output_file
136 proper_name ("Kayvan Aghaiepour"), \
137 proper_name ("David MacKenzie")
138 #elif HASH_ALGO_CKSUM
140 proper_name ("Padraig Brady"), \
141 proper_name ("Q. Frank Xia")
142 #elif HASH_ALGO_BLAKE2
144 proper_name ("Padraig Brady"), \
145 proper_name ("Samuel Neves")
148 proper_name ("Ulrich Drepper"), \
149 proper_name ("Scott Miller"), \
150 proper_name ("David Madore")
152 #if !HASH_ALGO_BLAKE2 && !HASH_ALGO_CKSUM
153 # define DIGEST_HEX_BYTES (DIGEST_BITS / 4)
155 #define DIGEST_BIN_BYTES (DIGEST_BITS / 8)
157 /* The minimum length of a valid digest line. This length does
158 not include any newline character at the end of a line. */
159 #if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
160 # define MIN_DIGEST_LINE_LENGTH 3 /* With -l 8. */
162 # define MIN_DIGEST_LINE_LENGTH \
163 (DIGEST_HEX_BYTES /* length of hexadecimal message digest */ \
165 + 1 /* minimum filename length */ )
170 output_file (char const *file
, int binary_file
, void const *digest
,
171 bool raw
, bool tagged
, unsigned char delim
, bool args
,
175 /* True if any of the files read were the standard input. */
176 static bool have_read_stdin
;
178 /* The minimum length of a valid checksum line for the selected algorithm. */
179 static size_t min_digest_line_length
;
181 /* Set to the length of a digest hex string for the selected algorithm. */
182 static size_t digest_hex_bytes
;
184 /* With --check, don't generate any output.
185 The exit code indicates success or failure. */
186 static bool status_only
= false;
188 /* With --check, print a message to standard error warning about each
189 improperly formatted checksum line. */
190 static bool warn
= false;
192 /* With --check, ignore missing files. */
193 static bool ignore_missing
= false;
195 /* With --check, suppress the "OK" printed for each verified file. */
196 static bool quiet
= false;
198 /* With --check, exit with a non-zero return code if any line is
199 improperly formatted. */
200 static bool strict
= false;
202 /* Whether a BSD reversed format checksum is detected. */
203 static int bsd_reversed
= -1;
205 /* line delimiter. */
206 static unsigned char digest_delim
= '\n';
209 /* If true, print base64-encoded digests, not hex. */
210 static bool base64_digest
= false;
213 /* If true, print binary digests, not hex. */
214 static bool raw_digest
= false;
216 #if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
217 # define BLAKE2B_MAX_LEN BLAKE2B_OUTBYTES
218 static uintmax_t digest_length
;
219 #endif /* HASH_ALGO_BLAKE2 */
221 typedef void (*digest_output_fn
)(char const *, int, void const *, bool,
222 bool, unsigned char, bool, uintmax_t);
230 static enum Algorithm sum_algorithm
;
231 static sumfn sumfns
[]=
236 static digest_output_fn sum_output_fns
[]=
245 md5_sum_stream (FILE *stream
, void *resstream
, uintmax_t *length
)
247 return md5_stream (stream
, resstream
);
250 sha1_sum_stream (FILE *stream
, void *resstream
, uintmax_t *length
)
252 return sha1_stream (stream
, resstream
);
255 sha224_sum_stream (FILE *stream
, void *resstream
, uintmax_t *length
)
257 return sha224_stream (stream
, resstream
);
260 sha256_sum_stream (FILE *stream
, void *resstream
, uintmax_t *length
)
262 return sha256_stream (stream
, resstream
);
265 sha384_sum_stream (FILE *stream
, void *resstream
, uintmax_t *length
)
267 return sha384_stream (stream
, resstream
);
270 sha512_sum_stream (FILE *stream
, void *resstream
, uintmax_t *length
)
272 return sha512_stream (stream
, resstream
);
275 blake2b_sum_stream (FILE *stream
, void *resstream
, uintmax_t *length
)
277 return blake2b_stream (stream
, resstream
, *length
);
280 sm3_sum_stream (FILE *stream
, void *resstream
, uintmax_t *length
)
282 return sm3_stream (stream
, resstream
);
300 static char const *const algorithm_args
[] =
302 "bsd", "sysv", "crc", "md5", "sha1", "sha224",
303 "sha256", "sha384", "sha512", "blake2b", "sm3", NULL
305 static enum Algorithm
const algorithm_types
[] =
307 bsd
, sysv
, crc
, md5
, sha1
, sha224
,
308 sha256
, sha384
, sha512
, blake2b
, sm3
,
310 ARGMATCH_VERIFY (algorithm_args
, algorithm_types
);
312 static char const *const algorithm_tags
[] =
314 "BSD", "SYSV", "CRC", "MD5", "SHA1", "SHA224",
315 "SHA256", "SHA384", "SHA512", "BLAKE2b", "SM3", NULL
317 static int const algorithm_bits
[] =
319 16, 16, 32, 128, 160, 224,
320 256, 384, 512, 512, 256, 0
323 static_assert (ARRAY_CARDINALITY (algorithm_bits
)
324 == ARRAY_CARDINALITY (algorithm_args
));
326 static bool algorithm_specified
= false;
327 static enum Algorithm cksum_algorithm
= crc
;
328 static sumfn cksumfns
[]=
342 static digest_output_fn cksum_output_fns
[]=
359 /* For long options that have no equivalent short option, use a
360 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
364 IGNORE_MISSING_OPTION
= CHAR_MAX
+ 1,
370 DEBUG_PROGRAM_OPTION
,
374 static struct option
const long_options
[] =
376 #if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
377 { "length", required_argument
, NULL
, 'l'},
381 { "check", no_argument
, NULL
, 'c' },
382 { "ignore-missing", no_argument
, NULL
, IGNORE_MISSING_OPTION
},
383 { "quiet", no_argument
, NULL
, QUIET_OPTION
},
384 { "status", no_argument
, NULL
, STATUS_OPTION
},
385 { "warn", no_argument
, NULL
, 'w' },
386 { "strict", no_argument
, NULL
, STRICT_OPTION
},
387 { "tag", no_argument
, NULL
, TAG_OPTION
},
388 { "zero", no_argument
, NULL
, 'z' },
391 { "algorithm", required_argument
, NULL
, 'a'},
392 { "base64", no_argument
, NULL
, 'b' },
393 { "debug", no_argument
, NULL
, DEBUG_PROGRAM_OPTION
},
394 { "raw", no_argument
, NULL
, RAW_OPTION
},
395 { "untagged", no_argument
, NULL
, UNTAG_OPTION
},
397 { "binary", no_argument
, NULL
, 'b' },
398 { "text", no_argument
, NULL
, 't' },
402 {"sysv", no_argument
, NULL
, 's'},
405 { GETOPT_HELP_OPTION_DECL
},
406 { GETOPT_VERSION_OPTION_DECL
},
413 if (status
!= EXIT_SUCCESS
)
418 Usage: %s [OPTION]... [FILE]...\n\
422 Print or verify checksums.\n\
423 By default use the 32 bit CRC algorithm.\n\
427 Print or check %s (%d-bit) checksums.\n\
437 -r use BSD sum algorithm (the default), use 1K blocks\n\
438 -s, --sysv use System V sum algorithm, use 512 bytes blocks\n\
441 #if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
442 emit_mandatory_arg_note ();
446 -a, --algorithm=TYPE select the digest type to use. See DIGEST below.\
450 -b, --base64 emit base64-encoded digests, not hexadecimal\
455 # if !HASH_ALGO_CKSUM
458 -b, --binary read in binary mode (default unless reading tty stdin)\
463 -b, --binary read in binary mode\n\
467 -c, --check read checksums from the FILEs and check them\n\
469 # if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
471 -l, --length=BITS digest length in bits; must not exceed the max for\n\
472 the blake2 algorithm and must be a multiple of 8\n\
477 --raw emit a raw binary digest, not hexadecimal\
481 --tag create a BSD-style checksum (the default)\n\
484 --untagged create a reversed style checksum, without digest type\n\
488 --tag create a BSD-style checksum\n\
491 # if !HASH_ALGO_CKSUM
494 -t, --text read in text mode (default if reading tty stdin)\n\
498 -t, --text read in text mode (default)\n\
502 -z, --zero end each output line with NUL, not newline,\n\
503 and disable file name escaping\n\
507 The following five options are useful only when verifying checksums:\n\
508 --ignore-missing don't fail or report status for missing files\n\
509 --quiet don't print OK for each successfully verified file\n\
510 --status don't output anything, status code shows success\n\
511 --strict exit non-zero for improperly formatted checksum lines\n\
512 -w, --warn warn about improperly formatted checksum lines\n\
518 --debug indicate which implementation used\n\
521 fputs (HELP_OPTION_DESCRIPTION
, stdout
);
522 fputs (VERSION_OPTION_DESCRIPTION
, stdout
);
526 DIGEST determines the digest algorithm and default output format:\n\
527 sysv (equivalent to sum -s)\n\
528 bsd (equivalent to sum -r)\n\
529 crc (equivalent to cksum)\n\
530 md5 (equivalent to md5sum)\n\
531 sha1 (equivalent to sha1sum)\n\
532 sha224 (equivalent to sha224sum)\n\
533 sha256 (equivalent to sha256sum)\n\
534 sha384 (equivalent to sha384sum)\n\
535 sha512 (equivalent to sha512sum)\n\
536 blake2b (equivalent to b2sum)\n\
537 sm3 (only available through cksum)\n\
540 #if !HASH_ALGO_SUM && !HASH_ALGO_CKSUM
543 The sums are computed as described in %s.\n"), DIGEST_REFERENCE
);
545 When checking, the input should be a former output of this program.\n\
546 The default mode is to print a line with: checksum, a space,\n\
547 a character indicating input mode ('*' for binary, ' ' for text\n\
548 or where binary is insignificant), and name for each FILE.\n\
550 Note: There is no difference between binary mode and text mode on GNU systems.\
555 When checking, the input should be a former output of this program,\n\
556 or equivalent standalone program.\
559 emit_ancillary_info (PROGRAM_NAME
);
565 #define ISWHITE(c) ((c) == ' ' || (c) == '\t')
567 /* Given a file name, S of length S_LEN, that is not NUL-terminated,
568 modify it in place, performing the equivalent of this sed substitution:
569 's/\\n/\n/g;s/\\r/\r/g;s/\\\\/\\/g' i.e., replacing each "\\n" string
570 with a newline, each "\\r" string with a carriage return,
571 and each "\\\\" with a single backslash, NUL-terminate it and return S.
572 If S is not a valid escaped file name, i.e., if it ends with an odd number
573 of backslashes or if it contains a backslash followed by anything other
574 than "n" or another backslash, return NULL. */
577 filename_unescape (char *s
, size_t s_len
)
581 for (size_t i
= 0; i
< s_len
; i
++)
588 /* File name ends with an unescaped backslash: invalid. */
604 /* Only '\', 'n' or 'r' may follow a backslash. */
610 /* The file name may not contain a NUL. */
624 /* Return true if S is a LEN-byte NUL-terminated string of hex or base64
625 digits and has the expected length. Otherwise, return false. */
628 valid_digits (unsigned char const *s
, size_t len
)
631 if (len
== BASE64_LENGTH (digest_length
/ 8))
634 for (i
= 0; i
< len
- digest_length
% 3; i
++)
640 for ( ; i
< len
; i
++)
649 if (len
== digest_hex_bytes
)
651 for (unsigned int i
= 0; i
< digest_hex_bytes
; i
++)
664 /* Split the checksum string S (of length S_LEN) from a BSD 'md5' or
665 'sha1' command into two parts: a hexadecimal digest, and the file
666 name. S is modified. Set *D_LEN to the length of the digest string.
667 Return true if successful. */
670 bsd_split_3 (char *s
, size_t s_len
,
671 unsigned char **digest
, size_t *d_len
,
672 char **file_name
, bool escaped_filename
)
677 /* Find end of filename. */
678 size_t i
= s_len
- 1;
679 while (i
&& s
[i
] != ')')
687 if (escaped_filename
&& filename_unescape (s
, i
) == NULL
)
692 while (ISWHITE (s
[i
]))
700 while (ISWHITE (s
[i
]))
703 *digest
= (unsigned char *) &s
[i
];
706 return valid_digits (*digest
, *d_len
);
710 /* Return the corresponding Algorithm for the string S,
711 or -1 for no match. */
714 algorithm_from_tag (char *s
)
716 /* Limit check size to this length for perf reasons. */
717 static size_t max_tag_len
;
720 char const * const * tag
= algorithm_tags
;
723 size_t tag_len
= strlen (*tag
++);
724 max_tag_len
= MAX (tag_len
, max_tag_len
);
730 /* Find end of tag */
731 while (i
<= max_tag_len
&& s
[i
] && ! ISWHITE (s
[i
])
732 && s
[i
] != '-' && s
[i
] != '(')
738 /* Terminate tag, and lookup. */
741 ptrdiff_t algo
= argmatch_exact (s
, algorithm_tags
);
748 /* Split the string S (of length S_LEN) into three parts:
749 a hexadecimal digest, binary flag, and the file name.
750 S is modified. Set *D_LEN to the length of the digest string.
751 Return true if successful. */
754 split_3 (char *s
, size_t s_len
,
755 unsigned char **digest
, size_t *d_len
, int *binary
, char **file_name
)
757 bool escaped_filename
= false;
758 size_t algo_name_len
;
761 while (ISWHITE (s
[i
]))
767 escaped_filename
= true;
770 /* Check for BSD-style checksum line. */
773 if (! algorithm_specified
)
775 ptrdiff_t algo_tag
= algorithm_from_tag (s
+ i
);
779 return false; /* We don't support checking these older formats. */
780 cksum_algorithm
= algo_tag
;
783 return false; /* We only support tagged format without -a. */
787 algo_name_len
= strlen (DIGEST_TYPE_STRING
);
788 if (STREQ_LEN (s
+ i
, DIGEST_TYPE_STRING
, algo_name_len
))
791 #if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
792 /* Terminate and match algorithm name. */
793 char const *algo_name
= &s
[i
- algo_name_len
];
794 bool length_specified
= s
[i
] == '-';
795 bool openssl_format
= s
[i
] == '('; /* and no length_specified */
797 if (!STREQ (algo_name
, DIGEST_TYPE_STRING
))
802 # if HASH_ALGO_BLAKE2
803 digest_length
= BLAKE2B_MAX_LEN
* 8;
805 digest_length
= algorithm_bits
[cksum_algorithm
];
807 if (length_specified
)
811 if (! (xstrtoumax (s
+ i
, &siend
, 0, &length
, NULL
) == LONGINT_OK
812 && 0 < length
&& length
<= digest_length
817 digest_length
= length
;
819 digest_hex_bytes
= digest_length
/ 4;
827 return bsd_split_3 (s
+ i
, s_len
- i
,
828 digest
, d_len
, file_name
, escaped_filename
);
833 /* Ignore this line if it is too short.
834 Each line must have at least 'min_digest_line_length - 1' (or one more, if
835 the first is a backslash) more characters to contain correct message digest
837 if (s_len
- i
< min_digest_line_length
+ (s
[i
] == '\\'))
840 *digest
= (unsigned char *) &s
[i
];
842 #if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
843 /* Auto determine length. */
845 if (cksum_algorithm
== blake2b
) {
847 unsigned char const *hp
= *digest
;
848 digest_hex_bytes
= 0;
849 while (isxdigit (*hp
++))
851 if (digest_hex_bytes
< 2 || digest_hex_bytes
% 2
852 || BLAKE2B_MAX_LEN
* 2 < digest_hex_bytes
)
854 digest_length
= digest_hex_bytes
* 4;
860 /* This field must be the hexadecimal or base64 representation
861 of the message digest. */
862 while (s
[i
] && !ISWHITE (s
[i
]))
865 *d_len
= &s
[i
] - (char *) *digest
;
868 if (! valid_digits (*digest
, *d_len
))
871 /* If "bsd reversed" format detected. */
872 if ((s_len
- i
== 1) || (s
[i
] != ' ' && s
[i
] != '*'))
874 /* Don't allow mixing bsd and standard formats,
875 to minimize security issues with attackers
876 renaming files with leading spaces.
877 This assumes that with bsd format checksums
878 that the first file name does not have
879 a leading ' ' or '*'. */
880 if (bsd_reversed
== 0)
884 else if (bsd_reversed
!= 1)
887 *binary
= (s
[i
++] == '*');
890 /* All characters between the type indicator and end of line are
891 significant -- that includes leading and trailing white space. */
894 if (escaped_filename
)
895 return filename_unescape (&s
[i
], s_len
- i
) != NULL
;
900 /* If ESCAPE is true, then translate each:
901 NEWLINE byte to the string, "\\n",
902 CARRIAGE RETURN byte to the string, "\\r",
903 and each backslash to "\\\\". */
905 print_filename (char const *file
, bool escape
)
909 fputs (file
, stdout
);
918 fputs ("\\n", stdout
);
922 fputs ("\\r", stdout
);
926 fputs ("\\\\", stdout
);
937 /* An interface to the function, DIGEST_STREAM.
938 Operate on FILENAME (it may be "-").
940 *BINARY indicates whether the file is binary. BINARY < 0 means it
941 depends on whether binary mode makes any difference and the file is
942 a terminal; in that case, clear *BINARY if the file was treated as
943 text because it was a terminal.
945 Put the checksum in *BIN_RESULT, which must be properly aligned.
946 Put true in *MISSING if the file can't be opened due to ENOENT.
947 Return true if successful. */
950 digest_file (char const *filename
, int *binary
, unsigned char *bin_result
,
951 bool *missing
, MAYBE_UNUSED
uintmax_t *length
)
955 bool is_stdin
= STREQ (filename
, "-");
961 have_read_stdin
= true;
963 if (O_BINARY
&& *binary
)
966 *binary
= ! isatty (STDIN_FILENO
);
968 xset_binary_mode (STDIN_FILENO
, O_BINARY
);
973 fp
= fopen (filename
, (O_BINARY
&& *binary
? "rb" : "r"));
976 if (ignore_missing
&& errno
== ENOENT
)
981 error (0, errno
, "%s", quotef (filename
));
986 fadvise (fp
, FADVISE_SEQUENTIAL
);
989 if (cksum_algorithm
== blake2b
)
990 *length
= digest_length
/ 8;
991 err
= DIGEST_STREAM (fp
, bin_result
, length
);
993 err
= DIGEST_STREAM (fp
, bin_result
, length
);
994 #elif HASH_ALGO_BLAKE2
995 err
= DIGEST_STREAM (fp
, bin_result
, digest_length
/ 8);
997 err
= DIGEST_STREAM (fp
, bin_result
);
999 err
= err
? errno
: 0;
1002 else if (fclose (fp
) != 0 && !err
)
1007 error (0, err
, "%s", quotef (filename
));
1016 output_file (char const *file
, int binary_file
, void const *digest
,
1017 bool raw
, bool tagged
, unsigned char delim
, MAYBE_UNUSED
bool args
,
1018 MAYBE_UNUSED
uintmax_t length
)
1020 # if HASH_ALGO_CKSUM
1023 fwrite (digest
, 1, digest_length
/ 8, stdout
);
1028 unsigned char const *bin_buffer
= digest
;
1030 /* Output a leading backslash if the file name contains problematic chars.
1031 Note we escape '\' itself to provide some forward compat to introduce
1032 escaping of other characters. */
1033 bool needs_escape
= delim
== '\n' && (strchr (file
, '\\')
1034 || strchr (file
, '\n')
1035 || strchr (file
, '\r'));
1041 fputs (DIGEST_TYPE_STRING
, stdout
);
1042 # if HASH_ALGO_BLAKE2
1043 if (digest_length
< BLAKE2B_MAX_LEN
* 8)
1044 printf ("-%"PRIuMAX
, digest_length
);
1045 # elif HASH_ALGO_CKSUM
1046 if (cksum_algorithm
== blake2b
)
1048 if (digest_length
< BLAKE2B_MAX_LEN
* 8)
1049 printf ("-%"PRIuMAX
, digest_length
);
1052 fputs (" (", stdout
);
1053 print_filename (file
, needs_escape
);
1054 fputs (") = ", stdout
);
1057 # if HASH_ALGO_CKSUM
1060 char b64
[BASE64_LENGTH (DIGEST_BIN_BYTES
) + 1];
1061 base64_encode ((char const *) bin_buffer
, digest_length
/ 8,
1063 fputs (b64
, stdout
);
1068 for (size_t i
= 0; i
< (digest_hex_bytes
/ 2); ++i
)
1069 printf ("%02x", bin_buffer
[i
]);
1076 # if HASH_ALGO_CKSUM
1077 /* Simplify output as always in binary mode. */
1080 putchar (binary_file
? '*' : ' ');
1083 print_filename (file
, needs_escape
);
1091 /* Return true if B64_DIGEST is the same as the base64 digest of the
1092 DIGEST_LENGTH/8 bytes at BIN_BUFFER. */
1094 b64_equal (unsigned char const *b64_digest
, unsigned char const *bin_buffer
)
1096 size_t b64_n_bytes
= BASE64_LENGTH (digest_length
/ 8);
1097 char b64
[BASE64_LENGTH (DIGEST_BIN_BYTES
) + 1];
1098 base64_encode ((char const *) bin_buffer
, digest_length
/ 8, b64
, sizeof b64
);
1099 return memcmp (b64_digest
, b64
, b64_n_bytes
+ 1) == 0;
1103 /* Return true if HEX_DIGEST is the same as the hex-encoded digest of the
1104 DIGEST_LENGTH/8 bytes at BIN_BUFFER. */
1106 hex_equal (unsigned char const *hex_digest
, unsigned char const *bin_buffer
)
1108 static const char bin2hex
[] = { '0', '1', '2', '3',
1111 'c', 'd', 'e', 'f' };
1112 size_t digest_bin_bytes
= digest_hex_bytes
/ 2;
1114 /* Compare generated binary number with text representation
1115 in check file. Ignore case of hex digits. */
1117 for (cnt
= 0; cnt
< digest_bin_bytes
; ++cnt
)
1119 if (tolower (hex_digest
[2 * cnt
])
1120 != bin2hex
[bin_buffer
[cnt
] >> 4]
1121 || (tolower (hex_digest
[2 * cnt
+ 1])
1122 != (bin2hex
[bin_buffer
[cnt
] & 0xf])))
1125 return cnt
== digest_bin_bytes
;
1129 digest_check (char const *checkfile_name
)
1131 FILE *checkfile_stream
;
1132 uintmax_t n_misformatted_lines
= 0;
1133 uintmax_t n_mismatched_checksums
= 0;
1134 uintmax_t n_open_or_read_failures
= 0;
1135 bool properly_formatted_lines
= false;
1136 bool matched_checksums
= false;
1137 unsigned char bin_buffer_unaligned
[DIGEST_BIN_BYTES
+ DIGEST_ALIGN
];
1138 /* Make sure bin_buffer is properly aligned. */
1139 unsigned char *bin_buffer
= ptr_align (bin_buffer_unaligned
, DIGEST_ALIGN
);
1140 uintmax_t line_number
;
1142 size_t line_chars_allocated
;
1143 bool is_stdin
= STREQ (checkfile_name
, "-");
1147 have_read_stdin
= true;
1148 checkfile_name
= _("standard input");
1149 checkfile_stream
= stdin
;
1153 checkfile_stream
= fopen (checkfile_name
, "r");
1154 if (checkfile_stream
== NULL
)
1156 error (0, errno
, "%s", quotef (checkfile_name
));
1163 line_chars_allocated
= 0;
1168 unsigned char *digest
;
1169 ssize_t line_length
;
1172 if (line_number
== 0)
1173 die (EXIT_FAILURE
, 0, _("%s: too many checksum lines"),
1174 quotef (checkfile_name
));
1176 line_length
= getline (&line
, &line_chars_allocated
, checkfile_stream
);
1177 if (line_length
<= 0)
1180 /* Ignore comment lines, which begin with a '#' character. */
1184 /* Remove any trailing newline. */
1185 line_length
-= line
[line_length
- 1] == '\n';
1186 /* Remove any trailing carriage return. */
1187 line_length
-= line
[line_length
- (0 < line_length
)] == '\r';
1189 /* Ignore empty lines. */
1190 if (line_length
== 0)
1193 line
[line_length
] = '\0';
1196 if (! (split_3 (line
, line_length
, &digest
, &d_len
, &binary
, &filename
)
1197 && ! (is_stdin
&& STREQ (filename
, "-"))))
1199 ++n_misformatted_lines
;
1205 ": improperly formatted %s checksum line"),
1206 quotef (checkfile_name
), line_number
,
1207 DIGEST_TYPE_STRING
);
1214 /* Only escape in the edge case producing multiple lines,
1215 to ease automatic processing of status output. */
1216 bool needs_escape
= ! status_only
&& strchr (filename
, '\n');
1218 properly_formatted_lines
= true;
1221 ok
= digest_file (filename
, &binary
, bin_buffer
, &missing
, &length
);
1225 ++n_open_or_read_failures
;
1230 print_filename (filename
, needs_escape
);
1231 printf (": %s\n", _("FAILED open or read"));
1234 else if (ignore_missing
&& missing
)
1236 /* Ignore missing files with --ignore-missing. */
1243 if (d_len
< digest_hex_bytes
)
1244 match
= b64_equal (digest
, bin_buffer
);
1247 if (d_len
== digest_hex_bytes
)
1248 match
= hex_equal (digest
, bin_buffer
);
1251 matched_checksums
= true;
1253 ++n_mismatched_checksums
;
1257 if ( ! matched_checksums
|| ! quiet
)
1261 print_filename (filename
, needs_escape
);
1264 if ( ! matched_checksums
)
1265 printf (": %s\n", _("FAILED"));
1267 printf (": %s\n", _("OK"));
1272 while (!feof (checkfile_stream
) && !ferror (checkfile_stream
));
1276 int err
= ferror (checkfile_stream
) ? 0 : -1;
1278 clearerr (checkfile_stream
);
1279 else if (fclose (checkfile_stream
) != 0 && err
< 0)
1284 error (0, err
, err
? "%s" : _("%s: read error"),
1285 quotef (checkfile_name
));
1289 if (! properly_formatted_lines
)
1291 /* Warn if no tests are found. */
1292 error (0, 0, _("%s: no properly formatted checksum lines found"),
1293 quotef (checkfile_name
));
1299 if (n_misformatted_lines
!= 0)
1302 ("WARNING: %" PRIuMAX
" line is improperly formatted",
1303 "WARNING: %" PRIuMAX
" lines are improperly formatted",
1304 select_plural (n_misformatted_lines
))),
1305 n_misformatted_lines
);
1307 if (n_open_or_read_failures
!= 0)
1310 ("WARNING: %" PRIuMAX
" listed file could not be read",
1311 "WARNING: %" PRIuMAX
" listed files could not be read",
1312 select_plural (n_open_or_read_failures
))),
1313 n_open_or_read_failures
);
1315 if (n_mismatched_checksums
!= 0)
1318 ("WARNING: %" PRIuMAX
" computed checksum did NOT match",
1319 "WARNING: %" PRIuMAX
" computed checksums did NOT match",
1320 select_plural (n_mismatched_checksums
))),
1321 n_mismatched_checksums
);
1323 if (ignore_missing
&& ! matched_checksums
)
1324 error (0, 0, _("%s: no file was verified"),
1325 quotef (checkfile_name
));
1329 return (properly_formatted_lines
1330 && matched_checksums
1331 && n_mismatched_checksums
== 0
1332 && n_open_or_read_failures
== 0
1333 && (!strict
|| n_misformatted_lines
== 0));
1337 main (int argc
, char **argv
)
1339 unsigned char bin_buffer_unaligned
[DIGEST_BIN_BYTES
+ DIGEST_ALIGN
];
1340 /* Make sure bin_buffer is properly aligned. */
1341 unsigned char *bin_buffer
= ptr_align (bin_buffer_unaligned
, DIGEST_ALIGN
);
1342 bool do_check
= false;
1347 bool prefix_tag
= true;
1350 bool prefix_tag
= false;
1353 /* Setting values of global variables. */
1354 initialize_main (&argc
, &argv
);
1355 set_program_name (argv
[0]);
1356 setlocale (LC_ALL
, "");
1357 bindtextdomain (PACKAGE
, LOCALEDIR
);
1358 textdomain (PACKAGE
);
1360 atexit (close_stdout
);
1362 /* Line buffer stdout to ensure lines are written atomically and immediately
1363 so that processes running in parallel do not intersperse their output. */
1364 setvbuf (stdout
, NULL
, _IOLBF
, 0);
1367 char const *short_opts
= "rs";
1368 #elif HASH_ALGO_CKSUM
1369 char const *short_opts
= "a:l:bctwz";
1370 char const *digest_length_str
= "";
1371 #elif HASH_ALGO_BLAKE2
1372 char const *short_opts
= "l:bctwz";
1373 char const *digest_length_str
= "";
1375 char const *short_opts
= "bctwz";
1378 while ((opt
= getopt_long (argc
, argv
, short_opts
, long_options
, NULL
)) != -1)
1383 cksum_algorithm
= XARGMATCH_EXACT ("--algorithm", optarg
,
1384 algorithm_args
, algorithm_types
);
1385 algorithm_specified
= true;
1388 case DEBUG_PROGRAM_OPTION
:
1392 #if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
1394 digest_length
= xdectoumax (optarg
, 0, UINTMAX_MAX
, "",
1395 _("invalid length"), 0);
1396 digest_length_str
= optarg
;
1397 if (digest_length
% 8 != 0)
1399 error (0, 0, _("invalid length: %s"), quote (digest_length_str
));
1400 die (EXIT_FAILURE
, 0, _("length is not a multiple of 8"));
1413 # if !HASH_ALGO_CKSUM
1422 status_only
= false;
1426 case IGNORE_MISSING_OPTION
:
1427 ignore_missing
= true;
1430 status_only
= false;
1437 # if HASH_ALGO_CKSUM
1439 base64_digest
= true;
1453 digest_delim
= '\0';
1457 case 'r': /* For SysV compatibility. */
1458 sum_algorithm
= bsd
;
1462 sum_algorithm
= sysv
;
1465 case_GETOPT_HELP_CHAR
;
1466 case_GETOPT_VERSION_CHAR (PROGRAM_NAME
, AUTHORS
);
1468 usage (EXIT_FAILURE
);
1471 min_digest_line_length
= MIN_DIGEST_LINE_LENGTH
;
1472 #if HASH_ALGO_BLAKE2 || HASH_ALGO_CKSUM
1473 # if HASH_ALGO_CKSUM
1474 if (digest_length
&& cksum_algorithm
!= blake2b
)
1475 die (EXIT_FAILURE
, 0,
1476 _("--length is only supported with --algorithm=blake2b"));
1478 if (digest_length
> BLAKE2B_MAX_LEN
* 8)
1480 error (0, 0, _("invalid length: %s"), quote (digest_length_str
));
1481 die (EXIT_FAILURE
, 0,
1482 _("maximum digest length for %s is %d bits"),
1483 quote (DIGEST_TYPE_STRING
),
1484 BLAKE2B_MAX_LEN
* 8);
1486 if (digest_length
== 0)
1488 # if HASH_ALGO_BLAKE2
1489 digest_length
= BLAKE2B_MAX_LEN
* 8;
1491 digest_length
= algorithm_bits
[cksum_algorithm
];
1494 digest_hex_bytes
= digest_length
/ 4;
1496 digest_hex_bytes
= DIGEST_HEX_BYTES
;
1500 switch (cksum_algorithm
)
1505 if (do_check
&& algorithm_specified
)
1506 die (EXIT_FAILURE
, 0,
1507 _("--check is not supported with --algorithm={bsd,sysv,crc}"));
1513 if (base64_digest
&& raw_digest
)
1515 error (0, 0, _("--base64 and --raw are mutually exclusive"));
1516 usage (EXIT_FAILURE
);
1520 if (prefix_tag
&& !binary
)
1522 /* This could be supported in a backwards compatible way
1523 by prefixing the output line with a space in text mode.
1524 However that's invasive enough that it was agreed to
1525 not support this mode with --tag, as --text use cases
1526 are adequately supported by the default output format. */
1527 error (0, 0, _("--tag does not support --text mode"));
1528 usage (EXIT_FAILURE
);
1531 if (digest_delim
!= '\n' && do_check
)
1533 error (0, 0, _("the --zero option is not supported when "
1534 "verifying checksums"));
1535 usage (EXIT_FAILURE
);
1537 #if !HASH_ALGO_CKSUM
1538 if (prefix_tag
&& do_check
)
1540 error (0, 0, _("the --tag option is meaningless when "
1541 "verifying checksums"));
1542 usage (EXIT_FAILURE
);
1546 #if !HASH_ALGO_CKSUM
1547 if (0 <= binary
&& do_check
)
1549 error (0, 0, _("the --binary and --text options are meaningless when "
1550 "verifying checksums"));
1551 usage (EXIT_FAILURE
);
1555 if (ignore_missing
&& !do_check
)
1558 _("the --ignore-missing option is meaningful only when "
1559 "verifying checksums"));
1560 usage (EXIT_FAILURE
);
1563 if (status_only
&& !do_check
)
1566 _("the --status option is meaningful only when verifying checksums"));
1567 usage (EXIT_FAILURE
);
1570 if (warn
&& !do_check
)
1573 _("the --warn option is meaningful only when verifying checksums"));
1574 usage (EXIT_FAILURE
);
1577 if (quiet
&& !do_check
)
1580 _("the --quiet option is meaningful only when verifying checksums"));
1581 usage (EXIT_FAILURE
);
1584 if (strict
& !do_check
)
1587 _("the --strict option is meaningful only when verifying checksums"));
1588 usage (EXIT_FAILURE
);
1591 if (!O_BINARY
&& binary
< 0)
1594 char **operand_lim
= argv
+ argc
;
1596 *operand_lim
++ = bad_cast ("-");
1597 else if (1 < argc
- optind
&& raw_digest
)
1599 die (EXIT_FAILURE
, 0,
1600 _("the --raw option is not supported with multiple files"));
1603 for (char **operandp
= argv
+ optind
; operandp
< operand_lim
; operandp
++)
1605 char *file
= *operandp
;
1607 ok
&= digest_check (file
);
1610 int binary_file
= binary
;
1614 if (! digest_file (file
, &binary_file
, bin_buffer
, &missing
, &length
))
1618 DIGEST_OUT (file
, binary_file
, bin_buffer
, raw_digest
, prefix_tag
,
1619 digest_delim
, optind
!= argc
, length
);
1624 if (have_read_stdin
&& fclose (stdin
) == EOF
)
1625 die (EXIT_FAILURE
, errno
, _("standard input"));
1627 return ok
? EXIT_SUCCESS
: EXIT_FAILURE
;