cryptohash_openssl.c File Reference

#include "postgres.h"
#include <openssl/evp.h>
#include "common/cryptohash.h"
#include "common/md5.h"
#include "common/sha1.h"
#include "common/sha2.h"
#include "utils/memutils.h"
#include "utils/resowner.h"
#include "utils/resowner_private.h"

Include dependency graph for cryptohash_openssl.c:

Go to the source code of this file.

Data Structures
struct	pg_cryptohash_ctx

Macros
#define	ALLOC(size)   MemoryContextAlloc(TopMemoryContext, size)
#define	FREE(ptr)   pfree(ptr)

Functions
pg_cryptohash_ctx *	pg_cryptohash_create (pg_cryptohash_type type)
int	pg_cryptohash_init (pg_cryptohash_ctx *ctx)
int	pg_cryptohash_update (pg_cryptohash_ctx *ctx, const uint8 *data, size_t len)
int	pg_cryptohash_final (pg_cryptohash_ctx *ctx, uint8 *dest, size_t len)
void	pg_cryptohash_free (pg_cryptohash_ctx *ctx)

Macro Definition Documentation

ALLOC

#define ALLOC

(

size

)

MemoryContextAlloc(TopMemoryContext, size)

Definition at line 42 of file cryptohash_openssl.c.

Referenced by pg_cryptohash_create().

FREE

#define FREE

(

ptr

)

pfree(ptr)

Definition at line 43 of file cryptohash_openssl.c.

Referenced by pg_cryptohash_create(), and pg_cryptohash_free().

Function Documentation

pg_cryptohash_create()

pg_cryptohash_ctx* pg_cryptohash_create

(

pg_cryptohash_type

type

)

Definition at line 73 of file cryptohash_openssl.c.

References ALLOC, CurrentResourceOwner, ereport, errcode(), errmsg(), ERROR, pg_cryptohash_ctx::evpctx, explicit_bzero(), FREE, PointerGetDatum, ResourceOwnerEnlargeCryptoHash(), ResourceOwnerRememberCryptoHash(), pg_cryptohash_ctx::resowner, and pg_cryptohash_ctx::type.

{
    pg_cryptohash_ctx *ctx;

    /*
     * Make sure that the resource owner has space to remember this reference.
     * This can error out with "out of memory", so do this before any other
     * allocation to avoid leaking.
     */
#ifndef FRONTEND
    ResourceOwnerEnlargeCryptoHash(CurrentResourceOwner);
#endif

    ctx = ALLOC(sizeof(pg_cryptohash_ctx));
    if (ctx == NULL)
        return NULL;
    memset(ctx, 0, sizeof(pg_cryptohash_ctx));
    ctx->type = type;

    /*
     * Initialization takes care of assigning the correct type for OpenSSL.
     */
    ctx->evpctx = EVP_MD_CTX_create();

    if (ctx->evpctx == NULL)
    {
        explicit_bzero(ctx, sizeof(pg_cryptohash_ctx));
        FREE(ctx);
#ifndef FRONTEND
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));
#else
        return NULL;
#endif
    }

#ifndef FRONTEND
    ctx->resowner = CurrentResourceOwner;
    ResourceOwnerRememberCryptoHash(CurrentResourceOwner,
                                    PointerGetDatum(ctx));
#endif

    return ctx;
}

pg_cryptohash_final()

int pg_cryptohash_final	(	pg_cryptohash_ctx *	ctx,
		uint8 *	dest,
		size_t	len
	)

Definition at line 187 of file cryptohash_openssl.c.

References pg_cryptohash_ctx::data, pg_cryptohash_ctx::evpctx, pg_cryptohash_ctx::md5, MD5_DIGEST_LENGTH, PG_MD5, pg_md5_final(), PG_SHA1, pg_sha1_final(), PG_SHA224, PG_SHA224_DIGEST_LENGTH, pg_sha224_final(), PG_SHA256, PG_SHA256_DIGEST_LENGTH, pg_sha256_final(), PG_SHA384, PG_SHA384_DIGEST_LENGTH, pg_sha384_final(), PG_SHA512, PG_SHA512_DIGEST_LENGTH, pg_sha512_final(), pg_cryptohash_ctx::sha1, SHA1_DIGEST_LENGTH, pg_cryptohash_ctx::sha224, pg_cryptohash_ctx::sha256, pg_cryptohash_ctx::sha384, pg_cryptohash_ctx::sha512, status(), and pg_cryptohash_ctx::type.

