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

Typedefs
typedef struct pg_cryptohash_ctx	pg_cryptohash_ctx

Enumerations
enum	pg_cryptohash_type { PG_MD5 = 0 , PG_SHA1 , PG_SHA224 , PG_SHA256 , PG_SHA384 , PG_SHA512 }

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)

const char *	pg_cryptohash_error (pg_cryptohash_ctx *ctx)

Typedef Documentation

◆ pg_cryptohash_ctx

typedef struct pg_cryptohash_ctx pg_cryptohash_ctx

Definition at line 30 of file cryptohash.h.

Enumeration Type Documentation

◆ pg_cryptohash_type

enum pg_cryptohash_type

Enumerator
PG_MD5
PG_SHA1
PG_SHA224
PG_SHA256
PG_SHA384
PG_SHA512

Definition at line 19 of file cryptohash.h.

{
    PG_MD5 = 0,
    PG_SHA1,
    PG_SHA224,
    PG_SHA256,
    PG_SHA384,
    PG_SHA512,
} pg_cryptohash_type;

Function Documentation

◆ pg_cryptohash_create()

pg_cryptohash_ctx * pg_cryptohash_create ( pg_cryptohash_type type )

Definition at line 74 of file cryptohash.c.

{
    pg_cryptohash_ctx *ctx;
 
    /*
     * Note that this always allocates enough space for the largest hash. A
     * smaller allocation would be enough for md5, sha224 and sha256, but the
     * small extra amount of memory does not make it worth complicating this
     * code.
     */
    ctx = ALLOC(sizeof(pg_cryptohash_ctx));
    if (ctx == NULL)
        return NULL;
 
    memset(ctx, 0, sizeof(pg_cryptohash_ctx));
    ctx->type = type;
    ctx->error = PG_CRYPTOHASH_ERROR_NONE;
    return ctx;
}

References ALLOC, CurrentResourceOwner, ereport, errcode(), errmsg(), pg_cryptohash_ctx::error, ERROR, pg_cryptohash_ctx::errreason, pg_cryptohash_ctx::evpctx, explicit_bzero(), FREE, PG_CRYPTOHASH_ERROR_NONE, ResourceOwnerEnlarge(), ResourceOwnerRememberCryptoHash(), pg_cryptohash_ctx::resowner, type, and pg_cryptohash_ctx::type.

Referenced by cryptohash_internal(), InitializeBackupManifest(), json_parse_manifest_incremental_init(), pg_checksum_init(), pg_hmac_create(), pg_hmac_init(), pg_md5_binary(), pg_md5_hash(), scram_H(), scram_mock_salt(), uuid_generate_internal(), and verify_manifest_checksum().

◆ pg_cryptohash_error()

const char * pg_cryptohash_error ( pg_cryptohash_ctx * ctx )

Definition at line 254 of file cryptohash.c.

{
    /*
     * This implementation would never fail because of an out-of-memory error,
     * except when creating the context.
     */
    if (ctx == NULL)
        return _("out of memory");
 
    switch (ctx->error)
    {
        case PG_CRYPTOHASH_ERROR_NONE:
            return _("success");
        case PG_CRYPTOHASH_ERROR_DEST_LEN:
            return _("destination buffer too small");
    }
 
    Assert(false);
    return _("success");
}

References _, Assert(), pg_cryptohash_ctx::error, pg_cryptohash_ctx::errreason, PG_CRYPTOHASH_ERROR_DEST_LEN, PG_CRYPTOHASH_ERROR_NONE, and PG_CRYPTOHASH_ERROR_OPENSSL.

Referenced by AppendStringToManifest(), cryptohash_internal(), InitializeBackupManifest(), pg_hmac_final(), pg_hmac_init(), pg_hmac_update(), pg_md5_binary(), pg_md5_hash(), scram_H(), SendBackupManifest(), and uuid_generate_internal().

◆ pg_cryptohash_final()

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

Definition at line 172 of file cryptohash.c.

