/*

* Copyright (c) 2006 Damien Miller <djm@mindrot.org>

*

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

* copyright notice and this permission notice appear in all copies.

*

* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

*/

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#define PYBCRYPT_VERSION "0.4"

#if defined(_WIN32)

typedef unsigned __int8 u_int8_t;

typedef unsigned __int16 u_int16_t;

typedef unsigned __int32 u_int32_t;

#define strdup _strdup /* strdup is not ANSI C. _strdup */

#endif

/* Import */

int pybc_bcrypt(const char *, const char *, char *, size_t);

void encode_salt(char *, u_int8_t *, u_int16_t, u_int8_t);

PyDoc_STRVAR(bcrypt_encode_salt_doc,

"encode_salt(csalt, log_rounds) -> encoded_salt\n\

Encode a raw binary salt and the specified log2(rounds) as a\n\

standard bcrypt text salt. Used internally by bcrypt.gensalt()\n");

static PyObject *

bcrypt_encode_salt(PyObject *self, PyObject *args, PyObject *kw_args)

{

static char *keywords[] = { "csalt", "log_rounds", NULL };

char *csalt = NULL;

Py_ssize_t csaltlen = -1;

long log_rounds = -1;

char ret[64];

if (!PyArg_ParseTupleAndKeywords(args, kw_args, "s#l:encode_salt",

keywords, &csalt, &csaltlen, &log_rounds))

return NULL;

if (csaltlen != 16) {

PyErr_SetString(PyExc_ValueError, "Invalid salt length");

return NULL;

}

if (log_rounds < 4 || log_rounds > 31) {

PyErr_SetString(PyExc_ValueError, "Invalid number of rounds");

return NULL;

}

encode_salt(ret, (u_int8_t *) csalt, csaltlen, log_rounds);

#if PY_MAJOR_VERSION >= 3

return PyUnicode_FromString(ret);

#else

return PyString_FromString(ret);

#endif

}

PyDoc_STRVAR(bcrypt_hashpw_doc,

"hashpw(password, salt) -> hashed_password\n\

Hash the specified password and the salt using the OpenBSD\n\

Blowfish password hashing algorithm. Returns the hashed password.\n");

static PyObject *

bcrypt_hashpw(PyObject *self, PyObject *args, PyObject *kw_args)

{

static char *keywords[] = { "password", "salt", NULL };

char *password = NULL, *salt = NULL;

char hashed[128];

int ret;

char *password_copy;

char *salt_copy;

if (!PyArg_ParseTupleAndKeywords(args, kw_args, "ss:hashpw", keywords,

&password, &salt))

return NULL;

password_copy = strdup(password);

salt_copy = strdup(salt);

Py_BEGIN_ALLOW_THREADS;

ret = pybc_bcrypt(password_copy, salt_copy, hashed, sizeof(hashed));

Py_END_ALLOW_THREADS;

memset(password_copy, 0, strlen(password_copy));

free(password_copy);

memset(salt_copy, 0, strlen(salt_copy));

free(salt_copy);

if (ret != 0 || strcmp(hashed, ":") == 0) {

PyErr_SetString(PyExc_ValueError, "Invalid salt");

return NULL;

}

#if PY_MAJOR_VERSION >= 3

return PyUnicode_FromString(hashed);

#else

return PyString_FromString(hashed);

#endif

}

static PyMethodDef bcrypt_methods[] = {

{ "hashpw", (PyCFunction)bcrypt_hashpw,

METH_VARARGS|METH_KEYWORDS, bcrypt_hashpw_doc },

{ "encode_salt", (PyCFunction)bcrypt_encode_salt,

METH_VARARGS|METH_KEYWORDS, bcrypt_encode_salt_doc },

{NULL, NULL} /* sentinel */

};

PyDoc_STRVAR(module_doc, "Internal module used by bcrypt.\n");

#if PY_MAJOR_VERSION >= 3

static struct PyModuleDef bcrypt_module = {

PyModuleDef_HEAD_INIT,

"bcrypt._bcrypt", /* m_name */

module_doc, /* m_doc */

-1, /* m_size */

bcrypt_methods, /* m_methods */

NULL, /* m_reload */

NULL, /* m_traverse */

NULL, /* m_clear */

NULL, /* m_free */

};

PyMODINIT_FUNC

PyInit__bcrypt(void)

{

PyObject *m;

m = PyModule_Create(&bcrypt_module);

PyModule_AddStringConstant(m, "__version__", PYBCRYPT_VERSION);

return m;

}

#else

PyMODINIT_FUNC

init_bcrypt(void)

{

PyObject *m;

m = Py_InitModule3("bcrypt._bcrypt", bcrypt_methods, module_doc);

PyModule_AddStringConstant(m, "__version__", PYBCRYPT_VERSION);

}

#endif