cryptlib  3.4.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Macros
python.c
Go to the documentation of this file.
1 
2 #include <Python.h>
3 #include "../cryptlib.h"
4 
5 
6 static PyObject* cryptHandleClass;
7 static PyObject* cryptQueryInfoClass;
8 static PyObject* cryptObjectInfoClass;
9 static PyObject *CryptException;
10 
11 static int getPointerWrite(PyObject* objPtr, unsigned char** bytesPtrPtr, int* lengthPtr)
12 {
13  if (objPtr == Py_None)
14  {
15  *bytesPtrPtr = NULL;
16  *lengthPtr = 0;
17  return 1;
18  }
19 
20  Py_ssize_t size = 0;
21 
22  /*See if it's an array object*/
23  if (PyObject_AsWriteBuffer(objPtr, (void **)bytesPtrPtr, &size) == -1)
24  return 0;
25  *lengthPtr = size;
26  return 1;
27 }
28 
29 static int getPointerRead(PyObject* objPtr, unsigned char** bytesPtrPtr, int* lengthPtr)
30 {
31  if (objPtr == Py_None)
32  {
33  *bytesPtrPtr = NULL;
34  *lengthPtr = 0;
35  return 1;
36  }
37 
38  Py_ssize_t size = 0;
39 
40  /*See if it's an array object*/
41  if (PyObject_AsWriteBuffer(objPtr, (void **)bytesPtrPtr, &size) == -1)
42  {
43  PyErr_Clear();
44  /*See if it's a string object*/
45  /*This returns the length excluding the NULL if it's a string,
46  which is what we want*/
47  if (PyObject_AsCharBuffer(objPtr, (const char **)bytesPtrPtr, &size) == -1)
48  return 0;
49  }
50  *lengthPtr = size;
51  return 1;
52 }
53 
54 static int getPointerReadNoLength(PyObject* objPtr, unsigned char** bytesPtrPtr)
55 {
56  int length;
57  return getPointerRead(objPtr, bytesPtrPtr, &length);
58 }
59 
60 static int getPointerWriteCheckIndices(PyObject* objPtr, unsigned char** bytesPtrPtr, int* lengthPtr)
61 {
62  int checkLength = *lengthPtr;
63 
64  if (getPointerWrite(objPtr, bytesPtrPtr, lengthPtr) == 0)
65  return 0;
66 
67  //If sequence is non-NULL and too short...
68  if (*bytesPtrPtr && (*lengthPtr < checkLength))
69  {
70  PyErr_SetString(PyExc_IndexError, "A sequence passed to cryptlib was too small");
71  return 0;
72  }
73  return 1;
74 }
75 
76 static int getPointerReadString(PyObject* objPtr, char** charPtrPtr)
77 {
78  Py_ssize_t length = 0;
79  char* newPtr = NULL;
80 
81  if (objPtr == Py_None)
82  {
83  *charPtrPtr = NULL;
84  return 1;
85  }
86 
87  /*See if it's a string or a buffer object*/
88  if (PyObject_AsCharBuffer(objPtr, charPtrPtr, &length) == -1)
89  {
90  /*See if it's an array*/
91  PyErr_Clear();
92  if (PyObject_AsWriteBuffer(objPtr, charPtrPtr, &length) == -1)
93  return 0;
94  }
95  /*This code isn't necessary for a string, but it is for arrays and buffers,
96  so we do it always anyway, since the PyObject_AsCharBuffer apparently doesn't
97  guarantee us null-terminated data, and this way releasePointerString() doesn't
98  have to differentiate */
99  newPtr = malloc(length+1);
100  if (newPtr == NULL)
101  {
102  PyErr_NoMemory();
103  return 0;
104  }
105  memcpy(newPtr, *charPtrPtr, length);
106  newPtr[length] = 0;
107  *charPtrPtr = newPtr;
108  return 1;
109 }
110 
111 static void releasePointer(PyObject* objPtr, unsigned char* bytesPtr)
112 {
113 }
114 
115 static void releasePointerString(PyObject* objPtr, char* charPtr)
116 {
117  free(charPtr);
118 }
119 
120 static PyObject* processStatus(int status)
121 {
122  PyObject* o = NULL;
123 
124  /* If an error has already occurred, ignore the status and just fall through */
125  if (PyErr_Occurred())
126  return(NULL);
127 
128  if (status >= CRYPT_OK)
129  return(Py_BuildValue(""));
130  else if (status == CRYPT_ERROR_PARAM1)
131  o = Py_BuildValue("(is)", CRYPT_ERROR_PARAM1, "Bad argument, parameter 1");
132  else if (status == CRYPT_ERROR_PARAM2)
133  o = Py_BuildValue("(is)", CRYPT_ERROR_PARAM2, "Bad argument, parameter 2");
134  else if (status == CRYPT_ERROR_PARAM3)
135  o = Py_BuildValue("(is)", CRYPT_ERROR_PARAM3, "Bad argument, parameter 3");
136  else if (status == CRYPT_ERROR_PARAM4)
137  o = Py_BuildValue("(is)", CRYPT_ERROR_PARAM4, "Bad argument, parameter 4");
138  else if (status == CRYPT_ERROR_PARAM5)
139  o = Py_BuildValue("(is)", CRYPT_ERROR_PARAM5, "Bad argument, parameter 5");
140  else if (status == CRYPT_ERROR_PARAM6)
141  o = Py_BuildValue("(is)", CRYPT_ERROR_PARAM6, "Bad argument, parameter 6");
142  else if (status == CRYPT_ERROR_PARAM7)
143  o = Py_BuildValue("(is)", CRYPT_ERROR_PARAM7, "Bad argument, parameter 7");
144  else if (status == CRYPT_ERROR_MEMORY)
145  o = Py_BuildValue("(is)", CRYPT_ERROR_MEMORY, "Out of memory");
146  else if (status == CRYPT_ERROR_NOTINITED)
147  o = Py_BuildValue("(is)", CRYPT_ERROR_NOTINITED, "Data has not been initialised");
148  else if (status == CRYPT_ERROR_INITED)
149  o = Py_BuildValue("(is)", CRYPT_ERROR_INITED, "Data has already been init'd");
150  else if (status == CRYPT_ERROR_NOSECURE)
151  o = Py_BuildValue("(is)", CRYPT_ERROR_NOSECURE, "Opn.not avail.at requested sec.level");
152  else if (status == CRYPT_ERROR_RANDOM)
153  o = Py_BuildValue("(is)", CRYPT_ERROR_RANDOM, "No reliable random data available");
154  else if (status == CRYPT_ERROR_FAILED)
155  o = Py_BuildValue("(is)", CRYPT_ERROR_FAILED, "Operation failed");
156  else if (status == CRYPT_ERROR_INTERNAL)
157  o = Py_BuildValue("(is)", CRYPT_ERROR_INTERNAL, "Internal consistency check failed");
158  else if (status == CRYPT_ERROR_NOTAVAIL)
159  o = Py_BuildValue("(is)", CRYPT_ERROR_NOTAVAIL, "This type of opn.not available");
160  else if (status == CRYPT_ERROR_PERMISSION)
161  o = Py_BuildValue("(is)", CRYPT_ERROR_PERMISSION, "No permiss.to perform this operation");
162  else if (status == CRYPT_ERROR_WRONGKEY)
163  o = Py_BuildValue("(is)", CRYPT_ERROR_WRONGKEY, "Incorrect key used to decrypt data");
164  else if (status == CRYPT_ERROR_INCOMPLETE)
165  o = Py_BuildValue("(is)", CRYPT_ERROR_INCOMPLETE, "Operation incomplete/still in progress");
166  else if (status == CRYPT_ERROR_COMPLETE)
167  o = Py_BuildValue("(is)", CRYPT_ERROR_COMPLETE, "Operation complete/can't continue");
168  else if (status == CRYPT_ERROR_TIMEOUT)
169  o = Py_BuildValue("(is)", CRYPT_ERROR_TIMEOUT, "Operation timed out before completion");
170  else if (status == CRYPT_ERROR_INVALID)
171  o = Py_BuildValue("(is)", CRYPT_ERROR_INVALID, "Invalid/inconsistent information");
172  else if (status == CRYPT_ERROR_SIGNALLED)
173  o = Py_BuildValue("(is)", CRYPT_ERROR_SIGNALLED, "Resource destroyed by extnl.event");
174  else if (status == CRYPT_ERROR_OVERFLOW)
175  o = Py_BuildValue("(is)", CRYPT_ERROR_OVERFLOW, "Resources/space exhausted");
176  else if (status == CRYPT_ERROR_UNDERFLOW)
177  o = Py_BuildValue("(is)", CRYPT_ERROR_UNDERFLOW, "Not enough data available");
178  else if (status == CRYPT_ERROR_BADDATA)
179  o = Py_BuildValue("(is)", CRYPT_ERROR_BADDATA, "Bad/unrecognised data format");
180  else if (status == CRYPT_ERROR_SIGNATURE)
181  o = Py_BuildValue("(is)", CRYPT_ERROR_SIGNATURE, "Signature/integrity check failed");
182  else if (status == CRYPT_ERROR_OPEN)
183  o = Py_BuildValue("(is)", CRYPT_ERROR_OPEN, "Cannot open object");
184  else if (status == CRYPT_ERROR_READ)
185  o = Py_BuildValue("(is)", CRYPT_ERROR_READ, "Cannot read item from object");
186  else if (status == CRYPT_ERROR_WRITE)
187  o = Py_BuildValue("(is)", CRYPT_ERROR_WRITE, "Cannot write item to object");
188  else if (status == CRYPT_ERROR_NOTFOUND)
189  o = Py_BuildValue("(is)", CRYPT_ERROR_NOTFOUND, "Requested item not found in object");
190  else if (status == CRYPT_ERROR_DUPLICATE)
191  o = Py_BuildValue("(is)", CRYPT_ERROR_DUPLICATE, "Item already present in object");
192  else if (status == CRYPT_ENVELOPE_RESOURCE)
193  o = Py_BuildValue("(is)", CRYPT_ENVELOPE_RESOURCE, "Need resource to proceed");
194  PyErr_SetObject(CryptException, o);
195  Py_DECREF(o);
196  return(NULL);
197 }
198 
199 static int processStatusBool(int status)
200 {
201  PyObject* o = processStatus(status);
202  if (o == NULL)
203  return(0);
204  else
205  {
206  Py_DECREF(o);
207  return(1);
208  }
209 }
210 
211 static PyObject* processStatusReturnInt(int status, int returnValue)
212 {
213  PyObject* o = processStatus(status);
214  if (o == NULL)
215  return(0);
216  else
217  {
218  Py_DECREF(o);
219  o = Py_BuildValue("i", returnValue);
220  return(o);
221  }
222 }
223 
224 static PyObject* processStatusReturnCryptHandle(int status, int returnValue)
225 {
226  PyObject* o2;
227  PyObject* o = processStatus(status);
228 
229  if (o == NULL)
230  return(0);
231  else
232  {
233  Py_DECREF(o);
234  o2 = Py_BuildValue("(i)", returnValue);
235  o = PyObject_CallObject(cryptHandleClass, o2);
236  Py_DECREF(o2);
237  return(o);
238  }
239 }
240 
241 static PyObject* processStatusReturnCryptQueryInfo(int status, CRYPT_QUERY_INFO returnValue)
242 {
243  PyObject* o2;
244  PyObject* o = processStatus(status);
245 
246  if (o == NULL)
247  return(0);
248  else
249  {
250  Py_DECREF(o);
251  o2 = Py_BuildValue("(siiii)", returnValue.algoName, returnValue.blockSize, returnValue.minKeySize, returnValue.keySize, returnValue.maxKeySize);
252  o = PyObject_CallObject(cryptQueryInfoClass, o2);
253  Py_DECREF(o2);
254  return(o);
255  }
256 }
257 
258 static PyObject* processStatusReturnCryptObjectInfo(int status, CRYPT_OBJECT_INFO returnValue)
259 {
260  PyObject* o2;
261  PyObject* o = processStatus(status);
262 
263  if (o == NULL)
264  return(0);
265  else
266  {
267  Py_DECREF(o);
268  o2 = Py_BuildValue("(iiiis#)", returnValue.objectType, returnValue.cryptAlgo, returnValue.cryptMode, returnValue.hashAlgo, returnValue.salt, returnValue.saltSize);
269  o = PyObject_CallObject(cryptObjectInfoClass, o2);
270  Py_DECREF(o2);
271  return(o);
272  }
273 }
274 
275 static PyObject* python_cryptInit(PyObject* self, PyObject* args)
276 {
277  int status = 0;
278 
279  status = cryptInit();
280 
281  return(processStatus(status));
282 }
283 
284 static PyObject* python_cryptEnd(PyObject* self, PyObject* args)
285 {
286  int status = 0;
287 
288  status = cryptEnd();
289 
290  return(processStatus(status));
291 }
292 
293 static PyObject* python_cryptQueryCapability(PyObject* self, PyObject* args)
294 {
295  int status = 0;
296  CRYPT_QUERY_INFO cryptQueryInfo;
297  int cryptAlgo = 0;
298 
299  if (!PyArg_ParseTuple(args, "i", &cryptAlgo))
300  return(NULL);
301 
302  status = cryptQueryCapability(cryptAlgo, &cryptQueryInfo);
303 
304  return(processStatusReturnCryptQueryInfo(status, cryptQueryInfo));
305 }
306 
307 static PyObject* python_cryptCreateContext(PyObject* self, PyObject* args)
308 {
309  int status = 0;
310  int cryptContext = 0;
311  int cryptUser = 0;
312  int cryptAlgo = 0;
313 
314  if (!PyArg_ParseTuple(args, "ii", &cryptUser, &cryptAlgo))
315  return(NULL);
316 
317  status = cryptCreateContext(&cryptContext, cryptUser, cryptAlgo);
318 
319  return(processStatusReturnCryptHandle(status, cryptContext));
320 }
321 
322 static PyObject* python_cryptDestroyContext(PyObject* self, PyObject* args)
323 {
324  int status = 0;
325  int cryptContext = 0;
326 
327  if (!PyArg_ParseTuple(args, "i", &cryptContext))
328  return(NULL);
329 
330  status = cryptDestroyContext(cryptContext);
331 
332  return(processStatus(status));
333 }
334 
335 static PyObject* python_cryptDestroyObject(PyObject* self, PyObject* args)
336 {
337  int status = 0;
338  int cryptObject = 0;
339 
340  if (!PyArg_ParseTuple(args, "i", &cryptObject))
341  return(NULL);
342 
343  status = cryptDestroyObject(cryptObject);
344 
345  return(processStatus(status));
346 }
347 
348 static PyObject* python_cryptGenerateKey(PyObject* self, PyObject* args)
349 {
350  int status = 0;
351  int cryptContext = 0;
352 
353  if (!PyArg_ParseTuple(args, "i", &cryptContext))
354  return(NULL);
355 
356  status = cryptGenerateKey(cryptContext);
357 
358  return(processStatus(status));
359 }
360 
361 static PyObject* python_cryptGenerateKeyAsync(PyObject* self, PyObject* args)
362 {
363  int status = 0;
364  int cryptContext = 0;
365 
366  if (!PyArg_ParseTuple(args, "i", &cryptContext))
367  return(NULL);
368 
369  status = cryptGenerateKeyAsync(cryptContext);
370 
371  return(processStatus(status));
372 }
373 
374 static PyObject* python_cryptAsyncQuery(PyObject* self, PyObject* args)
375 {
376  int status = 0;
377  int cryptObject = 0;
378 
379  if (!PyArg_ParseTuple(args, "i", &cryptObject))
380  return(NULL);
381 
382  status = cryptAsyncQuery(cryptObject);
383 
384  return(processStatus(status));
385 }
386 
387 static PyObject* python_cryptAsyncCancel(PyObject* self, PyObject* args)
388 {
389  int status = 0;
390  int cryptObject = 0;
391 
392  if (!PyArg_ParseTuple(args, "i", &cryptObject))
393  return(NULL);
394 
395  status = cryptAsyncCancel(cryptObject);
396 
397  return(processStatus(status));
398 }
399 
400 static PyObject* python_cryptEncrypt(PyObject* self, PyObject* args)
401 {
402  int status = 0;
403  int cryptContext = 0;
404  PyObject* buffer = NULL;
405  int length = 0;
406  unsigned char* bufferPtr = 0;
407 
408  if (!PyArg_ParseTuple(args, "iO", &cryptContext, &buffer))
409  return(NULL);
410 
411  if (!getPointerWrite(buffer, &bufferPtr, &length))
412  goto finish;
413 
414  status = cryptEncrypt(cryptContext, bufferPtr, length);
415 
416  finish:
417  releasePointer(buffer, bufferPtr);
418  return(processStatus(status));
419 }
420 
421 static PyObject* python_cryptDecrypt(PyObject* self, PyObject* args)
422 {
423  int status = 0;
424  int cryptContext = 0;
425  PyObject* buffer = NULL;
426  int length = 0;
427  unsigned char* bufferPtr = 0;
428 
429  if (!PyArg_ParseTuple(args, "iO", &cryptContext, &buffer))
430  return(NULL);
431 
432  if (!getPointerWrite(buffer, &bufferPtr, &length))
433  goto finish;
434 
435  status = cryptDecrypt(cryptContext, bufferPtr, length);
436 
437  finish:
438  releasePointer(buffer, bufferPtr);
439  return(processStatus(status));
440 }
441 
442 static PyObject* python_cryptSetAttribute(PyObject* self, PyObject* args)
443 {
444  int status = 0;
445  int cryptHandle = 0;
446  int attributeType = 0;
447  int value = 0;
448 
449  if (!PyArg_ParseTuple(args, "iii", &cryptHandle, &attributeType, &value))
450  return(NULL);
451 
452  status = cryptSetAttribute(cryptHandle, attributeType, value);
453 
454  return(processStatus(status));
455 }
456 
457 static PyObject* python_cryptSetAttributeString(PyObject* self, PyObject* args)
458 {
459  int status = 0;
460  int cryptHandle = 0;
461  int attributeType = 0;
462  PyObject* value = NULL;
463  int valueLength = 0;
464  unsigned char* valuePtr = 0;
465 
466  if (!PyArg_ParseTuple(args, "iiO", &cryptHandle, &attributeType, &value))
467  return(NULL);
468 
469  if (!getPointerRead(value, &valuePtr, &valueLength))
470  goto finish;
471 
472  status = cryptSetAttributeString(cryptHandle, attributeType, valuePtr, valueLength);
473 
474  finish:
475  releasePointer(value, valuePtr);
476  return(processStatus(status));
477 }
478 
479 static PyObject* python_cryptGetAttribute(PyObject* self, PyObject* args)
480 {
481  int status = 0;
482  int value = 0;
483  int cryptHandle = 0;
484  int attributeType = 0;
485 
486  if (!PyArg_ParseTuple(args, "ii", &cryptHandle, &attributeType))
487  return(NULL);
488 
489  status = cryptGetAttribute(cryptHandle, attributeType, &value);
490 
491  return(processStatusReturnInt(status, value));
492 }
493 
494 static PyObject* python_cryptGetAttributeString(PyObject* self, PyObject* args)
495 {
496  int status = 0;
497  int valueLength = 0;
498  int cryptHandle = 0;
499  int attributeType = 0;
500  PyObject* value = NULL;
501  unsigned char* valuePtr = 0;
502 
503  if (!PyArg_ParseTuple(args, "iiO", &cryptHandle, &attributeType, &value))
504  return(NULL);
505 
506  if (!processStatusBool(cryptGetAttributeString(cryptHandle, attributeType, NULL, &valueLength)))
507  goto finish;
508 
509  if (!getPointerWriteCheckIndices(value, &valuePtr, &valueLength))
510  goto finish;
511 
512  status = cryptGetAttributeString(cryptHandle, attributeType, valuePtr, &valueLength);
513 
514  finish:
515  releasePointer(value, valuePtr);
516  return(processStatusReturnInt(status, valueLength));
517 }
518 
519 static PyObject* python_cryptDeleteAttribute(PyObject* self, PyObject* args)
520 {
521  int status = 0;
522  int cryptHandle = 0;
523  int attributeType = 0;
524 
525  if (!PyArg_ParseTuple(args, "ii", &cryptHandle, &attributeType))
526  return(NULL);
527 
528  status = cryptDeleteAttribute(cryptHandle, attributeType);
529 
530  return(processStatus(status));
531 }
532 
533 static PyObject* python_cryptAddRandom(PyObject* self, PyObject* args)
534 {
535  int status = 0;
536  PyObject* randomData = NULL;
537  int randomDataLength = 0;
538  unsigned char* randomDataPtr = 0;
539 
540  //Special case to handle SLOWPOLL / FASTPOLL values
541  if (PyArg_ParseTuple(args, "i", &randomDataLength))
542  return processStatus(cryptAddRandom(NULL, randomDataLength));
543 
544  if (!PyArg_ParseTuple(args, "O", &randomData))
545  return(NULL);
546 
547  if (!getPointerRead(randomData, &randomDataPtr, &randomDataLength))
548  goto finish;
549 
550  status = cryptAddRandom(randomDataPtr, randomDataLength);
551 
552  finish:
553  releasePointer(randomData, randomDataPtr);
554  return(processStatus(status));
555 }
556 
557 static PyObject* python_cryptQueryObject(PyObject* self, PyObject* args)
558 {
559  int status = 0;
560  CRYPT_OBJECT_INFO cryptObjectInfo;
561  PyObject* objectData = NULL;
562  int objectDataLength = 0;
563  unsigned char* objectDataPtr = 0;
564 
565  if (!PyArg_ParseTuple(args, "O", &objectData))
566  return(NULL);
567 
568  if (!getPointerRead(objectData, &objectDataPtr, &objectDataLength))
569  goto finish;
570 
571  status = cryptQueryObject(objectDataPtr, objectDataLength, &cryptObjectInfo);
572 
573  finish:
574  releasePointer(objectData, objectDataPtr);
575  return(processStatusReturnCryptObjectInfo(status, cryptObjectInfo));
576 }
577 
578 static PyObject* python_cryptExportKey(PyObject* self, PyObject* args)
579 {
580  int status = 0;
581  int encryptedKeyLength = 0;
582  PyObject* encryptedKey = NULL;
583  int encryptedKeyMaxLength = 0;
584  int exportKey = 0;
585  int sessionKeyContext = 0;
586  unsigned char* encryptedKeyPtr = 0;
587 
588  if (!PyArg_ParseTuple(args, "Oiii", &encryptedKey, &encryptedKeyMaxLength, &exportKey, &sessionKeyContext))
589  return(NULL);
590 
591  if (!processStatusBool(cryptExportKey(NULL, encryptedKeyMaxLength, &encryptedKeyLength, exportKey, sessionKeyContext)))
592  goto finish;
593 
594  if (!getPointerWriteCheckIndices(encryptedKey, &encryptedKeyPtr, &encryptedKeyLength))
595  goto finish;
596 
597  status = cryptExportKey(encryptedKeyPtr, encryptedKeyMaxLength, &encryptedKeyLength, exportKey, sessionKeyContext);
598 
599  finish:
600  releasePointer(encryptedKey, encryptedKeyPtr);
601  return(processStatusReturnInt(status, encryptedKeyLength));
602 }
603 
604 static PyObject* python_cryptExportKeyEx(PyObject* self, PyObject* args)
605 {
606  int status = 0;
607  int encryptedKeyLength = 0;
608  PyObject* encryptedKey = NULL;
609  int encryptedKeyMaxLength = 0;
610  int formatType = 0;
611  int exportKey = 0;
612  int sessionKeyContext = 0;
613  unsigned char* encryptedKeyPtr = 0;
614 
615  if (!PyArg_ParseTuple(args, "Oiiii", &encryptedKey, &encryptedKeyMaxLength, &formatType, &exportKey, &sessionKeyContext))
616  return(NULL);
617 
618  if (!processStatusBool(cryptExportKeyEx(NULL, encryptedKeyMaxLength, &encryptedKeyLength, formatType, exportKey, sessionKeyContext)))
619  goto finish;
620 
621  if (!getPointerWriteCheckIndices(encryptedKey, &encryptedKeyPtr, &encryptedKeyLength))
622  goto finish;
623 
624  status = cryptExportKeyEx(encryptedKeyPtr, encryptedKeyMaxLength, &encryptedKeyLength, formatType, exportKey, sessionKeyContext);
625 
626  finish:
627  releasePointer(encryptedKey, encryptedKeyPtr);
628  return(processStatusReturnInt(status, encryptedKeyLength));
629 }
630 
631 static PyObject* python_cryptImportKey(PyObject* self, PyObject* args)
632 {
633  int status = 0;
634  PyObject* encryptedKey = NULL;
635  int encryptedKeyLength = 0;
636  int importKey = 0;
637  int sessionKeyContext = 0;
638  unsigned char* encryptedKeyPtr = 0;
639 
640  if (!PyArg_ParseTuple(args, "Oii", &encryptedKey, &importKey, &sessionKeyContext))
641  return(NULL);
642 
643  if (!getPointerRead(encryptedKey, &encryptedKeyPtr, &encryptedKeyLength))
644  goto finish;
645 
646  status = cryptImportKey(encryptedKeyPtr, encryptedKeyLength, importKey, sessionKeyContext);
647 
648  finish:
649  releasePointer(encryptedKey, encryptedKeyPtr);
650  return(processStatus(status));
651 }
652 
653 static PyObject* python_cryptImportKeyEx(PyObject* self, PyObject* args)
654 {
655  int status = 0;
656  int returnedContext = 0;
657  PyObject* encryptedKey = NULL;
658  int encryptedKeyLength = 0;
659  int importKey = 0;
660  int sessionKeyContext = 0;
661  unsigned char* encryptedKeyPtr = 0;
662 
663  if (!PyArg_ParseTuple(args, "Oii", &encryptedKey, &importKey, &sessionKeyContext))
664  return(NULL);
665 
666  if (!getPointerRead(encryptedKey, &encryptedKeyPtr, &encryptedKeyLength))
667  goto finish;
668 
669  status = cryptImportKeyEx(encryptedKeyPtr, encryptedKeyLength, importKey, sessionKeyContext, &returnedContext);
670 
671  finish:
672  releasePointer(encryptedKey, encryptedKeyPtr);
673  return(processStatusReturnCryptHandle(status, returnedContext));
674 }
675 
676 static PyObject* python_cryptCreateSignature(PyObject* self, PyObject* args)
677 {
678  int status = 0;
679  int signatureLength = 0;
680  PyObject* signature = NULL;
681  int signatureMaxLength = 0;
682  int signContext = 0;
683  int hashContext = 0;
684  unsigned char* signaturePtr = 0;
685 
686  if (!PyArg_ParseTuple(args, "Oiii", &signature, &signatureMaxLength, &signContext, &hashContext))
687  return(NULL);
688 
689  if (!processStatusBool(cryptCreateSignature(NULL, signatureMaxLength, &signatureLength, signContext, hashContext)))
690  goto finish;
691 
692  if (!getPointerWriteCheckIndices(signature, &signaturePtr, &signatureLength))
693  goto finish;
694 
695  status = cryptCreateSignature(signaturePtr, signatureMaxLength, &signatureLength, signContext, hashContext);
696 
697  finish:
698  releasePointer(signature, signaturePtr);
699  return(processStatusReturnInt(status, signatureLength));
700 }
701 
702 static PyObject* python_cryptCreateSignatureEx(PyObject* self, PyObject* args)
703 {
704  int status = 0;
705  int signatureLength = 0;
706  PyObject* signature = NULL;
707  int signatureMaxLength = 0;
708  int formatType = 0;
709  int signContext = 0;
710  int hashContext = 0;
711  int extraData = 0;
712  unsigned char* signaturePtr = 0;
713 
714  if (!PyArg_ParseTuple(args, "Oiiiii", &signature, &signatureMaxLength, &formatType, &signContext, &hashContext, &extraData))
715  return(NULL);
716 
717  if (!processStatusBool(cryptCreateSignatureEx(NULL, signatureMaxLength, &signatureLength, formatType, signContext, hashContext, extraData)))
718  goto finish;
719 
720  if (!getPointerWriteCheckIndices(signature, &signaturePtr, &signatureLength))
721  goto finish;
722 
723  status = cryptCreateSignatureEx(signaturePtr, signatureMaxLength, &signatureLength, formatType, signContext, hashContext, extraData);
724 
725  finish:
726  releasePointer(signature, signaturePtr);
727  return(processStatusReturnInt(status, signatureLength));
728 }
729 
730 static PyObject* python_cryptCheckSignature(PyObject* self, PyObject* args)
731 {
732  int status = 0;
733  PyObject* signature = NULL;
734  int signatureLength = 0;
735  int sigCheckKey = 0;
736  int hashContext = 0;
737  unsigned char* signaturePtr = 0;
738 
739  if (!PyArg_ParseTuple(args, "Oii", &signature, &sigCheckKey, &hashContext))
740  return(NULL);
741 
742  if (!getPointerRead(signature, &signaturePtr, &signatureLength))
743  goto finish;
744 
745  status = cryptCheckSignature(signaturePtr, signatureLength, sigCheckKey, hashContext);
746 
747  finish:
748  releasePointer(signature, signaturePtr);
749  return(processStatus(status));
750 }
751 
752 static PyObject* python_cryptCheckSignatureEx(PyObject* self, PyObject* args)
753 {
754  int status = 0;
755  int extraData = 0;
756  PyObject* signature = NULL;
757  int signatureLength = 0;
758  int sigCheckKey = 0;
759  int hashContext = 0;
760  unsigned char* signaturePtr = 0;
761 
762  if (!PyArg_ParseTuple(args, "Oii", &signature, &sigCheckKey, &hashContext))
763  return(NULL);
764 
765  if (!getPointerRead(signature, &signaturePtr, &signatureLength))
766  goto finish;
767 
768  status = cryptCheckSignatureEx(signaturePtr, signatureLength, sigCheckKey, hashContext, &extraData);
769 
770  finish:
771  releasePointer(signature, signaturePtr);
772  return(processStatusReturnCryptHandle(status, extraData));
773 }
774 
775 static PyObject* python_cryptKeysetOpen(PyObject* self, PyObject* args)
776 {
777  int status = 0;
778  int keyset = 0;
779  int cryptUser = 0;
780  int keysetType = 0;
781  PyObject* name = NULL;
782  int options = 0;
783  unsigned char* namePtr = 0;
784 
785  if (!PyArg_ParseTuple(args, "iiOi", &cryptUser, &keysetType, &name, &options))
786  return(NULL);
787 
788  if (!getPointerReadString(name, &namePtr))
789  goto finish;
790 
791  status = cryptKeysetOpen(&keyset, cryptUser, keysetType, namePtr, options);
792 
793  finish:
794  releasePointerString(name, namePtr);
795  return(processStatusReturnCryptHandle(status, keyset));
796 }
797 
798 static PyObject* python_cryptKeysetClose(PyObject* self, PyObject* args)
799 {
800  int status = 0;
801  int keyset = 0;
802 
803  if (!PyArg_ParseTuple(args, "i", &keyset))
804  return(NULL);
805 
806  status = cryptKeysetClose(keyset);
807 
808  return(processStatus(status));
809 }
810 
811 static PyObject* python_cryptGetPublicKey(PyObject* self, PyObject* args)
812 {
813  int status = 0;
814  int cryptContext = 0;
815  int keyset = 0;
816  int keyIDtype = 0;
817  PyObject* keyID = NULL;
818  unsigned char* keyIDPtr = 0;
819 
820  if (!PyArg_ParseTuple(args, "iiO", &keyset, &keyIDtype, &keyID))
821  return(NULL);
822 
823  if (!getPointerReadString(keyID, &keyIDPtr))
824  goto finish;
825 
826  status = cryptGetPublicKey(keyset, &cryptContext, keyIDtype, keyIDPtr);
827 
828  finish:
829  releasePointerString(keyID, keyIDPtr);
830  return(processStatusReturnCryptHandle(status, cryptContext));
831 }
832 
833 static PyObject* python_cryptGetPrivateKey(PyObject* self, PyObject* args)
834 {
835  int status = 0;
836  int cryptContext = 0;
837  int keyset = 0;
838  int keyIDtype = 0;
839  PyObject* keyID = NULL;
840  PyObject* password = NULL;
841  unsigned char* keyIDPtr = 0;
842  unsigned char* passwordPtr = 0;
843 
844  if (!PyArg_ParseTuple(args, "iiOO", &keyset, &keyIDtype, &keyID, &password))
845  return(NULL);
846 
847  if (!getPointerReadString(keyID, &keyIDPtr))
848  goto finish;
849  if (!getPointerReadString(password, &passwordPtr))
850  goto finish;
851 
852  status = cryptGetPrivateKey(keyset, &cryptContext, keyIDtype, keyIDPtr, passwordPtr);
853 
854  finish:
855  releasePointerString(keyID, keyIDPtr);
856  releasePointerString(password, passwordPtr);
857  return(processStatusReturnCryptHandle(status, cryptContext));
858 }
859 
860 static PyObject* python_cryptGetKey(PyObject* self, PyObject* args)
861 {
862  int status = 0;
863  int cryptContext = 0;
864  int keyset = 0;
865  int keyIDtype = 0;
866  PyObject* keyID = NULL;
867  PyObject* password = NULL;
868  unsigned char* keyIDPtr = 0;
869  unsigned char* passwordPtr = 0;
870 
871  if (!PyArg_ParseTuple(args, "iiOO", &keyset, &keyIDtype, &keyID, &password))
872  return(NULL);
873 
874  if (!getPointerReadString(keyID, &keyIDPtr))
875  goto finish;
876  if (!getPointerReadString(password, &passwordPtr))
877  goto finish;
878 
879  status = cryptGetKey(keyset, &cryptContext, keyIDtype, keyIDPtr, passwordPtr);
880 
881  finish:
882  releasePointerString(keyID, keyIDPtr);
883  releasePointerString(password, passwordPtr);
884  return(processStatusReturnCryptHandle(status, cryptContext));
885 }
886 
887 static PyObject* python_cryptAddPublicKey(PyObject* self, PyObject* args)
888 {
889  int status = 0;
890  int keyset = 0;
891  int certificate = 0;
892 
893  if (!PyArg_ParseTuple(args, "ii", &keyset, &certificate))
894  return(NULL);
895 
896  status = cryptAddPublicKey(keyset, certificate);
897 
898  return(processStatus(status));
899 }
900 
901 static PyObject* python_cryptAddPrivateKey(PyObject* self, PyObject* args)
902 {
903  int status = 0;
904  int keyset = 0;
905  int cryptKey = 0;
906  PyObject* password = NULL;
907  unsigned char* passwordPtr = 0;
908 
909  if (!PyArg_ParseTuple(args, "iiO", &keyset, &cryptKey, &password))
910  return(NULL);
911 
912  if (!getPointerReadString(password, &passwordPtr))
913  goto finish;
914 
915  status = cryptAddPrivateKey(keyset, cryptKey, passwordPtr);
916 
917  finish:
918  releasePointerString(password, passwordPtr);
919  return(processStatus(status));
920 }
921 
922 static PyObject* python_cryptDeleteKey(PyObject* self, PyObject* args)
923 {
924  int status = 0;
925  int keyset = 0;
926  int keyIDtype = 0;
927  PyObject* keyID = NULL;
928  unsigned char* keyIDPtr = 0;
929 
930  if (!PyArg_ParseTuple(args, "iiO", &keyset, &keyIDtype, &keyID))
931  return(NULL);
932 
933  if (!getPointerReadString(keyID, &keyIDPtr))
934  goto finish;
935 
936  status = cryptDeleteKey(keyset, keyIDtype, keyIDPtr);
937 
938  finish:
939  releasePointerString(keyID, keyIDPtr);
940  return(processStatus(status));
941 }
942 
943 static PyObject* python_cryptCreateCert(PyObject* self, PyObject* args)
944 {
945  int status = 0;
946  int certificate = 0;
947  int cryptUser = 0;
948  int certType = 0;
949 
950  if (!PyArg_ParseTuple(args, "ii", &cryptUser, &certType))
951  return(NULL);
952 
953  status = cryptCreateCert(&certificate, cryptUser, certType);
954 
955  return(processStatusReturnCryptHandle(status, certificate));
956 }
957 
958 static PyObject* python_cryptDestroyCert(PyObject* self, PyObject* args)
959 {
960  int status = 0;
961  int certificate = 0;
962 
963  if (!PyArg_ParseTuple(args, "i", &certificate))
964  return(NULL);
965 
966  status = cryptDestroyCert(certificate);
967 
968  return(processStatus(status));
969 }
970 
971 static PyObject* python_cryptGetCertExtension(PyObject* self, PyObject* args)
972 {
973  int status = 0;
974  int extensionLength = 0;
975  int criticalFlag = 0;
976  int certificate = 0;
977  PyObject* oid = NULL;
978  PyObject* extension = NULL;
979  int extensionMaxLength = 0;
980  unsigned char* oidPtr = 0;
981  unsigned char* extensionPtr = 0;
982 
983  if (!PyArg_ParseTuple(args, "iOOi", &certificate, &oid, &extension, &extensionMaxLength))
984  return(NULL);
985 
986  if (!getPointerReadString(oid, &oidPtr))
987  goto finish;
988 
989  if (!processStatusBool(cryptGetCertExtension(certificate, oidPtr, &criticalFlag, NULL, extensionMaxLength, &extensionLength)))
990  goto finish;
991 
992  if (!getPointerWriteCheckIndices(extension, &extensionPtr, &extensionLength))
993  goto finish;
994 
995  status = cryptGetCertExtension(certificate, oidPtr, &criticalFlag, extensionPtr, extensionMaxLength, &extensionLength);
996 
997  finish:
998  releasePointer(extension, extensionPtr);
999  releasePointerString(oid, oidPtr);
1000  return(processStatusReturnInt(status, extensionLength));
1001 }
1002 
1003 static PyObject* python_cryptAddCertExtension(PyObject* self, PyObject* args)
1004 {
1005  int status = 0;
1006  int certificate = 0;
1007  PyObject* oid = NULL;
1008  int criticalFlag = 0;
1009  PyObject* extension = NULL;
1010  int extensionLength = 0;
1011  unsigned char* oidPtr = 0;
1012  unsigned char* extensionPtr = 0;
1013 
1014  if (!PyArg_ParseTuple(args, "iOiO", &certificate, &oid, &criticalFlag, &extension))
1015  return(NULL);
1016 
1017  if (!getPointerReadString(oid, &oidPtr))
1018  goto finish;
1019 
1020  if (!getPointerRead(extension, &extensionPtr, &extensionLength))
1021  goto finish;
1022 
1023  status = cryptAddCertExtension(certificate, oidPtr, criticalFlag, extensionPtr, extensionLength);
1024 
1025  finish:
1026  releasePointer(extension, extensionPtr);
1027  releasePointerString(oid, oidPtr);
1028  return(processStatus(status));
1029 }
1030 
1031 static PyObject* python_cryptDeleteCertExtension(PyObject* self, PyObject* args)
1032 {
1033  int status = 0;
1034  int certificate = 0;
1035  PyObject* oid = NULL;
1036  unsigned char* oidPtr = 0;
1037 
1038  if (!PyArg_ParseTuple(args, "iO", &certificate, &oid))
1039  return(NULL);
1040 
1041  if (!getPointerReadString(oid, &oidPtr))
1042  goto finish;
1043 
1044  status = cryptDeleteCertExtension(certificate, oidPtr);
1045 
1046  finish:
1047  releasePointerString(oid, oidPtr);
1048  return(processStatus(status));
1049 }
1050 
1051 static PyObject* python_cryptSignCert(PyObject* self, PyObject* args)
1052 {
1053  int status = 0;
1054  int certificate = 0;
1055  int signContext = 0;
1056 
1057  if (!PyArg_ParseTuple(args, "ii", &certificate, &signContext))
1058  return(NULL);
1059 
1060  status = cryptSignCert(certificate, signContext);
1061 
1062  return(processStatus(status));
1063 }
1064 
1065 static PyObject* python_cryptCheckCert(PyObject* self, PyObject* args)
1066 {
1067  int status = 0;
1068  int certificate = 0;
1069  int sigCheckKey = 0;
1070 
1071  if (!PyArg_ParseTuple(args, "ii", &certificate, &sigCheckKey))
1072  return(NULL);
1073 
1074  status = cryptCheckCert(certificate, sigCheckKey);
1075 
1076  return(processStatus(status));
1077 }
1078 
1079 static PyObject* python_cryptImportCert(PyObject* self, PyObject* args)
1080 {
1081  int status = 0;
1082  int certificate = 0;
1083  PyObject* certObject = NULL;
1084  int certObjectLength = 0;
1085  int cryptUser = 0;
1086  unsigned char* certObjectPtr = 0;
1087 
1088  if (!PyArg_ParseTuple(args, "Oi", &certObject, &cryptUser))
1089  return(NULL);
1090 
1091  if (!getPointerRead(certObject, &certObjectPtr, &certObjectLength))
1092  goto finish;
1093 
1094  status = cryptImportCert(certObjectPtr, certObjectLength, cryptUser, &certificate);
1095 
1096  finish:
1097  releasePointer(certObject, certObjectPtr);
1098  return(processStatusReturnCryptHandle(status, certificate));
1099 }
1100 
1101 static PyObject* python_cryptExportCert(PyObject* self, PyObject* args)
1102 {
1103  int status = 0;
1104  int certObjectLength = 0;
1105  PyObject* certObject = NULL;
1106  int certObjectMaxLength = 0;
1107  int certFormatType = 0;
1108  int certificate = 0;
1109  unsigned char* certObjectPtr = 0;
1110 
1111  if (!PyArg_ParseTuple(args, "Oiii", &certObject, &certObjectMaxLength, &certFormatType, &certificate))
1112  return(NULL);
1113 
1114  if (!processStatusBool(cryptExportCert(NULL, certObjectMaxLength, &certObjectLength, certFormatType, certificate)))
1115  goto finish;
1116 
1117  if (!getPointerWriteCheckIndices(certObject, &certObjectPtr, &certObjectLength))
1118  goto finish;
1119 
1120  status = cryptExportCert(certObjectPtr, certObjectMaxLength, &certObjectLength, certFormatType, certificate);
1121 
1122  finish:
1123  releasePointer(certObject, certObjectPtr);
1124  return(processStatusReturnInt(status, certObjectLength));
1125 }
1126 
1127 static PyObject* python_cryptCAAddItem(PyObject* self, PyObject* args)
1128 {
1129  int status = 0;
1130  int keyset = 0;
1131  int certificate = 0;
1132 
1133  if (!PyArg_ParseTuple(args, "ii", &keyset, &certificate))
1134  return(NULL);
1135 
1136  status = cryptCAAddItem(keyset, certificate);
1137 
1138  return(processStatus(status));
1139 }
1140 
1141 static PyObject* python_cryptCAGetItem(PyObject* self, PyObject* args)
1142 {
1143  int status = 0;
1144  int certificate = 0;
1145  int keyset = 0;
1146  int certType = 0;
1147  int keyIDtype = 0;
1148  PyObject* keyID = NULL;
1149  unsigned char* keyIDPtr = 0;
1150 
1151  if (!PyArg_ParseTuple(args, "iiiO", &keyset, &certType, &keyIDtype, &keyID))
1152  return(NULL);
1153 
1154  if (!getPointerReadString(keyID, &keyIDPtr))
1155  goto finish;
1156 
1157  status = cryptCAGetItem(keyset, &certificate, certType, keyIDtype, keyIDPtr);
1158 
1159  finish:
1160  releasePointerString(keyID, keyIDPtr);
1161  return(processStatusReturnCryptHandle(status, certificate));
1162 }
1163 
1164 static PyObject* python_cryptCADeleteItem(PyObject* self, PyObject* args)
1165 {
1166  int status = 0;
1167  int keyset = 0;
1168  int certType = 0;
1169  int keyIDtype = 0;
1170  PyObject* keyID = NULL;
1171  unsigned char* keyIDPtr = 0;
1172 
1173  if (!PyArg_ParseTuple(args, "iiiO", &keyset, &certType, &keyIDtype, &keyID))
1174  return(NULL);
1175 
1176  if (!getPointerReadString(keyID, &keyIDPtr))
1177  goto finish;
1178 
1179  status = cryptCADeleteItem(keyset, certType, keyIDtype, keyIDPtr);
1180 
1181  finish:
1182  releasePointerString(keyID, keyIDPtr);
1183  return(processStatus(status));
1184 }
1185 
1186 static PyObject* python_cryptCACertManagement(PyObject* self, PyObject* args)
1187 {
1188  int status = 0;
1189  int certificate = 0;
1190  int action = 0;
1191  int keyset = 0;
1192  int caKey = 0;
1193  int certRequest = 0;
1194 
1195  if (!PyArg_ParseTuple(args, "iiii", &action, &keyset, &caKey, &certRequest))
1196  return(NULL);
1197 
1198  status = cryptCACertManagement(&certificate, action, keyset, caKey, certRequest);
1199 
1200  return(processStatusReturnCryptHandle(status, certificate));
1201 }
1202 
1203 static PyObject* python_cryptCreateEnvelope(PyObject* self, PyObject* args)
1204 {
1205  int status = 0;
1206  int envelope = 0;
1207  int cryptUser = 0;
1208  int formatType = 0;
1209 
1210  if (!PyArg_ParseTuple(args, "ii", &cryptUser, &formatType))
1211  return(NULL);
1212 
1213  status = cryptCreateEnvelope(&envelope, cryptUser, formatType);
1214 
1215  return(processStatusReturnCryptHandle(status, envelope));
1216 }
1217 
1218 static PyObject* python_cryptDestroyEnvelope(PyObject* self, PyObject* args)
1219 {
1220  int status = 0;
1221  int envelope = 0;
1222 
1223  if (!PyArg_ParseTuple(args, "i", &envelope))
1224  return(NULL);
1225 
1226  status = cryptDestroyEnvelope(envelope);
1227 
1228  return(processStatus(status));
1229 }
1230 
1231 static PyObject* python_cryptCreateSession(PyObject* self, PyObject* args)
1232 {
1233  int status = 0;
1234  int session = 0;
1235  int cryptUser = 0;
1236  int formatType = 0;
1237 
1238  if (!PyArg_ParseTuple(args, "ii", &cryptUser, &formatType))
1239  return(NULL);
1240 
1241  status = cryptCreateSession(&session, cryptUser, formatType);
1242 
1243  return(processStatusReturnCryptHandle(status, session));
1244 }
1245 
1246 static PyObject* python_cryptDestroySession(PyObject* self, PyObject* args)
1247 {
1248  int status = 0;
1249  int session = 0;
1250 
1251  if (!PyArg_ParseTuple(args, "i", &session))
1252  return(NULL);
1253 
1254  status = cryptDestroySession(session);
1255 
1256  return(processStatus(status));
1257 }
1258 
1259 static PyObject* python_cryptPushData(PyObject* self, PyObject* args)
1260 {
1261  int status = 0;
1262  int bytesCopied = 0;
1263  int envelope = 0;
1264  PyObject* buffer = NULL;
1265  int length = 0;
1266  unsigned char* bufferPtr = 0;
1267 
1268  if (!PyArg_ParseTuple(args, "iO", &envelope, &buffer))
1269  return(NULL);
1270 
1271  if (!getPointerRead(buffer, &bufferPtr, &length))
1272  goto finish;
1273 
1274  status = cryptPushData(envelope, bufferPtr, length, &bytesCopied);
1275 
1276  finish:
1277  releasePointer(buffer, bufferPtr);
1278  return(processStatusReturnInt(status, bytesCopied));
1279 }
1280 
1281 static PyObject* python_cryptFlushData(PyObject* self, PyObject* args)
1282 {
1283  int status = 0;
1284  int envelope = 0;
1285 
1286  if (!PyArg_ParseTuple(args, "i", &envelope))
1287  return(NULL);
1288 
1289  status = cryptFlushData(envelope);
1290 
1291  return(processStatus(status));
1292 }
1293 
1294 static PyObject* python_cryptPopData(PyObject* self, PyObject* args)
1295 {
1296  int status = 0;
1297  int bytesCopied = 0;
1298  int envelope = 0;
1299  PyObject* buffer = NULL;
1300  int length = 0;
1301  unsigned char* bufferPtr = 0;
1302 
1303  if (!PyArg_ParseTuple(args, "iOi", &envelope, &buffer, &length))
1304  return(NULL);
1305 
1306  //CryptPopData is a special case that doesn't have the length querying call
1307 
1308  if (!getPointerWrite(buffer, &bufferPtr, &bytesCopied))
1309  goto finish;
1310 
1311  status = cryptPopData(envelope, bufferPtr, length, &bytesCopied);
1312 
1313  finish:
1314  releasePointer(buffer, bufferPtr);
1315  return(processStatusReturnInt(status, bytesCopied));
1316 }
1317 
1318 static PyObject* python_cryptDeviceOpen(PyObject* self, PyObject* args)
1319 {
1320  int status = 0;
1321  int device = 0;
1322  int cryptUser = 0;
1323  int deviceType = 0;
1324  PyObject* name = NULL;
1325  unsigned char* namePtr = 0;
1326 
1327  if (!PyArg_ParseTuple(args, "iiO", &cryptUser, &deviceType, &name))
1328  return(NULL);
1329 
1330  if (!getPointerReadString(name, &namePtr))
1331  goto finish;
1332 
1333  status = cryptDeviceOpen(&device, cryptUser, deviceType, namePtr);
1334 
1335  finish:
1336  releasePointerString(name, namePtr);
1337  return(processStatusReturnCryptHandle(status, device));
1338 }
1339 
1340 static PyObject* python_cryptDeviceClose(PyObject* self, PyObject* args)
1341 {
1342  int status = 0;
1343  int device = 0;
1344 
1345  if (!PyArg_ParseTuple(args, "i", &device))
1346  return(NULL);
1347 
1348  status = cryptDeviceClose(device);
1349 
1350  return(processStatus(status));
1351 }
1352 
1353 static PyObject* python_cryptDeviceQueryCapability(PyObject* self, PyObject* args)
1354 {
1355  int status = 0;
1356  CRYPT_QUERY_INFO cryptQueryInfo;
1357  int device = 0;
1358  int cryptAlgo = 0;
1359 
1360  if (!PyArg_ParseTuple(args, "ii", &device, &cryptAlgo))
1361  return(NULL);
1362 
1363  status = cryptDeviceQueryCapability(device, cryptAlgo, &cryptQueryInfo);
1364 
1365  return(processStatusReturnCryptQueryInfo(status, cryptQueryInfo));
1366 }
1367 
1368 static PyObject* python_cryptDeviceCreateContext(PyObject* self, PyObject* args)
1369 {
1370  int status = 0;
1371  int cryptContext = 0;
1372  int device = 0;
1373  int cryptAlgo = 0;
1374 
1375  if (!PyArg_ParseTuple(args, "ii", &device, &cryptAlgo))
1376  return(NULL);
1377 
1378  status = cryptDeviceCreateContext(device, &cryptContext, cryptAlgo);
1379 
1380  return(processStatusReturnCryptHandle(status, cryptContext));
1381 }
1382 
1383 static PyObject* python_cryptLogin(PyObject* self, PyObject* args)
1384 {
1385  int status = 0;
1386  int user = 0;
1387  PyObject* name = NULL;
1388  PyObject* password = NULL;
1389  unsigned char* namePtr = 0;
1390  unsigned char* passwordPtr = 0;
1391 
1392  if (!PyArg_ParseTuple(args, "OO", &name, &password))
1393  return(NULL);
1394 
1395  if (!getPointerReadString(name, &namePtr))
1396  goto finish;
1397  if (!getPointerReadString(password, &passwordPtr))
1398  goto finish;
1399 
1400  status = cryptLogin(&user, namePtr, passwordPtr);
1401 
1402  finish:
1403  releasePointerString(name, namePtr);
1404  releasePointerString(password, passwordPtr);
1405  return(processStatusReturnCryptHandle(status, user));
1406 }
1407 
1408 static PyObject* python_cryptLogout(PyObject* self, PyObject* args)
1409 {
1410  int status = 0;
1411  int user = 0;
1412 
1413  if (!PyArg_ParseTuple(args, "i", &user))
1414  return(NULL);
1415 
1416  status = cryptLogout(user);
1417 
1418  return(processStatus(status));
1419 }
1420 
1421 
1422 
1423 static PyMethodDef module_functions[] =
1424 {
1425  { "cryptInit", python_cryptInit, METH_VARARGS },
1426  { "cryptEnd", python_cryptEnd, METH_VARARGS },
1427  { "cryptQueryCapability", python_cryptQueryCapability, METH_VARARGS },
1428  { "cryptCreateContext", python_cryptCreateContext, METH_VARARGS },
1429  { "cryptDestroyContext", python_cryptDestroyContext, METH_VARARGS },
1430  { "cryptDestroyObject", python_cryptDestroyObject, METH_VARARGS },
1431  { "cryptGenerateKey", python_cryptGenerateKey, METH_VARARGS },
1432  { "cryptGenerateKeyAsync", python_cryptGenerateKeyAsync, METH_VARARGS },
1433  { "cryptAsyncQuery", python_cryptAsyncQuery, METH_VARARGS },
1434  { "cryptAsyncCancel", python_cryptAsyncCancel, METH_VARARGS },
1435  { "cryptEncrypt", python_cryptEncrypt, METH_VARARGS },
1436  { "cryptDecrypt", python_cryptDecrypt, METH_VARARGS },
1437  { "cryptSetAttribute", python_cryptSetAttribute, METH_VARARGS },
1438  { "cryptSetAttributeString", python_cryptSetAttributeString, METH_VARARGS },
1439  { "cryptGetAttribute", python_cryptGetAttribute, METH_VARARGS },
1440  { "cryptGetAttributeString", python_cryptGetAttributeString, METH_VARARGS },
1441  { "cryptDeleteAttribute", python_cryptDeleteAttribute, METH_VARARGS },
1442  { "cryptAddRandom", python_cryptAddRandom, METH_VARARGS },
1443  { "cryptQueryObject", python_cryptQueryObject, METH_VARARGS },
1444  { "cryptExportKey", python_cryptExportKey, METH_VARARGS },
1445  { "cryptExportKeyEx", python_cryptExportKeyEx, METH_VARARGS },
1446  { "cryptImportKey", python_cryptImportKey, METH_VARARGS },
1447  { "cryptImportKeyEx", python_cryptImportKeyEx, METH_VARARGS },
1448  { "cryptCreateSignature", python_cryptCreateSignature, METH_VARARGS },
1449  { "cryptCreateSignatureEx", python_cryptCreateSignatureEx, METH_VARARGS },
1450  { "cryptCheckSignature", python_cryptCheckSignature, METH_VARARGS },
1451  { "cryptCheckSignatureEx", python_cryptCheckSignatureEx, METH_VARARGS },
1452  { "cryptKeysetOpen", python_cryptKeysetOpen, METH_VARARGS },
1453  { "cryptKeysetClose", python_cryptKeysetClose, METH_VARARGS },
1454  { "cryptGetPublicKey", python_cryptGetPublicKey, METH_VARARGS },
1455  { "cryptGetPrivateKey", python_cryptGetPrivateKey, METH_VARARGS },
1456  { "cryptGetKey", python_cryptGetKey, METH_VARARGS },
1457  { "cryptAddPublicKey", python_cryptAddPublicKey, METH_VARARGS },
1458  { "cryptAddPrivateKey", python_cryptAddPrivateKey, METH_VARARGS },
1459  { "cryptDeleteKey", python_cryptDeleteKey, METH_VARARGS },
1460  { "cryptCreateCert", python_cryptCreateCert, METH_VARARGS },
1461  { "cryptDestroyCert", python_cryptDestroyCert, METH_VARARGS },
1462  { "cryptGetCertExtension", python_cryptGetCertExtension, METH_VARARGS },
1463  { "cryptAddCertExtension", python_cryptAddCertExtension, METH_VARARGS },
1464  { "cryptDeleteCertExtension", python_cryptDeleteCertExtension, METH_VARARGS },
1465  { "cryptSignCert", python_cryptSignCert, METH_VARARGS },
1466  { "cryptCheckCert", python_cryptCheckCert, METH_VARARGS },
1467  { "cryptImportCert", python_cryptImportCert, METH_VARARGS },
1468  { "cryptExportCert", python_cryptExportCert, METH_VARARGS },
1469  { "cryptCAAddItem", python_cryptCAAddItem, METH_VARARGS },
1470  { "cryptCAGetItem", python_cryptCAGetItem, METH_VARARGS },
1471  { "cryptCADeleteItem", python_cryptCADeleteItem, METH_VARARGS },
1472  { "cryptCACertManagement", python_cryptCACertManagement, METH_VARARGS },
1473  { "cryptCreateEnvelope", python_cryptCreateEnvelope, METH_VARARGS },
1474  { "cryptDestroyEnvelope", python_cryptDestroyEnvelope, METH_VARARGS },
1475  { "cryptCreateSession", python_cryptCreateSession, METH_VARARGS },
1476  { "cryptDestroySession", python_cryptDestroySession, METH_VARARGS },
1477  { "cryptPushData", python_cryptPushData, METH_VARARGS },
1478  { "cryptFlushData", python_cryptFlushData, METH_VARARGS },
1479  { "cryptPopData", python_cryptPopData, METH_VARARGS },
1480  { "cryptDeviceOpen", python_cryptDeviceOpen, METH_VARARGS },
1481  { "cryptDeviceClose", python_cryptDeviceClose, METH_VARARGS },
1482  { "cryptDeviceQueryCapability", python_cryptDeviceQueryCapability, METH_VARARGS },
1483  { "cryptDeviceCreateContext", python_cryptDeviceCreateContext, METH_VARARGS },
1484  { "cryptLogin", python_cryptLogin, METH_VARARGS },
1485  { "cryptLogout", python_cryptLogout, METH_VARARGS },
1486  {0, 0}
1487 };
1488 
1489 DL_EXPORT(void) initcryptlib_py(void)
1490 {
1491  PyObject* module;
1492  PyObject* moduleDict;
1493 
1494  PyObject* v = NULL;
1495  PyObject *globalsDict;
1496 
1497  module = Py_InitModule("cryptlib_py", module_functions);
1498  moduleDict = PyModule_GetDict(module);
1499 
1500  CryptException = PyErr_NewException("cryptlib_py.CryptException", NULL, NULL);
1501  PyDict_SetItemString(moduleDict, "CryptException", CryptException);
1502 
1503  globalsDict = PyEval_GetGlobals();
1504  PyRun_String(
1505 "from array import *\n\
1506 import types\n\
1507 class CryptHandle:\n\
1508  def __init__(self, value):\n\
1509  self.__dict__['value'] = value\n\
1510  def __int__(self):\n\
1511  return self.value\n\
1512  def __str__(self):\n\
1513  return str(self.value)\n\
1514  def __repr__(self):\n\
1515  return str(self.value)\n\
1516  def __getattr__(self, name):\n\
1517  name = name.upper()\n\
1518  if not name.startswith('CRYPT_'):\n\
1519  name = 'CRYPT_' + name\n\
1520  nameVal = globals()[name]\n\
1521  try:\n\
1522  return cryptGetAttribute(self, nameVal)\n\
1523  except CryptException, ex:\n\
1524  length = cryptGetAttributeString(self, nameVal, None)\n\
1525  buf = array('c', '0' * length)\n\
1526  length = cryptGetAttributeString(self, nameVal, buf)\n\
1527  return ''.join(buf[:length])\n\
1528  def __setattr__(self, name, value):\n\
1529  name = name.upper()\n\
1530  if not name.startswith('CRYPT_'):\n\
1531  name = 'CRYPT_' + name\n\
1532  nameVal = globals()[name]\n\
1533  if isinstance(value, types.IntType) or isinstance(value, CryptHandle):\n\
1534  cryptSetAttribute(self, nameVal, value)\n\
1535  else:\n\
1536  cryptSetAttributeString(self, nameVal, value)\n",
1537  Py_file_input, globalsDict, moduleDict);
1538 
1539 
1540  PyRun_String(
1541 "class CRYPT_QUERY_INFO:\n\
1542  def __init__(self, algoName, blockSize, minKeySize, keySize, maxKeySize):\n\
1543  self.algoName = algoName\n\
1544  self.blockSize = blockSize\n\
1545  self.minKeySize = minKeySize\n\
1546  self.keySize = keySize\n\
1547  self.maxKeySize = maxKeySize\n",
1548  Py_file_input, globalsDict, moduleDict);
1549 
1550  PyRun_String(
1551 "class CRYPT_OBJECT_INFO:\n\
1552  def __init__(self, objectType, cryptAlgo, cryptMode, hashAlgo, salt):\n\
1553  self.objectType = objectType\n\
1554  self.cryptAlgo = cryptAlgo\n\
1555  self.cryptMode = cryptMode\n\
1556  self.hashAlgo = hashAlgo\n\
1557  self.salt = salt\n",
1558  Py_file_input, globalsDict, moduleDict);
1559 
1560  cryptHandleClass = PyMapping_GetItemString(moduleDict, "CryptHandle");
1561  cryptQueryInfoClass = PyMapping_GetItemString(moduleDict, "CRYPT_QUERY_INFO");
1562  cryptObjectInfoClass = PyMapping_GetItemString(moduleDict, "CRYPT_OBJECT_INFO");
1563 
1564  Py_DECREF(globalsDict);
1565 
1566 
1567 
1568  v = Py_BuildValue("i", 0);
1569  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_NONE", v);
1570  Py_DECREF(v); /* No encryption */
1571 
1572  v = Py_BuildValue("i", 1);
1573  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_DES", v);
1574  Py_DECREF(v); /* DES */
1575 
1576  v = Py_BuildValue("i", 2);
1577  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_3DES", v);
1578  Py_DECREF(v); /* Triple DES */
1579 
1580  v = Py_BuildValue("i", 3);
1581  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_IDEA", v);
1582  Py_DECREF(v); /* IDEA */
1583 
1584  v = Py_BuildValue("i", 4);
1585  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_CAST", v);
1586  Py_DECREF(v); /* CAST-128 */
1587 
1588  v = Py_BuildValue("i", 5);
1589  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_RC2", v);
1590  Py_DECREF(v); /* RC2 */
1591 
1592  v = Py_BuildValue("i", 6);
1593  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_RC4", v);
1594  Py_DECREF(v); /* RC4 */
1595 
1596  v = Py_BuildValue("i", 7);
1597  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_RC5", v);
1598  Py_DECREF(v); /* RC5 */
1599 
1600  v = Py_BuildValue("i", 8);
1601  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_AES", v);
1602  Py_DECREF(v); /* AES */
1603 
1604  v = Py_BuildValue("i", 9);
1605  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_BLOWFISH", v);
1606  Py_DECREF(v); /* Blowfish */
1607 
1608  v = Py_BuildValue("i", 10);
1609  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_SKIPJACK", v);
1610  Py_DECREF(v); /* Skipjack */
1611 
1612  v = Py_BuildValue("i", 100);
1613  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_DH", v);
1614  Py_DECREF(v); /* Diffie-Hellman */
1615 
1616  v = Py_BuildValue("i", 101);
1617  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_RSA", v);
1618  Py_DECREF(v); /* RSA */
1619 
1620  v = Py_BuildValue("i", 102);
1621  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_DSA", v);
1622  Py_DECREF(v); /* DSA */
1623 
1624  v = Py_BuildValue("i", 103);
1625  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_ELGAMAL", v);
1626  Py_DECREF(v); /* ElGamal */
1627 
1628  v = Py_BuildValue("i", 104);
1629  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_KEA", v);
1630  Py_DECREF(v); /* KEA */
1631 
1632  v = Py_BuildValue("i", 105);
1633  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_ECDSA", v);
1634  Py_DECREF(v); /* ECDSA */
1635 
1636  v = Py_BuildValue("i", 106);
1637  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_ECDH", v);
1638  Py_DECREF(v); /* ECDH */
1639 
1640  v = Py_BuildValue("i", 200);
1641  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_MD2", v);
1642  Py_DECREF(v); /* MD2 */
1643 
1644  v = Py_BuildValue("i", 201);
1645  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_MD4", v);
1646  Py_DECREF(v); /* MD4 */
1647 
1648  v = Py_BuildValue("i", 202);
1649  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_MD5", v);
1650  Py_DECREF(v); /* MD5 */
1651 
1652  v = Py_BuildValue("i", 203);
1653  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_SHA1", v);
1654  Py_DECREF(v); /* SHA/SHA1 */
1655 
1656  v = Py_BuildValue("i", 203);
1657  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_SHA", v);
1658  Py_DECREF(v); /* Older form */
1659 
1660  v = Py_BuildValue("i", 204);
1661  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_RIPEMD160", v);
1662  Py_DECREF(v); /* RIPE-MD 160 */
1663 
1664  v = Py_BuildValue("i", 205);
1665  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_SHA2", v);
1666  Py_DECREF(v); /* SHA-256 */
1667 
1668  v = Py_BuildValue("i", 205);
1669  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_SHA256", v);
1670  Py_DECREF(v); /* Alternate name */
1671 
1672  v = Py_BuildValue("i", 206);
1673  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_SHAng", v);
1674  Py_DECREF(v); /* Future SHA-nextgen standard */
1675 
1676  v = Py_BuildValue("i", 300);
1677  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_HMAC_MD5", v);
1678  Py_DECREF(v); /* HMAC-MD5 */
1679 
1680  v = Py_BuildValue("i", 301);
1681  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_HMAC_SHA1", v);
1682  Py_DECREF(v); /* HMAC-SHA */
1683 
1684  v = Py_BuildValue("i", 301);
1685  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_HMAC_SHA", v);
1686  Py_DECREF(v); /* Older form */
1687 
1688  v = Py_BuildValue("i", 302);
1689  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_HMAC_RIPEMD160", v);
1690  Py_DECREF(v); /* HMAC-RIPEMD-160 */
1691 
1692  v = Py_BuildValue("i", 303);
1693  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_HMAC_SHA2", v);
1694  Py_DECREF(v); /* HMAC-SHA2 */
1695 
1696  v = Py_BuildValue("i", 304);
1697  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_HMAC_SHAng", v);
1698  Py_DECREF(v); /* HMAC-future-SHA-nextgen */
1699 
1700  v = Py_BuildValue("i", 305);
1701  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_LAST", v);
1702  Py_DECREF(v); /* Last possible crypt algo value */
1703 
1704  v = Py_BuildValue("i", 1);
1705  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_FIRST_CONVENTIONAL", v);
1706  Py_DECREF(v);
1707 
1708  v = Py_BuildValue("i", 99);
1709  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_LAST_CONVENTIONAL", v);
1710  Py_DECREF(v);
1711 
1712  v = Py_BuildValue("i", 100);
1713  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_FIRST_PKC", v);
1714  Py_DECREF(v);
1715 
1716  v = Py_BuildValue("i", 199);
1717  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_LAST_PKC", v);
1718  Py_DECREF(v);
1719 
1720  v = Py_BuildValue("i", 200);
1721  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_FIRST_HASH", v);
1722  Py_DECREF(v);
1723 
1724  v = Py_BuildValue("i", 299);
1725  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_LAST_HASH", v);
1726  Py_DECREF(v);
1727 
1728  v = Py_BuildValue("i", 300);
1729  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_FIRST_MAC", v);
1730  Py_DECREF(v);
1731 
1732  v = Py_BuildValue("i", 399);
1733  PyDict_SetItemString(moduleDict, "CRYPT_ALGO_LAST_MAC", v);
1734  Py_DECREF(v); /* End of mac algo.range */
1735 
1736  v = Py_BuildValue("i", 0);
1737  PyDict_SetItemString(moduleDict, "CRYPT_MODE_NONE", v);
1738  Py_DECREF(v); /* No encryption mode */
1739 
1740  v = Py_BuildValue("i", 1);
1741  PyDict_SetItemString(moduleDict, "CRYPT_MODE_ECB", v);
1742  Py_DECREF(v); /* ECB */
1743 
1744  v = Py_BuildValue("i", 2);
1745  PyDict_SetItemString(moduleDict, "CRYPT_MODE_CBC", v);
1746  Py_DECREF(v); /* CBC */
1747 
1748  v = Py_BuildValue("i", 3);
1749  PyDict_SetItemString(moduleDict, "CRYPT_MODE_CFB", v);
1750  Py_DECREF(v); /* CFB */
1751 
1752  v = Py_BuildValue("i", 4);
1753  PyDict_SetItemString(moduleDict, "CRYPT_MODE_OFB", v);
1754  Py_DECREF(v); /* OFB */
1755 
1756  v = Py_BuildValue("i", 5);
1757  PyDict_SetItemString(moduleDict, "CRYPT_MODE_GCM", v);
1758  Py_DECREF(v); /* GCM */
1759 
1760  v = Py_BuildValue("i", 6);
1761  PyDict_SetItemString(moduleDict, "CRYPT_MODE_LAST", v);
1762  Py_DECREF(v); /* Last possible crypt mode value */
1763 
1764  v = Py_BuildValue("i", 0);
1765  PyDict_SetItemString(moduleDict, "CRYPT_KEYSET_NONE", v);
1766  Py_DECREF(v); /* No keyset type */
1767 
1768  v = Py_BuildValue("i", 1);
1769  PyDict_SetItemString(moduleDict, "CRYPT_KEYSET_FILE", v);
1770  Py_DECREF(v); /* Generic flat file keyset */
1771 
1772  v = Py_BuildValue("i", 2);
1773  PyDict_SetItemString(moduleDict, "CRYPT_KEYSET_HTTP", v);
1774  Py_DECREF(v); /* Web page containing cert/CRL */
1775 
1776  v = Py_BuildValue("i", 3);
1777  PyDict_SetItemString(moduleDict, "CRYPT_KEYSET_LDAP", v);
1778  Py_DECREF(v); /* LDAP directory service */
1779 
1780  v = Py_BuildValue("i", 4);
1781  PyDict_SetItemString(moduleDict, "CRYPT_KEYSET_ODBC", v);
1782  Py_DECREF(v); /* Generic ODBC interface */
1783 
1784  v = Py_BuildValue("i", 5);
1785  PyDict_SetItemString(moduleDict, "CRYPT_KEYSET_DATABASE", v);
1786  Py_DECREF(v); /* Generic RDBMS interface */
1787 
1788  v = Py_BuildValue("i", 6);
1789  PyDict_SetItemString(moduleDict, "CRYPT_KEYSET_ODBC_STORE", v);
1790  Py_DECREF(v); /* ODBC certificate store */
1791 
1792  v = Py_BuildValue("i", 7);
1793  PyDict_SetItemString(moduleDict, "CRYPT_KEYSET_DATABASE_STORE", v);
1794  Py_DECREF(v); /* Database certificate store */
1795 
1796  v = Py_BuildValue("i", 8);
1797  PyDict_SetItemString(moduleDict, "CRYPT_KEYSET_LAST", v);
1798  Py_DECREF(v); /* Last possible keyset type */
1799 
1800  v = Py_BuildValue("i", 0);
1801  PyDict_SetItemString(moduleDict, "CRYPT_DEVICE_NONE", v);
1802  Py_DECREF(v); /* No crypto device */
1803 
1804  v = Py_BuildValue("i", 1);
1805  PyDict_SetItemString(moduleDict, "CRYPT_DEVICE_FORTEZZA", v);
1806  Py_DECREF(v); /* Fortezza card */
1807 
1808  v = Py_BuildValue("i", 2);
1809  PyDict_SetItemString(moduleDict, "CRYPT_DEVICE_PKCS11", v);
1810  Py_DECREF(v); /* PKCS #11 crypto token */
1811 
1812  v = Py_BuildValue("i", 3);
1813  PyDict_SetItemString(moduleDict, "CRYPT_DEVICE_CRYPTOAPI", v);
1814  Py_DECREF(v); /* Microsoft CryptoAPI */
1815 
1816  v = Py_BuildValue("i", 4);
1817  PyDict_SetItemString(moduleDict, "CRYPT_DEVICE_HARDWARE", v);
1818  Py_DECREF(v); /* Generic crypo HW plugin */
1819 
1820  v = Py_BuildValue("i", 5);
1821  PyDict_SetItemString(moduleDict, "CRYPT_DEVICE_LAST", v);
1822  Py_DECREF(v); /* Last possible crypto device type */
1823 
1824  v = Py_BuildValue("i", 0);
1825  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_NONE", v);
1826  Py_DECREF(v); /* No certificate type */
1827 
1828  v = Py_BuildValue("i", 1);
1829  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_CERTIFICATE", v);
1830  Py_DECREF(v); /* Certificate */
1831 
1832  v = Py_BuildValue("i", 2);
1833  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_ATTRIBUTE_CERT", v);
1834  Py_DECREF(v); /* Attribute certificate */
1835 
1836  v = Py_BuildValue("i", 3);
1837  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_CERTCHAIN", v);
1838  Py_DECREF(v); /* PKCS #7 certificate chain */
1839 
1840  v = Py_BuildValue("i", 4);
1841  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_CERTREQUEST", v);
1842  Py_DECREF(v); /* PKCS #10 certification request */
1843 
1844  v = Py_BuildValue("i", 5);
1845  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_REQUEST_CERT", v);
1846  Py_DECREF(v); /* CRMF certification request */
1847 
1848  v = Py_BuildValue("i", 6);
1849  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_REQUEST_REVOCATION", v);
1850  Py_DECREF(v); /* CRMF revocation request */
1851 
1852  v = Py_BuildValue("i", 7);
1853  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_CRL", v);
1854  Py_DECREF(v); /* CRL */
1855 
1856  v = Py_BuildValue("i", 8);
1857  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_CMS_ATTRIBUTES", v);
1858  Py_DECREF(v); /* CMS attributes */
1859 
1860  v = Py_BuildValue("i", 9);
1861  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_RTCS_REQUEST", v);
1862  Py_DECREF(v); /* RTCS request */
1863 
1864  v = Py_BuildValue("i", 10);
1865  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_RTCS_RESPONSE", v);
1866  Py_DECREF(v); /* RTCS response */
1867 
1868  v = Py_BuildValue("i", 11);
1869  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_OCSP_REQUEST", v);
1870  Py_DECREF(v); /* OCSP request */
1871 
1872  v = Py_BuildValue("i", 12);
1873  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_OCSP_RESPONSE", v);
1874  Py_DECREF(v); /* OCSP response */
1875 
1876  v = Py_BuildValue("i", 13);
1877  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_PKIUSER", v);
1878  Py_DECREF(v); /* PKI user information */
1879 
1880  v = Py_BuildValue("i", 14);
1881  PyDict_SetItemString(moduleDict, "CRYPT_CERTTYPE_LAST", v);
1882  Py_DECREF(v); /* Last possible cert.type */
1883 
1884  v = Py_BuildValue("i", 0);
1885  PyDict_SetItemString(moduleDict, "CRYPT_FORMAT_NONE", v);
1886  Py_DECREF(v); /* No format type */
1887 
1888  v = Py_BuildValue("i", 1);
1889  PyDict_SetItemString(moduleDict, "CRYPT_FORMAT_AUTO", v);
1890  Py_DECREF(v); /* Deenv, auto-determine type */
1891 
1892  v = Py_BuildValue("i", 2);
1893  PyDict_SetItemString(moduleDict, "CRYPT_FORMAT_CRYPTLIB", v);
1894  Py_DECREF(v); /* cryptlib native format */
1895 
1896  v = Py_BuildValue("i", 3);
1897  PyDict_SetItemString(moduleDict, "CRYPT_FORMAT_CMS", v);
1898  Py_DECREF(v); /* PKCS #7 / CMS / S/MIME fmt. */
1899 
1900  v = Py_BuildValue("i", 3);
1901  PyDict_SetItemString(moduleDict, "CRYPT_FORMAT_PKCS7", v);
1902  Py_DECREF(v);
1903 
1904  v = Py_BuildValue("i", 4);
1905  PyDict_SetItemString(moduleDict, "CRYPT_FORMAT_SMIME", v);
1906  Py_DECREF(v); /* As CMS with MSG-style behaviour */
1907 
1908  v = Py_BuildValue("i", 5);
1909  PyDict_SetItemString(moduleDict, "CRYPT_FORMAT_PGP", v);
1910  Py_DECREF(v); /* PGP format */
1911 
1912  v = Py_BuildValue("i", 6);
1913  PyDict_SetItemString(moduleDict, "CRYPT_FORMAT_LAST", v);
1914  Py_DECREF(v); /* Last possible format type */
1915 
1916  v = Py_BuildValue("i", 0);
1917  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_NONE", v);
1918  Py_DECREF(v); /* No session type */
1919 
1920  v = Py_BuildValue("i", 1);
1921  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_SSH", v);
1922  Py_DECREF(v); /* SSH */
1923 
1924  v = Py_BuildValue("i", 2);
1925  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_SSH_SERVER", v);
1926  Py_DECREF(v); /* SSH server */
1927 
1928  v = Py_BuildValue("i", 3);
1929  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_SSL", v);
1930  Py_DECREF(v); /* SSL/TLS */
1931 
1932  v = Py_BuildValue("i", 4);
1933  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_SSL_SERVER", v);
1934  Py_DECREF(v); /* SSL/TLS server */
1935 
1936  v = Py_BuildValue("i", 5);
1937  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_RTCS", v);
1938  Py_DECREF(v); /* RTCS */
1939 
1940  v = Py_BuildValue("i", 6);
1941  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_RTCS_SERVER", v);
1942  Py_DECREF(v); /* RTCS server */
1943 
1944  v = Py_BuildValue("i", 7);
1945  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_OCSP", v);
1946  Py_DECREF(v); /* OCSP */
1947 
1948  v = Py_BuildValue("i", 8);
1949  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_OCSP_SERVER", v);
1950  Py_DECREF(v); /* OCSP server */
1951 
1952  v = Py_BuildValue("i", 9);
1953  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_TSP", v);
1954  Py_DECREF(v); /* TSP */
1955 
1956  v = Py_BuildValue("i", 10);
1957  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_TSP_SERVER", v);
1958  Py_DECREF(v); /* TSP server */
1959 
1960  v = Py_BuildValue("i", 11);
1961  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_CMP", v);
1962  Py_DECREF(v); /* CMP */
1963 
1964  v = Py_BuildValue("i", 12);
1965  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_CMP_SERVER", v);
1966  Py_DECREF(v); /* CMP server */
1967 
1968  v = Py_BuildValue("i", 13);
1969  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_SCEP", v);
1970  Py_DECREF(v); /* SCEP */
1971 
1972  v = Py_BuildValue("i", 14);
1973  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_SCEP_SERVER", v);
1974  Py_DECREF(v); /* SCEP server */
1975 
1976  v = Py_BuildValue("i", 15);
1977  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_CERTSTORE_SERVER", v);
1978  Py_DECREF(v); /* HTTP cert store interface */
1979 
1980  v = Py_BuildValue("i", 16);
1981  PyDict_SetItemString(moduleDict, "CRYPT_SESSION_LAST", v);
1982  Py_DECREF(v); /* Last possible session type */
1983 
1984  v = Py_BuildValue("i", 0);
1985  PyDict_SetItemString(moduleDict, "CRYPT_USER_NONE", v);
1986  Py_DECREF(v); /* No user type */
1987 
1988  v = Py_BuildValue("i", 1);
1989  PyDict_SetItemString(moduleDict, "CRYPT_USER_NORMAL", v);
1990  Py_DECREF(v); /* Normal user */
1991 
1992  v = Py_BuildValue("i", 2);
1993  PyDict_SetItemString(moduleDict, "CRYPT_USER_SO", v);
1994  Py_DECREF(v); /* Security officer */
1995 
1996  v = Py_BuildValue("i", 3);
1997  PyDict_SetItemString(moduleDict, "CRYPT_USER_CA", v);
1998  Py_DECREF(v); /* CA user */
1999 
2000  v = Py_BuildValue("i", 4);
2001  PyDict_SetItemString(moduleDict, "CRYPT_USER_LAST", v);
2002  Py_DECREF(v); /* Last possible user type */
2003 
2004  v = Py_BuildValue("i", 0);
2005  PyDict_SetItemString(moduleDict, "CRYPT_ATTRIBUTE_NONE", v);
2006  Py_DECREF(v); /* Non-value */
2007 
2008  v = Py_BuildValue("i", 1);
2009  PyDict_SetItemString(moduleDict, "CRYPT_PROPERTY_FIRST", v);
2010  Py_DECREF(v); /* ******************* */
2011 
2012  v = Py_BuildValue("i", 2);
2013  PyDict_SetItemString(moduleDict, "CRYPT_PROPERTY_HIGHSECURITY", v);
2014  Py_DECREF(v); /* Owned+non-forwardcount+locked */
2015 
2016  v = Py_BuildValue("i", 3);
2017  PyDict_SetItemString(moduleDict, "CRYPT_PROPERTY_OWNER", v);
2018  Py_DECREF(v); /* Object owner */
2019 
2020  v = Py_BuildValue("i", 4);
2021  PyDict_SetItemString(moduleDict, "CRYPT_PROPERTY_FORWARDCOUNT", v);
2022  Py_DECREF(v); /* No.of times object can be forwarded */
2023 
2024  v = Py_BuildValue("i", 5);
2025  PyDict_SetItemString(moduleDict, "CRYPT_PROPERTY_LOCKED", v);
2026  Py_DECREF(v); /* Whether properties can be chged/read */
2027 
2028  v = Py_BuildValue("i", 6);
2029  PyDict_SetItemString(moduleDict, "CRYPT_PROPERTY_USAGECOUNT", v);
2030  Py_DECREF(v); /* Usage count before object expires */
2031 
2032  v = Py_BuildValue("i", 7);
2033  PyDict_SetItemString(moduleDict, "CRYPT_PROPERTY_NONEXPORTABLE", v);
2034  Py_DECREF(v); /* Whether key is nonexp.from context */
2035 
2036  v = Py_BuildValue("i", 8);
2037  PyDict_SetItemString(moduleDict, "CRYPT_PROPERTY_LAST", v);
2038  Py_DECREF(v);
2039 
2040  v = Py_BuildValue("i", 9);
2041  PyDict_SetItemString(moduleDict, "CRYPT_GENERIC_FIRST", v);
2042  Py_DECREF(v); /* Extended error information */
2043 
2044  v = Py_BuildValue("i", 10);
2045  PyDict_SetItemString(moduleDict, "CRYPT_ATTRIBUTE_ERRORTYPE", v);
2046  Py_DECREF(v); /* Type of last error */
2047 
2048  v = Py_BuildValue("i", 11);
2049  PyDict_SetItemString(moduleDict, "CRYPT_ATTRIBUTE_ERRORLOCUS", v);
2050  Py_DECREF(v); /* Locus of last error */
2051 
2052  v = Py_BuildValue("i", 12);
2053  PyDict_SetItemString(moduleDict, "CRYPT_ATTRIBUTE_ERRORMESSAGE", v);
2054  Py_DECREF(v); /* Detailed error description */
2055 
2056  v = Py_BuildValue("i", 13);
2057  PyDict_SetItemString(moduleDict, "CRYPT_ATTRIBUTE_CURRENT_GROUP", v);
2058  Py_DECREF(v); /* Cursor mgt: Group in attribute list */
2059 
2060  v = Py_BuildValue("i", 14);
2061  PyDict_SetItemString(moduleDict, "CRYPT_ATTRIBUTE_CURRENT", v);
2062  Py_DECREF(v); /* Cursor mgt: Entry in attribute list */
2063 
2064  v = Py_BuildValue("i", 15);
2065  PyDict_SetItemString(moduleDict, "CRYPT_ATTRIBUTE_CURRENT_INSTANCE", v);
2066  Py_DECREF(v); /* Cursor mgt: Instance in attribute list */
2067 
2068  v = Py_BuildValue("i", 16);
2069  PyDict_SetItemString(moduleDict, "CRYPT_ATTRIBUTE_BUFFERSIZE", v);
2070  Py_DECREF(v); /* Internal data buffer size */
2071 
2072  v = Py_BuildValue("i", 17);
2073  PyDict_SetItemString(moduleDict, "CRYPT_GENERIC_LAST", v);
2074  Py_DECREF(v);
2075 
2076  v = Py_BuildValue("i", 100);
2077  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_FIRST", v);
2078  Py_DECREF(v); /* ************************** */
2079 
2080  v = Py_BuildValue("i", 101);
2081  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_INFO_DESCRIPTION", v);
2082  Py_DECREF(v); /* Text description */
2083 
2084  v = Py_BuildValue("i", 102);
2085  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_INFO_COPYRIGHT", v);
2086  Py_DECREF(v); /* Copyright notice */
2087 
2088  v = Py_BuildValue("i", 103);
2089  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_INFO_MAJORVERSION", v);
2090  Py_DECREF(v); /* Major release version */
2091 
2092  v = Py_BuildValue("i", 104);
2093  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_INFO_MINORVERSION", v);
2094  Py_DECREF(v); /* Minor release version */
2095 
2096  v = Py_BuildValue("i", 105);
2097  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_INFO_STEPPING", v);
2098  Py_DECREF(v); /* Release stepping */
2099 
2100  v = Py_BuildValue("i", 106);
2101  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_ENCR_ALGO", v);
2102  Py_DECREF(v); /* Encryption algorithm */
2103 
2104  v = Py_BuildValue("i", 107);
2105  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_ENCR_HASH", v);
2106  Py_DECREF(v); /* Hash algorithm */
2107 
2108  v = Py_BuildValue("i", 108);
2109  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_ENCR_MAC", v);
2110  Py_DECREF(v); /* MAC algorithm */
2111 
2112  v = Py_BuildValue("i", 109);
2113  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_PKC_ALGO", v);
2114  Py_DECREF(v); /* Public-key encryption algorithm */
2115 
2116  v = Py_BuildValue("i", 110);
2117  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_PKC_KEYSIZE", v);
2118  Py_DECREF(v); /* Public-key encryption key size */
2119 
2120  v = Py_BuildValue("i", 111);
2121  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_SIG_ALGO", v);
2122  Py_DECREF(v); /* Signature algorithm */
2123 
2124  v = Py_BuildValue("i", 112);
2125  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_SIG_KEYSIZE", v);
2126  Py_DECREF(v); /* Signature keysize */
2127 
2128  v = Py_BuildValue("i", 113);
2129  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_KEYING_ALGO", v);
2130  Py_DECREF(v); /* Key processing algorithm */
2131 
2132  v = Py_BuildValue("i", 114);
2133  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_KEYING_ITERATIONS", v);
2134  Py_DECREF(v); /* Key processing iterations */
2135 
2136  v = Py_BuildValue("i", 115);
2137  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_CERT_SIGNUNRECOGNISEDATTRIBUTES", v);
2138  Py_DECREF(v); /* Whether to sign unrecog.attrs */
2139 
2140  v = Py_BuildValue("i", 116);
2141  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_CERT_VALIDITY", v);
2142  Py_DECREF(v); /* Certificate validity period */
2143 
2144  v = Py_BuildValue("i", 117);
2145  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_CERT_UPDATEINTERVAL", v);
2146  Py_DECREF(v); /* CRL update interval */
2147 
2148  v = Py_BuildValue("i", 118);
2149  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_CERT_COMPLIANCELEVEL", v);
2150  Py_DECREF(v); /* PKIX compliance level for cert chks. */
2151 
2152  v = Py_BuildValue("i", 119);
2153  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_CERT_REQUIREPOLICY", v);
2154  Py_DECREF(v); /* Whether explicit policy req'd for certs */
2155 
2156  v = Py_BuildValue("i", 120);
2157  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_CMS_DEFAULTATTRIBUTES", v);
2158  Py_DECREF(v); /* Add default CMS attributes */
2159 
2160  v = Py_BuildValue("i", 120);
2161  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_SMIME_DEFAULTATTRIBUTES", v);
2162  Py_DECREF(v); /* LDAP keyset options */
2163 
2164  v = Py_BuildValue("i", 121);
2165  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_KEYS_LDAP_OBJECTCLASS", v);
2166  Py_DECREF(v); /* Object class */
2167 
2168  v = Py_BuildValue("i", 122);
2169  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_KEYS_LDAP_OBJECTTYPE", v);
2170  Py_DECREF(v); /* Object type to fetch */
2171 
2172  v = Py_BuildValue("i", 123);
2173  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_KEYS_LDAP_FILTER", v);
2174  Py_DECREF(v); /* Query filter */
2175 
2176  v = Py_BuildValue("i", 124);
2177  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_KEYS_LDAP_CACERTNAME", v);
2178  Py_DECREF(v); /* CA certificate attribute name */
2179 
2180  v = Py_BuildValue("i", 125);
2181  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_KEYS_LDAP_CERTNAME", v);
2182  Py_DECREF(v); /* Certificate attribute name */
2183 
2184  v = Py_BuildValue("i", 126);
2185  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_KEYS_LDAP_CRLNAME", v);
2186  Py_DECREF(v); /* CRL attribute name */
2187 
2188  v = Py_BuildValue("i", 127);
2189  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_KEYS_LDAP_EMAILNAME", v);
2190  Py_DECREF(v); /* Email attribute name */
2191 
2192  v = Py_BuildValue("i", 128);
2193  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_DEVICE_PKCS11_DVR01", v);
2194  Py_DECREF(v); /* Name of first PKCS #11 driver */
2195 
2196  v = Py_BuildValue("i", 129);
2197  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_DEVICE_PKCS11_DVR02", v);
2198  Py_DECREF(v); /* Name of second PKCS #11 driver */
2199 
2200  v = Py_BuildValue("i", 130);
2201  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_DEVICE_PKCS11_DVR03", v);
2202  Py_DECREF(v); /* Name of third PKCS #11 driver */
2203 
2204  v = Py_BuildValue("i", 131);
2205  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_DEVICE_PKCS11_DVR04", v);
2206  Py_DECREF(v); /* Name of fourth PKCS #11 driver */
2207 
2208  v = Py_BuildValue("i", 132);
2209  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_DEVICE_PKCS11_DVR05", v);
2210  Py_DECREF(v); /* Name of fifth PKCS #11 driver */
2211 
2212  v = Py_BuildValue("i", 133);
2213  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_DEVICE_PKCS11_HARDWAREONLY", v);
2214  Py_DECREF(v); /* Use only hardware mechanisms */
2215 
2216  v = Py_BuildValue("i", 134);
2217  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_NET_SOCKS_SERVER", v);
2218  Py_DECREF(v); /* Socks server name */
2219 
2220  v = Py_BuildValue("i", 135);
2221  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_NET_SOCKS_USERNAME", v);
2222  Py_DECREF(v); /* Socks user name */
2223 
2224  v = Py_BuildValue("i", 136);
2225  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_NET_HTTP_PROXY", v);
2226  Py_DECREF(v); /* Web proxy server */
2227 
2228  v = Py_BuildValue("i", 137);
2229  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_NET_CONNECTTIMEOUT", v);
2230  Py_DECREF(v); /* Timeout for network connection setup */
2231 
2232  v = Py_BuildValue("i", 138);
2233  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_NET_READTIMEOUT", v);
2234  Py_DECREF(v); /* Timeout for network reads */
2235 
2236  v = Py_BuildValue("i", 139);
2237  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_NET_WRITETIMEOUT", v);
2238  Py_DECREF(v); /* Timeout for network writes */
2239 
2240  v = Py_BuildValue("i", 140);
2241  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_MISC_ASYNCINIT", v);
2242  Py_DECREF(v); /* Whether to init cryptlib async'ly */
2243 
2244  v = Py_BuildValue("i", 141);
2245  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_MISC_SIDECHANNELPROTECTION", v);
2246  Py_DECREF(v); /* Protect against side-channel attacks */
2247 
2248  v = Py_BuildValue("i", 142);
2249  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_CONFIGCHANGED", v);
2250  Py_DECREF(v); /* Whether in-mem.opts match on-disk ones */
2251 
2252  v = Py_BuildValue("i", 143);
2253  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_SELFTESTOK", v);
2254  Py_DECREF(v); /* Whether self-test was completed and OK */
2255 
2256  v = Py_BuildValue("i", 144);
2257  PyDict_SetItemString(moduleDict, "CRYPT_OPTION_LAST", v);
2258  Py_DECREF(v);
2259 
2260  v = Py_BuildValue("i", 1000);
2261  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_FIRST", v);
2262  Py_DECREF(v); /* ******************** */
2263 
2264  v = Py_BuildValue("i", 1001);
2265  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_ALGO", v);
2266  Py_DECREF(v); /* Algorithm */
2267 
2268  v = Py_BuildValue("i", 1002);
2269  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_MODE", v);
2270  Py_DECREF(v); /* Mode */
2271 
2272  v = Py_BuildValue("i", 1003);
2273  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_NAME_ALGO", v);
2274  Py_DECREF(v); /* Algorithm name */
2275 
2276  v = Py_BuildValue("i", 1004);
2277  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_NAME_MODE", v);
2278  Py_DECREF(v); /* Mode name */
2279 
2280  v = Py_BuildValue("i", 1005);
2281  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_KEYSIZE", v);
2282  Py_DECREF(v); /* Key size in bytes */
2283 
2284  v = Py_BuildValue("i", 1006);
2285  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_BLOCKSIZE", v);
2286  Py_DECREF(v); /* Block size */
2287 
2288  v = Py_BuildValue("i", 1007);
2289  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_IVSIZE", v);
2290  Py_DECREF(v); /* IV size */
2291 
2292  v = Py_BuildValue("i", 1008);
2293  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_KEYING_ALGO", v);
2294  Py_DECREF(v); /* Key processing algorithm */
2295 
2296  v = Py_BuildValue("i", 1009);
2297  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_KEYING_ITERATIONS", v);
2298  Py_DECREF(v); /* Key processing iterations */
2299 
2300  v = Py_BuildValue("i", 1010);
2301  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_KEYING_SALT", v);
2302  Py_DECREF(v); /* Key processing salt */
2303 
2304  v = Py_BuildValue("i", 1011);
2305  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_KEYING_VALUE", v);
2306  Py_DECREF(v); /* Value used to derive key */
2307 
2308  v = Py_BuildValue("i", 1012);
2309  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_KEY", v);
2310  Py_DECREF(v); /* Key */
2311 
2312  v = Py_BuildValue("i", 1013);
2313  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_KEY_COMPONENTS", v);
2314  Py_DECREF(v); /* Public-key components */
2315 
2316  v = Py_BuildValue("i", 1014);
2317  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_IV", v);
2318  Py_DECREF(v); /* IV */
2319 
2320  v = Py_BuildValue("i", 1015);
2321  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_HASHVALUE", v);
2322  Py_DECREF(v); /* Hash value */
2323 
2324  v = Py_BuildValue("i", 1016);
2325  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_LABEL", v);
2326  Py_DECREF(v); /* Label for private/secret key */
2327 
2328  v = Py_BuildValue("i", 1017);
2329  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_PERSISTENT", v);
2330  Py_DECREF(v); /* Obj.is backed by device or keyset */
2331 
2332  v = Py_BuildValue("i", 1018);
2333  PyDict_SetItemString(moduleDict, "CRYPT_CTXINFO_LAST", v);
2334  Py_DECREF(v);
2335 
2336  v = Py_BuildValue("i", 2000);
2337  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_FIRST", v);
2338  Py_DECREF(v); /* ************************ */
2339 
2340  v = Py_BuildValue("i", 2001);
2341  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SELFSIGNED", v);
2342  Py_DECREF(v); /* Cert is self-signed */
2343 
2344  v = Py_BuildValue("i", 2002);
2345  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_IMMUTABLE", v);
2346  Py_DECREF(v); /* Cert is signed and immutable */
2347 
2348  v = Py_BuildValue("i", 2003);
2349  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_XYZZY", v);
2350  Py_DECREF(v); /* Cert is a magic just-works cert */
2351 
2352  v = Py_BuildValue("i", 2004);
2353  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CERTTYPE", v);
2354  Py_DECREF(v); /* Certificate object type */
2355 
2356  v = Py_BuildValue("i", 2005);
2357  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_FINGERPRINT", v);
2358  Py_DECREF(v); /* Certificate fingerprints */
2359 
2360  v = Py_BuildValue("i", 2005);
2361  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_FINGERPRINT_MD5", v);
2362  Py_DECREF(v);
2363 
2364  v = Py_BuildValue("i", 2006);
2365  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_FINGERPRINT_SHA1", v);
2366  Py_DECREF(v);
2367 
2368  v = Py_BuildValue("i", 2006);
2369  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_FINGERPRINT_SHA", v);
2370  Py_DECREF(v);
2371 
2372  v = Py_BuildValue("i", 2007);
2373  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_FINGERPRINT_SHA2", v);
2374  Py_DECREF(v);
2375 
2376  v = Py_BuildValue("i", 2008);
2377  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_FINGERPRINT_SHAng", v);
2378  Py_DECREF(v);
2379 
2380  v = Py_BuildValue("i", 2009);
2381  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CURRENT_CERTIFICATE", v);
2382  Py_DECREF(v); /* Cursor mgt: Rel.pos in chain/CRL/OCSP */
2383 
2384  v = Py_BuildValue("i", 2010);
2385  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_TRUSTED_USAGE", v);
2386  Py_DECREF(v); /* Usage that cert is trusted for */
2387 
2388  v = Py_BuildValue("i", 2011);
2389  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_TRUSTED_IMPLICIT", v);
2390  Py_DECREF(v); /* Whether cert is implicitly trusted */
2391 
2392  v = Py_BuildValue("i", 2012);
2393  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGNATURELEVEL", v);
2394  Py_DECREF(v); /* Amount of detail to include in sigs. */
2395 
2396  v = Py_BuildValue("i", 2013);
2397  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_VERSION", v);
2398  Py_DECREF(v); /* Cert.format version */
2399 
2400  v = Py_BuildValue("i", 2014);
2401  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SERIALNUMBER", v);
2402  Py_DECREF(v); /* Serial number */
2403 
2404  v = Py_BuildValue("i", 2015);
2405  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTPUBLICKEYINFO", v);
2406  Py_DECREF(v); /* Public key */
2407 
2408  v = Py_BuildValue("i", 2016);
2409  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CERTIFICATE", v);
2410  Py_DECREF(v); /* User certificate */
2411 
2412  v = Py_BuildValue("i", 2016);
2413  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_USERCERTIFICATE", v);
2414  Py_DECREF(v);
2415 
2416  v = Py_BuildValue("i", 2017);
2417  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CACERTIFICATE", v);
2418  Py_DECREF(v); /* CA certificate */
2419 
2420  v = Py_BuildValue("i", 2018);
2421  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ISSUERNAME", v);
2422  Py_DECREF(v); /* Issuer DN */
2423 
2424  v = Py_BuildValue("i", 2019);
2425  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_VALIDFROM", v);
2426  Py_DECREF(v); /* Cert valid-from time */
2427 
2428  v = Py_BuildValue("i", 2020);
2429  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_VALIDTO", v);
2430  Py_DECREF(v); /* Cert valid-to time */
2431 
2432  v = Py_BuildValue("i", 2021);
2433  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTNAME", v);
2434  Py_DECREF(v); /* Subject DN */
2435 
2436  v = Py_BuildValue("i", 2022);
2437  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ISSUERUNIQUEID", v);
2438  Py_DECREF(v); /* Issuer unique ID */
2439 
2440  v = Py_BuildValue("i", 2023);
2441  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTUNIQUEID", v);
2442  Py_DECREF(v); /* Subject unique ID */
2443 
2444  v = Py_BuildValue("i", 2024);
2445  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CERTREQUEST", v);
2446  Py_DECREF(v); /* Cert.request (DN + public key) */
2447 
2448  v = Py_BuildValue("i", 2025);
2449  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_THISUPDATE", v);
2450  Py_DECREF(v); /* CRL/OCSP current-update time */
2451 
2452  v = Py_BuildValue("i", 2026);
2453  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_NEXTUPDATE", v);
2454  Py_DECREF(v); /* CRL/OCSP next-update time */
2455 
2456  v = Py_BuildValue("i", 2027);
2457  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_REVOCATIONDATE", v);
2458  Py_DECREF(v); /* CRL/OCSP cert-revocation time */
2459 
2460  v = Py_BuildValue("i", 2028);
2461  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_REVOCATIONSTATUS", v);
2462  Py_DECREF(v); /* OCSP revocation status */
2463 
2464  v = Py_BuildValue("i", 2029);
2465  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CERTSTATUS", v);
2466  Py_DECREF(v); /* RTCS certificate status */
2467 
2468  v = Py_BuildValue("i", 2030);
2469  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_DN", v);
2470  Py_DECREF(v); /* Currently selected DN in string form */
2471 
2472  v = Py_BuildValue("i", 2031);
2473  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_PKIUSER_ID", v);
2474  Py_DECREF(v); /* PKI user ID */
2475 
2476  v = Py_BuildValue("i", 2032);
2477  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_PKIUSER_ISSUEPASSWORD", v);
2478  Py_DECREF(v); /* PKI user issue password */
2479 
2480  v = Py_BuildValue("i", 2033);
2481  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_PKIUSER_REVPASSWORD", v);
2482  Py_DECREF(v); /* PKI user revocation password */
2483 
2484  v = Py_BuildValue("i", 2100);
2485  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_COUNTRYNAME", v);
2486  Py_DECREF(v); /* countryName */
2487 
2488  v = Py_BuildValue("i", 2101);
2489  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_STATEORPROVINCENAME", v);
2490  Py_DECREF(v); /* stateOrProvinceName */
2491 
2492  v = Py_BuildValue("i", 2102);
2493  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_LOCALITYNAME", v);
2494  Py_DECREF(v); /* localityName */
2495 
2496  v = Py_BuildValue("i", 2103);
2497  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ORGANIZATIONNAME", v);
2498  Py_DECREF(v); /* organizationName */
2499 
2500  v = Py_BuildValue("i", 2103);
2501  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ORGANISATIONNAME", v);
2502  Py_DECREF(v);
2503 
2504  v = Py_BuildValue("i", 2104);
2505  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ORGANIZATIONALUNITNAME", v);
2506  Py_DECREF(v); /* organizationalUnitName */
2507 
2508  v = Py_BuildValue("i", 2104);
2509  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ORGANISATIONALUNITNAME", v);
2510  Py_DECREF(v);
2511 
2512  v = Py_BuildValue("i", 2105);
2513  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_COMMONNAME", v);
2514  Py_DECREF(v); /* commonName */
2515 
2516  v = Py_BuildValue("i", 2106);
2517  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_OTHERNAME_TYPEID", v);
2518  Py_DECREF(v); /* otherName.typeID */
2519 
2520  v = Py_BuildValue("i", 2107);
2521  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_OTHERNAME_VALUE", v);
2522  Py_DECREF(v); /* otherName.value */
2523 
2524  v = Py_BuildValue("i", 2108);
2525  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_RFC822NAME", v);
2526  Py_DECREF(v); /* rfc822Name */
2527 
2528  v = Py_BuildValue("i", 2108);
2529  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EMAIL", v);
2530  Py_DECREF(v);
2531 
2532  v = Py_BuildValue("i", 2109);
2533  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_DNSNAME", v);
2534  Py_DECREF(v); /* dNSName */
2535 
2536  v = Py_BuildValue("i", 2110);
2537  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_DIRECTORYNAME", v);
2538  Py_DECREF(v); /* directoryName */
2539 
2540  v = Py_BuildValue("i", 2111);
2541  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EDIPARTYNAME_NAMEASSIGNER", v);
2542  Py_DECREF(v); /* ediPartyName.nameAssigner */
2543 
2544  v = Py_BuildValue("i", 2112);
2545  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EDIPARTYNAME_PARTYNAME", v);
2546  Py_DECREF(v); /* ediPartyName.partyName */
2547 
2548  v = Py_BuildValue("i", 2113);
2549  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_UNIFORMRESOURCEIDENTIFIER", v);
2550  Py_DECREF(v); /* uniformResourceIdentifier */
2551 
2552  v = Py_BuildValue("i", 2114);
2553  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_IPADDRESS", v);
2554  Py_DECREF(v); /* iPAddress */
2555 
2556  v = Py_BuildValue("i", 2115);
2557  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_REGISTEREDID", v);
2558  Py_DECREF(v); /* registeredID */
2559 
2560  v = Py_BuildValue("i", 2200);
2561  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CHALLENGEPASSWORD", v);
2562  Py_DECREF(v); /* 1 3 6 1 4 1 3029 3 1 4 cRLExtReason */
2563 
2564  v = Py_BuildValue("i", 2201);
2565  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CRLEXTREASON", v);
2566  Py_DECREF(v); /* 1 3 6 1 4 1 3029 3 1 5 keyFeatures */
2567 
2568  v = Py_BuildValue("i", 2202);
2569  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_KEYFEATURES", v);
2570  Py_DECREF(v); /* 1 3 6 1 5 5 7 1 1 authorityInfoAccess */
2571 
2572  v = Py_BuildValue("i", 2203);
2573  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTHORITYINFOACCESS", v);
2574  Py_DECREF(v);
2575 
2576  v = Py_BuildValue("i", 2204);
2577  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTHORITYINFO_RTCS", v);
2578  Py_DECREF(v); /* accessDescription.accessLocation */
2579 
2580  v = Py_BuildValue("i", 2205);
2581  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTHORITYINFO_OCSP", v);
2582  Py_DECREF(v); /* accessDescription.accessLocation */
2583 
2584  v = Py_BuildValue("i", 2206);
2585  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTHORITYINFO_CAISSUERS", v);
2586  Py_DECREF(v); /* accessDescription.accessLocation */
2587 
2588  v = Py_BuildValue("i", 2207);
2589  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTHORITYINFO_CERTSTORE", v);
2590  Py_DECREF(v); /* accessDescription.accessLocation */
2591 
2592  v = Py_BuildValue("i", 2208);
2593  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTHORITYINFO_CRLS", v);
2594  Py_DECREF(v); /* accessDescription.accessLocation */
2595 
2596  v = Py_BuildValue("i", 2209);
2597  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_BIOMETRICINFO", v);
2598  Py_DECREF(v);
2599 
2600  v = Py_BuildValue("i", 2210);
2601  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_BIOMETRICINFO_TYPE", v);
2602  Py_DECREF(v); /* biometricData.typeOfData */
2603 
2604  v = Py_BuildValue("i", 2211);
2605  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_BIOMETRICINFO_HASHALGO", v);
2606  Py_DECREF(v); /* biometricData.hashAlgorithm */
2607 
2608  v = Py_BuildValue("i", 2212);
2609  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_BIOMETRICINFO_HASH", v);
2610  Py_DECREF(v); /* biometricData.dataHash */
2611 
2612  v = Py_BuildValue("i", 2213);
2613  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_BIOMETRICINFO_URL", v);
2614  Py_DECREF(v); /* biometricData.sourceDataUri */
2615 
2616  v = Py_BuildValue("i", 2214);
2617  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_QCSTATEMENT", v);
2618  Py_DECREF(v);
2619 
2620  v = Py_BuildValue("i", 2215);
2621  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_QCSTATEMENT_SEMANTICS", v);
2622  Py_DECREF(v); /* qcStatement.statementInfo.semanticsIdentifier */
2623 
2624  v = Py_BuildValue("i", 2216);
2625  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_QCSTATEMENT_REGISTRATIONAUTHORITY", v);
2626  Py_DECREF(v); /* qcStatement.statementInfo.nameRegistrationAuthorities */
2627 
2628  v = Py_BuildValue("i", 2217);
2629  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_IPADDRESSBLOCKS", v);
2630  Py_DECREF(v);
2631 
2632  v = Py_BuildValue("i", 2218);
2633  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_IPADDRESSBLOCKS_ADDRESSFAMILY", v);
2634  Py_DECREF(v); /* addressFamily */
2635 
2636  v = Py_BuildValue("i", 2219);
2637  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_IPADDRESSBLOCKS_INHERIT", v);
2638  Py_DECREF(v);
2639 
2640  v = Py_BuildValue("i", 2220);
2641  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_IPADDRESSBLOCKS_PREFIX", v);
2642  Py_DECREF(v); /* ipAddress.addressPrefix */
2643 
2644  v = Py_BuildValue("i", 2221);
2645  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_IPADDRESSBLOCKS_MIN", v);
2646  Py_DECREF(v); /* ipAddress.addressRangeMin */
2647 
2648  v = Py_BuildValue("i", 2222);
2649  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_IPADDRESSBLOCKS_MAX", v);
2650  Py_DECREF(v); /* ipAddress.addressRangeMax */
2651 
2652  v = Py_BuildValue("i", 2223);
2653  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTONOMOUSSYSIDS", v);
2654  Py_DECREF(v); /* CRYPT_CERTINFO_AUTONOMOUSSYSIDS_ASNUM_INHERIT,// asNum.inherit */
2655 
2656  v = Py_BuildValue("i", 2224);
2657  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTONOMOUSSYSIDS_ASNUM_INHERIT", v);
2658  Py_DECREF(v);
2659 
2660  v = Py_BuildValue("i", 2225);
2661  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTONOMOUSSYSIDS_ASNUM_ID", v);
2662  Py_DECREF(v); /* asNum.id */
2663 
2664  v = Py_BuildValue("i", 2226);
2665  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTONOMOUSSYSIDS_ASNUM_MIN", v);
2666  Py_DECREF(v); /* asNum.min */
2667 
2668  v = Py_BuildValue("i", 2227);
2669  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTONOMOUSSYSIDS_ASNUM_MAX", v);
2670  Py_DECREF(v); /* asNum.max */
2671 
2672  v = Py_BuildValue("i", 2228);
2673  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_OCSP_NONCE", v);
2674  Py_DECREF(v); /* nonce */
2675 
2676  v = Py_BuildValue("i", 2229);
2677  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_OCSP_RESPONSE", v);
2678  Py_DECREF(v);
2679 
2680  v = Py_BuildValue("i", 2230);
2681  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_OCSP_RESPONSE_OCSP", v);
2682  Py_DECREF(v); /* OCSP standard response */
2683 
2684  v = Py_BuildValue("i", 2231);
2685  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_OCSP_NOCHECK", v);
2686  Py_DECREF(v); /* 1 3 6 1 5 5 7 48 1 6 ocspArchiveCutoff */
2687 
2688  v = Py_BuildValue("i", 2232);
2689  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_OCSP_ARCHIVECUTOFF", v);
2690  Py_DECREF(v); /* 1 3 6 1 5 5 7 48 1 11 subjectInfoAccess */
2691 
2692  v = Py_BuildValue("i", 2233);
2693  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTINFOACCESS", v);
2694  Py_DECREF(v);
2695 
2696  v = Py_BuildValue("i", 2234);
2697  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTINFO_TIMESTAMPING", v);
2698  Py_DECREF(v); /* accessDescription.accessLocation */
2699 
2700  v = Py_BuildValue("i", 2235);
2701  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTINFO_CAREPOSITORY", v);
2702  Py_DECREF(v); /* accessDescription.accessLocation */
2703 
2704  v = Py_BuildValue("i", 2236);
2705  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTINFO_SIGNEDOBJECTREPOSITORY", v);
2706  Py_DECREF(v); /* accessDescription.accessLocation */
2707 
2708  v = Py_BuildValue("i", 2237);
2709  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTINFO_RPKIMANIFEST", v);
2710  Py_DECREF(v); /* accessDescription.accessLocation */
2711 
2712  v = Py_BuildValue("i", 2238);
2713  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTINFO_SIGNEDOBJECT", v);
2714  Py_DECREF(v); /* accessDescription.accessLocation */
2715 
2716  v = Py_BuildValue("i", 2239);
2717  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_DATEOFCERTGEN", v);
2718  Py_DECREF(v); /* 1 3 36 8 3 2 siggProcuration */
2719 
2720  v = Py_BuildValue("i", 2240);
2721  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_PROCURATION", v);
2722  Py_DECREF(v);
2723 
2724  v = Py_BuildValue("i", 2241);
2725  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_PROCURE_COUNTRY", v);
2726  Py_DECREF(v); /* country */
2727 
2728  v = Py_BuildValue("i", 2242);
2729  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_PROCURE_TYPEOFSUBSTITUTION", v);
2730  Py_DECREF(v); /* typeOfSubstitution */
2731 
2732  v = Py_BuildValue("i", 2243);
2733  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_PROCURE_SIGNINGFOR", v);
2734  Py_DECREF(v); /* signingFor.thirdPerson */
2735 
2736  v = Py_BuildValue("i", 2244);
2737  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_ADMISSIONS", v);
2738  Py_DECREF(v);
2739 
2740  v = Py_BuildValue("i", 2245);
2741  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_ADMISSIONS_AUTHORITY", v);
2742  Py_DECREF(v); /* authority */
2743 
2744  v = Py_BuildValue("i", 2246);
2745  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_ADMISSIONS_NAMINGAUTHID", v);
2746  Py_DECREF(v); /* namingAuth.iD */
2747 
2748  v = Py_BuildValue("i", 2247);
2749  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_ADMISSIONS_NAMINGAUTHURL", v);
2750  Py_DECREF(v); /* namingAuth.uRL */
2751 
2752  v = Py_BuildValue("i", 2248);
2753  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_ADMISSIONS_NAMINGAUTHTEXT", v);
2754  Py_DECREF(v); /* namingAuth.text */
2755 
2756  v = Py_BuildValue("i", 2249);
2757  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_ADMISSIONS_PROFESSIONITEM", v);
2758  Py_DECREF(v); /* professionItem */
2759 
2760  v = Py_BuildValue("i", 2250);
2761  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_ADMISSIONS_PROFESSIONOID", v);
2762  Py_DECREF(v); /* professionOID */
2763 
2764  v = Py_BuildValue("i", 2251);
2765  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_ADMISSIONS_REGISTRATIONNUMBER", v);
2766  Py_DECREF(v); /* registrationNumber */
2767 
2768  v = Py_BuildValue("i", 2252);
2769  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_MONETARYLIMIT", v);
2770  Py_DECREF(v);
2771 
2772  v = Py_BuildValue("i", 2253);
2773  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_MONETARY_CURRENCY", v);
2774  Py_DECREF(v); /* currency */
2775 
2776  v = Py_BuildValue("i", 2254);
2777  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_MONETARY_AMOUNT", v);
2778  Py_DECREF(v); /* amount */
2779 
2780  v = Py_BuildValue("i", 2255);
2781  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_MONETARY_EXPONENT", v);
2782  Py_DECREF(v); /* exponent */
2783 
2784  v = Py_BuildValue("i", 2256);
2785  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_DECLARATIONOFMAJORITY", v);
2786  Py_DECREF(v);
2787 
2788  v = Py_BuildValue("i", 2257);
2789  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_DECLARATIONOFMAJORITY_COUNTRY", v);
2790  Py_DECREF(v); /* fullAgeAtCountry */
2791 
2792  v = Py_BuildValue("i", 2258);
2793  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_RESTRICTION", v);
2794  Py_DECREF(v); /* 1 3 36 8 3 13 siggCertHash */
2795 
2796  v = Py_BuildValue("i", 2259);
2797  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_CERTHASH", v);
2798  Py_DECREF(v); /* 1 3 36 8 3 15 siggAdditionalInformation */
2799 
2800  v = Py_BuildValue("i", 2260);
2801  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SIGG_ADDITIONALINFORMATION", v);
2802  Py_DECREF(v); /* 1 3 101 1 4 1 strongExtranet */
2803 
2804  v = Py_BuildValue("i", 2261);
2805  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_STRONGEXTRANET", v);
2806  Py_DECREF(v);
2807 
2808  v = Py_BuildValue("i", 2262);
2809  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_STRONGEXTRANET_ZONE", v);
2810  Py_DECREF(v); /* sxNetIDList.sxNetID.zone */
2811 
2812  v = Py_BuildValue("i", 2263);
2813  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_STRONGEXTRANET_ID", v);
2814  Py_DECREF(v); /* sxNetIDList.sxNetID.id */
2815 
2816  v = Py_BuildValue("i", 2264);
2817  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTDIRECTORYATTRIBUTES", v);
2818  Py_DECREF(v);
2819 
2820  v = Py_BuildValue("i", 2265);
2821  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTDIR_TYPE", v);
2822  Py_DECREF(v); /* attribute.type */
2823 
2824  v = Py_BuildValue("i", 2266);
2825  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTDIR_VALUES", v);
2826  Py_DECREF(v); /* attribute.values */
2827 
2828  v = Py_BuildValue("i", 2267);
2829  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTKEYIDENTIFIER", v);
2830  Py_DECREF(v); /* 2 5 29 15 keyUsage */
2831 
2832  v = Py_BuildValue("i", 2268);
2833  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_KEYUSAGE", v);
2834  Py_DECREF(v); /* 2 5 29 16 privateKeyUsagePeriod */
2835 
2836  v = Py_BuildValue("i", 2269);
2837  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_PRIVATEKEYUSAGEPERIOD", v);
2838  Py_DECREF(v);
2839 
2840  v = Py_BuildValue("i", 2270);
2841  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_PRIVATEKEY_NOTBEFORE", v);
2842  Py_DECREF(v); /* notBefore */
2843 
2844  v = Py_BuildValue("i", 2271);
2845  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_PRIVATEKEY_NOTAFTER", v);
2846  Py_DECREF(v); /* notAfter */
2847 
2848  v = Py_BuildValue("i", 2272);
2849  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTALTNAME", v);
2850  Py_DECREF(v); /* 2 5 29 18 issuerAltName */
2851 
2852  v = Py_BuildValue("i", 2273);
2853  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ISSUERALTNAME", v);
2854  Py_DECREF(v); /* 2 5 29 19 basicConstraints */
2855 
2856  v = Py_BuildValue("i", 2274);
2857  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_BASICCONSTRAINTS", v);
2858  Py_DECREF(v);
2859 
2860  v = Py_BuildValue("i", 2275);
2861  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CA", v);
2862  Py_DECREF(v); /* cA */
2863 
2864  v = Py_BuildValue("i", 2275);
2865  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTHORITY", v);
2866  Py_DECREF(v);
2867 
2868  v = Py_BuildValue("i", 2276);
2869  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_PATHLENCONSTRAINT", v);
2870  Py_DECREF(v); /* pathLenConstraint */
2871 
2872  v = Py_BuildValue("i", 2277);
2873  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CRLNUMBER", v);
2874  Py_DECREF(v); /* 2 5 29 21 cRLReason */
2875 
2876  v = Py_BuildValue("i", 2278);
2877  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CRLREASON", v);
2878  Py_DECREF(v); /* 2 5 29 23 holdInstructionCode */
2879 
2880  v = Py_BuildValue("i", 2279);
2881  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_HOLDINSTRUCTIONCODE", v);
2882  Py_DECREF(v); /* 2 5 29 24 invalidityDate */
2883 
2884  v = Py_BuildValue("i", 2280);
2885  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_INVALIDITYDATE", v);
2886  Py_DECREF(v); /* 2 5 29 27 deltaCRLIndicator */
2887 
2888  v = Py_BuildValue("i", 2281);
2889  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_DELTACRLINDICATOR", v);
2890  Py_DECREF(v); /* 2 5 29 28 issuingDistributionPoint */
2891 
2892  v = Py_BuildValue("i", 2282);
2893  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ISSUINGDISTRIBUTIONPOINT", v);
2894  Py_DECREF(v);
2895 
2896  v = Py_BuildValue("i", 2283);
2897  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ISSUINGDIST_FULLNAME", v);
2898  Py_DECREF(v); /* distributionPointName.fullName */
2899 
2900  v = Py_BuildValue("i", 2284);
2901  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ISSUINGDIST_USERCERTSONLY", v);
2902  Py_DECREF(v); /* onlyContainsUserCerts */
2903 
2904  v = Py_BuildValue("i", 2285);
2905  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ISSUINGDIST_CACERTSONLY", v);
2906  Py_DECREF(v); /* onlyContainsCACerts */
2907 
2908  v = Py_BuildValue("i", 2286);
2909  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ISSUINGDIST_SOMEREASONSONLY", v);
2910  Py_DECREF(v); /* onlySomeReasons */
2911 
2912  v = Py_BuildValue("i", 2287);
2913  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ISSUINGDIST_INDIRECTCRL", v);
2914  Py_DECREF(v); /* indirectCRL */
2915 
2916  v = Py_BuildValue("i", 2288);
2917  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CERTIFICATEISSUER", v);
2918  Py_DECREF(v); /* 2 5 29 30 nameConstraints */
2919 
2920  v = Py_BuildValue("i", 2289);
2921  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_NAMECONSTRAINTS", v);
2922  Py_DECREF(v);
2923 
2924  v = Py_BuildValue("i", 2290);
2925  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_PERMITTEDSUBTREES", v);
2926  Py_DECREF(v); /* permittedSubtrees */
2927 
2928  v = Py_BuildValue("i", 2291);
2929  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXCLUDEDSUBTREES", v);
2930  Py_DECREF(v); /* excludedSubtrees */
2931 
2932  v = Py_BuildValue("i", 2292);
2933  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CRLDISTRIBUTIONPOINT", v);
2934  Py_DECREF(v);
2935 
2936  v = Py_BuildValue("i", 2293);
2937  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CRLDIST_FULLNAME", v);
2938  Py_DECREF(v); /* distributionPointName.fullName */
2939 
2940  v = Py_BuildValue("i", 2294);
2941  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CRLDIST_REASONS", v);
2942  Py_DECREF(v); /* reasons */
2943 
2944  v = Py_BuildValue("i", 2295);
2945  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CRLDIST_CRLISSUER", v);
2946  Py_DECREF(v); /* cRLIssuer */
2947 
2948  v = Py_BuildValue("i", 2296);
2949  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CERTIFICATEPOLICIES", v);
2950  Py_DECREF(v);
2951 
2952  v = Py_BuildValue("i", 2297);
2953  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CERTPOLICYID", v);
2954  Py_DECREF(v); /* policyInformation.policyIdentifier */
2955 
2956  v = Py_BuildValue("i", 2298);
2957  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CERTPOLICY_CPSURI", v);
2958  Py_DECREF(v); /* policyInformation.policyQualifiers.qualifier.cPSuri */
2959 
2960  v = Py_BuildValue("i", 2299);
2961  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CERTPOLICY_ORGANIZATION", v);
2962  Py_DECREF(v); /* policyInformation.policyQualifiers.qualifier.userNotice.noticeRef.organization */
2963 
2964  v = Py_BuildValue("i", 2300);
2965  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CERTPOLICY_NOTICENUMBERS", v);
2966  Py_DECREF(v); /* policyInformation.policyQualifiers.qualifier.userNotice.noticeRef.noticeNumbers */
2967 
2968  v = Py_BuildValue("i", 2301);
2969  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CERTPOLICY_EXPLICITTEXT", v);
2970  Py_DECREF(v); /* policyInformation.policyQualifiers.qualifier.userNotice.explicitText */
2971 
2972  v = Py_BuildValue("i", 2302);
2973  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_POLICYMAPPINGS", v);
2974  Py_DECREF(v);
2975 
2976  v = Py_BuildValue("i", 2303);
2977  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ISSUERDOMAINPOLICY", v);
2978  Py_DECREF(v); /* policyMappings.issuerDomainPolicy */
2979 
2980  v = Py_BuildValue("i", 2304);
2981  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SUBJECTDOMAINPOLICY", v);
2982  Py_DECREF(v); /* policyMappings.subjectDomainPolicy */
2983 
2984  v = Py_BuildValue("i", 2305);
2985  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTHORITYKEYIDENTIFIER", v);
2986  Py_DECREF(v);
2987 
2988  v = Py_BuildValue("i", 2306);
2989  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTHORITY_KEYIDENTIFIER", v);
2990  Py_DECREF(v); /* keyIdentifier */
2991 
2992  v = Py_BuildValue("i", 2307);
2993  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTHORITY_CERTISSUER", v);
2994  Py_DECREF(v); /* authorityCertIssuer */
2995 
2996  v = Py_BuildValue("i", 2308);
2997  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AUTHORITY_CERTSERIALNUMBER", v);
2998  Py_DECREF(v); /* authorityCertSerialNumber */
2999 
3000  v = Py_BuildValue("i", 2309);
3001  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_POLICYCONSTRAINTS", v);
3002  Py_DECREF(v);
3003 
3004  v = Py_BuildValue("i", 2310);
3005  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_REQUIREEXPLICITPOLICY", v);
3006  Py_DECREF(v); /* policyConstraints.requireExplicitPolicy */
3007 
3008  v = Py_BuildValue("i", 2311);
3009  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_INHIBITPOLICYMAPPING", v);
3010  Py_DECREF(v); /* policyConstraints.inhibitPolicyMapping */
3011 
3012  v = Py_BuildValue("i", 2312);
3013  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEYUSAGE", v);
3014  Py_DECREF(v);
3015 
3016  v = Py_BuildValue("i", 2313);
3017  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_MS_INDIVIDUALCODESIGNING", v);
3018  Py_DECREF(v); /* individualCodeSigning */
3019 
3020  v = Py_BuildValue("i", 2314);
3021  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_MS_COMMERCIALCODESIGNING", v);
3022  Py_DECREF(v); /* commercialCodeSigning */
3023 
3024  v = Py_BuildValue("i", 2315);
3025  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_MS_CERTTRUSTLISTSIGNING", v);
3026  Py_DECREF(v); /* certTrustListSigning */
3027 
3028  v = Py_BuildValue("i", 2316);
3029  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_MS_TIMESTAMPSIGNING", v);
3030  Py_DECREF(v); /* timeStampSigning */
3031 
3032  v = Py_BuildValue("i", 2317);
3033  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_MS_SERVERGATEDCRYPTO", v);
3034  Py_DECREF(v); /* serverGatedCrypto */
3035 
3036  v = Py_BuildValue("i", 2318);
3037  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_MS_ENCRYPTEDFILESYSTEM", v);
3038  Py_DECREF(v); /* encrypedFileSystem */
3039 
3040  v = Py_BuildValue("i", 2319);
3041  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_SERVERAUTH", v);
3042  Py_DECREF(v); /* serverAuth */
3043 
3044  v = Py_BuildValue("i", 2320);
3045  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_CLIENTAUTH", v);
3046  Py_DECREF(v); /* clientAuth */
3047 
3048  v = Py_BuildValue("i", 2321);
3049  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_CODESIGNING", v);
3050  Py_DECREF(v); /* codeSigning */
3051 
3052  v = Py_BuildValue("i", 2322);
3053  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_EMAILPROTECTION", v);
3054  Py_DECREF(v); /* emailProtection */
3055 
3056  v = Py_BuildValue("i", 2323);
3057  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_IPSECENDSYSTEM", v);
3058  Py_DECREF(v); /* ipsecEndSystem */
3059 
3060  v = Py_BuildValue("i", 2324);
3061  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_IPSECTUNNEL", v);
3062  Py_DECREF(v); /* ipsecTunnel */
3063 
3064  v = Py_BuildValue("i", 2325);
3065  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_IPSECUSER", v);
3066  Py_DECREF(v); /* ipsecUser */
3067 
3068  v = Py_BuildValue("i", 2326);
3069  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_TIMESTAMPING", v);
3070  Py_DECREF(v); /* timeStamping */
3071 
3072  v = Py_BuildValue("i", 2327);
3073  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_OCSPSIGNING", v);
3074  Py_DECREF(v); /* ocspSigning */
3075 
3076  v = Py_BuildValue("i", 2328);
3077  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_DIRECTORYSERVICE", v);
3078  Py_DECREF(v); /* directoryService */
3079 
3080  v = Py_BuildValue("i", 2329);
3081  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_ANYKEYUSAGE", v);
3082  Py_DECREF(v); /* anyExtendedKeyUsage */
3083 
3084  v = Py_BuildValue("i", 2330);
3085  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_NS_SERVERGATEDCRYPTO", v);
3086  Py_DECREF(v); /* serverGatedCrypto */
3087 
3088  v = Py_BuildValue("i", 2331);
3089  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXTKEY_VS_SERVERGATEDCRYPTO_CA", v);
3090  Py_DECREF(v); /* serverGatedCrypto CA */
3091 
3092  v = Py_BuildValue("i", 2332);
3093  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CRLSTREAMIDENTIFIER", v);
3094  Py_DECREF(v); /* 2 5 29 46 freshestCRL */
3095 
3096  v = Py_BuildValue("i", 2333);
3097  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_FRESHESTCRL", v);
3098  Py_DECREF(v);
3099 
3100  v = Py_BuildValue("i", 2334);
3101  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_FRESHESTCRL_FULLNAME", v);
3102  Py_DECREF(v); /* distributionPointName.fullName */
3103 
3104  v = Py_BuildValue("i", 2335);
3105  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_FRESHESTCRL_REASONS", v);
3106  Py_DECREF(v); /* reasons */
3107 
3108  v = Py_BuildValue("i", 2336);
3109  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_FRESHESTCRL_CRLISSUER", v);
3110  Py_DECREF(v); /* cRLIssuer */
3111 
3112  v = Py_BuildValue("i", 2337);
3113  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_ORDEREDLIST", v);
3114  Py_DECREF(v); /* 2 5 29 51 baseUpdateTime */
3115 
3116  v = Py_BuildValue("i", 2338);
3117  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_BASEUPDATETIME", v);
3118  Py_DECREF(v); /* 2 5 29 53 deltaInfo */
3119 
3120  v = Py_BuildValue("i", 2339);
3121  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_DELTAINFO", v);
3122  Py_DECREF(v);
3123 
3124  v = Py_BuildValue("i", 2340);
3125  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_DELTAINFO_LOCATION", v);
3126  Py_DECREF(v); /* deltaLocation */
3127 
3128  v = Py_BuildValue("i", 2341);
3129  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_DELTAINFO_NEXTDELTA", v);
3130  Py_DECREF(v); /* nextDelta */
3131 
3132  v = Py_BuildValue("i", 2342);
3133  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_INHIBITANYPOLICY", v);
3134  Py_DECREF(v); /* 2 5 29 58 toBeRevoked */
3135 
3136  v = Py_BuildValue("i", 2343);
3137  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_TOBEREVOKED", v);
3138  Py_DECREF(v);
3139 
3140  v = Py_BuildValue("i", 2344);
3141  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_TOBEREVOKED_CERTISSUER", v);
3142  Py_DECREF(v); /* certificateIssuer */
3143 
3144  v = Py_BuildValue("i", 2345);
3145  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_TOBEREVOKED_REASONCODE", v);
3146  Py_DECREF(v); /* reasonCode */
3147 
3148  v = Py_BuildValue("i", 2346);
3149  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_TOBEREVOKED_REVOCATIONTIME", v);
3150  Py_DECREF(v); /* revocationTime */
3151 
3152  v = Py_BuildValue("i", 2347);
3153  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_TOBEREVOKED_CERTSERIALNUMBER", v);
3154  Py_DECREF(v); /* certSerialNumber */
3155 
3156  v = Py_BuildValue("i", 2348);
3157  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_REVOKEDGROUPS", v);
3158  Py_DECREF(v);
3159 
3160  v = Py_BuildValue("i", 2349);
3161  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_REVOKEDGROUPS_CERTISSUER", v);
3162  Py_DECREF(v); /* certificateIssuer */
3163 
3164  v = Py_BuildValue("i", 2350);
3165  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_REVOKEDGROUPS_REASONCODE", v);
3166  Py_DECREF(v); /* reasonCode */
3167 
3168  v = Py_BuildValue("i", 2351);
3169  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_REVOKEDGROUPS_INVALIDITYDATE", v);
3170  Py_DECREF(v); /* invalidityDate */
3171 
3172  v = Py_BuildValue("i", 2352);
3173  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_REVOKEDGROUPS_STARTINGNUMBER", v);
3174  Py_DECREF(v); /* startingNumber */
3175 
3176  v = Py_BuildValue("i", 2353);
3177  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_REVOKEDGROUPS_ENDINGNUMBER", v);
3178  Py_DECREF(v); /* endingNumber */
3179 
3180  v = Py_BuildValue("i", 2354);
3181  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_EXPIREDCERTSONCRL", v);
3182  Py_DECREF(v); /* 2 5 29 63 aaIssuingDistributionPoint */
3183 
3184  v = Py_BuildValue("i", 2355);
3185  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AAISSUINGDISTRIBUTIONPOINT", v);
3186  Py_DECREF(v);
3187 
3188  v = Py_BuildValue("i", 2356);
3189  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AAISSUINGDIST_FULLNAME", v);
3190  Py_DECREF(v); /* distributionPointName.fullName */
3191 
3192  v = Py_BuildValue("i", 2357);
3193  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AAISSUINGDIST_SOMEREASONSONLY", v);
3194  Py_DECREF(v); /* onlySomeReasons */
3195 
3196  v = Py_BuildValue("i", 2358);
3197  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AAISSUINGDIST_INDIRECTCRL", v);
3198  Py_DECREF(v); /* indirectCRL */
3199 
3200  v = Py_BuildValue("i", 2359);
3201  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AAISSUINGDIST_USERATTRCERTS", v);
3202  Py_DECREF(v); /* containsUserAttributeCerts */
3203 
3204  v = Py_BuildValue("i", 2360);
3205  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AAISSUINGDIST_AACERTS", v);
3206  Py_DECREF(v); /* containsAACerts */
3207 
3208  v = Py_BuildValue("i", 2361);
3209  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_AAISSUINGDIST_SOACERTS", v);
3210  Py_DECREF(v); /* containsSOAPublicKeyCerts */
3211 
3212  v = Py_BuildValue("i", 2362);
3213  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_NS_CERTTYPE", v);
3214  Py_DECREF(v); /* netscape-cert-type */
3215 
3216  v = Py_BuildValue("i", 2363);
3217  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_NS_BASEURL", v);
3218  Py_DECREF(v); /* netscape-base-url */
3219 
3220  v = Py_BuildValue("i", 2364);
3221  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_NS_REVOCATIONURL", v);
3222  Py_DECREF(v); /* netscape-revocation-url */
3223 
3224  v = Py_BuildValue("i", 2365);
3225  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_NS_CAREVOCATIONURL", v);
3226  Py_DECREF(v); /* netscape-ca-revocation-url */
3227 
3228  v = Py_BuildValue("i", 2366);
3229  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_NS_CERTRENEWALURL", v);
3230  Py_DECREF(v); /* netscape-cert-renewal-url */
3231 
3232  v = Py_BuildValue("i", 2367);
3233  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_NS_CAPOLICYURL", v);
3234  Py_DECREF(v); /* netscape-ca-policy-url */
3235 
3236  v = Py_BuildValue("i", 2368);
3237  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_NS_SSLSERVERNAME", v);
3238  Py_DECREF(v); /* netscape-ssl-server-name */
3239 
3240  v = Py_BuildValue("i", 2369);
3241  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_NS_COMMENT", v);
3242  Py_DECREF(v); /* netscape-comment */
3243 
3244  v = Py_BuildValue("i", 2370);
3245  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_HASHEDROOTKEY", v);
3246  Py_DECREF(v);
3247 
3248  v = Py_BuildValue("i", 2371);
3249  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_ROOTKEYTHUMBPRINT", v);
3250  Py_DECREF(v); /* rootKeyThumbPrint */
3251 
3252  v = Py_BuildValue("i", 2372);
3253  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_CERTIFICATETYPE", v);
3254  Py_DECREF(v); /* 2 23 42 7 2 SET merchantData */
3255 
3256  v = Py_BuildValue("i", 2373);
3257  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_MERCHANTDATA", v);
3258  Py_DECREF(v);
3259 
3260  v = Py_BuildValue("i", 2374);
3261  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_MERID", v);
3262  Py_DECREF(v); /* merID */
3263 
3264  v = Py_BuildValue("i", 2375);
3265  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_MERACQUIRERBIN", v);
3266  Py_DECREF(v); /* merAcquirerBIN */
3267 
3268  v = Py_BuildValue("i", 2376);
3269  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_MERCHANTLANGUAGE", v);
3270  Py_DECREF(v); /* merNames.language */
3271 
3272  v = Py_BuildValue("i", 2377);
3273  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_MERCHANTNAME", v);
3274  Py_DECREF(v); /* merNames.name */
3275 
3276  v = Py_BuildValue("i", 2378);
3277  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_MERCHANTCITY", v);
3278  Py_DECREF(v); /* merNames.city */
3279 
3280  v = Py_BuildValue("i", 2379);
3281  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_MERCHANTSTATEPROVINCE", v);
3282  Py_DECREF(v); /* merNames.stateProvince */
3283 
3284  v = Py_BuildValue("i", 2380);
3285  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_MERCHANTPOSTALCODE", v);
3286  Py_DECREF(v); /* merNames.postalCode */
3287 
3288  v = Py_BuildValue("i", 2381);
3289  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_MERCHANTCOUNTRYNAME", v);
3290  Py_DECREF(v); /* merNames.countryName */
3291 
3292  v = Py_BuildValue("i", 2382);
3293  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_MERCOUNTRY", v);
3294  Py_DECREF(v); /* merCountry */
3295 
3296  v = Py_BuildValue("i", 2383);
3297  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_MERAUTHFLAG", v);
3298  Py_DECREF(v); /* merAuthFlag */
3299 
3300  v = Py_BuildValue("i", 2384);
3301  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_CERTCARDREQUIRED", v);
3302  Py_DECREF(v); /* 2 23 42 7 4 SET tunneling */
3303 
3304  v = Py_BuildValue("i", 2385);
3305  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_TUNNELING", v);
3306  Py_DECREF(v);
3307 
3308  v = Py_BuildValue("i", 2385);
3309  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_TUNNELLING", v);
3310  Py_DECREF(v);
3311 
3312  v = Py_BuildValue("i", 2386);
3313  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_TUNNELINGFLAG", v);
3314  Py_DECREF(v); /* tunneling */
3315 
3316  v = Py_BuildValue("i", 2386);
3317  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_TUNNELLINGFLAG", v);
3318  Py_DECREF(v);
3319 
3320  v = Py_BuildValue("i", 2387);
3321  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_TUNNELINGALGID", v);
3322  Py_DECREF(v); /* tunnelingAlgID */
3323 
3324  v = Py_BuildValue("i", 2387);
3325  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SET_TUNNELLINGALGID", v);
3326  Py_DECREF(v); /* S/MIME attributes */
3327 
3328  v = Py_BuildValue("i", 2500);
3329  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_CONTENTTYPE", v);
3330  Py_DECREF(v); /* 1 2 840 113549 1 9 4 messageDigest */
3331 
3332  v = Py_BuildValue("i", 2501);
3333  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_MESSAGEDIGEST", v);
3334  Py_DECREF(v); /* 1 2 840 113549 1 9 5 signingTime */
3335 
3336  v = Py_BuildValue("i", 2502);
3337  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGNINGTIME", v);
3338  Py_DECREF(v); /* 1 2 840 113549 1 9 6 counterSignature */
3339 
3340  v = Py_BuildValue("i", 2503);
3341  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_COUNTERSIGNATURE", v);
3342  Py_DECREF(v); /* counterSignature */
3343 
3344  v = Py_BuildValue("i", 2504);
3345  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGNINGDESCRIPTION", v);
3346  Py_DECREF(v); /* 1 2 840 113549 1 9 15 sMIMECapabilities */
3347 
3348  v = Py_BuildValue("i", 2505);
3349  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAPABILITIES", v);
3350  Py_DECREF(v);
3351 
3352  v = Py_BuildValue("i", 2506);
3353  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_3DES", v);
3354  Py_DECREF(v); /* 3DES encryption */
3355 
3356  v = Py_BuildValue("i", 2507);
3357  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_AES", v);
3358  Py_DECREF(v); /* AES encryption */
3359 
3360  v = Py_BuildValue("i", 2508);
3361  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_CAST128", v);
3362  Py_DECREF(v); /* CAST-128 encryption */
3363 
3364  v = Py_BuildValue("i", 2509);
3365  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_IDEA", v);
3366  Py_DECREF(v); /* IDEA encryption */
3367 
3368  v = Py_BuildValue("i", 2510);
3369  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_RC2", v);
3370  Py_DECREF(v); /* RC2 encryption (w.128 key) */
3371 
3372  v = Py_BuildValue("i", 2511);
3373  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_RC5", v);
3374  Py_DECREF(v); /* RC5 encryption (w.128 key) */
3375 
3376  v = Py_BuildValue("i", 2512);
3377  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_SKIPJACK", v);
3378  Py_DECREF(v); /* Skipjack encryption */
3379 
3380  v = Py_BuildValue("i", 2513);
3381  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_DES", v);
3382  Py_DECREF(v); /* DES encryption */
3383 
3384  v = Py_BuildValue("i", 2514);
3385  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_SHAng", v);
3386  Py_DECREF(v); /* SHA2-ng hash */
3387 
3388  v = Py_BuildValue("i", 2515);
3389  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_SHA2", v);
3390  Py_DECREF(v); /* SHA2-256 hash */
3391 
3392  v = Py_BuildValue("i", 2516);
3393  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_SHA1", v);
3394  Py_DECREF(v); /* SHA1 hash */
3395 
3396  v = Py_BuildValue("i", 2517);
3397  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_HMAC_SHAng", v);
3398  Py_DECREF(v); /* HMAC-SHA2-ng MAC */
3399 
3400  v = Py_BuildValue("i", 2518);
3401  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_HMAC_SHA2", v);
3402  Py_DECREF(v); /* HMAC-SHA2-256 MAC */
3403 
3404  v = Py_BuildValue("i", 2519);
3405  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_HMAC_SHA1", v);
3406  Py_DECREF(v); /* HMAC-SHA1 MAC */
3407 
3408  v = Py_BuildValue("i", 2520);
3409  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_AUTHENC256", v);
3410  Py_DECREF(v); /* AuthEnc w.256-bit key */
3411 
3412  v = Py_BuildValue("i", 2521);
3413  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_AUTHENC128", v);
3414  Py_DECREF(v); /* AuthEnc w.128-bit key */
3415 
3416  v = Py_BuildValue("i", 2522);
3417  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_RSA_SHAng", v);
3418  Py_DECREF(v); /* RSA with SHA-ng signing */
3419 
3420  v = Py_BuildValue("i", 2523);
3421  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_RSA_SHA2", v);
3422  Py_DECREF(v); /* RSA with SHA2-256 signing */
3423 
3424  v = Py_BuildValue("i", 2524);
3425  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_RSA_SHA1", v);
3426  Py_DECREF(v); /* RSA with SHA1 signing */
3427 
3428  v = Py_BuildValue("i", 2525);
3429  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_DSA_SHA1", v);
3430  Py_DECREF(v); /* DSA with SHA-1 signing */
3431 
3432  v = Py_BuildValue("i", 2526);
3433  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_ECDSA_SHAng", v);
3434  Py_DECREF(v); /* ECDSA with SHA-ng signing */
3435 
3436  v = Py_BuildValue("i", 2527);
3437  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_ECDSA_SHA2", v);
3438  Py_DECREF(v); /* ECDSA with SHA2-256 signing */
3439 
3440  v = Py_BuildValue("i", 2528);
3441  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_ECDSA_SHA1", v);
3442  Py_DECREF(v); /* ECDSA with SHA-1 signing */
3443 
3444  v = Py_BuildValue("i", 2529);
3445  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_PREFERSIGNEDDATA", v);
3446  Py_DECREF(v); /* preferSignedData */
3447 
3448  v = Py_BuildValue("i", 2530);
3449  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_CANNOTDECRYPTANY", v);
3450  Py_DECREF(v); /* canNotDecryptAny */
3451 
3452  v = Py_BuildValue("i", 2531);
3453  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SMIMECAP_PREFERBINARYINSIDE", v);
3454  Py_DECREF(v); /* preferBinaryInside */
3455 
3456  v = Py_BuildValue("i", 2532);
3457  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_RECEIPTREQUEST", v);
3458  Py_DECREF(v);
3459 
3460  v = Py_BuildValue("i", 2533);
3461  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_RECEIPT_CONTENTIDENTIFIER", v);
3462  Py_DECREF(v); /* contentIdentifier */
3463 
3464  v = Py_BuildValue("i", 2534);
3465  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_RECEIPT_FROM", v);
3466  Py_DECREF(v); /* receiptsFrom */
3467 
3468  v = Py_BuildValue("i", 2535);
3469  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_RECEIPT_TO", v);
3470  Py_DECREF(v); /* receiptsTo */
3471 
3472  v = Py_BuildValue("i", 2536);
3473  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SECURITYLABEL", v);
3474  Py_DECREF(v);
3475 
3476  v = Py_BuildValue("i", 2537);
3477  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SECLABEL_POLICY", v);
3478  Py_DECREF(v); /* securityPolicyIdentifier */
3479 
3480  v = Py_BuildValue("i", 2538);
3481  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SECLABEL_CLASSIFICATION", v);
3482  Py_DECREF(v); /* securityClassification */
3483 
3484  v = Py_BuildValue("i", 2539);
3485  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SECLABEL_PRIVACYMARK", v);
3486  Py_DECREF(v); /* privacyMark */
3487 
3488  v = Py_BuildValue("i", 2540);
3489  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SECLABEL_CATTYPE", v);
3490  Py_DECREF(v); /* securityCategories.securityCategory.type */
3491 
3492  v = Py_BuildValue("i", 2541);
3493  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SECLABEL_CATVALUE", v);
3494  Py_DECREF(v); /* securityCategories.securityCategory.value */
3495 
3496  v = Py_BuildValue("i", 2542);
3497  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_MLEXPANSIONHISTORY", v);
3498  Py_DECREF(v);
3499 
3500  v = Py_BuildValue("i", 2543);
3501  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_MLEXP_ENTITYIDENTIFIER", v);
3502  Py_DECREF(v); /* mlData.mailListIdentifier.issuerAndSerialNumber */
3503 
3504  v = Py_BuildValue("i", 2544);
3505  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_MLEXP_TIME", v);
3506  Py_DECREF(v); /* mlData.expansionTime */
3507 
3508  v = Py_BuildValue("i", 2545);
3509  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_MLEXP_NONE", v);
3510  Py_DECREF(v); /* mlData.mlReceiptPolicy.none */
3511 
3512  v = Py_BuildValue("i", 2546);
3513  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_MLEXP_INSTEADOF", v);
3514  Py_DECREF(v); /* mlData.mlReceiptPolicy.insteadOf.generalNames.generalName */
3515 
3516  v = Py_BuildValue("i", 2547);
3517  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_MLEXP_INADDITIONTO", v);
3518  Py_DECREF(v); /* mlData.mlReceiptPolicy.inAdditionTo.generalNames.generalName */
3519 
3520  v = Py_BuildValue("i", 2548);
3521  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_CONTENTHINTS", v);
3522  Py_DECREF(v);
3523 
3524  v = Py_BuildValue("i", 2549);
3525  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_CONTENTHINT_DESCRIPTION", v);
3526  Py_DECREF(v); /* contentDescription */
3527 
3528  v = Py_BuildValue("i", 2550);
3529  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_CONTENTHINT_TYPE", v);
3530  Py_DECREF(v); /* contentType */
3531 
3532  v = Py_BuildValue("i", 2551);
3533  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_EQUIVALENTLABEL", v);
3534  Py_DECREF(v);
3535 
3536  v = Py_BuildValue("i", 2552);
3537  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_EQVLABEL_POLICY", v);
3538  Py_DECREF(v); /* securityPolicyIdentifier */
3539 
3540  v = Py_BuildValue("i", 2553);
3541  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_EQVLABEL_CLASSIFICATION", v);
3542  Py_DECREF(v); /* securityClassification */
3543 
3544  v = Py_BuildValue("i", 2554);
3545  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_EQVLABEL_PRIVACYMARK", v);
3546  Py_DECREF(v); /* privacyMark */
3547 
3548  v = Py_BuildValue("i", 2555);
3549  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_EQVLABEL_CATTYPE", v);
3550  Py_DECREF(v); /* securityCategories.securityCategory.type */
3551 
3552  v = Py_BuildValue("i", 2556);
3553  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_EQVLABEL_CATVALUE", v);
3554  Py_DECREF(v); /* securityCategories.securityCategory.value */
3555 
3556  v = Py_BuildValue("i", 2557);
3557  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGNINGCERTIFICATE", v);
3558  Py_DECREF(v);
3559 
3560  v = Py_BuildValue("i", 2558);
3561  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGNINGCERT_ESSCERTID", v);
3562  Py_DECREF(v); /* certs.essCertID */
3563 
3564  v = Py_BuildValue("i", 2559);
3565  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGNINGCERT_POLICIES", v);
3566  Py_DECREF(v); /* policies.policyInformation.policyIdentifier */
3567 
3568  v = Py_BuildValue("i", 2560);
3569  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGNINGCERTIFICATEV2", v);
3570  Py_DECREF(v);
3571 
3572  v = Py_BuildValue("i", 2561);
3573  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGNINGCERTV2_ESSCERTIDV2", v);
3574  Py_DECREF(v); /* certs.essCertID */
3575 
3576  v = Py_BuildValue("i", 2562);
3577  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGNINGCERTV2_POLICIES", v);
3578  Py_DECREF(v); /* policies.policyInformation.policyIdentifier */
3579 
3580  v = Py_BuildValue("i", 2563);
3581  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGNATUREPOLICYID", v);
3582  Py_DECREF(v);
3583 
3584  v = Py_BuildValue("i", 2564);
3585  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGPOLICYID", v);
3586  Py_DECREF(v); /* sigPolicyID */
3587 
3588  v = Py_BuildValue("i", 2565);
3589  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGPOLICYHASH", v);
3590  Py_DECREF(v); /* sigPolicyHash */
3591 
3592  v = Py_BuildValue("i", 2566);
3593  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGPOLICY_CPSURI", v);
3594  Py_DECREF(v); /* sigPolicyQualifiers.sigPolicyQualifier.cPSuri */
3595 
3596  v = Py_BuildValue("i", 2567);
3597  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGPOLICY_ORGANIZATION", v);
3598  Py_DECREF(v); /* sigPolicyQualifiers.sigPolicyQualifier.userNotice.noticeRef.organization */
3599 
3600  v = Py_BuildValue("i", 2568);
3601  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGPOLICY_NOTICENUMBERS", v);
3602  Py_DECREF(v); /* sigPolicyQualifiers.sigPolicyQualifier.userNotice.noticeRef.noticeNumbers */
3603 
3604  v = Py_BuildValue("i", 2569);
3605  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGPOLICY_EXPLICITTEXT", v);
3606  Py_DECREF(v); /* sigPolicyQualifiers.sigPolicyQualifier.userNotice.explicitText */
3607 
3608  v = Py_BuildValue("i", 2570);
3609  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGTYPEIDENTIFIER", v);
3610  Py_DECREF(v);
3611 
3612  v = Py_BuildValue("i", 2571);
3613  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGTYPEID_ORIGINATORSIG", v);
3614  Py_DECREF(v); /* originatorSig */
3615 
3616  v = Py_BuildValue("i", 2572);
3617  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGTYPEID_DOMAINSIG", v);
3618  Py_DECREF(v); /* domainSig */
3619 
3620  v = Py_BuildValue("i", 2573);
3621  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGTYPEID_ADDITIONALATTRIBUTES", v);
3622  Py_DECREF(v); /* additionalAttributesSig */
3623 
3624  v = Py_BuildValue("i", 2574);
3625  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SIGTYPEID_REVIEWSIG", v);
3626  Py_DECREF(v); /* reviewSig */
3627 
3628  v = Py_BuildValue("i", 2575);
3629  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_NONCE", v);
3630  Py_DECREF(v); /* randomNonce */
3631 
3632  v = Py_BuildValue("i", 2576);
3633  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SCEP_MESSAGETYPE", v);
3634  Py_DECREF(v); /* messageType */
3635 
3636  v = Py_BuildValue("i", 2577);
3637  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SCEP_PKISTATUS", v);
3638  Py_DECREF(v); /* pkiStatus */
3639 
3640  v = Py_BuildValue("i", 2578);
3641  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SCEP_FAILINFO", v);
3642  Py_DECREF(v); /* failInfo */
3643 
3644  v = Py_BuildValue("i", 2579);
3645  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SCEP_SENDERNONCE", v);
3646  Py_DECREF(v); /* senderNonce */
3647 
3648  v = Py_BuildValue("i", 2580);
3649  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SCEP_RECIPIENTNONCE", v);
3650  Py_DECREF(v); /* recipientNonce */
3651 
3652  v = Py_BuildValue("i", 2581);
3653  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_SCEP_TRANSACTIONID", v);
3654  Py_DECREF(v); /* transID */
3655 
3656  v = Py_BuildValue("i", 2582);
3657  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SPCAGENCYINFO", v);
3658  Py_DECREF(v);
3659 
3660  v = Py_BuildValue("i", 2583);
3661  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SPCAGENCYURL", v);
3662  Py_DECREF(v); /* spcAgencyInfo.url */
3663 
3664  v = Py_BuildValue("i", 2584);
3665  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SPCSTATEMENTTYPE", v);
3666  Py_DECREF(v);
3667 
3668  v = Py_BuildValue("i", 2585);
3669  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SPCSTMT_INDIVIDUALCODESIGNING", v);
3670  Py_DECREF(v); /* individualCodeSigning */
3671 
3672  v = Py_BuildValue("i", 2586);
3673  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SPCSTMT_COMMERCIALCODESIGNING", v);
3674  Py_DECREF(v); /* commercialCodeSigning */
3675 
3676  v = Py_BuildValue("i", 2587);
3677  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SPCOPUSINFO", v);
3678  Py_DECREF(v);
3679 
3680  v = Py_BuildValue("i", 2588);
3681  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SPCOPUSINFO_NAME", v);
3682  Py_DECREF(v); /* spcOpusInfo.name */
3683 
3684  v = Py_BuildValue("i", 2589);
3685  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_CMS_SPCOPUSINFO_URL", v);
3686  Py_DECREF(v); /* spcOpusInfo.url */
3687 
3688  v = Py_BuildValue("i", 2590);
3689  PyDict_SetItemString(moduleDict, "CRYPT_CERTINFO_LAST", v);
3690  Py_DECREF(v);
3691 
3692  v = Py_BuildValue("i", 3000);
3693  PyDict_SetItemString(moduleDict, "CRYPT_KEYINFO_FIRST", v);
3694  Py_DECREF(v); /* ******************* */
3695 
3696  v = Py_BuildValue("i", 3001);
3697  PyDict_SetItemString(moduleDict, "CRYPT_KEYINFO_QUERY", v);
3698  Py_DECREF(v); /* Keyset query */
3699 
3700  v = Py_BuildValue("i", 3002);
3701  PyDict_SetItemString(moduleDict, "CRYPT_KEYINFO_QUERY_REQUESTS", v);
3702  Py_DECREF(v); /* Query of requests in cert store */
3703 
3704  v = Py_BuildValue("i", 3003);
3705  PyDict_SetItemString(moduleDict, "CRYPT_KEYINFO_LAST", v);
3706  Py_DECREF(v);
3707 
3708  v = Py_BuildValue("i", 4000);
3709  PyDict_SetItemString(moduleDict, "CRYPT_DEVINFO_FIRST", v);
3710  Py_DECREF(v); /* ******************* */
3711 
3712  v = Py_BuildValue("i", 4001);
3713  PyDict_SetItemString(moduleDict, "CRYPT_DEVINFO_INITIALISE", v);
3714  Py_DECREF(v); /* Initialise device for use */
3715 
3716  v = Py_BuildValue("i", 4001);
3717  PyDict_SetItemString(moduleDict, "CRYPT_DEVINFO_INITIALIZE", v);
3718  Py_DECREF(v);
3719 
3720  v = Py_BuildValue("i", 4002);
3721  PyDict_SetItemString(moduleDict, "CRYPT_DEVINFO_AUTHENT_USER", v);
3722  Py_DECREF(v); /* Authenticate user to device */
3723 
3724  v = Py_BuildValue("i", 4003);
3725  PyDict_SetItemString(moduleDict, "CRYPT_DEVINFO_AUTHENT_SUPERVISOR", v);
3726  Py_DECREF(v); /* Authenticate supervisor to dev. */
3727 
3728  v = Py_BuildValue("i", 4004);
3729  PyDict_SetItemString(moduleDict, "CRYPT_DEVINFO_SET_AUTHENT_USER", v);
3730  Py_DECREF(v); /* Set user authent.value */
3731 
3732  v = Py_BuildValue("i", 4005);
3733  PyDict_SetItemString(moduleDict, "CRYPT_DEVINFO_SET_AUTHENT_SUPERVISOR", v);
3734  Py_DECREF(v); /* Set supervisor auth.val. */
3735 
3736  v = Py_BuildValue("i", 4006);
3737  PyDict_SetItemString(moduleDict, "CRYPT_DEVINFO_ZEROISE", v);
3738  Py_DECREF(v); /* Zeroise device */
3739 
3740  v = Py_BuildValue("i", 4006);
3741  PyDict_SetItemString(moduleDict, "CRYPT_DEVINFO_ZEROIZE", v);
3742  Py_DECREF(v);
3743 
3744  v = Py_BuildValue("i", 4007);
3745  PyDict_SetItemString(moduleDict, "CRYPT_DEVINFO_LOGGEDIN", v);
3746  Py_DECREF(v); /* Whether user is logged in */
3747 
3748  v = Py_BuildValue("i", 4008);
3749  PyDict_SetItemString(moduleDict, "CRYPT_DEVINFO_LABEL", v);
3750  Py_DECREF(v); /* Device/token label */
3751 
3752  v = Py_BuildValue("i", 4009);
3753  PyDict_SetItemString(moduleDict, "CRYPT_DEVINFO_LAST", v);
3754  Py_DECREF(v);
3755 
3756  v = Py_BuildValue("i", 5000);
3757  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_FIRST", v);
3758  Py_DECREF(v); /* ********************* */
3759 
3760  v = Py_BuildValue("i", 5001);
3761  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_DATASIZE", v);
3762  Py_DECREF(v); /* Data size information */
3763 
3764  v = Py_BuildValue("i", 5002);
3765  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_COMPRESSION", v);
3766  Py_DECREF(v); /* Compression information */
3767 
3768  v = Py_BuildValue("i", 5003);
3769  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_CONTENTTYPE", v);
3770  Py_DECREF(v); /* Inner CMS content type */
3771 
3772  v = Py_BuildValue("i", 5004);
3773  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_DETACHEDSIGNATURE", v);
3774  Py_DECREF(v); /* Detached signature */
3775 
3776  v = Py_BuildValue("i", 5005);
3777  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_SIGNATURE_RESULT", v);
3778  Py_DECREF(v); /* Signature check result */
3779 
3780  v = Py_BuildValue("i", 5006);
3781  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_INTEGRITY", v);
3782  Py_DECREF(v); /* Integrity-protection level */
3783 
3784  v = Py_BuildValue("i", 5007);
3785  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_PASSWORD", v);
3786  Py_DECREF(v); /* User password */
3787 
3788  v = Py_BuildValue("i", 5008);
3789  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_KEY", v);
3790  Py_DECREF(v); /* Conventional encryption key */
3791 
3792  v = Py_BuildValue("i", 5009);
3793  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_SIGNATURE", v);
3794  Py_DECREF(v); /* Signature/signature check key */
3795 
3796  v = Py_BuildValue("i", 5010);
3797  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_SIGNATURE_EXTRADATA", v);
3798  Py_DECREF(v); /* Extra information added to CMS sigs */
3799 
3800  v = Py_BuildValue("i", 5011);
3801  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_RECIPIENT", v);
3802  Py_DECREF(v); /* Recipient email address */
3803 
3804  v = Py_BuildValue("i", 5012);
3805  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_PUBLICKEY", v);
3806  Py_DECREF(v); /* PKC encryption key */
3807 
3808  v = Py_BuildValue("i", 5013);
3809  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_PRIVATEKEY", v);
3810  Py_DECREF(v); /* PKC decryption key */
3811 
3812  v = Py_BuildValue("i", 5014);
3813  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_PRIVATEKEY_LABEL", v);
3814  Py_DECREF(v); /* Label of PKC decryption key */
3815 
3816  v = Py_BuildValue("i", 5015);
3817  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_ORIGINATOR", v);
3818  Py_DECREF(v); /* Originator info/key */
3819 
3820  v = Py_BuildValue("i", 5016);
3821  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_SESSIONKEY", v);
3822  Py_DECREF(v); /* Session key */
3823 
3824  v = Py_BuildValue("i", 5017);
3825  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_HASH", v);
3826  Py_DECREF(v); /* Hash value */
3827 
3828  v = Py_BuildValue("i", 5018);
3829  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_TIMESTAMP", v);
3830  Py_DECREF(v); /* Timestamp information */
3831 
3832  v = Py_BuildValue("i", 5019);
3833  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_KEYSET_SIGCHECK", v);
3834  Py_DECREF(v); /* Signature check keyset */
3835 
3836  v = Py_BuildValue("i", 5020);
3837  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_KEYSET_ENCRYPT", v);
3838  Py_DECREF(v); /* PKC encryption keyset */
3839 
3840  v = Py_BuildValue("i", 5021);
3841  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_KEYSET_DECRYPT", v);
3842  Py_DECREF(v); /* PKC decryption keyset */
3843 
3844  v = Py_BuildValue("i", 5022);
3845  PyDict_SetItemString(moduleDict, "CRYPT_ENVINFO_LAST", v);
3846  Py_DECREF(v);
3847 
3848  v = Py_BuildValue("i", 6000);
3849  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_FIRST", v);
3850  Py_DECREF(v); /* ******************** */
3851 
3852  v = Py_BuildValue("i", 6001);
3853  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_ACTIVE", v);
3854  Py_DECREF(v); /* Whether session is active */
3855 
3856  v = Py_BuildValue("i", 6002);
3857  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_CONNECTIONACTIVE", v);
3858  Py_DECREF(v); /* Whether network connection is active */
3859 
3860  v = Py_BuildValue("i", 6003);
3861  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_USERNAME", v);
3862  Py_DECREF(v); /* User name */
3863 
3864  v = Py_BuildValue("i", 6004);
3865  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_PASSWORD", v);
3866  Py_DECREF(v); /* Password */
3867 
3868  v = Py_BuildValue("i", 6005);
3869  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_PRIVATEKEY", v);
3870  Py_DECREF(v); /* Server/client private key */
3871 
3872  v = Py_BuildValue("i", 6006);
3873  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_KEYSET", v);
3874  Py_DECREF(v); /* Certificate store */
3875 
3876  v = Py_BuildValue("i", 6007);
3877  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_AUTHRESPONSE", v);
3878  Py_DECREF(v); /* Session authorisation OK */
3879 
3880  v = Py_BuildValue("i", 6008);
3881  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_SERVER_NAME", v);
3882  Py_DECREF(v); /* Server name */
3883 
3884  v = Py_BuildValue("i", 6009);
3885  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_SERVER_PORT", v);
3886  Py_DECREF(v); /* Server port number */
3887 
3888  v = Py_BuildValue("i", 6010);
3889  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_SERVER_FINGERPRINT", v);
3890  Py_DECREF(v); /* Server key fingerprint */
3891 
3892  v = Py_BuildValue("i", 6011);
3893  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_CLIENT_NAME", v);
3894  Py_DECREF(v); /* Client name */
3895 
3896  v = Py_BuildValue("i", 6012);
3897  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_CLIENT_PORT", v);
3898  Py_DECREF(v); /* Client port number */
3899 
3900  v = Py_BuildValue("i", 6013);
3901  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_SESSION", v);
3902  Py_DECREF(v); /* Transport mechanism */
3903 
3904  v = Py_BuildValue("i", 6014);
3905  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_NETWORKSOCKET", v);
3906  Py_DECREF(v); /* User-supplied network socket */
3907 
3908  v = Py_BuildValue("i", 6015);
3909  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_VERSION", v);
3910  Py_DECREF(v); /* Protocol version */
3911 
3912  v = Py_BuildValue("i", 6016);
3913  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_REQUEST", v);
3914  Py_DECREF(v); /* Cert.request object */
3915 
3916  v = Py_BuildValue("i", 6017);
3917  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_RESPONSE", v);
3918  Py_DECREF(v); /* Cert.response object */
3919 
3920  v = Py_BuildValue("i", 6018);
3921  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_CACERTIFICATE", v);
3922  Py_DECREF(v); /* Issuing CA certificate */
3923 
3924  v = Py_BuildValue("i", 6019);
3925  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_CMP_REQUESTTYPE", v);
3926  Py_DECREF(v); /* Request type */
3927 
3928  v = Py_BuildValue("i", 6020);
3929  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_CMP_PRIVKEYSET", v);
3930  Py_DECREF(v); /* Private-key keyset */
3931 
3932  v = Py_BuildValue("i", 6021);
3933  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_SSH_CHANNEL", v);
3934  Py_DECREF(v); /* SSH current channel */
3935 
3936  v = Py_BuildValue("i", 6022);
3937  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_SSH_CHANNEL_TYPE", v);
3938  Py_DECREF(v); /* SSH channel type */
3939 
3940  v = Py_BuildValue("i", 6023);
3941  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_SSH_CHANNEL_ARG1", v);
3942  Py_DECREF(v); /* SSH channel argument 1 */
3943 
3944  v = Py_BuildValue("i", 6024);
3945  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_SSH_CHANNEL_ARG2", v);
3946  Py_DECREF(v); /* SSH channel argument 2 */
3947 
3948  v = Py_BuildValue("i", 6025);
3949  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_SSH_CHANNEL_ACTIVE", v);
3950  Py_DECREF(v); /* SSH channel active */
3951 
3952  v = Py_BuildValue("i", 6026);
3953  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_SSL_OPTIONS", v);
3954  Py_DECREF(v); /* SSL/TLS protocol options */
3955 
3956  v = Py_BuildValue("i", 6027);
3957  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_TSP_MSGIMPRINT", v);
3958  Py_DECREF(v); /* TSP message imprint */
3959 
3960  v = Py_BuildValue("i", 6028);
3961  PyDict_SetItemString(moduleDict, "CRYPT_SESSINFO_LAST", v);
3962  Py_DECREF(v);
3963 
3964  v = Py_BuildValue("i", 7000);
3965  PyDict_SetItemString(moduleDict, "CRYPT_USERINFO_FIRST", v);
3966  Py_DECREF(v); /* ******************** */
3967 
3968  v = Py_BuildValue("i", 7001);
3969  PyDict_SetItemString(moduleDict, "CRYPT_USERINFO_PASSWORD", v);
3970  Py_DECREF(v); /* Password */
3971 
3972  v = Py_BuildValue("i", 7002);
3973  PyDict_SetItemString(moduleDict, "CRYPT_USERINFO_CAKEY_CERTSIGN", v);
3974  Py_DECREF(v); /* CA cert signing key */
3975 
3976  v = Py_BuildValue("i", 7003);
3977  PyDict_SetItemString(moduleDict, "CRYPT_USERINFO_CAKEY_CRLSIGN", v);
3978  Py_DECREF(v); /* CA CRL signing key */
3979 
3980  v = Py_BuildValue("i", 7004);
3981  PyDict_SetItemString(moduleDict, "CRYPT_USERINFO_CAKEY_RTCSSIGN", v);
3982  Py_DECREF(v); /* CA RTCS signing key */
3983 
3984  v = Py_BuildValue("i", 7005);
3985  PyDict_SetItemString(moduleDict, "CRYPT_USERINFO_CAKEY_OCSPSIGN", v);
3986  Py_DECREF(v); /* CA OCSP signing key */
3987 
3988  v = Py_BuildValue("i", 7006);
3989  PyDict_SetItemString(moduleDict, "CRYPT_USERINFO_LAST", v);
3990  Py_DECREF(v);
3991 
3992  v = Py_BuildValue("i", 7006);
3993  PyDict_SetItemString(moduleDict, "CRYPT_ATTRIBUTE_LAST", v);
3994  Py_DECREF(v);
3995 
3996  v = Py_BuildValue("i", 0);
3997  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_NONE", v);
3998  Py_DECREF(v);
3999 
4000  v = Py_BuildValue("i", 1);
4001  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_DATA", v);
4002  Py_DECREF(v);
4003 
4004  v = Py_BuildValue("i", 2);
4005  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_SIGNEDDATA", v);
4006  Py_DECREF(v);
4007 
4008  v = Py_BuildValue("i", 3);
4009  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_ENVELOPEDDATA", v);
4010  Py_DECREF(v);
4011 
4012  v = Py_BuildValue("i", 4);
4013  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_SIGNEDANDENVELOPEDDATA", v);
4014  Py_DECREF(v);
4015 
4016  v = Py_BuildValue("i", 5);
4017  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_DIGESTEDDATA", v);
4018  Py_DECREF(v);
4019 
4020  v = Py_BuildValue("i", 6);
4021  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_ENCRYPTEDDATA", v);
4022  Py_DECREF(v);
4023 
4024  v = Py_BuildValue("i", 7);
4025  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_COMPRESSEDDATA", v);
4026  Py_DECREF(v);
4027 
4028  v = Py_BuildValue("i", 8);
4029  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_AUTHDATA", v);
4030  Py_DECREF(v);
4031 
4032  v = Py_BuildValue("i", 9);
4033  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_AUTHENVDATA", v);
4034  Py_DECREF(v);
4035 
4036  v = Py_BuildValue("i", 10);
4037  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_TSTINFO", v);
4038  Py_DECREF(v);
4039 
4040  v = Py_BuildValue("i", 11);
4041  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_SPCINDIRECTDATACONTEXT", v);
4042  Py_DECREF(v);
4043 
4044  v = Py_BuildValue("i", 12);
4045  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_RTCSREQUEST", v);
4046  Py_DECREF(v);
4047 
4048  v = Py_BuildValue("i", 13);
4049  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_RTCSRESPONSE", v);
4050  Py_DECREF(v);
4051 
4052  v = Py_BuildValue("i", 14);
4053  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_RTCSRESPONSE_EXT", v);
4054  Py_DECREF(v);
4055 
4056  v = Py_BuildValue("i", 15);
4057  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_MRTD", v);
4058  Py_DECREF(v);
4059 
4060  v = Py_BuildValue("i", 16);
4061  PyDict_SetItemString(moduleDict, "CRYPT_CONTENT_LAST", v);
4062  Py_DECREF(v);
4063 
4064  v = Py_BuildValue("i", 0);
4065  PyDict_SetItemString(moduleDict, "CRYPT_SIGNATURELEVEL_NONE", v);
4066  Py_DECREF(v); /* Include only signature */
4067 
4068  v = Py_BuildValue("i", 1);
4069  PyDict_SetItemString(moduleDict, "CRYPT_SIGNATURELEVEL_SIGNERCERT", v);
4070  Py_DECREF(v); /* Include signer cert */
4071 
4072  v = Py_BuildValue("i", 2);
4073  PyDict_SetItemString(moduleDict, "CRYPT_SIGNATURELEVEL_ALL", v);
4074  Py_DECREF(v); /* Include all relevant info */
4075 
4076  v = Py_BuildValue("i", 3);
4077  PyDict_SetItemString(moduleDict, "CRYPT_SIGNATURELEVEL_LAST", v);
4078  Py_DECREF(v); /* Last possible sig.level type */
4079 
4080  v = Py_BuildValue("i", 0);
4081  PyDict_SetItemString(moduleDict, "CRYPT_INTEGRITY_NONE", v);
4082  Py_DECREF(v); /* No integrity protection */
4083 
4084  v = Py_BuildValue("i", 1);
4085  PyDict_SetItemString(moduleDict, "CRYPT_INTEGRITY_MACONLY", v);
4086  Py_DECREF(v); /* MAC only, no encryption */
4087 
4088  v = Py_BuildValue("i", 2);
4089  PyDict_SetItemString(moduleDict, "CRYPT_INTEGRITY_FULL", v);
4090  Py_DECREF(v); /* Encryption + ingerity protection */
4091 
4092  v = Py_BuildValue("i", 0);
4093  PyDict_SetItemString(moduleDict, "CRYPT_CERTFORMAT_NONE", v);
4094  Py_DECREF(v); /* No certificate format */
4095 
4096  v = Py_BuildValue("i", 1);
4097  PyDict_SetItemString(moduleDict, "CRYPT_CERTFORMAT_CERTIFICATE", v);
4098  Py_DECREF(v); /* DER-encoded certificate */
4099 
4100  v = Py_BuildValue("i", 2);
4101  PyDict_SetItemString(moduleDict, "CRYPT_CERTFORMAT_CERTCHAIN", v);
4102  Py_DECREF(v); /* PKCS #7 certificate chain */
4103 
4104  v = Py_BuildValue("i", 3);
4105  PyDict_SetItemString(moduleDict, "CRYPT_CERTFORMAT_TEXT_CERTIFICATE", v);
4106  Py_DECREF(v); /* base-64 wrapped cert */
4107 
4108  v = Py_BuildValue("i", 4);
4109  PyDict_SetItemString(moduleDict, "CRYPT_CERTFORMAT_TEXT_CERTCHAIN", v);
4110  Py_DECREF(v); /* base-64 wrapped cert chain */
4111 
4112  v = Py_BuildValue("i", 5);
4113  PyDict_SetItemString(moduleDict, "CRYPT_CERTFORMAT_XML_CERTIFICATE", v);
4114  Py_DECREF(v); /* XML wrapped cert */
4115 
4116  v = Py_BuildValue("i", 6);
4117  PyDict_SetItemString(moduleDict, "CRYPT_CERTFORMAT_XML_CERTCHAIN", v);
4118  Py_DECREF(v); /* XML wrapped cert chain */
4119 
4120  v = Py_BuildValue("i", 7);
4121  PyDict_SetItemString(moduleDict, "CRYPT_CERTFORMAT_LAST", v);
4122  Py_DECREF(v); /* Last possible cert.format type */
4123 
4124  v = Py_BuildValue("i", 0);
4125  PyDict_SetItemString(moduleDict, "CRYPT_REQUESTTYPE_NONE", v);
4126  Py_DECREF(v); /* No request type */
4127 
4128  v = Py_BuildValue("i", 1);
4129  PyDict_SetItemString(moduleDict, "CRYPT_REQUESTTYPE_INITIALISATION", v);
4130  Py_DECREF(v); /* Initialisation request */
4131 
4132  v = Py_BuildValue("i", 1);
4133  PyDict_SetItemString(moduleDict, "CRYPT_REQUESTTYPE_INITIALIZATION", v);
4134  Py_DECREF(v);
4135 
4136  v = Py_BuildValue("i", 2);
4137  PyDict_SetItemString(moduleDict, "CRYPT_REQUESTTYPE_CERTIFICATE", v);
4138  Py_DECREF(v); /* Certification request */
4139 
4140  v = Py_BuildValue("i", 3);
4141  PyDict_SetItemString(moduleDict, "CRYPT_REQUESTTYPE_KEYUPDATE", v);
4142  Py_DECREF(v); /* Key update request */
4143 
4144  v = Py_BuildValue("i", 4);
4145  PyDict_SetItemString(moduleDict, "CRYPT_REQUESTTYPE_REVOCATION", v);
4146  Py_DECREF(v); /* Cert revocation request */
4147 
4148  v = Py_BuildValue("i", 5);
4149  PyDict_SetItemString(moduleDict, "CRYPT_REQUESTTYPE_PKIBOOT", v);
4150  Py_DECREF(v); /* PKIBoot request */
4151 
4152  v = Py_BuildValue("i", 6);
4153  PyDict_SetItemString(moduleDict, "CRYPT_REQUESTTYPE_LAST", v);
4154  Py_DECREF(v); /* Last possible request type */
4155 
4156  v = Py_BuildValue("i", 0);
4157  PyDict_SetItemString(moduleDict, "CRYPT_KEYID_NONE", v);
4158  Py_DECREF(v); /* No key ID type */
4159 
4160  v = Py_BuildValue("i", 1);
4161  PyDict_SetItemString(moduleDict, "CRYPT_KEYID_NAME", v);
4162  Py_DECREF(v); /* Key owner name */
4163 
4164  v = Py_BuildValue("i", 2);
4165  PyDict_SetItemString(moduleDict, "CRYPT_KEYID_URI", v);
4166  Py_DECREF(v); /* Key owner URI */
4167 
4168  v = Py_BuildValue("i", 2);
4169  PyDict_SetItemString(moduleDict, "CRYPT_KEYID_EMAIL", v);
4170  Py_DECREF(v); /* Synonym: owner email addr. */
4171 
4172  v = Py_BuildValue("i", 3);
4173  PyDict_SetItemString(moduleDict, "CRYPT_KEYID_LAST", v);
4174  Py_DECREF(v); /* Last possible key ID type */
4175 
4176  v = Py_BuildValue("i", 0);
4177  PyDict_SetItemString(moduleDict, "CRYPT_OBJECT_NONE", v);
4178  Py_DECREF(v); /* No object type */
4179 
4180  v = Py_BuildValue("i", 1);
4181  PyDict_SetItemString(moduleDict, "CRYPT_OBJECT_ENCRYPTED_KEY", v);
4182  Py_DECREF(v); /* Conventionally encrypted key */
4183 
4184  v = Py_BuildValue("i", 2);
4185  PyDict_SetItemString(moduleDict, "CRYPT_OBJECT_PKCENCRYPTED_KEY", v);
4186  Py_DECREF(v); /* PKC-encrypted key */
4187 
4188  v = Py_BuildValue("i", 3);
4189  PyDict_SetItemString(moduleDict, "CRYPT_OBJECT_KEYAGREEMENT", v);
4190  Py_DECREF(v); /* Key agreement information */
4191 
4192  v = Py_BuildValue("i", 4);
4193  PyDict_SetItemString(moduleDict, "CRYPT_OBJECT_SIGNATURE", v);
4194  Py_DECREF(v); /* Signature */
4195 
4196  v = Py_BuildValue("i", 5);
4197  PyDict_SetItemString(moduleDict, "CRYPT_OBJECT_LAST", v);
4198  Py_DECREF(v); /* Last possible object type */
4199 
4200  v = Py_BuildValue("i", 0);
4201  PyDict_SetItemString(moduleDict, "CRYPT_ERRTYPE_NONE", v);
4202  Py_DECREF(v); /* No error information */
4203 
4204  v = Py_BuildValue("i", 1);
4205  PyDict_SetItemString(moduleDict, "CRYPT_ERRTYPE_ATTR_SIZE", v);
4206  Py_DECREF(v); /* Attribute data too small or large */
4207 
4208  v = Py_BuildValue("i", 2);
4209  PyDict_SetItemString(moduleDict, "CRYPT_ERRTYPE_ATTR_VALUE", v);
4210  Py_DECREF(v); /* Attribute value is invalid */
4211 
4212  v = Py_BuildValue("i", 3);
4213  PyDict_SetItemString(moduleDict, "CRYPT_ERRTYPE_ATTR_ABSENT", v);
4214  Py_DECREF(v); /* Required attribute missing */
4215 
4216  v = Py_BuildValue("i", 4);
4217  PyDict_SetItemString(moduleDict, "CRYPT_ERRTYPE_ATTR_PRESENT", v);
4218  Py_DECREF(v); /* Non-allowed attribute present */
4219 
4220  v = Py_BuildValue("i", 5);
4221  PyDict_SetItemString(moduleDict, "CRYPT_ERRTYPE_CONSTRAINT", v);
4222  Py_DECREF(v); /* Cert: Constraint violation in object */
4223 
4224  v = Py_BuildValue("i", 6);
4225  PyDict_SetItemString(moduleDict, "CRYPT_ERRTYPE_ISSUERCONSTRAINT", v);
4226  Py_DECREF(v); /* Cert: Constraint viol.in issuing cert */
4227 
4228  v = Py_BuildValue("i", 7);
4229  PyDict_SetItemString(moduleDict, "CRYPT_ERRTYPE_LAST", v);
4230  Py_DECREF(v); /* Last possible error info type */
4231 
4232  v = Py_BuildValue("i", 0);
4233  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_NONE", v);
4234  Py_DECREF(v); /* No cert management action */
4235 
4236  v = Py_BuildValue("i", 1);
4237  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_CREATE", v);
4238  Py_DECREF(v); /* Create cert store */
4239 
4240  v = Py_BuildValue("i", 2);
4241  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_CONNECT", v);
4242  Py_DECREF(v); /* Connect to cert store */
4243 
4244  v = Py_BuildValue("i", 3);
4245  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_DISCONNECT", v);
4246  Py_DECREF(v); /* Disconnect from cert store */
4247 
4248  v = Py_BuildValue("i", 4);
4249  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_ERROR", v);
4250  Py_DECREF(v); /* Error information */
4251 
4252  v = Py_BuildValue("i", 5);
4253  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_ADDUSER", v);
4254  Py_DECREF(v); /* Add PKI user */
4255 
4256  v = Py_BuildValue("i", 6);
4257  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_DELETEUSER", v);
4258  Py_DECREF(v); /* Delete PKI user */
4259 
4260  v = Py_BuildValue("i", 7);
4261  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_REQUEST_CERT", v);
4262  Py_DECREF(v); /* Cert request */
4263 
4264  v = Py_BuildValue("i", 8);
4265  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_REQUEST_RENEWAL", v);
4266  Py_DECREF(v); /* Cert renewal request */
4267 
4268  v = Py_BuildValue("i", 9);
4269  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_REQUEST_REVOCATION", v);
4270  Py_DECREF(v); /* Cert revocation request */
4271 
4272  v = Py_BuildValue("i", 10);
4273  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_CERT_CREATION", v);
4274  Py_DECREF(v); /* Cert creation */
4275 
4276  v = Py_BuildValue("i", 11);
4277  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_CERT_CREATION_COMPLETE", v);
4278  Py_DECREF(v); /* Confirmation of cert creation */
4279 
4280  v = Py_BuildValue("i", 12);
4281  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_CERT_CREATION_DROP", v);
4282  Py_DECREF(v); /* Cancellation of cert creation */
4283 
4284  v = Py_BuildValue("i", 13);
4285  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_CERT_CREATION_REVERSE", v);
4286  Py_DECREF(v); /* Cancel of creation w.revocation */
4287 
4288  v = Py_BuildValue("i", 14);
4289  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_RESTART_CLEANUP", v);
4290  Py_DECREF(v); /* Delete reqs after restart */
4291 
4292  v = Py_BuildValue("i", 15);
4293  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_RESTART_REVOKE_CERT", v);
4294  Py_DECREF(v); /* Complete revocation after restart */
4295 
4296  v = Py_BuildValue("i", 16);
4297  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_ISSUE_CERT", v);
4298  Py_DECREF(v); /* Cert issue */
4299 
4300  v = Py_BuildValue("i", 17);
4301  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_ISSUE_CRL", v);
4302  Py_DECREF(v); /* CRL issue */
4303 
4304  v = Py_BuildValue("i", 18);
4305  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_REVOKE_CERT", v);
4306  Py_DECREF(v); /* Cert revocation */
4307 
4308  v = Py_BuildValue("i", 19);
4309  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_EXPIRE_CERT", v);
4310  Py_DECREF(v); /* Cert expiry */
4311 
4312  v = Py_BuildValue("i", 20);
4313  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_CLEANUP", v);
4314  Py_DECREF(v); /* Clean up on restart */
4315 
4316  v = Py_BuildValue("i", 21);
4317  PyDict_SetItemString(moduleDict, "CRYPT_CERTACTION_LAST", v);
4318  Py_DECREF(v); /* Last possible cert store log action */
4319 
4320  v = Py_BuildValue("i", 0);
4321  PyDict_SetItemString(moduleDict, "CRYPT_KEYOPT_NONE", v);
4322  Py_DECREF(v); /* No options */
4323 
4324  v = Py_BuildValue("i", 1);
4325  PyDict_SetItemString(moduleDict, "CRYPT_KEYOPT_READONLY", v);
4326  Py_DECREF(v); /* Open keyset in read-only mode */
4327 
4328  v = Py_BuildValue("i", 2);
4329  PyDict_SetItemString(moduleDict, "CRYPT_KEYOPT_CREATE", v);
4330  Py_DECREF(v); /* Create a new keyset */
4331 
4332  v = Py_BuildValue("i", 3);
4333  PyDict_SetItemString(moduleDict, "CRYPT_KEYOPT_LAST", v);
4334  Py_DECREF(v); /* Last possible key option type */
4335 
4336  v = Py_BuildValue("i", 0);
4337  PyDict_SetItemString(moduleDict, "CRYPT_ECCCURVE_NONE", v);
4338  Py_DECREF(v); /* No ECC curve type */
4339 
4340  v = Py_BuildValue("i", 1);
4341  PyDict_SetItemString(moduleDict, "CRYPT_ECCCURVE_P192", v);
4342  Py_DECREF(v); /* NIST P192/X9.62 P192r1/SECG p192r1 curve */
4343 
4344  v = Py_BuildValue("i", 2);
4345  PyDict_SetItemString(moduleDict, "CRYPT_ECCCURVE_P224", v);
4346  Py_DECREF(v); /* NIST P224/X9.62 P224r1/SECG p224r1 curve */
4347 
4348  v = Py_BuildValue("i", 3);
4349  PyDict_SetItemString(moduleDict, "CRYPT_ECCCURVE_P256", v);
4350  Py_DECREF(v); /* NIST P256/X9.62 P256v1/SECG p256r1 curve */
4351 
4352  v = Py_BuildValue("i", 4);
4353  PyDict_SetItemString(moduleDict, "CRYPT_ECCCURVE_P384", v);
4354  Py_DECREF(v); /* NIST P384, SECG p384r1 curve */
4355 
4356  v = Py_BuildValue("i", 5);
4357  PyDict_SetItemString(moduleDict, "CRYPT_ECCCURVE_P521", v);
4358  Py_DECREF(v); /* NIST P521, SECG p521r1 */
4359 
4360  v = Py_BuildValue("i", 6);
4361  PyDict_SetItemString(moduleDict, "CRYPT_ECCCURVE_LAST", v);
4362  Py_DECREF(v); /* Last valid ECC curve type */
4363 
4364  v = Py_BuildValue("i", 0);
4365  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASON_UNSPECIFIED", v);
4366  Py_DECREF(v);
4367 
4368  v = Py_BuildValue("i", 1);
4369  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASON_KEYCOMPROMISE", v);
4370  Py_DECREF(v);
4371 
4372  v = Py_BuildValue("i", 2);
4373  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASON_CACOMPROMISE", v);
4374  Py_DECREF(v);
4375 
4376  v = Py_BuildValue("i", 3);
4377  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASON_AFFILIATIONCHANGED", v);
4378  Py_DECREF(v);
4379 
4380  v = Py_BuildValue("i", 4);
4381  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASON_SUPERSEDED", v);
4382  Py_DECREF(v);
4383 
4384  v = Py_BuildValue("i", 5);
4385  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASON_CESSATIONOFOPERATION", v);
4386  Py_DECREF(v);
4387 
4388  v = Py_BuildValue("i", 6);
4389  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASON_CERTIFICATEHOLD", v);
4390  Py_DECREF(v);
4391 
4392  v = Py_BuildValue("i", 8);
4393  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASON_REMOVEFROMCRL", v);
4394  Py_DECREF(v);
4395 
4396  v = Py_BuildValue("i", 9);
4397  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASON_PRIVILEGEWITHDRAWN", v);
4398  Py_DECREF(v);
4399 
4400  v = Py_BuildValue("i", 10);
4401  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASON_AACOMPROMISE", v);
4402  Py_DECREF(v);
4403 
4404  v = Py_BuildValue("i", 11);
4405  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASON_LAST", v);
4406  Py_DECREF(v); /* End of standard CRL reasons */
4407 
4408  v = Py_BuildValue("i", 20);
4409  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASON_NEVERVALID", v);
4410  Py_DECREF(v);
4411 
4412  v = Py_BuildValue("i", 21);
4413  PyDict_SetItemString(moduleDict, "CRYPT_CRLEXTREASON_LAST", v);
4414  Py_DECREF(v);
4415 
4416  v = Py_BuildValue("i", 0);
4417  PyDict_SetItemString(moduleDict, "CRYPT_HOLDINSTRUCTION_NONE", v);
4418  Py_DECREF(v);
4419 
4420  v = Py_BuildValue("i", 1);
4421  PyDict_SetItemString(moduleDict, "CRYPT_HOLDINSTRUCTION_CALLISSUER", v);
4422  Py_DECREF(v);
4423 
4424  v = Py_BuildValue("i", 2);
4425  PyDict_SetItemString(moduleDict, "CRYPT_HOLDINSTRUCTION_REJECT", v);
4426  Py_DECREF(v);
4427 
4428  v = Py_BuildValue("i", 3);
4429  PyDict_SetItemString(moduleDict, "CRYPT_HOLDINSTRUCTION_PICKUPTOKEN", v);
4430  Py_DECREF(v);
4431 
4432  v = Py_BuildValue("i", 4);
4433  PyDict_SetItemString(moduleDict, "CRYPT_HOLDINSTRUCTION_LAST", v);
4434  Py_DECREF(v);
4435 
4436  v = Py_BuildValue("i", 0);
4437  PyDict_SetItemString(moduleDict, "CRYPT_COMPLIANCELEVEL_OBLIVIOUS", v);
4438  Py_DECREF(v);
4439 
4440  v = Py_BuildValue("i", 1);
4441  PyDict_SetItemString(moduleDict, "CRYPT_COMPLIANCELEVEL_REDUCED", v);
4442  Py_DECREF(v);
4443 
4444  v = Py_BuildValue("i", 2);
4445  PyDict_SetItemString(moduleDict, "CRYPT_COMPLIANCELEVEL_STANDARD", v);
4446  Py_DECREF(v);
4447 
4448  v = Py_BuildValue("i", 3);
4449  PyDict_SetItemString(moduleDict, "CRYPT_COMPLIANCELEVEL_PKIX_PARTIAL", v);
4450  Py_DECREF(v);
4451 
4452  v = Py_BuildValue("i", 4);
4453  PyDict_SetItemString(moduleDict, "CRYPT_COMPLIANCELEVEL_PKIX_FULL", v);
4454  Py_DECREF(v);
4455 
4456  v = Py_BuildValue("i", 5);
4457  PyDict_SetItemString(moduleDict, "CRYPT_COMPLIANCELEVEL_LAST", v);
4458  Py_DECREF(v);
4459 
4460  v = Py_BuildValue("i", 0);
4461  PyDict_SetItemString(moduleDict, "CRYPT_CLASSIFICATION_UNMARKED", v);
4462  Py_DECREF(v);
4463 
4464  v = Py_BuildValue("i", 1);
4465  PyDict_SetItemString(moduleDict, "CRYPT_CLASSIFICATION_UNCLASSIFIED", v);
4466  Py_DECREF(v);
4467 
4468  v = Py_BuildValue("i", 2);
4469  PyDict_SetItemString(moduleDict, "CRYPT_CLASSIFICATION_RESTRICTED", v);
4470  Py_DECREF(v);
4471 
4472  v = Py_BuildValue("i", 3);
4473  PyDict_SetItemString(moduleDict, "CRYPT_CLASSIFICATION_CONFIDENTIAL", v);
4474  Py_DECREF(v);
4475 
4476  v = Py_BuildValue("i", 4);
4477  PyDict_SetItemString(moduleDict, "CRYPT_CLASSIFICATION_SECRET", v);
4478  Py_DECREF(v);
4479 
4480  v = Py_BuildValue("i", 5);
4481  PyDict_SetItemString(moduleDict, "CRYPT_CLASSIFICATION_TOP_SECRET", v);
4482  Py_DECREF(v);
4483 
4484  v = Py_BuildValue("i", 255);
4485  PyDict_SetItemString(moduleDict, "CRYPT_CLASSIFICATION_LAST", v);
4486  Py_DECREF(v);
4487 
4488  v = Py_BuildValue("i", 0);
4489  PyDict_SetItemString(moduleDict, "CRYPT_CERTSTATUS_VALID", v);
4490  Py_DECREF(v);
4491 
4492  v = Py_BuildValue("i", 1);
4493  PyDict_SetItemString(moduleDict, "CRYPT_CERTSTATUS_NOTVALID", v);
4494  Py_DECREF(v);
4495 
4496  v = Py_BuildValue("i", 2);
4497  PyDict_SetItemString(moduleDict, "CRYPT_CERTSTATUS_NONAUTHORITATIVE", v);
4498  Py_DECREF(v);
4499 
4500  v = Py_BuildValue("i", 3);
4501  PyDict_SetItemString(moduleDict, "CRYPT_CERTSTATUS_UNKNOWN", v);
4502  Py_DECREF(v);
4503 
4504  v = Py_BuildValue("i", 0);
4505  PyDict_SetItemString(moduleDict, "CRYPT_OCSPSTATUS_NOTREVOKED", v);
4506  Py_DECREF(v);
4507 
4508  v = Py_BuildValue("i", 1);
4509  PyDict_SetItemString(moduleDict, "CRYPT_OCSPSTATUS_REVOKED", v);
4510  Py_DECREF(v);
4511 
4512  v = Py_BuildValue("i", 2);
4513  PyDict_SetItemString(moduleDict, "CRYPT_OCSPSTATUS_UNKNOWN", v);
4514  Py_DECREF(v);
4515 
4516  v = Py_BuildValue("i", 0x000);
4517  PyDict_SetItemString(moduleDict, "CRYPT_KEYUSAGE_NONE", v);
4518  Py_DECREF(v);
4519 
4520  v = Py_BuildValue("i", 0x001);
4521  PyDict_SetItemString(moduleDict, "CRYPT_KEYUSAGE_DIGITALSIGNATURE", v);
4522  Py_DECREF(v);
4523 
4524  v = Py_BuildValue("i", 0x002);
4525  PyDict_SetItemString(moduleDict, "CRYPT_KEYUSAGE_NONREPUDIATION", v);
4526  Py_DECREF(v);
4527 
4528  v = Py_BuildValue("i", 0x004);
4529  PyDict_SetItemString(moduleDict, "CRYPT_KEYUSAGE_KEYENCIPHERMENT", v);
4530  Py_DECREF(v);
4531 
4532  v = Py_BuildValue("i", 0x008);
4533  PyDict_SetItemString(moduleDict, "CRYPT_KEYUSAGE_DATAENCIPHERMENT", v);
4534  Py_DECREF(v);
4535 
4536  v = Py_BuildValue("i", 0x010);
4537  PyDict_SetItemString(moduleDict, "CRYPT_KEYUSAGE_KEYAGREEMENT", v);
4538  Py_DECREF(v);
4539 
4540  v = Py_BuildValue("i", 0x020);
4541  PyDict_SetItemString(moduleDict, "CRYPT_KEYUSAGE_KEYCERTSIGN", v);
4542  Py_DECREF(v);
4543 
4544  v = Py_BuildValue("i", 0x040);
4545  PyDict_SetItemString(moduleDict, "CRYPT_KEYUSAGE_CRLSIGN", v);
4546  Py_DECREF(v);
4547 
4548  v = Py_BuildValue("i", 0x080);
4549  PyDict_SetItemString(moduleDict, "CRYPT_KEYUSAGE_ENCIPHERONLY", v);
4550  Py_DECREF(v);
4551 
4552  v = Py_BuildValue("i", 0x100);
4553  PyDict_SetItemString(moduleDict, "CRYPT_KEYUSAGE_DECIPHERONLY", v);
4554  Py_DECREF(v);
4555 
4556  v = Py_BuildValue("i", 0x200);
4557  PyDict_SetItemString(moduleDict, "CRYPT_KEYUSAGE_LAST", v);
4558  Py_DECREF(v); /* Last possible value */
4559 
4560  v = Py_BuildValue("i", 0x001);
4561  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASONFLAG_UNUSED", v);
4562  Py_DECREF(v);
4563 
4564  v = Py_BuildValue("i", 0x002);
4565  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASONFLAG_KEYCOMPROMISE", v);
4566  Py_DECREF(v);
4567 
4568  v = Py_BuildValue("i", 0x004);
4569  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASONFLAG_CACOMPROMISE", v);
4570  Py_DECREF(v);
4571 
4572  v = Py_BuildValue("i", 0x008);
4573  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASONFLAG_AFFILIATIONCHANGED", v);
4574  Py_DECREF(v);
4575 
4576  v = Py_BuildValue("i", 0x010);
4577  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASONFLAG_SUPERSEDED", v);
4578  Py_DECREF(v);
4579 
4580  v = Py_BuildValue("i", 0x020);
4581  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASONFLAG_CESSATIONOFOPERATION", v);
4582  Py_DECREF(v);
4583 
4584  v = Py_BuildValue("i", 0x040);
4585  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASONFLAG_CERTIFICATEHOLD", v);
4586  Py_DECREF(v);
4587 
4588  v = Py_BuildValue("i", 0x080);
4589  PyDict_SetItemString(moduleDict, "CRYPT_CRLREASONFLAG_LAST", v);
4590  Py_DECREF(v); /* Last poss.value */
4591 
4592  v = Py_BuildValue("i", 0x001);
4593  PyDict_SetItemString(moduleDict, "CRYPT_NS_CERTTYPE_SSLCLIENT", v);
4594  Py_DECREF(v);
4595 
4596  v = Py_BuildValue("i", 0x002);
4597  PyDict_SetItemString(moduleDict, "CRYPT_NS_CERTTYPE_SSLSERVER", v);
4598  Py_DECREF(v);
4599 
4600  v = Py_BuildValue("i", 0x004);
4601  PyDict_SetItemString(moduleDict, "CRYPT_NS_CERTTYPE_SMIME", v);
4602  Py_DECREF(v);
4603 
4604  v = Py_BuildValue("i", 0x008);
4605  PyDict_SetItemString(moduleDict, "CRYPT_NS_CERTTYPE_OBJECTSIGNING", v);
4606  Py_DECREF(v);
4607 
4608  v = Py_BuildValue("i", 0x010);
4609  PyDict_SetItemString(moduleDict, "CRYPT_NS_CERTTYPE_RESERVED", v);
4610  Py_DECREF(v);
4611 
4612  v = Py_BuildValue("i", 0x020);
4613  PyDict_SetItemString(moduleDict, "CRYPT_NS_CERTTYPE_SSLCA", v);
4614  Py_DECREF(v);
4615 
4616  v = Py_BuildValue("i", 0x040);
4617  PyDict_SetItemString(moduleDict, "CRYPT_NS_CERTTYPE_SMIMECA", v);
4618  Py_DECREF(v);
4619 
4620  v = Py_BuildValue("i", 0x080);
4621  PyDict_SetItemString(moduleDict, "CRYPT_NS_CERTTYPE_OBJECTSIGNINGCA", v);
4622  Py_DECREF(v);
4623 
4624  v = Py_BuildValue("i", 0x100);
4625  PyDict_SetItemString(moduleDict, "CRYPT_NS_CERTTYPE_LAST", v);
4626  Py_DECREF(v); /* Last possible value */
4627 
4628  v = Py_BuildValue("i", 0x001);
4629  PyDict_SetItemString(moduleDict, "CRYPT_SET_CERTTYPE_CARD", v);
4630  Py_DECREF(v);
4631 
4632  v = Py_BuildValue("i", 0x002);
4633  PyDict_SetItemString(moduleDict, "CRYPT_SET_CERTTYPE_MER", v);
4634  Py_DECREF(v);
4635 
4636  v = Py_BuildValue("i", 0x004);
4637  PyDict_SetItemString(moduleDict, "CRYPT_SET_CERTTYPE_PGWY", v);
4638  Py_DECREF(v);
4639 
4640  v = Py_BuildValue("i", 0x008);
4641  PyDict_SetItemString(moduleDict, "CRYPT_SET_CERTTYPE_CCA", v);
4642  Py_DECREF(v);
4643 
4644  v = Py_BuildValue("i", 0x010);
4645  PyDict_SetItemString(moduleDict, "CRYPT_SET_CERTTYPE_MCA", v);
4646  Py_DECREF(v);
4647 
4648  v = Py_BuildValue("i", 0x020);
4649  PyDict_SetItemString(moduleDict, "CRYPT_SET_CERTTYPE_PCA", v);
4650  Py_DECREF(v);
4651 
4652  v = Py_BuildValue("i", 0x040);
4653  PyDict_SetItemString(moduleDict, "CRYPT_SET_CERTTYPE_GCA", v);
4654  Py_DECREF(v);
4655 
4656  v = Py_BuildValue("i", 0x080);
4657  PyDict_SetItemString(moduleDict, "CRYPT_SET_CERTTYPE_BCA", v);
4658  Py_DECREF(v);
4659 
4660  v = Py_BuildValue("i", 0x100);
4661  PyDict_SetItemString(moduleDict, "CRYPT_SET_CERTTYPE_RCA", v);
4662  Py_DECREF(v);
4663 
4664  v = Py_BuildValue("i", 0x200);
4665  PyDict_SetItemString(moduleDict, "CRYPT_SET_CERTTYPE_ACQ", v);
4666  Py_DECREF(v);
4667 
4668  v = Py_BuildValue("i", 0x400);
4669  PyDict_SetItemString(moduleDict, "CRYPT_SET_CERTTYPE_LAST", v);
4670  Py_DECREF(v); /* Last possible value */
4671 
4672  v = Py_BuildValue("i", 0x00);
4673  PyDict_SetItemString(moduleDict, "CRYPT_SSLOPTION_NONE", v);
4674  Py_DECREF(v);
4675 
4676  v = Py_BuildValue("i", 0x00);
4677  PyDict_SetItemString(moduleDict, "CRYPT_SSLOPTION_MINVER_SSLV3", v);
4678  Py_DECREF(v); /* Min.protocol version */
4679 
4680  v = Py_BuildValue("i", 0x01);
4681  PyDict_SetItemString(moduleDict, "CRYPT_SSLOPTION_MINVER_TLS10", v);
4682  Py_DECREF(v);
4683 
4684  v = Py_BuildValue("i", 0x02);
4685  PyDict_SetItemString(moduleDict, "CRYPT_SSLOPTION_MINVER_TLS11", v);
4686  Py_DECREF(v);
4687 
4688  v = Py_BuildValue("i", 0x03);
4689  PyDict_SetItemString(moduleDict, "CRYPT_SSLOPTION_MINVER_TLS12", v);
4690  Py_DECREF(v);
4691 
4692  v = Py_BuildValue("i", 0x04);
4693  PyDict_SetItemString(moduleDict, "CRYPT_SSLOPTION_SUITEB_128", v);
4694  Py_DECREF(v); /* SuiteB security levels */
4695 
4696  v = Py_BuildValue("i", 0x08);
4697  PyDict_SetItemString(moduleDict, "CRYPT_SSLOPTION_SUITEB_256", v);
4698  Py_DECREF(v);
4699 
4700  v = Py_BuildValue("i", 256);
4701  PyDict_SetItemString(moduleDict, "CRYPT_MAX_KEYSIZE", v);
4702  Py_DECREF(v);
4703 
4704  v = Py_BuildValue("i", 32);
4705  PyDict_SetItemString(moduleDict, "CRYPT_MAX_IVSIZE", v);
4706  Py_DECREF(v);
4707 
4708  v = Py_BuildValue("i", 512);
4709  PyDict_SetItemString(moduleDict, "CRYPT_MAX_PKCSIZE", v);
4710  Py_DECREF(v);
4711 
4712  v = Py_BuildValue("i", 72);
4713  PyDict_SetItemString(moduleDict, "CRYPT_MAX_PKCSIZE_ECC", v);
4714  Py_DECREF(v);
4715 
4716  v = Py_BuildValue("i", 64);
4717  PyDict_SetItemString(moduleDict, "CRYPT_MAX_HASHSIZE", v);
4718  Py_DECREF(v);
4719 
4720  v = Py_BuildValue("i", 64);
4721  PyDict_SetItemString(moduleDict, "CRYPT_MAX_TEXTSIZE", v);
4722  Py_DECREF(v);
4723 
4724  v = Py_BuildValue("i", 0);
4725  PyDict_SetItemString(moduleDict, "CRYPT_KEYTYPE_PRIVATE", v);
4726  Py_DECREF(v);
4727 
4728  v = Py_BuildValue("i", 1);
4729  PyDict_SetItemString(moduleDict, "CRYPT_KEYTYPE_PUBLIC", v);
4730  Py_DECREF(v);
4731 
4732  v = Py_BuildValue("i", 0);
4733  PyDict_SetItemString(moduleDict, "CRYPT_OK", v);
4734  Py_DECREF(v); /* No error */
4735 
4736  v = Py_BuildValue("i", -100);
4737  PyDict_SetItemString(moduleDict, "CRYPT_USE_DEFAULT", v);
4738  Py_DECREF(v);
4739 
4740  v = Py_BuildValue("i", -101);
4741  PyDict_SetItemString(moduleDict, "CRYPT_UNUSED", v);
4742  Py_DECREF(v);
4743 
4744  v = Py_BuildValue("i", -200);
4745  PyDict_SetItemString(moduleDict, "CRYPT_CURSOR_FIRST", v);
4746  Py_DECREF(v);
4747 
4748  v = Py_BuildValue("i", -201);
4749  PyDict_SetItemString(moduleDict, "CRYPT_CURSOR_PREVIOUS", v);
4750  Py_DECREF(v);
4751 
4752  v = Py_BuildValue("i", -202);
4753  PyDict_SetItemString(moduleDict, "CRYPT_CURSOR_NEXT", v);
4754  Py_DECREF(v);
4755 
4756  v = Py_BuildValue("i", -203);
4757  PyDict_SetItemString(moduleDict, "CRYPT_CURSOR_LAST", v);
4758  Py_DECREF(v);
4759 
4760  v = Py_BuildValue("i", -300);
4761  PyDict_SetItemString(moduleDict, "CRYPT_RANDOM_FASTPOLL", v);
4762  Py_DECREF(v);
4763 
4764  v = Py_BuildValue("i", -301);
4765  PyDict_SetItemString(moduleDict, "CRYPT_RANDOM_SLOWPOLL", v);
4766  Py_DECREF(v);
4767 
4768  v = Py_BuildValue("i", -1);
4769  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_PARAM1", v);
4770  Py_DECREF(v); /* Bad argument, parameter 1 */
4771 
4772  v = Py_BuildValue("i", -2);
4773  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_PARAM2", v);
4774  Py_DECREF(v); /* Bad argument, parameter 2 */
4775 
4776  v = Py_BuildValue("i", -3);
4777  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_PARAM3", v);
4778  Py_DECREF(v); /* Bad argument, parameter 3 */
4779 
4780  v = Py_BuildValue("i", -4);
4781  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_PARAM4", v);
4782  Py_DECREF(v); /* Bad argument, parameter 4 */
4783 
4784  v = Py_BuildValue("i", -5);
4785  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_PARAM5", v);
4786  Py_DECREF(v); /* Bad argument, parameter 5 */
4787 
4788  v = Py_BuildValue("i", -6);
4789  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_PARAM6", v);
4790  Py_DECREF(v); /* Bad argument, parameter 6 */
4791 
4792  v = Py_BuildValue("i", -7);
4793  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_PARAM7", v);
4794  Py_DECREF(v); /* Bad argument, parameter 7 */
4795 
4796  v = Py_BuildValue("i", -10);
4797  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_MEMORY", v);
4798  Py_DECREF(v); /* Out of memory */
4799 
4800  v = Py_BuildValue("i", -11);
4801  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_NOTINITED", v);
4802  Py_DECREF(v); /* Data has not been initialised */
4803 
4804  v = Py_BuildValue("i", -12);
4805  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_INITED", v);
4806  Py_DECREF(v); /* Data has already been init'd */
4807 
4808  v = Py_BuildValue("i", -13);
4809  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_NOSECURE", v);
4810  Py_DECREF(v); /* Opn.not avail.at requested sec.level */
4811 
4812  v = Py_BuildValue("i", -14);
4813  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_RANDOM", v);
4814  Py_DECREF(v); /* No reliable random data available */
4815 
4816  v = Py_BuildValue("i", -15);
4817  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_FAILED", v);
4818  Py_DECREF(v); /* Operation failed */
4819 
4820  v = Py_BuildValue("i", -16);
4821  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_INTERNAL", v);
4822  Py_DECREF(v); /* Internal consistency check failed */
4823 
4824  v = Py_BuildValue("i", -20);
4825  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_NOTAVAIL", v);
4826  Py_DECREF(v); /* This type of opn.not available */
4827 
4828  v = Py_BuildValue("i", -21);
4829  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_PERMISSION", v);
4830  Py_DECREF(v); /* No permiss.to perform this operation */
4831 
4832  v = Py_BuildValue("i", -22);
4833  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_WRONGKEY", v);
4834  Py_DECREF(v); /* Incorrect key used to decrypt data */
4835 
4836  v = Py_BuildValue("i", -23);
4837  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_INCOMPLETE", v);
4838  Py_DECREF(v); /* Operation incomplete/still in progress */
4839 
4840  v = Py_BuildValue("i", -24);
4841  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_COMPLETE", v);
4842  Py_DECREF(v); /* Operation complete/can't continue */
4843 
4844  v = Py_BuildValue("i", -25);
4845  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_TIMEOUT", v);
4846  Py_DECREF(v); /* Operation timed out before completion */
4847 
4848  v = Py_BuildValue("i", -26);
4849  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_INVALID", v);
4850  Py_DECREF(v); /* Invalid/inconsistent information */
4851 
4852  v = Py_BuildValue("i", -27);
4853  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_SIGNALLED", v);
4854  Py_DECREF(v); /* Resource destroyed by extnl.event */
4855 
4856  v = Py_BuildValue("i", -30);
4857  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_OVERFLOW", v);
4858  Py_DECREF(v); /* Resources/space exhausted */
4859 
4860  v = Py_BuildValue("i", -31);
4861  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_UNDERFLOW", v);
4862  Py_DECREF(v); /* Not enough data available */
4863 
4864  v = Py_BuildValue("i", -32);
4865  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_BADDATA", v);
4866  Py_DECREF(v); /* Bad/unrecognised data format */
4867 
4868  v = Py_BuildValue("i", -33);
4869  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_SIGNATURE", v);
4870  Py_DECREF(v); /* Signature/integrity check failed */
4871 
4872  v = Py_BuildValue("i", -40);
4873  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_OPEN", v);
4874  Py_DECREF(v); /* Cannot open object */
4875 
4876  v = Py_BuildValue("i", -41);
4877  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_READ", v);
4878  Py_DECREF(v); /* Cannot read item from object */
4879 
4880  v = Py_BuildValue("i", -42);
4881  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_WRITE", v);
4882  Py_DECREF(v); /* Cannot write item to object */
4883 
4884  v = Py_BuildValue("i", -43);
4885  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_NOTFOUND", v);
4886  Py_DECREF(v); /* Requested item not found in object */
4887 
4888  v = Py_BuildValue("i", -44);
4889  PyDict_SetItemString(moduleDict, "CRYPT_ERROR_DUPLICATE", v);
4890  Py_DECREF(v); /* Item already present in object */
4891 
4892  v = Py_BuildValue("i", -50);
4893  PyDict_SetItemString(moduleDict, "CRYPT_ENVELOPE_RESOURCE", v);
4894  Py_DECREF(v); /* Need resource to proceed */
4895 }
Generated on Thu Jan 10 2013 10:00:43 for cryptlib by   doxygen 1.8.2