Merge lp:~morgan-s-reed/pyopenssl/mr-RSAadditions into lp:~exarkun/pyopenssl/trunk

[Morgan]

[Morgan (morgan-s-reed)]

This branch is now ready for merging, all changes from trunk have been back-merged in, all tests succeed.

[Jean-Paul Calderone (exarkun)]

The first thing that strikes me about this change is the apparent redundancy that it introduces into the key APIs exposed by pyOpenSSL. It seems like adding sign, verify, encrypt, and decrypt methods to the `PKey` type would be the right way to expose this functionality. As I understand it, the EVP_Sign*, EVP_Verify*, EVP_Encrypt*, and EVP_Decrypt* functions will do this with the existing data structure wrapped by the `PKey` type.

review: Needs Fixing

[Morgan (morgan-s-reed)]

On Mon, Nov 23, 2009 at 03:04, Jean-Paul Calderone
<email address hidden> wrote:
> Review: Needs Fixing
> The first thing that strikes me about this change is the apparent redundancy that it introduces into the key APIs exposed by pyOpenSSL.  It seems like adding sign, verify, encrypt, and decrypt methods to the `PKey` type would be the right way to expose this functionality.  As I understand it, the EVP_Sign*, EVP_Verify*, EVP_Encrypt*, and EVP_Decrypt* functions will do this with the existing data structure wrapped by the `PKey` type.

Reviewing the documentation for the EVP module, you are correct that
the RSA_sign and RSA_verify methods are redundant. However it is not
(from what I can tell) possible to do direct RSA encryption/decryption
with the EVP module (this is what I implemented the RSA bindings for,
I was working with a licensing scheme that used a license key
encrypted directly by RSA), the API only allows you to "envelope"
symmetrically encrypted data in an EVP context (generate symmetric
keys/IVs encrypt "enveloped" data with those, encrypt those with
RSA/DSA). EVP_Decrypt* and EVP_Encrypt* methods are (as far as I can
tell) only for symmetric encryption.

That said the person who requested the RSA/AES stuff on the list
probably needs the EVP methods rather than the direct low-level
methods.

I will have a look into implementing the relevant EVP methods on PKey
but I'm not sure if I will have time to complete the implementation.

[Morgan (morgan-s-reed)]

On Mon, Nov 23, 2009 at 08:45, Morgan Reed <email address hidden> wrote:
> I will have a look into implementing the relevant EVP methods on PKey
> but I'm not sure if I will have time to complete the implementation.

Apologies for the double message, Gmail was having kittens for some
unknown reason.

Have we heard anything from Edward Tait recently? I note he was
working on a "branch with-EVP_sign+verify", though I've no idea what
the status of it is.

[Morgan (morgan-s-reed)]

On Mon, Nov 23, 2009 at 08:50, Morgan Reed <email address hidden> wrote:
> Apologies for the double message, Gmail was having kittens for some
> unknown reason.

Ahh, I see now, scratch that, launchpad is sending me copies of my responses...

Unmerged revisions

91. By intrinsic <intrinsic@athena> on 2009-11-21

Fixed RSA test case

90. By intrinsic <intrinsic@athena> on 2009-11-21

Cleaned the garbage out of crypto.c

89. By intrinsic <intrinsic@athena> on 2009-11-21

Fixed breakage from the merging trunk

88. By intrinsic <intrinsic@athena> on 2009-11-21

Trunk Merge Completed

87. By intrinsic <intrinsic@athena> on 2009-11-21

Incremental merge commit 5

86. By intrinsic <intrinsic@athena> on 2009-11-21

Incremental merge commit 4

85. By intrinsic <intrinsic@athena> on 2009-11-21

Incremental merge commit 3

84. By intrinsic <intrinsic@athena> on 2009-11-21

Incremental merge commit 2

83. By intrinsic <intrinsic@athena> on 2009-11-21

Incremental merge commit 1

82. By intrinsic <intrinsic@athena> on 2009-11-16

Committing local changes prior to back-merging trunk

=== modified file 'PKG-INFO'
--- PKG-INFO	2008-02-19 01:50:23 +0000
+++ PKG-INFO	2009-11-21 12:40:29 +0000
@@ -1,10 +1,10 @@
 Metadata-Version: 1.0
 Name: pyOpenSSL
-Version: 0.6
+Version: 0.8a1
 Summary: Python wrapper module around the OpenSSL library
 Home-page: http://pyopenssl.sourceforge.net/
-Author: Martin Sjögren, AB Strakt
-Author-email: [e-mail]
+Author: Jean-Paul Calderone
+Author-email: [e-mail]
 License: LGPL
 Description: High-level wrapper around a subset of the OpenSSL library, includes
         * SSL.Connection objects, wrapping the methods of Python's portable

=== modified file 'doc/pyOpenSSL.tex'
--- doc/pyOpenSSL.tex	2009-11-13 14:16:32 +0000
+++ doc/pyOpenSSL.tex	2009-11-21 12:40:29 +0000
@@ -207,6 +207,14 @@
 method.
 \end{classdesc}
 
+\begin{datadesc}{RSAType}
+A Python type object representing the RSA object type.
+\end{datadesc}
+
+\begin{funcdesc}{RSA}{}
+Factory function that creates a RSA object. 
+\end{funcdesc}
+
 \begin{datadesc}{FILETYPE_PEM}
 \dataline{FILETYPE_ASN1}
 File type constants.
