Modules/_hashopenssl.c

   1 /* Module that wraps all OpenSSL hash algorithms */
   2
   3 /*
   4  * Copyright (C) 2005   Gregory P. Smith (greg@krypto.org)
   5  * Licensed to PSF under a Contributor Agreement.
   6  *
   7  * Derived from a skeleton of shamodule.c containing work performed by:
   8  *
   9  * Andrew Kuchling (amk@amk.ca)
  10  * Greg Stein (gstein@lyra.org)
  11  *
  12  */
  13
  14 #define PY_SSIZE_T_CLEAN
  15
  16 #include "Python.h"
  17 #include "structmember.h"
  18
  19 /* EVP is the preferred interface to hashing in OpenSSL */
  20 #include <openssl/evp.h>
  21
  22
  23 #ifndef HASH_OBJ_CONSTRUCTOR
  24 #define HASH_OBJ_CONSTRUCTOR 0
  25 #endif
  26
  27 typedef struct {
  28     PyObject_HEAD
  29     PyObject            *name;  /* name of this hash algorithm */
  30     EVP_MD_CTX          ctx;    /* OpenSSL message digest context */
  31 } EVPobject;
  32
  33
  34 static PyTypeObject EVPtype;
  35
  36
  37 #define DEFINE_CONSTS_FOR_NEW(Name)  \
  38     static PyObject *CONST_ ## Name ## _name_obj; \
  39     static EVP_MD_CTX CONST_new_ ## Name ## _ctx; \
  40     static EVP_MD_CTX *CONST_new_ ## Name ## _ctx_p = NULL;
  41
  42 DEFINE_CONSTS_FOR_NEW(md5)
  43 DEFINE_CONSTS_FOR_NEW(sha1)
  44 DEFINE_CONSTS_FOR_NEW(sha224)
  45 DEFINE_CONSTS_FOR_NEW(sha256)
  46 DEFINE_CONSTS_FOR_NEW(sha384)
  47 DEFINE_CONSTS_FOR_NEW(sha512)
  48
  49
  50 static EVPobject *
  51 newEVPobject(PyObject *name)
  52 {
  53     EVPobject *retval = (EVPobject *)PyObject_New(EVPobject, &EVPtype);
  54
  55     /* save the name for .name to return */
  56     if (retval != NULL) {
  57         Py_INCREF(name);
  58         retval->name = name;
  59     }
  60
  61     return retval;
  62 }
  63
  64 /* Internal methods for a hash object */
  65
  66 static void
  67 EVP_dealloc(PyObject *ptr)
  68 {
  69     EVP_MD_CTX_cleanup(&((EVPobject *)ptr)->ctx);
  70     Py_XDECREF(((EVPobject *)ptr)->name);
  71     PyObject_Del(ptr);
  72 }
  73
  74
  75 /* External methods for a hash object */
  76
  77 PyDoc_STRVAR(EVP_copy__doc__, "Return a copy of the hash object.");
  78
  79 static PyObject *
  80 EVP_copy(EVPobject *self, PyObject *unused)
  81 {
  82     EVPobject *newobj;
  83
  84     if ( (newobj = newEVPobject(self->name))==NULL)
  85         return NULL;
  86
  87     EVP_MD_CTX_copy(&newobj->ctx, &self->ctx);
  88     return (PyObject *)newobj;
  89 }
  90
  91 PyDoc_STRVAR(EVP_digest__doc__,
  92 "Return the digest value as a string of binary data.");
  93
  94 static PyObject *
  95 EVP_digest(EVPobject *self, PyObject *unused)
  96 {
  97     unsigned char digest[EVP_MAX_MD_SIZE];
  98     EVP_MD_CTX temp_ctx;
  99     PyObject *retval;
 100     unsigned int digest_size;
 101
 102     EVP_MD_CTX_copy(&temp_ctx, &self->ctx);
 103     digest_size = EVP_MD_CTX_size(&temp_ctx);
 104     EVP_DigestFinal(&temp_ctx, digest, NULL);
 105
 106     retval = PyBytes_FromStringAndSize((const char *)digest, digest_size);
 107     EVP_MD_CTX_cleanup(&temp_ctx);
 108     return retval;
 109 }
 110
 111 PyDoc_STRVAR(EVP_hexdigest__doc__,
 112 "Return the digest value as a string of hexadecimal digits.");
 113
 114 static PyObject *
 115 EVP_hexdigest(EVPobject *self, PyObject *unused)
 116 {
 117     unsigned char digest[EVP_MAX_MD_SIZE];
 118     EVP_MD_CTX temp_ctx;
 119     PyObject *retval;
 120     char *hex_digest;
 121     unsigned int i, j, digest_size;
 122
 123     /* Get the raw (binary) digest value */
 124     EVP_MD_CTX_copy(&temp_ctx, &self->ctx);
 125     digest_size = EVP_MD_CTX_size(&temp_ctx);
 126     EVP_DigestFinal(&temp_ctx, digest, NULL);
 127
 128     EVP_MD_CTX_cleanup(&temp_ctx);
 129
 130     /* Create a new string */
 131     /* NOTE: not thread safe! modifying an already created string object */
 132     /* (not a problem because we hold the GIL by default) */
 133     retval = PyBytes_FromStringAndSize(NULL, digest_size * 2);
 134     if (!retval)
 135             return NULL;
 136     hex_digest = PyBytes_AsString(retval);
 137     if (!hex_digest) {
 138             Py_DECREF(retval);
 139             return NULL;
 140     }
 141
 142     /* Make hex version of the digest */
 143     for(i=j=0; i<digest_size; i++) {
 144         char c;
 145         c = (digest[i] >> 4) & 0xf;
 146         c = (c>9) ? c+'a'-10 : c + '0';
 147         hex_digest[j++] = c;
 148         c = (digest[i] & 0xf);
 149         c = (c>9) ? c+'a'-10 : c + '0';
 150         hex_digest[j++] = c;
 151     }
 152     return retval;
 153 }
 154
 155 PyDoc_STRVAR(EVP_update__doc__,
 156 "Update this hash object's state with the provided string.");
 157
 158 static PyObject *
 159 EVP_update(EVPobject *self, PyObject *args)
 160 {
 161     unsigned char *cp;
 162     Py_ssize_t len;
 163
 164     if (!PyArg_ParseTuple(args, "s#:update", &cp, &len))
 165         return NULL;
 166
 167     EVP_DigestUpdate(&self->ctx, cp, Py_SAFE_DOWNCAST(len, Py_ssize_t,
 168                                                       unsigned int));
 169
 170     Py_INCREF(Py_None);
 171     return Py_None;
 172 }
 173
 174 static PyMethodDef EVP_methods[] = {
 175     {"update",    (PyCFunction)EVP_update,    METH_VARARGS, EVP_update__doc__},
 176     {"digest",    (PyCFunction)EVP_digest,    METH_NOARGS,  EVP_digest__doc__},
 177     {"hexdigest", (PyCFunction)EVP_hexdigest, METH_NOARGS,  EVP_hexdigest__doc__},
 178     {"copy",      (PyCFunction)EVP_copy,      METH_NOARGS,  EVP_copy__doc__},
 179     {NULL,        NULL}         /* sentinel */
 180 };
 181
 182 static PyObject *
 183 EVP_get_block_size(EVPobject *self, void *closure)
 184 {
 185     return PyInt_FromLong(EVP_MD_CTX_block_size(&((EVPobject *)self)->ctx));
 186 }
 187
 188 static PyObject *
 189 EVP_get_digest_size(EVPobject *self, void *closure)
 190 {
 191     return PyInt_FromLong(EVP_MD_CTX_size(&((EVPobject *)self)->ctx));
 192 }
 193
 194 static PyMemberDef EVP_members[] = {
 195     {"name", T_OBJECT, offsetof(EVPobject, name), READONLY, PyDoc_STR("algorithm name.")},
 196     {NULL}  /* Sentinel */
 197 };
 198
 199 static PyGetSetDef EVP_getseters[] = {
 200     {"digest_size",
 201      (getter)EVP_get_digest_size, NULL,
 202      NULL,
 203      NULL},
 204     {"block_size",
 205      (getter)EVP_get_block_size, NULL,
 206      NULL,
 207      NULL},
 208     /* the old md5 and sha modules support 'digest_size' as in PEP 247.
 209      * the old sha module also supported 'digestsize'.  ugh. */
 210     {"digestsize",
 211      (getter)EVP_get_digest_size, NULL,
 212      NULL,
 213      NULL},
 214     {NULL}  /* Sentinel */
 215 };
 216
 217
 218 static PyObject *
 219 EVP_repr(PyObject *self)
 220 {
 221     char buf[100];
 222     PyOS_snprintf(buf, sizeof(buf), "<%s HASH object @ %p>",
 223             PyBytes_AsString(((EVPobject *)self)->name), self);
 224     return PyBytes_FromString(buf);
 225 }
 226
 227 #if HASH_OBJ_CONSTRUCTOR
 228 static int
 229 EVP_tp_init(EVPobject *self, PyObject *args, PyObject *kwds)
 230 {
 231     static char *kwlist[] = {"name", "string", NULL};
 232     PyObject *name_obj = NULL;
 233     char *nameStr;
 234     unsigned char *cp = NULL;
 235     Py_ssize_t len = 0;
 236     const EVP_MD *digest;
 237
 238     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|s#:HASH", kwlist,
 239                                      &name_obj, &cp, &len)) {
 240         return -1;
 241     }
 242
 243     if (!PyArg_Parse(name_obj, "s", &nameStr)) {
 244         PyErr_SetString(PyExc_TypeError, "name must be a string");
 245         return -1;
 246     }
 247
 248     digest = EVP_get_digestbyname(nameStr);
 249     if (!digest) {
 250         PyErr_SetString(PyExc_ValueError, "unknown hash function");
 251         return -1;
 252     }
 253     EVP_DigestInit(&self->ctx, digest);
 254
 255     self->name = name_obj;
 256     Py_INCREF(self->name);
 257
 258     if (cp && len)
 259         EVP_DigestUpdate(&self->ctx, cp, Py_SAFE_DOWNCAST(len, Py_ssize_t,
 260                                                           unsigned int));
 261
 262     return 0;
 263 }
 264 #endif
 265
 266
 267 PyDoc_STRVAR(hashtype_doc,
 268 "A hash represents the object used to calculate a checksum of a\n\
 269 string of information.\n\
 270 \n\
 271 Methods:\n\
 272 \n\
 273 update() -- updates the current digest with an additional string\n\
 274 digest() -- return the current digest value\n\
 275 hexdigest() -- return the current digest as a string of hexadecimal digits\n\
 276 copy() -- return a copy of the current hash object\n\
 277 \n\
 278 Attributes:\n\
 279 \n\
 280 name -- the hash algorithm being used by this object\n\
 281 digest_size -- number of bytes in this hashes output\n");
 282
 283 static PyTypeObject EVPtype = {
 284     PyVarObject_HEAD_INIT(NULL, 0)
 285     "_hashlib.HASH",    /*tp_name*/
 286     sizeof(EVPobject),  /*tp_basicsize*/
 287     0,                  /*tp_itemsize*/
 288     /* methods */
 289     EVP_dealloc,        /*tp_dealloc*/
 290     0,                  /*tp_print*/
 291     0,                  /*tp_getattr*/
 292     0,                  /*tp_setattr*/
 293     0,                  /*tp_compare*/
 294     EVP_repr,           /*tp_repr*/
 295     0,                  /*tp_as_number*/
 296     0,                  /*tp_as_sequence*/
 297     0,                  /*tp_as_mapping*/
 298     0,                  /*tp_hash*/
 299     0,                  /*tp_call*/
 300     0,                  /*tp_str*/
 301     0,                  /*tp_getattro*/
 302     0,                  /*tp_setattro*/
 303     0,                  /*tp_as_buffer*/
 304     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 305     hashtype_doc,       /*tp_doc*/
 306     0,                  /*tp_traverse*/
 307     0,                  /*tp_clear*/
 308     0,                  /*tp_richcompare*/
 309     0,                  /*tp_weaklistoffset*/
 310     0,                  /*tp_iter*/
 311     0,                  /*tp_iternext*/
 312     EVP_methods,        /* tp_methods */
 313     EVP_members,        /* tp_members */
 314     EVP_getseters,      /* tp_getset */
 315 #if 1
 316     0,                  /* tp_base */
 317     0,                  /* tp_dict */
 318     0,                  /* tp_descr_get */
 319     0,                  /* tp_descr_set */
 320     0,                  /* tp_dictoffset */
 321 #endif
 322 #if HASH_OBJ_CONSTRUCTOR
 323     (initproc)EVP_tp_init, /* tp_init */
 324 #endif
 325 };
 326
 327 static PyObject *
 328 EVPnew(PyObject *name_obj,
 329        const EVP_MD *digest, const EVP_MD_CTX *initial_ctx,
 330        const unsigned char *cp, unsigned int len)
 331 {
 332     EVPobject *self;
 333
 334     if (!digest && !initial_ctx) {
 335         PyErr_SetString(PyExc_ValueError, "unsupported hash type");
 336         return NULL;
 337     }
 338
 339     if ((self = newEVPobject(name_obj)) == NULL)
 340         return NULL;
 341
 342     if (initial_ctx) {
 343         EVP_MD_CTX_copy(&self->ctx, initial_ctx);
 344     } else {
 345         EVP_DigestInit(&self->ctx, digest);
 346     }
 347
 348     if (cp && len)
 349         EVP_DigestUpdate(&self->ctx, cp, len);
 350
 351     return (PyObject *)self;
 352 }
 353
 354
 355 /* The module-level function: new() */
 356
 357 PyDoc_STRVAR(EVP_new__doc__,
 358 "Return a new hash object using the named algorithm.\n\
 359 An optional string argument may be provided and will be\n\
 360 automatically hashed.\n\
 361 \n\
 362 The MD5 and SHA1 algorithms are always supported.\n");
 363
 364 static PyObject *
 365 EVP_new(PyObject *self, PyObject *args, PyObject *kwdict)
 366 {
 367     static char *kwlist[] = {"name", "string", NULL};
 368     PyObject *name_obj = NULL;
 369     char *name;
 370     const EVP_MD *digest;
 371     unsigned char *cp = NULL;
 372     Py_ssize_t len = 0;
 373
 374     if (!PyArg_ParseTupleAndKeywords(args, kwdict, "O|s#:new", kwlist,
 375                                      &name_obj, &cp, &len)) {
 376         return NULL;
 377     }
 378
 379     if (!PyArg_Parse(name_obj, "s", &name)) {
 380         PyErr_SetString(PyExc_TypeError, "name must be a string");
 381         return NULL;
 382     }
 383
 384     digest = EVP_get_digestbyname(name);
 385
 386     return EVPnew(name_obj, digest, NULL, cp, Py_SAFE_DOWNCAST(len, Py_ssize_t,
 387                                                                unsigned int));
 388 }
 389
 390 /*
 391  *  This macro generates constructor function definitions for specific
 392  *  hash algorithms.  These constructors are much faster than calling
 393  *  the generic one passing it a python string and are noticably
 394  *  faster than calling a python new() wrapper.  Thats important for
 395  *  code that wants to make hashes of a bunch of small strings.
 396  */
 397 #define GEN_CONSTRUCTOR(NAME)  \
 398     static PyObject * \
 399     EVP_new_ ## NAME (PyObject *self, PyObject *args) \
 400     { \
 401         unsigned char *cp = NULL; \
 402         Py_ssize_t len = 0; \
 403      \
 404         if (!PyArg_ParseTuple(args, "|s#:" #NAME , &cp, &len)) { \
 405             return NULL; \
 406         } \
 407      \
 408         return EVPnew( \
 409                 CONST_ ## NAME ## _name_obj, \
 410                 NULL, \
 411                 CONST_new_ ## NAME ## _ctx_p, \
 412                 cp, Py_SAFE_DOWNCAST(len, Py_ssize_t, unsigned int)); \
 413     }
 414
 415 /* a PyMethodDef structure for the constructor */
 416 #define CONSTRUCTOR_METH_DEF(NAME)  \
 417     {"openssl_" #NAME, (PyCFunction)EVP_new_ ## NAME, METH_VARARGS, \
 418         PyDoc_STR("Returns a " #NAME \
 419                   " hash object; optionally initialized with a string") \
 420     }
 421
 422 /* used in the init function to setup a constructor */
 423 #define INIT_CONSTRUCTOR_CONSTANTS(NAME)  do { \
 424     CONST_ ## NAME ## _name_obj = PyBytes_FromString(#NAME); \
 425     if (EVP_get_digestbyname(#NAME)) { \
 426         CONST_new_ ## NAME ## _ctx_p = &CONST_new_ ## NAME ## _ctx; \
 427         EVP_DigestInit(CONST_new_ ## NAME ## _ctx_p, EVP_get_digestbyname(#NAME)); \
 428     } \
 429 } while (0);
 430
 431 GEN_CONSTRUCTOR(md5)
 432 GEN_CONSTRUCTOR(sha1)
 433 GEN_CONSTRUCTOR(sha224)
 434 GEN_CONSTRUCTOR(sha256)
 435 GEN_CONSTRUCTOR(sha384)
 436 GEN_CONSTRUCTOR(sha512)
 437
 438 /* List of functions exported by this module */
 439
 440 static struct PyMethodDef EVP_functions[] = {
 441     {"new", (PyCFunction)EVP_new, METH_VARARGS|METH_KEYWORDS, EVP_new__doc__},
 442     CONSTRUCTOR_METH_DEF(md5),
 443     CONSTRUCTOR_METH_DEF(sha1),
 444     CONSTRUCTOR_METH_DEF(sha224),
 445     CONSTRUCTOR_METH_DEF(sha256),
 446     CONSTRUCTOR_METH_DEF(sha384),
 447     CONSTRUCTOR_METH_DEF(sha512),
 448     {NULL,      NULL}            /* Sentinel */
 449 };
 450
 451
 452 /* Initialize this module. */
 453
 454 PyMODINIT_FUNC
 455 init_hashlib(void)
 456 {
 457     PyObject *m;
 458
 459     OpenSSL_add_all_digests();
 460
 461     /* TODO build EVP_functions openssl_* entries dynamically based
 462      * on what hashes are supported rather than listing many
 463      * but having some be unsupported.  Only init appropriate
 464      * constants. */
 465
 466     Py_TYPE(&EVPtype) = &PyType_Type;
 467     if (PyType_Ready(&EVPtype) < 0)
 468         return;
 469
 470     m = Py_InitModule("_hashlib", EVP_functions);
 471     if (m == NULL)
 472         return;
 473
 474 #if HASH_OBJ_CONSTRUCTOR
 475     Py_INCREF(&EVPtype);
 476     PyModule_AddObject(m, "HASH", (PyObject *)&EVPtype);
 477 #endif
 478
 479     /* these constants are used by the convenience constructors */
 480     INIT_CONSTRUCTOR_CONSTANTS(md5);
 481     INIT_CONSTRUCTOR_CONSTANTS(sha1);
 482     INIT_CONSTRUCTOR_CONSTANTS(sha224);
 483     INIT_CONSTRUCTOR_CONSTANTS(sha256);
 484     INIT_CONSTRUCTOR_CONSTANTS(sha384);
 485     INIT_CONSTRUCTOR_CONSTANTS(sha512);
 486 }