/*

 * Copyright (c) 2012 Tim Ruehsen

 * Copyright (c) 2015-2024 Free Software Foundation, Inc.

 *

 * This file is part of Wget.

 *

 * Wget 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.

 *

 * Wget 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 Wget.  If not, see <https://www.gnu.org/licenses/>.

 *

 *

 * Hash routines

 *

 * Changelog

 * 29.07.2012  Tim Ruehsen  created

 *

 */

#include <config.h>

#include <unistd.h>

#include <stdlib.h>

#include <fcntl.h>

#include <sys/stat.h>

#ifdef HAVE_MMAP

# include <sys/mman.h>

#endif

#include <wget.h>

#include "private.h"

/**

 * \file

 * \brief Hashing functions

 * \ingroup libwget-hash

 * @{

 *

 */

/**

 * \param[in] hashname Name of the hashing algorithm (see table below)

 * \return A constant to be used by libwget hashing functions

 *

 * Get the hashing algorithms list item that corresponds to the named hashing algorithm.

 *

 * This function returns a constant that uniquely identifies a known supported hashing algorithm

 * within libwget. All the supported algorithms are listed in the ::wget_digest_algorithm enum.

 *

 * Algorithm name | Constant

 * -------------- | --------

 * sha1 or sha-1|WGET_DIGTYPE_SHA1

 * sha256 or sha-256|WGET_DIGTYPE_SHA256

 * sha512 or sha-512|WGET_DIGTYPE_SHA512

 * sha224 or sha-224|WGET_DIGTYPE_SHA224

 * sha384 or sha-384|WGET_DIGTYPE_SHA384

 * md5|WGET_DIGTYPE_MD5

 * md2|WGET_DIGTYPE_MD2

 * rmd160|WGET_DIGTYPE_RMD160

 */

wget_digest_algorithm wget_hash_get_algorithm(const char *hashname)

{

  if (hashname) {

    if (*hashname == 's' || *hashname == 'S') {

      if (!wget_strcasecmp_ascii(hashname, "sha-1") || !wget_strcasecmp_ascii(hashname, "sha1"))

        return WGET_DIGTYPE_SHA1;

      else if (!wget_strcasecmp_ascii(hashname, "sha-256") || !wget_strcasecmp_ascii(hashname, "sha256"))

        return WGET_DIGTYPE_SHA256;

      else if (!wget_strcasecmp_ascii(hashname, "sha-512") || !wget_strcasecmp_ascii(hashname, "sha512"))

        return WGET_DIGTYPE_SHA512;

      else if (!wget_strcasecmp_ascii(hashname, "sha-224") || !wget_strcasecmp_ascii(hashname, "sha224"))

        return WGET_DIGTYPE_SHA224;

      else if (!wget_strcasecmp_ascii(hashname, "sha-384") || !wget_strcasecmp_ascii(hashname, "sha384"))

        return WGET_DIGTYPE_SHA384;

    }

    else if (!wget_strcasecmp_ascii(hashname, "md5"))

      return WGET_DIGTYPE_MD5;

    else if (!wget_strcasecmp_ascii(hashname, "md2"))

      return WGET_DIGTYPE_MD2;

    else if (!wget_strcasecmp_ascii(hashname, "rmd160"))

      return WGET_DIGTYPE_RMD160;

  }

  error_printf(_("Unknown hash type '%s'\n"), hashname);

  return WGET_DIGTYPE_UNKNOWN;

}

#if defined WITH_GNUTLS && !defined WITH_LIBNETTLE

#include <gnutls/gnutls.h>

#ifdef HAVE_GNUTLS_CRYPTO_H

#  include <gnutls/crypto.h>

#endif

struct wget_hash_hd_st {

  gnutls_hash_hd_t

    dig;

};

