209 lines
7.8 KiB
C
209 lines
7.8 KiB
C
/****************************************************************
|
|
* *
|
|
* Copyright 2009, 2012 Fidelity Information Services, Inc *
|
|
* *
|
|
* This source code contains the intellectual property *
|
|
* of its copyright holder(s), and is made available *
|
|
* under a license. If you do not know the terms of *
|
|
* the license, please stop and do not read further. *
|
|
* *
|
|
****************************************************************/
|
|
#ifndef GTMCRYPT_REF_H
|
|
#define GTMCRYPT_REF_H
|
|
|
|
#if !defined(DEBUG) && defined(assert)
|
|
# undef assert
|
|
# define assert(x)
|
|
#endif
|
|
|
|
#include "gtm_common_defs.h" /* To import common macros implemented by GT.M */
|
|
#include "gtm_sizeof.h" /* for SIZEOF */
|
|
|
|
/* ==================================================================================== */
|
|
/* Legend to namespaces used -
|
|
* gc_XXXXX - All functions start with the gc_ namespace
|
|
* gc_dbk_XXX - All functions related to db key mapping and internal book keeping
|
|
* gc_sym_XXX - All functions related to usages of symmetric enc/dec activities, primarily using libgcrypt or libcrypto
|
|
* gc_pk_XXX - All functions related to usages of public/private key enc/dec activities, primarily using libgpgme
|
|
*/
|
|
/* ==================================================================================== */
|
|
|
|
|
|
/* The value 1023 for PATH_MAX is derived using pathconf("path", _PC_PATH_MAX) on z/OS and
|
|
* we figure other POSIX platforms are at least as capable if they don't define PATH_MAX.
|
|
* Since we can't afford to call a function on each use of PATH_MAX/GTM_PATH_MAX, this
|
|
* value is hardcoded here.
|
|
*
|
|
* Note on Linux (at least), PATH_MAX is actually defined in <sys/param.h>. We would include
|
|
* that here unconditionally but on AIX, param.h includes limits.h. Note that regardless of where
|
|
* it gets defined, PATH_MAX needs to be defined prior to including stdlib.h. This is because in a
|
|
* pro build, at least Linux verifies the 2nd parm of realpath() is PATH_MAX bytes or more.
|
|
* Since param.h sets PATH_MAX to 4K on Linux, this can cause structures defined as GTM_PATH_MAX
|
|
* to raise an error when used in the 2nd argument of realpath().
|
|
* Note : The definition of PATH_MAX and GTM_PATH_MAX is borrowed from gtm_limits.h. Change in one
|
|
* should be reflected in the other.
|
|
*/
|
|
#ifndef PATH_MAX
|
|
# ifdef __linux__
|
|
# include <sys/param.h>
|
|
# else
|
|
# define PATH_MAX 1023
|
|
# endif
|
|
#endif
|
|
/* Now define our version which includes space for a terminating NULL byte */
|
|
#define GTM_PATH_MAX PATH_MAX + 1
|
|
#define TAB_NAME_MAX 512
|
|
#define GTM_PASSPHRASE_MAX 512
|
|
#define GC_ENCRYPT 1
|
|
#define GC_DECRYPT 0
|
|
#define GC_FAILURE 1
|
|
#define GC_SUCCESS 0
|
|
#define DOT_GTM_DBKEYS ".gtm_dbkeys"
|
|
#define DOT_GNUPG ".gnupg"
|
|
#define SYMMETRIC_KEY_MAX 32
|
|
#define GTMCRYPT_HASH_LEN 64
|
|
#define GTMCRYPT_HASH_HEX_LEN GTMCRYPT_HASH_LEN * 2
|
|
#define INVALID_HANDLE -1
|
|
#define GTMCI "GTMCI"
|
|
#define MAX_GTMCRYPT_ERR_STRLEN 2048
|
|
|
|
#define GC_MIN_STATIC_BLOCK_SIZE 4096 /* Have a good size block, so that we dont keep reallocating */
|
|
#define GC_FLAGS (RTLD_NOW | RTLD_GLOBAL)
|
|
|
|
/* Some environment variables that encryption plugin cares about */
|
|
#define GNUPGHOME "GNUPGHOME"
|
|
#define GTM_PASSWD "gtm_passwd"
|
|
#define GTM_OBFUSCATION_KEY "gtm_obfuscation_key"
|
|
#define GTM_DBKEYS "gtm_dbkeys"
|
|
#define HOME "HOME"
|
|
#define USER "USER"
|
|
#define GTM_DIST "gtm_dist"
|
|
|
|
#define ENV_UNDEF_ERROR "Environment variable %s not set"
|
|
#define ENV_EMPTY_ERROR "Environment variable %s set to empty string"
|
|
|
|
/* Define function pointers to the functions that the encryption plugin imports from libgtmshr.so at runtime */
|
|
#define GTM_MALLOC_FUNC "gtm_malloc"
|
|
#define GTM_FREE_FUNC "gtm_free"
|
|
#define GTM_FILENAME_TO_ID_FUNC "gtm_filename_to_id"
|
|
#define GTM_CI_FUNC "gtm_ci"
|
|
#define GTM_ZSTATUS_FUNC "gtm_zstatus"
|
|
#define GTM_IS_FILE_IDENTICAL_FUNC "gtm_is_file_identical"
|
|
#define GTM_XCFILEID_FREE_FUNC "gtm_xcfileid_free"
|
|
|
|
typedef void * (*gtm_malloc_fptr_t)(size_t);
|
|
typedef void (*gtm_free_fptr_t)(void *);
|
|
typedef xc_status_t (*gtm_filename_to_id_fptr_t)(xc_string_t *, xc_fileid_ptr_t *);
|
|
typedef xc_status_t (*gtm_ci_fptr_t)(const char *c_rtn_name, ...);
|
|
typedef void (*gtm_zstatus_fptr_t)(char *msg, int len);
|
|
typedef xc_status_t (*gtm_is_file_identical_fptr_t)(xc_fileid_ptr_t, xc_fileid_ptr_t);
|
|
typedef void (*gtm_xcfileid_free_fptr_t)(xc_fileid_ptr_t);
|
|
|
|
GBLDEF gtm_malloc_fptr_t gtm_malloc_fptr;
|
|
GBLDEF gtm_free_fptr_t gtm_free_fptr;
|
|
GBLDEF gtm_filename_to_id_fptr_t gtm_filename_to_id_fptr;
|
|
GBLDEF gtm_ci_fptr_t gtm_ci_fptr;
|
|
GBLDEF gtm_zstatus_fptr_t gtm_zstatus_fptr;
|
|
GBLDEF gtm_is_file_identical_fptr_t gtm_is_file_identical_fptr;
|
|
GBLDEF gtm_xcfileid_free_fptr_t gtm_xcfileid_free_fptr;
|
|
|
|
xc_status_t gc_init_interface(int prompt_passwd); /* function that sets up the above function pointers */
|
|
|
|
GBLREF char gtmcrypt_err_string[MAX_GTMCRYPT_ERR_STRLEN]; /* most recent error that the plugin encountered */
|
|
|
|
#define SNPRINTF(SRC, LEN, ...) \
|
|
{ \
|
|
int rc; \
|
|
\
|
|
do \
|
|
{ \
|
|
rc = snprintf(SRC, LEN, __VA_ARGS__); /* BYPASSOK */ \
|
|
} while ((-1 == rc) && (EINTR == errno)); /* EINTR-safe */ \
|
|
}
|
|
|
|
#define SPRINTF(SRC, ...) \
|
|
{ \
|
|
int rc; \
|
|
\
|
|
do \
|
|
{ \
|
|
rc = sprintf(SRC, __VA_ARGS__); /* BYPASSOK */ \
|
|
} while ((-1 == rc) && (EINTR == errno)); /* EINTR-safe */ \
|
|
}
|
|
|
|
#define UPDATE_ERROR_STRING(...) \
|
|
{ \
|
|
SNPRINTF(gtmcrypt_err_string, MAX_GTMCRYPT_ERR_STRLEN, __VA_ARGS__); \
|
|
}
|
|
|
|
#define DLSYM_ERR_AND_EXIT(fptr_type, fptr, func_name) \
|
|
{ \
|
|
char *dlerr_ptr; \
|
|
\
|
|
fptr = (fptr_type)dlsym(handle, func_name); \
|
|
if (NULL == fptr) \
|
|
{ \
|
|
if (NULL == (dlerr_ptr = dlerror())) \
|
|
{ \
|
|
UPDATE_ERROR_STRING("Unable to resolve symbol %s. Unknown system error", func_name); \
|
|
} else \
|
|
UPDATE_ERROR_STRING("Unable to resolve symbol %s. %s", func_name, dlerr_ptr); \
|
|
return GC_FAILURE; \
|
|
} \
|
|
}
|
|
|
|
#define GC_MALLOC(blk, len, type) \
|
|
{ \
|
|
blk = (type *)gtm_malloc_fptr(len); \
|
|
assert(blk); \
|
|
}
|
|
|
|
#define GC_FREE(blk) gtm_free_fptr(blk)
|
|
|
|
|
|
/* Following makes sure that at no point we are in the encryption library without gtmcrypt_init getting called
|
|
* prior to the current call
|
|
*/
|
|
#define GC_VERIFY_INITED \
|
|
{ \
|
|
if (!gtmcrypt_inited) \
|
|
{ \
|
|
UPDATE_ERROR_STRING("Encryption library has not been initialized"); \
|
|
return GC_FAILURE; \
|
|
} \
|
|
}
|
|
|
|
#define GC_INT(H) ((H >= 'A' && H <= 'F') ? ((H - 'A') + 10) : (H - '0'))
|
|
|
|
#define GC_UNHEX(a, b, len) \
|
|
{ \
|
|
int i; \
|
|
for (i = 0; i < len; i += 2) \
|
|
b[i/2] = (unsigned char)(GC_INT(a[i]) * 16 + GC_INT(a[i + 1])); \
|
|
}
|
|
|
|
#define GC_HEX(a, b, len) \
|
|
{ \
|
|
int i; \
|
|
for (i = 0; i < len; i += 2) \
|
|
SPRINTF(b + i, "%02X", (unsigned char)a[i / 2]); \
|
|
}
|
|
|
|
/* Allocate a single block, and reuse everytime this macro is called */
|
|
#ifdef USE_OPENSSL
|
|
#define GC_GET_STATIC_BLOCK(out, block_len) \
|
|
{ \
|
|
static char *blk = (char *)NULL; \
|
|
static int allocated_len = GC_MIN_STATIC_BLOCK_SIZE; \
|
|
if (blk == NULL || (block_len > allocated_len)) \
|
|
{ \
|
|
if (blk) \
|
|
GC_FREE(blk); \
|
|
allocated_len = (block_len > allocated_len) ? ROUND_UP(block_len, GC_MIN_STATIC_BLOCK_SIZE) : allocated_len; \
|
|
GC_MALLOC(blk, allocated_len, char); \
|
|
} \
|
|
out = blk; \
|
|
}
|
|
#endif
|
|
#endif /* GTMCRYPT_REF_H */
|