hmac.c File Reference

#include "postgres.h"
#include "common/cryptohash.h"
#include "common/hmac.h"
#include "common/md5.h"
#include "common/sha1.h"
#include "common/sha2.h"

Include dependency graph for hmac.c:

Go to the source code of this file.

Data Structures
struct	pg_hmac_ctx

Macros
#define	ALLOC(size)   palloc(size)
#define	FREE(ptr)   pfree(ptr)
#define	HMAC_IPAD   0x36
#define	HMAC_OPAD   0x5C

Typedefs
typedef enum pg_hmac_errno	pg_hmac_errno

Enumerations
enum	pg_hmac_errno {   PG_HMAC_ERROR_NONE = 0 , PG_HMAC_ERROR_OOM , PG_HMAC_ERROR_INTERNAL , PG_HMAC_ERROR_NONE = 0 ,   PG_HMAC_ERROR_DEST_LEN , PG_HMAC_ERROR_OPENSSL }

Functions
pg_hmac_ctx *	pg_hmac_create (pg_cryptohash_type type)
int	pg_hmac_init (pg_hmac_ctx *ctx, const uint8 *key, size_t len)
int	pg_hmac_update (pg_hmac_ctx *ctx, const uint8 *data, size_t len)
int	pg_hmac_final (pg_hmac_ctx *ctx, uint8 *dest, size_t len)
void	pg_hmac_free (pg_hmac_ctx *ctx)
const char *	pg_hmac_error (pg_hmac_ctx *ctx)

Macro Definition Documentation

ALLOC

#define ALLOC

(

size

)

palloc(size)

Definition at line 34 of file hmac.c.

FREE

#define FREE

(

ptr

)

pfree(ptr)

Definition at line 35 of file hmac.c.

HMAC_IPAD

#define HMAC_IPAD   0x36

Definition at line 67 of file hmac.c.

HMAC_OPAD

#define HMAC_OPAD   0x5C

Definition at line 68 of file hmac.c.

Typedef Documentation

pg_hmac_errno

typedef enum pg_hmac_errno pg_hmac_errno

Enumeration Type Documentation

pg_hmac_errno

enum pg_hmac_errno

Enumerator
PG_HMAC_ERROR_NONE
PG_HMAC_ERROR_OOM
PG_HMAC_ERROR_INTERNAL
PG_HMAC_ERROR_NONE
PG_HMAC_ERROR_DEST_LEN
PG_HMAC_ERROR_OPENSSL

Definition at line 42 of file hmac.c.

{
    PG_HMAC_ERROR_NONE = 0,
    PG_HMAC_ERROR_OOM,
    PG_HMAC_ERROR_INTERNAL,
} pg_hmac_errno;

Function Documentation

pg_hmac_create()

pg_hmac_ctx* pg_hmac_create

(

pg_cryptohash_type

type

)

Definition at line 77 of file hmac.c.

{
    pg_hmac_ctx *ctx;
 
    ctx = ALLOC(sizeof(pg_hmac_ctx));
    if (ctx == NULL)
        return NULL;
    memset(ctx, 0, sizeof(pg_hmac_ctx));
    ctx->type = type;
    ctx->error = PG_HMAC_ERROR_NONE;
    ctx->errreason = NULL;
 
    /*
     * Initialize the context data.  This requires to know the digest and
     * block lengths, that depend on the type of hash used.
     */
    switch (type)
    {
        case PG_MD5:
            ctx->digest_size = MD5_DIGEST_LENGTH;
            ctx->block_size = MD5_BLOCK_SIZE;
            break;
        case PG_SHA1:
            ctx->digest_size = SHA1_DIGEST_LENGTH;
            ctx->block_size = SHA1_BLOCK_SIZE;
            break;
        case PG_SHA224:
            ctx->digest_size = PG_SHA224_DIGEST_LENGTH;
            ctx->block_size = PG_SHA224_BLOCK_LENGTH;
            break;
        case PG_SHA256:
            ctx->digest_size = PG_SHA256_DIGEST_LENGTH;
            ctx->block_size = PG_SHA256_BLOCK_LENGTH;
            break;
        case PG_SHA384:
            ctx->digest_size = PG_SHA384_DIGEST_LENGTH;
            ctx->block_size = PG_SHA384_BLOCK_LENGTH;
            break;
        case PG_SHA512:
            ctx->digest_size = PG_SHA512_DIGEST_LENGTH;
            ctx->block_size = PG_SHA512_BLOCK_LENGTH;
            break;
    }
 
    ctx->hash = pg_cryptohash_create(type);
    if (ctx->hash == NULL)
    {
        explicit_bzero(ctx, sizeof(pg_hmac_ctx));
        FREE(ctx);
        return NULL;
    }
 
    return ctx;
}

