diff options
Diffstat (limited to 'src/lib/libcrypto/engine/vendor_defns')
-rw-r--r-- | src/lib/libcrypto/engine/vendor_defns/aep.h | 178 | ||||
-rw-r--r-- | src/lib/libcrypto/engine/vendor_defns/atalla.h | 48 | ||||
-rw-r--r-- | src/lib/libcrypto/engine/vendor_defns/cswift.h | 234 | ||||
-rw-r--r-- | src/lib/libcrypto/engine/vendor_defns/hw_4758_cca.h | 149 | ||||
-rw-r--r-- | src/lib/libcrypto/engine/vendor_defns/hw_ubsec.h | 100 | ||||
-rw-r--r-- | src/lib/libcrypto/engine/vendor_defns/hwcryptohook.h | 486 | ||||
-rw-r--r-- | src/lib/libcrypto/engine/vendor_defns/sureware.h | 239 |
7 files changed, 0 insertions, 1434 deletions
diff --git a/src/lib/libcrypto/engine/vendor_defns/aep.h b/src/lib/libcrypto/engine/vendor_defns/aep.h deleted file mode 100644 index 2b2792d2d6..0000000000 --- a/src/lib/libcrypto/engine/vendor_defns/aep.h +++ /dev/null | |||
@@ -1,178 +0,0 @@ | |||
1 | /* This header declares the necessary definitions for using the exponentiation | ||
2 | * acceleration capabilities, and rnd number generation of the AEP card. | ||
3 | * | ||
4 | */ | ||
5 | |||
6 | /* | ||
7 | * | ||
8 | * Some AEP defines | ||
9 | * | ||
10 | */ | ||
11 | |||
12 | /*Successful return value*/ | ||
13 | #define AEP_R_OK 0x00000000 | ||
14 | |||
15 | /*Miscelleanous unsuccessful return value*/ | ||
16 | #define AEP_R_GENERAL_ERROR 0x10000001 | ||
17 | |||
18 | /*Insufficient host memory*/ | ||
19 | #define AEP_R_HOST_MEMORY 0x10000002 | ||
20 | |||
21 | #define AEP_R_FUNCTION_FAILED 0x10000006 | ||
22 | |||
23 | /*Invalid arguments in function call*/ | ||
24 | #define AEP_R_ARGUMENTS_BAD 0x10020000 | ||
25 | |||
26 | #define AEP_R_NO_TARGET_RESOURCES 0x10030000 | ||
27 | |||
28 | /*Error occuring on socket operation*/ | ||
29 | #define AEP_R_SOCKERROR 0x10000010 | ||
30 | |||
31 | /*Socket has been closed from the other end*/ | ||
32 | #define AEP_R_SOCKEOF 0x10000011 | ||
33 | |||
34 | /*Invalid handles*/ | ||
35 | #define AEP_R_CONNECTION_HANDLE_INVALID 0x100000B3 | ||
36 | |||
37 | #define AEP_R_TRANSACTION_HANDLE_INVALID 0x10040000 | ||
38 | |||
39 | /*Transaction has not yet returned from accelerator*/ | ||
40 | #define AEP_R_TRANSACTION_NOT_READY 0x00010000 | ||
41 | |||
42 | /*There is already a thread waiting on this transaction*/ | ||
43 | #define AEP_R_TRANSACTION_CLAIMED 0x10050000 | ||
44 | |||
45 | /*The transaction timed out*/ | ||
46 | #define AEP_R_TIMED_OUT 0x10060000 | ||
47 | |||
48 | #define AEP_R_FXN_NOT_IMPLEMENTED 0x10070000 | ||
49 | |||
50 | #define AEP_R_TARGET_ERROR 0x10080000 | ||
51 | |||
52 | /*Error in the AEP daemon process*/ | ||
53 | #define AEP_R_DAEMON_ERROR 0x10090000 | ||
54 | |||
55 | /*Invalid ctx id*/ | ||
56 | #define AEP_R_INVALID_CTX_ID 0x10009000 | ||
57 | |||
58 | #define AEP_R_NO_KEY_MANAGER 0x1000a000 | ||
59 | |||
60 | /*Error obtaining a mutex*/ | ||
61 | #define AEP_R_MUTEX_BAD 0x000001A0 | ||
62 | |||
63 | /*Fxn call before AEP_Initialise ot after AEP_Finialise*/ | ||
64 | #define AEP_R_AEPAPI_NOT_INITIALIZED 0x10000190 | ||
65 | |||
66 | /*AEP_Initialise has already been called*/ | ||
67 | #define AEP_R_AEPAPI_ALREADY_INITIALIZED 0x10000191 | ||
68 | |||
69 | /*Maximum number of connections to daemon reached*/ | ||
70 | #define AEP_R_NO_MORE_CONNECTION_HNDLS 0x10000200 | ||
71 | |||
72 | /* | ||
73 | * | ||
74 | * Some AEP Type definitions | ||
75 | * | ||
76 | */ | ||
77 | |||
78 | /* an unsigned 8-bit value */ | ||
79 | typedef unsigned char AEP_U8; | ||
80 | |||
81 | /* an unsigned 8-bit character */ | ||
82 | typedef char AEP_CHAR; | ||
83 | |||
84 | /* a BYTE-sized Boolean flag */ | ||
85 | typedef AEP_U8 AEP_BBOOL; | ||
86 | |||
87 | /*Unsigned value, at least 16 bits long*/ | ||
88 | typedef unsigned short AEP_U16; | ||
89 | |||
90 | /* an unsigned value, at least 32 bits long */ | ||
91 | #ifdef SIXTY_FOUR_BIT_LONG | ||
92 | typedef unsigned int AEP_U32; | ||
93 | #else | ||
94 | typedef unsigned long AEP_U32; | ||
95 | #endif | ||
96 | |||
97 | #ifdef SIXTY_FOUR_BIT_LONG | ||
98 | typedef unsigned long AEP_U64; | ||
99 | #else | ||
100 | typedef struct { unsigned long l1, l2; } AEP_U64; | ||
101 | #endif | ||
102 | |||
103 | /* at least 32 bits; each bit is a Boolean flag */ | ||
104 | typedef AEP_U32 AEP_FLAGS; | ||
105 | |||
106 | typedef AEP_U8 *AEP_U8_PTR; | ||
107 | typedef AEP_CHAR *AEP_CHAR_PTR; | ||
108 | typedef AEP_U32 *AEP_U32_PTR; | ||
109 | typedef AEP_U64 *AEP_U64_PTR; | ||
110 | typedef void *AEP_VOID_PTR; | ||
111 | |||
112 | /* Pointer to a AEP_VOID_PTR-- i.e., pointer to pointer to void */ | ||
113 | typedef AEP_VOID_PTR *AEP_VOID_PTR_PTR; | ||
114 | |||
115 | /*Used to identify an AEP connection handle*/ | ||
116 | typedef AEP_U32 AEP_CONNECTION_HNDL; | ||
117 | |||
118 | /*Pointer to an AEP connection handle*/ | ||
119 | typedef AEP_CONNECTION_HNDL *AEP_CONNECTION_HNDL_PTR; | ||
120 | |||
121 | /*Used by an application (in conjunction with the apps process id) to | ||
122 | identify an individual transaction*/ | ||
123 | typedef AEP_U32 AEP_TRANSACTION_ID; | ||
124 | |||
125 | /*Pointer to an applications transaction identifier*/ | ||
126 | typedef AEP_TRANSACTION_ID *AEP_TRANSACTION_ID_PTR; | ||
127 | |||
128 | /*Return value type*/ | ||
129 | typedef AEP_U32 AEP_RV; | ||
130 | |||
131 | #define MAX_PROCESS_CONNECTIONS 256 | ||
132 | |||
133 | #define RAND_BLK_SIZE 1024 | ||
134 | |||
135 | typedef enum{ | ||
136 | NotConnected= 0, | ||
137 | Connected= 1, | ||
138 | InUse= 2 | ||
139 | } AEP_CONNECTION_STATE; | ||
140 | |||
141 | |||
142 | typedef struct AEP_CONNECTION_ENTRY{ | ||
143 | AEP_CONNECTION_STATE conn_state; | ||
144 | AEP_CONNECTION_HNDL conn_hndl; | ||
145 | } AEP_CONNECTION_ENTRY; | ||
146 | |||
147 | |||
148 | typedef AEP_RV t_AEP_OpenConnection(AEP_CONNECTION_HNDL_PTR phConnection); | ||
149 | typedef AEP_RV t_AEP_CloseConnection(AEP_CONNECTION_HNDL hConnection); | ||
150 | |||
151 | typedef AEP_RV t_AEP_ModExp(AEP_CONNECTION_HNDL hConnection, | ||
152 | AEP_VOID_PTR pA, AEP_VOID_PTR pP, | ||
153 | AEP_VOID_PTR pN, | ||
154 | AEP_VOID_PTR pResult, | ||
155 | AEP_TRANSACTION_ID* pidTransID); | ||
156 | |||
157 | typedef AEP_RV t_AEP_ModExpCrt(AEP_CONNECTION_HNDL hConnection, | ||
158 | AEP_VOID_PTR pA, AEP_VOID_PTR pP, | ||
159 | AEP_VOID_PTR pQ, | ||
160 | AEP_VOID_PTR pDmp1, AEP_VOID_PTR pDmq1, | ||
161 | AEP_VOID_PTR pIqmp, | ||
162 | AEP_VOID_PTR pResult, | ||
163 | AEP_TRANSACTION_ID* pidTransID); | ||
164 | |||
165 | #ifdef AEPRAND | ||
166 | typedef AEP_RV t_AEP_GenRandom(AEP_CONNECTION_HNDL hConnection, | ||
167 | AEP_U32 Len, | ||
168 | AEP_U32 Type, | ||
169 | AEP_VOID_PTR pResult, | ||
170 | AEP_TRANSACTION_ID* pidTransID); | ||
171 | #endif | ||
172 | |||
173 | typedef AEP_RV t_AEP_Initialize(AEP_VOID_PTR pInitArgs); | ||
174 | typedef AEP_RV t_AEP_Finalize(); | ||
175 | typedef AEP_RV t_AEP_SetBNCallBacks(AEP_RV (*GetBigNumSizeFunc)(), | ||
176 | AEP_RV (*MakeAEPBigNumFunc)(), | ||
177 | AEP_RV (*ConverAEPBigNumFunc)()); | ||
178 | |||
diff --git a/src/lib/libcrypto/engine/vendor_defns/atalla.h b/src/lib/libcrypto/engine/vendor_defns/atalla.h deleted file mode 100644 index 149970d441..0000000000 --- a/src/lib/libcrypto/engine/vendor_defns/atalla.h +++ /dev/null | |||
@@ -1,48 +0,0 @@ | |||
1 | /* This header declares the necessary definitions for using the exponentiation | ||
2 | * acceleration capabilities of Atalla cards. The only cryptographic operation | ||
3 | * is performed by "ASI_RSAPrivateKeyOpFn" and this takes a structure that | ||
4 | * defines an "RSA private key". However, it is really only performing a | ||
5 | * regular mod_exp using the supplied modulus and exponent - no CRT form is | ||
6 | * being used. Hence, it is a generic mod_exp function in disguise, and we use | ||
7 | * it as such. | ||
8 | * | ||
9 | * Thanks to the people at Atalla for letting me know these definitions are | ||
10 | * fine and that they can be reproduced here. | ||
11 | * | ||
12 | * Geoff. | ||
13 | */ | ||
14 | |||
15 | typedef struct ItemStr | ||
16 | { | ||
17 | unsigned char *data; | ||
18 | int len; | ||
19 | } Item; | ||
20 | |||
21 | typedef struct RSAPrivateKeyStr | ||
22 | { | ||
23 | void *reserved; | ||
24 | Item version; | ||
25 | Item modulus; | ||
26 | Item publicExponent; | ||
27 | Item privateExponent; | ||
28 | Item prime[2]; | ||
29 | Item exponent[2]; | ||
30 | Item coefficient; | ||
31 | } RSAPrivateKey; | ||
32 | |||
33 | /* Predeclare the function pointer types that we dynamically load from the DSO. | ||
34 | * These use the same names and form that Ben's original support code had (in | ||
35 | * crypto/bn/bn_exp.c) unless of course I've inadvertently changed the style | ||
36 | * somewhere along the way! | ||
37 | */ | ||
38 | |||
39 | typedef int tfnASI_GetPerformanceStatistics(int reset_flag, | ||
40 | unsigned int *ret_buf); | ||
41 | |||
42 | typedef int tfnASI_GetHardwareConfig(long card_num, unsigned int *ret_buf); | ||
43 | |||
44 | typedef int tfnASI_RSAPrivateKeyOpFn(RSAPrivateKey * rsaKey, | ||
45 | unsigned char *output, | ||
46 | unsigned char *input, | ||
47 | unsigned int modulus_len); | ||
48 | |||
diff --git a/src/lib/libcrypto/engine/vendor_defns/cswift.h b/src/lib/libcrypto/engine/vendor_defns/cswift.h deleted file mode 100644 index 60079326bb..0000000000 --- a/src/lib/libcrypto/engine/vendor_defns/cswift.h +++ /dev/null | |||
@@ -1,234 +0,0 @@ | |||
1 | /* Attribution notice: Rainbow have generously allowed me to reproduce | ||
2 | * the necessary definitions here from their API. This means the support | ||
3 | * can build independently of whether application builders have the | ||
4 | * API or hardware. This will allow developers to easily produce software | ||
5 | * that has latent hardware support for any users that have accelertors | ||
6 | * installed, without the developers themselves needing anything extra. | ||
7 | * | ||
8 | * I have only clipped the parts from the CryptoSwift header files that | ||
9 | * are (or seem) relevant to the CryptoSwift support code. This is | ||
10 | * simply to keep the file sizes reasonable. | ||
11 | * [Geoff] | ||
12 | */ | ||
13 | |||
14 | |||
15 | /* NB: These type widths do *not* seem right in general, in particular | ||
16 | * they're not terribly friendly to 64-bit architectures (unsigned long) | ||
17 | * will be 64-bit on IA-64 for a start. I'm leaving these alone as they | ||
18 | * agree with Rainbow's API and this will only be called into question | ||
19 | * on platforms with Rainbow support anyway! ;-) */ | ||
20 | |||
21 | #ifdef __cplusplus | ||
22 | extern "C" { | ||
23 | #endif /* __cplusplus */ | ||
24 | |||
25 | typedef long SW_STATUS; /* status */ | ||
26 | typedef unsigned char SW_BYTE; /* 8 bit byte */ | ||
27 | typedef unsigned short SW_U16; /* 16 bit number */ | ||
28 | #if defined(_IRIX) | ||
29 | #include <sgidefs.h> | ||
30 | typedef __uint32_t SW_U32; | ||
31 | #else | ||
32 | typedef unsigned long SW_U32; /* 32 bit integer */ | ||
33 | #endif | ||
34 | |||
35 | #if defined(OPENSSL_SYS_WIN32) | ||
36 | typedef struct _SW_U64 { | ||
37 | SW_U32 low32; | ||
38 | SW_U32 high32; | ||
39 | } SW_U64; /* 64 bit integer */ | ||
40 | #elif defined(OPENSSL_SYS_MACINTOSH_CLASSIC) | ||
41 | typedef longlong SW_U64 | ||
42 | #else /* Unix variants */ | ||
43 | typedef struct _SW_U64 { | ||
44 | SW_U32 low32; | ||
45 | SW_U32 high32; | ||
46 | } SW_U64; /* 64 bit integer */ | ||
47 | #endif | ||
48 | |||
49 | /* status codes */ | ||
50 | #define SW_OK (0L) | ||
51 | #define SW_ERR_BASE (-10000L) | ||
52 | #define SW_ERR_NO_CARD (SW_ERR_BASE-1) /* The Card is not present */ | ||
53 | #define SW_ERR_CARD_NOT_READY (SW_ERR_BASE-2) /* The card has not powered */ | ||
54 | /* up yet */ | ||
55 | #define SW_ERR_TIME_OUT (SW_ERR_BASE-3) /* Execution of a command */ | ||
56 | /* time out */ | ||
57 | #define SW_ERR_NO_EXECUTE (SW_ERR_BASE-4) /* The Card failed to */ | ||
58 | /* execute the command */ | ||
59 | #define SW_ERR_INPUT_NULL_PTR (SW_ERR_BASE-5) /* a required pointer is */ | ||
60 | /* NULL */ | ||
61 | #define SW_ERR_INPUT_SIZE (SW_ERR_BASE-6) /* size is invalid, too */ | ||
62 | /* small, too large. */ | ||
63 | #define SW_ERR_INVALID_HANDLE (SW_ERR_BASE-7) /* Invalid SW_ACC_CONTEXT */ | ||
64 | /* handle */ | ||
65 | #define SW_ERR_PENDING (SW_ERR_BASE-8) /* A request is already out- */ | ||
66 | /* standing at this */ | ||
67 | /* context handle */ | ||
68 | #define SW_ERR_AVAILABLE (SW_ERR_BASE-9) /* A result is available. */ | ||
69 | #define SW_ERR_NO_PENDING (SW_ERR_BASE-10)/* No request is pending. */ | ||
70 | #define SW_ERR_NO_MEMORY (SW_ERR_BASE-11)/* Not enough memory */ | ||
71 | #define SW_ERR_BAD_ALGORITHM (SW_ERR_BASE-12)/* Invalid algorithm type */ | ||
72 | /* in SW_PARAM structure */ | ||
73 | #define SW_ERR_MISSING_KEY (SW_ERR_BASE-13)/* No key is associated with */ | ||
74 | /* context. */ | ||
75 | /* swAttachKeyParam() is */ | ||
76 | /* not called. */ | ||
77 | #define SW_ERR_KEY_CMD_MISMATCH \ | ||
78 | (SW_ERR_BASE-14)/* Cannot perform requested */ | ||
79 | /* SW_COMMAND_CODE since */ | ||
80 | /* key attached via */ | ||
81 | /* swAttachKeyParam() */ | ||
82 | /* cannot be used for this*/ | ||
83 | /* SW_COMMAND_CODE. */ | ||
84 | #define SW_ERR_NOT_IMPLEMENTED \ | ||
85 | (SW_ERR_BASE-15)/* Not implemented */ | ||
86 | #define SW_ERR_BAD_COMMAND (SW_ERR_BASE-16)/* Bad command code */ | ||
87 | #define SW_ERR_BAD_ITEM_SIZE (SW_ERR_BASE-17)/* too small or too large in */ | ||
88 | /* the "initems" or */ | ||
89 | /* "outitems". */ | ||
90 | #define SW_ERR_BAD_ACCNUM (SW_ERR_BASE-18)/* Bad accelerator number */ | ||
91 | #define SW_ERR_SELFTEST_FAIL (SW_ERR_BASE-19)/* At least one of the self */ | ||
92 | /* test fail, look at the */ | ||
93 | /* selfTestBitmap in */ | ||
94 | /* SW_ACCELERATOR_INFO for*/ | ||
95 | /* details. */ | ||
96 | #define SW_ERR_MISALIGN (SW_ERR_BASE-20)/* Certain alogrithms require*/ | ||
97 | /* key materials aligned */ | ||
98 | /* in certain order, e.g. */ | ||
99 | /* 128 bit for CRT */ | ||
100 | #define SW_ERR_OUTPUT_NULL_PTR \ | ||
101 | (SW_ERR_BASE-21)/* a required pointer is */ | ||
102 | /* NULL */ | ||
103 | #define SW_ERR_OUTPUT_SIZE \ | ||
104 | (SW_ERR_BASE-22)/* size is invalid, too */ | ||
105 | /* small, too large. */ | ||
106 | #define SW_ERR_FIRMWARE_CHECKSUM \ | ||
107 | (SW_ERR_BASE-23)/* firmware checksum mismatch*/ | ||
108 | /* download failed. */ | ||
109 | #define SW_ERR_UNKNOWN_FIRMWARE \ | ||
110 | (SW_ERR_BASE-24)/* unknown firmware error */ | ||
111 | #define SW_ERR_INTERRUPT (SW_ERR_BASE-25)/* request is abort when */ | ||
112 | /* it's waiting to be */ | ||
113 | /* completed. */ | ||
114 | #define SW_ERR_NVWRITE_FAIL (SW_ERR_BASE-26)/* error in writing to Non- */ | ||
115 | /* volatile memory */ | ||
116 | #define SW_ERR_NVWRITE_RANGE (SW_ERR_BASE-27)/* out of range error in */ | ||
117 | /* writing to NV memory */ | ||
118 | #define SW_ERR_RNG_ERROR (SW_ERR_BASE-28)/* Random Number Generation */ | ||
119 | /* failure */ | ||
120 | #define SW_ERR_DSS_FAILURE (SW_ERR_BASE-29)/* DSS Sign or Verify failure*/ | ||
121 | #define SW_ERR_MODEXP_FAILURE (SW_ERR_BASE-30)/* Failure in various math */ | ||
122 | /* calculations */ | ||
123 | #define SW_ERR_ONBOARD_MEMORY (SW_ERR_BASE-31)/* Error in accessing on - */ | ||
124 | /* board memory */ | ||
125 | #define SW_ERR_FIRMWARE_VERSION \ | ||
126 | (SW_ERR_BASE-32)/* Wrong version in firmware */ | ||
127 | /* update */ | ||
128 | #define SW_ERR_ZERO_WORKING_ACCELERATOR \ | ||
129 | (SW_ERR_BASE-44)/* All accelerators are bad */ | ||
130 | |||
131 | |||
132 | /* algorithm type */ | ||
133 | #define SW_ALG_CRT 1 | ||
134 | #define SW_ALG_EXP 2 | ||
135 | #define SW_ALG_DSA 3 | ||
136 | #define SW_ALG_NVDATA 4 | ||
137 | |||
138 | /* command code */ | ||
139 | #define SW_CMD_MODEXP_CRT 1 /* perform Modular Exponentiation using */ | ||
140 | /* Chinese Remainder Theorem (CRT) */ | ||
141 | #define SW_CMD_MODEXP 2 /* perform Modular Exponentiation */ | ||
142 | #define SW_CMD_DSS_SIGN 3 /* perform DSS sign */ | ||
143 | #define SW_CMD_DSS_VERIFY 4 /* perform DSS verify */ | ||
144 | #define SW_CMD_RAND 5 /* perform random number generation */ | ||
145 | #define SW_CMD_NVREAD 6 /* perform read to nonvolatile RAM */ | ||
146 | #define SW_CMD_NVWRITE 7 /* perform write to nonvolatile RAM */ | ||
147 | |||
148 | typedef SW_U32 SW_ALGTYPE; /* alogrithm type */ | ||
149 | typedef SW_U32 SW_STATE; /* state */ | ||
150 | typedef SW_U32 SW_COMMAND_CODE; /* command code */ | ||
151 | typedef SW_U32 SW_COMMAND_BITMAP[4]; /* bitmap */ | ||
152 | |||
153 | typedef struct _SW_LARGENUMBER { | ||
154 | SW_U32 nbytes; /* number of bytes in the buffer "value" */ | ||
155 | SW_BYTE* value; /* the large integer as a string of */ | ||
156 | /* bytes in network (big endian) order */ | ||
157 | } SW_LARGENUMBER; | ||
158 | |||
159 | #if defined(OPENSSL_SYS_WIN32) | ||
160 | #include <windows.h> | ||
161 | typedef HANDLE SW_OSHANDLE; /* handle to kernel object */ | ||
162 | #define SW_OS_INVALID_HANDLE INVALID_HANDLE_VALUE | ||
163 | #define SW_CALLCONV _stdcall | ||
164 | #elif defined(OPENSSL_SYS_MACINTOSH_CLASSIC) | ||
165 | /* async callback mechanisms */ | ||
166 | /* swiftCallbackLevel */ | ||
167 | #define SW_MAC_CALLBACK_LEVEL_NO 0 | ||
168 | #define SW_MAC_CALLBACK_LEVEL_HARDWARE 1 /* from the hardware ISR */ | ||
169 | #define SW_MAC_CALLBACK_LEVEL_SECONDARY 2 /* as secondary ISR */ | ||
170 | typedef int SW_MAC_CALLBACK_LEVEL; | ||
171 | typedef int SW_OSHANDLE; | ||
172 | #define SW_OS_INVALID_HANDLE (-1) | ||
173 | #define SW_CALLCONV | ||
174 | #else /* Unix variants */ | ||
175 | typedef int SW_OSHANDLE; /* handle to driver */ | ||
176 | #define SW_OS_INVALID_HANDLE (-1) | ||
177 | #define SW_CALLCONV | ||
178 | #endif | ||
179 | |||
180 | typedef struct _SW_CRT { | ||
181 | SW_LARGENUMBER p; /* prime number p */ | ||
182 | SW_LARGENUMBER q; /* prime number q */ | ||
183 | SW_LARGENUMBER dmp1; /* exponent1 */ | ||
184 | SW_LARGENUMBER dmq1; /* exponent2 */ | ||
185 | SW_LARGENUMBER iqmp; /* CRT coefficient */ | ||
186 | } SW_CRT; | ||
187 | |||
188 | typedef struct _SW_EXP { | ||
189 | SW_LARGENUMBER modulus; /* modulus */ | ||
190 | SW_LARGENUMBER exponent;/* exponent */ | ||
191 | } SW_EXP; | ||
192 | |||
193 | typedef struct _SW_DSA { | ||
194 | SW_LARGENUMBER p; /* */ | ||
195 | SW_LARGENUMBER q; /* */ | ||
196 | SW_LARGENUMBER g; /* */ | ||
197 | SW_LARGENUMBER key; /* private/public key */ | ||
198 | } SW_DSA; | ||
199 | |||
200 | typedef struct _SW_NVDATA { | ||
201 | SW_U32 accnum; /* accelerator board number */ | ||
202 | SW_U32 offset; /* offset in byte */ | ||
203 | } SW_NVDATA; | ||
204 | |||
205 | typedef struct _SW_PARAM { | ||
206 | SW_ALGTYPE type; /* type of the alogrithm */ | ||
207 | union { | ||
208 | SW_CRT crt; | ||
209 | SW_EXP exp; | ||
210 | SW_DSA dsa; | ||
211 | SW_NVDATA nvdata; | ||
212 | } up; | ||
213 | } SW_PARAM; | ||
214 | |||
215 | typedef SW_U32 SW_CONTEXT_HANDLE; /* opaque context handle */ | ||
216 | |||
217 | |||
218 | /* Now the OpenSSL bits, these function types are the for the function | ||
219 | * pointers that will bound into the Rainbow shared libraries. */ | ||
220 | typedef SW_STATUS SW_CALLCONV t_swAcquireAccContext(SW_CONTEXT_HANDLE *hac); | ||
221 | typedef SW_STATUS SW_CALLCONV t_swAttachKeyParam(SW_CONTEXT_HANDLE hac, | ||
222 | SW_PARAM *key_params); | ||
223 | typedef SW_STATUS SW_CALLCONV t_swSimpleRequest(SW_CONTEXT_HANDLE hac, | ||
224 | SW_COMMAND_CODE cmd, | ||
225 | SW_LARGENUMBER pin[], | ||
226 | SW_U32 pin_count, | ||
227 | SW_LARGENUMBER pout[], | ||
228 | SW_U32 pout_count); | ||
229 | typedef SW_STATUS SW_CALLCONV t_swReleaseAccContext(SW_CONTEXT_HANDLE hac); | ||
230 | |||
231 | #ifdef __cplusplus | ||
232 | } | ||
233 | #endif /* __cplusplus */ | ||
234 | |||
diff --git a/src/lib/libcrypto/engine/vendor_defns/hw_4758_cca.h b/src/lib/libcrypto/engine/vendor_defns/hw_4758_cca.h deleted file mode 100644 index 296636e81a..0000000000 --- a/src/lib/libcrypto/engine/vendor_defns/hw_4758_cca.h +++ /dev/null | |||
@@ -1,149 +0,0 @@ | |||
1 | /**********************************************************************/ | ||
2 | /* */ | ||
3 | /* Prototypes of the CCA verbs used by the 4758 CCA openssl driver */ | ||
4 | /* */ | ||
5 | /* Maurice Gittens <maurice@gittens.nl> */ | ||
6 | /* */ | ||
7 | /**********************************************************************/ | ||
8 | |||
9 | #ifndef __HW_4758_CCA__ | ||
10 | #define __HW_4758_CCA__ | ||
11 | |||
12 | /* | ||
13 | * Only WIN32 support for now | ||
14 | */ | ||
15 | #if defined(WIN32) | ||
16 | |||
17 | #define CCA_LIB_NAME "CSUNSAPI" | ||
18 | |||
19 | #define CSNDPKX "CSNDPKX_32" | ||
20 | #define CSNDKRR "CSNDKRR_32" | ||
21 | #define CSNDPKE "CSNDPKE_32" | ||
22 | #define CSNDPKD "CSNDPKD_32" | ||
23 | #define CSNDDSV "CSNDDSV_32" | ||
24 | #define CSNDDSG "CSNDDSG_32" | ||
25 | #define CSNBRNG "CSNBRNG_32" | ||
26 | |||
27 | #define SECURITYAPI __stdcall | ||
28 | #else | ||
29 | /* Fixme!! | ||
30 | Find out the values of these constants for other platforms. | ||
31 | */ | ||
32 | #define CCA_LIB_NAME "CSUNSAPI" | ||
33 | |||
34 | #define CSNDPKX "CSNDPKX" | ||
35 | #define CSNDKRR "CSNDKRR" | ||
36 | #define CSNDPKE "CSNDPKE" | ||
37 | #define CSNDPKD "CSNDPKD" | ||
38 | #define CSNDDSV "CSNDDSV" | ||
39 | #define CSNDDSG "CSNDDSG" | ||
40 | #define CSNBRNG "CSNBRNG" | ||
41 | |||
42 | #define SECURITYAPI | ||
43 | #endif | ||
44 | |||
45 | /* | ||
46 | * security API prototypes | ||
47 | */ | ||
48 | |||
49 | /* PKA Key Record Read */ | ||
50 | typedef void (SECURITYAPI *F_KEYRECORDREAD) | ||
51 | (long * return_code, | ||
52 | long * reason_code, | ||
53 | long * exit_data_length, | ||
54 | unsigned char * exit_data, | ||
55 | long * rule_array_count, | ||
56 | unsigned char * rule_array, | ||
57 | unsigned char * key_label, | ||
58 | long * key_token_length, | ||
59 | unsigned char * key_token); | ||
60 | |||
61 | /* Random Number Generate */ | ||
62 | typedef void (SECURITYAPI *F_RANDOMNUMBERGENERATE) | ||
63 | (long * return_code, | ||
64 | long * reason_code, | ||
65 | long * exit_data_length, | ||
66 | unsigned char * exit_data, | ||
67 | unsigned char * form, | ||
68 | unsigned char * random_number); | ||
69 | |||
70 | /* Digital Signature Generate */ | ||
71 | typedef void (SECURITYAPI *F_DIGITALSIGNATUREGENERATE) | ||
72 | (long * return_code, | ||
73 | long * reason_code, | ||
74 | long * exit_data_length, | ||
75 | unsigned char * exit_data, | ||
76 | long * rule_array_count, | ||
77 | unsigned char * rule_array, | ||
78 | long * PKA_private_key_id_length, | ||
79 | unsigned char * PKA_private_key_id, | ||
80 | long * hash_length, | ||
81 | unsigned char * hash, | ||
82 | long * signature_field_length, | ||
83 | long * signature_bit_length, | ||
84 | unsigned char * signature_field); | ||
85 | |||
86 | /* Digital Signature Verify */ | ||
87 | typedef void (SECURITYAPI *F_DIGITALSIGNATUREVERIFY)( | ||
88 | long * return_code, | ||
89 | long * reason_code, | ||
90 | long * exit_data_length, | ||
91 | unsigned char * exit_data, | ||
92 | long * rule_array_count, | ||
93 | unsigned char * rule_array, | ||
94 | long * PKA_public_key_id_length, | ||
95 | unsigned char * PKA_public_key_id, | ||
96 | long * hash_length, | ||
97 | unsigned char * hash, | ||
98 | long * signature_field_length, | ||
99 | unsigned char * signature_field); | ||
100 | |||
101 | /* PKA Public Key Extract */ | ||
102 | typedef void (SECURITYAPI *F_PUBLICKEYEXTRACT)( | ||
103 | long * return_code, | ||
104 | long * reason_code, | ||
105 | long * exit_data_length, | ||
106 | unsigned char * exit_data, | ||
107 | long * rule_array_count, | ||
108 | unsigned char * rule_array, | ||
109 | long * source_key_identifier_length, | ||
110 | unsigned char * source_key_identifier, | ||
111 | long * target_key_token_length, | ||
112 | unsigned char * target_key_token); | ||
113 | |||
114 | /* PKA Encrypt */ | ||
115 | typedef void (SECURITYAPI *F_PKAENCRYPT) | ||
116 | (long * return_code, | ||
117 | long * reason_code, | ||
118 | long * exit_data_length, | ||
119 | unsigned char * exit_data, | ||
120 | long * rule_array_count, | ||
121 | unsigned char * rule_array, | ||
122 | long * key_value_length, | ||
123 | unsigned char * key_value, | ||
124 | long * data_struct_length, | ||
125 | unsigned char * data_struct, | ||
126 | long * RSA_public_key_length, | ||
127 | unsigned char * RSA_public_key, | ||
128 | long * RSA_encipher_length, | ||
129 | unsigned char * RSA_encipher ); | ||
130 | |||
131 | /* PKA Decrypt */ | ||
132 | typedef void (SECURITYAPI *F_PKADECRYPT) | ||
133 | (long * return_code, | ||
134 | long * reason_code, | ||
135 | long * exit_data_length, | ||
136 | unsigned char * exit_data, | ||
137 | long * rule_array_count, | ||
138 | unsigned char * rule_array, | ||
139 | long * enciphered_key_length, | ||
140 | unsigned char * enciphered_key, | ||
141 | long * data_struct_length, | ||
142 | unsigned char * data_struct, | ||
143 | long * RSA_private_key_length, | ||
144 | unsigned char * RSA_private_key, | ||
145 | long * key_value_length, | ||
146 | unsigned char * key_value ); | ||
147 | |||
148 | |||
149 | #endif | ||
diff --git a/src/lib/libcrypto/engine/vendor_defns/hw_ubsec.h b/src/lib/libcrypto/engine/vendor_defns/hw_ubsec.h deleted file mode 100644 index b6619d40f2..0000000000 --- a/src/lib/libcrypto/engine/vendor_defns/hw_ubsec.h +++ /dev/null | |||
@@ -1,100 +0,0 @@ | |||
1 | /****************************************************************************** | ||
2 | * | ||
3 | * Copyright 2000 | ||
4 | * Broadcom Corporation | ||
5 | * 16215 Alton Parkway | ||
6 | * PO Box 57013 | ||
7 | * Irvine CA 92619-7013 | ||
8 | * | ||
9 | *****************************************************************************/ | ||
10 | /* | ||
11 | * Broadcom Corporation uBSec SDK | ||
12 | */ | ||
13 | /* | ||
14 | * Character device header file. | ||
15 | */ | ||
16 | /* | ||
17 | * Revision History: | ||
18 | * | ||
19 | * October 2000 JTT Created. | ||
20 | */ | ||
21 | |||
22 | #define MAX_PUBLIC_KEY_BITS (1024) | ||
23 | #define MAX_PUBLIC_KEY_BYTES (1024/8) | ||
24 | #define SHA_BIT_SIZE (160) | ||
25 | #define MAX_CRYPTO_KEY_LENGTH 24 | ||
26 | #define MAX_MAC_KEY_LENGTH 64 | ||
27 | #define UBSEC_CRYPTO_DEVICE_NAME ((unsigned char *)"/dev/ubscrypt") | ||
28 | #define UBSEC_KEY_DEVICE_NAME ((unsigned char *)"/dev/ubskey") | ||
29 | |||
30 | /* Math command types. */ | ||
31 | #define UBSEC_MATH_MODADD 0x0001 | ||
32 | #define UBSEC_MATH_MODSUB 0x0002 | ||
33 | #define UBSEC_MATH_MODMUL 0x0004 | ||
34 | #define UBSEC_MATH_MODEXP 0x0008 | ||
35 | #define UBSEC_MATH_MODREM 0x0010 | ||
36 | #define UBSEC_MATH_MODINV 0x0020 | ||
37 | |||
38 | typedef long ubsec_MathCommand_t; | ||
39 | typedef long ubsec_RNGCommand_t; | ||
40 | |||
41 | typedef struct ubsec_crypto_context_s { | ||
42 | unsigned int flags; | ||
43 | unsigned char crypto[MAX_CRYPTO_KEY_LENGTH]; | ||
44 | unsigned char auth[MAX_MAC_KEY_LENGTH]; | ||
45 | } ubsec_crypto_context_t, *ubsec_crypto_context_p; | ||
46 | |||
47 | /* | ||
48 | * Predeclare the function pointer types that we dynamically load from the DSO. | ||
49 | */ | ||
50 | |||
51 | typedef int t_UBSEC_ubsec_bytes_to_bits(unsigned char *n, int bytes); | ||
52 | |||
53 | typedef int t_UBSEC_ubsec_bits_to_bytes(int bits); | ||
54 | |||
55 | typedef int t_UBSEC_ubsec_open(unsigned char *device); | ||
56 | |||
57 | typedef int t_UBSEC_ubsec_close(int fd); | ||
58 | |||
59 | typedef int t_UBSEC_diffie_hellman_generate_ioctl (int fd, | ||
60 | unsigned char *x, int *x_len, unsigned char *y, int *y_len, | ||
61 | unsigned char *g, int g_len, unsigned char *m, int m_len, | ||
62 | unsigned char *userX, int userX_len, int random_bits); | ||
63 | |||
64 | typedef int t_UBSEC_diffie_hellman_agree_ioctl (int fd, | ||
65 | unsigned char *x, int x_len, unsigned char *y, int y_len, | ||
66 | unsigned char *m, int m_len, unsigned char *k, int *k_len); | ||
67 | |||
68 | typedef int t_UBSEC_rsa_mod_exp_ioctl (int fd, | ||
69 | unsigned char *x, int x_len, unsigned char *m, int m_len, | ||
70 | unsigned char *e, int e_len, unsigned char *y, int *y_len); | ||
71 | |||
72 | typedef int t_UBSEC_rsa_mod_exp_crt_ioctl (int fd, | ||
73 | unsigned char *x, int x_len, unsigned char *qinv, int qinv_len, | ||
74 | unsigned char *edq, int edq_len, unsigned char *q, int q_len, | ||
75 | unsigned char *edp, int edp_len, unsigned char *p, int p_len, | ||
76 | unsigned char *y, int *y_len); | ||
77 | |||
78 | typedef int t_UBSEC_dsa_sign_ioctl (int fd, | ||
79 | int hash, unsigned char *data, int data_len, | ||
80 | unsigned char *rndom, int random_len, | ||
81 | unsigned char *p, int p_len, unsigned char *q, int q_len, | ||
82 | unsigned char *g, int g_len, unsigned char *key, int key_len, | ||
83 | unsigned char *r, int *r_len, unsigned char *s, int *s_len); | ||
84 | |||
85 | typedef int t_UBSEC_dsa_verify_ioctl (int fd, | ||
86 | int hash, unsigned char *data, int data_len, | ||
87 | unsigned char *p, int p_len, unsigned char *q, int q_len, | ||
88 | unsigned char *g, int g_len, unsigned char *key, int key_len, | ||
89 | unsigned char *r, int r_len, unsigned char *s, int s_len, | ||
90 | unsigned char *v, int *v_len); | ||
91 | |||
92 | typedef int t_UBSEC_math_accelerate_ioctl(int fd, ubsec_MathCommand_t command, | ||
93 | unsigned char *ModN, int *ModN_len, unsigned char *ExpE, int *ExpE_len, | ||
94 | unsigned char *ParamA, int *ParamA_len, unsigned char *ParamB, int *ParamB_len, | ||
95 | unsigned char *Result, int *Result_len); | ||
96 | |||
97 | typedef int t_UBSEC_rng_ioctl(int fd, ubsec_RNGCommand_t command, | ||
98 | unsigned char *Result, int *Result_len); | ||
99 | |||
100 | typedef int t_UBSEC_max_key_len_ioctl(int fd, int *max_key_len); | ||
diff --git a/src/lib/libcrypto/engine/vendor_defns/hwcryptohook.h b/src/lib/libcrypto/engine/vendor_defns/hwcryptohook.h deleted file mode 100644 index aaa4d4575e..0000000000 --- a/src/lib/libcrypto/engine/vendor_defns/hwcryptohook.h +++ /dev/null | |||
@@ -1,486 +0,0 @@ | |||
1 | /* | ||
2 | * ModExp / RSA (with/without KM) plugin API | ||
3 | * | ||
4 | * The application will load a dynamic library which | ||
5 | * exports entrypoint(s) defined in this file. | ||
6 | * | ||
7 | * This set of entrypoints provides only a multithreaded, | ||
8 | * synchronous-within-each-thread, facility. | ||
9 | * | ||
10 | * | ||
11 | * This file is Copyright 1998-2000 nCipher Corporation Limited. | ||
12 | * | ||
13 | * Redistribution and use in source and binary forms, with opr without | ||
14 | * modification, are permitted provided that the following conditions | ||
15 | * are met: | ||
16 | * | ||
17 | * 1. Redistributions of source code must retain the copyright notice, | ||
18 | * this list of conditions, and the following disclaimer. | ||
19 | * | ||
20 | * 2. Redistributions in binary form must reproduce the above | ||
21 | * copyright notice, this list of conditions, and the following | ||
22 | * disclaimer, in the documentation and/or other materials provided | ||
23 | * with the distribution | ||
24 | * | ||
25 | * IN NO EVENT SHALL NCIPHER CORPORATION LIMITED (`NCIPHER') AND/OR | ||
26 | * ANY OTHER AUTHORS OR DISTRIBUTORS OF THIS FILE BE LIABLE for any | ||
27 | * damages arising directly or indirectly from this file, its use or | ||
28 | * this licence. Without prejudice to the generality of the | ||
29 | * foregoing: all liability shall be excluded for direct, indirect, | ||
30 | * special, incidental, consequential or other damages or any loss of | ||
31 | * profits, business, revenue goodwill or anticipated savings; | ||
32 | * liability shall be excluded even if nCipher or anyone else has been | ||
33 | * advised of the possibility of damage. In any event, if the | ||
34 | * exclusion of liability is not effective, the liability of nCipher | ||
35 | * or any author or distributor shall be limited to the lesser of the | ||
36 | * price paid and 1,000 pounds sterling. This licence only fails to | ||
37 | * exclude or limit liability for death or personal injury arising out | ||
38 | * of negligence, and only to the extent that such an exclusion or | ||
39 | * limitation is not effective. | ||
40 | * | ||
41 | * NCIPHER AND THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ALL | ||
42 | * AND ANY WARRANTIES (WHETHER EXPRESS OR IMPLIED), including, but not | ||
43 | * limited to, any implied warranties of merchantability, fitness for | ||
44 | * a particular purpose, satisfactory quality, and/or non-infringement | ||
45 | * of any third party rights. | ||
46 | * | ||
47 | * US Government use: This software and documentation is Commercial | ||
48 | * Computer Software and Computer Software Documentation, as defined in | ||
49 | * sub-paragraphs (a)(1) and (a)(5) of DFAR 252.227-7014, "Rights in | ||
50 | * Noncommercial Computer Software and Noncommercial Computer Software | ||
51 | * Documentation." Use, duplication or disclosure by the Government is | ||
52 | * subject to the terms and conditions specified here. | ||
53 | * | ||
54 | * By using or distributing this file you will be accepting these | ||
55 | * terms and conditions, including the limitation of liability and | ||
56 | * lack of warranty. If you do not wish to accept these terms and | ||
57 | * conditions, DO NOT USE THE FILE. | ||
58 | * | ||
59 | * | ||
60 | * The actual dynamically loadable plugin, and the library files for | ||
61 | * static linking, which are also provided in some distributions, are | ||
62 | * not covered by the licence described above. You should have | ||
63 | * received a separate licence with terms and conditions for these | ||
64 | * library files; if you received the library files without a licence, | ||
65 | * please contact nCipher. | ||
66 | * | ||
67 | * | ||
68 | * $Id: hwcryptohook.h,v 1.1.1.1 2003/05/11 21:35:16 markus Exp $ | ||
69 | */ | ||
70 | |||
71 | #ifndef HWCRYPTOHOOK_H | ||
72 | #define HWCRYPTOHOOK_H | ||
73 | |||
74 | #include <sys/types.h> | ||
75 | #include <stdio.h> | ||
76 | |||
77 | #ifndef HWCRYPTOHOOK_DECLARE_APPTYPES | ||
78 | #define HWCRYPTOHOOK_DECLARE_APPTYPES 1 | ||
79 | #endif | ||
80 | |||
81 | #define HWCRYPTOHOOK_ERROR_FAILED -1 | ||
82 | #define HWCRYPTOHOOK_ERROR_FALLBACK -2 | ||
83 | #define HWCRYPTOHOOK_ERROR_MPISIZE -3 | ||
84 | |||
85 | #if HWCRYPTOHOOK_DECLARE_APPTYPES | ||
86 | |||
87 | /* These structs are defined by the application and opaque to the | ||
88 | * crypto plugin. The application may define these as it sees fit. | ||
89 | * Default declarations are provided here, but the application may | ||
90 | * #define HWCRYPTOHOOK_DECLARE_APPTYPES 0 | ||
91 | * to prevent these declarations, and instead provide its own | ||
92 | * declarations of these types. (Pointers to them must still be | ||
93 | * ordinary pointers to structs or unions, or the resulting combined | ||
94 | * program will have a type inconsistency.) | ||
95 | */ | ||
96 | typedef struct HWCryptoHook_MutexValue HWCryptoHook_Mutex; | ||
97 | typedef struct HWCryptoHook_CondVarValue HWCryptoHook_CondVar; | ||
98 | typedef struct HWCryptoHook_PassphraseContextValue HWCryptoHook_PassphraseContext; | ||
99 | typedef struct HWCryptoHook_CallerContextValue HWCryptoHook_CallerContext; | ||
100 | |||
101 | #endif /* HWCRYPTOHOOK_DECLARE_APPTYPES */ | ||
102 | |||
103 | /* These next two structs are opaque to the application. The crypto | ||
104 | * plugin will return pointers to them; the caller simply manipulates | ||
105 | * the pointers. | ||
106 | */ | ||
107 | typedef struct HWCryptoHook_Context *HWCryptoHook_ContextHandle; | ||
108 | typedef struct HWCryptoHook_RSAKey *HWCryptoHook_RSAKeyHandle; | ||
109 | |||
110 | typedef struct { | ||
111 | char *buf; | ||
112 | size_t size; | ||
113 | } HWCryptoHook_ErrMsgBuf; | ||
114 | /* Used for error reporting. When a HWCryptoHook function fails it | ||
115 | * will return a sentinel value (0 for pointer-valued functions, or a | ||
116 | * negative number, usually HWCRYPTOHOOK_ERROR_FAILED, for | ||
117 | * integer-valued ones). It will, if an ErrMsgBuf is passed, also put | ||
118 | * an error message there. | ||
119 | * | ||
120 | * size is the size of the buffer, and will not be modified. If you | ||
121 | * pass 0 for size you must pass 0 for buf, and nothing will be | ||
122 | * recorded (just as if you passed 0 for the struct pointer). | ||
123 | * Messages written to the buffer will always be null-terminated, even | ||
124 | * when truncated to fit within size bytes. | ||
125 | * | ||
126 | * The contents of the buffer are not defined if there is no error. | ||
127 | */ | ||
128 | |||
129 | typedef struct HWCryptoHook_MPIStruct { | ||
130 | unsigned char *buf; | ||
131 | size_t size; | ||
132 | } HWCryptoHook_MPI; | ||
133 | /* When one of these is returned, a pointer is passed to the function. | ||
134 | * At call, size is the space available. Afterwards it is updated to | ||
135 | * be set to the actual length (which may be more than the space available, | ||
136 | * if there was not enough room and the result was truncated). | ||
137 | * buf (the pointer) is not updated. | ||
138 | * | ||
139 | * size is in bytes and may be zero at call or return, but must be a | ||
140 | * multiple of the limb size. Zero limbs at the MS end are not | ||
141 | * permitted. | ||
142 | */ | ||
143 | |||
144 | #define HWCryptoHook_InitFlags_FallbackModExp 0x0002UL | ||
145 | #define HWCryptoHook_InitFlags_FallbackRSAImmed 0x0004UL | ||
146 | /* Enable requesting fallback to software in case of problems with the | ||
147 | * hardware support. This indicates to the crypto provider that the | ||
148 | * application is prepared to fall back to software operation if the | ||
149 | * ModExp* or RSAImmed* functions return HWCRYPTOHOOK_ERROR_FALLBACK. | ||
150 | * Without this flag those calls will never return | ||
151 | * HWCRYPTOHOOK_ERROR_FALLBACK. The flag will also cause the crypto | ||
152 | * provider to avoid repeatedly attempting to contact dead hardware | ||
153 | * within a short interval, if appropriate. | ||
154 | */ | ||
155 | |||
156 | #define HWCryptoHook_InitFlags_SimpleForkCheck 0x0010UL | ||
157 | /* Without _SimpleForkCheck the library is allowed to assume that the | ||
158 | * application will not fork and call the library in the child(ren). | ||
159 | * | ||
160 | * When it is specified, this is allowed. However, after a fork | ||
161 | * neither parent nor child may unload any loaded keys or call | ||
162 | * _Finish. Instead, they should call exit (or die with a signal) | ||
163 | * without calling _Finish. After all the children have died the | ||
164 | * parent may unload keys or call _Finish. | ||
165 | * | ||
166 | * This flag only has any effect on UN*X platforms. | ||
167 | */ | ||
168 | |||
169 | typedef struct { | ||
170 | unsigned long flags; | ||
171 | void *logstream; /* usually a FILE*. See below. */ | ||
172 | |||
173 | size_t limbsize; /* bignum format - size of radix type, must be power of 2 */ | ||
174 | int mslimbfirst; /* 0 or 1 */ | ||
175 | int msbytefirst; /* 0 or 1; -1 = native */ | ||
176 | |||
177 | /* All the callback functions should return 0 on success, or a | ||
178 | * nonzero integer (whose value will be visible in the error message | ||
179 | * put in the buffer passed to the call). | ||
180 | * | ||
181 | * If a callback is not available pass a null function pointer. | ||
182 | * | ||
183 | * The callbacks may not call down again into the crypto plugin. | ||
184 | */ | ||
185 | |||
186 | /* For thread-safety. Set everything to 0 if you promise only to be | ||
187 | * singlethreaded. maxsimultaneous is the number of calls to | ||
188 | * ModExp[Crt]/RSAImmed{Priv,Pub}/RSA. If you don't know what to | ||
189 | * put there then say 0 and the hook library will use a default. | ||
190 | * | ||
191 | * maxmutexes is a small limit on the number of simultaneous mutexes | ||
192 | * which will be requested by the library. If there is no small | ||
193 | * limit, set it to 0. If the crypto plugin cannot create the | ||
194 | * advertised number of mutexes the calls to its functions may fail. | ||
195 | * If a low number of mutexes is advertised the plugin will try to | ||
196 | * do the best it can. Making larger numbers of mutexes available | ||
197 | * may improve performance and parallelism by reducing contention | ||
198 | * over critical sections. Unavailability of any mutexes, implying | ||
199 | * single-threaded operation, should be indicated by the setting | ||
200 | * mutex_init et al to 0. | ||
201 | */ | ||
202 | int maxmutexes; | ||
203 | int maxsimultaneous; | ||
204 | size_t mutexsize; | ||
205 | int (*mutex_init)(HWCryptoHook_Mutex*, HWCryptoHook_CallerContext *cactx); | ||
206 | int (*mutex_acquire)(HWCryptoHook_Mutex*); | ||
207 | void (*mutex_release)(HWCryptoHook_Mutex*); | ||
208 | void (*mutex_destroy)(HWCryptoHook_Mutex*); | ||
209 | |||
210 | /* For greater efficiency, can use condition vars internally for | ||
211 | * synchronisation. In this case maxsimultaneous is ignored, but | ||
212 | * the other mutex stuff must be available. In singlethreaded | ||
213 | * programs, set everything to 0. | ||
214 | */ | ||
215 | size_t condvarsize; | ||
216 | int (*condvar_init)(HWCryptoHook_CondVar*, HWCryptoHook_CallerContext *cactx); | ||
217 | int (*condvar_wait)(HWCryptoHook_CondVar*, HWCryptoHook_Mutex*); | ||
218 | void (*condvar_signal)(HWCryptoHook_CondVar*); | ||
219 | void (*condvar_broadcast)(HWCryptoHook_CondVar*); | ||
220 | void (*condvar_destroy)(HWCryptoHook_CondVar*); | ||
221 | |||
222 | /* The semantics of acquiring and releasing mutexes and broadcasting | ||
223 | * and waiting on condition variables are expected to be those from | ||
224 | * POSIX threads (pthreads). The mutexes may be (in pthread-speak) | ||
225 | * fast mutexes, recursive mutexes, or nonrecursive ones. | ||
226 | * | ||
227 | * The _release/_signal/_broadcast and _destroy functions must | ||
228 | * always succeed when given a valid argument; if they are given an | ||
229 | * invalid argument then the program (crypto plugin + application) | ||
230 | * has an internal error, and they should abort the program. | ||
231 | */ | ||
232 | |||
233 | int (*getpassphrase)(const char *prompt_info, | ||
234 | int *len_io, char *buf, | ||
235 | HWCryptoHook_PassphraseContext *ppctx, | ||
236 | HWCryptoHook_CallerContext *cactx); | ||
237 | /* Passphrases and the prompt_info, if they contain high-bit-set | ||
238 | * characters, are UTF-8. The prompt_info may be a null pointer if | ||
239 | * no prompt information is available (it should not be an empty | ||
240 | * string). It will not contain text like `enter passphrase'; | ||
241 | * instead it might say something like `Operator Card for John | ||
242 | * Smith' or `SmartCard in nFast Module #1, Slot #1'. | ||
243 | * | ||
244 | * buf points to a buffer in which to return the passphrase; on | ||
245 | * entry *len_io is the length of the buffer. It should be updated | ||
246 | * by the callback. The returned passphrase should not be | ||
247 | * null-terminated by the callback. | ||
248 | */ | ||
249 | |||
250 | int (*getphystoken)(const char *prompt_info, | ||
251 | const char *wrong_info, | ||
252 | HWCryptoHook_PassphraseContext *ppctx, | ||
253 | HWCryptoHook_CallerContext *cactx); | ||
254 | /* Requests that the human user physically insert a different | ||
255 | * smartcard, DataKey, etc. The plugin should check whether the | ||
256 | * currently inserted token(s) are appropriate, and if they are it | ||
257 | * should not make this call. | ||
258 | * | ||
259 | * prompt_info is as before. wrong_info is a description of the | ||
260 | * currently inserted token(s) so that the user is told what | ||
261 | * something is. wrong_info, like prompt_info, may be null, but | ||
262 | * should not be an empty string. Its contents should be | ||
263 | * syntactically similar to that of prompt_info. | ||
264 | */ | ||
265 | |||
266 | /* Note that a single LoadKey operation might cause several calls to | ||
267 | * getpassphrase and/or requestphystoken. If requestphystoken is | ||
268 | * not provided (ie, a null pointer is passed) then the plugin may | ||
269 | * not support loading keys for which authorisation by several cards | ||
270 | * is required. If getpassphrase is not provided then cards with | ||
271 | * passphrases may not be supported. | ||
272 | * | ||
273 | * getpassphrase and getphystoken do not need to check that the | ||
274 | * passphrase has been entered correctly or the correct token | ||
275 | * inserted; the crypto plugin will do that. If this is not the | ||
276 | * case then the crypto plugin is responsible for calling these | ||
277 | * routines again as appropriate until the correct token(s) and | ||
278 | * passphrase(s) are supplied as required, or until any retry limits | ||
279 | * implemented by the crypto plugin are reached. | ||
280 | * | ||
281 | * In either case, the application must allow the user to say `no' | ||
282 | * or `cancel' to indicate that they do not know the passphrase or | ||
283 | * have the appropriate token; this should cause the callback to | ||
284 | * return nonzero indicating error. | ||
285 | */ | ||
286 | |||
287 | void (*logmessage)(void *logstream, const char *message); | ||
288 | /* A log message will be generated at least every time something goes | ||
289 | * wrong and an ErrMsgBuf is filled in (or would be if one was | ||
290 | * provided). Other diagnostic information may be written there too, | ||
291 | * including more detailed reasons for errors which are reported in an | ||
292 | * ErrMsgBuf. | ||
293 | * | ||
294 | * When a log message is generated, this callback is called. It | ||
295 | * should write a message to the relevant logging arrangements. | ||
296 | * | ||
297 | * The message string passed will be null-terminated and may be of arbitrary | ||
298 | * length. It will not be prefixed by the time and date, nor by the | ||
299 | * name of the library that is generating it - if this is required, | ||
300 | * the logmessage callback must do it. The message will not have a | ||
301 | * trailing newline (though it may contain internal newlines). | ||
302 | * | ||
303 | * If a null pointer is passed for logmessage a default function is | ||
304 | * used. The default function treats logstream as a FILE* which has | ||
305 | * been converted to a void*. If logstream is 0 it does nothing. | ||
306 | * Otherwise it prepends the date and time and library name and | ||
307 | * writes the message to logstream. Each line will be prefixed by a | ||
308 | * descriptive string containing the date, time and identity of the | ||
309 | * crypto plugin. Errors on the logstream are not reported | ||
310 | * anywhere, and the default function doesn't flush the stream, so | ||
311 | * the application must set the buffering how it wants it. | ||
312 | * | ||
313 | * The crypto plugin may also provide a facility to have copies of | ||
314 | * log messages sent elsewhere, and or for adjusting the verbosity | ||
315 | * of the log messages; any such facilities will be configured by | ||
316 | * external means. | ||
317 | */ | ||
318 | |||
319 | } HWCryptoHook_InitInfo; | ||
320 | |||
321 | typedef | ||
322 | HWCryptoHook_ContextHandle HWCryptoHook_Init_t(const HWCryptoHook_InitInfo *initinfo, | ||
323 | size_t initinfosize, | ||
324 | const HWCryptoHook_ErrMsgBuf *errors, | ||
325 | HWCryptoHook_CallerContext *cactx); | ||
326 | extern HWCryptoHook_Init_t HWCryptoHook_Init; | ||
327 | |||
328 | /* Caller should set initinfosize to the size of the HWCryptoHook struct, | ||
329 | * so it can be extended later. | ||
330 | * | ||
331 | * On success, a message for display or logging by the server, | ||
332 | * including the name and version number of the plugin, will be filled | ||
333 | * in into *errors; on failure *errors is used for error handling, as | ||
334 | * usual. | ||
335 | */ | ||
336 | |||
337 | /* All these functions return 0 on success, HWCRYPTOHOOK_ERROR_FAILED | ||
338 | * on most failures. HWCRYPTOHOOK_ERROR_MPISIZE means at least one of | ||
339 | * the output MPI buffer(s) was too small; the sizes of all have been | ||
340 | * set to the desired size (and for those where the buffer was large | ||
341 | * enough, the value may have been copied in), and no error message | ||
342 | * has been recorded. | ||
343 | * | ||
344 | * You may pass 0 for the errors struct. In any case, unless you set | ||
345 | * _NoStderr at init time then messages may be reported to stderr. | ||
346 | */ | ||
347 | |||
348 | /* The RSAImmed* functions (and key managed RSA) only work with | ||
349 | * modules which have an RSA patent licence - currently that means KM | ||
350 | * units; the ModExp* ones work with all modules, so you need a patent | ||
351 | * licence in the software in the US. They are otherwise identical. | ||
352 | */ | ||
353 | |||
354 | typedef | ||
355 | void HWCryptoHook_Finish_t(HWCryptoHook_ContextHandle hwctx); | ||
356 | extern HWCryptoHook_Finish_t HWCryptoHook_Finish; | ||
357 | /* You must not have any calls going or keys loaded when you call this. */ | ||
358 | |||
359 | typedef | ||
360 | int HWCryptoHook_RandomBytes_t(HWCryptoHook_ContextHandle hwctx, | ||
361 | unsigned char *buf, size_t len, | ||
362 | const HWCryptoHook_ErrMsgBuf *errors); | ||
363 | extern HWCryptoHook_RandomBytes_t HWCryptoHook_RandomBytes; | ||
364 | |||
365 | typedef | ||
366 | int HWCryptoHook_ModExp_t(HWCryptoHook_ContextHandle hwctx, | ||
367 | HWCryptoHook_MPI a, | ||
368 | HWCryptoHook_MPI p, | ||
369 | HWCryptoHook_MPI n, | ||
370 | HWCryptoHook_MPI *r, | ||
371 | const HWCryptoHook_ErrMsgBuf *errors); | ||
372 | extern HWCryptoHook_ModExp_t HWCryptoHook_ModExp; | ||
373 | |||
374 | typedef | ||
375 | int HWCryptoHook_RSAImmedPub_t(HWCryptoHook_ContextHandle hwctx, | ||
376 | HWCryptoHook_MPI m, | ||
377 | HWCryptoHook_MPI e, | ||
378 | HWCryptoHook_MPI n, | ||
379 | HWCryptoHook_MPI *r, | ||
380 | const HWCryptoHook_ErrMsgBuf *errors); | ||
381 | extern HWCryptoHook_RSAImmedPub_t HWCryptoHook_RSAImmedPub; | ||
382 | |||
383 | typedef | ||
384 | int HWCryptoHook_ModExpCRT_t(HWCryptoHook_ContextHandle hwctx, | ||
385 | HWCryptoHook_MPI a, | ||
386 | HWCryptoHook_MPI p, | ||
387 | HWCryptoHook_MPI q, | ||
388 | HWCryptoHook_MPI dmp1, | ||
389 | HWCryptoHook_MPI dmq1, | ||
390 | HWCryptoHook_MPI iqmp, | ||
391 | HWCryptoHook_MPI *r, | ||
392 | const HWCryptoHook_ErrMsgBuf *errors); | ||
393 | extern HWCryptoHook_ModExpCRT_t HWCryptoHook_ModExpCRT; | ||
394 | |||
395 | typedef | ||
396 | int HWCryptoHook_RSAImmedPriv_t(HWCryptoHook_ContextHandle hwctx, | ||
397 | HWCryptoHook_MPI m, | ||
398 | HWCryptoHook_MPI p, | ||
399 | HWCryptoHook_MPI q, | ||
400 | HWCryptoHook_MPI dmp1, | ||
401 | HWCryptoHook_MPI dmq1, | ||
402 | HWCryptoHook_MPI iqmp, | ||
403 | HWCryptoHook_MPI *r, | ||
404 | const HWCryptoHook_ErrMsgBuf *errors); | ||
405 | extern HWCryptoHook_RSAImmedPriv_t HWCryptoHook_RSAImmedPriv; | ||
406 | |||
407 | /* The RSAImmed* and ModExp* functions may return E_FAILED or | ||
408 | * E_FALLBACK for failure. | ||
409 | * | ||
410 | * E_FAILED means the failure is permanent and definite and there | ||
411 | * should be no attempt to fall back to software. (Eg, for some | ||
412 | * applications, which support only the acceleration-only | ||
413 | * functions, the `key material' may actually be an encoded key | ||
414 | * identifier, and doing the operation in software would give wrong | ||
415 | * answers.) | ||
416 | * | ||
417 | * E_FALLBACK means that doing the computation in software would seem | ||
418 | * reasonable. If an application pays attention to this and is | ||
419 | * able to fall back, it should also set the Fallback init flags. | ||
420 | */ | ||
421 | |||
422 | typedef | ||
423 | int HWCryptoHook_RSALoadKey_t(HWCryptoHook_ContextHandle hwctx, | ||
424 | const char *key_ident, | ||
425 | HWCryptoHook_RSAKeyHandle *keyhandle_r, | ||
426 | const HWCryptoHook_ErrMsgBuf *errors, | ||
427 | HWCryptoHook_PassphraseContext *ppctx); | ||
428 | extern HWCryptoHook_RSALoadKey_t HWCryptoHook_RSALoadKey; | ||
429 | /* The key_ident is a null-terminated string configured by the | ||
430 | * user via the application's usual configuration mechanisms. | ||
431 | * It is provided to the user by the crypto provider's key management | ||
432 | * system. The user must be able to enter at least any string of between | ||
433 | * 1 and 1023 characters inclusive, consisting of printable 7-bit | ||
434 | * ASCII characters. The provider should avoid using | ||
435 | * any characters except alphanumerics and the punctuation | ||
436 | * characters _ - + . / @ ~ (the user is expected to be able | ||
437 | * to enter these without quoting). The string may be case-sensitive. | ||
438 | * The application may allow the user to enter other NULL-terminated strings, | ||
439 | * and the provider must cope (returning an error if the string is not | ||
440 | * valid). | ||
441 | * | ||
442 | * If the key does not exist, no error is recorded and 0 is returned; | ||
443 | * keyhandle_r will be set to 0 instead of to a key handle. | ||
444 | */ | ||
445 | |||
446 | typedef | ||
447 | int HWCryptoHook_RSAGetPublicKey_t(HWCryptoHook_RSAKeyHandle k, | ||
448 | HWCryptoHook_MPI *n, | ||
449 | HWCryptoHook_MPI *e, | ||
450 | const HWCryptoHook_ErrMsgBuf *errors); | ||
451 | extern HWCryptoHook_RSAGetPublicKey_t HWCryptoHook_RSAGetPublicKey; | ||
452 | /* The crypto plugin will not store certificates. | ||
453 | * | ||
454 | * Although this function for acquiring the public key value is | ||
455 | * provided, it is not the purpose of this API to deal fully with the | ||
456 | * handling of the public key. | ||
457 | * | ||
458 | * It is expected that the crypto supplier's key generation program | ||
459 | * will provide general facilities for producing X.509 | ||
460 | * self-certificates and certificate requests in PEM format. These | ||
461 | * will be given to the user so that they can configure them in the | ||
462 | * application, send them to CAs, or whatever. | ||
463 | * | ||
464 | * In case this kind of certificate handling is not appropriate, the | ||
465 | * crypto supplier's key generation program should be able to be | ||
466 | * configured not to generate such a self-certificate or certificate | ||
467 | * request. Then the application will need to do all of this, and | ||
468 | * will need to store and handle the public key and certificates | ||
469 | * itself. | ||
470 | */ | ||
471 | |||
472 | typedef | ||
473 | int HWCryptoHook_RSAUnloadKey_t(HWCryptoHook_RSAKeyHandle k, | ||
474 | const HWCryptoHook_ErrMsgBuf *errors); | ||
475 | extern HWCryptoHook_RSAUnloadKey_t HWCryptoHook_RSAUnloadKey; | ||
476 | /* Might fail due to locking problems, or other serious internal problems. */ | ||
477 | |||
478 | typedef | ||
479 | int HWCryptoHook_RSA_t(HWCryptoHook_MPI m, | ||
480 | HWCryptoHook_RSAKeyHandle k, | ||
481 | HWCryptoHook_MPI *r, | ||
482 | const HWCryptoHook_ErrMsgBuf *errors); | ||
483 | extern HWCryptoHook_RSA_t HWCryptoHook_RSA; | ||
484 | /* RSA private key operation (sign or decrypt) - raw, unpadded. */ | ||
485 | |||
486 | #endif /*HWCRYPTOHOOK_H*/ | ||
diff --git a/src/lib/libcrypto/engine/vendor_defns/sureware.h b/src/lib/libcrypto/engine/vendor_defns/sureware.h deleted file mode 100644 index 4bc22027f9..0000000000 --- a/src/lib/libcrypto/engine/vendor_defns/sureware.h +++ /dev/null | |||
@@ -1,239 +0,0 @@ | |||
1 | /* | ||
2 | * Written by Corinne Dive-Reclus(cdive@baltimore.com) | ||
3 | * | ||
4 | * Copyright@2001 Baltimore Technologies Ltd. | ||
5 | * * | ||
6 | * THIS FILE IS PROVIDED BY BALTIMORE TECHNOLOGIES ``AS IS'' AND * | ||
7 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * | ||
8 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * | ||
9 | * ARE DISCLAIMED. IN NO EVENT SHALL BALTIMORE TECHNOLOGIES BE LIABLE * | ||
10 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * | ||
11 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * | ||
12 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * | ||
13 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * | ||
14 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * | ||
15 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * | ||
16 | * SUCH DAMAGE. * | ||
17 | * | ||
18 | * | ||
19 | */ | ||
20 | #ifdef WIN32 | ||
21 | #define SW_EXPORT __declspec ( dllexport ) | ||
22 | #else | ||
23 | #define SW_EXPORT | ||
24 | #endif | ||
25 | |||
26 | /* | ||
27 | * List of exposed SureWare errors | ||
28 | */ | ||
29 | #define SUREWAREHOOK_ERROR_FAILED -1 | ||
30 | #define SUREWAREHOOK_ERROR_FALLBACK -2 | ||
31 | #define SUREWAREHOOK_ERROR_UNIT_FAILURE -3 | ||
32 | #define SUREWAREHOOK_ERROR_DATA_SIZE -4 | ||
33 | #define SUREWAREHOOK_ERROR_INVALID_PAD -5 | ||
34 | /* | ||
35 | * -----------------WARNING----------------------------------- | ||
36 | * In all the following functions: | ||
37 | * msg is a string with at least 24 bytes free. | ||
38 | * A 24 bytes string will be concatenated to the existing content of msg. | ||
39 | */ | ||
40 | /* | ||
41 | * SureWare Initialisation function | ||
42 | * in param threadsafe, if !=0, thread safe enabled | ||
43 | * return SureWareHOOK_ERROR_UNIT_FAILURE if failure, 1 if success | ||
44 | */ | ||
45 | typedef int SureWareHook_Init_t(char*const msg,int threadsafe); | ||
46 | extern SW_EXPORT SureWareHook_Init_t SureWareHook_Init; | ||
47 | /* | ||
48 | * SureWare Finish function | ||
49 | */ | ||
50 | typedef void SureWareHook_Finish_t(); | ||
51 | extern SW_EXPORT SureWareHook_Finish_t SureWareHook_Finish; | ||
52 | /* | ||
53 | * PRE_CONDITION: | ||
54 | * DO NOT CALL ANY OF THE FOLLOWING FUNCTIONS IN CASE OF INIT FAILURE | ||
55 | */ | ||
56 | /* | ||
57 | * SureWare RAND Bytes function | ||
58 | * In case of failure, the content of buf is unpredictable. | ||
59 | * return 1 if success | ||
60 | * SureWareHOOK_ERROR_FALLBACK if function not available in hardware | ||
61 | * SureWareHOOK_ERROR_FAILED if error while processing | ||
62 | * SureWareHOOK_ERROR_UNIT_FAILURE if hardware failure | ||
63 | * SUREWAREHOOK_ERROR_DATA_SIZE wrong size for buf | ||
64 | * | ||
65 | * in/out param buf : a num bytes long buffer where random bytes will be put | ||
66 | * in param num : the number of bytes into buf | ||
67 | */ | ||
68 | typedef int SureWareHook_Rand_Bytes_t(char*const msg,unsigned char *buf, int num); | ||
69 | extern SW_EXPORT SureWareHook_Rand_Bytes_t SureWareHook_Rand_Bytes; | ||
70 | |||
71 | /* | ||
72 | * SureWare RAND Seed function | ||
73 | * Adds some seed to the Hardware Random Number Generator | ||
74 | * return 1 if success | ||
75 | * SureWareHOOK_ERROR_FALLBACK if function not available in hardware | ||
76 | * SureWareHOOK_ERROR_FAILED if error while processing | ||
77 | * SureWareHOOK_ERROR_UNIT_FAILURE if hardware failure | ||
78 | * SUREWAREHOOK_ERROR_DATA_SIZE wrong size for buf | ||
79 | * | ||
80 | * in param buf : the seed to add into the HRNG | ||
81 | * in param num : the number of bytes into buf | ||
82 | */ | ||
83 | typedef int SureWareHook_Rand_Seed_t(char*const msg,const void *buf, int num); | ||
84 | extern SW_EXPORT SureWareHook_Rand_Seed_t SureWareHook_Rand_Seed; | ||
85 | |||
86 | /* | ||
87 | * SureWare Load Private Key function | ||
88 | * return 1 if success | ||
89 | * SureWareHOOK_ERROR_FAILED if error while processing | ||
90 | * No hardware is contact for this function. | ||
91 | * | ||
92 | * in param key_id :the name of the private protected key file without the extension | ||
93 | ".sws" | ||
94 | * out param hptr : a pointer to a buffer allocated by SureWare_Hook | ||
95 | * out param num: the effective key length in bytes | ||
96 | * out param keytype: 1 if RSA 2 if DSA | ||
97 | */ | ||
98 | typedef int SureWareHook_Load_Privkey_t(char*const msg,const char *key_id,char **hptr,unsigned long *num,char *keytype); | ||
99 | extern SW_EXPORT SureWareHook_Load_Privkey_t SureWareHook_Load_Privkey; | ||
100 | |||
101 | /* | ||
102 | * SureWare Info Public Key function | ||
103 | * return 1 if success | ||
104 | * SureWareHOOK_ERROR_FAILED if error while processing | ||
105 | * No hardware is contact for this function. | ||
106 | * | ||
107 | * in param key_id :the name of the private protected key file without the extension | ||
108 | ".swp" | ||
109 | * out param hptr : a pointer to a buffer allocated by SureWare_Hook | ||
110 | * out param num: the effective key length in bytes | ||
111 | * out param keytype: 1 if RSA 2 if DSA | ||
112 | */ | ||
113 | typedef int SureWareHook_Info_Pubkey_t(char*const msg,const char *key_id,unsigned long *num, | ||
114 | char *keytype); | ||
115 | extern SW_EXPORT SureWareHook_Info_Pubkey_t SureWareHook_Info_Pubkey; | ||
116 | |||
117 | /* | ||
118 | * SureWare Load Public Key function | ||
119 | * return 1 if success | ||
120 | * SureWareHOOK_ERROR_FAILED if error while processing | ||
121 | * No hardware is contact for this function. | ||
122 | * | ||
123 | * in param key_id :the name of the public protected key file without the extension | ||
124 | ".swp" | ||
125 | * in param num : the bytes size of n and e | ||
126 | * out param n: where to write modulus in bn format | ||
127 | * out param e: where to write exponent in bn format | ||
128 | */ | ||
129 | typedef int SureWareHook_Load_Rsa_Pubkey_t(char*const msg,const char *key_id,unsigned long num, | ||
130 | unsigned long *n, unsigned long *e); | ||
131 | extern SW_EXPORT SureWareHook_Load_Rsa_Pubkey_t SureWareHook_Load_Rsa_Pubkey; | ||
132 | |||
133 | /* | ||
134 | * SureWare Load DSA Public Key function | ||
135 | * return 1 if success | ||
136 | * SureWareHOOK_ERROR_FAILED if error while processing | ||
137 | * No hardware is contact for this function. | ||
138 | * | ||
139 | * in param key_id :the name of the public protected key file without the extension | ||
140 | ".swp" | ||
141 | * in param num : the bytes size of n and e | ||
142 | * out param pub: where to write pub key in bn format | ||
143 | * out param p: where to write prime in bn format | ||
144 | * out param q: where to write sunprime (length 20 bytes) in bn format | ||
145 | * out param g: where to write base in bn format | ||
146 | */ | ||
147 | typedef int SureWareHook_Load_Dsa_Pubkey_t(char*const msg,const char *key_id,unsigned long num, | ||
148 | unsigned long *pub, unsigned long *p,unsigned long*q, | ||
149 | unsigned long *g); | ||
150 | extern SW_EXPORT SureWareHook_Load_Dsa_Pubkey_t SureWareHook_Load_Dsa_Pubkey; | ||
151 | |||
152 | /* | ||
153 | * SureWare Free function | ||
154 | * Destroy the key into the hardware if destroy==1 | ||
155 | */ | ||
156 | typedef void SureWareHook_Free_t(char *p,int destroy); | ||
157 | extern SW_EXPORT SureWareHook_Free_t SureWareHook_Free; | ||
158 | |||
159 | #define SUREWARE_PKCS1_PAD 1 | ||
160 | #define SUREWARE_ISO9796_PAD 2 | ||
161 | #define SUREWARE_NO_PAD 0 | ||
162 | /* | ||
163 | * SureWare RSA Private Decryption | ||
164 | * return 1 if success | ||
165 | * SureWareHOOK_ERROR_FAILED if error while processing | ||
166 | * SureWareHOOK_ERROR_UNIT_FAILURE if hardware failure | ||
167 | * SUREWAREHOOK_ERROR_DATA_SIZE wrong size for buf | ||
168 | * | ||
169 | * in param flen : byte size of from and to | ||
170 | * in param from : encrypted data buffer, should be a not-null valid pointer | ||
171 | * out param tlen: byte size of decrypted data, if error, unexpected value | ||
172 | * out param to : decrypted data buffer, should be a not-null valid pointer | ||
173 | * in param prsa: a protected key pointer, should be a not-null valid pointer | ||
174 | * int padding: padding id as follow | ||
175 | * SUREWARE_PKCS1_PAD | ||
176 | * SUREWARE_NO_PAD | ||
177 | * | ||
178 | */ | ||
179 | typedef int SureWareHook_Rsa_Priv_Dec_t(char*const msg,int flen,unsigned char *from, | ||
180 | int *tlen,unsigned char *to, | ||
181 | char *prsa,int padding); | ||
182 | extern SW_EXPORT SureWareHook_Rsa_Priv_Dec_t SureWareHook_Rsa_Priv_Dec; | ||
183 | /* | ||
184 | * SureWare RSA Signature | ||
185 | * return 1 if success | ||
186 | * SureWareHOOK_ERROR_FAILED if error while processing | ||
187 | * SureWareHOOK_ERROR_UNIT_FAILURE if hardware failure | ||
188 | * SUREWAREHOOK_ERROR_DATA_SIZE wrong size for buf | ||
189 | * | ||
190 | * in param flen : byte size of from and to | ||
191 | * in param from : encrypted data buffer, should be a not-null valid pointer | ||
192 | * out param tlen: byte size of decrypted data, if error, unexpected value | ||
193 | * out param to : decrypted data buffer, should be a not-null valid pointer | ||
194 | * in param prsa: a protected key pointer, should be a not-null valid pointer | ||
195 | * int padding: padding id as follow | ||
196 | * SUREWARE_PKCS1_PAD | ||
197 | * SUREWARE_ISO9796_PAD | ||
198 | * | ||
199 | */ | ||
200 | typedef int SureWareHook_Rsa_Sign_t(char*const msg,int flen,unsigned char *from, | ||
201 | int *tlen,unsigned char *to, | ||
202 | char *prsa,int padding); | ||
203 | extern SW_EXPORT SureWareHook_Rsa_Sign_t SureWareHook_Rsa_Sign; | ||
204 | /* | ||
205 | * SureWare DSA Signature | ||
206 | * return 1 if success | ||
207 | * SureWareHOOK_ERROR_FAILED if error while processing | ||
208 | * SureWareHOOK_ERROR_UNIT_FAILURE if hardware failure | ||
209 | * SUREWAREHOOK_ERROR_DATA_SIZE wrong size for buf | ||
210 | * | ||
211 | * in param flen : byte size of from and to | ||
212 | * in param from : encrypted data buffer, should be a not-null valid pointer | ||
213 | * out param to : decrypted data buffer, should be a 40bytes valid pointer | ||
214 | * in param pdsa: a protected key pointer, should be a not-null valid pointer | ||
215 | * | ||
216 | */ | ||
217 | typedef int SureWareHook_Dsa_Sign_t(char*const msg,int flen,const unsigned char *from, | ||
218 | unsigned long *r,unsigned long *s,char *pdsa); | ||
219 | extern SW_EXPORT SureWareHook_Dsa_Sign_t SureWareHook_Dsa_Sign; | ||
220 | |||
221 | |||
222 | /* | ||
223 | * SureWare Mod Exp | ||
224 | * return 1 if success | ||
225 | * SureWareHOOK_ERROR_FAILED if error while processing | ||
226 | * SureWareHOOK_ERROR_UNIT_FAILURE if hardware failure | ||
227 | * SUREWAREHOOK_ERROR_DATA_SIZE wrong size for buf | ||
228 | * | ||
229 | * mod and res are mlen bytes long. | ||
230 | * exp is elen bytes long | ||
231 | * data is dlen bytes long | ||
232 | * mlen,elen and dlen are all multiple of sizeof(unsigned long) | ||
233 | */ | ||
234 | typedef int SureWareHook_Mod_Exp_t(char*const msg,int mlen,const unsigned long *mod, | ||
235 | int elen,const unsigned long *exponent, | ||
236 | int dlen,unsigned long *data, | ||
237 | unsigned long *res); | ||
238 | extern SW_EXPORT SureWareHook_Mod_Exp_t SureWareHook_Mod_Exp; | ||
239 | |||