static const gnutls_digest_algorithm_t

  algorithms[WGET_DIGTYPE_MAX] = {

//    [WGET_DIGTYPE_UNKNOWN] = GNUTLS_DIG_UNKNOWN, // both values are 0

    [WGET_DIGTYPE_MD2] = GNUTLS_DIG_MD2,

    [WGET_DIGTYPE_MD5] = GNUTLS_DIG_MD5,

    [WGET_DIGTYPE_RMD160] = GNUTLS_DIG_RMD160,

    [WGET_DIGTYPE_SHA1] = GNUTLS_DIG_SHA1,

    [WGET_DIGTYPE_SHA224] = GNUTLS_DIG_SHA224,

    [WGET_DIGTYPE_SHA256] = GNUTLS_DIG_SHA256,

    [WGET_DIGTYPE_SHA384] = GNUTLS_DIG_SHA384,

    [WGET_DIGTYPE_SHA512] = GNUTLS_DIG_SHA512

};

/**

 * \param[in] algorithm One of the hashing algorithms returned by wget_hash_get_algorithm()

 * \param[in] text Input data to hash

 * \param[in] textlen Length of the input data

 * \param[in] digest Caller-supplied buffer where the output hash will be placed

 * \return Zero on success or a negative value on error

 *

 * Convenience function to hash the given data in a single call.

 *

 * The caller must ensure that the provided output buffer \p digest is large enough

 * to store the hash. A particular hash algorithm is guaranteed to always generate

 * the same amount of data (e.g. 512 bits) but different hash algorithms will output

 * different lengths of data. To get the output length of the chosen algorithm \p algorithm,

 * call wget_hash_get_len().

 *

 * \note This function's behavior depends on the underlying cryptographic engine libwget was compiled with.

 */

int wget_hash_fast(wget_digest_algorithm algorithm, const void *text, size_t textlen, void *digest)

{

  if ((unsigned) algorithm >= countof(algorithms))

    return WGET_E_INVALID;

  gnutls_digest_algorithm_t hashtype = algorithms[algorithm];

  if (hashtype == GNUTLS_DIG_UNKNOWN)

    return WGET_E_UNSUPPORTED;

  if (gnutls_hash_fast(algorithms[algorithm], text, textlen, digest) != 0)

    return WGET_E_UNKNOWN;

  return WGET_E_SUCCESS;

}

/**

 * \param[in] algorithm One of the hashing algorithms returned by wget_hash_get_algorithm()

 * \return The length of the output data generated by the algorithm

 *

 * Determines the output length of the given hashing algorithm.

 *

 * A particular hash algorithm is guaranteed to always generate

 * the same amount of data (e.g. 512 bits) but different hash algorithms will output

 * different lengths of data.

 */

int wget_hash_get_len(wget_digest_algorithm algorithm)

{

  if ((unsigned)algorithm < countof(algorithms))

    return gnutls_hash_get_len(algorithms[algorithm]);

  else

    return 0;

}

/**

 * \param[out] handle Caller-provided pointer to a ::wget_hash_hd structure where the handle to this

 * hashing primitive will be stored, needed in subsequent calls to wget_hash()

 * \param[in] algorithm One of the hashing algorithms returned by wget_hash_get_algorithm()

 * \return Zero on success or a negative value on error

 *

 * Initialize the cryptographic engine to compute hashes with the given hashing algorithm,

 * as well as the hashing algorithm itself.

 *

 * After this function returns, wget_hash() might be called as many times as desired.

 */

int wget_hash_init(wget_hash_hd **handle, wget_digest_algorithm algorithm)

{

  if ((unsigned)algorithm >= countof(algorithms))

    return WGET_E_INVALID;

  gnutls_digest_algorithm_t hashtype = algorithms[algorithm];

  if (hashtype == GNUTLS_DIG_UNKNOWN)

    return WGET_E_UNSUPPORTED;

  if (!(*handle = wget_malloc(sizeof(struct wget_hash_hd_st))))

    return WGET_E_MEMORY;

  if (gnutls_hash_init(&(*handle)->dig, algorithms[algorithm]) != 0) {

    xfree(*handle);

    return WGET_E_UNKNOWN;

  }

  return WGET_E_SUCCESS;

}