References ALLOC, pg_hmac_ctx::block_size, pg_hmac_ctx::digest_size, pg_hmac_ctx::error, pg_hmac_ctx::errreason, explicit_bzero(), FREE, pg_hmac_ctx::hash, MD5_BLOCK_SIZE, MD5_DIGEST_LENGTH, pg_cryptohash_create(), PG_HMAC_ERROR_NONE, PG_MD5, PG_SHA1, PG_SHA224, PG_SHA224_BLOCK_LENGTH, PG_SHA224_DIGEST_LENGTH, PG_SHA256, PG_SHA256_BLOCK_LENGTH, PG_SHA256_DIGEST_LENGTH, PG_SHA384, PG_SHA384_BLOCK_LENGTH, PG_SHA384_DIGEST_LENGTH, PG_SHA512, PG_SHA512_BLOCK_LENGTH, PG_SHA512_DIGEST_LENGTH, SHA1_BLOCK_SIZE, SHA1_DIGEST_LENGTH, type, and pg_hmac_ctx::type.

Referenced by build_server_final_message(), calculate_client_proof(), scram_ClientKey(), scram_SaltedPassword(), scram_ServerKey(), verify_client_proof(), and verify_server_signature().

pg_hmac_error()

const char* pg_hmac_error

(

pg_hmac_ctx *

ctx

)

Definition at line 306 of file hmac.c.

{
    if (ctx == NULL)
        return _("out of memory");
 
    /*
     * If a reason is provided, rely on it, else fallback to any error code
     * set.
     */
    if (ctx->errreason)
        return ctx->errreason;
 
    switch (ctx->error)
    {
        case PG_HMAC_ERROR_NONE:
            return _("success");
        case PG_HMAC_ERROR_INTERNAL:
            return _("internal error");
        case PG_HMAC_ERROR_OOM:
            return _("out of memory");
    }
 
    Assert(false);              /* cannot be reached */
    return _("success");
}

References _, Assert, pg_hmac_ctx::error, pg_hmac_ctx::errreason, PG_HMAC_ERROR_INTERNAL, PG_HMAC_ERROR_NONE, and PG_HMAC_ERROR_OOM.

Referenced by build_server_final_message(), calculate_client_proof(), scram_ClientKey(), scram_SaltedPassword(), scram_ServerKey(), verify_client_proof(), and verify_server_signature().

pg_hmac_final()

int pg_hmac_final	(	pg_hmac_ctx *	ctx,
		uint8 *	dest,
		size_t	len
	)

Definition at line 244 of file hmac.c.

{
    uint8      *h;
 
    if (ctx == NULL)
        return -1;
 
    h = ALLOC(ctx->digest_size);
    if (h == NULL)
    {
        ctx->error = PG_HMAC_ERROR_OOM;
        return -1;
    }
    memset(h, 0, ctx->digest_size);
 
    if (pg_cryptohash_final(ctx->hash, h, ctx->digest_size) < 0)
    {
        ctx->error = PG_HMAC_ERROR_INTERNAL;
        ctx->errreason = pg_cryptohash_error(ctx->hash);
        FREE(h);
        return -1;
    }
 
    /* H(K XOR opad, tmp) */
    if (pg_cryptohash_init(ctx->hash) < 0 ||
        pg_cryptohash_update(ctx->hash, ctx->k_opad, ctx->block_size) < 0 ||
        pg_cryptohash_update(ctx->hash, h, ctx->digest_size) < 0 ||
        pg_cryptohash_final(ctx->hash, dest, len) < 0)
    {
        ctx->error = PG_HMAC_ERROR_INTERNAL;
        ctx->errreason = pg_cryptohash_error(ctx->hash);
        FREE(h);
        return -1;
    }
 
    FREE(h);
    return 0;
}

References ALLOC, pg_hmac_ctx::block_size, generate_unaccent_rules::dest, pg_hmac_ctx::digest_size, pg_hmac_ctx::error, pg_hmac_ctx::errreason, FREE, pg_hmac_ctx::hash, pg_hmac_ctx::k_opad, len, pg_cryptohash_error(), pg_cryptohash_final(), pg_cryptohash_init(), pg_cryptohash_update(), PG_HMAC_ERROR_INTERNAL, and PG_HMAC_ERROR_OOM.

Referenced by build_server_final_message(), calculate_client_proof(), scram_ClientKey(), scram_SaltedPassword(), scram_ServerKey(), verify_client_proof(), and verify_server_signature().

pg_hmac_free()

void pg_hmac_free

(

pg_hmac_ctx *

ctx

)

Definition at line 289 of file hmac.c.

{
    if (ctx == NULL)
        return;
 
    pg_cryptohash_free(ctx->hash);
    explicit_bzero(ctx, sizeof(pg_hmac_ctx));
    FREE(ctx);
}

