db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-10-30 23:37:45 +02:00
Code Issues Releases Activity

Rename cipherBlock*() functions to cipherBlock*C().

Browse Source 
Some of the old names conflict with the new functions that must be created to implement the filter. Rename these to cipherBlock*C() to indicate that they take C-style parameters.

These functions are only used by the Perl LibC code and will be removed or refactored eventually.
This commit is contained in:
David Steele
2018-11-27 22:49:24 -05:00
parent fea27dbd7e
commit 7df7cf6e6d
5 changed files with 75 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
libc/xs/crypto/cipherBlock.xs
View File

@@ -28,7 +28,7 @@ CODE:
RETVAL->memContext = MEM_COMTEXT_XS();
RETVAL->pxPayload = cipherBlockNew(mode, type, key, keySize, digest);
RETVAL->pxPayload = cipherBlockNewC(mode, type, key, keySize, digest);
}
MEM_CONTEXT_XS_NEW_END();
OUTPUT:
@@ -47,10 +47,10 @@ CODE:
STRLEN tSize;
const unsigned char *sourcePtr = (const unsigned char *)SvPV(source, tSize);
RETVAL = NEWSV(0, cipherBlockProcessSize(self->pxPayload, tSize));
RETVAL = NEWSV(0, cipherBlockProcessSizeC(self->pxPayload, tSize));
SvPOK_only(RETVAL);
SvCUR_set(RETVAL, cipherBlockProcess(self->pxPayload, sourcePtr, tSize, (unsigned char *)SvPV_nolen(RETVAL)));
SvCUR_set(RETVAL, cipherBlockProcessC(self->pxPayload, sourcePtr, tSize, (unsigned char *)SvPV_nolen(RETVAL)));
}
MEM_CONTEXT_XS_END();
OUTPUT:
@@ -65,10 +65,10 @@ CODE:
MEM_CONTEXT_XS_BEGIN(self->memContext)
{
RETVAL = NEWSV(0, cipherBlockProcessSize(self->pxPayload, 0));
RETVAL = NEWSV(0, cipherBlockProcessSizeC(self->pxPayload, 0));
SvPOK_only(RETVAL);
SvCUR_set(RETVAL, cipherBlockFlush(self->pxPayload, (unsigned char *)SvPV_nolen(RETVAL)));
SvCUR_set(RETVAL, cipherBlockFlushC(self->pxPayload, (unsigned char *)SvPV_nolen(RETVAL)));
}
MEM_CONTEXT_XS_END();
OUTPUT:

25
src/crypto/cipherBlock.c
View File