/**

 * \param[in] handle Handle to the hashing primitive returned by a subsequent call to wget_hash_init()

 * \param[in] text Input data

 * \param[in] textlen Length of the input data

 * \return Zero on success or a negative value on error

 *

 * Update the digest by adding additional input data to it. This method can be called

 * as many times as desired. Once finished, call wget_hash_deinit() to complete

 * the computation and get the resulting hash.

 */

int wget_hash(wget_hash_hd *handle, const void *text, size_t textlen)

{

  return gnutls_hash(handle->dig, text, textlen) == 0 ? 0 : -1;

}

/**

 * \param[in] handle Handle to the hashing primitive returned by a subsequent call to wget_hash_init()

 * \param[out] digest Caller-supplied buffer where the output hash will be placed.

 * \return 0 on success, < 0 on failure

 *

 * Complete the hash computation by performing final operations, such as padding,

 * and obtain the final result. The result will be placed in the caller-supplied

 * buffer \p digest. The caller must ensure that the provided output buffer \p digest

 * is large enough to store the hash. To get the output length of the chosen algorithm

 * \p algorithm, call wget_hash_get_len().

 */

int wget_hash_deinit(wget_hash_hd **handle, void *digest)

{

  gnutls_hash_deinit((*handle)->dig, digest);

  xfree(*handle);

  return WGET_E_SUCCESS;

}

#elif defined WITH_LIBWOLFCRYPT

#define WOLFSSL_SHA224

#define WOLFSSL_SHA384

#define WOLFSSL_SHA512

#define WC_NO_HARDEN

#include <wolfssl/options.h>

#include <wolfssl/wolfcrypt/hash.h>

struct wget_hash_hd_st {

  wc_HashAlg

    hash;

  enum wc_HashType

    type;

};

static const enum wc_HashType

  algorithms[] = {

    // [WGET_DIGTYPE_UNKNOWN] = WC_HASH_TYPE_NONE, // both values are 0

    // [WGET_DIGTYPE_MD2] = WC_HASH_TYPE_MD2, // not in wc_hashAlg

    [WGET_DIGTYPE_MD5] = WC_HASH_TYPE_MD5,

    [WGET_DIGTYPE_SHA1] = WC_HASH_TYPE_SHA,

    [WGET_DIGTYPE_SHA224] = WC_HASH_TYPE_SHA224,

    [WGET_DIGTYPE_SHA256] = WC_HASH_TYPE_SHA256,

    [WGET_DIGTYPE_SHA384] = WC_HASH_TYPE_SHA384,

    [WGET_DIGTYPE_SHA512] = WC_HASH_TYPE_SHA512,

};

int wget_hash_fast(wget_digest_algorithm algorithm, const void *text, size_t textlen, void *digest)

{

  if ((unsigned) algorithm >= countof(algorithms))

    return WGET_E_INVALID;

  enum wc_HashType hashtype = algorithms[algorithm];

  if (hashtype == WC_HASH_TYPE_NONE)

    return WGET_E_UNSUPPORTED;

  if (wc_Hash(hashtype, text, (unsigned) textlen, digest, wc_HashGetDigestSize(hashtype)) != 0)

    return WGET_E_UNKNOWN;

  return WGET_E_SUCCESS;

}

int wget_hash_get_len(wget_digest_algorithm algorithm)

{

  if ((unsigned) algorithm < countof(algorithms)) {

    int ret = wc_HashGetDigestSize(algorithms[algorithm]);

    if (ret > 0)

      return ret;

  }

  return 0;

}

int wget_hash_init(wget_hash_hd **handle, wget_digest_algorithm algorithm)

{

  if ((unsigned) algorithm >= countof(algorithms))

    return WGET_E_INVALID;

  enum wc_HashType hashtype = algorithms[algorithm];

  if (hashtype == WC_HASH_TYPE_NONE)

    return WGET_E_UNSUPPORTED;

  if (!(*handle = wget_malloc(sizeof(struct wget_hash_hd_st))))

    return WGET_E_MEMORY;

  if (wc_HashInit(&(*handle)->hash, hashtype) != 0) {

    xfree(*handle);

    return WGET_E_UNKNOWN;

  }

  (*handle)->type = hashtype;

  return WGET_E_SUCCESS;

}