{
    if (ctx == NULL)
        return -1;
 
    switch (ctx->type)
    {
        case PG_MD5:
            if (len < MD5_DIGEST_LENGTH)
            {
                ctx->error = PG_CRYPTOHASH_ERROR_DEST_LEN;
                return -1;
            }
            pg_md5_final(&ctx->data.md5, dest);
            break;
        case PG_SHA1:
            if (len < SHA1_DIGEST_LENGTH)
            {
                ctx->error = PG_CRYPTOHASH_ERROR_DEST_LEN;
                return -1;
            }
            pg_sha1_final(&ctx->data.sha1, dest);
            break;
        case PG_SHA224:
            if (len < PG_SHA224_DIGEST_LENGTH)
            {
                ctx->error = PG_CRYPTOHASH_ERROR_DEST_LEN;
                return -1;
            }
            pg_sha224_final(&ctx->data.sha224, dest);
            break;
        case PG_SHA256:
            if (len < PG_SHA256_DIGEST_LENGTH)
            {
                ctx->error = PG_CRYPTOHASH_ERROR_DEST_LEN;
                return -1;
            }
            pg_sha256_final(&ctx->data.sha256, dest);
            break;
        case PG_SHA384:
            if (len < PG_SHA384_DIGEST_LENGTH)
            {
                ctx->error = PG_CRYPTOHASH_ERROR_DEST_LEN;
                return -1;
            }
            pg_sha384_final(&ctx->data.sha384, dest);
            break;
        case PG_SHA512:
            if (len < PG_SHA512_DIGEST_LENGTH)
            {
                ctx->error = PG_CRYPTOHASH_ERROR_DEST_LEN;
                return -1;
            }
            pg_sha512_final(&ctx->data.sha512, dest);
            break;
    }
 
    return 0;
}

Referenced by cryptohash_internal(), pg_checksum_final(), pg_hmac_final(), pg_hmac_init(), pg_md5_binary(), pg_md5_hash(), scram_H(), scram_mock_salt(), SendBackupManifest(), uuid_generate_internal(), and verify_manifest_checksum().

◆ pg_cryptohash_free()

void pg_cryptohash_free ( pg_cryptohash_ctx * ctx )

Definition at line 238 of file cryptohash.c.

{
    if (ctx == NULL)
        return;
 
    explicit_bzero(ctx, sizeof(pg_cryptohash_ctx));
    FREE(ctx);
}

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

Referenced by cryptohash_internal(), FreeBackupManifest(), pg_checksum_final(), pg_checksum_init(), pg_hmac_free(), pg_hmac_init(), pg_md5_binary(), pg_md5_hash(), ResOwnerReleaseCryptoHash(), scram_H(), scram_mock_salt(), uuid_generate_internal(), and verify_manifest_checksum().

◆ pg_cryptohash_init()

int pg_cryptohash_init ( pg_cryptohash_ctx * ctx )

Definition at line 100 of file cryptohash.c.

{
    if (ctx == NULL)
        return -1;
 
    switch (ctx->type)
    {
        case PG_MD5:
            pg_md5_init(&ctx->data.md5);
            break;
        case PG_SHA1:
            pg_sha1_init(&ctx->data.sha1);
            break;
        case PG_SHA224:
            pg_sha224_init(&ctx->data.sha224);
            break;
        case PG_SHA256:
            pg_sha256_init(&ctx->data.sha256);
            break;
        case PG_SHA384:
            pg_sha384_init(&ctx->data.sha384);
            break;
        case PG_SHA512:
            pg_sha512_init(&ctx->data.sha512);
            break;
    }
 
    return 0;
}

Referenced by cryptohash_internal(), InitializeBackupManifest(), json_parse_manifest_incremental_init(), pg_checksum_init(), pg_hmac_final(), pg_hmac_init(), pg_md5_binary(), pg_md5_hash(), scram_H(), scram_mock_salt(), uuid_generate_internal(), and verify_manifest_checksum().

◆ pg_cryptohash_update()

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

Definition at line 136 of file cryptohash.c.

{
    if (ctx == NULL)
        return -1;
 
    switch (ctx->type)
    {
        case PG_MD5:
            pg_md5_update(&ctx->data.md5, data, len);
            break;
        case PG_SHA1:
            pg_sha1_update(&ctx->data.sha1, data, len);
            break;
        case PG_SHA224:
            pg_sha224_update(&ctx->data.sha224, data, len);
            break;
        case PG_SHA256:
            pg_sha256_update(&ctx->data.sha256, data, len);
            break;
        case PG_SHA384:
            pg_sha384_update(&ctx->data.sha384, data, len);
            break;
        case PG_SHA512:
            pg_sha512_update(&ctx->data.sha512, data, len);
            break;
    }
 
    return 0;
}

Referenced by AppendStringToManifest(), cryptohash_internal(), json_parse_manifest_incremental_chunk(), pg_checksum_update(), pg_hmac_final(), pg_hmac_init(), pg_hmac_update(), pg_md5_binary(), pg_md5_hash(), scram_H(), scram_mock_salt(), uuid_generate_internal(), and verify_manifest_checksum().

Typedefs

Enumerations

Functions