~myers-1/pyopenssl/npn

« back to all changes in this revision

Viewing changes to src/crypto/pkcs12.c

  • Committer: Jean-Paul Calderone
  • Date: 2010-01-25 22:55:30 UTC
  • mfrom: (126 trunk)
  • mto: This revision was merged to the branch mainline in revision 129.
  • Revision ID: exarkun@divmod.com-20100125225530-5e9nsb6bzoesoz42
merge trunk and resolve simple conflict

Show diffs side-by-side

added added

removed removed

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