/* See LICENSE file for copyright and license details. */
#include "common.h"
const char *argv0 = "bsum";
static int lenght_by_command_name = 0;
static int flag_check = 0;
static int flag_binary = 0;
static int flag_lower = 0;
static int flag_upper = 0;
static int flag_hex = 0;
static int flag_zero = 0;
static int length;
static void
usage(void)
{
/* TODO add support for salt (-S) */
fprintf(stderr, "usage: %s%s [-c | -B | -L | -U] [-xz] [file] ...",
argv0, lenght_by_command_name ? "" : " [-l bits]");
exit(2);
}
static void
get_lenght_by_command_name(const char *command)
{
const char *p;
p = strrchr(command, '/');
p = p ? &p[1] : command;
if (strstr(p, "b224sum"))
lenght_by_command_name = 224;
else if (strstr(p, "b256sum"))
lenght_by_command_name = 256;
else if (strstr(p, "b384sum"))
lenght_by_command_name = 384;
else if (strstr(p, "b512sum"))
lenght_by_command_name = 512;
}
static int
hash_fd_blake(int fd, const char *fname, int decode_hex, unsigned char hash[], void *state,
void (*init_func)(void *state), size_t (*update_func)(void *state, const void *msg, size_t n),
size_t (*get_buf_size_func)(size_t bytes, size_t bits, const char *suffix),
void (*digest_func)(void *state, void *msg, size_t bytes, size_t bits, const char *suffix, unsigned char out[]))
{
char *buf = NULL;
size_t size = 0;
size_t len = 0;
size_t off = 0;
size_t req;
ssize_t r;
int ok;
init_func(state);
for (;;) {
if (len == size)
buf = erealloc(buf, size += 8 << 10);
r = read(fd, &buf[len], size - len);
if (r <= 0) {
if (!r)
break;
if (errno == EINTR)
continue;
fprintf(stderr, "%s: %s: %s\n", argv0, fname, strerror(errno));
free(buf);
return -1;
}
len += (size_t)r;
if (!decode_hex) {
off += update_func(state, &buf[off], len - off);
if (off == len)
off = 0;
}
}
if (off)
memmove(&buf[0], &buf[off], len -= off);
if (decode_hex) {
len = libblake_decode_hex(buf, len, buf, &ok);
if (!ok) {
fprintf(stderr, "%s: %s: %s\n", argv0, fname, "invalid hexadecimal input");
free(buf);
return -1;
}
}
req = get_buf_size_func(len, 0, NULL);
if (req > size)
buf = erealloc(buf, size);
libblake_blake224_digest(state, buf, len, 0, NULL, hash);
free(buf);
return 0;
}
static int
hash_fd_blake224(int fd, const char *fname, int decode_hex, unsigned char hash[])
{
struct libblake_blake224_state state;
return hash_fd_blake(fd, fname, decode_hex, hash, &state,
(void (*)(void *))&libblake_blake224_init,
(size_t (*)(void *, const void *, size_t))&libblake_blake224_update,
&libblake_blake224_digest_get_required_input_size,
(void (*)(void *, void *, size_t, size_t, const char *, unsigned char[]))&libblake_blake224_digest);
}
static int
hash_fd_blake256(int fd, const char *fname, int decode_hex, unsigned char hash[])
{
struct libblake_blake256_state state;
return hash_fd_blake(fd, fname, decode_hex, hash, &state,
(void (*)(void *))&libblake_blake256_init,
(size_t (*)(void *, const void *, size_t))&libblake_blake256_update,
&libblake_blake256_digest_get_required_input_size,
(void (*)(void *, void *, size_t, size_t, const char *, unsigned char[]))&libblake_blake256_digest);
}
static int
hash_fd_blake384(int fd, const char *fname, int decode_hex, unsigned char hash[])
{
struct libblake_blake384_state state;
return hash_fd_blake(fd, fname, decode_hex, hash, &state,
(void (*)(void *))&libblake_blake384_init,
(size_t (*)(void *, const void *, size_t))&libblake_blake384_update,
&libblake_blake384_digest_get_required_input_size,
(void (*)(void *, void *, size_t, size_t, const char *, unsigned char[]))&libblake_blake384_digest);
}
static int
hash_fd_blake512(int fd, const char *fname, int decode_hex, unsigned char hash[])
{
struct libblake_blake512_state state;
return hash_fd_blake(fd, fname, decode_hex, hash, &state,
(void (*)(void *))&libblake_blake512_init,
(size_t (*)(void *, const void *, size_t))&libblake_blake512_update,
&libblake_blake512_digest_get_required_input_size,
(void (*)(void *, void *, size_t, size_t, const char *, unsigned char[]))&libblake_blake512_digest);
}
int
hash_fd(int fd, const char *fname, int decode_hex, unsigned char hash[])
{
int ret;
if (length == 224)
ret = hash_fd_blake224(fd, fname, decode_hex, hash);
else if (length == 256)
ret = hash_fd_blake256(fd, fname, decode_hex, hash);
else if (length == 384)
ret = hash_fd_blake384(fd, fname, decode_hex, hash);
else if (length == 512)
ret = hash_fd_blake512(fd, fname, decode_hex, hash);
else
abort();
return ret;
}
int
main(int argc, char *argv[])
{
int status = 0;
int output_case;
char newline;
if (argv[0])
get_lenght_by_command_name(argv[0]);
length = lenght_by_command_name;
ARGBEGIN {
case 'c':
flag_check = 1;
break;
case 'B':
flag_binary = 1;
break;
case 'L':
flag_lower = 1;
flag_upper = 0;
break;
case 'U':
flag_upper = 1;
flag_lower = 0;
break;
case 'x':
flag_hex = 1;
break;
case 'z':
flag_zero = 1;
break;
case 'l':
if (length)
usage();
length = atoi(ARG());
if (length != 224 && length != 256 && length != 384 && length != 512) {
fprintf(stderr, "%s: valid arguments for -l are 224 (default), 256, 384, and 512\n", argv0);
return 2;
}
break;
default:
usage();
} ARGEND;
if (flag_check + flag_binary + flag_lower + flag_upper > 1)
usage();
if (!length)
length = 224;
newline = flag_zero ? '\0' : '\n';
if (flag_check) {
if (!argc) {
status |= -check_and_print("-", (size_t)length, flag_hex, newline);
} else {
for (; *argv; argv++)
status |= -check_and_print(*argv, (size_t)length, flag_hex, newline);
}
} else {
output_case = flag_binary ? -1 : flag_upper;
if (!argc) {
status |= -hash_and_print("-", (size_t)length, flag_hex, newline, output_case);
} else {
for (; *argv; argv++)
status |= -hash_and_print(*argv, (size_t)length, flag_hex, newline, output_case);
}
}
if (fflush(stdout) || ferror(stdout) || fclose(stdout)) {
fprintf(stderr, "%s: %s\n", argv0, strerror(errno));
return 2;
}
return status;
}