int wget_hash(wget_hash_hd *handle, const void *text, size_t textlen)

{

  if (wc_HashUpdate(&handle->hash, handle->type, text, (unsigned) textlen) == 0)

    return WGET_E_SUCCESS;

  return WGET_E_UNKNOWN;

}

int wget_hash_deinit(wget_hash_hd **handle, void *digest)

{

  int rc = wc_HashFinal(&(*handle)->hash, (*handle)->type, digest);

  xfree(*handle);

  return rc == 0 ? rc : WGET_E_UNKNOWN;

}

#elif defined WITH_LIBCRYPTO

#include <openssl/evp.h>

typedef const EVP_MD *evp_md_func(void);

struct wget_hash_hd_st {

  EVP_MD_CTX

    *ctx;

};

static evp_md_func *

  algorithms[] = {

//    [WGET_DIGTYPE_UNKNOWN] = NULL,

//    [WGET_DIGTYPE_MD2]     = EVP_md2,

    [WGET_DIGTYPE_MD5]     = EVP_md5,

    [WGET_DIGTYPE_RMD160]  = EVP_ripemd160,

    [WGET_DIGTYPE_SHA1]    = EVP_sha1,

    [WGET_DIGTYPE_SHA224]  = EVP_sha224,

    [WGET_DIGTYPE_SHA256]  = EVP_sha256,

    [WGET_DIGTYPE_SHA384]  = EVP_sha384,

    [WGET_DIGTYPE_SHA512]  = EVP_sha512,

  };

int wget_hash_fast(wget_digest_algorithm algorithm, const void *text, size_t textlen, void *digest)

{

  if ((unsigned) algorithm >= countof(algorithms))

    return WGET_E_INVALID;

  evp_md_func *evp = algorithms[algorithm];

  if (!evp)

    return WGET_E_UNSUPPORTED;

  if (EVP_Digest(text, textlen, digest, NULL, evp(), NULL) == 0)

    return WGET_E_UNKNOWN;

  return WGET_E_SUCCESS;

}

int wget_hash_get_len(wget_digest_algorithm algorithm)

{

  evp_md_func *evp;

  if ((unsigned) algorithm >= countof(algorithms)

    || (evp = algorithms[algorithm]) == NULL)

    return 0;

  return EVP_MD_size(evp());

}

int wget_hash_init(wget_hash_hd **handle, wget_digest_algorithm algorithm)

{

  evp_md_func *evp;

  if ((unsigned) algorithm >= countof(algorithms))

    return WGET_E_UNSUPPORTED;

  if ((evp = algorithms[algorithm]) == NULL)

    return WGET_E_UNSUPPORTED;

  if (!(*handle = wget_malloc(sizeof(struct wget_hash_hd_st))))

    return WGET_E_MEMORY;

  if (!((*handle)->ctx = EVP_MD_CTX_new())) {

    xfree(*handle);

    return WGET_E_UNKNOWN;

  }

  if (EVP_DigestInit_ex((*handle)->ctx, evp(), NULL))

    return WGET_E_SUCCESS;

  EVP_MD_CTX_free((*handle)->ctx);

  xfree(*handle);

  return WGET_E_UNKNOWN;

}

int wget_hash(wget_hash_hd *handle, const void *text, size_t textlen)

{

  if (EVP_DigestUpdate(handle->ctx, text, textlen))

    return WGET_E_SUCCESS;

  return WGET_E_INVALID;

}

int wget_hash_deinit(wget_hash_hd **handle, void *digest)

{

  EVP_DigestFinal_ex((*handle)->ctx, digest, NULL);

  EVP_MD_CTX_free((*handle)->ctx);

  xfree(*handle);

  return WGET_E_SUCCESS;

}

#elif defined WITH_LIBNETTLE

#include <nettle/nettle-meta.h>

#include <nettle/md2.h>

#include <nettle/md5.h>

#include <nettle/ripemd160.h>

#include <nettle/sha2.h>

struct wget_hash_hd_st {

  const struct nettle_hash

    *hash;

  void

    *context;

};