@@ -612,10 +620,61 @@
 Verify the NetscapeSPKI object using the given \var{key}.
 \end{methoddesc}
 
+\subsubsection{RSA objects \label{openssl-rsa}}
+
+RSA objects have the following methods:
+
+\begin{methoddesc}[RSA]{generate_key}{bits}
+Generate a new RSA keypair of the given size (\var{bits}) and store within the 
+object.
+\end{methoddesc}
+
+\begin{methoddesc}[RSA]{key_bits}{}
+Returns the RSA_size of the contained keys
+\end{methoddesc}
+
+\begin{methoddesc}[RSA]{public_encrypt}{message\optional{, padding}}
+Returns the given \var{message} encrypted with the public key stored in the 
+object with the given \var{padding}, (defaults to RSA_PKCS1_PADDING, other valid 
+options are; RSA_PKCS1_OAEP_PADDING, RSA_SSLV23_PADDING and RSA_NO_PADDING), 
+throws an error if the input data is larger than the key stored in the object.
+\end{methoddesc}
+
+\begin{methoddesc}[RSA]{private_encrypt}{message\optional{, padding}}
+Returns the given \var{message} encrypted with the private key stored in the 
+object with the given \var{padding}, (defaults to RSA_PKCS1_PADDING, the only
+other valid option at this time is RSA_NO_PADDING (these are the only supported
+paddings in OpenSSL 0.9.8g)), throws an error if the input data is larger than 
+the key stored in the object.
+\end{methoddesc}
+
+\begin{methoddesc}[RSA]{public_decrypt}{message\optional{, padding}}
+Returns the plaintext decrypted from the given \var{message} using the public 
+key stored in the object, throws an error if the type of the padding does not 
+match the padding used to encrypt the message.
+\end{methoddesc}
+
+\begin{methoddesc}[RSA]{private_decrypt}{message\optional{, padding}}
+Returns the plaintext decrypted from the given \var{message} using the private 
+key stored in the object.
+\end{methoddesc}
+
+\begin{methoddesc}[RSA]{sign}{algorithm, digest}
+Signs the message whose digest as generated by \var{algorithm} (valid options
+are NID_sha1, NID_ripemd160, NID_md5 and NID_md5_sha1) is \var{digest} with the
+contained private key.
+\end{methoddesc}
+
+\begin{methoddesc}[RSA]{verify}{algorithm, digest, signature}
+Verifies the \var{signature} for the message whose digest as generated by 
+\var{algorithm} (valid options are NID_sha1, NID_ripemd160, NID_md5 and 
+NID_md5_sha1) is \var{digest} using the contained public key.
+\end{methoddesc}
 
 % % % rand module
 
-\subsection{\module{rand} --- An interface to the OpenSSL pseudo random number generator \label{openssl-rand}}
+\subsection{\module{rand} --- An interface to the OpenSSL pseudo random number 
+generator \label{openssl-rand}}
 
 \declaremodule{extension}{rand}
 \modulesynopsis{An interface to the OpenSSL pseudo random number generator}
@@ -1191,8 +1250,6 @@
 operation.
 \end{methoddesc}
 
-
-
 \section{Internals \label{internals}}
 
 We ran into three main problems developing this: Exceptions, callbacks and

=== modified file 'setup.py'
--- setup.py	2009-11-11 15:51:56 +0000
+++ setup.py	2009-11-21 12:40:29 +0000
@@ -26,13 +26,13 @@
               'src/crypto/x509store.c', 'src/crypto/x509req.c',
               'src/crypto/x509ext.c', 'src/crypto/pkcs7.c',
               'src/crypto/pkcs12.c', 'src/crypto/netscape_spki.c',
-              'src/util.c']
+              'src/crypto/rsa.c', 'src/util.c']
 crypto_dep = ['src/crypto/crypto.h', 'src/crypto/x509.h',
               'src/crypto/x509name.h', 'src/crypto/pkey.h',
               'src/crypto/x509store.h', 'src/crypto/x509req.h',
               'src/crypto/x509ext.h', 'src/crypto/pkcs7.h',
               'src/crypto/pkcs12.h', 'src/crypto/netscape_spki.h',
-              'src/util.h']
+              'src/crypto/rsa.h', 'src/util.h']
 rand_src = ['src/rand/rand.c', 'src/util.c']
 rand_dep = ['src/util.h']
 ssl_src = ['src/ssl/connection.c', 'src/ssl/context.c', 'src/ssl/ssl.c',

=== modified file 'src/crypto/crypto.c'
--- src/crypto/crypto.c	2009-07-17 17:50:12 +0000
+++ src/crypto/crypto.c	2009-11-21 12:40:29 +0000
@@ -150,7 +150,7 @@
     crypto_PKeyObj *pkey;
 
     if (!PyArg_ParseTuple(args, "iO!|sO:dump_privatekey", &type,
-			  &crypto_PKey_Type, &pkey, &cipher_name, &pw))
+              &crypto_PKey_Type, &pkey, &cipher_name, &pw))
         return NULL;
 
     if (cipher_name != NULL && pw == NULL)
