diff --git a/tests/unit/test_keys.py b/tests/unit/test_keys.py
index 3297680f..5523378b 100755
--- a/tests/unit/test_keys.py
+++ b/tests/unit/test_keys.py
@@ -70,17 +70,17 @@ def test_generate_rsa_key(self):
     self.assertTrue(tuf.formats.RSAKEY_SCHEMA.matches(KEYS.generate_rsa_key(2048)))
     self.assertTrue(tuf.formats.RSAKEY_SCHEMA.matches(KEYS.generate_rsa_key(4096)))
     
-  def test_create_in_metadata_format(self):
+  def test_format_keyval_to_metadata(self):
     keyvalue = rsakey_dict['keyval']
     keytype = rsakey_dict['keytype']
-    key_meta = KEYS.create_in_metadata_format(keytype, keyvalue)
+    key_meta = KEYS.format_keyval_to_metadata(keytype, keyvalue)
     
     # Check if the format of the object returned by this function corresponds
     # to KEY_SCHEMA format.
     self.assertEqual(None, 
                      tuf.formats.KEY_SCHEMA.check_match(key_meta), 
                      FORMAT_ERROR_MSG)    
-    key_meta = KEYS.create_in_metadata_format(keytype, keyvalue, private=True)
+    key_meta = KEYS.format_keyval_to_metadata(keytype, keyvalue, private=True)
 
     # Check if the format of the object returned by this function corresponds
     # to KEY_SCHEMA format.
@@ -88,22 +88,22 @@ def test_create_in_metadata_format(self):
                      FORMAT_ERROR_MSG) 
     
     # Supplying a 'bad' keyvalue.
-    self.assertRaises(tuf.FormatError, KEYS.create_in_metadata_format,
+    self.assertRaises(tuf.FormatError, KEYS.format_keyval_to_metadata,
                       'bad_keytype', keyvalue)
 
     del keyvalue['public']
-    self.assertRaises(tuf.FormatError, KEYS.create_in_metadata_format,
+    self.assertRaises(tuf.FormatError, KEYS.format_keyval_to_metadata,
                       keytype, keyvalue)
 
 
 
-  def test_create_from_metadata_format(self):
+  def test_format_metadata_to_key(self):
     # Reconfiguring rsakey_dict to conform to KEY_SCHEMA
     # i.e. {keytype: 'rsa', keyval: {public: pub_key, private: priv_key}}
     #keyid = rsakey_dict['keyid']
     del rsakey_dict['keyid']
 
-    rsakey_dict_from_meta = KEYS.create_from_metadata_format(rsakey_dict) 
+    rsakey_dict_from_meta = KEYS.format_metadata_to_key(rsakey_dict) 
 
     # Check if the format of the object returned by this function corresponds
     # to RSAKEY_SCHEMA format.
@@ -112,13 +112,13 @@ def test_create_from_metadata_format(self):
            FORMAT_ERROR_MSG)
 
     # Supplying a wrong number of arguments.
-    self.assertRaises(TypeError, KEYS.create_from_metadata_format)
+    self.assertRaises(TypeError, KEYS.format_metadata_to_key)
     args = (rsakey_dict, rsakey_dict)
-    self.assertRaises(TypeError, KEYS.create_from_metadata_format, *args)
+    self.assertRaises(TypeError, KEYS.format_metadata_to_key, *args)
 
     # Supplying a malformed argument to the function - should get FormatError
     del rsakey_dict['keyval']
-    self.assertRaises(tuf.FormatError, KEYS.create_from_metadata_format,
+    self.assertRaises(tuf.FormatError, KEYS.format_metadata_to_key,
                       rsakey_dict)   
 
 
diff --git a/tuf/keys.py b/tuf/keys.py
index 925b339f..dd0facbd 100755
--- a/tuf/keys.py
+++ b/tuf/keys.py
@@ -19,7 +19,7 @@
   generated RSA key to a file.  The 'PyCrypto' package used by 'rsa_key.py'
   generates the actual RSA keys and the functions listed above can be viewed
   as an easy-to-use public interface.  Additional functions contained here
-  include create_in_metadata_format() and create_from_metadata_format().  These
+  include format_keyval_to_metadata() and format_metadata_to_key().  These
   last two functions produce or use RSA keys compatible with the key structures
   listed in TUF Metadata files.  The generate() function returns a dictionary
   containing all the information needed of RSA keys, such as public and private=
@@ -270,7 +270,7 @@ def generate_ed25519_key():
 
 
 
-def create_in_metadata_format(keytype, key_value, private=False):
+def format_keyval_to_metadata(keytype, key_value, private=False):
   """
   <Purpose>
     Return a dictionary conformant to 'tuf.formats.KEY_SCHEMA'.
@@ -295,7 +295,7 @@ def create_in_metadata_format(keytype, key_value, private=False):
     >>> key_val = ed25519_key['keyval']
     >>> keytype = ed25519_key['keytype']
     >>> ed25519_metadata = \
-    create_in_metadata_format(keytype, key_val, private=True)
+    format_keyval_to_metadata(keytype, key_val, private=True)
     >>> tuf.formats.KEY_SCHEMA.matches(ed25519_metadata)
     True
   
@@ -345,7 +345,7 @@ def create_in_metadata_format(keytype, key_value, private=False):
 
 
 
-def create_from_metadata_format(key_metadata):
+def format_metadata_to_key(key_metadata):
   """
   <Purpose>
     Construct an RSA key dictionary (i.e., tuf.formats.RSAKEY_SCHEMA)
@@ -371,8 +371,8 @@ def create_from_metadata_format(key_metadata):
     >>> key_val = ed25519_key['keyval']
     >>> keytype = ed25519_key['keytype']
     >>> ed25519_metadata = \
-    create_in_metadata_format(keytype, key_val, private=True)
-    >>> ed25519_key_2 = create_from_metadata_format(ed25519_metadata)
+    format_keyval_to_metadata(keytype, key_val, private=True)
+    >>> ed25519_key_2 = format_metadata_to_key(ed25519_metadata)
     >>> tuf.formats.ED25519KEY_SCHEMA.matches(ed25519_key_2)
     True
     >>> ed25519_key == ed25519_key_2
@@ -429,8 +429,8 @@ def _get_keyid(keytype, key_value):
 
   # 'keyid' will be generated from an object conformant to KEY_SCHEMA,
   # which is the format Metadata files (e.g., root.txt) store keys.
-  # 'create_in_metadata_format()' returns the object needed by _get_keyid().
-  rsakey_meta = create_in_metadata_format(keytype, key_value, private=False)
+  # 'format_keyval_to_metadata()' returns the object needed by _get_keyid().
+  rsakey_meta = format_keyval_to_metadata(keytype, key_value, private=False)
 
   # Convert the RSA key to JSON Canonical format suitable for adding
   # to digest objects.