static const struct nettle_hash *

  algorithms[WGET_DIGTYPE_MAX] = {

//    [WGET_DIGTYPE_UNKNOWN] = NULL,

    [WGET_DIGTYPE_MD2] = &nettle_md2,

    [WGET_DIGTYPE_MD5] = &nettle_md5,

#ifdef RIPEMD160_DIGEST_SIZE

    [WGET_DIGTYPE_RMD160] = &nettle_ripemd160,

#endif

    [WGET_DIGTYPE_SHA1] = &nettle_sha1,

#ifdef SHA224_DIGEST_SIZE

    [WGET_DIGTYPE_SHA224] = &nettle_sha224,

#endif

#ifdef SHA256_DIGEST_SIZE

    [WGET_DIGTYPE_SHA256] = &nettle_sha256,

#endif

#ifdef SHA384_DIGEST_SIZE

    [WGET_DIGTYPE_SHA384] = &nettle_sha384,

#endif

#ifdef SHA512_DIGEST_SIZE

    [WGET_DIGTYPE_SHA512] = &nettle_sha512,

#endif

};

int wget_hash_fast(wget_digest_algorithm algorithm, const void *text, size_t textlen, void *digest)

{

  wget_hash_hd *dig;

  int rc;

  if ((rc = wget_hash_init(&dig, algorithm)) == 0) {

    rc = wget_hash(dig, text, textlen);

    wget_hash_deinit(&dig, digest);

  }

  return rc;

}

int wget_hash_get_len(wget_digest_algorithm algorithm)

{

  if ((unsigned)algorithm < countof(algorithms))

    return algorithms[algorithm]->digest_size;

  else

    return 0;

}

int wget_hash_init(wget_hash_hd **handle, wget_digest_algorithm algorithm)

{

  if ((unsigned)algorithm >= countof(algorithms))

    return WGET_E_INVALID;

  if (!algorithms[algorithm])

    return WGET_E_UNSUPPORTED;

  wget_hash_hd *h;

  if (!(h = wget_malloc(sizeof(struct wget_hash_hd_st))))

    return WGET_E_MEMORY;

  h->hash = algorithms[algorithm];

  if (!(h->context = wget_malloc(h->hash->context_size))) {

    xfree(h);

    return WGET_E_MEMORY;

  }

  h->hash->init(h->context);

  *handle = h;

  return WGET_E_SUCCESS;

}

int wget_hash(wget_hash_hd *handle, const void *text, size_t textlen)

{

  handle->hash->update(handle->context, textlen, text);

  return WGET_E_SUCCESS;

}

int wget_hash_deinit(wget_hash_hd **handle, void *digest)

{

  (*handle)->hash->digest((*handle)->context, (*handle)->hash->digest_size, digest);

  xfree((*handle)->context);

  xfree(*handle);

  return WGET_E_SUCCESS;

}

#elif defined WITH_GCRYPT

#ifdef HAVE_GCRYPT_H

  #include <gcrypt.h>

#endif

struct wget_hash_hd_st {

  int

    algorithm;

  gcry_md_hd_t

    context;

};

static const int algorithms[] = {

//  [WGET_DIGTYPE_UNKNOWN] = GCRY_MD_NONE,

  [WGET_DIGTYPE_MD2] = GCRY_MD_MD2,

  [WGET_DIGTYPE_MD5] = GCRY_MD_MD5,

  [WGET_DIGTYPE_RMD160] = GCRY_MD_RMD160,

  [WGET_DIGTYPE_SHA1] = GCRY_MD_SHA1,

  [WGET_DIGTYPE_SHA224] = GCRY_MD_SHA224,

  [WGET_DIGTYPE_SHA256] = GCRY_MD_SHA256,

  [WGET_DIGTYPE_SHA384] = GCRY_MD_SHA384,

  [WGET_DIGTYPE_SHA512] = GCRY_MD_SHA512

};

int wget_hash_fast(wget_digest_algorithm algorithm, const void *text, size_t textlen, void *digest)

{

  wget_hash_hd *dig;

  int rc;

  if ((rc = wget_hash_init(&dig, algorithm)) == 0) {

    rc = wget_hash(dig, text, textlen);

    wget_hash_deinit(&dig, digest);

  }

  return rc;

}