@@ -290,7 +290,7 @@
     crypto_X509Obj *cert;
 
     if (!PyArg_ParseTuple(args, "iO!:dump_certificate", &type,
-			  &crypto_X509_Type, &cert))
+              &crypto_X509_Type, &cert))
         return NULL;
 
     bio = BIO_new(BIO_s_mem());
@@ -393,7 +393,7 @@
     crypto_X509ReqObj *req;
 
     if (!PyArg_ParseTuple(args, "iO!:dump_certificate_request", &type,
-			  &crypto_X509Req_Type, &req))
+              &crypto_X509Req_Type, &req))
         return NULL;
 
     bio = BIO_new(BIO_s_mem());
@@ -514,6 +514,54 @@
     return (PyObject *)crypto_PKCS12_New(p12, passphrase);
 }
 
+static char crypto_load_rsa_doc[] = "\n\
+Load an RSA object from a buffer\n\
+\n\
+@param spam: Always NULL\n\
+           args - The Python argument tuple, should be empty.\n\
+@returns:   The RSA object\n\
+";
+
+static PyObject *
+crypto_load_rsa(PyObject *spam, PyObject *args)
+{
+    crypto_RSAObj *crypto_RSA_New(RSA *, int);
+    RSA *rsa;
+
+    if (!PyArg_ParseTuple(args, "s#|s:load_rsa"))
+        return NULL;
+
+    if ((rsa = RSA_new()) == NULL) {
+      exception_from_error_queue(crypto_Error);
+      return NULL;
+    }
+
+    return (PyObject *)crypto_RSA_New(rsa, 1);
+}
+
+static char crypto_rsa_doc[] = "\n\
+The factory function inserted in the module dictionary to create RSA\n\
+objects\n\
+\n\
+Arguments: spam - Always NULL\n\
+           args - The Python argument tuple, should be empty\n\
+Returns:   The RSA object\n\
+";
+
+static PyObject *
+crypto_rsa(PyObject *spam, PyObject *args)
+{
+    crypto_RSAObj *py_rsa;
+
+    if (!PyArg_ParseTuple(args, ":RSA"))
+        return NULL;
+
+    py_rsa = crypto_RSA_New(RSA_new(), 1);
+    if (py_rsa) {
+    py_rsa->initialized = 0;
+    }
+    return (PyObject *)py_rsa;
+}
 
 static char crypto_X509_verify_cert_error_string_doc[] = "\n\
 Get X509 verify certificate error string.\n\
@@ -557,6 +605,9 @@
     { "dump_certificate_request", (PyCFunction)crypto_dump_certificate_request, METH_VARARGS, crypto_dump_certificate_request_doc },
     { "load_pkcs7_data", (PyCFunction)crypto_load_pkcs7_data, METH_VARARGS, crypto_load_pkcs7_data_doc },
     { "load_pkcs12", (PyCFunction)crypto_load_pkcs12, METH_VARARGS, crypto_load_pkcs12_doc },
+    { "load_rsa",    (PyCFunction)crypto_load_rsa,    METH_VARARGS, crypto_load_rsa_doc },
+    /* Factory functions */
+    { "RSA",     (PyCFunction)crypto_rsa,     METH_VARARGS, crypto_rsa_doc },
     { "X509_verify_cert_error_string", (PyCFunction)crypto_X509_verify_cert_error_string, METH_VARARGS, crypto_X509_verify_cert_error_string_doc },
     { "_exception_from_error_queue", (PyCFunction)crypto_exception_from_error_queue, METH_NOARGS, crypto_exception_from_error_queue_doc },
     { NULL, NULL }
@@ -654,9 +705,10 @@
     crypto_API[crypto_X509Req_New_NUM]   = (void *)crypto_X509Req_New;
     crypto_API[crypto_X509Store_New_NUM] = (void *)crypto_X509Store_New;
     crypto_API[crypto_PKey_New_NUM]      = (void *)crypto_PKey_New;
-    crypto_API[crypto_X509Extension_New_NUM] = (void *)crypto_X509Extension_New;
-    crypto_API[crypto_PKCS7_New_NUM]     = (void *)crypto_PKCS7_New;
-    crypto_API[crypto_NetscapeSPKI_New_NUM]     = (void *)crypto_NetscapeSPKI_New;
+    crypto_API[crypto_X509Extension_New_NUM]= (void *)crypto_X509Extension_New;
+    crypto_API[crypto_PKCS7_New_NUM]        = (void *)crypto_PKCS7_New;
+    crypto_API[crypto_NetscapeSPKI_New_NUM] = (void *)crypto_NetscapeSPKI_New;
+    crypto_API[crypto_RSA_New_NUM]          = (void *)crypto_RSA_New;
     c_api_object = PyCObject_FromVoidPtr((void *)crypto_API, NULL);
     if (c_api_object != NULL)
         PyModule_AddObject(module, "_C_API", c_api_object);
@@ -674,6 +726,17 @@
     PyModule_AddIntConstant(module, "TYPE_RSA", crypto_TYPE_RSA);
     PyModule_AddIntConstant(module, "TYPE_DSA", crypto_TYPE_DSA);
 
