get rid of ed25519.bytes_from_* methods

src/allmydata/client.py

@@ -11,6 +11,7 @@ from twisted.python.filepath import FilePath
 
 import allmydata
 from allmydata.crypto import rsa, ed25519
+from allmydata.crypto.util import remove_prefix
 from allmydata.storage.server import StorageServer
 from allmydata import storage_client
 from allmydata.immutable.upload import Uploader
@@ -489,8 +490,8 @@ class _Client(node.Node, pollmixin.PollMixin):
 
     def get_long_nodeid(self):
         # this matches what IServer.get_longname() says about us elsewhere
-        vk_bytes = ed25519.bytes_from_verifying_key(self._node_public_key)
-        return "v0-" + base32.b2a(vk_bytes)
+        vk_string = ed25519.string_from_verifying_key(self._node_public_key)
+        return remove_prefix(vk_string, "pub-")
 
     def get_long_tubid(self):
         return idlib.nodeid_b2a(self.nodeid)
@@ -511,7 +512,8 @@ class _Client(node.Node, pollmixin.PollMixin):
             else:
                 # otherwise, we're free to use the more natural seed of our
                 # pubkey-based serverid
-                vk_bytes = ed25519.bytes_from_verifying_key(self._node_public_key)
+                vk_string = ed25519.string_from_verifying_key(self._node_public_key)
+                vk_bytes = remove_prefix(vk_string, ed25519.PUBLIC_KEY_PREFIX)
                 seed = base32.b2a(vk_bytes)
             self.config.write_config_file("permutation-seed", seed+"\n")
         return seed.strip()

src/allmydata/crypto/ed25519.py

@@ -53,18 +53,6 @@ def create_signing_keypair():
     return private_key, private_key.public_key()
 
 
-def bytes_from_signing_key(private_key):
-    """
-    Turn a private signing key into serialized bytes
-    """
-    _validate_private_key(private_key)
-    return private_key.private_bytes(
-        Encoding.Raw,
-        PrivateFormat.Raw,
-        NoEncryption(),
-    )
-
-
 def verifying_key_from_signing_key(private_key):
     """
     :returns: the public key associated to the given `private_key`
@@ -94,7 +82,7 @@ def sign_data(private_key, data):
 
 def string_from_signing_key(private_key):
     """
-    Encode a private key to a string bytes
+    Encode a private key to a string of bytes
 
     :param private_key: the private part returned from
         `create_signing_keypair` or from
@@ -103,7 +91,12 @@ def string_from_signing_key(private_key):
     :returns: byte-string representing this key
     """
     _validate_private_key(private_key)
-    return PRIVATE_KEY_PREFIX + b2a(bytes_from_signing_key(private_key))
+    raw_key_bytes = private_key.private_bytes(
+        Encoding.Raw,
+        PrivateFormat.Raw,
+        NoEncryption(),
+    )
+    return PRIVATE_KEY_PREFIX + b2a(raw_key_bytes)
 
 
 def signing_keypair_from_string(private_key_bytes):
@@ -123,23 +116,6 @@ def signing_keypair_from_string(private_key_bytes):
     return private_key, private_key.public_key()
 
 
-def bytes_from_verifying_key(public_key):
-    """
-    Encode a verifying key to bytes.
-
-    :param public_key: the public part of a key returned from
-        `create_signing_keypair` or from
-        `signing_keypair_from_string`
-
-    :returns: bytes representing this key
-    """
-    _validate_public_key(public_key)
-    return public_key.public_bytes(
-        Encoding.Raw,
-        PublicFormat.Raw,
-    )
-
-
 def verify_signature(public_key, alleged_signature, data):
     """
     :param public_key: a verifying key
@@ -182,14 +158,18 @@ def verifying_key_from_string(public_key_bytes):
 
 def string_from_verifying_key(public_key):
     """
-    Encode a public key to a string
+    Encode a public key to a string of bytes
 
     :param public_key: the public part of a keypair
 
     :returns: byte-string representing this key
     """
     _validate_public_key(public_key)
