📄 testlib.c
字号:
/****************************************************************************
* *
* cryptlib Test Code *
* Copyright Peter Gutmann 1995-2002 *
* *
****************************************************************************/
#ifdef _MSC_VER
#include "../cryptlib.h"
#include "../test/test.h"
#else
#include "cryptlib.h"
#include "test/test.h"
#endif /* Braindamaged VC++ include handling */
/* Define the following to perform a smoke test on the cryptlib kernel */
/* #define SMOKE_TEST */
/* Whether various keyset tests worked, the results are used later to test
other routines. We initially set the key read result to TRUE in case the
keyset read tests are never called, so we can still trying reading the
keys in other tests */
int keyReadOK = TRUE, doubleCertOK = FALSE;
/* The keys for testing the RSA, DSA, and Elgamal implementations. These are
the same 512-bit keys as the one used for the lib_xxx.c self-tests */
typedef struct {
const int nLen; const BYTE n[ 128 ];
const int eLen; const BYTE e[ 3 ];
const int dLen; const BYTE d[ 128 ];
const int pLen; const BYTE p[ 64 ];
const int qLen; const BYTE q[ 64 ];
const int uLen; const BYTE u[ 64 ];
const int e1Len; const BYTE e1[ 64 ];
const int e2Len; const BYTE e2[ 64 ];
} RSA_KEY;
static const RSA_KEY rsa512TestKey = {
/* n */
512,
{ 0xE1, 0x95, 0x41, 0x17, 0xB4, 0xCB, 0xDC, 0xD0,
0xCB, 0x9B, 0x11, 0x19, 0x9C, 0xED, 0x04, 0x6F,
0xBD, 0x70, 0x2D, 0x5C, 0x8A, 0x32, 0xFF, 0x16,
0x22, 0x57, 0x30, 0x3B, 0xD4, 0x59, 0x9C, 0x01,
0xF0, 0xA3, 0x70, 0xA1, 0x6C, 0x16, 0xAC, 0xCC,
0x8C, 0xAD, 0xB0, 0xA0, 0xAF, 0xC7, 0xCC, 0x49,
0x4F, 0xD9, 0x5D, 0x32, 0x1C, 0x2A, 0xE8, 0x4E,
0x15, 0xE1, 0x26, 0x6C, 0xC4, 0xB8, 0x94, 0xE1 },
/* e */
5,
{ 0x11 },
/* d */
509,
{ 0x13, 0xE7, 0x85, 0xBE, 0x53, 0xB7, 0xA2, 0x8A,
0xE4, 0xC9, 0xEA, 0xEB, 0xAB, 0xF6, 0xCB, 0xAF,
0x81, 0xA8, 0x04, 0x00, 0xA2, 0xC8, 0x43, 0xAF,
0x21, 0x25, 0xCF, 0x8C, 0xCE, 0xF8, 0xD9, 0x0F,
0x10, 0x78, 0x4C, 0x1A, 0x26, 0x5D, 0x90, 0x18,
0x79, 0x90, 0x42, 0x83, 0x6E, 0xAE, 0x3E, 0x20,
0x0B, 0x0C, 0x5B, 0x6B, 0x8E, 0x31, 0xE5, 0xCF,
0xD6, 0xE0, 0xBB, 0x41, 0xC1, 0xB8, 0x2E, 0x17 },
/* p */
256,
{ 0xED, 0xE4, 0x02, 0x90, 0xA4, 0xA4, 0x98, 0x0D,
0x45, 0xA2, 0xF3, 0x96, 0x09, 0xED, 0x7B, 0x40,
0xCD, 0xF6, 0x21, 0xCC, 0xC0, 0x1F, 0x83, 0x09,
0x56, 0x37, 0x97, 0xFB, 0x05, 0x5B, 0x87, 0xB7 },
/* q */
256,
{ 0xF2, 0xC1, 0x64, 0xE8, 0x69, 0xF8, 0x5E, 0x54,
0x8F, 0xFD, 0x20, 0x8E, 0x6A, 0x23, 0x90, 0xF2,
0xAF, 0x57, 0x2F, 0x4D, 0x10, 0x80, 0x8E, 0x11,
0x3C, 0x61, 0x44, 0x33, 0x2B, 0xE0, 0x58, 0x27 },
/* u */
255,
{ 0x87, 0xB5, 0xEE, 0xA0, 0xC1, 0xF8, 0x27, 0x93,
0xCB, 0xE3, 0xD8, 0xA4, 0x5C, 0xF1, 0xBE, 0x17,
0xAA, 0x1A, 0xBB, 0xF6, 0x5C, 0x0A, 0x92, 0xEC,
0x92, 0xD8, 0x57, 0x53, 0xDC, 0xCA, 0x3D, 0x74 },
/* exponent1 */
256,
{ 0x99, 0xED, 0xE3, 0x8A, 0xC4, 0xE2, 0xF8, 0xF9,
0x87, 0x69, 0x70, 0x70, 0x24, 0x8A, 0x9B, 0x0B,
0xD0, 0x90, 0x33, 0xFC, 0xF4, 0xC9, 0x18, 0x8D,
0x92, 0x23, 0xF8, 0xED, 0xB8, 0x2C, 0x2A, 0xA3 },
/* exponent2 */
256,
{ 0xB9, 0xA2, 0xF2, 0xCF, 0xD8, 0x90, 0xC0, 0x9B,
0x04, 0xB2, 0x82, 0x4E, 0xC9, 0xA2, 0xBA, 0x22,
0xFE, 0x8D, 0xF6, 0xFE, 0xB2, 0x44, 0x30, 0x67,
0x88, 0x86, 0x9D, 0x90, 0x8A, 0xF6, 0xD9, 0xFF }
};
static const RSA_KEY rsa1024TestKey = {
/* n */
1024,
{ 0x9C, 0x4D, 0x98, 0x18, 0x67, 0xF9, 0x45, 0xBC,
0xB6, 0x75, 0x53, 0x5D, 0x2C, 0xFA, 0x55, 0xE4,
0x51, 0x54, 0x9F, 0x0C, 0x16, 0xB1, 0xAF, 0x89,
0xF6, 0xF3, 0xE7, 0x78, 0xB1, 0x2B, 0x07, 0xFB,
0xDC, 0xDE, 0x64, 0x23, 0x34, 0x87, 0xDA, 0x0B,
0xE5, 0xB3, 0x17, 0x16, 0xA4, 0xE3, 0x7F, 0x23,
0xDF, 0x96, 0x16, 0x28, 0xA6, 0xD2, 0xF0, 0x0A,
0x59, 0xEE, 0x06, 0xB3, 0x76, 0x6C, 0x64, 0x19,
0xD9, 0x76, 0x41, 0x25, 0x66, 0xD1, 0x93, 0x51,
0x52, 0x06, 0x6B, 0x71, 0x50, 0x0E, 0xAB, 0x30,
0xA5, 0xC8, 0x41, 0xFC, 0x30, 0xBC, 0x32, 0xD7,
0x4B, 0x22, 0xF2, 0x45, 0x4C, 0x94, 0x68, 0xF1,
0x92, 0x8A, 0x4C, 0xF9, 0xD4, 0x5E, 0x87, 0x92,
0xA8, 0x54, 0x93, 0x92, 0x94, 0x48, 0xA4, 0xA3,
0xEE, 0x19, 0x7F, 0x6E, 0xD3, 0x14, 0xB1, 0x48,
0xCE, 0x93, 0xD1, 0xEA, 0x4C, 0xE1, 0x9D, 0xEF },
/* e */
17,
{ 0x01, 0x00, 0x01 },
/* d */
1022,
{ 0x37, 0xE2, 0x66, 0x67, 0x13, 0x85, 0xC4, 0xB1,
0x5C, 0x6B, 0x46, 0x8B, 0x21, 0xF1, 0xBF, 0x94,
0x0A, 0xA0, 0x3E, 0xDD, 0x8B, 0x9F, 0xAC, 0x2B,
0x9F, 0xE8, 0x44, 0xF2, 0x9A, 0x25, 0xD0, 0x8C,
0xF4, 0xC3, 0x6E, 0xFA, 0x47, 0x65, 0xEB, 0x48,
0x25, 0xB0, 0x8A, 0xA8, 0xC5, 0xFB, 0xB1, 0x11,
0x9A, 0x77, 0x87, 0x24, 0xB1, 0xC0, 0xE9, 0xA2,
0x49, 0xD5, 0x19, 0x00, 0x41, 0x6F, 0x2F, 0xBA,
0x9F, 0x28, 0x47, 0xF9, 0xB8, 0xBA, 0xFF, 0xF4,
0x8B, 0x20, 0xC9, 0xC9, 0x39, 0xAB, 0x52, 0x0E,
0x8A, 0x5A, 0xAF, 0xB3, 0xA3, 0x93, 0x4D, 0xBB,
0xFE, 0x62, 0x9B, 0x02, 0xCC, 0xA7, 0xB4, 0xAE,
0x86, 0x65, 0x88, 0x19, 0xD7, 0x44, 0xA7, 0xE4,
0x18, 0xB6, 0xCE, 0x01, 0xCD, 0xDF, 0x36, 0x81,
0xD5, 0xE1, 0x62, 0xF8, 0xD0, 0x27, 0xF1, 0x86,
0xA8, 0x58, 0xA7, 0xEB, 0x39, 0x79, 0x56, 0x41 },
/* p */
512,
{ 0xCF, 0xDA, 0xF9, 0x99, 0x6F, 0x05, 0x95, 0x84,
0x09, 0x90, 0xB3, 0xAB, 0x39, 0xB7, 0xDD, 0x1D,
0x7B, 0xFC, 0xFD, 0x10, 0x35, 0xA0, 0x18, 0x1D,
0x9A, 0x11, 0x30, 0x90, 0xD4, 0x3B, 0xF0, 0x5A,
0xC1, 0xA6, 0xF4, 0x53, 0xD0, 0x94, 0xA0, 0xED,
0xE0, 0xE4, 0xE0, 0x8E, 0x44, 0x18, 0x42, 0x42,
0xE1, 0x2C, 0x0D, 0xF7, 0x30, 0xE2, 0xB8, 0x09,
0x73, 0x50, 0x28, 0xF6, 0x55, 0x85, 0x57, 0x03 },
/* q */
512,
{ 0xC0, 0x81, 0xC4, 0x82, 0x6E, 0xF6, 0x1C, 0x92,
0x83, 0xEC, 0x17, 0xFB, 0x30, 0x98, 0xED, 0x6E,
0x89, 0x92, 0xB2, 0xA1, 0x21, 0x0D, 0xC1, 0x95,
0x49, 0x99, 0xD3, 0x79, 0xD3, 0xBD, 0x94, 0x93,
0xB9, 0x28, 0x68, 0xFF, 0xDE, 0xEB, 0xE8, 0xD2,
0x0B, 0xED, 0x7C, 0x08, 0xD0, 0xD5, 0x59, 0xE3,
0xC1, 0x76, 0xEA, 0xC1, 0xCD, 0xB6, 0x8B, 0x39,
0x4E, 0x29, 0x59, 0x5F, 0xFA, 0xCE, 0x83, 0xA5 },
/* u */
511,
{ 0x4B, 0x87, 0x97, 0x1F, 0x27, 0xED, 0xAA, 0xAF,
0x42, 0xF4, 0x57, 0x82, 0x3F, 0xEC, 0x80, 0xED,
0x1E, 0x91, 0xF8, 0xB4, 0x33, 0xDA, 0xEF, 0xC3,
0x03, 0x53, 0x0F, 0xCE, 0xB9, 0x5F, 0xE4, 0x29,
0xCC, 0xEE, 0x6A, 0x5E, 0x11, 0x0E, 0xFA, 0x66,
0x85, 0xDC, 0xFC, 0x48, 0x31, 0x0C, 0x00, 0x97,
0xC6, 0x0A, 0xF2, 0x34, 0x60, 0x6B, 0xF7, 0x68,
0x09, 0x4E, 0xCF, 0xB1, 0x9E, 0x33, 0x9A, 0x41 },
/* exponent1 */
511,
{ 0x6B, 0x2A, 0x0D, 0xF8, 0x22, 0x7A, 0x71, 0x8C,
0xE2, 0xD5, 0x9D, 0x1C, 0x91, 0xA4, 0x8F, 0x37,
0x0D, 0x5E, 0xF1, 0x26, 0x73, 0x4F, 0x78, 0x3F,
0x82, 0xD8, 0x8B, 0xFE, 0x8F, 0xBD, 0xDB, 0x7D,
0x1F, 0x4C, 0xB1, 0xB9, 0xA8, 0xD7, 0x88, 0x65,
0x3C, 0xC7, 0x24, 0x53, 0x95, 0x1E, 0x20, 0xC3,
0x94, 0x8E, 0x7F, 0x20, 0xCC, 0x2E, 0x88, 0x0E,
0x2F, 0x4A, 0xCB, 0xE3, 0xBD, 0x52, 0x02, 0xFB },
/* exponent2 */
509,
{ 0x10, 0x27, 0xD3, 0xD2, 0x0E, 0x75, 0xE1, 0x17,
0xFA, 0xB2, 0x49, 0xA0, 0xEF, 0x07, 0x26, 0x85,
0xEC, 0x4D, 0xBF, 0x67, 0xFE, 0x5A, 0x25, 0x30,
0xDE, 0x28, 0x66, 0xB3, 0x06, 0xAE, 0x16, 0x55,
0xFF, 0x68, 0x00, 0xC7, 0xD8, 0x71, 0x7B, 0xEC,
0x84, 0xCB, 0xBD, 0x69, 0x0F, 0xFD, 0x97, 0xB9,
0xA1, 0x76, 0xD5, 0x64, 0xC6, 0x5A, 0xD7, 0x7C,
0x4B, 0xAE, 0xF4, 0xAD, 0x35, 0x63, 0x37, 0x71 }
};
typedef struct {
const int pLen; const BYTE p[ 64 ];
const int qLen; const BYTE q[ 20 ];
const int gLen; const BYTE g[ 64 ];
const int xLen; const BYTE x[ 20 ];
const int yLen; const BYTE y[ 64 ];
} DLP_PRIVKEY;
static const DLP_PRIVKEY dlpTestKey = {
/* p */
512,
{ 0x8D, 0xF2, 0xA4, 0x94, 0x49, 0x22, 0x76, 0xAA,
0x3D, 0x25, 0x75, 0x9B, 0xB0, 0x68, 0x69, 0xCB,
0xEA, 0xC0, 0xD8, 0x3A, 0xFB, 0x8D, 0x0C, 0xF7,
0xCB, 0xB8, 0x32, 0x4F, 0x0D, 0x78, 0x82, 0xE5,
0xD0, 0x76, 0x2F, 0xC5, 0xB7, 0x21, 0x0E, 0xAF,
0xC2, 0xE9, 0xAD, 0xAC, 0x32, 0xAB, 0x7A, 0xAC,
0x49, 0x69, 0x3D, 0xFB, 0xF8, 0x37, 0x24, 0xC2,
0xEC, 0x07, 0x36, 0xEE, 0x31, 0xC8, 0x02, 0x91 },
/* q */
160,
{ 0xC7, 0x73, 0x21, 0x8C, 0x73, 0x7E, 0xC8, 0xEE,
0x99, 0x3B, 0x4F, 0x2D, 0xED, 0x30, 0xF4, 0x8E,
0xDA, 0xCE, 0x91, 0x5F },
/* g */
512,
{ 0x62, 0x6D, 0x02, 0x78, 0x39, 0xEA, 0x0A, 0x13,
0x41, 0x31, 0x63, 0xA5, 0x5B, 0x4C, 0xB5, 0x00,
0x29, 0x9D, 0x55, 0x22, 0x95, 0x6C, 0xEF, 0xCB,
0x3B, 0xFF, 0x10, 0xF3, 0x99, 0xCE, 0x2C, 0x2E,
0x71, 0xCB, 0x9D, 0xE5, 0xFA, 0x24, 0xBA, 0xBF,
0x58, 0xE5, 0xB7, 0x95, 0x21, 0x92, 0x5C, 0x9C,
0xC4, 0x2E, 0x9F, 0x6F, 0x46, 0x4B, 0x08, 0x8C,
0xC5, 0x72, 0xAF, 0x53, 0xE6, 0xD7, 0x88, 0x02 },
/* x */
160,
{ 0x20, 0x70, 0xB3, 0x22, 0x3D, 0xBA, 0x37, 0x2F,
0xDE, 0x1C, 0x0F, 0xFC, 0x7B, 0x2E, 0x3B, 0x49,
0x8B, 0x26, 0x06, 0x14 },
/* y */
512,
{ 0x19, 0x13, 0x18, 0x71, 0xD7, 0x5B, 0x16, 0x12,
0xA8, 0x19, 0xF2, 0x9D, 0x78, 0xD1, 0xB0, 0xD7,
0x34, 0x6F, 0x7A, 0xA7, 0x7B, 0xB6, 0x2A, 0x85,
0x9B, 0xFD, 0x6C, 0x56, 0x75, 0xDA, 0x9D, 0x21,
0x2D, 0x3A, 0x36, 0xEF, 0x16, 0x72, 0xEF, 0x66,
0x0B, 0x8C, 0x7C, 0x25, 0x5C, 0xC0, 0xEC, 0x74,
0x85, 0x8F, 0xBA, 0x33, 0xF4, 0x4C, 0x06, 0x69,
0x96, 0x30, 0xA7, 0x6B, 0x03, 0x0E, 0xE3, 0x33 }
};
#ifdef TEST_CONFIG
/* The names of the configuration options we check for */
static struct {
const CRYPT_ATTRIBUTE_TYPE option; /* Option */
const char *name; /* Option name */
const BOOLEAN isNumeric; /* Whether it's a numeric option */
} configOption[] = {
{ CRYPT_OPTION_INFO_DESCRIPTION, "CRYPT_OPTION_INFO_DESCRIPTION", FALSE },
{ CRYPT_OPTION_INFO_COPYRIGHT, "CRYPT_OPTION_INFO_COPYRIGHT", FALSE },
{ CRYPT_OPTION_INFO_MAJORVERSION, "CRYPT_OPTION_INFO_MAJORVERSION", TRUE },
{ CRYPT_OPTION_INFO_MINORVERSION, "CRYPT_OPTION_INFO_MINORVERSION", TRUE },
{ CRYPT_OPTION_INFO_STEPPING, "CRYPT_OPTION_INFO_STEPPING", TRUE },
{ CRYPT_OPTION_ENCR_ALGO, "CRYPT_OPTION_ENCR_ALGO", TRUE },
{ CRYPT_OPTION_ENCR_HASH, "CRYPT_OPTION_ENCR_HASH", TRUE },
{ CRYPT_OPTION_ENCR_MAC, "CRYPT_OPTION_ENCR_MAC", TRUE },
{ CRYPT_OPTION_PKC_ALGO, "CRYPT_OPTION_PKC_ALGO", TRUE },
{ CRYPT_OPTION_PKC_KEYSIZE, "CRYPT_OPTION_PKC_KEYSIZE", TRUE },
{ CRYPT_OPTION_SIG_ALGO, "CRYPT_OPTION_SIG_ALGO", TRUE },
{ CRYPT_OPTION_SIG_KEYSIZE, "CRYPT_OPTION_SIG_KEYSIZE", TRUE },
{ CRYPT_OPTION_KEYING_ALGO, "CRYPT_OPTION_KEYING_ALGO", TRUE },
{ CRYPT_OPTION_KEYING_ITERATIONS, "CRYPT_OPTION_KEYING_ITERATIONS", TRUE },
{ CRYPT_OPTION_CERT_CREATEV3CERT, "CRYPT_OPTION_CERT_CREATEV3CERT", TRUE },
{ CRYPT_OPTION_CERT_PKCS10ALT, "CRYPT_OPTION_CERT_PKCS10ALT", TRUE },
{ CRYPT_OPTION_CERT_FIXEMAILADDRESS, "CRYPT_OPTION_CERT_FIXEMAILADDRESS", TRUE },
{ CRYPT_OPTION_CERT_SIGNUNRECOGNISEDATTRIBUTES, "CRYPT_OPTION_CERT_SIGNUNRECOGNISEDATTRIBUTES", TRUE },
{ CRYPT_OPTION_CERT_TRUSTCHAINROOT, "CRYPT_OPTION_CERT_TRUSTCHAINROOT", TRUE },
{ CRYPT_OPTION_CERT_VALIDITY, "CRYPT_OPTION_CERT_VALIDITY", TRUE },
{ CRYPT_OPTION_CERT_UPDATEINTERVAL, "CRYPT_OPTION_CERT_UPDATEINTERVAL", TRUE },
{ CRYPT_OPTION_CERT_ENCODE_VALIDITYNESTING, "CRYPT_OPTION_CERT_ENCODE_VALIDITYNESTING", TRUE },
{ CRYPT_OPTION_CERT_DECODE_VALIDITYNESTING, "CRYPT_OPTION_CERT_DECODE_VALIDITYNESTING", TRUE },
{ CRYPT_OPTION_CERT_ENCODE_CRITICAL, "CRYPT_OPTION_CERT_ENCODE_CRITICAL", TRUE },
{ CRYPT_OPTION_CERT_DECODE_CRITICAL, "CRYPT_OPTION_CERT_DECODE_CRITICAL", TRUE },
{ CRYPT_OPTION_KEYS_LDAP_OBJECTCLASS, "CRYPT_OPTION_KEYS_LDAP_OBJECTCLASS", FALSE },
{ CRYPT_OPTION_KEYS_LDAP_OBJECTTYPE, "CRYPT_OPTION_KEYS_LDAP_OBJECTTYPE", TRUE },
{ CRYPT_OPTION_KEYS_LDAP_FILTER, "CRYPT_OPTION_KEYS_LDAP_FILTER", FALSE },
{ CRYPT_OPTION_KEYS_LDAP_CACERTNAME, "CRYPT_OPTION_KEYS_LDAP_CACERTNAME", FALSE },
{ CRYPT_OPTION_KEYS_LDAP_CERTNAME, "CRYPT_OPTION_KEYS_LDAP_CERTNAME", FALSE },
{ CRYPT_OPTION_KEYS_LDAP_CRLNAME, "CRYPT_OPTION_KEYS_LDAP_CRLNAME", FALSE },
{ CRYPT_OPTION_KEYS_LDAP_EMAILNAME, "CRYPT_OPTION_KEYS_LDAP_EMAILNAME", FALSE },
{ CRYPT_OPTION_DEVICE_PKCS11_DVR01, "CRYPT_OPTION_DEVICE_PKCS11_DVR01", FALSE },
{ CRYPT_OPTION_DEVICE_PKCS11_DVR02, "CRYPT_OPTION_DEVICE_PKCS11_DVR02", FALSE },
{ CRYPT_OPTION_DEVICE_PKCS11_DVR03, "CRYPT_OPTION_DEVICE_PKCS11_DVR03", FALSE },
{ CRYPT_OPTION_DEVICE_PKCS11_DVR04, "CRYPT_OPTION_DEVICE_PKCS11_DVR04", FALSE },
{ CRYPT_OPTION_DEVICE_PKCS11_DVR05, "CRYPT_OPTION_DEVICE_PKCS11_DVR05", FALSE },
{ CRYPT_OPTION_DEVICE_PKCS11_HARDWAREONLY, "CRYPT_OPTION_DEVICE_PKCS11_HARDWAREONLY", TRUE },
{ CRYPT_OPTION_DEVICE_SERIALRNG, "CRYPT_OPTION_DEVICE_SERIALRNG", FALSE },
{ CRYPT_OPTION_DEVICE_SERIALRNG_PARAMS, "CRYPT_OPTION_DEVICE_SERIALPARAMS", FALSE },
{ CRYPT_OPTION_CMS_DEFAULTATTRIBUTES, "CRYPT_OPTION_CMS_DEFAULTATTRIBUTES", TRUE },
{ CRYPT_OPTION_NET_SOCKS_SERVER, "CRYPT_OPTION_NET_SOCKS_SERVER", FALSE },
{ CRYPT_OPTION_NET_SOCKS_USERNAME, "CRYPT_OPTION_NET_SOCKS_USERNAME", FALSE },
{ CRYPT_OPTION_NET_HTTP_PROXY, "CRYPT_OPTION_NET_HTTP_PROXY", FALSE },
{ CRYPT_OPTION_NET_TIMEOUT, "CRYPT_OPTION_NET_TIMEOUT", TRUE },
{ CRYPT_ATTRIBUTE_NONE, NULL, 0 }
};
#endif /* TEST_CONFIG */
/* There are some sizeable (for DOS) data structures used, so we increase the
stack size to allow for them */
#if defined( __MSDOS16__ ) && defined( __TURBOC__ )
extern unsigned _stklen = 16384;
/* We also fake out a few unnecessary/unused functions */
void gfInit( void ) {}
void gfQuit( void ) {}
void deflateInit_( void ) {}
void deflateInit2_( void ) {}
void deflate( void ) {}
void deflateEnd( void ) {}
int pgpProcessPreamble( void ) { return( CRYPT_ERROR_NOTAVAIL ); }
int pgpProcessPostamble( void ) { return( CRYPT_ERROR_NOTAVAIL ); }
#ifdef __BORLANDC__x
/* BC++ 3.x doesn't have mbstowcs() in the default library, and also defines
wchar_t as char (!!) so we fake it here */
size_t mbstowcs( char *pwcs, const char *s, size_t n )
{
memcpy( pwcs, s, n );
return( n );
}
#endif /* __BORLANDC__ */
#endif /* __MSDOS16__ && __TURBOC__ */
/* Some algorithms can be disabled to eliminate patent problems or reduce the
size of the code. The following functions are used to select generally
equivalent alternatives if the required algorithm isn't available. These
selections make certain assumptions (that the given algorithms are always
available, which is virtually guaranteed, and that they have the same
general properties as the algorithms they're replacing, which is also
usually the case - Blowfish for IDEA, RC2, or RC5, and MD5 for MD4) */
CRYPT_ALGO selectCipher( const CRYPT_ALGO algorithm )
{
if( cryptStatusOK( cryptQueryCapability( algorithm, NULL ) ) )
return( algorithm );
return( CRYPT_ALGO_BLOWFISH );
}
/* When using multiple threads we need to delay one thread for a small
amount of time, unfortunately there's no easy way to do this with pthreads
so we have to provide the following wrapper function which makes an
(implementation-specific) attempt at it */
#if defined( UNIX_THREADS ) || defined( WINDOWS_THREADS ) || defined( OS2_THREADS )
#if defined( UNIX_THREADS )
/* This include must be outside the function to avoid weird compiler errors
on some systems */
#include <sys/time.h>
#endif /* UNIX_THREADS */
void delayThread( const int seconds )
{
#if defined( UNIX_THREADS )
struct timeval tv = { 0 };
/* The following should put a thread to sleep for a second on most
systems since the select() should be a thread-safe one in the
presence of pthreads */
tv.tv_sec = seconds;
select( 1, NULL, NULL, NULL, &tv );
#elif defined( WINDOWS_THREADS )
Sleep( seconds * 1000 );
#endif /* Threading system-specific delay functions */
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -