_fastmath.c

python的加密库

			       &PyLong_Type, &lk))
	{
		return NULL;
	}
	mpz_init (m);
	mpz_init (k);
	mpz_init (r);
	mpz_init (s);
	longObjToMPZ (m, (PyLongObject *) lm);
	longObjToMPZ (k, (PyLongObject *) lk);
	result = dsaSign (key, m, k, r, s);
	if (result == 1)
	{
		PyErr_SetString (fastmathError, "K not between 2 and q");
		return NULL;
	}
	lr = mpzToLongObj (r);
	ls = mpzToLongObj (s);
	mpz_clear (m);
	mpz_clear (k);
	mpz_clear (r);
	mpz_clear (s);
	return Py_BuildValue ("(NN)", lr, ls);
}

PyObject *
dsaKey__verify (dsaKey * key, PyObject * args)
{
	PyObject *lm, *lr, *ls;
	mpz_t m, r, s;
	int result;
	if (!PyArg_ParseTuple (args, "O!O!O!", &PyLong_Type, &lm,
			       &PyLong_Type, &lr, &PyLong_Type, &ls))
	{
		return NULL;
	}
	mpz_init (m);
	mpz_init (r);
	mpz_init (s);
	longObjToMPZ (m, (PyLongObject *) lm);
	longObjToMPZ (r, (PyLongObject *) lr);
	longObjToMPZ (s, (PyLongObject *) ls);
	result = dsaVerify (key, m, r, s);
	mpz_clear (m);
	mpz_clear (r);
	mpz_clear (s);
	if (result) {
		Py_INCREF(Py_True);
		return Py_True;
        } else {
		Py_INCREF(Py_False);
		return Py_False;
	}
}

PyObject *
dsaKey_size (dsaKey * key, PyObject * args)
{
	if (!PyArg_ParseTuple (args, ""))
		return NULL;
	return Py_BuildValue ("i", mpz_sizeinbase (key->p, 2) - 1);
}

PyObject *
dsaKey_has_private (dsaKey * key, PyObject * args)
{
	if (!PyArg_ParseTuple (args, ""))
		return NULL;
	if (mpz_size (key->x) == 0) {
		Py_INCREF(Py_False);
		return Py_False;
        } else {
		Py_INCREF(Py_True);
		return Py_True;
        }
}

PyObject *
rsaKey_new (PyObject * self, PyObject * args)
{
	PyLongObject *n = NULL, *e = NULL, *d = NULL, *p = NULL, *q = NULL, 
                     *u = NULL;
	rsaKey *key;

	if (!PyArg_ParseTuple(args, "O!O!|O!O!O!O!", &PyLong_Type, &n,
			      &PyLong_Type, &e, &PyLong_Type, &d, 
			      &PyLong_Type, &p, &PyLong_Type, &q,
                              &PyLong_Type, &u))
		return NULL;

	key = PyObject_New (rsaKey, &rsaKeyType);
	mpz_init (key->n);
	mpz_init (key->e);
	mpz_init (key->d);
	mpz_init (key->p);
	mpz_init (key->q);
	mpz_init (key->u);
	longObjToMPZ (key->n, n);
	longObjToMPZ (key->e, e);
	if (!d)
	{
		return (PyObject *) key;
	}
	longObjToMPZ (key->d, d);
	if (p && q)
	{
		longObjToMPZ (key->p, p);
		longObjToMPZ (key->q, q);
		if (u) {
			longObjToMPZ (key->u, u);
		} else {
			mpz_invert (key->u, key->p, key->q);
		}
	}
	return (PyObject *) key;
}

static void
rsaKey_dealloc (rsaKey * key)
{
	mpz_clear (key->n);
	mpz_clear (key->e);
	mpz_clear (key->d);
	mpz_clear (key->p);
	mpz_clear (key->q);
	mpz_clear (key->u);
	PyObject_Del (key);
}

static PyObject *
rsaKey_getattr (rsaKey * key, char *attr)
{
	if (strcmp (attr, "n") == 0)
		return mpzToLongObj (key->n);
	else if (strcmp (attr, "e") == 0)
		return mpzToLongObj (key->e);
	else if (strcmp (attr, "d") == 0)
	{
		if (mpz_size (key->d) == 0)
		{
			PyErr_SetString(PyExc_AttributeError,
					"rsaKey instance has no attribute 'd'");
			return NULL;
		}
		return mpzToLongObj (key->d);
	}
	else if (strcmp (attr, "p") == 0)
	{
		if (mpz_size (key->p) == 0)
		{
			PyErr_SetString(PyExc_AttributeError,
					"rsaKey instance has no attribute 'p'");
			return NULL;
		}
		return mpzToLongObj (key->p);
	}
	else if (strcmp (attr, "q") == 0)
	{
		if (mpz_size (key->q) == 0)
		{
			PyErr_SetString(PyExc_AttributeError,
					"rsaKey instance has no attribute 'q'");
			return NULL;
		}
		return mpzToLongObj (key->q);
	}
	else if (strcmp (attr, "u") == 0)
	{
		if (mpz_size (key->u) == 0)
		{
			PyErr_SetString(PyExc_AttributeError,
					"rsaKey instance has no attribute 'u'");
			return NULL;
		}
		return mpzToLongObj (key->u);
	}
	else
	{
		return Py_FindMethod (rsaKey__methods__, 
				      (PyObject *) key, attr);
	}
}

PyObject *
rsaKey__encrypt (rsaKey * key, PyObject * args)
{
	PyObject *l, *r;
	mpz_t v;
	int result;
	if (!PyArg_ParseTuple (args, "O!", &PyLong_Type, &l))
	{
		return NULL;
	}
	mpz_init (v);
	longObjToMPZ (v, (PyLongObject *) l);
	result = rsaEncrypt (key, v);
	if (result == 1)
	{
		PyErr_SetString (fastmathError, "Plaintext too large");
		return NULL;
	}
	r = (PyObject *) mpzToLongObj (v);
	mpz_clear (v);
	return Py_BuildValue ("N", r);
}

PyObject *
rsaKey__decrypt (rsaKey * key, PyObject * args)
{
	PyObject *l, *r;
	mpz_t v;
	int result;
	if (!PyArg_ParseTuple (args, "O!", &PyLong_Type, &l))
	{
		return NULL;
	}
	mpz_init (v);
	longObjToMPZ (v, (PyLongObject *) l);
	result = rsaDecrypt (key, v);
	if (result == 1)
	{
		PyErr_SetString (fastmathError, 
				 "Ciphertext too large");
		return NULL;
	}
	else if (result == 2)
	{
		PyErr_SetString (fastmathError, 
				 "Private key not available in this object");
		return NULL;
	}
	r = mpzToLongObj (v);
	mpz_clear (v);
	return Py_BuildValue ("N", r);
}

PyObject *
rsaKey__verify (rsaKey * key, PyObject * args)
{
	PyObject *l, *lsig;
	mpz_t v, vsig;
	if (!PyArg_ParseTuple(args, "O!O!", 
			      &PyLong_Type, &l, &PyLong_Type, &lsig))
	{
		return NULL;
	}
	mpz_init (v);
	mpz_init (vsig);
	longObjToMPZ (v, (PyLongObject *) l);
	longObjToMPZ (vsig, (PyLongObject *) lsig);
	rsaEncrypt (key, vsig);
	if (mpz_cmp (v, vsig) == 0) {
		Py_INCREF(Py_True);
		return Py_True;
	}
	else {
		Py_INCREF(Py_False);
		return Py_False;
        }
}

PyObject *
rsaKey__blind (rsaKey * key, PyObject * args)
{
	PyObject *l, *lblind, *r;
	mpz_t v, vblind;
	int result;
	if (!PyArg_ParseTuple (args, "O!O!", &PyLong_Type, &l, 
                               &PyLong_Type, &lblind))
		{
			return NULL;
		}
	mpz_init (v);
	mpz_init (vblind);
	longObjToMPZ (v, (PyLongObject *) l);
	longObjToMPZ (vblind, (PyLongObject *) lblind);
	result = rsaBlind (key, v, vblind);
	if (result == 1)
		{
			PyErr_SetString (fastmathError, "Message too large");
			return NULL;
		}
	else if (result == 2)
		{
			PyErr_SetString (fastmathError, "Blinding factor too large");
			return NULL;
		}
	r = (PyObject *) mpzToLongObj (v);
	mpz_clear (v);
	mpz_clear (vblind);
	return Py_BuildValue ("N", r);
}

PyObject *
rsaKey__unblind (rsaKey * key, PyObject * args)
{
	PyObject *l, *lblind, *r;
	mpz_t v, vblind;
	int result;
	if (!PyArg_ParseTuple (args, "O!O!", &PyLong_Type, &l, 
                               &PyLong_Type, &lblind))
		{
			return NULL;
		}
	mpz_init (v);
	mpz_init (vblind);
	longObjToMPZ (v, (PyLongObject *) l);
	longObjToMPZ (vblind, (PyLongObject *) lblind);
	result = rsaUnBlind (key, v, vblind);
	if (result == 1)
		{
			PyErr_SetString (fastmathError, "Message too large");
			return NULL;
		}
	else if (result == 2)
		{
			PyErr_SetString (fastmathError, "Blinding factor too large");
			return NULL;
		}
	else if (result == 3)
		{
			PyErr_SetString (fastmathError, "Inverse doesn't exist");
			return NULL;
		}
	r = (PyObject *) mpzToLongObj (v);
	mpz_clear (v);
	mpz_clear (vblind);
	return Py_BuildValue ("N", r);
}
  
PyObject *
rsaKey_size (rsaKey * key, PyObject * args)
{
	if (!PyArg_ParseTuple (args, ""))
		return NULL;
	return Py_BuildValue ("i", mpz_sizeinbase (key->n, 2) - 1);
}

PyObject *
rsaKey_has_private (rsaKey * key, PyObject * args)
{
	if (!PyArg_ParseTuple (args, ""))
		return NULL;
	if (mpz_size (key->d) == 0) {
		Py_INCREF(Py_False);
		return Py_False;
        } else {
		Py_INCREF(Py_True);
		return Py_True;
	}
}


PyObject *
isPrime (PyObject * self, PyObject * args)
{
	PyObject *l;
	mpz_t n;
	int result;

	if (!PyArg_ParseTuple (args, "O!", &PyLong_Type, &l))
	{
		return NULL;
	}
	mpz_init (n);
	longObjToMPZ (n, (PyLongObject *) l);

	result = mpz_probab_prime_p(n, 5);

	mpz_clear (n);

	if (result == 0) {
		Py_INCREF(Py_False);
		return Py_False;
        } else {
		Py_INCREF(Py_True);
		return Py_True;
	}
}


static PyMethodDef _fastmath__methods__[] = {
	{"dsa_construct", dsaKey_new, METH_VARARGS},
	{"rsa_construct", rsaKey_new, METH_VARARGS},
        {"isPrime", isPrime, METH_VARARGS},
	{NULL, NULL}
};

void
init_fastmath (void)
{
        PyObject *_fastmath_module;
        PyObject *_fastmath_dict;

	rsaKeyType.ob_type = &PyType_Type;
	dsaKeyType.ob_type = &PyType_Type;
	_fastmath_module = Py_InitModule ("_fastmath", _fastmath__methods__);
	_fastmath_dict = PyModule_GetDict (_fastmath_module);
	fastmathError = PyErr_NewException ("_fastmath.error", NULL, NULL);
	PyDict_SetItemString (_fastmath_dict, "error", fastmathError);
}