OpenSSL/crypto/pkcs12.c

   1 /*
   2  * pkcs12.c
   3  *
   4  * Copyright (C) AB Strakt
   5  * See LICENSE for details.
   6  *
   7  * Certificate transport (PKCS12) handling code,
   8  * mostly thin wrappers around OpenSSL.
   9  * See the file RATIONALE for a short explanation of why
  10  * this module was written.
  11  *
  12  * Reviewed 2001-07-23
  13  */
  14 #include <Python.h>
  15 #define crypto_MODULE
  16 #include "crypto.h"
  17
  18 /*
  19  * PKCS12 is a standard exchange format for digital certificates.
  20  * See e.g. the OpenSSL homepage http://www.openssl.org/ for more information
  21  */
  22
  23 static void crypto_PKCS12_dealloc(crypto_PKCS12Obj *self);
  24 static int crypto_PKCS12_clear(crypto_PKCS12Obj *self);
  25
  26 static char crypto_PKCS12_get_certificate_doc[] = "\n\
  27 Return certificate portion of the PKCS12 structure\n\
  28 \n\
  29 @return: X509 object containing the certificate\n\
  30 ";
  31 static PyObject *
  32 crypto_PKCS12_get_certificate(crypto_PKCS12Obj *self, PyObject *args)
  33 {
  34     if (!PyArg_ParseTuple(args, ":get_certificate"))
  35         return NULL;
  36
  37     Py_INCREF(self->cert);
  38     return self->cert;
  39 }
  40
  41 static char crypto_PKCS12_set_certificate_doc[] = "\n\
  42 Replace the certificate portion of the PKCS12 structure\n\
  43 \n\
  44 @param cert: The new certificate.\n\
  45 @type cert: L{X509} or L{NoneType}\n\
  46 @return: None\n\
  47 ";
  48 static PyObject *
  49 crypto_PKCS12_set_certificate(crypto_PKCS12Obj *self, PyObject *args, PyObject *keywds) {
  50     PyObject *cert = NULL;
  51     static char *kwlist[] = {"cert", NULL};
  52
  53     if (!PyArg_ParseTupleAndKeywords(args, keywds, "O:set_certificate",
  54         kwlist, &cert))
  55         return NULL;
  56
  57     if (cert != Py_None && ! crypto_X509_Check(cert)) {
  58         PyErr_SetString(PyExc_TypeError, "cert must be type X509 or None");
  59         return NULL;
  60     }
  61
  62     Py_INCREF(cert);  /* Make consistent before calling Py_DECREF() */
  63     Py_DECREF(self->cert);
  64     self->cert = cert;
  65
  66     Py_INCREF(Py_None);
  67     return Py_None;
  68 }
  69
  70 static char crypto_PKCS12_get_privatekey_doc[] = "\n\
  71 Return private key portion of the PKCS12 structure\n\
  72 \n\
  73 @returns: PKey object containing the private key\n\
  74 ";
  75 static crypto_PKeyObj *
  76 crypto_PKCS12_get_privatekey(crypto_PKCS12Obj *self, PyObject *args)
  77 {
  78     if (!PyArg_ParseTuple(args, ":get_privatekey"))
  79         return NULL;
  80
  81     Py_INCREF(self->key);
  82     return (crypto_PKeyObj *) self->key;
  83 }
  84
  85 static char crypto_PKCS12_set_privatekey_doc[] = "\n\
  86 Replace or set the certificate portion of the PKCS12 structure\n\
  87 \n\
  88 @param pkey: The new private key.\n\
  89 @type pkey: L{PKey}\n\
  90 @return: None\n\
  91 ";
  92 static PyObject *
  93 crypto_PKCS12_set_privatekey(crypto_PKCS12Obj *self, PyObject *args, PyObject *keywds) {
  94     PyObject *pkey = NULL;
  95     static char *kwlist[] = {"pkey", NULL};
  96
  97     if (!PyArg_ParseTupleAndKeywords(args, keywds, "O:set_privatekey",
  98         kwlist, &pkey))
  99         return NULL;
 100
 101     if (pkey != Py_None && ! crypto_PKey_Check(pkey)) {
 102         PyErr_SetString(PyExc_TypeError, "pkey must be type X509 or None");
 103         return NULL;
 104     }
 105
 106     Py_INCREF(pkey);  /* Make consistent before calling Py_DECREF() */
 107     Py_DECREF(self->key);
 108     self->key = pkey;
 109
 110     Py_INCREF(Py_None);
 111     return Py_None;
 112 }
 113
 114 static char crypto_PKCS12_get_ca_certificates_doc[] = "\n\
 115 Return CA certificates within of the PKCS12 object\n\
 116 \n\
 117 @return: A newly created tuple containing the CA certificates in the chain,\n\
 118          if any are present, or None if no CA certificates are present.\n\
 119 ";
 120 static PyObject *
 121 crypto_PKCS12_get_ca_certificates(crypto_PKCS12Obj *self, PyObject *args)
 122 {
 123     if (!PyArg_ParseTuple(args, ":get_ca_certificates"))
 124         return NULL;
 125
 126     Py_INCREF(self->cacerts);
 127     return self->cacerts;
 128 }
 129
 130 static char crypto_PKCS12_set_ca_certificates_doc[] = "\n\
 131 Replace or set the CA certificates withing the PKCS12 object.\n\
 132 \n\
 133 @param cacerts: The new CA certificates.\n\
 134 @type cacerts: Iterable of L{X509} or L{NoneType}\n\
 135 @return: None\n\
 136 ";
 137 static PyObject *
 138 crypto_PKCS12_set_ca_certificates(crypto_PKCS12Obj *self, PyObject *args, PyObject *keywds)
 139 {
 140     PyObject *obj;
 141     PyObject *cacerts;
 142     static char *kwlist[] = {"cacerts", NULL};
 143     int i, len; /* Py_ssize_t for Python 2.5+ */
 144
 145     if (!PyArg_ParseTupleAndKeywords(args, keywds, "O:set_ca_certificates",
 146         kwlist, &cacerts))
 147         return NULL;
 148     if (cacerts == Py_None) {
 149         Py_INCREF(cacerts);
 150     } else {
 151         /* It's iterable */
 152         cacerts = PySequence_Tuple(cacerts);
 153         if (cacerts == NULL) {
 154             return NULL;
 155         }
 156         len = PyTuple_Size(cacerts);
 157
 158         /* Check is's a simple list filled only with X509 objects. */
 159         for (i = 0; i < len; i++) {
 160             obj = PyTuple_GetItem(cacerts, i);
 161             if (!crypto_X509_Check(obj)) {
 162                 Py_DECREF(cacerts);
 163                 PyErr_SetString(PyExc_TypeError, "iterable must only contain X509Type");
 164                 return NULL;
 165             }
 166         }
 167     }
 168
 169     Py_DECREF(self->cacerts);
 170     self->cacerts = cacerts;
 171
 172     Py_INCREF(Py_None);
 173     return Py_None;
 174 }
 175
 176 static char crypto_PKCS12_get_friendlyname_doc[] = "\n\
 177 Return friendly name portion of the PKCS12 structure\n\
 178 \n\
 179 @returns: String containing the friendlyname\n\
 180 ";
 181 static PyObject *
 182 crypto_PKCS12_get_friendlyname(crypto_PKCS12Obj *self, PyObject *args) {
 183     if (!PyArg_ParseTuple(args, ":get_friendlyname"))
 184         return NULL;
 185
 186     Py_INCREF(self->friendlyname);
 187     return (PyObject *) self->friendlyname;
 188 }
 189
 190 static char crypto_PKCS12_set_friendlyname_doc[] = "\n\
 191 Replace or set the certificate portion of the PKCS12 structure\n\
 192 \n\
 193 @param name: The new friendly name.\n\
 194 @type name: L{str}\n\
 195 @return: None\n\
 196 ";
 197 static PyObject *
 198 crypto_PKCS12_set_friendlyname(crypto_PKCS12Obj *self, PyObject *args, PyObject *keywds) {
 199     PyObject *name = NULL;
 200     static char *kwlist[] = {"name", NULL};
 201
 202     if (!PyArg_ParseTupleAndKeywords(args, keywds, "O:set_friendlyname",
 203         kwlist, &name))
 204         return NULL;
 205
 206     if (name != Py_None && ! PyBytes_CheckExact(name)) {
 207         PyErr_SetString(PyExc_TypeError, "name must be a byte string or None");
 208         return NULL;
 209     }
 210
 211     Py_INCREF(name);  /* Make consistent before calling Py_DECREF() */
 212     Py_DECREF(self->friendlyname);
 213     self->friendlyname = name;
 214
 215     Py_INCREF(Py_None);
 216     return Py_None;
 217 }
 218
 219 static char crypto_PKCS12_export_doc[] = "\n\
 220 export([passphrase=None][, friendly_name=None][, iter=2048][, maciter=1]\n\
 221 Dump a PKCS12 object as a string.  See also \"man PKCS12_create\".\n\
 222 \n\
 223 @param passphrase: used to encrypt the PKCS12\n\
 224 @type passphrase: L{str}\n\
 225 @param iter: How many times to repeat the encryption\n\
 226 @type iter: L{int}\n\
 227 @param maciter: How many times to repeat the MAC\n\
 228 @type maciter: L{int}\n\
 229 @return: The string containing the PKCS12\n\
 230 ";
 231 static PyObject *
 232 crypto_PKCS12_export(crypto_PKCS12Obj *self, PyObject *args, PyObject *keywds) {
 233     int i; /* Py_ssize_t for Python 2.5+ */
 234     PyObject *obj;
 235     int buf_len;
 236     PyObject *buffer;
 237     char *temp, *passphrase = NULL, *friendly_name = NULL;
 238     BIO *bio;
 239     PKCS12 *p12;
 240     EVP_PKEY *pkey = NULL;
 241     STACK_OF(X509) *cacerts = NULL;
 242     X509 *x509 = NULL;
 243     int iter = 0;  /* defaults to PKCS12_DEFAULT_ITER */
 244     int maciter = 0;
 245     static char *kwlist[] = {"passphrase", "iter", "maciter", NULL};
 246
 247     if (!PyArg_ParseTupleAndKeywords(args, keywds, "|zii:export",
 248         kwlist, &passphrase, &iter, &maciter))
 249         return NULL;
 250
 251     if (self->key != Py_None) {
 252         pkey = ((crypto_PKeyObj*) self->key)->pkey;
 253     }
 254     if (self->cert != Py_None) {
 255         x509 = ((crypto_X509Obj*) self->cert)->x509;
 256     }
 257     if (self->cacerts != Py_None) {
 258         cacerts = sk_X509_new_null();
 259         for (i = 0; i < PyTuple_Size(self->cacerts); i++) {  /* For each CA cert */
 260             obj = PySequence_GetItem(self->cacerts, i);
 261             /* assert(PyObject_IsInstance(obj, (PyObject *) &crypto_X509_Type )); */
 262             sk_X509_push(cacerts, (( crypto_X509Obj* ) obj)->x509);
 263             Py_DECREF(obj);
 264         }
 265     }
 266     if (self->friendlyname != Py_None) {
 267         friendly_name = PyBytes_AsString(self->friendlyname);
 268     }
 269
 270     p12 = PKCS12_create(passphrase, friendly_name, pkey, x509, cacerts,
 271                         NID_pbe_WithSHA1And3_Key_TripleDES_CBC,
 272                         NID_pbe_WithSHA1And3_Key_TripleDES_CBC,
 273                         iter, maciter, 0);
 274     sk_X509_free(cacerts); /* NULL safe.  Free just the container. */
 275     if (p12 == NULL) {
 276         exception_from_error_queue(crypto_Error);
 277         return NULL;
 278     }
 279     bio = BIO_new(BIO_s_mem());
 280     i2d_PKCS12_bio(bio, p12);
 281     buf_len = BIO_get_mem_data(bio, &temp);
 282     buffer = PyBytes_FromStringAndSize(temp, buf_len);
 283     BIO_free(bio);
 284     return buffer;
 285 }
 286
 287 /*
 288  * ADD_METHOD(name) expands to a correct PyMethodDef declaration
 289  *   {  'name', (PyCFunction)crypto_PKCS12_name, METH_VARARGS, crypto_PKCS12_name_doc }
 290  * for convenience
 291  */
 292 #define ADD_METHOD(name)        \
 293     { #name, (PyCFunction)crypto_PKCS12_##name, METH_VARARGS, crypto_PKCS12_##name##_doc }
 294 #define ADD_KW_METHOD(name)        \
 295     { #name, (PyCFunction)crypto_PKCS12_##name, METH_VARARGS | METH_KEYWORDS, crypto_PKCS12_##name##_doc }
 296 static PyMethodDef crypto_PKCS12_methods[] =
 297 {
 298     ADD_METHOD(get_certificate),
 299     ADD_KW_METHOD(set_certificate),
 300     ADD_METHOD(get_privatekey),
 301     ADD_KW_METHOD(set_privatekey),
 302     ADD_METHOD(get_ca_certificates),
 303     ADD_KW_METHOD(set_ca_certificates),
 304     ADD_METHOD(get_friendlyname),
 305     ADD_KW_METHOD(set_friendlyname),
 306     ADD_KW_METHOD(export),
 307     { NULL, NULL }
 308 };
 309 #undef ADD_METHOD
 310
 311 /*
 312  * Constructor for PKCS12 objects, never called by Python code directly.
 313  * The strategy for this object is to create all the Python objects
 314  * corresponding to the cert/key/CA certs right away
 315  *
 316  * Arguments: p12        - A "real" PKCS12 object or NULL
 317  *            passphrase - Passphrase to use when decrypting the PKCS12 object
 318  * Returns:   The newly created PKCS12 object
 319  */
 320 crypto_PKCS12Obj *
 321 crypto_PKCS12_New(PKCS12 *p12, char *passphrase) {
 322     crypto_PKCS12Obj *self = NULL;
 323     PyObject *cacertobj = NULL;
 324
 325     unsigned char *alias_str;
 326     int alias_len;
 327
 328     X509 *cert = NULL;
 329     EVP_PKEY *pkey = NULL;
 330     STACK_OF(X509) *cacerts = NULL;
 331
 332     int i, cacert_count = 0;
 333
 334     /* allocate space for the CA cert stack */
 335     if((cacerts = sk_X509_new_null()) == NULL) {
 336         goto error;   /* out of memory? */
 337     }
 338
 339     /* parse the PKCS12 lump */
 340     if (p12 && !PKCS12_parse(p12, passphrase, &pkey, &cert, &cacerts)) {
 341         /*
 342          * If PKCS12_parse fails, and it allocated cacerts, it seems to free
 343          * cacerts, but not re-NULL the pointer.  Zounds!  Make sure it is
 344          * re-set to NULL here, else we'll have a double-free below.
 345          */
 346         cacerts = NULL;
 347         exception_from_error_queue(crypto_Error);
 348         goto error;
 349     }
 350
 351     if (!(self = PyObject_GC_New(crypto_PKCS12Obj, &crypto_PKCS12_Type))) {
 352         goto error;
 353     }
 354
 355     /* client certificate and friendlyName */
 356     if (cert == NULL) {
 357         Py_INCREF(Py_None);
 358         self->cert = Py_None;
 359         Py_INCREF(Py_None);
 360         self->friendlyname = Py_None;
 361     } else {
 362         if ((self->cert = (PyObject *)crypto_X509_New(cert, 1)) == NULL) {
 363             goto error;
 364         }
 365
 366         /*  Now we need to extract the friendlyName of the PKCS12
 367          *  that was stored by PKCS_parse() in the alias of the
 368          *  certificate. */
 369         alias_str = X509_alias_get0(cert, &alias_len);
 370         if (alias_str) {
 371             self->friendlyname = Py_BuildValue(BYTESTRING_FMT "#", alias_str, alias_len);
 372             if (!self->friendlyname) {
 373                 /*
 374                  * XXX Untested
 375                  */
 376                 goto error;
 377             }
 378             /* success */
 379         } else {
 380             Py_INCREF(Py_None);
 381             self->friendlyname = Py_None;
 382         }
 383     }
 384
 385     /* private key */
 386     if (pkey == NULL) {
 387         Py_INCREF(Py_None);
 388         self->key = Py_None;
 389     } else {
 390         if ((self->key = (PyObject *)crypto_PKey_New(pkey, 1)) == NULL)
 391             goto error;
 392     }
 393
 394     /* CA certs */
 395     cacert_count = sk_X509_num(cacerts);
 396     if (cacert_count <= 0) {
 397         Py_INCREF(Py_None);
 398         self->cacerts = Py_None;
 399     } else {
 400         if ((self->cacerts = PyTuple_New(cacert_count)) == NULL) {
 401             goto error;
 402         }
 403
 404         for (i = 0; i < cacert_count; i++) {
 405             cert = sk_X509_value(cacerts, i);
 406             if ((cacertobj = (PyObject *)crypto_X509_New(cert, 1)) == NULL) {
 407                 goto error;
 408             }
 409             PyTuple_SET_ITEM(self->cacerts, i, cacertobj);
 410         }
 411     }
 412
 413     sk_X509_free(cacerts); /* Don't free the certs, just the container. */
 414     PyObject_GC_Track(self);
 415
 416     return self;
 417
 418 error:
 419     sk_X509_free(cacerts); /* NULL safe. Free just the container. */
 420     if (self) {
 421         crypto_PKCS12_clear(self);
 422         PyObject_GC_Del(self);
 423     }
 424     return NULL;
 425 }
 426
 427 static char crypto_PKCS12_doc[] = "\n\
 428 PKCS12() -> PKCS12 instance\n\
 429 \n\
 430 Create a new empty PKCS12 object.\n\
 431 \n\
 432 @returns: The PKCS12 object\n\
 433 ";
 434 static PyObject *
 435 crypto_PKCS12_new(PyTypeObject *subtype, PyObject *args, PyObject *kwargs) {
 436     if (!PyArg_ParseTuple(args, ":PKCS12")) {
 437         return NULL;
 438     }
 439
 440     return (PyObject *)crypto_PKCS12_New(NULL, NULL);
 441 }
 442
 443 /*
 444  * Call the visitproc on all contained objects.
 445  *
 446  * Arguments: self - The PKCS12 object
 447  *            visit - Function to call
 448  *            arg - Extra argument to visit
 449  * Returns:   0 if all goes well, otherwise the return code from the first
 450  *            call that gave non-zero result.
 451  */
 452 static int
 453 crypto_PKCS12_traverse(crypto_PKCS12Obj *self, visitproc visit, void *arg)
 454 {
 455     int ret = 0;
 456
 457     if (ret == 0 && self->cert != NULL)
 458         ret = visit(self->cert, arg);
 459     if (ret == 0 && self->key != NULL)
 460         ret = visit(self->key, arg);
 461     if (ret == 0 && self->cacerts != NULL)
 462         ret = visit(self->cacerts, arg);
 463     if (ret == 0 && self->friendlyname != NULL)
 464         ret = visit(self->friendlyname, arg);
 465     return ret;
 466 }
 467
 468 /*
 469  * Decref all contained objects and zero the pointers.
 470  *
 471  * Arguments: self - The PKCS12 object
 472  * Returns:   Always 0.
 473  */
 474 static int
 475 crypto_PKCS12_clear(crypto_PKCS12Obj *self)
 476 {
 477     Py_XDECREF(self->cert);
 478     self->cert = NULL;
 479     Py_XDECREF(self->key);
 480     self->key = NULL;
 481     Py_XDECREF(self->cacerts);
 482     self->cacerts = NULL;
 483     Py_XDECREF(self->friendlyname);
 484     self->friendlyname = NULL;
 485     return 0;
 486 }
 487
 488 /*
 489  * Deallocate the memory used by the PKCS12 object
 490  *
 491  * Arguments: self - The PKCS12 object
 492  * Returns:   None
 493  */
 494 static void
 495 crypto_PKCS12_dealloc(crypto_PKCS12Obj *self)
 496 {
 497     PyObject_GC_UnTrack(self);
 498     crypto_PKCS12_clear(self);
 499     PyObject_GC_Del(self);
 500 }
 501
 502 PyTypeObject crypto_PKCS12_Type = {
 503     PyOpenSSL_HEAD_INIT(&PyType_Type, 0)
 504     "PKCS12",
 505     sizeof(crypto_PKCS12Obj),
 506     0,
 507     (destructor)crypto_PKCS12_dealloc,
 508     NULL, /* print */
 509     NULL, /* getattr */
 510     NULL, /* setattr */
 511     NULL, /* compare */
 512     NULL, /* repr */
 513     NULL, /* as_number */
 514     NULL, /* as_sequence */
 515     NULL, /* as_mapping */
 516     NULL, /* hash */
 517     NULL, /* call */
 518     NULL, /* str */
 519     NULL, /* getattro */
 520     NULL, /* setattro */
 521     NULL, /* as_buffer */
 522     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
 523     crypto_PKCS12_doc,
 524     (traverseproc)crypto_PKCS12_traverse,
 525     (inquiry)crypto_PKCS12_clear,
 526     NULL, /* tp_richcompare */
 527     0, /* tp_weaklistoffset */
 528     NULL, /* tp_iter */
 529     NULL, /* tp_iternext */
 530     crypto_PKCS12_methods, /* tp_methods */
 531     NULL, /* tp_members */
 532     NULL, /* tp_getset */
 533     NULL, /* tp_base */
 534     NULL, /* tp_dict */
 535     NULL, /* tp_descr_get */
 536     NULL, /* tp_descr_set */
 537     0, /* tp_dictoffset */
 538     NULL, /* tp_init */
 539     NULL, /* tp_alloc */
 540     crypto_PKCS12_new, /* tp_new */
 541 };
 542
 543 /*
 544  * Initialize the PKCS12 part of the crypto sub module
 545  *
 546  * Arguments: module - The crypto module
 547  * Returns:   None
 548  */
 549 int
 550 init_crypto_pkcs12(PyObject *module) {
 551     if (PyType_Ready(&crypto_PKCS12_Type) < 0) {
 552         return 0;
 553     }
 554
 555     if (PyModule_AddObject(module, "PKCS12", (PyObject *)&crypto_PKCS12_Type) != 0) {
 556         return 0;
 557     }
 558
 559     if (PyModule_AddObject(module, "PKCS12Type", (PyObject *)&crypto_PKCS12_Type) != 0) {
 560         return 0;
 561     }
 562
 563     return 1;
 564 }