HMAC, HMAC_CTX_new, HMAC_CTX_reset, HMAC_CTX_free, HMAC_Init, HMAC_Init_ex,
HMAC_Update, HMAC_Final, HMAC_CTX_copy, HMAC_CTX_set_flags, HMAC_CTX_get_md -
HMAC message authentication code
unsigned char *HMAC(const EVP_MD *evp_md, const void *key,
int key_len, const unsigned char *d, int n,
unsigned char *md, unsigned int *md_len);
int HMAC_CTX_reset(HMAC_CTX *ctx);
int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int key_len,
const EVP_MD *md, ENGINE *impl);
int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, int len);
int HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len);
void HMAC_CTX_free(HMAC_CTX *ctx);
int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx);
void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags);
const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx);
#if OPENSSL_API_COMPAT < 0x10100000L
int HMAC_Init(HMAC_CTX *ctx, const void *key, int key_len,
const EVP_MD *md);
HMAC is a MAC (message authentication code), i.e. a keyed hash function used for
message authentication, which is based on a hash function.
computes the message authentication code of the n
using the hash function evp_md
and the key key
It places the result in md
(which must have space for the output of the
hash function, which is no more than EVP_MAX_MD_SIZE
is NULL, the digest is placed in a static array. The size of the
output is placed in md_len
, unless it is NULL
. Note: passing a
NULL value for md
to use the static array is not thread safe.
can be EVP_sha1()
creates a new HMAC_CTX in heap memory.
zeroes an existing HMAC_CTX
resources, making it suitable for new computations as if it was newly created
erases the key and other data from the HMAC_CTX
releases any associated resources and finally frees the HMAC_CTX
The following functions may be used if the message is not completely stored in
initializes a HMAC_CTX
structure to use the hash
and the key key
which is key_len
long. It is deprecated and only included for backward compatibility with
initializes or reuses a HMAC_CTX
structure to use
the hash function evp_md
and key key
. If both are NULL (or
is the same as the previous digest used by ctx
is NULL) the existing key is reused. ctx
must have been
created with HMAC_CTX_new()
before the first use of an HMAC_CTX
in this function. N.B. HMAC_Init() had this
undocumented behaviour in previous versions of OpenSSL - failure to
switch to HMAC_Init_ex() in programs that expect
it will cause them to stop working
is called with key
is not the same as the previous digest used by ctx
an error is returned because reuse of an existing key with a different digest
is not supported.
can be called repeatedly with chunks of the message to be
authenticated ( len
bytes at data
places the message authentication code in md
must have space for the hash function output.
copies all of the internal state from sctx
applies the specified flags to the internal
EVP_MD_CTXs. These flags have the same meaning as for
returns the EVP_MD that has previously been set for the
returns a pointer to the message authentication code or NULL if an
returns a pointer to a new HMAC_CTX
on success or
if an error occurred.
return 1 for success or 0 if an
return the EVP_MD previously set for the supplied
HMAC_CTX or NULL if no EVP_MD has been set.
was replaced with HMAC_CTX_reset()
existed in OpenSSL versions before 1.1.0.
new in OpenSSL version 1.1.0.
return values in versions of OpenSSL before 1.0.0.
Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved.
Licensed under the OpenSSL license (the "License"). You may not use
this file except in compliance with the License. You can obtain a copy in the
file LICENSE in the source distribution or at