1 /*
2 * Copyright 2018-2021 NXP
3 * All rights reserved.
4 *
5 * SPDX-License-Identifier: BSD-3-Clause
6 */
7 #include "fsl_sss_sscp.h"
8 #include <string.h>
9 #include "fsl_sss_api.h"
10 #include "fsl_sscp.h"
11 #include "fsl_sscp_commands.h"
12
13 #define NUMBER_OF_BITS_IN_BYTE (8u)
14 #define MAX_SUPPORTED_COORDINATE_LENGTH_IN_BITS (1024u)
15 #define NUMBER_OF_COORDINATES_PER_EC_KEY_SLOT (3u)
16 #define SSS_SSCP_TUNNEL_HAVE_BUFFER_MASK (0x80000000u)
17
sss_sscp_open_session(sss_sscp_session_t * session,uint32_t sessionId,sss_type_t subsystem,sscp_context_t * sscpctx)18 sss_status_t sss_sscp_open_session(sss_sscp_session_t *session,
19 uint32_t sessionId,
20 sss_type_t subsystem,
21 sscp_context_t *sscpctx)
22
23 {
24 SSCP_BUILD_ASSURE(sizeof(sss_session_t) >= sizeof(sss_sscp_session_t), _sss_sscp_session_size);
25 sscp_operation_t op = {0};
26 sscp_status_t status = kStatus_SSCP_Fail;
27 uint32_t ret = 0u;
28
29 session->subsystem = subsystem;
30 session->sscp = sscpctx;
31 op.paramTypes =
32 SSCP_OP_SET_PARAM(kSSCP_ParamType_ValueInputTuple, kSSCP_ParamType_None, kSSCP_ParamType_None,
33 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
34
35 op.params[0].value.a = (uint32_t)subsystem;
36 op.params[0].value.b = sessionId;
37
38 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ContextReference);
39 op.resultCount = 1u;
40 op.result[0].context.ptr = session;
41 op.result[0].context.type = kSSCP_ParamContextType_SSS_Session;
42
43 status = sscpctx->invoke(sscpctx, kSSCP_CMD_SSS_OpenSession, &op, &ret);
44 if (status != kStatus_SSCP_Success)
45 {
46 return kStatus_SSS_Fail;
47 }
48
49 return (sss_status_t)ret;
50 }
51
sss_sscp_close_session(sss_sscp_session_t * session)52 sss_status_t sss_sscp_close_session(sss_sscp_session_t *session)
53 {
54 sscp_operation_t op = {0};
55 sscp_status_t status = kStatus_SSCP_Fail;
56 uint32_t ret = 0u;
57
58 op.paramTypes =
59 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
60 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
61
62 op.params[0].context.ptr = session;
63 op.params[0].context.type = kSSCP_ParamContextType_SSS_Session;
64
65 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
66 op.resultCount = 0u;
67
68 sscp_context_t *sscpCtx = session->sscp;
69 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_CloseSession, &op, &ret);
70 if (status != kStatus_SSCP_Success)
71 {
72 return kStatus_SSS_Fail;
73 }
74 return (sss_status_t)ret;
75 }
76
77 /*******************************SYMETRIC***************************************/
sss_sscp_symmetric_context_init(sss_sscp_symmetric_t * context,sss_sscp_session_t * session,sss_sscp_object_t * keyObject,sss_algorithm_t algorithm,sss_mode_t mode)78 sss_status_t sss_sscp_symmetric_context_init(sss_sscp_symmetric_t *context,
79 sss_sscp_session_t *session,
80 sss_sscp_object_t *keyObject,
81 sss_algorithm_t algorithm,
82 sss_mode_t mode)
83 {
84 SSCP_BUILD_ASSURE(sizeof(sss_symmetric_t) >= sizeof(sss_sscp_symmetric_t), _sss_sscp_symmetric_size);
85 sscp_operation_t op = {0};
86 sscp_status_t status = kStatus_SSCP_Fail;
87 uint32_t ret = 0u;
88
89 context->session = session;
90 context->keyObject = keyObject;
91 context->algorithm = algorithm;
92 context->mode = mode;
93
94 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ContextReference,
95 kSSCP_ParamType_ValueInputTuple, kSSCP_ParamType_None, kSSCP_ParamType_None,
96 kSSCP_ParamType_None, kSSCP_ParamType_None);
97
98 op.params[0].context.ptr = session;
99 op.params[0].context.type = kSSCP_ParamContextType_SSS_Session;
100
101 op.params[1].context.ptr = keyObject;
102 op.params[1].context.type = kSSCP_ParamContextType_SSS_Object;
103
104 op.params[2].value.a = (uint32_t)algorithm;
105 op.params[2].value.b = (uint32_t)mode;
106
107 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ContextReference);
108 op.resultCount = 1u;
109 op.result[0].context.ptr = context;
110 op.result[0].context.type = kSSCP_ParamContextType_SSS_Symmetric;
111
112 sscp_context_t *sscpCtx = session->sscp;
113 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_SymmetricContextInit, &op, &ret);
114 if (status != kStatus_SSCP_Success)
115 {
116 return kStatus_SSS_Fail;
117 }
118
119 return (sss_status_t)ret;
120 }
121
sss_sscp_cipher_one_go(sss_sscp_symmetric_t * context,uint8_t * iv,size_t ivLen,const uint8_t * srcData,uint8_t * destData,size_t dataLen)122 sss_status_t sss_sscp_cipher_one_go(
123 sss_sscp_symmetric_t *context, uint8_t *iv, size_t ivLen, const uint8_t *srcData, uint8_t *destData, size_t dataLen)
124 {
125 SSCP_BUILD_ASSURE(sizeof(sss_symmetric_t) >= sizeof(sss_sscp_symmetric_t), _sss_sscp_symmetric_size);
126 sscp_operation_t op = {0};
127 sscp_status_t status = kStatus_SSCP_Fail;
128 uint32_t ret = 0u;
129
130 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput,
131 kSSCP_ParamType_MemrefInputNoSize, kSSCP_ParamType_MemrefInOut,
132 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
133
134 op.params[0].context.ptr = context;
135 op.params[0].context.type = kSSCP_ParamContextType_SSS_Symmetric;
136
137 op.params[1].memref.buffer = (uintptr_t)iv;
138 op.params[1].memref.size = ivLen;
139 op.params[2].memref.buffer = (uintptr_t)srcData;
140 op.params[2].memref.size = dataLen;
141 op.params[3].memref.buffer = (uintptr_t)destData;
142 op.params[3].memref.size = dataLen;
143
144 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
145 op.resultCount = 0u;
146
147 sscp_context_t *sscpCtx = context->session->sscp;
148 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_SymmetricCipherOneGo, &op, &ret);
149 if (status != kStatus_SSCP_Success)
150 {
151 return kStatus_SSS_Fail;
152 }
153
154 return (sss_status_t)ret;
155 }
156
sss_sscp_cipher_init(sss_sscp_symmetric_t * context,uint8_t * iv,size_t ivLen)157 sss_status_t sss_sscp_cipher_init(sss_sscp_symmetric_t *context, uint8_t *iv, size_t ivLen)
158 {
159 sscp_operation_t op = {0};
160 sscp_status_t status = kStatus_SSCP_Fail;
161 uint32_t ret = 0u;
162
163 op.paramTypes =
164 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_None,
165 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
166
167 op.params[0].context.ptr = context;
168 op.params[0].context.type = (uint32_t)kSSCP_ParamContextType_SSS_Symmetric;
169 op.params[1].memref.buffer = (uintptr_t)iv;
170 op.params[1].memref.size = ivLen;
171
172 sscp_context_t *sscpCtx = context->session->sscp;
173 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_SymmetricCipherInit, &op, &ret);
174 if (status != kStatus_SSCP_Success)
175 {
176 return kStatus_SSS_Fail;
177 }
178
179 return (sss_status_t)ret;
180 }
181
sss_sscp_cipher_update(sss_sscp_symmetric_t * context,const uint8_t * srcData,size_t srcLen,uint8_t * destData,size_t * destLen)182 sss_status_t sss_sscp_cipher_update(
183 sss_sscp_symmetric_t *context, const uint8_t *srcData, size_t srcLen, uint8_t *destData, size_t *destLen)
184 {
185 sscp_operation_t op = {0};
186 sscp_status_t status = kStatus_SSCP_Fail;
187 uint32_t ret = 0u;
188
189 size_t len = (destLen != NULL) ? *destLen : srcLen;
190
191 op.paramTypes =
192 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_MemrefOutput,
193 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
194
195 op.params[0].context.ptr = context;
196 op.params[0].context.type = (uint32_t)kSSCP_ParamContextType_SSS_Symmetric;
197 op.params[1].memref.buffer = (uintptr_t)srcData;
198 op.params[1].memref.size = srcLen;
199 op.params[2].memref.buffer = (uintptr_t)destData;
200 op.params[2].memref.size = len;
201
202 sscp_context_t *sscpCtx = context->session->sscp;
203 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_SymmetricCipherUpdate, &op, &ret);
204 if (status != kStatus_SSCP_Success)
205 {
206 if (destLen != NULL)
207 {
208 *destLen = 0u;
209 }
210 return kStatus_SSS_Fail;
211 }
212
213 /* update the size member of kSSCP_ParamType_MemrefOutput param with the actual byte length written to output buffer
214 */
215 if (destLen != NULL)
216 {
217 *destLen = op.params[2].memref.size;
218 }
219 return kStatus_SSS_Success;
220 }
221
sss_sscp_cipher_finish(sss_sscp_symmetric_t * context,const uint8_t * srcData,size_t srcLen,uint8_t * destData,size_t * destLen)222 sss_status_t sss_sscp_cipher_finish(
223 sss_sscp_symmetric_t *context, const uint8_t *srcData, size_t srcLen, uint8_t *destData, size_t *destLen)
224 {
225 sscp_operation_t op = {0};
226 sscp_status_t status = kStatus_SSCP_Fail;
227 uint32_t ret = 0u;
228
229 size_t len = (destLen != NULL) ? *destLen : srcLen;
230
231 op.paramTypes =
232 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_MemrefOutput,
233 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
234
235 op.params[0].context.ptr = context;
236 op.params[0].context.type = (uint32_t)kSSCP_ParamContextType_SSS_Symmetric;
237 op.params[1].memref.buffer = (uintptr_t)srcData;
238 op.params[1].memref.size = srcLen;
239 op.params[2].memref.buffer = (uintptr_t)destData;
240 op.params[2].memref.size = len;
241
242 sscp_context_t *sscpCtx = context->session->sscp;
243 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_SymmetricCipherFinish, &op, &ret);
244 if (status != kStatus_SSCP_Success)
245 {
246 if (destLen != NULL)
247 {
248 *destLen = 0u;
249 }
250 return kStatus_SSS_Fail;
251 }
252
253 /* update the size member of kSSCP_ParamType_MemrefOutput param with the actual byte length written to output buffer
254 */
255 if (destLen != NULL)
256 {
257 *destLen = op.params[2].memref.size;
258 }
259 return kStatus_SSS_Success;
260 }
261
sss_sscp_cipher_crypt_ctr(sss_sscp_symmetric_t * context,const uint8_t * srcData,uint8_t * destData,size_t size,uint8_t * initialCounter,uint8_t * lastEncryptedCounter,size_t * szLeft)262 sss_status_t sss_sscp_cipher_crypt_ctr(sss_sscp_symmetric_t *context,
263 const uint8_t *srcData,
264 uint8_t *destData,
265 size_t size,
266 uint8_t *initialCounter,
267 uint8_t *lastEncryptedCounter,
268 size_t *szLeft)
269 {
270 SSCP_BUILD_ASSURE(sizeof(sss_symmetric_t) >= sizeof(sss_sscp_symmetric_t), _sss_sscp_symmetric_size);
271 sscp_operation_t op = {0};
272 sscp_status_t status = kStatus_SSCP_Fail;
273 uint32_t ret = 0u;
274
275 /* this func specific for AES CTR */
276 /* don't consider DES at the moment for the CTR mode */
277 if (context->algorithm != kAlgorithm_SSS_AES_CTR)
278 {
279 return kStatus_SSS_InvalidArgument;
280 }
281
282 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput,
283 kSSCP_ParamType_MemrefOutput, kSSCP_ParamType_MemrefInOut,
284 kSSCP_ParamType_MemrefInOut, kSSCP_ParamType_MemrefInOut, kSSCP_ParamType_None);
285
286 op.params[0].context.ptr = context;
287 op.params[0].context.type = kSSCP_ParamContextType_SSS_Symmetric;
288
289 op.params[1].memref.buffer = (uintptr_t)srcData;
290 op.params[1].memref.size = size;
291 op.params[2].memref.buffer = (uintptr_t)destData;
292 op.params[2].memref.size = size;
293 op.params[3].memref.buffer = (uintptr_t)initialCounter;
294 op.params[3].memref.size = SSS_AES_BLOCK_SIZE;
295 op.params[4].memref.buffer = (uintptr_t)lastEncryptedCounter;
296 op.params[4].memref.size = SSS_AES_BLOCK_SIZE;
297 op.params[5].memref.buffer = (uintptr_t)szLeft;
298 op.params[5].memref.size = sizeof(*szLeft);
299
300 sscp_context_t *sscpCtx = context->session->sscp;
301 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_SymmetricCryptCtr, &op, &ret);
302 if (status != kStatus_SSCP_Success)
303 {
304 return kStatus_SSS_Fail;
305 }
306
307 return (sss_status_t)ret;
308 }
sss_sscp_symmetric_context_free(sss_sscp_symmetric_t * context)309 sss_status_t sss_sscp_symmetric_context_free(sss_sscp_symmetric_t *context)
310 {
311 sscp_operation_t op = {0};
312 sscp_status_t status = kStatus_SSCP_Fail;
313 uint32_t ret = 0u;
314
315 op.paramTypes =
316 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
317 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
318
319 op.params[0].context.ptr = context;
320 op.params[0].context.type = kSSCP_ParamContextType_SSS_Symmetric;
321
322 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
323 op.resultCount = 0u;
324
325 sscp_context_t *sscpCtx = context->session->sscp;
326 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_ContextFree, &op, &ret);
327 if (status != kStatus_SSCP_Success)
328 {
329 return kStatus_SSS_Fail;
330 }
331 return (sss_status_t)ret;
332 }
333 /**********************************AEAD****************************************/
334
sss_sscp_aead_context_init(sss_sscp_aead_t * context,sss_sscp_session_t * session,sss_sscp_object_t * keyObject,sss_algorithm_t algorithm,sss_mode_t mode)335 sss_status_t sss_sscp_aead_context_init(sss_sscp_aead_t *context,
336 sss_sscp_session_t *session,
337 sss_sscp_object_t *keyObject,
338 sss_algorithm_t algorithm,
339 sss_mode_t mode)
340 {
341 SSCP_BUILD_ASSURE(sizeof(sss_aead_t) >= sizeof(sss_sscp_aead_t), _sss_sscp_aead_size);
342 sscp_operation_t op = {0};
343 sscp_status_t status = kStatus_SSCP_Fail;
344 uint32_t ret = 0u;
345
346 context->session = session;
347 context->keyObject = keyObject;
348 context->algorithm = algorithm;
349 context->mode = mode;
350
351 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ContextReference,
352 kSSCP_ParamType_ValueInputTuple, kSSCP_ParamType_None, kSSCP_ParamType_None,
353 kSSCP_ParamType_None, kSSCP_ParamType_None);
354
355 op.params[0].context.ptr = session;
356 op.params[0].context.type = kSSCP_ParamContextType_SSS_Session;
357
358 op.params[1].context.ptr = keyObject;
359 op.params[1].context.type = kSSCP_ParamContextType_SSS_Object;
360
361 op.params[2].value.a = (uint32_t)algorithm;
362 op.params[2].value.b = (uint32_t)mode;
363
364 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ContextReference);
365 op.resultCount = 1u;
366 op.result[0].context.ptr = context;
367 op.result[0].context.type = kSSCP_ParamContextType_SSS_Aead;
368
369 sscp_context_t *sscpCtx = session->sscp;
370 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_AeadContextInit, &op, &ret);
371 if (status != kStatus_SSCP_Success)
372 {
373 return kStatus_SSS_Fail;
374 }
375
376 return (sss_status_t)ret;
377 }
378
sss_sscp_aead_one_go(sss_sscp_aead_t * context,const uint8_t * srcData,uint8_t * destData,size_t size,uint8_t * nonce,size_t nonceLen,const uint8_t * aad,size_t aadLen,uint8_t * tag,size_t * tagLen)379 sss_status_t sss_sscp_aead_one_go(sss_sscp_aead_t *context,
380 const uint8_t *srcData,
381 uint8_t *destData,
382 size_t size,
383 uint8_t *nonce,
384 size_t nonceLen,
385 const uint8_t *aad,
386 size_t aadLen,
387 uint8_t *tag,
388 size_t *tagLen)
389 {
390 SSCP_BUILD_ASSURE(sizeof(sss_aead_t) >= sizeof(sss_sscp_aead_t), _sss_sscp_aead_size);
391 sscp_operation_t op = {0};
392 sscp_status_t status = kStatus_SSCP_Fail;
393 uint32_t ret = 0u;
394
395 /* set paramTypes for the tag[] buffer according to mode
396 * for encrypt (and authenticate) mode, the tag[] is output, written by invoked function,
397 * for decrypt (and verify) mode, the tag[] is input, to be verified by invoked function
398 */
399 if (context->mode == kMode_SSS_Encrypt)
400 {
401 op.paramTypes =
402 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInputNoSize,
403 kSSCP_ParamType_MemrefOutputNoSize, kSSCP_ParamType_ValueInputSingle,
404 kSSCP_ParamType_MemrefInput, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_MemrefOutput);
405 }
406 else
407 {
408 op.paramTypes =
409 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInputNoSize,
410 kSSCP_ParamType_MemrefOutputNoSize, kSSCP_ParamType_ValueInputSingle,
411 kSSCP_ParamType_MemrefInput, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_MemrefInput);
412 }
413
414 op.params[0].context.ptr = context;
415 op.params[0].context.type = kSSCP_ParamContextType_SSS_Aead;
416
417 op.params[1].memref.buffer = (uintptr_t)srcData;
418 op.params[2].memref.buffer = (uintptr_t)destData;
419 op.params[3].value.a = size;
420 op.params[4].memref.buffer = (uintptr_t)nonce;
421 op.params[4].memref.size = nonceLen;
422 op.params[5].memref.buffer = (uintptr_t)aad;
423 op.params[5].memref.size = aadLen;
424 op.params[6].memref.buffer = (uintptr_t)tag;
425 op.params[6].memref.size = *tagLen;
426 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ValueOutputSingle);
427 op.resultCount = 1u;
428 op.result[0].value.a = (uint32_t)tagLen;
429 sscp_context_t *sscpCtx = context->session->sscp;
430 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_AeadOneGo, &op, &ret);
431 if (status != kStatus_SSCP_Success)
432 {
433 return kStatus_SSS_Fail;
434 }
435 return (sss_status_t)ret;
436 }
437
sss_sscp_aead_context_free(sss_sscp_aead_t * context)438 sss_status_t sss_sscp_aead_context_free(sss_sscp_aead_t *context)
439 {
440 sscp_operation_t op = {0};
441 sscp_status_t status = kStatus_SSCP_Fail;
442 uint32_t ret;
443
444 op.paramTypes =
445 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
446 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
447
448 op.params[0].context.ptr = context;
449 op.params[0].context.type = kSSCP_ParamContextType_SSS_Aead;
450
451 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
452 op.resultCount = 0u;
453
454 sscp_context_t *sscpCtx = context->session->sscp;
455 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_ContextFree, &op, &ret);
456 if (status != kStatus_SSCP_Success)
457 {
458 ret = kStatus_SSS_Fail;
459 }
460
461 return (sss_status_t)ret;
462 }
463
sss_sscp_aead_init(sss_sscp_aead_t * context,uint8_t * nonce,size_t nonceLen,size_t tagLen,size_t aadLen,size_t payloadLen)464 sss_status_t sss_sscp_aead_init(
465 sss_sscp_aead_t *context, uint8_t *nonce, size_t nonceLen, size_t tagLen, size_t aadLen, size_t payloadLen)
466 {
467 return kStatus_SSS_Fail;
468 }
469
sss_sscp_aead_update_aad(sss_sscp_aead_t * context,const uint8_t * aadData,size_t aadDataLen)470 sss_status_t sss_sscp_aead_update_aad(sss_sscp_aead_t *context, const uint8_t *aadData, size_t aadDataLen)
471 {
472 return kStatus_SSS_Fail;
473 }
474
sss_sscp_aead_update(sss_sscp_aead_t * context,const uint8_t * srcData,size_t srcLen,uint8_t destData,size_t * destLen)475 sss_status_t sss_sscp_aead_update(
476 sss_sscp_aead_t *context, const uint8_t *srcData, size_t srcLen, uint8_t destData, size_t *destLen)
477 {
478 return kStatus_SSS_Fail;
479 }
480
sss_sscp_aead_finish(sss_sscp_aead_t * context,const uint8_t * srcData,size_t srcLen,uint8_t destData,size_t * destLen,uint8_t * tag,size_t * tagLen)481 sss_status_t sss_sscp_aead_finish(sss_sscp_aead_t *context,
482 const uint8_t *srcData,
483 size_t srcLen,
484 uint8_t destData,
485 size_t *destLen,
486 uint8_t *tag,
487 size_t *tagLen)
488 {
489 return kStatus_SSS_Fail;
490 }
491
492 /********************************DIGEST****************************************/
sss_sscp_digest_context_init(sss_sscp_digest_t * context,sss_sscp_session_t * session,sss_algorithm_t algorithm,sss_mode_t mode)493 sss_status_t sss_sscp_digest_context_init(sss_sscp_digest_t *context,
494 sss_sscp_session_t *session,
495 sss_algorithm_t algorithm,
496 sss_mode_t mode)
497 {
498 SSCP_BUILD_ASSURE(sizeof(sss_digest_t) >= sizeof(sss_sscp_digest_t), _sss_sscp_digest_size);
499 sscp_operation_t op = {0};
500 sscp_status_t status = kStatus_SSCP_Fail;
501 uint32_t ret = 0u;
502 sss_status_t tmpStat = kStatus_SSS_Success;
503
504 context->algorithm = algorithm;
505 context->mode = mode;
506 context->session = session;
507 switch (algorithm)
508 {
509 case kAlgorithm_SSS_SHA1:
510 context->digestFullLen = 20u;
511 break;
512 case kAlgorithm_SSS_SHA224:
513 context->digestFullLen = 28u;
514 break;
515 case kAlgorithm_SSS_SHA256:
516 context->digestFullLen = 32u;
517 break;
518 case kAlgorithm_SSS_SHA384:
519 context->digestFullLen = 48u;
520 break;
521 case kAlgorithm_SSS_SHA512:
522 context->digestFullLen = 64u;
523 break;
524 default:
525 tmpStat = kStatus_SSS_Fail;
526 break;
527 }
528
529 if (tmpStat == kStatus_SSS_Fail)
530 {
531 return kStatus_SSS_Fail;
532 }
533
534 op.paramTypes =
535 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ValueInputTuple, kSSCP_ParamType_None,
536 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
537
538 op.params[0].context.ptr = session;
539 op.params[0].context.type = kSSCP_ParamContextType_SSS_Session;
540
541 op.params[1].value.a = (uint32_t)algorithm;
542 op.params[1].value.b = (uint32_t)mode;
543
544 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ContextReference);
545 op.resultCount = 1u;
546 op.result[0].context.ptr = context;
547 op.result[0].context.type = kSSCP_ParamContextType_SSS_Digest;
548
549 sscp_context_t *sscpCtx = session->sscp;
550 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_DigestContextInit, &op, &ret);
551
552 if (status != kStatus_SSCP_Success)
553 {
554 ret = kStatus_SSS_Fail;
555 }
556 return (sss_status_t)ret;
557 }
558
sss_sscp_digest_one_go(sss_sscp_digest_t * context,const uint8_t * message,size_t messageLen,uint8_t * digest,size_t * digestLen)559 sss_status_t sss_sscp_digest_one_go(
560 sss_sscp_digest_t *context, const uint8_t *message, size_t messageLen, uint8_t *digest, size_t *digestLen)
561 {
562 SSCP_BUILD_ASSURE(sizeof(sss_digest_t) >= sizeof(sss_sscp_digest_t), _sss_sscp_digest_size);
563 sscp_operation_t op = {0};
564 sscp_status_t status = kStatus_SSCP_Fail;
565 uint32_t ret = 0u;
566
567 /* if the caller gives NULL pointer to digestLen, it is assumed that digest[] buffer is big enough to hold full
568 * digest */
569 size_t len = (digestLen != NULL) ? *digestLen : context->digestFullLen;
570
571 /* if the *digestLen cannot hold full digest (per algorithm spec) return error */
572 if (len < context->digestFullLen)
573 {
574 return kStatus_SSS_Fail;
575 }
576
577 op.paramTypes =
578 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_MemrefInput,
579 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
580
581 op.params[0].context.ptr = context;
582 op.params[0].context.type = kSSCP_ParamContextType_SSS_Digest;
583
584 op.params[1].memref.buffer = (uintptr_t)message;
585 op.params[1].memref.size = messageLen;
586 op.params[2].memref.buffer = (uintptr_t)digest;
587 op.params[2].memref.size = len;
588
589 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ValueOutputSingle);
590 op.resultCount = 1u;
591 op.result[0].value.a = (uint32_t)digestLen;
592
593 sscp_context_t *sscpCtx = context->session->sscp;
594 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_DigestOneGo, &op, &ret);
595 if (status != kStatus_SSCP_Success)
596 {
597 ret = kStatus_SSS_Fail;
598 }
599
600 return (sss_status_t)ret;
601 }
602
sss_sscp_digest_init(sss_sscp_digest_t * context)603 sss_status_t sss_sscp_digest_init(sss_sscp_digest_t *context)
604 {
605 sscp_operation_t op = {0};
606 sscp_status_t status = kStatus_SSCP_Fail;
607 uint32_t ret = 0u;
608
609 op.paramTypes =
610 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
611 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
612
613 op.params[0].context.ptr = context;
614 op.params[0].context.type = kSSCP_ParamContextType_SSS_Digest;
615
616 sscp_context_t *sscpCtx = context->session->sscp;
617 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_DigestInit, &op, &ret);
618 if (status != kStatus_SSCP_Success)
619 {
620 ret = kStatus_SSS_Fail;
621 }
622
623 return (sss_status_t)ret;
624 }
625
sss_sscp_digest_update(sss_sscp_digest_t * context,uint8_t * message,size_t messageLen)626 sss_status_t sss_sscp_digest_update(sss_sscp_digest_t *context, uint8_t *message, size_t messageLen)
627 {
628 sscp_operation_t op = {0};
629 sscp_status_t status = kStatus_SSCP_Fail;
630 uint32_t ret = 0u;
631
632 op.paramTypes =
633 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_None,
634 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
635
636 op.params[0].context.ptr = context;
637 op.params[0].context.type = kSSCP_ParamContextType_SSS_Digest;
638
639 op.params[1].memref.buffer = (uintptr_t)message;
640 op.params[1].memref.size = messageLen;
641
642 sscp_context_t *sscpCtx = context->session->sscp;
643 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_DigestUpdate, &op, &ret);
644 if (status != kStatus_SSCP_Success)
645 {
646 ret = kStatus_SSS_Fail;
647 }
648
649 return (sss_status_t)ret;
650 }
651
sss_sscp_digest_finish(sss_sscp_digest_t * context,uint8_t * digest,size_t * digestLen)652 sss_status_t sss_sscp_digest_finish(sss_sscp_digest_t *context, uint8_t *digest, size_t *digestLen)
653 {
654 sscp_operation_t op = {0};
655 sscp_status_t status = kStatus_SSCP_Fail;
656 uint32_t ret = 0u;
657
658 /* if the caller gives NULL pointer to digestLen, it is assumed that digest[] buffer is big enough to hold full
659 * digest */
660 size_t len = (digestLen != NULL) ? *digestLen : context->digestFullLen;
661
662 /* if the *digestLen cannot hold full digest (per algorithm spec) return error */
663 if (len < context->digestFullLen)
664 {
665 return kStatus_SSS_Fail;
666 }
667
668 op.paramTypes =
669 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefOutput, kSSCP_ParamType_None,
670 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
671
672 op.params[0].context.ptr = context;
673 op.params[0].context.type = kSSCP_ParamContextType_SSS_Digest;
674
675 op.params[1].memref.buffer = (uintptr_t)digest;
676 op.params[1].memref.size = len;
677
678 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ValueOutputSingle);
679 op.resultCount = 1u;
680 op.result[0].value.a = (uint32_t)digestLen;
681
682 sscp_context_t *sscpCtx = context->session->sscp;
683 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_DigestFinish, &op, &ret);
684 if (status != kStatus_SSCP_Success)
685 {
686 if (digestLen != NULL)
687 {
688 *digestLen = 0u;
689 }
690 return kStatus_SSS_Fail;
691 }
692
693 /* the size member of kSSCP_ParamType_MemrefOutput param is updated with the actual byte length written to output
694 * buffer
695 */
696 if (digestLen != NULL)
697 {
698 *digestLen = op.params[1].memref.size;
699 }
700
701 return (sss_status_t)ret;
702 }
703
sss_sscp_digest_context_free(sss_sscp_digest_t * context)704 sss_status_t sss_sscp_digest_context_free(sss_sscp_digest_t *context)
705 {
706 sscp_operation_t op = {0};
707 sscp_status_t status = kStatus_SSCP_Fail;
708 uint32_t ret = 0u;
709
710 op.paramTypes =
711 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
712 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
713
714 op.params[0].context.ptr = context;
715 op.params[0].context.type = kSSCP_ParamContextType_SSS_Digest;
716
717 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
718 op.resultCount = 0u;
719
720 sscp_context_t *sscpCtx = context->session->sscp;
721 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_ContextFree, &op, &ret);
722 if (status != kStatus_SSCP_Success)
723 {
724 ret = kStatus_SSS_Fail;
725 }
726 return (sss_status_t)ret;
727 }
728
729 /***********************************MAC****************************************/
sss_sscp_mac_context_init(sss_sscp_mac_t * context,sss_sscp_session_t * session,sss_sscp_object_t * keyObject,sss_algorithm_t algorithm,sss_mode_t mode)730 sss_status_t sss_sscp_mac_context_init(sss_sscp_mac_t *context,
731 sss_sscp_session_t *session,
732 sss_sscp_object_t *keyObject,
733 sss_algorithm_t algorithm,
734 sss_mode_t mode)
735 {
736 SSCP_BUILD_ASSURE(sizeof(sss_mac_t) >= sizeof(sss_sscp_mac_t), _sss_sscp_mac_size);
737 sscp_operation_t op = {0};
738 sscp_status_t status = kStatus_SSCP_Fail;
739 uint32_t ret = 0u;
740
741 context->algorithm = algorithm;
742 context->mode = mode;
743 context->session = session;
744 context->keyObject = keyObject;
745
746 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ContextReference,
747 kSSCP_ParamType_ValueInputTuple, kSSCP_ParamType_None, kSSCP_ParamType_None,
748 kSSCP_ParamType_None, kSSCP_ParamType_None);
749
750 op.params[0].context.ptr = session;
751 op.params[0].context.type = kSSCP_ParamContextType_SSS_Session;
752
753 op.params[1].context.ptr = keyObject;
754 op.params[1].context.type = kSSCP_ParamContextType_SSS_Object;
755
756 op.params[2].value.a = (uint32_t)algorithm;
757 op.params[2].value.b = (uint32_t)mode;
758
759 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ContextReference);
760 op.resultCount = 1u;
761 op.result[0].context.ptr = context;
762 op.result[0].context.type = kSSCP_ParamContextType_SSS_Mac;
763
764 sscp_context_t *sscpCtx = session->sscp;
765 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_MacContextInit, &op, &ret);
766 if (status != kStatus_SSCP_Success)
767 {
768 ret = kStatus_SSS_Fail;
769 }
770 return (sss_status_t)ret;
771 }
772
sss_sscp_mac_one_go(sss_sscp_mac_t * context,const uint8_t * message,size_t messageLen,uint8_t * mac,size_t * macLen)773 sss_status_t sss_sscp_mac_one_go(
774 sss_sscp_mac_t *context, const uint8_t *message, size_t messageLen, uint8_t *mac, size_t *macLen)
775 {
776 SSCP_BUILD_ASSURE(sizeof(sss_mac_t) >= sizeof(sss_sscp_mac_t), _sss_sscp_mac_size);
777 sscp_operation_t op = {0};
778 sscp_status_t status = kStatus_SSCP_Fail;
779 uint32_t ret = 0u;
780 size_t macSize = (macLen != NULL) ? *macLen : 0u;
781
782 op.paramTypes =
783 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_MemrefInOut,
784 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
785
786 op.params[0].context.ptr = context;
787 op.params[0].context.type = kSSCP_ParamContextType_SSS_Mac;
788
789 op.params[1].memref.buffer = (uintptr_t)message;
790 op.params[1].memref.size = messageLen;
791 op.params[2].memref.buffer = (uintptr_t)mac;
792 op.params[2].memref.size = macSize;
793
794 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ValueOutputSingle);
795 op.resultCount = 1u;
796 op.result[0].value.a = (uint32_t)macLen;
797
798 sscp_context_t *sscpCtx = context->session->sscp;
799 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_MacOneGo, &op, &ret);
800 if (status != kStatus_SSCP_Success)
801 {
802 if (macLen != NULL)
803 {
804 *macLen = 0u;
805 }
806 ret = kStatus_SSS_Fail;
807 }
808 return (sss_status_t)ret;
809 }
810
sss_sscp_mac_init(sss_sscp_mac_t * context)811 sss_status_t sss_sscp_mac_init(sss_sscp_mac_t *context)
812 {
813 sscp_operation_t op = {0};
814 sscp_status_t status = kStatus_SSCP_Fail;
815 uint32_t ret = 0u;
816
817 op.paramTypes =
818 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
819 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
820
821 op.params[0].context.ptr = context;
822 op.params[0].context.type = kSSCP_ParamContextType_SSS_Mac;
823
824 sscp_context_t *sscpCtx = context->session->sscp;
825 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_MacInit, &op, &ret);
826 if (status != kStatus_SSCP_Success)
827 {
828 ret = kStatus_SSS_Fail;
829 }
830
831 return (sss_status_t)ret;
832 }
833
sss_sscp_mac_update(sss_sscp_mac_t * context,const uint8_t * message,size_t messageLen)834 sss_status_t sss_sscp_mac_update(sss_sscp_mac_t *context, const uint8_t *message, size_t messageLen)
835 {
836 sscp_operation_t op = {0};
837 sscp_status_t status = kStatus_SSCP_Fail;
838 uint32_t ret = 0u;
839
840 op.paramTypes =
841 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_None,
842 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
843
844 op.params[0].context.ptr = context;
845 op.params[0].context.type = kSSCP_ParamContextType_SSS_Mac;
846
847 op.params[1].memref.buffer = (uintptr_t)message;
848 op.params[1].memref.size = messageLen;
849
850 sscp_context_t *sscpCtx = context->session->sscp;
851 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_MacUpdate, &op, &ret);
852 if (status != kStatus_SSCP_Success)
853 {
854 ret = kStatus_SSS_Fail;
855 }
856
857 return (sss_status_t)ret;
858 }
859
sss_sscp_mac_finish(sss_sscp_mac_t * context,uint8_t * mac,size_t * macLen)860 sss_status_t sss_sscp_mac_finish(sss_sscp_mac_t *context, uint8_t *mac, size_t *macLen)
861 {
862 sscp_operation_t op = {0};
863 sscp_status_t status = kStatus_SSCP_Fail;
864 uint32_t ret = 0u;
865 size_t macSize = (macLen != NULL) ? *macLen : 0u;
866
867 op.paramTypes =
868 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefOutput, kSSCP_ParamType_None,
869 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
870
871 op.params[0].context.ptr = context;
872 op.params[0].context.type = kSSCP_ParamContextType_SSS_Mac;
873
874 op.params[1].memref.buffer = (uintptr_t)mac;
875 op.params[1].memref.size = macSize;
876
877 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ValueOutputSingle);
878 op.resultCount = 1u;
879 op.result[0].value.a = (uint32_t)macLen;
880
881 sscp_context_t *sscpCtx = context->session->sscp;
882 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_MacFinish, &op, &ret);
883 if (status != kStatus_SSCP_Success)
884 {
885 if (macLen != NULL)
886 {
887 *macLen = 0u;
888 }
889 ret = kStatus_SSS_Fail;
890 }
891 return (sss_status_t)ret;
892 }
893
sss_sscp_mac_context_free(sss_sscp_mac_t * context)894 sss_status_t sss_sscp_mac_context_free(sss_sscp_mac_t *context)
895 {
896 sscp_operation_t op = {0};
897 sscp_status_t status = kStatus_SSCP_Fail;
898 uint32_t ret = 0u;
899
900 op.paramTypes =
901 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
902 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
903
904 op.params[0].context.ptr = context;
905 op.params[0].context.type = kSSCP_ParamContextType_SSS_Mac;
906
907 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
908 op.resultCount = 0u;
909
910 sscp_context_t *sscpCtx = context->session->sscp;
911 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_ContextFree, &op, &ret);
912 if (status != kStatus_SSCP_Success)
913 {
914 ret = kStatus_SSS_Fail;
915 }
916 return (sss_status_t)ret;
917 }
918
919 /*******************************ASYMETRIC**************************************/
sss_sscp_asymmetric_context_init(sss_sscp_asymmetric_t * context,sss_sscp_session_t * session,sss_sscp_object_t * keyObject,sss_algorithm_t algorithm,sss_mode_t mode)920 sss_status_t sss_sscp_asymmetric_context_init(sss_sscp_asymmetric_t *context,
921 sss_sscp_session_t *session,
922 sss_sscp_object_t *keyObject,
923 sss_algorithm_t algorithm,
924 sss_mode_t mode)
925 {
926 SSCP_BUILD_ASSURE(sizeof(sss_digest_t) >= sizeof(sss_sscp_digest_t), _sss_sscp_digest_size);
927 sscp_operation_t op = {0};
928 sscp_status_t status = kStatus_SSCP_Fail;
929 uint32_t ret = 0u;
930
931 context->session = session;
932 context->keyObject = keyObject;
933 context->mode = mode;
934 context->algorithm = algorithm;
935
936 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ContextReference,
937 kSSCP_ParamType_ValueInputTuple, kSSCP_ParamType_None, kSSCP_ParamType_None,
938 kSSCP_ParamType_None, kSSCP_ParamType_None);
939
940 op.params[0].context.ptr = session;
941 op.params[0].context.type = kSSCP_ParamContextType_SSS_Session;
942
943 op.params[1].context.ptr = keyObject;
944 op.params[1].context.type = kSSCP_ParamContextType_SSS_Object;
945
946 op.params[2].value.a = (uint32_t)algorithm;
947 op.params[2].value.b = (uint32_t)mode;
948
949 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ContextReference);
950 op.resultCount = 1u;
951 op.result[0].context.ptr = context;
952 op.result[0].context.type = kSSCP_ParamContextType_SSS_Asymmetric;
953
954 sscp_context_t *sscpCtx = session->sscp;
955 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_AsymetricContextInit, &op, &ret);
956 if (status != kStatus_SSCP_Success)
957 {
958 ret = kStatus_SSS_Fail;
959 }
960 return (sss_status_t)ret;
961 }
962
sss_sscp_asymmetric_encrypt(sss_sscp_asymmetric_t * context,const uint8_t * srcData,size_t srcLen,uint8_t * destData,size_t * destLen)963 sss_status_t sss_sscp_asymmetric_encrypt(
964 sss_sscp_asymmetric_t *context, const uint8_t *srcData, size_t srcLen, uint8_t *destData, size_t *destLen)
965 {
966 SSCP_BUILD_ASSURE(sizeof(sss_asymmetric_t) >= sizeof(sss_sscp_asymmetric_t), _sss_sscp_asymmetric_size);
967 sscp_operation_t op = {0};
968 sscp_status_t status = kStatus_SSCP_Fail;
969 uint32_t ret = 0u;
970
971 /* if the caller gives NULL pointer to signatureLen, it is assumed that signature[] buffer is big enough to hold
972 * full
973 * signature */
974 size_t len = (destLen != NULL) ? *destLen : 0u;
975
976 /* if the *signatureLen cannot hold full signature (per algorithm spec) return error */
977 if (len < context->signatureFullLen)
978 {
979 return kStatus_SSS_Fail;
980 }
981
982 op.paramTypes =
983 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_MemrefOutput,
984 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
985
986 op.params[0].context.ptr = context;
987 op.params[0].context.type = kSSCP_ParamContextType_SSS_Asymmetric;
988
989 op.params[1].memref.buffer = (uintptr_t)srcData;
990 op.params[1].memref.size = srcLen;
991 op.params[2].memref.buffer = (uintptr_t)destData;
992 op.params[2].memref.size = len;
993
994 sscp_context_t *sscpCtx = context->session->sscp;
995 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_AsymmetricEncrypt, &op, &ret);
996 if (status != kStatus_SSCP_Success)
997 {
998 return kStatus_SSS_Fail;
999 }
1000
1001 /* the size member of kSSCP_ParamType_MemrefOutput param is updated with the actual byte length written to output
1002 * buffer
1003 */
1004 if (destLen != NULL)
1005 {
1006 *destLen = op.params[2].memref.size;
1007 }
1008
1009 return (sss_status_t)ret;
1010 }
1011
sss_sscp_asymmetric_decrypt(sss_sscp_asymmetric_t * context,const uint8_t * srcData,size_t srcLen,uint8_t * destData,size_t * destLen)1012 sss_status_t sss_sscp_asymmetric_decrypt(
1013 sss_sscp_asymmetric_t *context, const uint8_t *srcData, size_t srcLen, uint8_t *destData, size_t *destLen)
1014 {
1015 SSCP_BUILD_ASSURE(sizeof(sss_asymmetric_t) >= sizeof(sss_sscp_asymmetric_t), _sss_sscp_asymmetric_size);
1016 sscp_operation_t op = {0};
1017 sscp_status_t status = kStatus_SSCP_Fail;
1018 uint32_t ret = 0u;
1019
1020 /* if the caller gives NULL pointer to signatureLen, it is assumed that signature[] buffer is big enough to hold
1021 * full
1022 * signature */
1023 size_t len = (destLen != NULL) ? *destLen : 0u;
1024
1025 /* if the *signatureLen cannot hold full signature (per algorithm spec) return error */
1026 if (len < context->signatureFullLen)
1027 {
1028 return kStatus_SSS_Fail;
1029 }
1030
1031 op.paramTypes =
1032 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_MemrefOutput,
1033 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1034
1035 op.params[0].context.ptr = context;
1036 op.params[0].context.type = kSSCP_ParamContextType_SSS_Asymmetric;
1037
1038 op.params[1].memref.buffer = (uintptr_t)srcData;
1039 op.params[1].memref.size = srcLen;
1040 op.params[2].memref.buffer = (uintptr_t)destData;
1041 op.params[2].memref.size = len;
1042
1043 sscp_context_t *sscpCtx = context->session->sscp;
1044 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_AsymmetricDecrypt, &op, &ret);
1045 if (status != kStatus_SSCP_Success)
1046 {
1047 return kStatus_SSS_Fail;
1048 }
1049
1050 /* the size member of kSSCP_ParamType_MemrefOutput param is updated with the actual byte length written to output
1051 * buffer
1052 */
1053 if (destLen != NULL)
1054 {
1055 *destLen = op.params[2].memref.size;
1056 }
1057
1058 return (sss_status_t)ret;
1059 }
1060
sss_sscp_asymmetric_sign_digest(sss_sscp_asymmetric_t * context,uint8_t * digest,size_t digestLen,uint8_t * signature,size_t * signatureLen)1061 sss_status_t sss_sscp_asymmetric_sign_digest(
1062 sss_sscp_asymmetric_t *context, uint8_t *digest, size_t digestLen, uint8_t *signature, size_t *signatureLen)
1063 {
1064 SSCP_BUILD_ASSURE(sizeof(sss_asymmetric_t) >= sizeof(sss_sscp_asymmetric_t), _sss_sscp_asymmetric_size);
1065 sscp_operation_t op = {0};
1066 sscp_status_t status = kStatus_SSCP_Fail;
1067 uint32_t ret = 0u;
1068
1069 /* if the caller gives NULL pointer to signatureLen, it is assumed that signature[] buffer is big enough to hold
1070 * full
1071 * signature */
1072 /*size_t len = (signatureLen != NULL) ? *signatureLen : context->signatureFullLen;*/
1073
1074 /* if the *signatureLen cannot hold full signature (per algorithm spec) return error */
1075 /*if (len < context->signatureFullLen)
1076 {
1077 return kStatus_SSS_Fail;
1078 }*/
1079
1080 op.paramTypes =
1081 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_MemrefOutput,
1082 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1083
1084 op.params[0].context.ptr = context;
1085 op.params[0].context.type = kSSCP_ParamContextType_SSS_Asymmetric;
1086
1087 op.params[1].memref.buffer = (uintptr_t)digest;
1088 op.params[1].memref.size = digestLen;
1089 op.params[2].memref.buffer = (uintptr_t)signature;
1090 op.params[2].memref.size = *signatureLen;
1091
1092 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ValueOutputSingle);
1093 op.resultCount = 1u;
1094 op.result[0].value.a = (uint32_t)signatureLen;
1095
1096 sscp_context_t *sscpCtx = context->session->sscp;
1097 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_AsymmetricSignDigest, &op, &ret);
1098 if (status != kStatus_SSCP_Success)
1099 {
1100 ret = kStatus_SSS_Fail;
1101 }
1102 return (sss_status_t)ret;
1103 }
1104
sss_sscp_asymmetric_verify_digest(sss_sscp_asymmetric_t * context,uint8_t * digest,size_t digestLen,uint8_t * signature,size_t signatureLen)1105 sss_status_t sss_sscp_asymmetric_verify_digest(
1106 sss_sscp_asymmetric_t *context, uint8_t *digest, size_t digestLen, uint8_t *signature, size_t signatureLen)
1107 {
1108 sscp_operation_t op = {0};
1109 sscp_status_t status = kStatus_SSCP_Fail;
1110 uint32_t ret = 0u;
1111
1112 op.paramTypes =
1113 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_MemrefInput,
1114 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1115
1116 op.params[0].context.ptr = context;
1117 op.params[0].context.type = kSSCP_ParamContextType_SSS_Asymmetric;
1118
1119 /* common function parameters */
1120 op.params[1].memref.buffer = (uintptr_t)digest;
1121 op.params[1].memref.size = digestLen;
1122 op.params[2].memref.buffer = (uintptr_t)signature;
1123 op.params[2].memref.size = signatureLen;
1124
1125 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1126 op.resultCount = 0u;
1127
1128 sscp_context_t *sscpCtx = context->session->sscp;
1129 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_AsymmetricVerifyDigest, &op, &ret);
1130 if (status != kStatus_SSCP_Success)
1131 {
1132 return kStatus_SSS_Fail;
1133 }
1134
1135 return (sss_status_t)ret;
1136 }
1137
sss_sscp_asymmetric_context_free(sss_sscp_asymmetric_t * context)1138 sss_status_t sss_sscp_asymmetric_context_free(sss_sscp_asymmetric_t *context)
1139 {
1140 sscp_operation_t op = {0};
1141 sscp_status_t status = kStatus_SSCP_Fail;
1142 uint32_t ret = 0u;
1143
1144 op.paramTypes =
1145 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
1146 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1147
1148 op.params[0].context.ptr = context;
1149 op.params[0].context.type = kSSCP_ParamContextType_SSS_Asymmetric;
1150
1151 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1152 op.resultCount = 0u;
1153
1154 sscp_context_t *sscpCtx = context->session->sscp;
1155 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_ContextFree, &op, &ret);
1156 if (status != kStatus_SSCP_Success)
1157 {
1158 return kStatus_SSS_Fail;
1159 }
1160 return (sss_status_t)ret;
1161 }
1162
1163 /********************************TUNNEL****************************************/
sss_sscp_tunnel_context_init(sss_sscp_tunnel_t * context,sss_sscp_session_t * session,uint32_t tunnelType)1164 sss_status_t sss_sscp_tunnel_context_init(sss_sscp_tunnel_t *context, sss_sscp_session_t *session, uint32_t tunnelType)
1165 {
1166 SSCP_BUILD_ASSURE(sizeof(sss_tunnel_t) >= sizeof(sss_sscp_tunnel_t), _sss_sscp_tunnel_size);
1167 sscp_operation_t op = {0};
1168 sscp_status_t status = kStatus_SSCP_Fail;
1169 uint32_t ret = 0u;
1170
1171 context->session = session;
1172 context->tunnelType = tunnelType;
1173
1174 op.paramTypes =
1175 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ValueInputSingle, kSSCP_ParamType_None,
1176 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1177
1178 op.params[0].context.ptr = session;
1179 op.params[0].context.type = kSSCP_ParamContextType_SSS_Session;
1180
1181 op.params[1].value.a = tunnelType;
1182
1183 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ContextReference);
1184 op.resultCount = 1u;
1185 op.result[0].context.ptr = context;
1186 op.result[0].context.type = kSSCP_ParamContextType_SSS_Tunnel;
1187
1188 sscp_context_t *sscpCtx = context->session->sscp;
1189 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_TunnelContextInit, &op, &ret);
1190
1191 if (status != kStatus_SSCP_Success)
1192 {
1193 return kStatus_SSS_Fail;
1194 }
1195
1196 return (sss_status_t)ret;
1197 }
1198
sss_sscp_tunnel(sss_sscp_tunnel_t * context,uint8_t * data,size_t dataLen,uint32_t * resultState)1199 sss_status_t sss_sscp_tunnel(sss_sscp_tunnel_t *context, uint8_t *data, size_t dataLen, uint32_t *resultState)
1200 {
1201 SSCP_BUILD_ASSURE(sizeof(sss_tunnel_t) >= sizeof(sss_sscp_tunnel_t), _sss_sscp_tunnel_size);
1202 sscp_operation_t op = {0};
1203 sscp_status_t status = kStatus_SSCP_Fail;
1204 uint32_t ret = 0u;
1205
1206 if ((context->tunnelType & SSS_SSCP_TUNNEL_HAVE_BUFFER_MASK) == SSS_SSCP_TUNNEL_HAVE_BUFFER_MASK)
1207 {
1208 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput,
1209 kSSCP_ParamType_MemrefInput, kSSCP_ParamType_None, kSSCP_ParamType_None,
1210 kSSCP_ParamType_None, kSSCP_ParamType_None);
1211 op.params[2].memref.buffer = (uintptr_t)context->buffer;
1212 op.params[2].memref.size = context->bufferSize;
1213 }
1214 else
1215 {
1216 op.paramTypes =
1217 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput, kSSCP_ParamType_None,
1218 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1219 }
1220
1221 op.params[0].context.ptr = context;
1222 op.params[0].context.type = kSSCP_ParamContextType_SSS_Tunnel;
1223
1224 op.params[1].memref.buffer = (uintptr_t)data;
1225 op.params[1].memref.size = dataLen;
1226
1227 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ValueOutputSingle);
1228 op.resultCount = 1u;
1229 op.result[0].value.a = (uint32_t)resultState;
1230
1231 sscp_context_t *sscpCtx = context->session->sscp;
1232 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_Tunnel, &op, &ret);
1233 if (status != kStatus_SSCP_Success)
1234 {
1235 return kStatus_SSS_Fail;
1236 }
1237
1238 return (sss_status_t)ret;
1239 }
1240
sss_sscp_tunnel_context_free(sss_sscp_tunnel_t * context)1241 sss_status_t sss_sscp_tunnel_context_free(sss_sscp_tunnel_t *context)
1242 {
1243 sscp_operation_t op = {0};
1244 sscp_status_t status = kStatus_SSCP_Fail;
1245 uint32_t ret = 0u;
1246
1247 op.paramTypes =
1248 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
1249 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1250
1251 op.params[0].context.ptr = context;
1252 op.params[0].context.type = kSSCP_ParamContextType_SSS_Tunnel;
1253
1254 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1255 op.resultCount = 0u;
1256
1257 sscp_context_t *sscpCtx = context->session->sscp;
1258 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_ContextFree, &op, &ret);
1259 if (status != kStatus_SSCP_Success)
1260 {
1261 return kStatus_SSS_Fail;
1262 }
1263 return (sss_status_t)ret;
1264 }
1265
1266 /*******************************DERIVEKEY**************************************/
sss_sscp_derive_key_context_init(sss_sscp_derive_key_t * context,sss_sscp_session_t * session,sss_sscp_object_t * keyObject,sss_algorithm_t algorithm,sss_mode_t mode)1267 sss_status_t sss_sscp_derive_key_context_init(sss_sscp_derive_key_t *context,
1268 sss_sscp_session_t *session,
1269 sss_sscp_object_t *keyObject,
1270 sss_algorithm_t algorithm,
1271 sss_mode_t mode)
1272 {
1273 sscp_operation_t op = {0};
1274 sscp_status_t status = kStatus_SSCP_Fail;
1275 uint32_t ret = 0u;
1276
1277 context->algorithm = algorithm;
1278 context->mode = mode;
1279 context->session = session;
1280 context->keyObject = keyObject;
1281
1282 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ContextReference,
1283 kSSCP_ParamType_ValueInputTuple, kSSCP_ParamType_None, kSSCP_ParamType_None,
1284 kSSCP_ParamType_None, kSSCP_ParamType_None);
1285
1286 op.params[0].context.ptr = session;
1287 op.params[0].context.type = kSSCP_ParamContextType_SSS_Session;
1288
1289 op.params[1].context.ptr = keyObject;
1290 op.params[1].context.type = kSSCP_ParamContextType_SSS_Object;
1291
1292 op.params[2].value.a = (uint32_t)algorithm;
1293 op.params[2].value.b = (uint32_t)mode;
1294
1295 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ContextReference);
1296 op.resultCount = 1u;
1297 op.result[0].context.ptr = context;
1298 op.result[0].context.type = kSSCP_ParamContextType_SSS_DeriveKey;
1299
1300 sscp_context_t *sscpCtx = context->session->sscp;
1301 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_DeriveKeyContextInit, &op, &ret);
1302 if (status != kStatus_SSCP_Success)
1303 {
1304 return kStatus_SSS_Fail;
1305 }
1306
1307 return (sss_status_t)ret;
1308 }
1309
sss_sscp_derive_key(sss_sscp_derive_key_t * context,const uint8_t * saltData,size_t saltLen,sss_sscp_object_t * derivedKeyObject)1310 sss_status_t sss_sscp_derive_key(sss_sscp_derive_key_t *context,
1311 const uint8_t *saltData,
1312 size_t saltLen,
1313 sss_sscp_object_t *derivedKeyObject)
1314 {
1315 sscp_operation_t op = {0};
1316 sscp_status_t status = kStatus_SSCP_Fail;
1317 uint32_t ret = 0u;
1318
1319 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInput,
1320 kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
1321 kSSCP_ParamType_None, kSSCP_ParamType_None);
1322
1323 op.params[0].context.ptr = context;
1324 op.params[0].context.type = kSSCP_ParamContextType_SSS_DeriveKey;
1325
1326 op.params[1].memref.buffer = (uintptr_t)saltData;
1327 op.params[1].memref.size = saltLen;
1328
1329 op.params[2].context.ptr = derivedKeyObject;
1330 op.params[2].context.type = kSSCP_ParamContextType_SSS_Object;
1331
1332 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1333 op.resultCount = 1u;
1334
1335 sscp_context_t *sscpCtx = context->session->sscp;
1336 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_DeriveKey, &op, &ret);
1337 if (status != kStatus_SSCP_Success)
1338 {
1339 return kStatus_SSS_Fail;
1340 }
1341
1342 return (sss_status_t)ret;
1343 }
1344
sss_sscp_asymmetric_dh_derive_key(sss_sscp_derive_key_t * context,sss_sscp_object_t * otherPartyKeyObject,sss_sscp_object_t * derivedKeyObject)1345 sss_status_t sss_sscp_asymmetric_dh_derive_key(sss_sscp_derive_key_t *context,
1346 sss_sscp_object_t *otherPartyKeyObject,
1347 sss_sscp_object_t *derivedKeyObject)
1348 {
1349 SSCP_BUILD_ASSURE(sizeof(sss_derive_key_t) >= sizeof(sss_sscp_derive_key_t), _sss_sscp_derive_key_size);
1350 sscp_operation_t op = {0};
1351 sscp_status_t status = kStatus_SSCP_Fail;
1352 uint32_t ret = 0u;
1353
1354 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ContextReference,
1355 kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
1356 kSSCP_ParamType_None, kSSCP_ParamType_None);
1357
1358 op.params[0].context.ptr = context;
1359 op.params[0].context.type = kSSCP_ParamContextType_SSS_DeriveKey;
1360
1361 op.params[1].context.ptr = otherPartyKeyObject;
1362 op.params[1].context.type = kSSCP_ParamContextType_SSS_Object;
1363
1364 op.params[2].context.ptr = derivedKeyObject;
1365 op.params[2].context.type = kSSCP_ParamContextType_SSS_Object;
1366
1367 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1368 op.resultCount = 1u;
1369
1370 sscp_context_t *sscpCtx = context->session->sscp;
1371 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_AsymmetricDeriveKey, &op, &ret);
1372 if (status != kStatus_SSCP_Success)
1373 {
1374 return kStatus_SSS_Fail;
1375 }
1376
1377 return (sss_status_t)ret;
1378 }
1379
sss_sscp_derive_key_context_free(sss_sscp_derive_key_t * context)1380 sss_status_t sss_sscp_derive_key_context_free(sss_sscp_derive_key_t *context)
1381 {
1382 sscp_operation_t op = {0};
1383 sscp_status_t status = kStatus_SSCP_Fail;
1384 uint32_t ret = 0u;
1385
1386 op.paramTypes =
1387 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
1388 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1389
1390 op.params[0].context.ptr = context;
1391 op.params[0].context.type = kSSCP_ParamContextType_SSS_DeriveKey;
1392
1393 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1394 op.resultCount = 0u;
1395
1396 sscp_context_t *sscpCtx = context->session->sscp;
1397 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_ContextFree, &op, &ret);
1398 if (status != kStatus_SSCP_Success)
1399 {
1400 return kStatus_SSS_Fail;
1401 }
1402 return (sss_status_t)ret;
1403 }
1404
1405 /*******************************KEYSTORE***************************************/
sss_sscp_key_store_init(sss_sscp_key_store_t * keyStore,sss_sscp_session_t * session)1406 sss_status_t sss_sscp_key_store_init(sss_sscp_key_store_t *keyStore, sss_sscp_session_t *session)
1407 {
1408 SSCP_BUILD_ASSURE(sizeof(sss_key_store_t) >= sizeof(sss_sscp_key_store_t), _sss_sscp_key_store_size);
1409 sscp_operation_t op = {0};
1410 sscp_status_t status = kStatus_SSCP_Fail;
1411 uint32_t ret = 0u;
1412
1413 keyStore->session = session;
1414 keyStore->keyStoreId = 0u;
1415
1416 op.paramTypes =
1417 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ValueInputSingle, kSSCP_ParamType_None,
1418 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1419
1420 op.params[0].context.ptr = session;
1421 op.params[0].context.type = kSSCP_ParamContextType_SSS_Session;
1422
1423 op.params[1].value.a = keyStore->keyStoreId;
1424
1425 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ContextReference);
1426 op.resultCount = 1u;
1427 op.result[0].context.ptr = keyStore;
1428 op.result[0].context.type = kSSCP_ParamContextType_SSS_KeyStore;
1429
1430 sscp_context_t *sscpCtx = keyStore->session->sscp;
1431 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyStoreContextInit, &op, &ret);
1432 if (status != kStatus_SSCP_Success)
1433 {
1434 return kStatus_SSS_Fail;
1435 }
1436
1437 return (sss_status_t)ret;
1438 }
1439
sss_sscp_key_store_set_key(sss_sscp_key_store_t * keyStore,sss_sscp_object_t * keyObject,const uint8_t * data,size_t dataLen,uint32_t keyBitLen,sss_key_part_t keyPart)1440 sss_status_t sss_sscp_key_store_set_key(sss_sscp_key_store_t *keyStore,
1441 sss_sscp_object_t *keyObject,
1442 const uint8_t *data,
1443 size_t dataLen,
1444 uint32_t keyBitLen,
1445 sss_key_part_t keyPart)
1446 {
1447 sscp_operation_t op = {0};
1448 sscp_status_t status = kStatus_SSCP_Fail;
1449 uint32_t ret = 0u;
1450
1451 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ContextReference,
1452 kSSCP_ParamType_MemrefInput, kSSCP_ParamType_ValueInputTuple,
1453 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1454
1455 op.params[0].context.ptr = keyStore;
1456 op.params[0].context.type = kSSCP_ParamContextType_SSS_KeyStore;
1457
1458 op.params[1].context.ptr = keyObject;
1459 op.params[1].context.type = kSSCP_ParamContextType_SSS_Object;
1460
1461 op.params[2].memref.buffer = (uintptr_t)data;
1462 op.params[2].memref.size = dataLen;
1463
1464 op.params[3].value.a = keyBitLen;
1465 op.params[3].value.b = keyPart;
1466
1467 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1468 op.resultCount = 0u;
1469
1470 sscp_context_t *sscpCtx = keyStore->session->sscp;
1471 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyStoreSetKey, &op, &ret);
1472 if (status != kStatus_SSCP_Success)
1473 {
1474 return kStatus_SSS_Fail;
1475 }
1476
1477 return (sss_status_t)ret;
1478 }
1479
sss_sscp_key_store_get_key(sss_sscp_key_store_t * keyStore,sss_sscp_object_t * keyObject,uint8_t * data,size_t * dataLen,size_t * pKeyBitLen,sss_key_part_t keyPart)1480 sss_status_t sss_sscp_key_store_get_key(sss_sscp_key_store_t *keyStore,
1481 sss_sscp_object_t *keyObject,
1482 uint8_t *data,
1483 size_t *dataLen,
1484 size_t *pKeyBitLen,
1485 sss_key_part_t keyPart)
1486 {
1487 sscp_operation_t op = {0};
1488 sscp_status_t status = kStatus_SSCP_Fail;
1489 uint32_t ret = 0u;
1490
1491 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ContextReference,
1492 kSSCP_ParamType_MemrefOutput, kSSCP_ParamType_MemrefOutputNoSize,
1493 kSSCP_ParamType_ValueInputSingle, kSSCP_ParamType_None, kSSCP_ParamType_None);
1494
1495 op.params[0].context.ptr = keyStore;
1496 op.params[0].context.type = kSSCP_ParamContextType_SSS_KeyStore;
1497
1498 op.params[1].context.ptr = keyObject;
1499 op.params[1].context.type = kSSCP_ParamContextType_SSS_Object;
1500
1501 op.params[2].memref.buffer = (uintptr_t)data;
1502 op.params[2].memref.size = *dataLen;
1503
1504 op.params[3].memref.buffer = (uintptr_t)pKeyBitLen;
1505
1506 op.params[4].value.a = keyPart;
1507
1508 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ValueOutputSingle);
1509 op.resultCount = 1u;
1510 op.result[0].value.a = (uint32_t)dataLen;
1511
1512 sscp_context_t *sscpCtx = keyStore->session->sscp;
1513 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyStoreGetKey, &op, &ret);
1514 if (status != kStatus_SSCP_Success)
1515 {
1516 return kStatus_SSS_Fail;
1517 }
1518
1519 return (sss_status_t)ret;
1520 }
1521
sss_sscp_key_store_import_key(sss_sscp_key_store_t * keyStore,sss_sscp_object_t * keyObject,const uint8_t * data,size_t dataLen,uint32_t keyBitLen,sss_sscp_blob_type_t blobType)1522 sss_status_t sss_sscp_key_store_import_key(sss_sscp_key_store_t *keyStore,
1523 sss_sscp_object_t *keyObject,
1524 const uint8_t *data,
1525 size_t dataLen,
1526 uint32_t keyBitLen,
1527 sss_sscp_blob_type_t blobType)
1528 {
1529 sscp_operation_t op = {0};
1530 sscp_status_t status = kStatus_SSCP_Fail;
1531 uint32_t ret = 0u;
1532
1533 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ContextReference,
1534 kSSCP_ParamType_MemrefInput, kSSCP_ParamType_ValueInputSingle,
1535 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1536
1537 op.params[0].context.ptr = keyStore;
1538 op.params[0].context.type = kSSCP_ParamContextType_SSS_KeyStore;
1539
1540 op.params[1].context.ptr = keyObject;
1541 op.params[1].context.type = kSSCP_ParamContextType_SSS_Object;
1542
1543 op.params[2].memref.buffer = (uintptr_t)data;
1544 op.params[2].memref.size = dataLen;
1545
1546 op.params[3].value.a = blobType;
1547
1548 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1549 op.resultCount = 0u;
1550
1551 sscp_context_t *sscpCtx = keyStore->session->sscp;
1552 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyStoreImportKey, &op, &ret);
1553 if (status != kStatus_SSCP_Success)
1554 {
1555 return kStatus_SSS_Fail;
1556 }
1557
1558 return (sss_status_t)ret;
1559 }
1560
sss_sscp_key_store_export_key(sss_sscp_key_store_t * keyStore,sss_sscp_object_t * keyObject,uint8_t * data,size_t * dataLen,sss_sscp_blob_type_t blobType)1561 sss_status_t sss_sscp_key_store_export_key(sss_sscp_key_store_t *keyStore,
1562 sss_sscp_object_t *keyObject,
1563 uint8_t *data,
1564 size_t *dataLen,
1565 sss_sscp_blob_type_t blobType)
1566 {
1567 sscp_operation_t op = {0};
1568 sscp_status_t status = kStatus_SSCP_Fail;
1569 uint32_t ret = 0u;
1570
1571 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ContextReference,
1572 kSSCP_ParamType_MemrefOutput, kSSCP_ParamType_ValueInputSingle,
1573 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1574
1575 op.params[0].context.ptr = keyStore;
1576 op.params[0].context.type = kSSCP_ParamContextType_SSS_KeyStore;
1577
1578 op.params[1].context.ptr = keyObject;
1579 op.params[1].context.type = kSSCP_ParamContextType_SSS_Object;
1580
1581 op.params[2].memref.buffer = (uintptr_t)data;
1582 op.params[2].memref.size = *dataLen;
1583
1584 op.params[3].value.a = blobType;
1585
1586 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ValueOutputSingle);
1587 op.resultCount = 1u;
1588 op.result[0].value.a = (uint32_t)dataLen;
1589
1590 sscp_context_t *sscpCtx = keyStore->session->sscp;
1591 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyStoreExportKey, &op, &ret);
1592 if (status != kStatus_SSCP_Success)
1593 {
1594 return kStatus_SSS_Fail;
1595 }
1596
1597 return (sss_status_t)ret;
1598 }
1599
sss_sscp_key_store_open_key(sss_sscp_key_store_t * keyStore,sss_sscp_object_t * keyObject)1600 sss_status_t sss_sscp_key_store_open_key(sss_sscp_key_store_t *keyStore, sss_sscp_object_t *keyObject)
1601 {
1602 sscp_operation_t op = {0};
1603 sscp_status_t status = kStatus_SSCP_Fail;
1604 uint32_t ret = 0u;
1605
1606 op.paramTypes =
1607 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ContextReference, kSSCP_ParamType_None,
1608 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1609
1610 op.params[0].context.ptr = keyStore;
1611 op.params[0].context.type = kSSCP_ParamContextType_SSS_KeyStore;
1612
1613 op.params[1].context.ptr = keyObject;
1614 op.params[1].context.type = kSSCP_ParamContextType_SSS_Object;
1615
1616 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1617 op.resultCount = 0u;
1618
1619 sscp_context_t *sscpCtx = keyStore->session->sscp;
1620 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyStoreOpenKey, &op, &ret);
1621 if (status != kStatus_SSCP_Success)
1622 {
1623 return kStatus_SSS_Fail;
1624 }
1625
1626 return (sss_status_t)ret;
1627 }
1628
sss_sscp_key_store_open_internal_key(sss_sscp_key_store_t * keyStore,sss_internal_keyID_t keyID)1629 sss_status_t sss_sscp_key_store_open_internal_key(sss_sscp_key_store_t *keyStore, sss_internal_keyID_t keyID)
1630 {
1631 sscp_operation_t op = {0};
1632 sscp_status_t status = kStatus_SSCP_Fail;
1633 uint32_t ret = 0u;
1634
1635 op.paramTypes =
1636 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ValueInputSingle, kSSCP_ParamType_None,
1637 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1638
1639 op.params[0].context.ptr = keyStore;
1640 op.params[0].context.type = kSSCP_ParamContextType_SSS_KeyStore;
1641
1642 op.params[1].value.a = keyID;
1643
1644 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1645 op.resultCount = 0u;
1646
1647 sscp_context_t *sscpCtx = keyStore->session->sscp;
1648 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyStoreOpenKey, &op, &ret);
1649 if (status != kStatus_SSCP_Success)
1650 {
1651 return kStatus_SSS_Fail;
1652 }
1653
1654 return (sss_status_t)ret;
1655 }
1656
sss_sscp_key_store_generate_key(sss_sscp_key_store_t * keyStore,sss_sscp_object_t * keyObject,size_t keyBitLen,void * options)1657 sss_status_t sss_sscp_key_store_generate_key(sss_sscp_key_store_t *keyStore,
1658 sss_sscp_object_t *keyObject,
1659 size_t keyBitLen,
1660 void *options)
1661 {
1662 sscp_operation_t op = {0};
1663 sscp_status_t status = kStatus_SSCP_Fail;
1664 uint32_t ret = 0u;
1665
1666 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ContextReference,
1667 kSSCP_ParamType_ValueInputSingle, kSSCP_ParamType_None, kSSCP_ParamType_None,
1668 kSSCP_ParamType_None, kSSCP_ParamType_None);
1669
1670 op.params[0].context.ptr = keyStore;
1671 op.params[0].context.type = kSSCP_ParamContextType_SSS_KeyStore;
1672
1673 op.params[1].context.ptr = keyObject;
1674 op.params[1].context.type = kSSCP_ParamContextType_SSS_Object;
1675
1676 op.params[2].value.a = keyBitLen;
1677
1678 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1679 op.resultCount = 0u;
1680
1681 sscp_context_t *sscpCtx = keyStore->session->sscp;
1682 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyStoreGenerateKey, &op, &ret);
1683 if (status != kStatus_SSCP_Success)
1684 {
1685 return kStatus_SSS_Fail;
1686 }
1687
1688 return (sss_status_t)ret;
1689 }
1690
sss_sscp_key_store_erase_key(sss_sscp_key_store_t * keyStore,sss_sscp_object_t * keyObject)1691 sss_status_t sss_sscp_key_store_erase_key(sss_sscp_key_store_t *keyStore, sss_sscp_object_t *keyObject)
1692 {
1693 sscp_operation_t op = {0};
1694 sscp_status_t status = kStatus_SSCP_Fail;
1695 uint32_t ret = 0u;
1696
1697 op.paramTypes =
1698 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ContextReference, kSSCP_ParamType_None,
1699 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1700
1701 op.params[0].context.ptr = keyStore;
1702 op.params[0].context.type = kSSCP_ParamContextType_SSS_KeyStore;
1703
1704 op.params[1].context.ptr = keyObject;
1705 op.params[1].context.type = kSSCP_ParamContextType_SSS_Object;
1706
1707 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1708 op.resultCount = 0u;
1709
1710 sscp_context_t *sscpCtx = keyStore->session->sscp;
1711 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyStoreEraseKey, &op, &ret);
1712 if (status != kStatus_SSCP_Success)
1713 {
1714 return kStatus_SSS_Fail;
1715 }
1716
1717 return (sss_status_t)ret;
1718 }
1719
sss_sscp_key_store_erase_all(sss_sscp_key_store_t * keyStore)1720 sss_status_t sss_sscp_key_store_erase_all(sss_sscp_key_store_t *keyStore)
1721 {
1722 sscp_operation_t op = {0};
1723 sscp_status_t status = kStatus_SSCP_Fail;
1724 uint32_t ret = 0u;
1725
1726 op.paramTypes =
1727 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
1728 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1729
1730 op.params[0].context.ptr = keyStore;
1731 op.params[0].context.type = kSSCP_ParamContextType_SSS_KeyStore;
1732
1733 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1734 op.resultCount = 0u;
1735
1736 sscp_context_t *sscpCtx = keyStore->session->sscp;
1737 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyStoreEraseAll, &op, &ret);
1738 if (status != kStatus_SSCP_Success)
1739 {
1740 return kStatus_SSS_Fail;
1741 }
1742
1743 return (sss_status_t)ret;
1744 }
1745
sss_sscp_key_store_free(sss_sscp_key_store_t * keyStore)1746 sss_status_t sss_sscp_key_store_free(sss_sscp_key_store_t *keyStore)
1747 {
1748 sscp_operation_t op = {0};
1749 sscp_status_t status = kStatus_SSCP_Fail;
1750 uint32_t ret = 0u;
1751
1752 op.paramTypes =
1753 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
1754 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1755
1756 op.params[0].context.ptr = keyStore;
1757 op.params[0].context.type = kSSCP_ParamContextType_SSS_KeyStore;
1758
1759 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1760 op.resultCount = 0u;
1761
1762 sscp_context_t *sscpCtx = keyStore->session->sscp;
1763 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyStoreContextFree, &op, &ret);
1764 if (status != kStatus_SSCP_Success)
1765 {
1766 return kStatus_SSS_Fail;
1767 }
1768 return (sss_status_t)ret;
1769 }
1770
sss_sscp_key_store_get_property(sss_sscp_key_store_t * keyStore,sss_sscp_key_store_property_t propertyId,uint32_t * property)1771 sss_status_t sss_sscp_key_store_get_property(sss_sscp_key_store_t *keyStore,
1772 sss_sscp_key_store_property_t propertyId,
1773 uint32_t *property)
1774 {
1775 sscp_operation_t op = {0};
1776 sscp_status_t status = kStatus_SSCP_Fail;
1777 uint32_t ret = 0u;
1778
1779 op.paramTypes =
1780 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ValueInputSingle, kSSCP_ParamType_None,
1781 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1782
1783 op.params[0].context.ptr = keyStore;
1784 op.params[0].context.type = kSSCP_ParamContextType_SSS_KeyStore;
1785
1786 op.params[1].value.a = propertyId;
1787
1788 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ValueOutputSingle);
1789 op.resultCount = 1u;
1790 op.result[0].value.a = (uint32_t)property;
1791
1792 sscp_context_t *sscpCtx = keyStore->session->sscp;
1793 if ((sscpCtx == NULL) || (sscpCtx->invoke == NULL))
1794 {
1795 return kStatus_SSS_Fail;
1796 }
1797 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyStoreGetProperty, &op, &ret);
1798 if (status != kStatus_SSCP_Success)
1799 {
1800 return kStatus_SSS_Fail;
1801 }
1802
1803 return (sss_status_t)ret;
1804 }
1805 /*********************************RNG******************************************/
sss_sscp_rng_context_init(sss_sscp_session_t * session,sss_sscp_rng_t * context,uint32_t rngTypeSpecifier)1806 sss_status_t sss_sscp_rng_context_init(sss_sscp_session_t *session, sss_sscp_rng_t *context, uint32_t rngTypeSpecifier)
1807 {
1808 context->session = session;
1809 context->rngTypeSpecifier = rngTypeSpecifier;
1810 return kStatus_SSS_Success;
1811 }
1812
sss_sscp_rng_get_random(sss_sscp_rng_t * context,uint8_t * random_data,size_t dataLen)1813 sss_status_t sss_sscp_rng_get_random(sss_sscp_rng_t *context, uint8_t *random_data, size_t dataLen)
1814 {
1815 sscp_operation_t op = {0};
1816 sscp_status_t status = kStatus_SSCP_Fail;
1817 uint32_t ret = 0u;
1818
1819 op.paramTypes =
1820 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_MemrefInOut, kSSCP_ParamType_None,
1821 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1822
1823 op.params[0].context.ptr = context;
1824 op.params[0].context.type = kSSCP_ParamContextType_SSS_Rng;
1825
1826 op.params[1].memref.buffer = (uintptr_t)random_data;
1827 op.params[1].memref.size = dataLen;
1828
1829 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1830 op.resultCount = 0u;
1831
1832 sscp_context_t *sscpCtx = context->session->sscp;
1833 status = sscpCtx->invoke(sscpCtx, KSSCP_CMD_SSS_RngGet, &op, &ret);
1834 if (status != kStatus_SSCP_Success)
1835 {
1836 return kStatus_SSS_Fail;
1837 }
1838
1839 return (sss_status_t)ret;
1840 }
1841
sss_sscp_rng_free(sss_sscp_rng_t * context)1842 sss_status_t sss_sscp_rng_free(sss_sscp_rng_t *context)
1843 {
1844 /* clean the rng context */
1845 (void)memset(context, 0, sizeof(sss_sscp_rng_t));
1846 return kStatus_SSS_Success;
1847 }
1848
1849 /******************************KEYOBJECT***************************************/
sss_sscp_key_object_init_internal(sss_sscp_object_t * keyObject,sss_sscp_key_store_t * keyStore)1850 sss_status_t sss_sscp_key_object_init_internal(sss_sscp_object_t *keyObject, sss_sscp_key_store_t *keyStore)
1851 {
1852 SSCP_BUILD_ASSURE(sizeof(sss_object_t) >= sizeof(sss_sscp_object_t), _sss_sscp_key_object_size);
1853 keyObject->keyStore = keyStore;
1854 keyObject->objectType = 0u; /* object type: key */
1855
1856 return kStatus_SSS_Success;
1857 }
1858
sss_sscp_key_object_init(sss_sscp_object_t * keyObject,sss_sscp_key_store_t * keyStore)1859 sss_status_t sss_sscp_key_object_init(sss_sscp_object_t *keyObject, sss_sscp_key_store_t *keyStore)
1860 {
1861 SSCP_BUILD_ASSURE(sizeof(sss_object_t) >= sizeof(sss_sscp_object_t), _sss_sscp_key_object_size);
1862 sscp_operation_t op = {0};
1863 sscp_status_t status = kStatus_SSCP_Fail;
1864 uint32_t ret = 0u;
1865
1866 keyObject->keyStore = keyStore;
1867 keyObject->objectType = 0u; /* object type: key */
1868
1869 op.paramTypes =
1870 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
1871 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1872
1873 op.params[0].context.ptr = keyStore;
1874 op.params[0].context.type = kSSCP_ParamContextType_SSS_KeyStore;
1875
1876 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ContextReference);
1877 op.resultCount = 1u;
1878 op.result[0].context.ptr = keyObject;
1879 op.result[0].context.type = kSSCP_ParamContextType_SSS_Object;
1880
1881 sscp_context_t *sscpCtx = keyStore->session->sscp;
1882 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyObjectContextInit, &op, &ret);
1883 if (status != kStatus_SSCP_Success)
1884 {
1885 return kStatus_SSS_Fail;
1886 }
1887
1888 return (sss_status_t)ret;
1889 }
1890
sss_sscp_key_object_allocate_handle(sss_sscp_object_t * keyObject,uint32_t keyId,sss_key_part_t keyPart,sss_cipher_type_t cipherType,uint32_t keyByteLenMax,uint32_t options)1891 sss_status_t sss_sscp_key_object_allocate_handle(sss_sscp_object_t *keyObject,
1892 uint32_t keyId,
1893 sss_key_part_t keyPart,
1894 sss_cipher_type_t cipherType,
1895 uint32_t keyByteLenMax,
1896 uint32_t options)
1897 {
1898 SSCP_BUILD_ASSURE(sizeof(sss_object_t) >= sizeof(sss_sscp_object_t), _sss_sscp_object_size);
1899 sscp_operation_t op = {0};
1900 sscp_status_t status = kStatus_SSCP_Fail;
1901 uint32_t ret = 0u;
1902
1903 keyObject->objectType = keyPart;
1904 keyObject->objectKeyCipher = cipherType;
1905
1906 op.paramTypes = SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ValueInputTuple,
1907 kSSCP_ParamType_ValueInputTuple, kSSCP_ParamType_ValueInputSingle,
1908 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1909
1910 op.params[0].context.ptr = keyObject;
1911 op.params[0].context.type = kSSCP_ParamContextType_SSS_Object;
1912
1913 op.params[1].value.a = keyId;
1914 op.params[1].value.b = keyPart;
1915
1916 op.params[2].value.a = cipherType;
1917 op.params[2].value.b = keyByteLenMax;
1918
1919 op.params[3].value.a = options;
1920
1921 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1922 op.resultCount = 0u;
1923
1924 sscp_context_t *sscpCtx = keyObject->keyStore->session->sscp;
1925 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyObjectAllocateHandle, &op, &ret);
1926 if (status != kStatus_SSCP_Success)
1927 {
1928 return kStatus_SSS_Fail;
1929 }
1930
1931 return (sss_status_t)ret;
1932 }
1933
sss_sscp_key_object_get_handle(sss_sscp_object_t * keyObject,uint32_t keyId)1934 sss_status_t sss_sscp_key_object_get_handle(sss_sscp_object_t *keyObject, uint32_t keyId)
1935 {
1936 SSCP_BUILD_ASSURE(sizeof(sss_object_t) >= sizeof(sss_sscp_object_t), _sss_sscp_object_size);
1937 sscp_operation_t op = {0};
1938 sscp_status_t status = kStatus_SSCP_Fail;
1939 uint32_t ret = 0u;
1940
1941 op.paramTypes =
1942 SSCP_OP_SET_PARAM(kSSCP_ParamType_ValueInputSingle, kSSCP_ParamType_None, kSSCP_ParamType_None,
1943 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1944
1945 op.params[0].value.a = keyId;
1946
1947 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ContextReference);
1948 op.resultCount = 1u;
1949 op.result[0].context.ptr = keyObject;
1950 op.result[0].context.type = kSSCP_ParamContextType_SSS_Object;
1951
1952 sscp_context_t *sscpCtx = keyObject->keyStore->session->sscp;
1953 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyObjectGetHandle, &op, &ret);
1954 if (status != kStatus_SSCP_Success)
1955 {
1956 return kStatus_SSS_Fail;
1957 }
1958 return (sss_status_t)ret;
1959 }
1960
sss_sscp_key_object_set_eccgfp_group(sss_sscp_object_t * keyObject,sss_eccgfp_group_t * group)1961 sss_status_t sss_sscp_key_object_set_eccgfp_group(sss_sscp_object_t *keyObject, sss_eccgfp_group_t *group)
1962 {
1963 keyObject->eccgfpGroup = group;
1964 return kStatus_SSS_Success;
1965 }
1966
sss_sscp_key_object_set_properties(sss_sscp_object_t * keyObject,uint32_t options)1967 sss_status_t sss_sscp_key_object_set_properties(sss_sscp_object_t *keyObject, uint32_t options)
1968 {
1969 sscp_operation_t op = {0};
1970 sscp_status_t status = kStatus_SSCP_Fail;
1971 uint32_t ret = 0u;
1972
1973 op.paramTypes =
1974 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ValueInputSingle, kSSCP_ParamType_None,
1975 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
1976
1977 op.params[0].context.ptr = keyObject;
1978 op.params[0].context.type = kSSCP_ParamContextType_SSS_Object;
1979
1980 op.params[1].value.a = options;
1981
1982 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
1983 op.resultCount = 0u;
1984
1985 sscp_context_t *sscpCtx = keyObject->keyStore->session->sscp;
1986 if ((sscpCtx == NULL) || (sscpCtx->invoke == NULL))
1987 {
1988 return kStatus_SSS_Fail;
1989 }
1990 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyObjectSetProperties, &op, &ret);
1991 if (status != kStatus_SSCP_Success)
1992 {
1993 return kStatus_SSS_Fail;
1994 }
1995 return (sss_status_t)ret;
1996 }
1997
sss_sscp_key_object_get_properties(sss_sscp_object_t * keyObject,uint32_t * options)1998 sss_status_t sss_sscp_key_object_get_properties(sss_sscp_object_t *keyObject, uint32_t *options)
1999 {
2000 sscp_operation_t op = {0};
2001 sscp_status_t status = kStatus_SSCP_Fail;
2002 uint32_t ret = 0u;
2003
2004 op.paramTypes =
2005 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_None, kSSCP_ParamType_None,
2006 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
2007
2008 op.params[0].context.ptr = keyObject;
2009 op.params[0].context.type = kSSCP_ParamContextType_SSS_Object;
2010
2011 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_ValueOutputSingle);
2012 op.resultCount = 1u;
2013 op.result[0].value.a = (uint32_t)options;
2014
2015 sscp_context_t *sscpCtx = keyObject->keyStore->session->sscp;
2016 if ((sscpCtx == NULL) || (sscpCtx->invoke == NULL))
2017 {
2018 return kStatus_SSS_Fail;
2019 }
2020 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyObjectGetProperties, &op, &ret);
2021 if (status != kStatus_SSCP_Success)
2022 {
2023 return kStatus_SSS_Fail;
2024 }
2025 return (sss_status_t)ret;
2026 }
2027
sss_sscp_key_object_free(sss_sscp_object_t * keyObject,uint32_t options)2028 sss_status_t sss_sscp_key_object_free(sss_sscp_object_t *keyObject, uint32_t options)
2029 {
2030 sscp_operation_t op = {0};
2031 sscp_status_t status = kStatus_SSCP_Fail;
2032 uint32_t ret = 0u;
2033
2034 op.paramTypes =
2035 SSCP_OP_SET_PARAM(kSSCP_ParamType_ContextReference, kSSCP_ParamType_ValueInputSingle, kSSCP_ParamType_None,
2036 kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None, kSSCP_ParamType_None);
2037
2038 op.params[0].context.ptr = keyObject;
2039 op.params[0].context.type = kSSCP_ParamContextType_SSS_Object;
2040
2041 op.params[1].value.a = options;
2042
2043 op.resultTypes = SSCP_OP_SET_RESULT(kSSCP_ParamType_None);
2044 op.resultCount = 0u;
2045
2046 sscp_context_t *sscpCtx = keyObject->keyStore->session->sscp;
2047 if ((sscpCtx == NULL) || (sscpCtx->invoke == NULL))
2048 {
2049 return kStatus_SSS_Fail;
2050 }
2051 status = sscpCtx->invoke(sscpCtx, kSSCP_CMD_SSS_KeyObjectContextFree, &op, &ret);
2052 if (status != kStatus_SSCP_Success)
2053 {
2054 return kStatus_SSS_Fail;
2055 }
2056 return (sss_status_t)ret;
2057 }
2058
