adds RSA cipher

test/test_ciphers.py

@@ -159,10 +159,93 @@ class TestRsaPrivate(unittest.TestCase):
         + "3989E59C195530BAB7488C48140EF49F7E779743E1B419353123759C3B44AD69" \
         + "1256EE0061641666D37C742B15B4A2FEBF086B1A5D3F9012B105863129DBD9E2"
 
+    plain = "Everyone gets Friday off."
+
+
     def setUp(self):
         self.rsa = RsaPrivate(self.key.decode("hex"))
 
 
     def test_raises(self):
-        # invalid construction
+        # invalid key
         self.assertRaises(KeyError, RsaPrivate, 'key')
+
+
+    def test_output_size(self):
+        assert self.rsa.output_size == 1024 / 8
+
+
+    def test_encrypt_decrypt(self):
+        cipher = self.rsa.encrypt(self.plain)
+        result = self.rsa.decrypt(cipher)
+
+        assert len(cipher) == self.rsa.output_size == 1024 / 8
+        assert self.plain == result
+
+
+    def test_sign_verify(self):
+        signature = self.rsa.sign(self.plain)
+        result    = self.rsa.verify(signature)
+
+        assert len(signature) == self.rsa.output_size == 1024 / 8
+        assert self.plain == result
+
+
+class TestRsaPublic(unittest.TestCase):
+    prv = "3082025C02010002818100BC730EA849F374A2A9EF18A5DA559921F9C8ECB36D" \
+        + "48E53535757737ECD161905F3ED9E4D5DF94CAC1A9D719DA86C9E84DC4613682" \
+        + "FEABAD7E7725BB8D11A5BC623AA838CC39A20466B4F7F7F3AADA4D020EBB5E8D" \
+        + "6948DC77C9280E22E96BA426BA4CE8C1FD4A6F2B1FEF8AAEF69062E5641EEB2B" \
+        + "3C67C8DC2700F6916865A902030100010281801397EAE8387825A25C04CE0D40" \
+        + "7C31E5C470CD9B823B5809863B665FDC3190F14FD5DB15DDDED73B9593311831" \
+        + "0E5EA3D6A21A716E81481C4BCFDB8E7A866132DCFB55C1166D279224458BF1B8" \
+        + "48B14B1DACDEDADD8E2FC291FBA5A96EF83A6AF1FD5018EF9FE7C3CA78EA56D3" \
+        + "D3725B96DD4E064E3AC3D9BE72B66507074C01024100FA47D47A7C923C55EF81" \
+        + "F041302DA3CF8F1CE6872705700DDF9835D6F18B382F24B5D084B6794F712994" \
+        + "5AF0646AACE772C6ED4D59983E673AF3742CF9611769024100C0C1820D0CEBC6" \
+        + "2FDC92F99D821A31E9E9F74BF282871CEE166AD11D188270F3C0B62FF6F3F71D" \
+        + "F18623C84EEB8F568E8FF5BFF1F72BB5CC3DC657390C1B54410241009D7E05DE" \
+        + "EDF4B7B2FBFC304B551DE32F0147966905CD0E2E2CBD8363B6AB7CB76DCA5B64" \
+        + "A7CEBE86DF3B53DE61D21EEBA5F637EDACAB78D94CE755FBD71199C102401898" \
+        + "1829E61E2739702168AC0A2FA172C121869538C65890A0579CBAE3A7B115C8DE" \
+        + "F61BC2612376EFB09D1C44BE1343396717C89DCAFBF545648B38822CF2810240" \
+        + "3989E59C195530BAB7488C48140EF49F7E779743E1B419353123759C3B44AD69" \
+        + "1256EE0061641666D37C742B15B4A2FEBF086B1A5D3F9012B105863129DBD9E2"
+
+    pub = "30819F300D06092A864886F70D010101050003818D0030818902818100BC730E" \
+        + "A849F374A2A9EF18A5DA559921F9C8ECB36D48E53535757737ECD161905F3ED9" \
+        + "E4D5DF94CAC1A9D719DA86C9E84DC4613682FEABAD7E7725BB8D11A5BC623AA8" \
+        + "38CC39A20466B4F7F7F3AADA4D020EBB5E8D6948DC77C9280E22E96BA426BA4C" \
+        + "E8C1FD4A6F2B1FEF8AAEF69062E5641EEB2B3C67C8DC2700F6916865A90203010001"
+
+    plain = "Everyone gets Friday off."
+
+
+    def setUp(self):
+        self.private = RsaPrivate(self.prv.decode("hex"))
+        self.public  = RsaPublic(self.pub.decode("hex"))
+
+
+    def test_raises(self):
+        # invalid key
+        self.assertRaises(KeyError, RsaPublic, 'key')
+
+
+    def test_output_size(self):
+        assert self.public.output_size == 1024 / 8
+
+
+    def test_encrypt_decrypt(self):
+        cipher = self.public.encrypt(self.plain)
+        result = self.private.decrypt(cipher)
+
+        assert len(cipher) == self.public.output_size == 1024 / 8
+        assert self.plain == result
+
+
+    def test_sign_verify(self):
+        signature = self.private.sign(self.plain)
+        result    = self.public.verify(signature)
+
+        assert len(signature) == self.public.output_size == 1024 / 8
+        assert self.plain == result

