SEcube open-source SDK
L1_enumerations.h
Go to the documentation of this file.
1 
10 #ifndef L1_ENUMERATIONS_H
11 #define L1_ENUMERATIONS_H
12 
13 #include "../L0/L0_enumerations.h"
14 
15 //L1 Error
16 namespace L1Error {
17  struct Error {
18  enum {
19  OK = 0,
20  SE3_ERR_ACCESS = 100,
21  SE3_ERR_PIN = 101,
22  SE3_ERR_RESOURCE = 200,
23  SE3_ERR_EXPIRED = 201,
24  SE3_ERR_MEMORY = 400,
25  SE3_ERR_AUTH = 401,
26 
27  SE3_ERR_OPENED = 300
28  };
29  };
30 }
31 
32 
33 namespace L1Request {
34  struct Offset {
35  enum {
36  //SE3_REQ1_OFFSET_AUTH = 0,
37  AUTH = 0,
38  //SE3_REQ1_OFFSET_IV = 16,
39  IV = 16,
40  //SE3_REQ1_OFFSET_TOKEN = 32,
41  TOKEN = 32,
42  //SE3_REQ1_OFFSET_LEN = 48,
43  LEN = 48,
44  //SE3_REQ1_OFFSET_CMD = 50,
45  CMD = 50,
46  //SE3_REQ1_OFFSET_DATA = 64,
47  DATA = 64,
48  };
49  };
50 
51  struct Size {
52  enum {
53  //SE3_REQ1_MAX_DATA = (SE3_REQ_MAX_DATA - SE3_REQ1_OFFSET_DATA)
54  MAX_DATA = L0Request::Size::MAX_DATA - L1Request::Offset::DATA
55  };
56  };
57 
58  struct KeyOffset {
59  enum {
60  //SE3_CMD1_KEY_EDIT_REQ_OFF_OP = 0,
61  OP = 0,
62  //SE3_CMD1_KEY_EDIT_REQ_OFF_ID = 2,
63  ID = 2,
64  //SE3_CMD1_KEY_EDIT_REQ_OFF_VALIDITY = 6,
65  VALIDITY = 6,
66  //SE3_CMD1_KEY_EDIT_REQ_OFF_DATA_LEN = 10,
67  DATA_LEN = 10,
68  //SE3_CMD1_KEY_EDIT_REQ_OFF_NAME_LEN = 12,
69  NAME_LEN = 12,
70  //SE3_CMD1_KEY_EDIT_REQ_OFF_DATA_AND_NAME = 14
71  DATA_AND_NAME = 14
72  };
73  };
74 }
75 
76 namespace L1Response {
77  struct Offset {
78  enum {
79  //SE3_RESP1_OFFSET_AUTH = 0,
80  AUTH = 0,
81  //SE3_RESP1_OFFSET_IV = 16,
82  IV = 16,
83  //SE3_RESP1_OFFSET_TOKEN = 32,
84  TOKEN = 32,
85  //SE3_RESP1_OFFSET_LEN = 48,
86  LEN = 48,
87  //SE3_RESP1_OFFSET_STATUS = 50,
88  STATUS = 50,
89  //SE3_RESP1_OFFSET_DATA = 64
90  DATA = 64
91  };
92  };
93 
94  struct Size {
95  enum {
96  //SE3_RESP1_MAX_DATA = (SE3_REQ_MAX_DATA - SE3_RESP1_OFFSET_DATA)
97  MAX_DATA = L0Response::Size::MAX_DATA - L1Response::Offset::DATA
98  };
99  };
100 }
101 
102 namespace L1ChallengeRequest {
103  struct Offset {
104  enum {
105  //SE3_CMD1_CHALLENGE_REQ_OFF_CC1 = 0,
106  CC1 = 0,
107  //SE3_CMD1_CHALLENGE_REQ_OFF_CC2 = 32,
108  CC2 = 32,
109  //SE3_CMD1_CHALLENGE_REQ_OFF_ACCESS = 64
110  ACCESS = 64
111  };
112  };
113 
114  struct Size {
115  enum {
116  //SE3_CMD1_CHALLENGE_REQ_SIZE = 66
117  SIZE = 66
118  };
119  };
120 }
121 
122 namespace L1ChallengeResponse {
123  struct Offset {
124  enum {
125  //SE3_CMD1_CHALLENGE_RESP_OFF_SC = 0,
126  SC = 0,
127  //SE3_CMD1_CHALLENGE_RESP_OFF_SRESP = 32
128  SRESP = 32
129  };
130  };
131 
132  struct Size {
133  enum {
134  //SE3_CMD1_CHALLENGE_RESP_SIZE = 64
135  SIZE = 64
136  };
137  };
138 }
139 
140 namespace L1Parameters {
141  struct Size {
142  enum {
143  //SE3_L1_PIN_SIZE = 32,
144  PIN = 32,
145  //SE3_L1_KEY_SIZE = 32,
146  KEY = 32,
147  //SE3_L1_AUTH_SIZE = 16,
148  AUTH = 16,
149  //SE3_L1_CRYPTOBLOCK_SIZE = 16,
150  CRYPTO_BLOCK = 16,
151  //SE3_L1_CHALLENGE_SIZE = 32,
152  CHALLENGE = 32,
153  //SE3_L1_IV_SIZE = 16,
154  IV = 16,
155  //SE3_L1_TOKEN_SIZE = 16
156  TOKEN = 16
157  };
158  };
159 
160  struct Parameter {
161  enum {
162  //SE3_L1_CHALLENGE_ITERATIONS = 32
163  ITERATIONS = 32
164  };
165  };
166 }
167 
168 namespace L1Crypto {
169  // @matteo: cryptotypes added because required by SEfile
170  struct CryptoTypes {
171  enum {
172  SE3_CRYPTO_TYPE_BLOCKCIPHER = 0,
173  SE3_CRYPTO_TYPE_STREAMCIPHER = 1,
174  SE3_CRYPTO_TYPE_DIGEST = 2,
175  SE3_CRYPTO_TYPE_BLOCKCIPHER_AUTH = 3,
176  SE3_CRYPTO_TYPE_OTHER = 0xFFFF
177  };
178  };
179 
180  struct ListResponseOffset {
181  enum {
182  //SE3_CMD1_CRYPTO_LIST_RESP_OFF_COUNT = 0,
183  COUNT = 0,
184  //SE3_CMD1_CRYPTO_LIST_RESP_OFF_ALGOINFO = 2
185  ALGORITHM_INFO = 2
186  };
187  };
188 
189  struct ListRequestSize {
190  enum {
191  //SE3_CMD1_CRYPTO_LIST_REQ_SIZE = 0,
192  REQ_SIZE = 0,
193  };
194  };
195 
196  struct AlgorithmInfoOffset {
197  enum {
198  //SE3_CMD1_CRYPTO_ALGOINFO_OFF_NAME = 0,
199  NAME = 0,
200  //SE3_CMD1_CRYPTO_ALGOINFO_OFF_TYPE = 16,
201  TYPE = 16,
202  //SE3_CMD1_CRYPTO_ALGOINFO_OFF_BLOCK_SIZE = 18,
203  BLOCK_SIZE = 18,
204  //SE3_CMD1_CRYPTO_ALGOINFO_OFF_KEY_SIZE = 20
205  KEY_SIZE = 20
206  };
207  };
208 
209  struct AlgorithmInfoSize {
210  enum {
211  //SE3_CMD1_CRYPTO_ALGOINFO_SIZE = 22,
212  SIZE = 22,
213  //SE3_CMD1_CRYPTO_ALGOINFO_NAME_SIZE = 16
214  NAME_SIZE = 16
215  };
216  };
217 
218  struct SetTimeRequestOffset {
219  enum {
220  //SE3_CMD1_CRYPTO_SET_TIME_REQ_OFF_DEVTIME = 0
221  DEV_TIME = 0
222  };
223  };
224 
225  struct SetTimeRequestSize {
226  enum {
227  //SE3_CMD1_CRYPTO_SET_TIME_REQ_SIZE = 4
228  SIZE = 4
229  };
230  };
231 
232  struct InitRequestOffset {
233  enum {
234  //SE3_CMD1_CRYPTO_INIT_REQ_OFF_ALGO = 0,
235  ALGO = 0,
236  //SE3_CMD1_CRYPTO_INIT_REQ_OFF_MODE = 2,
237  MODE = 2,
238  //SE3_CMD1_CRYPTO_INIT_REQ_OFF_KEY_ID = 4
239  KEY_ID = 4
240  };
241  };
242 
243  struct InitRequestSize {
244  enum {
245  //SE3_CMD1_CRYPTO_INIT_REQ_SIZE = 8
246  SIZE = 8
247  };
248  };
249 
250  struct InitResponseOffset {
251  enum {
252  //SE3_CMD1_CRYPTO_INIT_RESP_OFF_SID = 0
253  SID = 0
254  };
255  };
256 
257  struct InitResponseSize {
258  enum {
259  //SE3_CMD1_CRYPTO_INIT_RESP_SIZE = 4
260  SIZE = 4
261  };
262  };
263 
264  struct UpdateRequestOffset {
265  enum {
266  //SE3_CMD1_CRYPTO_UPDATE_REQ_OFF_SID = 0,
267  SID = 0,
268  //SE3_CMD1_CRYPTO_UPDATE_REQ_OFF_FLAGS = 4,
269  FLAGS = 4,
270  //SE3_CMD1_CRYPTO_UPDATE_REQ_OFF_DATAIN1_LEN = 6,
271  DATAIN1_LEN = 6,
272  //SE3_CMD1_CRYPTO_UPDATE_REQ_OFF_DATAIN2_LEN = 8,
273  DATAIN2_LEN = 8,
274  //SE3_CMD1_CRYPTO_UPDATE_REQ_OFF_DATA = 16
275  DATA = 16
276  };
277  };
278 
279  struct UpdateResponseOffset {
280  enum {
281  //SE3_CMD1_CRYPTO_UPDATE_RESP_OFF_DATAOUT_LEN = 0,
282  DATAOUT_LEN = 0,
283  //SE3_CMD1_CRYPTO_UPDATE_RESP_OFF_DATA = 16
284  DATA = 16
285  };
286  };
287 
288  struct UpdateSize {
289  enum {
290  //SE3_CRYPTO_MAX_DATAIN = (SE3_REQ1_MAX_DATA - SE3_CMD1_CRYPTO_UPDATE_REQ_OFF_DATA),
291  DATAIN = L1Request::Size::MAX_DATA - L1Crypto::UpdateRequestOffset::DATA,
292  //SE3_CRYPTO_MAX_DATAOUT = (SE3_RESP1_MAX_DATA - SE3_CMD1_CRYPTO_UPDATE_RESP_OFF_DATA)
293  DATAOUT = L1Response::Size::MAX_DATA - L1Crypto::UpdateResponseOffset::DATA
294  };
295  };
296 
297  struct UpdateFlags {
298  enum {
299  //SE3_CRYPTO_FLAG_FINIT = (1 << 15),
300  FINIT = 1 << 15,
301  //SE3_CRYPTO_FLAG_RESET = (1 << 14),
302  RESET = 1 << 14,
303  //SE3_CRYPTO_FLAG_SETIV = SE3_CRYPTO_FLAG_RESET,
304  SET_IV = RESET,
305  //SE3_CRYPTO_FLAG_SETNONCE = (1 << 13),
306  SETNONCE = 1 << 13,
307  //SE3_CRYPTO_FLAG_AUTH = (1 << 12)
308  AUTH = 1 << 12
309  };
310  };
311 }
312 
313 namespace L1Key {
314  struct Size {
315  enum {
316  //SE3_KEY_DATA_MAX = 2048,
317  MAX_DATA = 2048,
318  //SE3_KEY_NAME_MAX = 32
319  MAX_NAME = 32
320  };
321  };
322 
323  struct RequestListSize {
324  enum {
325  //SE3_CMD1_KEY_LIST_REQ_SIZE = 36
326  SIZE = 36
327  };
328  };
329 
330  struct RequestListOffset {
331  enum {
332  //SE3_CMD1_KEY_LIST_REQ_OFF_SKIP = 0,
333  SKIP = 0,
334  //SE3_CMD1_KEY_LIST_REQ_OFF_NMAX = 2,
335  NMAX = 2,
336  };
337  };
338 
339  struct ResponeListOffset {
340  enum {
341  //SE3_CMD1_KEY_LIST_RESP_OFF_COUNT = 0,
342  COUNT = 0,
343  //SE3_CMD1_KEY_LIST_RESP_OFF_KEYINFO = 2
344  KEYINFO = 2
345  };
346  };
347 
348  struct InfoOffset {
349  enum {
350  //SE3_CMD1_KEY_LIST_KEYINFO_OFF_ID = 0,
351  ID = 0,
352  //SE3_CMD1_KEY_LIST_KEYINFO_OFF_VALIDITY = 4,
353  VALIDITY = 4,
354  //SE3_CMD1_KEY_LIST_KEYINFO_OFF_DATA_LEN = 8,
355  DATA_LEN = 8,
356  //SE3_CMD1_KEY_LIST_KEYINFO_OFF_NAME_LEN = 10,
357  NAME_LEN = 10,
358  //SE3_CMD1_KEY_LIST_KEYINFO_OFF_FINGERPRINT = 12
359  FINGERPRINT = 12,
360  // SE3_CMD1_KEY_LIST_KEYINFO_OFF_NAME = 44
361  NAME = 44
362 
363  };
364  };
365 }
366 
367 namespace L1Commands {
368  struct Flags {
369  enum {
370  //SE3_CMDFLAG_ENCRYPT = (1 << 15), ///< encrypt L1 packet
371  ENCRYPT = 1 << 15, //encrypt L1 packet
372  //SE3_CMDFLAG_SIGN = (1 << 14) ///< sign L1 payload
373  SIGN = 1 << 14 //sign L1 payload
374  };
375  };
376 
377  struct Codes {
378  enum {
379  //SE3_CMD1_CHALLENGE = 1,
380  CHALLENGE = 1,
381  //SE3_CMD1_LOGIN = 2,
382  LOGIN = 2,
383  //SE3_CMD1_LOGOUT = 3,
384  LOGOUT = 3,
385  //SE3_CMD1_CONFIG = 4,
386  CONFIG = 4,
387  //SE3_CMD1_KEY_EDIT = 5,
388  KEY_EDIT = 5,
389  //SE3_CMD1_KEY_LIST = 6,
390  KEY_LIST = 6,
391  //SE3_CMD1_CRYPTO_INIT = 7,
392  CRYPTO_INIT = 7,
393  //SE3_CMD1_CRYPTO_UPDATE = 8,
394  CRYPTO_UPDATE = 8,
395  //SE3_CMD1_CRYPTO_LIST = 9,
396  CRYPTO_LIST = 9,
397  //SE3_CMD1_CRYPTO_SET_TIME = 10
398  SET_TIME = 10,
399  //SE3_CMD1_LOGOUT_FORCED = 11
400  FORCED_LOGOUT=11,
401  //SE3_CMD1_SEKEY (includes all options below)
402  SEKEY = 12
403  };
404  };
405 
406  struct Options {
407  enum{
408  SE3_SEKEY_OP_SETINFO = 1,
409  SE3_SEKEY_OP_GETINFO = 2,
410  SE3_SEKEY_OP_GETKEY = 3,
411  SE3_SEKEY_OP_GET_KEY_IDS = 4,
412  SE3_SEKEY_DELETEALL = 5,
413  SE3_SEKEY_DELETEKEY = 6,
414  SE3_SEKEY_OP_GETKEYENC = 7,
415  SE3_SEKEY_INSERTKEY = 8
416  //SE3_SEKEY_FINDKEY = 9
417  };
418  };
419 }
420 
421 namespace L1Login {
422  struct RequestOffset {
423  enum {
424  //SE3_CMD1_LOGIN_REQ_OFF_CRESP = 0
425  CRESP = 0
426  };
427  };
428 
429  struct RequestSize {
430  enum {
431  //SE3_CMD1_LOGIN_REQ_SIZE = 32
432  SIZE = 32
433  };
434  };
435 
436  struct ResponseOffset {
437  enum {
438  //SE3_CMD1_LOGIN_RESP_OFF_TOKEN = 0
439  TOKEN = 0
440  };
441  };
442 
443  struct ResponseSize {
444  enum {
445  //SE3_CMD1_LOGIN_RESP_SIZE = 16
446  SIZE = 16
447  };
448  };
449 }
450 
451 namespace L1Algorithms {
452  /* WARNING: any change in the algorithms below must be propagated also
453  * in SEkey code which is based on this namespace. */
454  struct Algorithms {
455  enum {
456  AES = 0,
457  SHA256 = 1,
458  HMACSHA256 = 2,
459  AES_HMACSHA256 = 3,
460  AES_HMAC = 4
461  };
462  };
463 
464  // @matteo: copied from original C source code because needed by SEfile
465  struct Parameters {
466  enum {
467  SE3_ALGO_MAX = 8
468  };
469  };
470 }
471 
472 namespace L1Configuration {
473  struct RequestOffset {
474  enum {
475  //SE3_CMD1_CONFIG_REQ_OFF_ID = 0,
476  CONFIG_ID = 0,
477  //SE3_CMD1_CONFIG_REQ_OFF_OP = 2,
478  CONFIG_OP = 2,
479  //SE3_CMD1_CONFIG_REQ_OFF_VALUE = 4,
480  CONFIG_VALUE = 4,
481  };
482  };
483 
484  struct ResponseOffset {
485  enum {
486  //SE3_CMD1_CONFIG_RESP_OFF_VALUE = 0
487  CONFIG_VALUE = 0
488  };
489  };
490 
491  struct Operation {
492  enum {
493  //SE3_CONFIG_OP_GET = 1,
494  GET = 1,
495  //SE3_CONFIG_OP_SET = 2
496  SET = 2
497  };
498  };
499 
500  struct RecordSize {
501  enum {
502  //SE3_RECORD_SIZE = 32,
503  RECORD_SIZE = 32,
504  //SE3_RECORD_MAX = 2
505  RECORD_MAX = 2
506  };
507  };
508 
509  struct RecordType {
510  enum {
511  //SE3_RECORD_TYPE_ADMINPIN = 0,
512  ADMINPIN = 0,
513  //SE3_RECORD_TYPE_USERPIN = 1
514  USERPIN = 1
515  };
516  };
517 }
518 
519 namespace CryptoInitialisation {
528  struct Parameters {
529  enum {
530  //SE3_DIR_SHIFT = 8
531  SHIFT = 8
532  };
533  };
534 
535  struct Mode {
536  enum {
537  //SE3_DIR_ENCRYPT = (1 << SE3_DIR_SHIFT),
538  ENCRYPT = 1 << CryptoInitialisation::Parameters::SHIFT,
539  //SE3_DIR_DECRYPT = (2 << SE3_DIR_SHIFT)
540  DECRYPT = 2 << CryptoInitialisation::Parameters::SHIFT
541  };
542  };
543 
544  struct Feedback {
545  enum {
546  //SE3_FEEDBACK_ECB = 1,
547  ECB = 1,
548  //SE3_FEEDBACK_CBC = 2,
549  CBC = 2,
550  //SE3_FEEDBACK_OFB = 3,
551  OFB = 3,
552  //SE3_FEEDBACK_CTR = 4,
553  CTR = 4,
554  //SE3_FEEDBACK_CFB = 5
555  CFB = 5
556  };
557  };
558 }
559 
560 namespace L1SEkey {
561  struct Direction { // Operations to read or write SEkey user info (username and user ID) from the SEcube to the host and vice-versa
562  enum {
563  LOAD, // Read from the SEcube
564  STORE // Write to the SEcube
565  };
566  };
567 }
568 
569 #endif
CryptoInitialisation::Parameters
L1CryptoInit default modes.
Definition: L1_enumerations.h:528