hash.h File Reference

#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
#include <openssl/evp.h>

Include dependency graph for hash.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	YH_INTERNAL   __attribute__((visibility("hidden")))

Enumerations
enum	hash_t {   _NONE , _SHA1 , _SHA256 , _SHA384 ,   _SHA512 }

Functions
bool YH_INTERNAL	hash_bytes (const uint8_t *in, size_t len, hash_t hash, uint8_t *out, size_t *out_len)
bool YH_INTERNAL	hash_create (hash_ctx *ctx, hash_t hash)
bool YH_INTERNAL	hash_init (hash_ctx ctx)
bool YH_INTERNAL	hash_update (hash_ctx ctx, const uint8_t *in, size_t cb_in)
bool YH_INTERNAL	hash_final (hash_ctx ctx, uint8_t *out, size_t *pcb_out)
bool YH_INTERNAL	hash_destroy (hash_ctx ctx)
const YH_INTERNAL EVP_MD *	get_hash (hash_t hash)

Macro Definition Documentation

YH_INTERNAL

#define YH_INTERNAL   __attribute__((visibility("hidden")))

Definition at line 42 of file hash.h.

Enumeration Type Documentation

hash_t

enum hash_t

Enumerator
_NONE
_SHA1
_SHA256
_SHA384
_SHA512

Definition at line 33 of file hash.h.

             {
  _NONE,
  _SHA1,
  _SHA256,
  _SHA384,
  _SHA512,
} hash_t;

Function Documentation

get_hash()

const YH_INTERNAL EVP_MD * get_hash

(

hash_t

hash

)

Definition at line 42 of file hash.c.

                                                {
  switch (hash) {
    case _NONE:
      return NULL;
 
    case _SHA1:
      return EVP_sha1();
 
    case _SHA256:
      return EVP_sha256();
 
    case _SHA384:
      return EVP_sha384();
 
    case _SHA512:
      return EVP_sha512();
 
    default:
      return NULL;
  }
}

Here is the caller graph for this function:

hash_bytes()

bool YH_INTERNAL hash_bytes	(	const uint8_t *	in,
		size_t	len,
		hash_t	hash,
		uint8_t *	out,
		size_t *	out_len )

Definition at line 90 of file hash.c.

                                 {
#ifndef _WIN32_BCRYPT
 
  const EVP_MD *md;
 
  uint32_t d_len;
 
  md = get_hash(hash);
  if (md == NULL) {
    return false;
  }
 
  EVP_MD_CTX *mdctx = EVP_MD_CTX_create();
  EVP_DigestInit_ex(mdctx, md, NULL);
  EVP_DigestUpdate(mdctx, in, len);
  EVP_DigestFinal_ex(mdctx, out, &d_len);
 
  *out_len = (uint16_t) d_len;
 
  EVP_MD_CTX_destroy(mdctx);
 
  return true;
 
#else
 
  bool res = false;
  NTSTATUS status = 0;
  LPCWSTR alg = NULL;
  BCRYPT_ALG_HANDLE hAlg = 0;
  BCRYPT_HASH_HANDLE hHash = 0;
  DWORD cbHashObj = 0;
  DWORD cbHash = 0;
  DWORD cbData = 0;
  PBYTE pbHashObj = NULL;
 
  alg = get_hash(hash);
  if (alg == NULL) {
    return false;
  }
 
  if (!BCRYPT_SUCCESS(status =
                        BCryptOpenAlgorithmProvider(&hAlg, alg, NULL, 0))) {
    goto cleanup;
  }
 
  if (!BCRYPT_SUCCESS(status = BCryptGetProperty(hAlg, BCRYPT_OBJECT_LENGTH,
                                                 (PBYTE) &cbHashObj,
                                                 sizeof(DWORD), &cbData, 0))) {
    goto cleanup;
  }
 
  if (!(pbHashObj = (PBYTE) malloc(cbHashObj))) {
    goto cleanup;
  }
 
  if (!BCRYPT_SUCCESS(status = BCryptGetProperty(hAlg, BCRYPT_HASH_LENGTH,
                                                 (PBYTE) &cbHash, sizeof(DWORD),
                                                 &cbData, 0))) {
    goto cleanup;
  }
 
  if (*out_len < cbHash) {
    goto cleanup;
  }
 
  if (!BCRYPT_SUCCESS(status = BCryptCreateHash(hAlg, &hHash, pbHashObj,
                                                cbHashObj, NULL, 0, 0))) {
    goto cleanup;
  }
 
  if (!BCRYPT_SUCCESS(status = BCryptHashData(hHash, (PBYTE) in, len, 0))) {
    goto cleanup;
  }
 
  if (!BCRYPT_SUCCESS(status = BCryptFinishHash(hHash, out, cbHash, 0))) {
    goto cleanup;
  }
 
  *out_len = cbHash;
  res = true;
 
cleanup:
 
  if (pbHashObj) {
    free(pbHashObj);
  }
  if (hHash) {
    BCryptDestroyHash(hHash);
  }
  if (hAlg) {
    BCryptCloseAlgorithmProvider(hAlg, 0);
  }
 
  return res;
 
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

hash_create()

bool YH_INTERNAL hash_create	(	hash_ctx *	ctx,
		hash_t	hash )

hash_destroy()

bool YH_INTERNAL hash_destroy

(

hash_ctx

ctx

)

hash_final()

bool YH_INTERNAL hash_final	(	hash_ctx	ctx,
		uint8_t *	out,
		size_t *	pcb_out )

hash_init()

bool YH_INTERNAL hash_init

(

hash_ctx

ctx

)

hash_update()

bool YH_INTERNAL hash_update	(	hash_ctx	ctx,
		const uint8_t *	in,
		size_t	cb_in )