+    PyModule_AddIntConstant(module, "RSA_PKCS1_PADDING",        crypto_RSA_PKCS1_PADDING);
+    PyModule_AddIntConstant(module, "RSA_PKCS1_OAEP_PADDING",   crypto_RSA_PKCS1_OAEP_PADDING);
+    PyModule_AddIntConstant(module, "RSA_SSLV23_PADDING",       crypto_RSA_SSLV23_PADDING);
+    PyModule_AddIntConstant(module, "RSA_NO_PADDING",           crypto_RSA_NO_PADDING);
+
+    PyModule_AddIntConstant(module, "NID_sha1",         crypto_NID_sha1);
+    PyModule_AddIntConstant(module, "NID_ripemd160",    crypto_NID_ripemd160);
+    PyModule_AddIntConstant(module, "NID_md5",          crypto_NID_md5);
+    PyModule_AddIntConstant(module, "NID_md5_sha1",     crypto_NID_md5_sha1);
+
+
 #ifdef WITH_THREAD
     if (!init_openssl_threads())
         goto error;
@@ -696,6 +759,8 @@
         goto error;
     if (!init_crypto_netscape_spki(module))
         goto error;
+    if (!init_crypto_rsa(module))
+        goto error;
 
 error:
     ;

=== modified file 'src/crypto/crypto.h'
--- src/crypto/crypto.h	2009-07-17 20:06:12 +0000
+++ src/crypto/crypto.h	2009-11-21 12:40:29 +0000
@@ -2,6 +2,7 @@
  * crypto.h
  *
  * Copyright (C) AB Strakt 2001, All rights reserved
+ * Copyright (C) Morgan Reed 2008, All rights reserved
  *
  * Exports from crypto.c.
  * See the file RATIONALE for a short explanation of why this module was written.
@@ -23,6 +24,7 @@
 #include "x509ext.h"
 #include "pkcs7.h"
 #include "pkcs12.h"
+#include "rsa.h"
 #include "../util.h"
 
 extern PyObject *crypto_Error;
@@ -59,7 +61,11 @@
 #define crypto_NetscapeSPKI_New_RETURN      crypto_NetscapeSPKIObj *
 #define crypto_NetscapeSPKI_New_PROTO       (NETSCAPE_SPKI *, int)
 
-#define crypto_API_pointers             8
+#define crypto_RSA_New_NUM      8
+#define crypto_RSA_New_RETURN       crypto_RSAObj *
+#define crypto_RSA_New_PROTO        (RSA *, int)
+
+#define crypto_API_pointers             9
 
 #ifdef crypto_MODULE
 
@@ -71,6 +77,7 @@
 extern crypto_X509Extension_New_RETURN crypto_X509Extension_New crypto_X509Extension_New_PROTO;
 extern crypto_PKCS7_New_RETURN     crypto_PKCS7_New     crypto_PKCS7_New_PROTO;
 extern crypto_NetscapeSPKI_New_RETURN  crypto_NetscapeSPKI_New  crypto_NetscapeSPKI_New_PROTO;
+extern crypto_RSA_New_RETURN       crypto_RSA_New   crypto_RSA_New_PROTO;
 
 #else /* crypto_MODULE */
 
@@ -92,6 +99,8 @@
  (*(crypto_PKCS7_New_RETURN (*)crypto_PKCS7_New_PROTO) crypto_API[crypto_PKCS7_New_NUM])
 #define crypto_NetscapeSPKI_New     \
  (*(crypto_NetscapeSPKI_New_RETURN (*)crypto_NetscapeSPKI_New_PROTO) crypto_API[crypto_NetscapeSPKI_New_NUM])