{
    int         status = 0;

    if (ctx == NULL)
        return -1;

    switch (ctx->type)
    {
        case PG_MD5:
            if (len < MD5_DIGEST_LENGTH)
                return -1;
            break;
        case PG_SHA1:
            if (len < SHA1_DIGEST_LENGTH)
                return -1;
            break;
        case PG_SHA224:
            if (len < PG_SHA224_DIGEST_LENGTH)
                return -1;
            break;
        case PG_SHA256:
            if (len < PG_SHA256_DIGEST_LENGTH)
                return -1;
            break;
        case PG_SHA384:
            if (len < PG_SHA384_DIGEST_LENGTH)
                return -1;
            break;
        case PG_SHA512:
            if (len < PG_SHA512_DIGEST_LENGTH)
                return -1;
            break;
    }

    status = EVP_DigestFinal_ex(ctx->evpctx, dest, 0);

    /* OpenSSL internals return 1 on success, 0 on failure */
    if (status <= 0)
        return -1;
    return 0;
}

pg_cryptohash_free()

void pg_cryptohash_free

(

pg_cryptohash_ctx *

ctx

)

Definition at line 236 of file cryptohash_openssl.c.

References pg_cryptohash_ctx::evpctx, explicit_bzero(), FREE, PointerGetDatum, ResourceOwnerForgetCryptoHash(), and pg_cryptohash_ctx::resowner.

{
    if (ctx == NULL)
        return;

    EVP_MD_CTX_destroy(ctx->evpctx);

#ifndef FRONTEND
    ResourceOwnerForgetCryptoHash(ctx->resowner,
                                  PointerGetDatum(ctx));
#endif

    explicit_bzero(ctx, sizeof(pg_cryptohash_ctx));
    FREE(ctx);
}

pg_cryptohash_init()

int pg_cryptohash_init

(

pg_cryptohash_ctx *

ctx

)

Definition at line 125 of file cryptohash_openssl.c.

References pg_cryptohash_ctx::data, pg_cryptohash_ctx::evpctx, pg_cryptohash_ctx::md5, PG_MD5, pg_md5_init(), PG_SHA1, pg_sha1_init(), PG_SHA224, pg_sha224_init(), PG_SHA256, pg_sha256_init(), PG_SHA384, pg_sha384_init(), PG_SHA512, pg_sha512_init(), pg_cryptohash_ctx::sha1, pg_cryptohash_ctx::sha224, pg_cryptohash_ctx::sha256, pg_cryptohash_ctx::sha384, pg_cryptohash_ctx::sha512, status(), and pg_cryptohash_ctx::type.

{
    int         status = 0;

    if (ctx == NULL)
        return -1;

    switch (ctx->type)
    {
        case PG_MD5:
            status = EVP_DigestInit_ex(ctx->evpctx, EVP_md5(), NULL);
            break;
        case PG_SHA1:
            status = EVP_DigestInit_ex(ctx->evpctx, EVP_sha1(), NULL);
            break;
        case PG_SHA224:
            status = EVP_DigestInit_ex(ctx->evpctx, EVP_sha224(), NULL);
            break;
        case PG_SHA256:
            status = EVP_DigestInit_ex(ctx->evpctx, EVP_sha256(), NULL);
            break;
        case PG_SHA384:
            status = EVP_DigestInit_ex(ctx->evpctx, EVP_sha384(), NULL);
            break;
        case PG_SHA512:
            status = EVP_DigestInit_ex(ctx->evpctx, EVP_sha512(), NULL);
            break;
    }

    /* OpenSSL internals return 1 on success, 0 on failure */
    if (status <= 0)
        return -1;
    return 0;
}

pg_cryptohash_update()

int pg_cryptohash_update	(	pg_cryptohash_ctx *	ctx,
		const uint8 *	data,
		size_t	len
	)

Definition at line 166 of file cryptohash_openssl.c.

References pg_cryptohash_ctx::data, pg_cryptohash_ctx::evpctx, pg_cryptohash_ctx::md5, PG_MD5, pg_md5_update(), PG_SHA1, pg_sha1_update(), PG_SHA224, pg_sha224_update(), PG_SHA256, pg_sha256_update(), PG_SHA384, pg_sha384_update(), PG_SHA512, pg_sha512_update(), pg_cryptohash_ctx::sha1, pg_cryptohash_ctx::sha224, pg_cryptohash_ctx::sha256, pg_cryptohash_ctx::sha384, pg_cryptohash_ctx::sha512, status(), and pg_cryptohash_ctx::type.

{
    int         status = 0;

    if (ctx == NULL)
        return -1;

    status = EVP_DigestUpdate(ctx->evpctx, data, len);

    /* OpenSSL internals return 1 on success, 0 on failure */
    if (status <= 0)
        return -1;
    return 0;
}