RSA BSAFE Micro Edition Suite	Streamlined security for mobile and embedded devices

---

cryp_mod.h

Go to the documentation of this file.

/* $Id: cryp_mod.h,v 1.170.2.1 2005/10/11 03:37:15 hpriddle Exp $ */
/*
 * Copyright (C) 1998-2003 RSA Security Inc. All rights reserved.
 *
 * This work contains proprietary information of RSA Security.
 * Distribution is limited to authorized licensees of RSA
 * Security. Any unauthorized reproduction, distribution or
 * modification of this work is strictly prohibited.
 */

#ifndef HEADER_COMMON_CRYP_MOD_H
#define HEADER_COMMON_CRYP_MOD_H

#ifdef  __cplusplus
extern "C" {
#endif

#include "r_lib.h"
#include "r_com.h"
#include "r_nid.h"
#include "r_pkey.h"
#include "r_skey.h"

#include "c_impmth.h"

#if !defined(NO_NAT_METH) && !defined(NO_SOFTWARE_CRYPTO)
#include "nat_meth.h"
#endif

#ifndef HEADER_COMMON_MODULE_CRYP_MOD_TYPEDEF_DEF
#define HEADER_COMMON_MODULE_CRYP_MOD_TYPEDEF_DEF

typedef int R_CR_ALG_ID;
typedef int R_CR_ALG_TYPE;
typedef int R_CR_ALG_SUB;
#endif /* HEADER_COMMON_MODULE_CRYP_MOD_TYPEDEF_DEF */

#define R_CR_DIGEST_MD2_LEN                 16

#define R_CR_DIGEST_MD5_LEN                 16

#define R_CR_DIGEST_SHA1_LEN                20

#define R_CR_DIGEST_SHA256_LEN              32

#define R_CR_DIGEST_SHA384_LEN              48

#define R_CR_DIGEST_SHA512_LEN              64
#ifndef NO_SHA512

#define R_CR_DIGEST_MAX_LEN                 R_CR_DIGEST_SHA512_LEN
#elif !defined(NO_SHA384)
#define R_CR_DIGEST_MAX_LEN                 R_CR_DIGEST_SHA384_LEN
#elif !defined(NO_SHA256)
#define R_CR_DIGEST_MAX_LEN                 R_CR_DIGEST_SHA256_LEN
#elif !defined(NO_SHA1)
#define R_CR_DIGEST_MAX_LEN                 R_CR_DIGEST_SHA1_LEN
#elif !defined(NO_MD5)
#define R_CR_DIGEST_MAX_LEN                 R_CR_DIGEST_MD5_LEN
#else
#define R_CR_DIGEST_MAX_LEN                 16
#endif

#define R_CR_CIPHER_KEY_MAX_LEN             32 /* AES is the biggest */

#define R_CR_CIPHER_IV_MAX_LEN              32 /* AES is the biggest */

#define R_CR_NOT_SUPPORTED                  0

#define R_CR_NOT_AVAIL                      1

#define R_CR_SUPPORTED                      2

#define R_CR_TYPE_NONE                      0

#define R_CR_TYPE_ASYM                      1

#define R_CR_TYPE_CIPHER                    2

#define R_CR_TYPE_DIGEST                    3

#define R_CR_TYPE_RANDOM                    4

#define R_CR_TYPE_KEY_EXCHANGE              5

#define R_CR_TYPE_SIGNATURE                 6

#define R_CR_TYPE_MAC                       7

#define R_CR_TYPE_KEYGEN                    8

#define R_CR_TYPE_PARAMGEN                  9

#define R_CR_TYPE_MAX                       9

/* There are two sorts of sub-ids -- Those with a single bit set that can be
   combined by bit-wise or in a method table for methods that can handle more
   than one sub-id. For algorithms for which combinable sub-ids are not
   sensible, a range for scalar sub-id allocation is also reserved.

   Assuming a 32-bit integer, up to 30 single-bit sub-ids and 2^^31 - 2
   scalar sub-ids may be defined.

   The macros below have the effect of defining scalar sub-ids as odd numbers
   and single-bit sub-ids as even numbers. Using the low-order bit to
   distinguish scalar and bit ids ensures independence from integer size.
*/
#define R_CR_SUB_BIT(n)                 (1<<((n)+1))
#define R_CR_SUB_SCALAR(n)              (((n)<<1)|1)
#define R_CR_IS_SUB_SCALAR(sub)         ((((sub)&1)==1)||(sub==R_CR_SUB_NONE))
#define R_CR_IS_SUB_BIT(sub)            (!R_CR_IS_SUB_SCALAR(sub))

/* the max sub bit currently used - must be updated when new SUB_IDs are added
 * as the hardware module uses this to make sure SUB_IDs it requires do
 * no clash with those used here.
 */
#define R_CR_SUB_BIT_MAX                8

#define R_CR_SUB_NONE                   0

#define R_CR_SUB_SIGN                   R_CR_SUB_BIT(0)

#define R_CR_SUB_VERIFY                 R_CR_SUB_BIT(1)

#define R_CR_SUB_ENCRYPT                R_CR_SUB_BIT(2)

#define R_CR_SUB_DECRYPT                R_CR_SUB_BIT(3)

#define R_CR_SUB_PUBLIC                 R_CR_SUB_BIT(4)

#define R_CR_SUB_PRIVATE                R_CR_SUB_BIT(5)

#define R_CR_SUB_MAC                    R_CR_SUB_BIT(6)

#define R_CR_SUB_SOFTWARE_ONLY          R_CR_SUB_BIT(7)

#define R_CR_SUB_HARDWARE_ONLY          R_CR_SUB_BIT(8)

#define R_CR_SUB_PUB_ENC                (R_CR_SUB_PUBLIC|R_CR_SUB_ENCRYPT)

#define R_CR_SUB_PUB_DEC                (R_CR_SUB_PUBLIC|R_CR_SUB_DECRYPT)

#define R_CR_SUB_PRIV_ENC               (R_CR_SUB_PRIVATE|R_CR_SUB_ENCRYPT)

#define R_CR_SUB_PRIV_DEC               (R_CR_SUB_PRIVATE|R_CR_SUB_DECRYPT)

/*
 * Use this macro to define IDs that are meaningful only to the R_CR_xxx
 * functions and not to lower layers (e.g., the nat_meth layer. These IDs
 * MUST NOT be passed to lower layers that expect some type of NID_xxx. The
 * local IDs begin at 4096 to give wide berth to the NIDs defined in
 * object.h.
 */
#define R_CR_ID_LOCAL(local_id)             (4096 + (local_id))

/* the max id currently used - must be updated when new IDs are added
 * as the hardware module uses this to make sure IDs it requires do
 * no clash with those used here.
 */
#define R_CR_ID_MAX                         R_CR_ID_LOCAL(10)

/* Define algorithm IDs and map them to NIDs where possible.
   In general, two names are defined for each ID -- one that includes the
   algorithm type and one that does not.
 */
#define R_CR_ID_UNKNOWN                     (-1)

#define R_CR_ID_RSA                         NID_rsa

#define R_CR_ID_RSA_PKCS1                   NID_rsaEncryption

#define R_CR_ID_RSA_PKCS1_OAEP              NID_rsaes_oaep

#define R_CR_ID_RSA_PKCS1_SSL               R_CR_ID_LOCAL(7)

#define R_CR_ID_RSA_PKCS1_RAW               R_CR_ID_LOCAL(9)

#define R_CR_ID_RSA_X931                    R_CR_ID_LOCAL(14)

#define R_CR_ID_ECAES                       R_CR_ID_LOCAL(23)

#define R_CR_ID_AES_128_CBC                 NID_aes128_cbc

#define R_CR_ID_AES_128_ECB                 NID_aes128_ecb

#define R_CR_ID_AES_128_CFB                 NID_aes128_cfb

#define R_CR_ID_AES_128_OFB                 NID_aes128_ofb

#define R_CR_ID_AES_192_CBC                 NID_aes192_cbc

#define R_CR_ID_AES_192_ECB                 NID_aes192_ecb

#define R_CR_ID_AES_192_CFB                 NID_aes192_cfb

#define R_CR_ID_AES_192_OFB                 NID_aes192_ofb

#define R_CR_ID_AES_256_CBC                 NID_aes256_cbc

#define R_CR_ID_AES_256_ECB                 NID_aes256_ecb

#define R_CR_ID_AES_256_CFB                 NID_aes256_cfb

#define R_CR_ID_AES_256_OFB                 NID_aes256_ofb

#define R_CR_ID_DES_CBC                     NID_des_cbc

#define R_CR_ID_DES_EDE                     NID_des_ede

#define R_CR_ID_DES_ECB                     NID_des_ecb

#define R_CR_ID_DES_CFB64                   NID_des_cfb64

#define R_CR_ID_DES_EDE3                    NID_des_ede3

#define R_CR_ID_DES_EDE_CBC                 NID_des_ede_cbc

#define R_CR_ID_DES_EDE3_CBC                NID_des_ede3_cbc

#define R_CR_ID_DES_EDE_CFB64               NID_des_ede_cfb64

#define R_CR_ID_DES_EDE3_CFB64              NID_des_ede3_cfb64

#define R_CR_ID_DES_EDE_OFB64               NID_des_ede_ofb64

#define R_CR_ID_DES_EDE3_OFB64              NID_des_ede3_ofb64

#define R_CR_ID_DES_40_CBC                  NID_des_40_cbc

#define R_CR_ID_DES_40_CFB                  NID_des_40_cfb

#define R_CR_ID_DES_OFB                     NID_des_ofb64

#define R_CR_ID_RC2_CBC                     NID_rc2_cbc

#define R_CR_ID_RC2_ECB                     NID_rc2_ecb

#define R_CR_ID_RC2_CFB                     NID_rc2_cfb64

#define R_CR_ID_RC2_OFB                     NID_rc2_ofb64

#define R_CR_ID_RC2_40_CBC                  NID_rc2_40_cbc

#define R_CR_ID_RC4                         NID_rc4

#define R_CR_ID_RC4_40                      NID_rc4_40

#define R_CR_ID_RC5_CBC                     NID_rc5_cbc

/*
 * Equivalent RC5-CBC identifier for compatibility with OpenSSL
 */
#define R_CR_ID_RC5_CBC_NO_PAD              NID_rc5_cbc_no_pad

#define R_CR_ID_RC5_ECB                     NID_rc5_ecb

#define R_CR_ID_RC5_CFB                     NID_rc5_cfb64

#define R_CR_ID_RC5_OFB                     NID_rc5_ofb64

/*
 * A cryptographic identifier which indicates an RC6 CBC symmetric cipher.
 * The following table details the usage of the identifier
 * in @ref R_CR_CTX_FN.
 *
 * <table><tr>
 * <td><b>Function</b></td>
 * <td><b>String</b></td>
 * <td><b>Description</b></td>
 * </tr><tr>
 * <td>R_CR_ID_from_string()</td>
 * <td><tt>"RC6_CBC"</tt></td>
 * <td>This string is interpreted as the <tt>RC6_CBC</tt> type.</td>
 * </tr><tr>
 * <td>R_CR_ID_to_string()</td>
 * <td><tt>"RC6_CBC"</tt></td>
 * <td>The string that represents an <tt>RC6_CBC</tt> type.</td>
 * </tr></table>
 */
#define R_CR_ID_RC6_CBC                     NID_rc6_cbc
/*
 * A cryptographic identifier which indicates an RC6 ECB symmetric cipher.
 * The following table details the usage of the identifier
 * in @ref R_CR_CTX_FN.
 *
 * <table><tr>
 * <td><b>Function</b></td>
 * <td><b>String</b></td>
 * <td><b>Description</b></td>
 * </tr><tr>
 * <td>R_CR_ID_from_string()</td>
 * <td><tt>"RC6_ECB"</tt></td>
 * <td>This string is interpreted as the <tt>RC6_ECB</tt> type.</td>
 * </tr><tr>
 * <td>R_CR_ID_to_string()</td>
 * <td><tt>"RC6_ECB"</tt></td>
 * <td>The string that represents an <tt>RC6_ECB</tt> type.</td>
 * </tr></table>
 */
#define R_CR_ID_RC6_ECB                     NID_rc6_ecb
/*
 * A cryptographic identifier which indicates an RC6 CFB symmetric cipher.
 * The following table details the usage of the identifier
 * in @ref R_CR_CTX_FN.
 *
 * <table><tr>
 * <td><b>Function</b></td>
 * <td><b>String</b></td>
 * <td><b>Description</b></td>
 * </tr><tr>
 * <td>R_CR_ID_from_string()</td>
 * <td><tt>"RC6_CFB"</tt></td>
 * <td>This string is interpreted as the <tt>RC6_CFB</tt> type.</td>
 * </tr><tr>
 * <td>R_CR_ID_to_string()</td>
 * <td><tt>"RC6_CFB"</tt></td>
 * <td>The string that represents an <tt>RC6_CFB</tt> type.</td>
 * </tr></table>
 */
#define R_CR_ID_RC6_CFB                     NID_rc6_cfb128
/*
 * A cryptographic identifier which indicates an RC6 OFB symmetric cipher.
 * The following table details the usage of the identifier
 * in @ref R_CR_CTX_FN.
 *
 * <table><tr>
 * <td><b>Function</b></td>
 * <td><b>String</b></td>
 * <td><b>Description</b></td>
 * </tr><tr>
 * <td>R_CR_ID_from_string()</td>
 * <td><tt>"RC6_OFB"</tt></td>
 * <td>This string is interpreted as the <tt>RC6_OFB</tt> type.</td>
 * </tr><tr>
 * <td>R_CR_ID_to_string()</td>
 * <td><tt>"RC6_OFB"</tt></td>
 * <td>The string that represents an <tt>RC6_OFB</tt> type.</td>
 * </tr></table>
 */
#define R_CR_ID_RC6_OFB                     NID_rc6_ofb128

#define R_CR_ID_NULL                        0

#define R_CR_ID_SHA1                        NID_sha1

#define R_CR_ID_SHA256                      NID_sha256

#define R_CR_ID_SHA384                      NID_sha384

#define R_CR_ID_SHA512                      NID_sha512

#define R_CR_ID_MD2                         NID_md2

#define R_CR_ID_MD5                         NID_md5

#define R_CR_ID_DIGEST_NULL                 R_CR_ID_NULL

#define R_CR_ID_RANDOM                      R_CR_ID_LOCAL(0)

#define R_CR_ID_RANDOM_ENTROPY              R_CR_ID_LOCAL(11)

/*
 * Indicates a random cryptographic identifier that uses
 * the global FIPS 186-2 CN1 random object.
 */
#define R_CR_ID_RANDOM_GLOBAL               R_CR_ID_LOCAL(12)

#define R_CR_ID_RANDOM_MODULUS              R_CR_ID_LOCAL(13)

#define R_CR_ID_RANDOM_SYS                  R_CR_ID_LOCAL(8)

/*
 * Indicates the identifier for the deterministic random implementation.
 * This "random" implementation allows Byte blocks to be set by the
 * application that are returned without modification from
 * R_CR_random_bytes(). This option is meant to be used for testing
 * purposes only, where deterministic random output is an advantage.
 *
 * The following table details the usage of the identifier
 * in @ref R_CR_CTX_FN.
 *
 * <table><tr>
 * <td><b>Function</b></td>
 * <td><b>String</b></td>
 * <td><b>Description</b></td>
 * </tr><tr>
 * <td>R_CR_ID_from_string()</td>
 * <td><tt>"RANDOM_OTP"</tt></td>
 * <td>This string is interpreted as the <tt>RANDOM_OTP</tt> type.</td>
 * </tr><tr>
 * <td>R_CR_ID_to_string()</td>
 * <td><tt>"RANDOM_OTP"</tt></td>
 * <td>The string that represents a <tt>RANDOM_OTP</tt> type.</td>
 * </tr></table>
 */
#define R_CR_ID_RANDOM_OTP                  R_CR_ID_LOCAL(17)

#ifndef NO_DH

#endif /* NO_DH */

#define R_CR_ID_KE_DH                       NID_dhKeyAgreement

#define R_CR_ID_DSA                         NID_dsa

/* Defines for signing and verify */
#define R_CR_ID_SHA1_DSA                    NID_dsaWithSHA1

#define R_CR_ID_SHA1_RSA                    NID_sha1WithRSAEncryption

#define R_CR_ID_SHA1_RSA_RAW                R_CR_ID_LOCAL(10)

#define R_CR_ID_SHA1_RSA_X931               R_CR_ID_LOCAL(15)

#define R_CR_ID_MD2_RSA                     NID_md2WithRSAEncryption

#define R_CR_ID_MD5_RSA                     NID_md5WithRSAEncryption

#define R_CR_ID_SIGNATURE_TYPE_NONE         R_CR_ID_NULL

#define R_CR_ID_SIGNATURE_TYPE_DER          1

#define R_CR_ID_HMAC_MD5                    R_CR_ID_LOCAL(1)

#define R_CR_ID_HMAC_SHA1                   R_CR_ID_LOCAL(2)

#define R_CR_ID_RSA_KEY_GENERATION          R_CR_ID_LOCAL(3)

#define R_CR_ID_RSA_KEY_GENERATION_X931     R_CR_ID_LOCAL(18)

#define R_CR_ID_DSA_KEY_GENERATION          R_CR_ID_LOCAL(4)

#define R_CR_ID_RSA_KEY_GENERATION_VENDOR    R_CR_ID_LOCAL(16)

#define R_CR_ID_DSA_PARAMETER_GENERATION    R_CR_ID_LOCAL(5)

#define R_CR_ID_DH_PARAMETER_GENERATION     R_CR_ID_LOCAL(6)

#define R_CR_ID_ECDSA_SHA1                  NID_ECDSAwithSHA1

/*
 * A cryptographic identifier which indicates that the algorithm is supported.
 */
#define R_CR_INFO_ID_SUPPORTED              0

#define R_CR_INFO_ID_KEY_LEN                1
/*
 * A cryptographic identifier which indicates the export strength cipher.
 */
#define R_CR_INFO_ID_IS_EXPORT              2
/*
 * A cryptographic identifier which indicates key agreement authentication.
 */
#define R_CR_INFO_ID_KE_AUTHENTICATE        3
/*
 * A cryptographic identifier which indicates the key agreement type.
 */
#define R_CR_INFO_ID_KE_TYPE                4
/*
 * A cryptographic identifier which indicates the export strength key length.
 */
#define R_CR_INFO_ID_CIPHER_EXP_KEY_LEN     5

#define R_CR_INFO_ID_CIPHER_IV_LEN          6
/*
 * A cryptographic identifier which indicates the symmetric cipher parameter.
 */
#define R_CR_INFO_ID_CIPHER_PARAM           7

#define R_CR_INFO_ID_CIPHER_ROUNDS          8
/*
 * A cryptographic identifier which indicates the symmetric cipher type.
 */
#define R_CR_INFO_ID_CIPHER_TYPE            9

#define R_CR_INFO_ID_CIPHER_BLOCK_SIZE      10

#define R_CR_INFO_ID_DIGEST_MAC_LEN         11

#define R_CR_INFO_ID_DIGEST_BLOCK_SIZE      13

#define R_CR_INFO_ID_CIPHER_BITS            14

#define R_CR_INFO_ID_OAEP_PARAM             15

#define R_CR_INFO_ID_SURRENDER              16

#define R_CR_INFO_ID_CRYPTO_TYPE            17

#define R_CR_INFO_ID_CRYPTO_ID              18

#define R_CR_INFO_ID_CRYPTO_SUB             19

#define R_CR_INFO_ID_BLOCK_PADDING          20

#define R_CR_INFO_ID_FLAGS                  21

#define R_CR_INFO_ID_NUM_BITS               22  
#define R_CR_INFO_ID_NUM_PRIMES             23  
#define R_CR_INFO_ID_PUBLIC_KEY             24

#define R_CR_INFO_ID_PRIVATE_KEY            25

#define R_CR_INFO_ID_DSA_P                  26

#define R_CR_INFO_ID_DSA_Q                  27

#define R_CR_INFO_ID_DSA_G                  28

#define R_CR_INFO_ID_DH_PRIME_LENGTH        29  
#define R_CR_INFO_ID_DH_GENERATOR_ORDER     30

#define R_CR_INFO_ID_RSA_E                  31  
#define R_CR_INFO_ID_DSA_PARAMETERS         32

#define R_CR_INFO_ID_SIGNATURE              33

#define R_CR_INFO_DH_PRIV_KEY               34

#define R_CR_INFO_ID_RAND_FILE_NAME         48

#define R_CR_INFO_ID_RAND_WRITE_FILE        49

#define R_CR_INFO_ID_RAND_ADD_ENTROPY       50

#define R_CR_INFO_ID_RAND_LOAD_FILE         51

#define R_CR_INFO_ID_RAND_ENTROPY_FUNC      52

#define R_CR_INFO_ID_RANDOM                 53

#define R_CR_INFO_ID_RAND_BLOCK_SIZE        54

#define R_CR_INFO_ID_RAND_AUTO_SEED         56

#define R_CR_INFO_ID_RAND_KEY_SEED_COMPARE  57

#define R_CR_INFO_ID_RAND_RUN_TIME_TESTS    58

#define R_CR_INFO_ID_RAND_SEED_RESET        59

#define R_CR_INFO_ID_RAND_MODULUS           60
/*
 * A cryptographic identifier which sets the random object into a
 * deterministic mode of operation for testing purposes. Only available
 * when using #R_CR_ID_RANDOM_OTP. The deterministic mode of operation is
 * enabled by default.
 */
#define R_CR_INFO_ID_RAND_PREDICTABLE_MODE  62
/*
 * A cryptographic identifier which sets against a random object a random
 * object with which to get random data from. Only available when using
 * #R_CR_ID_RANDOM_OTP.
 */
#define R_CR_INFO_ID_RAND_REAL_RANDOM       63

#define R_CR_INFO_ID_DSA_SEED               64

/* next available value for R_CR_INFO_ID is: 65 */

#define R_CR_INFO_ID_LABEL                  PK_SHARED_ID_LABEL

#define R_CR_INFO_ID_KEY_ID                 PK_SHARED_ID_HW_ID

#define R_CR_FLAG_CIPHER_NO_BLOCK_PADDING   0x0001

#define R_CR_FLAG_CIPHER_KEY_SET            0x0002

#define R_CR_FLAG_DER_SIGNATURE             0x0004

#define R_CR_FLAG_ITEMS_ALLOCED             0x0008

#define R_CR_FLAG_RANDOM_AVAIL              0x0010

#define R_CR_FLAG_RANDOM_R_CR               0x0020


#define R_CR_RANDOM_ENTROPY_TYPE_SMALL      1

#define R_CR_RANDOM_ENTROPY_TYPE_LARGE      2

#define R_CR_RANDOM_RNG_KEY_SEED_COMPARE_OFF           0

#define R_CR_RANDOM_RNG_KEY_SEED_COMPARE_ON            1

#define R_CR_RANDOM_RNG_KEY_SEED_COMPARE_FAILED        2

#define R_CR_RANDOM_RNG_TESTS_OFF           0

#define R_CR_RANDOM_RNG_TESTS_ON            1

#define R_CR_RANDOM_RNG_TESTS_FAILED        2

#define R_CR_CTX_INFO_ID_RANDOM             0

#define R_CR_CTX_INFO_ID_SURRENDER          1

#ifndef NO_HDW

#endif
#define R_CR_CTX_INFO_ID_HW_CTX             3


/* Structure types */
typedef struct r_cr_method_st               R_CR_METHOD;
typedef struct r_cr_imp_method_st           R_CR_IMP_METHOD;
typedef struct r_cr_ctx_st                  R_CR_CTX;
#ifndef HEADER_COMMON_R_CR_TYPEDEF_DEF
#define HEADER_COMMON_R_CR_TYPEDEF_DEF

typedef struct r_cr_st                      R_CR;
#endif /* HEADER_COMMON_R_CR_TYPEDEF_DEF */

typedef struct r_sign_vfy_map_obj_st        R_CR_SIGN_VFY_MAP;

struct r_sign_vfy_map_obj_st
    {
    int sig_id;
    int dig_id;
    int pk_id;
    };

#define R_CR_RES_LIBRARY_SMALL \
        { R_RES_MOD_ID_LIBRARY, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_DEF, \
          R_RES_FLAG_DEF, NULL, NULL, \
          (void *(*)(void *))R_LIB_CTX_get_small_method, NULL }

#define R_CR_RES_LIBRARY \
        { R_RES_MOD_ID_LIBRARY, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_DEF, \
          R_RES_FLAG_DEF, NULL, NULL, \
          (void *(*)(void *))R_LIB_CTX_get_default_method, NULL }

#ifdef FIPS140_ONLY
#define R_CR_RES_CRYPTO_DEFAULT R_CR_RES_NIST
#else
#define R_CR_RES_CRYPTO_DEFAULT \
    { R_RES_MOD_ID_CRYPTO, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_DEF, \
      R_RES_FLAG_DEF, NULL, NULL, \
      (void *(*)(void *))R_CR_get_default_method, \
      (void *(*)(void *))R_CR_get_default_imp_method }
#endif

#define R_CR_RES_CRYPTO_CUSTOM \
    { R_RES_MOD_ID_CRYPTO, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_DEF, \
      R_RES_FLAG_DEF, NULL, NULL, \
      (void *(*)(void *))R_CR_get_default_method, \
      (void *(*)(void *))(R_CR_HAVE_CIPHER_LIST *(*)(void *))r_crm_custom_list_retriever }

#define R_CR_RES_SIGNATURE_MAP \
    { R_RES_MOD_ID_CRYPTO, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_MAP,\
          R_RES_FLAG_DEF, NULL, NULL, NULL,\
      (void *(*)(void *))R_CR_get_default_signature_map }

#define R_CR_RES_LOCK \
    { R_RES_MOD_ID_LOCK, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_DEF, \
      R_RES_FLAG_DEF, NULL, R_LOCK_lib_finish, \
      (void *(*)(void *))R_LOCK_get_default_method, NULL }

#define R_CR_RES_PKEY_PRINT \
    { R_RES_MOD_ID_PKEY, R_RES_IMPL_ID_PRINT_FUNC, \
      R_RES_SUB_ID_DEF, R_RES_FLAG_DEF, NULL, NULL, NULL, \
      (void *(*)(void *))R_PKEY_get_print_func }

#define R_CR_RES_PKEY_RSA \
    { R_RES_MOD_ID_PKEY, R_RES_IMPL_ID_DEF, R_PKEY_TYPE_RSA, \
      R_RES_FLAG_DEF, NULL, NULL, (void *(*)(void *))R_PKEY_pk_method, \
      NULL }

#define R_CR_RES_PKEY_DSA \
    { R_RES_MOD_ID_PKEY, R_RES_IMPL_ID_DEF, R_PKEY_TYPE_DSA, \
      R_RES_FLAG_DEF, NULL, NULL, (void *(*)(void *))R_PKEY_pk_method, \
      NULL }

#define R_CR_RES_PKEY_DH \
    { R_RES_MOD_ID_PKEY, R_RES_IMPL_ID_DEF, R_PKEY_TYPE_DH, \
      R_RES_FLAG_DEF, NULL, NULL, (void *(*)(void *))R_PKEY_pk_method, \
      NULL }

#define R_CR_RES_RAND \
    { R_RES_MOD_ID_RAND, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_DEF, \
      R_RES_FLAG_DEF, NULL, \
      (int (*)(R_RES_LIST *, R_RES_ITEM *, void **))R_rand_lib_cleanup, \
      (void *(*)(void *))R_rand_get_default, NULL }

#define R_CR_RES_TIME \
    { R_RES_MOD_ID_TIME, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_DEF, \
      R_RES_FLAG_DEF, NULL, NULL, \
      (void *(*)(void *))R_TIME_get_time_mi_method, NULL }

#define R_CR_RES_COMMON_ERROR_STRINGS \
    { R_RES_MOD_ID_LIBRARY, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_ERROR_STRINGS, \
      R_RES_FLAG_DEF, NULL, NULL, NULL, \
      (void *(*)(void *))R_LIB_CTX_com_err_str_table }

#define R_CR_RES_CRYPTO_REASON_STRINGS \
    { R_RES_MOD_ID_CRYPTO, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_REASON_STRINGS, \
          R_RES_FLAG_DEF, NULL, NULL, NULL, \
      (void *(*)(void *))R_CR_get_reason_string_table }

#define R_CR_RES_CRYPTO_FUNCTION_NAMES \
    { R_RES_MOD_ID_CRYPTO, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_FUNCTION_STRINGS,\
          R_RES_FLAG_DEF, NULL, NULL, NULL,\
      (void *(*)(void *))R_CR_get_function_string_table }

#define R_CR_RES_CRYPTO_DETAIL_STRINGS \
    { R_RES_MOD_ID_CRYPTO, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_DETAIL_STRINGS, \
          R_RES_FLAG_DEF, NULL, NULL, NULL, \
      (void *(*)(void *))R_CR_get_detail_string_table }

#define R_CR_RES_END_OF_LIST \
    { R_RES_MOD_ID_RES_LIST, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_DEF, \
      R_RES_LIST_FLAG_STATIC, NULL, R_RES_LIST_lib_finish, NULL, NULL }


#ifndef NO_BIO

extern BIO_METHOD * R_CDECL r_cr_digest_get_bio_method();
extern BIO_METHOD * R_CDECL r_cr_encrypt_get_bio_method();
extern BIO_METHOD * R_CDECL r_cr_decrypt_get_bio_method();
extern BIO_METHOD * R_CDECL r_cr_cipher_get_bio_method();

#define R_CR_RES_BIO_DIGEST                                    \
    { R_RES_MOD_ID_BIO, BIO_TYPE_CR, R_CR_TYPE_DIGEST,         \
      R_RES_FLAG_DEF, NULL, NULL,                              \
      (void *(*)(void *))r_cr_digest_get_bio_method, NULL }

#define R_CR_RES_BIO_ENCRYPT                                   \
    { R_RES_MOD_ID_BIO, BIO_TYPE_CIPHER, R_CR_SUB_ENCRYPT,     \
      R_RES_FLAG_DEF, NULL, NULL,                              \
      (void *(*)(void *))r_cr_encrypt_get_bio_method, NULL }

#define R_CR_RES_BIO_DECRYPT                                   \
    { R_RES_MOD_ID_BIO, BIO_TYPE_CIPHER, R_CR_SUB_DECRYPT,     \
      R_RES_FLAG_DEF, NULL, NULL,                              \
      (void *(*)(void *))r_cr_decrypt_get_bio_method, NULL }

#define R_CR_RES_BIO_CIPHER                                    \
    { R_RES_MOD_ID_BIO, BIO_TYPE_CIPHER,                       \
      R_CR_SUB_ENCRYPT | R_CR_SUB_DECRYPT, R_RES_FLAG_DEF,     \
      NULL, NULL,                                              \
      (void *(*)(void *))r_cr_cipher_get_bio_method, NULL }

#endif /* !NO_BIO */

#include "cryp_macros.h"

#if !defined(NO_R_CR_METH_TABLE)
int R_CDECL R_CR_CTX_new(R_LIB_CTX *lib_ctx, R_RES_FLAG flag,
                         R_CR_CTX **crypto_ctx);
#endif /* !defined(NO_R_CR_METH_TABLE) */

#if !defined(NO_R_CR_FUNC) && !defined(NO_R_CR_METH_TABLE)
int R_CDECL R_CR_CTX_free(R_CR_CTX *ctx);

int R_CDECL R_CR_new(R_CR_CTX *ctx, R_CR_ALG_TYPE alg_type,
            R_CR_ALG_ID alg_id, R_CR_ALG_SUB alg_sub, R_CR **crypto);
int R_CDECL R_CR_dup(R_CR *crypto, R_CR **new_crypto);
int R_CDECL R_CR_free(R_CR *crypto);
int R_CDECL R_CR_encrypt_init(R_CR *crypto, R_SKEY *key, R_ITEM *iv);
int R_CDECL R_CR_encrypt(R_CR *crypto, unsigned char *data,
    unsigned int dlen, unsigned char *out, unsigned int *olen);
int R_CDECL R_CR_encrypt_update(R_CR *crypto, unsigned char *data,
    unsigned int dlen, unsigned char *out, unsigned int *olen);
int R_CDECL R_CR_encrypt_final(R_CR *crypto,unsigned char *out, unsigned int *olen);

int R_CDECL R_CR_decrypt_init(R_CR *crypto, R_SKEY *key, R_ITEM *iv);
int R_CDECL R_CR_decrypt(R_CR *crypto, unsigned char *data,
    unsigned int dlen, unsigned char *out, unsigned int *olen);
int R_CDECL R_CR_decrypt_update(R_CR *crypto, unsigned char *data,
    unsigned int dlen, unsigned char *out, unsigned int *olen);
int R_CDECL R_CR_decrypt_final(R_CR *crypto,unsigned char *out, unsigned int *olen);
int R_CDECL R_CR_sign_init(R_CR *crypto, R_PKEY *key);
int R_CDECL R_CR_sign(R_CR *crypto, unsigned char *data, unsigned int dlen,
    unsigned char *out, unsigned int *olen);
int R_CDECL R_CR_sign_update(R_CR *crypto, unsigned char *data, unsigned int dlen);
int R_CDECL R_CR_sign_final(R_CR *crypto,unsigned char *out, unsigned int *olen);

int R_CDECL R_CR_verify_init(R_CR *crypto, R_PKEY *key);
int R_CDECL R_CR_verify(R_CR *crypto, unsigned char *data,
    unsigned int dlen, unsigned char *signature, unsigned int slen,
    int *result);
int R_CDECL R_CR_verify_update(R_CR *crypto, unsigned char *data,
        unsigned int dlen);
int R_CDECL R_CR_verify_final(R_CR *crypto, unsigned char *signature,
        unsigned int sig_len, int *result);
int R_CDECL R_CR_asym_encrypt_init(R_CR *crypto, R_PKEY *key);
int R_CDECL R_CR_asym_encrypt(R_CR *crypto, unsigned char *data,
        unsigned int dlen, unsigned char *out,
                unsigned int *olen);
int R_CDECL R_CR_asym_decrypt_init(R_CR *crypto, R_PKEY *key);
int R_CDECL R_CR_asym_decrypt(R_CR *crypto, unsigned char *data,
    unsigned int dlen, unsigned char *out, unsigned int *olen);
int R_CDECL R_CR_digest_init(R_CR *crypto);
int R_CDECL R_CR_digest(R_CR *crypto, unsigned char *data,
    unsigned int dlen, unsigned char *out,
    unsigned int *out_len);
int R_CDECL R_CR_digest_update(R_CR *crypto, unsigned char *data,
    unsigned int dlen);
int R_CDECL R_CR_digest_final(R_CR *crypto, unsigned char *out,
    unsigned int *olen);

int R_CDECL R_CR_mac_init(R_CR *crypto, R_SKEY *key);
int R_CDECL R_CR_mac(R_CR *crypto, unsigned char *data,
    unsigned int dlen, unsigned char *out,
    unsigned int *olen);
int R_CDECL R_CR_mac_update(R_CR *crypto, unsigned char *data,
    unsigned int dlen);
int R_CDECL R_CR_mac_final(R_CR *crypto, unsigned char *out,
    unsigned int *olen);

int R_CDECL R_CR_verify_mac_init(R_CR *crypto, R_SKEY *key);
int R_CDECL R_CR_verify_mac(R_CR *crypto, unsigned char *data,
    unsigned int dlen, unsigned char *mac, unsigned int mac_len,
    int *result);
int R_CDECL R_CR_verify_mac_update(R_CR *crypto, unsigned char *data,
        unsigned int dlen);
int R_CDECL R_CR_verify_mac_final(R_CR *crypto, unsigned char *mac,
        unsigned int mac_len, int *result);
int R_CDECL R_CR_key_exchange_init(R_CR *crypto, R_PKEY *params);
int R_CDECL R_CR_key_exchange_phase_1(R_CR *crypto, unsigned char *out,
    unsigned int *olen);
int R_CDECL R_CR_key_exchange_phase_2(R_CR *crypto, unsigned char *data,
    unsigned int dlen, unsigned char *out, unsigned int * olen);
int R_CDECL R_CR_generate_key_init(R_CR *crypto);
int R_CDECL R_CR_generate_key(R_CR *crypto, R_PKEY **key);

int R_CDECL R_CR_generate_parameter_init(R_CR *crypto);
int R_CDECL R_CR_generate_parameter(R_CR *crypto, R_PKEY **key);

int R_CDECL R_CR_random_seed(R_CR *crypto, unsigned char *bytes, unsigned int len);
int R_CDECL R_CR_random_bytes(R_CR *crypto, unsigned int  dlen,
    unsigned char *obuf, unsigned int *olen);
#endif /* !defined(NO_R_CR_FUNC) && !defined(NO_R_CR_METH_TABLE) */

int R_CDECL R_CR_get_info(R_CR *crypto, int id, void *param);
int R_CDECL R_CR_set_info(R_CR *crypto, int id, void *param);

int R_CDECL R_CR_CTX_get_info(R_CR_CTX *ctx, int id, void *param);
int R_CDECL R_CR_CTX_set_info(R_CR_CTX *ctx, int id, void *param);

int R_CDECL R_CR_CTX_alg_supported(R_CR_CTX *ctx, int alg_type, int alg_id,
    int alg_sub, int *is_supported);

const R_CR_SIGN_VFY_MAP * R_CDECL R_CR_get_default_signature_map(void *imp_data);

int R_CDECL R_CR_CTX_ids_to_sig_id(R_CR_CTX *ctx, int dig_id, int pkey_id, int *sig_id);
int R_CDECL R_CR_CTX_ids_from_sig_id(R_CR_CTX *ctx, int sig_id, int *dig_id,
    int *pkey_id);
#if !defined(NO_R_CR_FUNC) && !defined(NO_R_CR_METH_TABLE)
int R_CDECL R_CR_get_error(R_CR *crypto, int *data);
int R_CDECL R_CR_get_reason(R_CR *crypto, int *data);
int R_CDECL R_CR_get_detail(R_CR *crypto, int *data);
int R_CDECL R_CR_get_function(R_CR *crypto, int *data);
int R_CDECL R_CR_get_line(R_CR *crypto, int *data);

int R_CDECL R_CR_get_file(R_CR *crypto, char **data);
int R_CDECL R_CR_get_error_string(R_CR *crypto, char **data);
int R_CDECL R_CR_get_reason_string(R_CR *crypto, char **data);
int R_CDECL R_CR_get_detail_string(R_CR *crypto, char **data);
int R_CDECL R_CR_get_function_string(R_CR *crypto, char **data);
#endif /* !defined(NO_R_CR_FUNC) && !defined(NO_R_CR_METH_TABLE) */


#if !defined(NO_R_CR_FUNC) && !defined(NO_R_CR_METH_TABLE)
/* error related strings */
R_STRTBL * R_CDECL R_CR_get_reason_string_table(void *imp_data);
R_STRTBL * R_CDECL R_CR_get_detail_string_table(void *imp_data);
R_STRTBL * R_CDECL R_CR_get_function_string_table(void *imp_data);
#endif /* !defined(NO_R_CR_FUNC) && !defined(NO_R_CR_METH_TABLE) */

#ifndef NO_BIO
BIO * R_CDECL BIO_new_CR_MD(R_LIB_CTX *ctx, int flag, int id);
#endif /* NO_BIO */

int R_CDECL R_CR_ID_from_string(char *str, R_CR_ALG_ID *type);
int R_CDECL R_CR_ID_to_string(R_CR_ALG_ID type, unsigned int max_str_len, char *str);
int R_CDECL R_CR_ID_sign_to_string(R_CR_ALG_ID sign_type, unsigned int max_str_len,
     char *str);
int R_CDECL R_CR_TYPE_from_string(char *str, R_CR_ALG_TYPE *type);
int R_CDECL R_CR_TYPE_to_string(R_CR_ALG_TYPE type, unsigned int max_str_len, char *str);
int R_CDECL R_CR_SUB_from_string(char *str, R_CR_ALG_SUB *type);
int R_CDECL R_CR_SUB_to_string(R_CR_ALG_SUB type, unsigned int max_str_len, char *str);
/* Default method */
R_CR_METHOD * R_CDECL R_CR_get_default_method(void *imp_data);
R_CR_IMP_METHOD * R_CDECL R_CR_get_default_imp_method(void *imp_data);
#define R_CR_RES_CRYPTO_CUSTOM_METHOD(meth_fn, alg_fn) \
    { R_RES_MOD_ID_CRYPTO, R_RES_IMPL_ID_DEF, R_RES_SUB_ID_DEF, \
      R_RES_FLAG_DEF, NULL, NULL, \
      (void *(*)(void *))meth_fn, \
      (void *(*)(void *))alg_fn }

#define R_CR_DEFINE_CUSTOM_CIPHER_LIST(list, fn) \
    static R_CR_IMP_METHOD *fn(void)\
        { return((R_CR_IMP_METHOD *)list); } typedef int _dummy_int ## fn

#define R_CR_DEFINE_CUSTOM_METHOD_TABLE(list, fn) \
    static R_CR_METHOD *fn(void *imp_data)\
    { return((R_CR_METHOD *)&list); }  typedef int _dummy_int ## fn

#ifdef FIPS140_ONLY
#include "r_cr_nist.h"
#endif

#ifdef  __cplusplus
}
#endif
#endif /* HEADER_COMMON_CRYP_MOD_H */

---

Copyright (c) 1999-2005 RSA Security Inc. All rights reserved. 072-001001-2100-001-000 - 2.1