wolfcrypt/ciphers.py

@@ -89,10 +89,10 @@ class _Cipher(object):
             self._enc = _ffi.new(self._native_type)
             self._set_key(_ENCRYPTION)
 
-        ret = "\0" * len(string)
-        self._encrypt(ret, string)
+        result = "\0" * len(string)
+        self._encrypt(result, string)
 
-        return ret
+        return result
 
 
     def decrypt(self, string):
@@ -104,10 +104,10 @@ class _Cipher(object):
             self._dec = _ffi.new(self._native_type)
             self._set_key(_DECRYPTION)
 
-        ret = "\0" * len(string)
-        self._decrypt(ret, string)
+        result = "\0" * len(string)
+        self._decrypt(result, string)
 
-        return ret
+        return result
 
 
 class Aes(_Cipher):
@@ -169,37 +169,6 @@ class _Rsa(object):
             _lib.wc_FreeRsaKey(self.native_object)
 
 
-class RsaPrivate(_Rsa):
-    def __init__(self, key):
-        _Rsa.__init__(self)
-
-        idx = _ffi.new("word32*")
-        idx[0] = 0
-
-        if _lib.wc_RsaPrivateKeyDecode(key, idx, self.native_object, len(key)):
-            raise KeyError
-
-        self.output_size = _lib.wc_RsaEncryptSize(self.native_object)
-
-
-    def decrypt(self, data):
-        ret = "\0" * self.output_size
-
-        _lib.wc_RsaPrivateDecrypt(data, len(data), ret, len(ret),
-                                  self.native_object)
-
-        return ret
-
-
-    def sign(self, data):
-        ret = "\0" * self.output_size
-
-        _lib.wc_RsaSSL_Sign(data, len(data), ret, len(ret),
-                            self.native_object, self._random.native_object)
-
-        return ret
-
-
 class RsaPublic(_Rsa):
     def __init__(self, key):
         _Rsa.__init__(self)
@@ -212,16 +181,72 @@ class RsaPublic(_Rsa):
 
         self.output_size = _lib.wc_RsaEncryptSize(self.native_object)
 
-
-    def encrypt(self, data):
-        ret = "\0" * self.output_size
-
-        _lib.wc_RsaPublicEncrypt(data, len(data), ret, len(ret),
-                                 self.native_object, self._random.native_object)
-
-        return ret
+        if self.output_size <= 0:
+            raise KeyError
 
 
-    def verify(self, data, signature):
-        return _lib.wc_RsaSSL_Verify(data, len(data), ret, len(ret),
-                                     self.native_object)
+    def encrypt(self, plaintext):
+        ciphertext = "\0" * self.output_size
+
+        ret = _lib.wc_RsaPublicEncrypt(plaintext, len(plaintext),
+                                       ciphertext, len(ciphertext),
+                                       self.native_object,
+                                       self._random.native_object)
+
+        if ret != self.output_size:
+            raise KeyError
+
+        return ciphertext
+
+
+    def verify(self, signature):
+        plaintext = "\0" * self.output_size
+
+        ret = _lib.wc_RsaSSL_Verify(signature, len(signature),
+                                    plaintext, len(plaintext),
+                                    self.native_object)
+
+        if ret < 0:
+            raise KeyError
+
+        return plaintext[:ret]
+
+
+class RsaPrivate(RsaPublic):
+    def __init__(self, key):
+        _Rsa.__init__(self)
+
+        idx = _ffi.new("word32*")
+        idx[0] = 0
+
+        if _lib.wc_RsaPrivateKeyDecode(key, idx, self.native_object, len(key)):
+            raise KeyError
+
+        self.output_size = _lib.wc_RsaEncryptSize(self.native_object)
+
+
+    def decrypt(self, ciphertext):
+        plaintext = "\0" * self.output_size
+
+        ret = _lib.wc_RsaPrivateDecrypt(ciphertext, len(ciphertext),
+                                        plaintext, len(plaintext),
+                                        self.native_object)
+
+        if ret < 0:
+            raise KeyError
+
+        return plaintext[:ret]
+
+
+    def sign(self, plaintext):
+        signature = "\0" * self.output_size
+
+        ret = _lib.wc_RsaSSL_Sign(plaintext, len(plaintext),
+                                  signature, len(signature),
+                                  self.native_object,
+                                  self._random.native_object)
+
+        if ret != self.output_size:
+            raise KeyError
+
+        return signature