@@ -45,7 +45,7 @@ struct CipherBlock
New block encrypt/decrypt object
***********************************************************************************************************************************/
CipherBlock *
cipherBlockNew(CipherMode mode, const char *cipherName, const unsigned char *pass, size_t passSize, const char *digestName)
cipherBlockNewC(CipherMode mode, const char *cipherName, const unsigned char *pass, size_t passSize, const char *digestName)
{
FUNCTION_DEBUG_BEGIN(logLevelTrace);
FUNCTION_DEBUG_PARAM(ENUM, mode);
@@ -111,7 +111,7 @@ cipherBlockNew(CipherMode mode, const char *cipherName, const unsigned char *pas
Determine how large the destination buffer should be
***********************************************************************************************************************************/
size_t
cipherBlockProcessSize(CipherBlock *this, size_t sourceSize)
cipherBlockProcessSizeC(CipherBlock *this, size_t sourceSize)
{
FUNCTION_DEBUG_BEGIN(logLevelTrace);
FUNCTION_DEBUG_PARAM(CIPHER_BLOCK, this);
@@ -134,7 +134,7 @@ cipherBlockProcessSize(CipherBlock *this, size_t sourceSize)
Encrypt/decrypt data
***********************************************************************************************************************************/
size_t
cipherBlockProcess(CipherBlock *this, const unsigned char *source, size_t sourceSize, unsigned char *destination)
cipherBlockProcessC(CipherBlock *this, const unsigned char *source, size_t sourceSize, unsigned char *destination)
{
FUNCTION_DEBUG_BEGIN(logLevelTrace);
FUNCTION_DEBUG_PARAM(CIPHER_BLOCK, this);
@@ -249,7 +249,7 @@ cipherBlockProcess(CipherBlock *this, const unsigned char *source, size_t source
Flush the remaining data
***********************************************************************************************************************************/
size_t
cipherBlockFlush(CipherBlock *this, unsigned char *destination)
cipherBlockFlushC(CipherBlock *this, unsigned char *destination)
{
FUNCTION_DEBUG_BEGIN(logLevelTrace);
FUNCTION_DEBUG_PARAM(CIPHER_BLOCK, this);
@@ -282,17 +282,18 @@ cipherBlockFree(CipherBlock *this)
{
FUNCTION_DEBUG_BEGIN(logLevelTrace);
FUNCTION_DEBUG_PARAM(CIPHER_BLOCK, this);
FUNCTION_DEBUG_ASSERT(this != NULL);
FUNCTION_DEBUG_END();
// Free cipher context
if (this->cipherContext)
EVP_CIPHER_CTX_cleanup(this->cipherContext);
if (this != NULL)
{
// Free cipher context
if (this->cipherContext)
EVP_CIPHER_CTX_cleanup(this->cipherContext);
// Free mem context
memContextCallbackClear(this->memContext);
memContextFree(this->memContext);
// Free mem context
memContextCallbackClear(this->memContext);
memContextFree(this->memContext);
}
FUNCTION_DEBUG_RESULT_VOID();
}

18
src/crypto/cipherBlock.h
View File

@@ -11,14 +11,22 @@ typedef struct CipherBlock CipherBlock;
#include "crypto/cipher.h"
/***********************************************************************************************************************************
Constructor
***********************************************************************************************************************************/
CipherBlock *cipherBlockNewC(
CipherMode mode, const char *cipherName, const unsigned char *pass, size_t passSize, const char *digestName);
/***********************************************************************************************************************************
Functions
***********************************************************************************************************************************/
CipherBlock *cipherBlockNew(
CipherMode mode, const char *cipherName, const unsigned char *pass, size_t passSize, const char *digestName);
size_t cipherBlockProcessSize(CipherBlock *this, size_t sourceSize);
size_t cipherBlockProcess(CipherBlock *this, const unsigned char *source, size_t sourceSize, unsigned char *destination);
size_t cipherBlockFlush(CipherBlock *this, unsigned char *destination);
size_t cipherBlockProcessSizeC(CipherBlock *this, size_t sourceSize);
size_t cipherBlockProcessC(CipherBlock *this, const unsigned char *source, size_t sourceSize, unsigned char *destination);
size_t cipherBlockFlushC(CipherBlock *this, unsigned char *destination);
/***********************************************************************************************************************************
Destructor
***********************************************************************************************************************************/
void cipherBlockFree(CipherBlock *this);
/***********************************************************************************************************************************

10
src/perl/libc.auto.c
View File

@@ -627,7 +627,7 @@ XS_EUPXS(XS_pgBackRest__LibC__Cipher__Block_new)
RETVAL->memContext = MEM_COMTEXT_XS();
RETVAL->pxPayload = cipherBlockNew(mode, type, key, keySize, digest);
RETVAL->pxPayload = cipherBlockNewC(mode, type, key, keySize, digest);
}
MEM_CONTEXT_XS_NEW_END();
{
@@ -669,10 +669,10 @@ XS_EUPXS(XS_pgBackRest__LibC__Cipher__Block_process)
STRLEN tSize;
const unsigned char *sourcePtr = (const unsigned char *)SvPV(source, tSize);
RETVAL = NEWSV(0, cipherBlockProcessSize(self->pxPayload, tSize));
RETVAL = NEWSV(0, cipherBlockProcessSizeC(self->pxPayload, tSize));
SvPOK_only(RETVAL);
SvCUR_set(RETVAL, cipherBlockProcess(self->pxPayload, sourcePtr, tSize, (unsigned char *)SvPV_nolen(RETVAL)));
SvCUR_set(RETVAL, cipherBlockProcessC(self->pxPayload, sourcePtr, tSize, (unsigned char *)SvPV_nolen(RETVAL)));
}
MEM_CONTEXT_XS_END();
RETVAL = sv_2mortal(RETVAL);
@@ -705,10 +705,10 @@ XS_EUPXS(XS_pgBackRest__LibC__Cipher__Block_flush)
MEM_CONTEXT_XS_BEGIN(self->memContext)
{
RETVAL = NEWSV(0, cipherBlockProcessSize(self->pxPayload, 0));
RETVAL = NEWSV(0, cipherBlockProcessSizeC(self->pxPayload, 0));
SvPOK_only(RETVAL);
SvCUR_set(RETVAL, cipherBlockFlush(self->pxPayload, (unsigned char *)SvPV_nolen(RETVAL)));
SvCUR_set(RETVAL, cipherBlockFlushC(self->pxPayload, (unsigned char *)SvPV_nolen(RETVAL)));
}
MEM_CONTEXT_XS_END();
RETVAL = sv_2mortal(RETVAL);

76
test/src/module/crypto/cipherBlockTest.c
View File

@@ -26,17 +26,17 @@ testRun(void)
// Cipher and digest errors
// -------------------------------------------------------------------------------------------------------------------------
TEST_ERROR(
cipherBlockNew(
cipherBlockNewC(
cipherModeEncrypt, BOGUS_STR, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL), AssertError,
"unable to load cipher 'BOGUS'");
TEST_ERROR(
cipherBlockNew(
cipherBlockNewC(
cipherModeEncrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, BOGUS_STR), AssertError,
"unable to load digest 'BOGUS'");
// Initialization of object
// -------------------------------------------------------------------------------------------------------------------------
CipherBlock *cipherBlock = cipherBlockNew(cipherModeEncrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
CipherBlock *cipherBlock = cipherBlockNewC(cipherModeEncrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
TEST_RESULT_STR(memContextName(cipherBlock->memContext), "cipherBlock", "mem context name is valid");
TEST_RESULT_INT(cipherBlock->mode, cipherModeEncrypt, "mode is valid");
TEST_RESULT_INT(cipherBlock->passSize, TEST_PASS_SIZE, "passphrase size is valid");
@@ -47,7 +47,9 @@ testRun(void)
TEST_RESULT_PTR_NE(cipherBlock->cipher, NULL, "cipher is set");
TEST_RESULT_PTR_NE(cipherBlock->digest, NULL, "digest is set");
TEST_RESULT_PTR(cipherBlock->cipherContext, NULL, "cipher context is not set");
memContextFree(cipherBlock->memContext);
TEST_RESULT_VOID(cipherBlockFree(cipherBlock), "free cipher block");
TEST_RESULT_VOID(cipherBlockFree(NULL), "free null cipher block");
}
// *****************************************************************************************************************************
@@ -60,14 +62,14 @@ testRun(void)
// Encrypt
// -------------------------------------------------------------------------------------------------------------------------
CipherBlock *blockEncrypt = cipherBlockNew(
CipherBlock *blockEncrypt = cipherBlockNewC(
cipherModeEncrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
TEST_RESULT_INT(
cipherBlockProcessSize(blockEncrypt, strlen(TEST_PLAINTEXT)),
cipherBlockProcessSizeC(blockEncrypt, strlen(TEST_PLAINTEXT)),
strlen(TEST_PLAINTEXT) + EVP_MAX_BLOCK_LENGTH + CIPHER_BLOCK_MAGIC_SIZE + PKCS5_SALT_LEN, "check process size");
encryptSize = cipherBlockProcess(blockEncrypt, (unsigned char *)TEST_PLAINTEXT, strlen(TEST_PLAINTEXT), encryptBuffer);
encryptSize = cipherBlockProcessC(blockEncrypt, (unsigned char *)TEST_PLAINTEXT, strlen(TEST_PLAINTEXT), encryptBuffer);
TEST_RESULT_BOOL(blockEncrypt->saltDone, true, "salt done is true");
TEST_RESULT_BOOL(blockEncrypt->processDone, true, "process done is true");
@@ -75,16 +77,16 @@ testRun(void)
TEST_RESULT_INT(encryptSize, CIPHER_BLOCK_HEADER_SIZE, "cipher size is header len");
TEST_RESULT_INT(
cipherBlockProcessSize(blockEncrypt, strlen(TEST_PLAINTEXT)),
cipherBlockProcessSizeC(blockEncrypt, strlen(TEST_PLAINTEXT)),
strlen(TEST_PLAINTEXT) + EVP_MAX_BLOCK_LENGTH, "check process size");
encryptSize += cipherBlockProcess(
encryptSize += cipherBlockProcessC(
blockEncrypt, (unsigned char *)TEST_PLAINTEXT, strlen(TEST_PLAINTEXT), encryptBuffer + encryptSize);
TEST_RESULT_INT(
encryptSize, CIPHER_BLOCK_HEADER_SIZE + (size_t)EVP_CIPHER_block_size(blockEncrypt->cipher),
"cipher size increases by one block");
encryptSize += cipherBlockFlush(blockEncrypt, encryptBuffer + encryptSize);
encryptSize += cipherBlockFlushC(blockEncrypt, encryptBuffer + encryptSize);
TEST_RESULT_INT(
encryptSize, CIPHER_BLOCK_HEADER_SIZE + (size_t)(EVP_CIPHER_block_size(blockEncrypt->cipher) * 2),
"cipher size increases by one block on flush");
@@ -93,17 +95,17 @@ testRun(void)
// Decrypt in one pass
// -------------------------------------------------------------------------------------------------------------------------
CipherBlock *blockDecrypt = cipherBlockNew(
CipherBlock *blockDecrypt = cipherBlockNewC(
cipherModeDecrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
TEST_RESULT_INT(
cipherBlockProcessSize(blockDecrypt, encryptSize),
cipherBlockProcessSizeC(blockDecrypt, encryptSize),
encryptSize + EVP_MAX_BLOCK_LENGTH, "check process size");
decryptSize = cipherBlockProcess(blockDecrypt, encryptBuffer, encryptSize, decryptBuffer);
decryptSize = cipherBlockProcessC(blockDecrypt, encryptBuffer, encryptSize, decryptBuffer);
TEST_RESULT_INT(decryptSize, EVP_CIPHER_block_size(blockDecrypt->cipher), "decrypt size is one block");
decryptSize += cipherBlockFlush(blockDecrypt, decryptBuffer + decryptSize);
decryptSize += cipherBlockFlushC(blockDecrypt, decryptBuffer + decryptSize);
TEST_RESULT_INT(decryptSize, strlen(TEST_PLAINTEXT) * 2, "check final decrypt size");
decryptBuffer[decryptSize] = 0;
@@ -113,12 +115,12 @@ testRun(void)
// Decrypt in small chunks to test buffering
// -------------------------------------------------------------------------------------------------------------------------
blockDecrypt = cipherBlockNew(cipherModeDecrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
blockDecrypt = cipherBlockNewC(cipherModeDecrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
decryptSize = 0;
memset(decryptBuffer, 0, TEST_BUFFER_SIZE);
decryptSize = cipherBlockProcess(blockDecrypt, encryptBuffer, CIPHER_BLOCK_MAGIC_SIZE, decryptBuffer);
decryptSize = cipherBlockProcessC(blockDecrypt, encryptBuffer, CIPHER_BLOCK_MAGIC_SIZE, decryptBuffer);
TEST_RESULT_INT(decryptSize, 0, "no decrypt since header read is not complete");
TEST_RESULT_BOOL(blockDecrypt->saltDone, false, "salt done is false");
TEST_RESULT_BOOL(blockDecrypt->processDone, false, "process done is false");
@@ -126,7 +128,7 @@ testRun(void)
TEST_RESULT_BOOL(
memcmp(blockDecrypt->header, CIPHER_BLOCK_MAGIC, CIPHER_BLOCK_MAGIC_SIZE) == 0, true, "check header magic");
decryptSize += cipherBlockProcess(
decryptSize += cipherBlockProcessC(
blockDecrypt, encryptBuffer + CIPHER_BLOCK_MAGIC_SIZE, PKCS5_SALT_LEN, decryptBuffer + decryptSize);
TEST_RESULT_INT(decryptSize, 0, "no decrypt since no data processed yet");
TEST_RESULT_BOOL(blockDecrypt->saltDone, true, "salt done is true");
@@ -138,12 +140,12 @@ testRun(void)
PKCS5_SALT_LEN) == 0,
true, "check header salt");
decryptSize += cipherBlockProcess(
decryptSize += cipherBlockProcessC(
blockDecrypt, encryptBuffer + CIPHER_BLOCK_HEADER_SIZE, encryptSize - CIPHER_BLOCK_HEADER_SIZE,
decryptBuffer + decryptSize);
TEST_RESULT_INT(decryptSize, EVP_CIPHER_block_size(blockDecrypt->cipher), "decrypt size is one block");
decryptSize += cipherBlockFlush(blockDecrypt, decryptBuffer + decryptSize);
decryptSize += cipherBlockFlushC(blockDecrypt, decryptBuffer + decryptSize);
TEST_RESULT_INT(decryptSize, strlen(TEST_PLAINTEXT) * 2, "check final decrypt size");
decryptBuffer[decryptSize] = 0;
@@ -153,62 +155,62 @@ testRun(void)
// Encrypt zero byte file and decrypt it
// -------------------------------------------------------------------------------------------------------------------------
blockEncrypt = cipherBlockNew(cipherModeEncrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
blockEncrypt = cipherBlockNewC(cipherModeEncrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
TEST_RESULT_INT(cipherBlockProcess(blockEncrypt, decryptBuffer, 0, encryptBuffer), 16, "process header");
TEST_RESULT_INT(cipherBlockFlush(blockEncrypt, encryptBuffer + 16), 16, "flush remaining bytes");
TEST_RESULT_INT(cipherBlockProcessC(blockEncrypt, decryptBuffer, 0, encryptBuffer), 16, "process header");
TEST_RESULT_INT(cipherBlockFlushC(blockEncrypt, encryptBuffer + 16), 16, "flush remaining bytes");
cipherBlockFree(blockEncrypt);
blockDecrypt = cipherBlockNew(cipherModeDecrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
blockDecrypt = cipherBlockNewC(cipherModeDecrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
TEST_RESULT_INT(cipherBlockProcess(blockDecrypt, encryptBuffer, 32, decryptBuffer), 0, "0 bytes processed");
TEST_RESULT_INT(cipherBlockFlush(blockDecrypt, decryptBuffer), 0, "0 bytes on flush");
TEST_RESULT_INT(cipherBlockProcessC(blockDecrypt, encryptBuffer, 32, decryptBuffer), 0, "0 bytes processed");
TEST_RESULT_INT(cipherBlockFlushC(blockDecrypt, decryptBuffer), 0, "0 bytes on flush");
cipherBlockFree(blockDecrypt);
// Invalid cipher header
// -------------------------------------------------------------------------------------------------------------------------
blockDecrypt = cipherBlockNew(cipherModeDecrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
blockDecrypt = cipherBlockNewC(cipherModeDecrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
TEST_ERROR(
cipherBlockProcess(
cipherBlockProcessC(
blockDecrypt, (unsigned char *)"1234567890123456", 16, decryptBuffer), CryptoError, "cipher header invalid");
cipherBlockFree(blockDecrypt);
// Invalid encrypted data cannot be flushed
// -------------------------------------------------------------------------------------------------------------------------
blockDecrypt = cipherBlockNew(cipherModeDecrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
blockDecrypt = cipherBlockNewC(cipherModeDecrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
TEST_RESULT_INT(
cipherBlockProcess(
cipherBlockProcessC(
blockDecrypt, (unsigned char *)(CIPHER_BLOCK_MAGIC "12345678"), 16, decryptBuffer), 0, "process header");
TEST_RESULT_INT(
cipherBlockProcess(
cipherBlockProcessC(
blockDecrypt, (unsigned char *)"1234567890123456", 16, decryptBuffer), 0, "process 0 bytes");
TEST_ERROR(cipherBlockFlush(blockDecrypt, decryptBuffer), CryptoError, "unable to flush");
TEST_ERROR(cipherBlockFlushC(blockDecrypt, decryptBuffer), CryptoError, "unable to flush");
cipherBlockFree(blockDecrypt);
// File with no header should not flush
// -------------------------------------------------------------------------------------------------------------------------
blockDecrypt = cipherBlockNew(cipherModeDecrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
blockDecrypt = cipherBlockNewC(cipherModeDecrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
TEST_RESULT_INT(cipherBlockProcess(blockDecrypt, encryptBuffer, 0, decryptBuffer), 0, "no header processed");
TEST_ERROR(cipherBlockFlush(blockDecrypt, decryptBuffer), CryptoError, "cipher header missing");
TEST_RESULT_INT(cipherBlockProcessC(blockDecrypt, encryptBuffer, 0, decryptBuffer), 0, "no header processed");
TEST_ERROR(cipherBlockFlushC(blockDecrypt, decryptBuffer), CryptoError, "cipher header missing");
cipherBlockFree(blockDecrypt);
// File with header only should error
// -------------------------------------------------------------------------------------------------------------------------
blockDecrypt = cipherBlockNew(cipherModeDecrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
blockDecrypt = cipherBlockNewC(cipherModeDecrypt, TEST_CIPHER, (unsigned char *)TEST_PASS, TEST_PASS_SIZE, NULL);
TEST_RESULT_INT(
cipherBlockProcess(
cipherBlockProcessC(
blockDecrypt, (unsigned char *)(CIPHER_BLOCK_MAGIC "12345678"), 16, decryptBuffer), 0, "0 bytes processed");
TEST_ERROR(cipherBlockFlush(blockDecrypt, decryptBuffer), CryptoError, "unable to flush");
TEST_ERROR(cipherBlockFlushC(blockDecrypt, decryptBuffer), CryptoError, "unable to flush");
cipherBlockFree(blockDecrypt);
}