References explicit_bzero(), FREE, pg_hmac_ctx::hash, and pg_cryptohash_free().

Referenced by build_server_final_message(), calculate_client_proof(), scram_ClientKey(), scram_SaltedPassword(), scram_ServerKey(), verify_client_proof(), and verify_server_signature().

pg_hmac_init()

int pg_hmac_init	(	pg_hmac_ctx *	ctx,
		const uint8 *	key,
		size_t	len
	)

Definition at line 138 of file hmac.c.

{
    int         i;
    int         digest_size;
    int         block_size;
    uint8      *shrinkbuf = NULL;
 
    if (ctx == NULL)
        return -1;
 
    digest_size = ctx->digest_size;
    block_size = ctx->block_size;
 
    memset(ctx->k_opad, HMAC_OPAD, ctx->block_size);
    memset(ctx->k_ipad, HMAC_IPAD, ctx->block_size);
 
    /*
     * If the key is longer than the block size, pass it through the hash once
     * to shrink it down.
     */
    if (len > block_size)
    {
        pg_cryptohash_ctx *hash_ctx;
 
        /* temporary buffer for one-time shrink */
        shrinkbuf = ALLOC(digest_size);
        if (shrinkbuf == NULL)
        {
            ctx->error = PG_HMAC_ERROR_OOM;
            return -1;
        }
        memset(shrinkbuf, 0, digest_size);
 
        hash_ctx = pg_cryptohash_create(ctx->type);
        if (hash_ctx == NULL)
        {
            ctx->error = PG_HMAC_ERROR_OOM;
            FREE(shrinkbuf);
            return -1;
        }
 
        if (pg_cryptohash_init(hash_ctx) < 0 ||
            pg_cryptohash_update(hash_ctx, key, len) < 0 ||
            pg_cryptohash_final(hash_ctx, shrinkbuf, digest_size) < 0)
        {
            ctx->error = PG_HMAC_ERROR_INTERNAL;
            ctx->errreason = pg_cryptohash_error(hash_ctx);
            pg_cryptohash_free(hash_ctx);
            FREE(shrinkbuf);
            return -1;
        }
 
        key = shrinkbuf;
        len = digest_size;
        pg_cryptohash_free(hash_ctx);
    }
 
    for (i = 0; i < len; i++)
    {
        ctx->k_ipad[i] ^= key[i];
        ctx->k_opad[i] ^= key[i];
    }
 
    /* tmp = H(K XOR ipad, text) */
    if (pg_cryptohash_init(ctx->hash) < 0 ||
        pg_cryptohash_update(ctx->hash, ctx->k_ipad, ctx->block_size) < 0)
    {
        ctx->error = PG_HMAC_ERROR_INTERNAL;
        ctx->errreason = pg_cryptohash_error(ctx->hash);
        if (shrinkbuf)
            FREE(shrinkbuf);
        return -1;
    }
 
    if (shrinkbuf)
        FREE(shrinkbuf);
    return 0;
}

References ALLOC, block_size, pg_hmac_ctx::block_size, pg_hmac_ctx::digest_size, pg_hmac_ctx::error, pg_hmac_ctx::errreason, FREE, pg_hmac_ctx::hash, HMAC_IPAD, HMAC_OPAD, i, pg_hmac_ctx::k_ipad, pg_hmac_ctx::k_opad, sort-test::key, len, pg_cryptohash_create(), pg_cryptohash_error(), pg_cryptohash_final(), pg_cryptohash_free(), pg_cryptohash_init(), pg_cryptohash_update(), PG_HMAC_ERROR_INTERNAL, PG_HMAC_ERROR_OOM, and pg_hmac_ctx::type.

Referenced by build_server_final_message(), calculate_client_proof(), scram_ClientKey(), scram_SaltedPassword(), scram_ServerKey(), verify_client_proof(), and verify_server_signature().

pg_hmac_update()

int pg_hmac_update	(	pg_hmac_ctx *	ctx,
		const uint8 *	data,
		size_t	len
	)

Definition at line 223 of file hmac.c.

{
    if (ctx == NULL)
        return -1;
 
    if (pg_cryptohash_update(ctx->hash, data, len) < 0)
    {
        ctx->error = PG_HMAC_ERROR_INTERNAL;
        ctx->errreason = pg_cryptohash_error(ctx->hash);
        return -1;
    }
 
    return 0;
}

References data, pg_hmac_ctx::error, pg_hmac_ctx::errreason, pg_hmac_ctx::hash, len, pg_cryptohash_error(), pg_cryptohash_update(), and PG_HMAC_ERROR_INTERNAL.

Referenced by build_server_final_message(), calculate_client_proof(), scram_ClientKey(), scram_SaltedPassword(), scram_ServerKey(), verify_client_proof(), and verify_server_signature().