int wget_hash_get_len(wget_digest_algorithm algorithm)

{

  if ((unsigned)algorithm < countof(algorithms))

    return gcry_md_get_algo_dlen(algorithms[algorithm]);

  else

    return 0;

}

int wget_hash_init(wget_hash_hd **handle, wget_digest_algorithm algorithm)

{

  if ((unsigned)algorithm >= countof(algorithms))

    return WGET_E_INVALID;

  if (!algorithms[algorithm])

    return WGET_E_UNSUPPORTED;

  wget_hash_hd *h;

  if (!(h = wget_malloc(sizeof(struct wget_hash_hd_st))))

    return WGET_E_MEMORY;

  h->algorithm = algorithms[algorithm];

  gcry_md_open(&h->context, h->algorithm, 0);

  *handle = h;

  return WGET_E_SUCCESS;

}

int wget_hash(wget_hash_hd *handle, const void *text, size_t textlen)

{

  gcry_md_write(handle->context, text, textlen);

  return 0;

}

int wget_hash_deinit(wget_hash_hd **handle, void *digest)

{

  gcry_md_final((*handle)->context);

  void *ret = gcry_md_read((*handle)->context, (*handle)->algorithm);

  memcpy(digest, ret, gcry_md_get_algo_dlen((*handle)->algorithm));

  gcry_md_close((*handle)->context);

  xfree(*handle);

  return WGET_E_SUCCESS;

}

#else // use the gnulib functions

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wundef"

#include "md2.h"

#include "md5.h"

#include "sha1.h"

#include "sha256.h"

#include "sha512.h"

#pragma GCC diagnostic pop

typedef void (*_hash_init_t)(void *);

typedef void (*_hash_process_t)(const void *, size_t, void *);

typedef void (*_hash_finish_t)(void *, void *);

typedef void (*_hash_read_t)(const void *, void *);

static struct _algorithm {

  _hash_init_t init;

  _hash_process_t process;

  _hash_finish_t finish;

  _hash_read_t read;

  size_t ctx_len;

  size_t digest_len;

} _algorithm[WGET_DIGTYPE_MAX] = {

  [WGET_DIGTYPE_MD2] = {

    (_hash_init_t)md2_init_ctx,

    (_hash_process_t)md2_process_bytes,

    (_hash_finish_t)md2_finish_ctx,

    (_hash_read_t)md2_read_ctx,

    sizeof(struct md2_ctx),

    MD2_DIGEST_SIZE

  },

  [WGET_DIGTYPE_MD5] = {

    (_hash_init_t)md5_init_ctx,

    (_hash_process_t)md5_process_bytes,

    (_hash_finish_t)md5_finish_ctx,

    (_hash_read_t)md5_read_ctx,

    sizeof(struct md5_ctx),

    MD5_DIGEST_SIZE

  },

  [WGET_DIGTYPE_SHA1] = {

    (_hash_init_t)sha1_init_ctx,

    (_hash_process_t)sha1_process_bytes,

    (_hash_finish_t)sha1_finish_ctx,

    (_hash_read_t)sha1_read_ctx,

    sizeof(struct sha1_ctx),

    SHA1_DIGEST_SIZE

  },

  [WGET_DIGTYPE_SHA224] = {

    (_hash_init_t)sha224_init_ctx,

    (_hash_process_t)sha256_process_bytes, // sha256 is intentional

    (_hash_finish_t)sha224_finish_ctx,

    (_hash_read_t)sha224_read_ctx,

    sizeof(struct sha256_ctx), // sha256 is intentional

    SHA224_DIGEST_SIZE

  },

  [WGET_DIGTYPE_SHA256] = {

    (_hash_init_t)sha256_init_ctx,

    (_hash_process_t)sha256_process_bytes,

    (_hash_finish_t)sha256_finish_ctx,

    (_hash_read_t)sha256_read_ctx,

    sizeof(struct sha256_ctx),

    SHA256_DIGEST_SIZE

  },

  [WGET_DIGTYPE_SHA384] = {

    (_hash_init_t)sha384_init_ctx,

    (_hash_process_t)sha512_process_bytes, // sha512 is intentional

    (_hash_finish_t)sha384_finish_ctx,

    (_hash_read_t)sha384_read_ctx,

    sizeof(struct sha512_ctx), // sha512 is intentional

    SHA384_DIGEST_SIZE

  },

  [WGET_DIGTYPE_SHA512] = {

    (_hash_init_t)sha512_init_ctx,

    (_hash_process_t)sha512_process_bytes,

    (_hash_finish_t)sha512_finish_ctx,

    (_hash_read_t)sha512_read_ctx,

    sizeof(struct sha512_ctx),

    SHA512_DIGEST_SIZE

  }

};