+#define crypto_RSA_New  \
+ (*(crypto_RSA_New_RETURN (*)crypto_RSA_New_PROTO) crypto_API[crypto_RSA_New_NUM])
 
 #define import_crypto() \
 { \

=== added file 'src/crypto/rsa.c'
--- src/crypto/rsa.c	1970-01-01 00:00:00 +0000
+++ src/crypto/rsa.c	2009-11-21 12:40:29 +0000
@@ -0,0 +1,400 @@
+/*
+ * rsa.c
+ *
+ * Copyright (C) Morgan Reed 2008, All rights reserved
+ *
+ * RSA encryption/decryption routines.
+ *
+ */
+#include <Python.h>
+#define crypto_MODULE
+#include "crypto.h"
+
+#define DEBUG
+
+#define     DEFAULT_PADDING     RSA_PKCS1_PADDING
+
+/*
+ * This is done every time something fails, so turning it into a macro is
+ * really nice.
+ *
+ * Arguments:   None
+ * Returns:     Doesn't return
+ */
+#define FAIL() \
+do {                                    \
+    exception_from_error_queue(crypto_Error);       \
+    return NULL;                        \
+} while (0)
+
+static char crypto_RSA_sign_doc[] = "\n\
+Returns the passed message digest signed with the contained private key\n\
+\n\
+Arguments: self - The RSA object\n\
+           args - The python argument tuple, should be:\n\
+             algo - The algorithm used to generate the digest\n\
+             digest - The message digest\n\
+Returns:   String containing the signature\n\
+";
+
+static PyObject *
+crypto_RSA_sign(crypto_RSAObj *self, PyObject *args)
+{
+    int bufsz = RSA_size(self->rsa);
+    unsigned int algo, digestlen, siglen;    
+    unsigned char *digest;
+    unsigned char *sig = (char *)malloc(bufsz);
+
+
+    if(!PyArg_ParseTuple(args, "is#:sign", &algo, &digest, &digestlen))
+        return NULL;
+
+    if(!RSA_sign(algo, digest, digestlen, sig, &siglen, self->rsa)) {
+        ERR_print_errors_fp(stdout);
+        FAIL();
+    }
+
+    return PyString_FromStringAndSize(sig, siglen);
+}
+
+static char crypto_RSA_verify_doc[] = "\n\
+Tests the given signature against the contained public key\n\
+\n\
+Arguments: self - The RSA object\n\
+           args - The python argument tuple, should be:\n\
+             algo - The algorithm used to generate the digest\n\
+             digest - The message digest\n\
+             sig - The signature\n\
+Returns:   Boolean result of comparison\n\
+";
+
+static PyObject *
+crypto_RSA_verify(crypto_RSAObj *self, PyObject *args)
+{
+    unsigned long ret;
+    unsigned int algo, digestlen, siglen;
+    unsigned char *digest;
+    unsigned char *sig;
+
+    if(!PyArg_ParseTuple(args, "is#s#:verify", &algo, &digest, &digestlen,
+       &sig, &siglen))
+        return NULL;
+ 
+    if(!(ret =RSA_verify(algo, digest, digestlen, sig, siglen, self->rsa)))
+        ERR_print_errors_fp(stdout);
+  
+    return PyLong_FromUnsignedLong(ret);
+
+}
+
+static char crypto_RSA_key_bits_doc[] = "\n\
+Returns the length of the contained RSA key\n\
+\n\
+Arguments: self - The RSA object\n\
+           args - The python argument tuple, should be empty\n\
+Returns:   Integer length of key\n\
+";
+
+static PyObject *
+crypto_RSA_key_bits(crypto_RSAObj *self, PyObject *args)
+{
+	unsigned long bits = (8 * RSA_size(self->rsa));
+	return PyLong_FromUnsignedLong(bits);
+}
+
+static char crypto_RSA_generate_key_doc[] = "\n\
+Generates a new RSA keypair\n\
+\n\
+Arguments: self - The RSA object\n\
+           args - The Python argument tuple, should be:\n\
+             bits - Key bits\n\
+Returns:   None\n\
+";
+
+static PyObject *
+crypto_RSA_generate_key(crypto_RSAObj *self, PyObject *args)
+{
+	int bits;
+	RSA *rsa;
+	
+	if (!PyArg_ParseTuple(args, "i:generate_key", &bits))
+		return NULL;
+
+	if (bits <= 0) {
+		PyErr_SetString(PyExc_ValueError, "Invalid number of bits");
+		return NULL;
+    }
+    if ((rsa = RSA_generate_key(bits, 0x10001, NULL, NULL)) == NULL)
+		FAIL();
+	
+	self->rsa = rsa;
+
+	self->initialized = 1;
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+
+static char crypto_RSA_public_encrypt_doc[] = "\n\
+Encrypts the input buffer with the associated public key\n\
+\n\
+Arguments: self - The RSA object\n\
+           args - The Python argument tuple, should be:\n\
+             ibuf - Cleartext input\n\
+Returns:   String containing encrypted data\n\
+"; 
+    
+static PyObject *
+crypto_RSA_public_encrypt(crypto_RSAObj *self, PyObject *args)
+{
+    int bufsz = RSA_size(self->rsa);
+    int sz, rsz;
+	int padding = DEFAULT_PADDING;
+    unsigned char *buf = (char*)malloc(bufsz);
+    unsigned char *ibuf;
+
+    if (!self->rsa) {
+		FAIL();
+    }
+
+    if (!PyArg_ParseTuple(args, "s#|i:public_encrypt", &ibuf, &sz, &padding)) {
+		FAIL();
+    }
+
+    rsz = RSA_public_encrypt(sz, ibuf, buf, self->rsa, padding);
+	if (rsz == -1) {
+		ERR_print_errors_fp(stdout);
+		FAIL();
+	}
+
+    return PyString_FromStringAndSize(buf, rsz);
+}
+
+static char crypto_RSA_public_decrypt_doc[] = "\n\
+Decrypts the input buffer with the associated public key\n\
+\n\
+Arguments: self - The RSA object\n\
+           args - The Python argument tuple, should be:\n\
+             ibuf - Cyphertext input\n\
+Returns:   String containing encrypted data\n\
+";
+   
+static PyObject *
+crypto_RSA_public_decrypt(crypto_RSAObj *self, PyObject *args)
+{
+    int bufsz = RSA_size(self->rsa);
+    int sz, rsz;
+	int padding = DEFAULT_PADDING;
+    unsigned char *buf = (char*)malloc(bufsz);
+    unsigned char *ibuf;
+    
+	if (!self->rsa) {
+        FAIL();
+    }
+
+    if (!PyArg_ParseTuple(args, "s#|i:public_decrypt", &ibuf, &sz, &padding)) {
+        FAIL();
+    }
+
+    rsz = RSA_public_decrypt(sz, ibuf, buf, self->rsa, padding);
+	if (rsz == -1) {
+		ERR_print_errors_fp(stdout);
+		FAIL();
+	}
+
+    return PyString_FromStringAndSize(buf, rsz);
+}
+
+static char crypto_RSA_private_encrypt_doc[] = "\n\
+Encrypts the input buffer with the associated private key\n\
+\n\
+Arguments: self - The RSA object\n\
+           args - The Python argument tuple, should be:\n\
+             ibuf - Cleartext input\n\
+Returns:   String containing encrypted data\n\
+";
+
+static PyObject *
+crypto_RSA_private_encrypt(crypto_RSAObj *self, PyObject *args)
+{
+    int bufsz = RSA_size(self->rsa);
+    int sz, rsz;
+	int padding = DEFAULT_PADDING;
+    unsigned char *buf = (char*)malloc(bufsz);
+    unsigned char *ibuf;
+
+    if (!self->rsa) {
+    FAIL();
+    }
+    
+    if (!PyArg_ParseTuple(args, "s#|i:private_decrypt", &ibuf, &sz, &padding)) {
+        FAIL();
+    }
+    
+    rsz = RSA_private_encrypt(sz, ibuf, buf, self->rsa, padding);
+	if (rsz == -1) {
+		ERR_print_errors_fp(stdout);
+		FAIL();
+	}
+
+    return PyString_FromStringAndSize(buf, rsz);
+}
+
+
+static char crypto_RSA_private_decrypt_doc[] = "\n\
+Decrypts the input buffer with the associated private key\n\
+\n\
+Arguments: self - The RSA object\n\
+           args - The Python argument tuple, should be:\n\
+             ibuf - Cyphertext input\n\
+Returns:   String containing encrypted data\n\
+";
+
+static PyObject *
+crypto_RSA_private_decrypt(crypto_RSAObj *self, PyObject *args)
+{   
+    int bufsz = RSA_size(self->rsa);
+    int sz, rsz;
+	int padding = DEFAULT_PADDING; 
+    unsigned char *buf = (char*)malloc(bufsz);
+    unsigned char *ibuf;
+ 
+    if (!self->rsa) {
+        FAIL();
+    }                   
+
+    if (!PyArg_ParseTuple(args, "s#|i:private_decrypt", &ibuf, &sz, &padding)){
+		FAIL();
+    }
+
+    rsz = RSA_private_decrypt(sz, ibuf, buf, self->rsa, padding);
+	if (rsz == -1) {
+		ERR_print_errors_fp(stdout);
+		FAIL();
+	}
+
+    return PyString_FromStringAndSize(buf, rsz);
+}
+
+/*
+ * ADD_METHOD(name) expands to a correct PyMethodDef declaration
+ *   {  'name', (PyCFunction)crypto_RSA_name, METH_VARARGS }
+ * for convenience
+ */
+#define ADD_METHOD(name)        \
+    { #name, (PyCFunction)crypto_RSA_##name, METH_VARARGS, crypto_RSA_##name##_doc }
+static PyMethodDef crypto_RSA_methods[] =
+{
+    ADD_METHOD(sign),
+    ADD_METHOD(verify),
+	ADD_METHOD(key_bits),
+	ADD_METHOD(generate_key),
+	ADD_METHOD(public_encrypt),
+	ADD_METHOD(public_decrypt),
+	ADD_METHOD(private_encrypt),
+	ADD_METHOD(private_decrypt),
+    { NULL, NULL }
+};
+#undef ADD_METHOD
+
+
+/*
+ * Constructor for RSA objects, never called by Python code directly
+ *
+ * Arguments: rsa     - A "real" RSA object
+ *            dealloc - Boolean value to specify whether the destructor should
+ *                      free the "real" RSA object
+ * Returns:   The newly created RSA object
+ */
+crypto_RSAObj *
+crypto_RSA_New(RSA *rsa, int dealloc)
+{
+    crypto_RSAObj *self;
+
+    self = PyObject_New(crypto_RSAObj, &crypto_RSA_Type);
+
+    if (self == NULL)
+        return NULL;
+
+    self->rsa = rsa;
+    self->dealloc = dealloc;
+
+    /*
+     * Heuristic.  Most call-sites pass an initialized EVP_PKEY.  Not
+     * necessarily the case that they will, though.  That's part of why this is
+     * a hack. -exarkun
+     */
+    self->initialized = 1;
+
+    return self;
+}
+
+/*
+ * Deallocate the memory used by the RSA object
+ *
+ * Arguments: self - The RSA object
+ * Returns:   None
+ */
+static void
+crypto_RSA_dealloc(crypto_RSAObj *self)
+{
+    /* Sometimes we don't have to dealloc the "real" RSA pointer ourselves */
+    if (self->dealloc)
+        RSA_free(self->rsa);
+
+    PyObject_Del(self);
+}
+
+/*
+ * Find attribute
+ *
+ * Arguments: self - The RSA object
+ *            name - The attribute name
+ * Returns:   A Python object for the attribute, or NULL if something went
+ *            wrong
+ */
+static PyObject *
+crypto_RSA_getattr(crypto_RSAObj *self, char *name)
+{
+    return Py_FindMethod(crypto_RSA_methods, (PyObject *)self, name);
+}
+
+PyTypeObject crypto_RSA_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,
+    "RSA",
+    sizeof(crypto_RSAObj),
+    0,
+    (destructor)crypto_RSA_dealloc,
+    NULL, /* print */
+    (getattrfunc)crypto_RSA_getattr,
+    NULL, /* setattr */
+    NULL, /* compare */
+    NULL, /* repr */
+    NULL, /* as_number */
+    NULL, /* as_sequence */
+    NULL, /* as_mapping */
+    NULL, /* hash */
+};
+
+
+/*
+ * Initialize the RSA part of the crypto sub module
+ *
+ * Arguments: dict - The crypto module dictionary
+ * Returns:   None
+ */
+int
+init_crypto_rsa(PyObject *module)
+{
+    if (PyType_Ready(&crypto_RSA_Type) < 0) {
+        return 0;
+    }
+
+    if(PyModule_AddObject(module, "RSAType", (PyObject *)&crypto_RSA_Type) != 0) {
+        return 0;
+    } 
+    
+    return 1;
+}
+

=== added file 'src/crypto/rsa.h'
--- src/crypto/rsa.h	1970-01-01 00:00:00 +0000
+++ src/crypto/rsa.h	2009-11-21 12:40:29 +0000
@@ -0,0 +1,47 @@
+/*
+ * rsa.h
+ *
+ * Copyright (C) Morgan Reed 2008, All rights reserved
+ *
+ * Interface to RSA encryption/decryption routines 
+ *
+ */
+#ifndef PyOpenSSL_crypto_RSA_H_
+#define PyOpenSSL_crypto_RSA_H_
+
+#include <Python.h>
+#include <openssl/rsa.h>
+#include <openssl/objects.h>
+
+extern  int       init_crypto_rsa   (PyObject *);
+
+extern  PyTypeObject    crypto_RSA_Type;
+
+#define crypto_RSA_Check(v) ((v)->ob_type == &crypto_RSA_Type)
+
+typedef struct {
+    PyObject_HEAD
+
+    /*
+     * A pointer to the underlying OpenSSL structure.
+     */
+    RSA     *rsa;
+
+    int     initialized;
+    /*
+     * A flag indicating whether pkey will be freed when this object is freed.
+     */
+    int     dealloc;
+} crypto_RSAObj;
+
+#define crypto_RSA_PKCS1_PADDING        RSA_PKCS1_PADDING
+#define crypto_RSA_PKCS1_OAEP_PADDING   RSA_PKCS1_OAEP_PADDING
+#define crypto_RSA_SSLV23_PADDING       RSA_SSLV23_PADDING
+#define crypto_RSA_NO_PADDING           RSA_NO_PADDING
+
+#define crypto_NID_sha1             NID_sha1
+#define crypto_NID_ripemd160        NID_ripemd160
+#define crypto_NID_md5              NID_md5
+#define crypto_NID_md5_sha1         NID_md5_sha1
+
+#endif

=== modified file 'test/test_crypto.py'
--- test/test_crypto.py	2009-09-01 14:35:50 +0000
+++ test/test_crypto.py	2009-11-21 12:40:29 +0000
@@ -10,10 +10,15 @@
 from os import popen2
 from datetime import datetime, timedelta
 
+from hashlib import sha1
+
 from OpenSSL.crypto import TYPE_RSA, TYPE_DSA, Error, PKey, PKeyType
 from OpenSSL.crypto import X509, X509Type, X509Name, X509NameType
 from OpenSSL.crypto import X509Req, X509ReqType
 from OpenSSL.crypto import X509Extension, X509ExtensionType
+from OpenSSL.crypto import RSA, RSAType, NID_sha1, NID_md5
+from OpenSSL.crypto import RSA_PKCS1_OAEP_PADDING, RSA_PKCS1_PADDING 
+from OpenSSL.crypto import RSA_NO_PADDING, RSA_SSLV23_PADDING
 from OpenSSL.crypto import load_certificate, load_privatekey
 from OpenSSL.crypto import FILETYPE_PEM, FILETYPE_ASN1, FILETYPE_TEXT
 from OpenSSL.crypto import dump_certificate, load_certificate_request
@@ -197,6 +202,8 @@
 -----END RSA PRIVATE KEY-----
 """
 encryptedPrivateKeyPEMPassphrase = "foobar"
+# testPlaintext MUST be 128-bits long for the RSA no_padding tests
+testPlaintext = "testing testing "
 
 # Some PKCS#7 stuff.  Generated with the openssl command line:
 #
@@ -735,7 +742,8 @@
     """
     def signable(self):
         """
-        Return something with a C{set_pubkey}, C{set_pubkey}, and C{sign} method.
+        Return something with a C{set_pubkey}, C{set_pubkey}, and C{sign} 
+        method.
         """
         raise NotImplementedError()
 
@@ -790,7 +798,9 @@
         request = X509Req()
         self.assertTrue(
             isinstance(request, X509ReqType),
-            "%r is of type %r, should be %r" % (request, type(request), X509ReqType))
+            "%r is of type %r, should be %r" % (request, 
+                                                type(request), 
+                                                X509ReqType))
 
 
     def test_version(self):
@@ -817,7 +827,9 @@
         subject = request.get_subject()
         self.assertTrue(
             isinstance(subject, X509NameType),
-            "%r is of type %r, should be %r" % (subject, type(subject), X509NameType))
+            "%r is of type %r, should be %r" % (subject, 
+                                                type(subject), 
+                                                X509NameType))
         subject.commonName = "foo"
         self.assertEqual(request.get_subject().commonName, "foo")
         del request