-    return PUBLIC_KEY_PREFIX + b2a(bytes_from_verifying_key(public_key))
+    raw_key_bytes = public_key.public_bytes(
+        Encoding.Raw,
+        PublicFormat.Raw,
+    )
+    return PUBLIC_KEY_PREFIX + b2a(raw_key_bytes)
 
 
 def _validate_public_key(public_key):

src/allmydata/introducer/common.py

@@ -31,10 +31,10 @@ def sign_to_foolscap(announcement, signing_key):
     sig = b"v0-" + base32.b2a(
         ed25519.sign_data(signing_key, msg)
     )
-    verifying_key_bytes = ed25519.bytes_from_verifying_key(
+    verifying_key_string = ed25519.string_from_verifying_key(
         ed25519.verifying_key_from_signing_key(signing_key)
     )
-    ann_t = (msg, sig, b"v0-" + base32.b2a(verifying_key_bytes))
+    ann_t = (msg, sig, remove_prefix(verifying_key_string, b"pub-"))
     return ann_t
 
 

src/allmydata/test/cli/test_cli.py

@@ -735,9 +735,9 @@ class Admin(unittest.TestCase):
             self.failUnless(privkey_bits[1].startswith("priv-v0-"), lines[0])
             self.failUnless(pubkey_bits[1].startswith("pub-v0-"), lines[1])
             sk, pk = ed25519.signing_keypair_from_string(privkey_bits[1])
-            vk_bytes = base32.a2b(remove_prefix(pubkey_bits[1], "pub-v0-"))
+            vk_bytes = pubkey_bits[1]
             self.failUnlessEqual(
-                ed25519.bytes_from_verifying_key(pk),
+                ed25519.string_from_verifying_key(pk),
                 vk_bytes,
             )
         d.addCallback(_done)

src/allmydata/test/test_crypto.py

@@ -201,8 +201,8 @@ class TestRegression(unittest.TestCase):
         public_key = ed25519.verifying_key_from_string(pub_str)
 
         self.assertEqual(
-            ed25519.bytes_from_verifying_key(public_key),
-            ed25519.bytes_from_verifying_key(derived_public_key),
+            ed25519.string_from_verifying_key(public_key),
+            ed25519.string_from_verifying_key(derived_public_key),
         )
 
         new_sig = ed25519.sign_data(private_key, test_data)
@@ -289,25 +289,22 @@ class TestEd25519(unittest.TestCase):
 
         # the desrialized signing keys are the same as the original
         self.assertEqual(
-            ed25519.bytes_from_signing_key(private_key),
-            ed25519.bytes_from_signing_key(private_key2),
+            ed25519.string_from_signing_key(private_key),
+            ed25519.string_from_signing_key(private_key2),
         )
         self.assertEqual(
-            ed25519.bytes_from_verifying_key(public_key),
-            ed25519.bytes_from_verifying_key(public_key2),
+            ed25519.string_from_verifying_key(public_key),
+            ed25519.string_from_verifying_key(public_key2),
         )
 
         # ditto, but for the verifying keys
         public_key_str = ed25519.string_from_verifying_key(public_key)
-        public_key_bytes = ed25519.bytes_from_verifying_key(public_key)
-
         self.assertIsInstance(public_key_str, six.string_types)
-        self.assertIsInstance(public_key_bytes, six.binary_type)
 
         public_key2 = ed25519.verifying_key_from_string(public_key_str)
         self.assertEqual(
-            ed25519.bytes_from_verifying_key(public_key),
-            ed25519.bytes_from_verifying_key(public_key2),
+            ed25519.string_from_verifying_key(public_key),
+            ed25519.string_from_verifying_key(public_key2),
         )
 
     def test_deserialize_private_not_bytes(self):