struct wget_hash_hd_st {

  const struct _algorithm

    *algorithm;

  void

    *context;

};

int wget_hash_fast(wget_digest_algorithm algorithm, const void *text, size_t textlen, void *digest)

{

  wget_hash_hd *dig;

  int rc;

  if ((rc = wget_hash_init(&dig, algorithm)) == WGET_E_SUCCESS) {

    rc = wget_hash(dig, text, textlen);

    wget_hash_deinit(&dig, digest);

  }

  return rc;

}

int wget_hash_get_len(wget_digest_algorithm algorithm)

{

  if ((unsigned)algorithm < countof(_algorithm))

    return (int) _algorithm[algorithm].digest_len;

  else

    return 0;

}

int wget_hash_init(wget_hash_hd **handle, wget_digest_algorithm algorithm)

{

  if ((unsigned)algorithm >= countof(_algorithm))

    return WGET_E_INVALID;

  if (!_algorithm[algorithm].ctx_len)

    return WGET_E_UNSUPPORTED;

  wget_hash_hd *h;

  if (!(h = wget_malloc(sizeof(struct wget_hash_hd_st))))

    return WGET_E_MEMORY;

  h->algorithm = &_algorithm[algorithm];

  if (!(h->context = wget_malloc(h->algorithm->ctx_len))) {

    xfree(h);

    return WGET_E_MEMORY;

  }

  h->algorithm->init(h->context);

  *handle = h;

  return WGET_E_SUCCESS;

}

int wget_hash(wget_hash_hd *handle, const void *text, size_t textlen)

{

  handle->algorithm->process(text, textlen, handle->context);

  return 0;

}

int wget_hash_deinit(wget_hash_hd **handle, void *digest)

{

  (*handle)->algorithm->finish((*handle)->context, digest);

  xfree((*handle)->context);

  xfree(*handle);

  return WGET_E_SUCCESS;

}

#endif

/**

 * \param[in] hashname Name of the hashing algorithm. See wget_hash_get_algorithm()

 * \param[in] fd File descriptor for the target file

 * \param[out] digest_hex caller-supplied buffer that will contain the resulting hex string

 * \param[in] digest_hex_size Length of \p digest_hex

 * \param[in] offset File offset to start hashing at

 * \param[in] length Number of bytes to hash, starting from \p offset. Zero will hash up to the end of the file

 * \return 0 on success or -1 in case of failure

 *

 * Compute the hash of the contents of the target file and return its hex representation.

 *

 * This function will encode the resulting hash in a string of hex digits, and

 * place that string in the user-supplied buffer \p digest_hex.

 */

int wget_hash_file_fd(const char *hashname, int fd, char *digest_hex, size_t digest_hex_size, off_t offset, off_t length)

