mirror of https://github.com/postgres/postgres
Two new routines to allocate a hash context and to free it are created,
as these become necessary for the goal behind this refactoring: switch
the all cryptohash implementations for OpenSSL to use EVP (for FIPS and
also because upstream does not recommend the use of low-level cryptohash
functions for 20 years). Note that OpenSSL hides the internals of
cryptohash contexts since 1.1.0, so it is necessary to leave the
allocation to OpenSSL itself, explaining the need for those two new
routines. This part is going to require more work to properly track
hash contexts with resource owners, but this not introduced here.
Still, this refactoring makes the move possible.
This reduces the number of routines for all SHA2 implementations from
twelve (SHA{224,256,386,512} with init, update and final calls) to five
(create, free, init, update and final calls) by incorporating the hash
type directly into the hash context data.
The new cryptohash routines are moved to a new file, called cryptohash.c
for the fallback implementations, with SHA2 specifics becoming a part
internal to src/common/. OpenSSL specifics are part of
cryptohash_openssl.c. This infrastructure is usable for more hash
types, like MD5 or HMAC.
Any code paths using the internal SHA2 routines are adapted to report
correctly errors, which are most of the changes of this commit. The
zones mostly impacted are checksum manifests, libpq and SCRAM.
Note that e21cbb4 was a first attempt to switch SHA2 to EVP, but it
lacked the refactoring needed for libpq, as done here.
This patch has been tested on Linux and Windows, with and without
OpenSSL, and down to 1.0.1, the oldest version supported on HEAD.
Author: Michael Paquier
Reviewed-by: Daniel Gustafsson
Discussion: https://postgr.es/m/20200924025314.GE7405@paquier.xyz
pull/57/head
Michael Paquier
5 years ago
parent
888671a8cd
commit
87ae9691d2
@ -0,0 +1,190 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* cryptohash.c |
||||
* Fallback implementations for cryptographic hash functions. |
||||
* |
||||
* This is the set of in-core functions used when there are no other |
||||
* alternative options like OpenSSL. |
||||
* |
||||
* Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* IDENTIFICATION |
||||
* src/common/cryptohash.c |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
|
||||
#ifndef FRONTEND |
||||
#include "postgres.h" |
||||
#else |
||||
#include "postgres_fe.h" |
||||
#endif |
||||
|
||||
#include <sys/param.h> |
||||
|
||||
#include "common/cryptohash.h" |
||||
#include "sha2_int.h" |
||||
|
||||
/*
|
||||
* In backend, use palloc/pfree to ease the error handling. In frontend, |
||||
* use malloc to be able to return a failure status back to the caller. |
||||
*/ |
||||
#ifndef FRONTEND |
||||
#define ALLOC(size) palloc(size) |
||||
#define FREE(ptr) pfree(ptr) |
||||
#else |
||||
#define ALLOC(size) malloc(size) |
||||
#define FREE(ptr) free(ptr) |
||||
#endif |
||||
|
||||
/*
|
||||
* pg_cryptohash_create |
||||
* |
||||
* Allocate a hash context. Returns NULL on failure for an OOM. The |
||||
* backend issues an error, without returning. |
||||
*/ |
||||
pg_cryptohash_ctx * |
||||
pg_cryptohash_create(pg_cryptohash_type type) |
||||
{ |
||||
pg_cryptohash_ctx *ctx; |
||||
|
||||
ctx = ALLOC(sizeof(pg_cryptohash_ctx)); |
||||
if (ctx == NULL) |
||||
return NULL; |
||||
|
||||
ctx->type = type; |
||||
|
||||
switch (type) |
||||
{ |
||||
case PG_SHA224: |
||||
ctx->data = ALLOC(sizeof(pg_sha224_ctx)); |
||||
break; |
||||
case PG_SHA256: |
||||
ctx->data = ALLOC(sizeof(pg_sha256_ctx)); |
||||
break; |
||||
case PG_SHA384: |
||||
ctx->data = ALLOC(sizeof(pg_sha384_ctx)); |
||||
break; |
||||
case PG_SHA512: |
||||
ctx->data = ALLOC(sizeof(pg_sha512_ctx)); |
||||
break; |
||||
} |
||||
|
||||
if (ctx->data == NULL) |
||||
{ |
||||
explicit_bzero(ctx, sizeof(pg_cryptohash_ctx)); |
||||
FREE(ctx); |
||||
return NULL; |
||||
} |
||||
|
||||
return ctx; |
||||
} |
||||
|
||||
/*
|
||||
* pg_cryptohash_init |
||||
* |
||||
* Initialize a hash context. Note that this implementation is designed |
||||
* to never fail, so this always returns 0. |
||||
*/ |
||||
int |
||||
pg_cryptohash_init(pg_cryptohash_ctx *ctx) |
||||
{ |
||||
if (ctx == NULL) |
||||
return 0; |
||||
|
||||
switch (ctx->type) |
||||
{ |
||||
case PG_SHA224: |
||||
pg_sha224_init((pg_sha224_ctx *) ctx->data); |
||||
break; |
||||
case PG_SHA256: |
||||
pg_sha256_init((pg_sha256_ctx *) ctx->data); |
||||
break; |
||||
case PG_SHA384: |
||||
pg_sha384_init((pg_sha384_ctx *) ctx->data); |
||||
break; |
||||
case PG_SHA512: |
||||
pg_sha512_init((pg_sha512_ctx *) ctx->data); |
||||
break; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
/*
|
||||
* pg_cryptohash_update |
||||
* |
||||
* Update a hash context. Note that this implementation is designed |
||||
* to never fail, so this always returns 0. |
||||
*/ |
||||
int |
||||
pg_cryptohash_update(pg_cryptohash_ctx *ctx, const uint8 *data, size_t len) |
||||
{ |
||||
if (ctx == NULL) |
||||
return 0; |
||||
|
||||
switch (ctx->type) |
||||
{ |
||||
case PG_SHA224: |
||||
pg_sha224_update((pg_sha224_ctx *) ctx->data, data, len); |
||||
break; |
||||
case PG_SHA256: |
||||
pg_sha256_update((pg_sha256_ctx *) ctx->data, data, len); |
||||
break; |
||||
case PG_SHA384: |
||||
pg_sha384_update((pg_sha384_ctx *) ctx->data, data, len); |
||||
break; |
||||
case PG_SHA512: |
||||
pg_sha512_update((pg_sha512_ctx *) ctx->data, data, len); |
||||
break; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
/*
|
||||
* pg_cryptohash_final |
||||
* |
||||
* Finalize a hash context. Note that this implementation is designed |
||||
* to never fail, so this always returns 0. |
||||
*/ |
||||
int |
||||
pg_cryptohash_final(pg_cryptohash_ctx *ctx, uint8 *dest) |
||||
{ |
||||
if (ctx == NULL) |
||||
return 0; |
||||
|
||||
switch (ctx->type) |
||||
{ |
||||
case PG_SHA224: |
||||
pg_sha224_final((pg_sha224_ctx *) ctx->data, dest); |
||||
break; |
||||
case PG_SHA256: |
||||
pg_sha256_final((pg_sha256_ctx *) ctx->data, dest); |
||||
break; |
||||
case PG_SHA384: |
||||
pg_sha384_final((pg_sha384_ctx *) ctx->data, dest); |
||||
break; |
||||
case PG_SHA512: |
||||
pg_sha512_final((pg_sha512_ctx *) ctx->data, dest); |
||||
break; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
/*
|
||||
* pg_cryptohash_free |
||||
* |
||||
* Free a hash context. |
||||
*/ |
||||
void |
||||
pg_cryptohash_free(pg_cryptohash_ctx *ctx) |
||||
{ |
||||
if (ctx == NULL) |
||||
return; |
||||
FREE(ctx->data); |
||||
explicit_bzero(ctx, sizeof(pg_cryptohash_ctx)); |
||||
FREE(ctx); |
||||
} |
||||
@ -0,0 +1,197 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* cryptohash_openssl.c |
||||
* Set of wrapper routines on top of OpenSSL to support cryptographic |
||||
* hash functions. |
||||
* |
||||
* This should only be used if code is compiled with OpenSSL support. |
||||
* |
||||
* Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* IDENTIFICATION |
||||
* src/common/cryptohash_openssl.c |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
|
||||
#ifndef FRONTEND |
||||
#include "postgres.h" |
||||
#else |
||||
#include "postgres_fe.h" |
||||
#endif |
||||
|
||||
#include <openssl/sha.h> |
||||
|
||||
#include "common/cryptohash.h" |
||||
|
||||
/*
|
||||
* In backend, use palloc/pfree to ease the error handling. In frontend, |
||||
* use malloc to be able to return a failure status back to the caller. |
||||
*/ |
||||
#ifndef FRONTEND |
||||
#define ALLOC(size) palloc(size) |
||||
#define FREE(ptr) pfree(ptr) |
||||
#else |
||||
#define ALLOC(size) malloc(size) |
||||
#define FREE(ptr) free(ptr) |
||||
#endif |
||||
|
||||
/*
|
||||
* pg_cryptohash_create |
||||
* |
||||
* Allocate a hash context. Returns NULL on failure for an OOM. The |
||||
* backend issues an error, without returning. |
||||
*/ |
||||
pg_cryptohash_ctx * |
||||
pg_cryptohash_create(pg_cryptohash_type type) |
||||
{ |
||||
pg_cryptohash_ctx *ctx; |
||||
|
||||
ctx = ALLOC(sizeof(pg_cryptohash_ctx)); |
||||
if (ctx == NULL) |
||||
return NULL; |
||||
|
||||
ctx->type = type; |
||||
|
||||
switch (type) |
||||
{ |
||||
case PG_SHA224: |
||||
case PG_SHA256: |
||||
ctx->data = ALLOC(sizeof(SHA256_CTX)); |
||||
break; |
||||
case PG_SHA384: |
||||
case PG_SHA512: |
||||
ctx->data = ALLOC(sizeof(SHA512_CTX)); |
||||
break; |
||||
} |
||||
|
||||
if (ctx->data == NULL) |
||||
{ |
||||
explicit_bzero(ctx, sizeof(pg_cryptohash_ctx)); |
||||
FREE(ctx); |
||||
return NULL; |
||||
} |
||||
|
||||
return ctx; |
||||
} |
||||
|
||||
/*
|
||||
* pg_cryptohash_init |
||||
* |
||||
* Initialize a hash context. Returns 0 on success, and -1 on failure. |
||||
*/ |
||||
int |
||||
pg_cryptohash_init(pg_cryptohash_ctx *ctx) |
||||
{ |
||||
int status = 0; |
||||
|
||||
if (ctx == NULL) |
||||
return 0; |
||||
|
||||
switch (ctx->type) |
||||
{ |
||||
case PG_SHA224: |
||||
status = SHA224_Init((SHA256_CTX *) ctx->data); |
||||
break; |
||||
case PG_SHA256: |
||||
status = SHA256_Init((SHA256_CTX *) ctx->data); |
||||
break; |
||||
case PG_SHA384: |
||||
status = SHA384_Init((SHA512_CTX *) ctx->data); |
||||
break; |
||||
case PG_SHA512: |
||||
status = SHA512_Init((SHA512_CTX *) ctx->data); |
||||
break; |
||||
} |
||||
|
||||
/* OpenSSL internals return 1 on success, 0 on failure */ |
||||
if (status <= 0) |
||||
return -1; |
||||
return 0; |
||||
} |
||||
|
||||
/*
|
||||
* pg_cryptohash_update |
||||
* |
||||
* Update a hash context. Returns 0 on success, and -1 on failure. |
||||
*/ |
||||
int |
||||
pg_cryptohash_update(pg_cryptohash_ctx *ctx, const uint8 *data, size_t len) |
||||
{ |
||||
int status; |
||||
|
||||
if (ctx == NULL) |
||||
return 0; |
||||
|
||||
switch (ctx->type) |
||||
{ |
||||
case PG_SHA224: |
||||
status = SHA224_Update((SHA256_CTX *) ctx->data, data, len); |
||||
break; |
||||
case PG_SHA256: |
||||
status = SHA256_Update((SHA256_CTX *) ctx->data, data, len); |
||||
break; |
||||
case PG_SHA384: |
||||
status = SHA384_Update((SHA512_CTX *) ctx->data, data, len); |
||||
break; |
||||
case PG_SHA512: |
||||
status = SHA512_Update((SHA512_CTX *) ctx->data, data, len); |
||||
break; |
||||
} |
||||
|
||||
/* OpenSSL internals return 1 on success, 0 on failure */ |
||||
if (status <= 0) |
||||
return -1; |
||||
return 0; |
||||
} |
||||
|
||||
/*
|
||||
* pg_cryptohash_final |
||||
* |
||||
* Finalize a hash context. Returns 0 on success, and -1 on failure. |
||||
*/ |
||||
int |
||||
pg_cryptohash_final(pg_cryptohash_ctx *ctx, uint8 *dest) |
||||
{ |
||||
int status; |
||||
|
||||
if (ctx == NULL) |
||||
return 0; |
||||
|
||||
switch (ctx->type) |
||||
{ |
||||
case PG_SHA224: |
||||
status = SHA224_Final(dest, (SHA256_CTX *) ctx->data); |
||||
break; |
||||
case PG_SHA256: |
||||
status = SHA256_Final(dest, (SHA256_CTX *) ctx->data); |
||||
break; |
||||
case PG_SHA384: |
||||
status = SHA384_Final(dest, (SHA512_CTX *) ctx->data); |
||||
break; |
||||
case PG_SHA512: |
||||
status = SHA512_Final(dest, (SHA512_CTX *) ctx->data); |
||||
break; |
||||
} |
||||
|
||||
/* OpenSSL internals return 1 on success, 0 on failure */ |
||||
if (status <= 0) |
||||
return -1; |
||||
return 0; |
||||
} |
||||
|
||||
/*
|
||||
* pg_cryptohash_free |
||||
* |
||||
* Free a hash context. |
||||
*/ |
||||
void |
||||
pg_cryptohash_free(pg_cryptohash_ctx *ctx) |
||||
{ |
||||
if (ctx == NULL) |
||||
return; |
||||
FREE(ctx->data); |
||||
explicit_bzero(ctx, sizeof(pg_cryptohash_ctx)); |
||||
FREE(ctx); |
||||
} |
||||
@ -0,0 +1,91 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* sha2_int.h |
||||
* Internal headers for fallback implementation of SHA{224,256,384,512} |
||||
* |
||||
* Portions Copyright (c) 2016-2020, PostgreSQL Global Development Group |
||||
* |
||||
* IDENTIFICATION |
||||
* src/common/sha2_int.h |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
|
||||
/* $OpenBSD: sha2.h,v 1.2 2004/04/28 23:11:57 millert Exp $ */ |
||||
|
||||
/*
|
||||
* FILE: sha2.h |
||||
* AUTHOR: Aaron D. Gifford <me@aarongifford.com> |
||||
* |
||||
* Copyright (c) 2000-2001, Aaron D. Gifford |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions |
||||
* are met: |
||||
* 1. Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* 2. Redistributions in binary form must reproduce the above copyright |
||||
* notice, this list of conditions and the following disclaimer in the |
||||
* documentation and/or other materials provided with the distribution. |
||||
* 3. Neither the name of the copyright holder nor the names of contributors |
||||
* may be used to endorse or promote products derived from this software |
||||
* without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND |
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE |
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
||||
* SUCH DAMAGE. |
||||
* |
||||
* $From: sha2.h,v 1.1 2001/11/08 00:02:01 adg Exp adg $ |
||||
*/ |
||||
|
||||
#ifndef PG_SHA2_INT_H |
||||
#define PG_SHA2_INT_H |
||||
|
||||
#include "common/sha2.h" |
||||
|
||||
typedef struct pg_sha256_ctx |
||||
{ |
||||
uint32 state[8]; |
||||
uint64 bitcount; |
||||
uint8 buffer[PG_SHA256_BLOCK_LENGTH]; |
||||
} pg_sha256_ctx; |
||||
typedef struct pg_sha512_ctx |
||||
{ |
||||
uint64 state[8]; |
||||
uint64 bitcount[2]; |
||||
uint8 buffer[PG_SHA512_BLOCK_LENGTH]; |
||||
} pg_sha512_ctx; |
||||
typedef struct pg_sha256_ctx pg_sha224_ctx; |
||||
typedef struct pg_sha512_ctx pg_sha384_ctx; |
||||
|
||||
/* Interface routines for SHA224/256/384/512 */ |
||||
extern void pg_sha224_init(pg_sha224_ctx *ctx); |
||||
extern void pg_sha224_update(pg_sha224_ctx *ctx, const uint8 *input0, |
||||
size_t len); |
||||
extern void pg_sha224_final(pg_sha224_ctx *ctx, uint8 *dest); |
||||
|
||||
extern void pg_sha256_init(pg_sha256_ctx *ctx); |
||||
extern void pg_sha256_update(pg_sha256_ctx *ctx, const uint8 *input0, |
||||
size_t len); |
||||
extern void pg_sha256_final(pg_sha256_ctx *ctx, uint8 *dest); |
||||
|
||||
extern void pg_sha384_init(pg_sha384_ctx *ctx); |
||||
extern void pg_sha384_update(pg_sha384_ctx *ctx, |
||||
const uint8 *, size_t len); |
||||
extern void pg_sha384_final(pg_sha384_ctx *ctx, uint8 *dest); |
||||
|
||||
extern void pg_sha512_init(pg_sha512_ctx *ctx); |
||||
extern void pg_sha512_update(pg_sha512_ctx *ctx, const uint8 *input0, |
||||
size_t len); |
||||
extern void pg_sha512_final(pg_sha512_ctx *ctx, uint8 *dest); |
||||
|
||||
#endif /* PG_SHA2_INT_H */ |
||||
@ -1,102 +0,0 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* sha2_openssl.c |
||||
* Set of wrapper routines on top of OpenSSL to support SHA-224 |
||||
* SHA-256, SHA-384 and SHA-512 functions. |
||||
* |
||||
* This should only be used if code is compiled with OpenSSL support. |
||||
* |
||||
* Portions Copyright (c) 2016-2020, PostgreSQL Global Development Group |
||||
* |
||||
* IDENTIFICATION |
||||
* src/common/sha2_openssl.c |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
|
||||
#ifndef FRONTEND |
||||
#include "postgres.h" |
||||
#else |
||||
#include "postgres_fe.h" |
||||
#endif |
||||
|
||||
#include <openssl/sha.h> |
||||
|
||||
#include "common/sha2.h" |
||||
|
||||
|
||||
/* Interface routines for SHA-256 */ |
||||
void |
||||
pg_sha256_init(pg_sha256_ctx *ctx) |
||||
{ |
||||
SHA256_Init((SHA256_CTX *) ctx); |
||||
} |
||||
|
||||
void |
||||
pg_sha256_update(pg_sha256_ctx *ctx, const uint8 *data, size_t len) |
||||
{ |
||||
SHA256_Update((SHA256_CTX *) ctx, data, len); |
||||
} |
||||
|
||||
void |
||||
pg_sha256_final(pg_sha256_ctx *ctx, uint8 *dest) |
||||
{ |
||||
SHA256_Final(dest, (SHA256_CTX *) ctx); |
||||
} |
||||
|
||||
/* Interface routines for SHA-512 */ |
||||
void |
||||
pg_sha512_init(pg_sha512_ctx *ctx) |
||||
{ |
||||
SHA512_Init((SHA512_CTX *) ctx); |
||||
} |
||||
|
||||
void |
||||
pg_sha512_update(pg_sha512_ctx *ctx, const uint8 *data, size_t len) |
||||
{ |
||||
SHA512_Update((SHA512_CTX *) ctx, data, len); |
||||
} |
||||
|
||||
void |
||||
pg_sha512_final(pg_sha512_ctx *ctx, uint8 *dest) |
||||
{ |
||||
SHA512_Final(dest, (SHA512_CTX *) ctx); |
||||
} |
||||
|
||||
/* Interface routines for SHA-384 */ |
||||
void |
||||
pg_sha384_init(pg_sha384_ctx *ctx) |
||||
{ |
||||
SHA384_Init((SHA512_CTX *) ctx); |
||||
} |
||||
|
||||
void |
||||
pg_sha384_update(pg_sha384_ctx *ctx, const uint8 *data, size_t len) |
||||
{ |
||||
SHA384_Update((SHA512_CTX *) ctx, data, len); |
||||
} |
||||
|
||||
void |
||||
pg_sha384_final(pg_sha384_ctx *ctx, uint8 *dest) |
||||
{ |
||||
SHA384_Final(dest, (SHA512_CTX *) ctx); |
||||
} |
||||
|
||||
/* Interface routines for SHA-224 */ |
||||
void |
||||
pg_sha224_init(pg_sha224_ctx *ctx) |
||||
{ |
||||
SHA224_Init((SHA256_CTX *) ctx); |
||||
} |
||||
|
||||
void |
||||
pg_sha224_update(pg_sha224_ctx *ctx, const uint8 *data, size_t len) |
||||
{ |
||||
SHA224_Update((SHA256_CTX *) ctx, data, len); |
||||
} |
||||
|
||||
void |
||||
pg_sha224_final(pg_sha224_ctx *ctx, uint8 *dest) |
||||
{ |
||||
SHA224_Final(dest, (SHA256_CTX *) ctx); |
||||
} |
||||
@ -0,0 +1,40 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* cryptohash.h |
||||
* Generic headers for cryptographic hash functions. |
||||
* |
||||
* Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* IDENTIFICATION |
||||
* src/include/common/cryptohash.h |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
|
||||
#ifndef PG_CRYPTOHASH_H |
||||
#define PG_CRYPTOHASH_H |
||||
|
||||
/* Context Structures for each hash function */ |
||||
typedef enum |
||||
{ |
||||
PG_SHA224 = 0, |
||||
PG_SHA256, |
||||
PG_SHA384, |
||||
PG_SHA512 |
||||
} pg_cryptohash_type; |
||||
|
||||
typedef struct pg_cryptohash_ctx |
||||
{ |
||||
pg_cryptohash_type type; |
||||
/* private area used by each hash implementation */ |
||||
void *data; |
||||
} pg_cryptohash_ctx; |
||||
|
||||
extern pg_cryptohash_ctx *pg_cryptohash_create(pg_cryptohash_type type); |
||||
extern int pg_cryptohash_init(pg_cryptohash_ctx *ctx); |
||||
extern int pg_cryptohash_update(pg_cryptohash_ctx *ctx, const uint8 *data, size_t len); |
||||
extern int pg_cryptohash_final(pg_cryptohash_ctx *ctx, uint8 *dest); |
||||
extern void pg_cryptohash_free(pg_cryptohash_ctx *ctx); |
||||
|
||||
#endif /* PG_CRYPTOHASH_H */ |
||||
Loading…
Reference in new issue