// SPDX-License-Identifier: GPL-2.0-only

// SPDX-FileCopyrightText: © 2015 Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>

#include <common.h>

#include <command.h>

#include <linux/pagemap.h>

#include <fs.h>

#include <fcntl.h>

#include <errno.h>

#include <xfuncs.h>

#include <malloc.h>

#include <digest.h>

#include <getopt.h>

#include <libfile.h>

#include "internal.h"

int __do_digest(struct digest *d, unsigned char *sig,

           int argc, char *argv[])

{

  int ret = COMMAND_ERROR_USAGE;

  int i;

  unsigned char *hash;

  if (argc < 1)

    goto err;

  hash = calloc(digest_length(d), sizeof(unsigned char));

  if (!hash) {

    perror("calloc");

    goto err;

  }

  while (*argv) {

    char *filename = "/dev/mem";

    loff_t start = 0, size = MAX_LFS_FILESIZE;

    int show_area = 1;

    /* arguments are either file, file+area or area */

    if (parse_area_spec(*argv, &start, &size)) {

      filename = *argv;

      show_area = 0;

      if (argv[1] && !parse_area_spec(argv[1], &start, &size)) {

        argv++;

        show_area = 1;

      }

    }

    ret = digest_file_window(d, filename,

           hash, sig, start, size);

    if (ret < 0) {

      ret = 1;

    } else {

      if (!sig) {

        for (i = 0; i < digest_length(d); i++)

          printf("%02x", hash[i]);

        printf("  %s", filename);

        if (show_area)

          printf("\t0x%08llx ... 0x%08llx",

            start, start + size);

        puts("\n");

      }

    }

    argv++;

  }

  free(hash);

err:

  digest_free(d);

  return ret;

}

static void __maybe_unused prints_algo_help(void)

{

  puts("\navailable algo:\n");

  digest_algo_prints("\t");

}

static int do_digest(int argc, char *argv[])

{

  struct digest *d;

  unsigned char *tmp_key = NULL;

  unsigned char *tmp_sig = NULL;

  char *sig = NULL;

  char *sigfile = NULL;

  size_t siglen = 0;

  char *key = NULL;

  char *keyfile = NULL;

  size_t keylen = 0;

  size_t digestlen = 0;

  char *algo = NULL;

  int opt;

  int ret = COMMAND_ERROR;

  if (argc < 2)

    return COMMAND_ERROR_USAGE;

  while((opt = getopt(argc, argv, "a:k:K:s:S:")) > 0) {

    switch(opt) {

    case 'k':

      key = optarg;

      keylen = strlen(key);

      break;

    case 'K':

      keyfile = optarg;

      break;

    case 'a':

      algo = optarg;

      break;

    case 's':

      sig = optarg;

      siglen = strlen(sig);

      break;

    case 'S':

      sigfile = optarg;

      break;

    }

  }

  if (!algo)

    return COMMAND_ERROR_USAGE;

  d = digest_alloc(algo);

  if (!d) {

    eprintf("algo '%s' not found\n", algo);

    return COMMAND_ERROR_USAGE;

  }

  argc -= optind;

  argv += optind;

  if (keyfile) {

    tmp_key = key = read_file(keyfile, &keylen);

    if (!key) {

      eprintf("file '%s' not found\n", keyfile);

      goto err;

    }

  }

  if (key) {

    ret = digest_set_key(d, key, keylen);

    free(tmp_key);

    if (ret)

      goto err;

  } else if (digest_is_flags(d, DIGEST_ALGO_NEED_KEY)) {

    eprintf("%s need a key to be used\n", digest_name(d));

    goto err;

  }

  if (sigfile) {

    sig = tmp_sig = read_file(sigfile, &siglen);

    if (!tmp_sig) {

      eprintf("file '%s' not found\n", sigfile);

      goto err;

    }

  }

  if (sig) {

    digestlen = digest_length(d);

    if (siglen >= 2 * digestlen) {

      if (!tmp_sig)

        tmp_sig = xmalloc(digestlen);

      ret = hex2bin(tmp_sig, sig, digestlen);

      if (ret)

        goto err;

      sig = tmp_sig;

    } else if (siglen != digestlen) {

      eprintf("%s wrong size %zu, expected %zu\n",

        sigfile, siglen, digestlen);

      ret = COMMAND_ERROR;

      goto err;

    }

  }

  ret = __do_digest(d, sig, argc, argv);

  free(tmp_sig);

  return ret;

err:

  digest_free(d);

  return ret;

}

BAREBOX_CMD_HELP_START(digest)

BAREBOX_CMD_HELP_TEXT("Calculate a digest over a FILE or a memory area.")

BAREBOX_CMD_HELP_TEXT("Options:")

BAREBOX_CMD_HELP_OPT ("-a <algo>\t",  "hash or signature algorithm name/driver to use")

BAREBOX_CMD_HELP_OPT ("-k <key>\t",   "use supplied <key> (ASCII or hex) for MAC")

BAREBOX_CMD_HELP_OPT ("-K <file>\t",  "use key from <file> (binary) for MAC")

BAREBOX_CMD_HELP_OPT ("-s <hex>\t",   "verify data against supplied <hex> (hash, MAC or signature)")

BAREBOX_CMD_HELP_OPT ("-S <file>\t",  "verify data against <file> (hash, MAC or signature)")

BAREBOX_CMD_HELP_END

BAREBOX_CMD_START(digest)

  .cmd    = do_digest,

  BAREBOX_CMD_DESC("calculate digest")

  BAREBOX_CMD_OPTS("-a <algo> [-k <key> | -K <file>] [-s <sig> | -S <file>] FILE|AREA")

  BAREBOX_CMD_GROUP(CMD_GRP_FILE)

  BAREBOX_CMD_HELP(cmd_digest_help)

  BAREBOX_CMD_USAGE(prints_algo_help)

BAREBOX_CMD_END