{

  wget_digest_algorithm algorithm;

  int ret = WGET_E_UNKNOWN;

  struct stat st;

  if (digest_hex_size)

    *digest_hex=0;

  if (fd == -1 || fstat(fd, &st) != 0)

    return WGET_E_IO;

  if (length == 0)

    length = st.st_size;

  if (offset + length > st.st_size)

    return WGET_E_INVALID;

  debug_printf("%s hashing pos %llu, length %llu...\n", hashname, (unsigned long long)offset, (unsigned long long)length);

  if ((algorithm = wget_hash_get_algorithm(hashname)) != WGET_DIGTYPE_UNKNOWN) {

    unsigned char digest[256];

    size_t digestlen = wget_hash_get_len(algorithm);

    if (digestlen > sizeof(digest)) {

      error_printf(_("%s: Unexpected hash len %zu > %zu\n"), __func__, digestlen, sizeof(digest));

      return ret;

    }

#ifdef HAVE_MMAP

    char *buf = mmap(NULL, length, PROT_READ, MAP_PRIVATE, fd, offset);

    if (buf != MAP_FAILED) {

      if (wget_hash_fast(algorithm, buf, length, digest) == 0) {

        wget_memtohex(digest, digestlen, digest_hex, digest_hex_size);

        debug_printf("  hash %s", digest_hex);

        ret = WGET_E_SUCCESS;

      }

      munmap(buf, length);

    } else {

#endif

      // Fallback to read

      ssize_t nbytes = 0;

      wget_hash_hd *dig;

      char tmp[65536];

      if ((ret = wget_hash_init(&dig, algorithm))) {

        error_printf(_("%s: Hash init failed for type '%s': %s\n"), __func__, hashname, wget_strerror(ret));

        return ret;

      }

      while (length > 0 && (nbytes = read(fd, tmp, sizeof(tmp))) > 0) {

        if ((ret = wget_hash(dig, tmp, nbytes))) {

          error_printf(_("%s: Hash update failed: %s\n"), __func__, wget_strerror(ret));

          return ret;

        }

        if (nbytes <= length)

          length -= nbytes;

        else

          length = 0;

      }

      if ((ret = wget_hash_deinit(&dig, digest))) {

        error_printf(_("%s: Hash finalization failed: %s\n"), __func__, wget_strerror(ret));

        return ret;

      }

      if (nbytes < 0) {

        error_printf(_("%s: Failed to read %llu bytes\n"), __func__, (unsigned long long)length);

        return WGET_E_IO;

      }

      wget_memtohex(digest, digestlen, digest_hex, digest_hex_size);

      ret = WGET_E_SUCCESS;

#ifdef HAVE_MMAP

    }

#endif

  }

  return ret;

}

/**

 * \param[in] hashname Name of the hashing algorithm. See wget_hash_get_algorithm()

 * \param[in] fname Target file name

 * \param[out] digest_hex Caller-supplied buffer that will contain the resulting hex string

 * \param[in] digest_hex_size Length of \p digest_hex

 * \param[in] offset File offset to start hashing at

 * \param[in] length Number of bytes to hash, starting from \p offset.  Zero will hash up to the end of the file

 * \return 0 on success or -1 in case of failure

 *

 * Compute the hash of the contents of the target file starting from \p offset and up to \p length bytes

 * and return its hex representation.

 *

 * This function will encode the resulting hash in a string of hex digits, and

 * place that string in the user-supplied buffer \p digest_hex.

 */

int wget_hash_file_offset(const char *hashname, const char *fname, char *digest_hex, size_t digest_hex_size, off_t offset, off_t length)

{

  int fd, ret;

  if ((fd = open(fname, O_RDONLY|O_BINARY)) == -1) {

    if (digest_hex_size)

      *digest_hex=0;

    return 0;

  }

  ret = wget_hash_file_fd(hashname, fd, digest_hex, digest_hex_size, offset, length);

  close(fd);

  return ret;

}

/**

 * \param[in] hashname Name of the hashing algorithm. See wget_hash_get_algorithm()

 * \param[in] fname Target file name

 * \param[out] digest_hex Caller-supplied buffer that will contain the resulting hex string

 * \param[in] digest_hex_size Length of \p digest_hex

 * \return 0 on success or -1 in case of failure

 *

 * Compute the hash of the contents of the target file and return its hex representation.

 *

 * This function will encode the resulting hash in a string of hex digits, and

 * place that string in the user-supplied buffer \p digest_hex.

 */

int wget_hash_file(const char *hashname, const char *fname, char *digest_hex, size_t digest_hex_size)

{

  return wget_hash_file_offset(hashname, fname, digest_hex, digest_hex_size, 0, 0);

}

/**@}*/