@@ -1533,5 +1545,133 @@
 
 
 
+class RSATests(TestCase):
+
+    def test_construction(self):
+        """
+        L{RSA} takes no arguments and returns an instance of L{RSAType}.
+        """
+        rsaobj = RSA()
+        self.assertTrue(
+            isinstance(rsaobj, RSAType),
+            "%r is of type %r, should be %r" % (rsaobj,
+                                                type(rsaobj),
+                                                RSAType))
+
+    def test_generate_key(self):
+        """
+        L{generate_key} generates a new RSA key the given size and stores it in
+        the internal structure
+        """
+        bits = 1024
+        rsaobj = RSA()
+        rsaobj.generate_key(bits)
+        self.assertEqual(rsaobj.key_bits(), bits)
+
+    def test_regenerate_key(self):
+        """
+        L{generate_key} should generates a new key of the given size everytime
+        it is called
+        """
+        bits = 512
+        rsaobj = RSA()
+        rsaobj.generate_key(bits)
+        self.assertEqual(rsaobj.key_bits(), bits)
+        rsaobj.generate_key(bits * 2)
+        self.assertEqual(rsaobj.key_bits(), bits * 2)
+
+    def test_public_encrypt(self):
+        """
+        L{public_encrypt} generates a new key and encrypts a static value with
+        the public key, then decrypts it with the private and compare the 
+        result
+        """
+        bits = 512 
+        rsaobj = RSA()
+        rsaobj.generate_key(bits)
+        crypt = rsaobj.public_encrypt(testPlaintext)
+        decrypt = rsaobj.private_decrypt(crypt)
+        self.assertEqual(decrypt, testPlaintext)
+
+    def test_private_encrypt(self):
+        """
+        L{private_encrypt} generates a new key and encrypts a static value with
+        the private key, then decrypts it with the public and compares the 
+        result
+        """
+        bits = 512
+        rsaobj = RSA()
+        rsaobj.generate_key(bits)
+        crypt = rsaobj.private_encrypt(testPlaintext)
+        decrypt = rsaobj.public_decrypt(crypt)
+        self.assertEqual(decrypt, testPlaintext)
+    
+    def test_public_encrypt_oaep_padding(self):
+        """
+        L{public_encrypt} generates a new key and encrypts a static value with
+        the public key, then decrypts it with the private and compare the 
+        result
+        """
+        bits = 512 
+        rsaobj = RSA()
+        rsaobj.generate_key(bits)
+        crypt = rsaobj.public_encrypt(testPlaintext, RSA_PKCS1_OAEP_PADDING)
+        decrypt = rsaobj.private_decrypt(crypt, RSA_PKCS1_OAEP_PADDING)
+        self.assertEqual(decrypt, testPlaintext)
+
+    def test_public_encrypt_no_padding(self):
+        """
+        L{private_encrypt} generates a new key and encrypts a static value with
+        the private key, then decrypts it with the public and compares the 
+        result
+        """
+        bits = 128 
+        rsaobj = RSA()
+        rsaobj.generate_key(bits)
+        crypt = rsaobj.public_encrypt(testPlaintext, RSA_NO_PADDING)
+        decrypt = rsaobj.private_decrypt(crypt, RSA_NO_PADDING)
+        self.assertEqual(decrypt, testPlaintext)
+       
+    def test_private_encrypt_no_padding(self):
+        """
+        L{private_encrypt} generates a new key and encrypts a static value with
+        the private key, then decrypts it with the public and compares the 
+        result
+        """
+        bits = 128 
+        rsaobj = RSA()
+        rsaobj.generate_key(bits)
+        crypt = rsaobj.private_encrypt(testPlaintext, RSA_NO_PADDING)
+        decrypt = rsaobj.public_decrypt(crypt, RSA_NO_PADDING)
+        self.assertEqual(decrypt, testPlaintext)
+       
+    def test_sign(self):
+        """
+        L{sign} generates a new key, signs a static value with it then verifies
+        the generated signature
+        """
+        bits = 512
+        rsaobj = RSA()
+        rsaobj.generate_key(bits)
+        digest = sha1()
+        digest.update(testPlaintext)
+        sig = rsaobj.sign(NID_sha1, digest.digest())
+        self.assertTrue(rsaobj.verify(NID_sha1, digest.digest(), sig))
+
+    def test_verify(self):
+        """
+        L{verify} generates a new key, signs a static value with it then 
+        mangles the message and verifies, verify should fail
+        """
+        bits = 512
+        rsaobj = RSA()
+        rsaobj.generate_key(bits)
+        digest = sha1()
+        digest.update(testPlaintext)
+        sig = rsaobj.sign(NID_sha1, digest.digest())
+        digest.update(testPlaintext[::-1])
+        self.assertFalse(rsaobj.verify(NID_sha1, digest.digest(), sig))
+
+
 if __name__ == '__main__':
     main()