Added tests for command line commands. Various test related cleanups. Added (currently broken) HTTP GET support and refactored the integration tests as a result (also currently broken.

Author: ntoll

Makefile

@@ -35,15 +35,16 @@ test: clean
 
 coverage: clean
 	coverage run -m unittest discover --buffer
-	coverage report -m --include=drogulus/* --omit=drogulus/net/*
+	coverage report -m --include=drogulus/* --omit=drogulus/net/*,drogulus/commands/*,drogulus/contrib/*
 	coverage report -m --include=drogulus/net/*
+	coverage report -m --include=drogulus/commands/*
 
 integration:
 	python integration_tests/run.py
 
 check: clean pep8 pyflakes coverage integration
 
-package: clean
+package: check
 	python setup.py sdist
 
 publish: check

drogulus/commands/keygen.py

@@ -2,21 +2,20 @@
 """
 Defines the command for generating an RSA keypair for use with the drogulus.
 """
-from Crypto.PublicKey import RSA
-from Crypto import Random
 from cliff.command import Command
-from .utils import data_dir
+import rsa
+from .utils import data_dir, APPNAME, save_keys
 import getpass
 import os
 
 
 class KeyGen(Command):
     """
-    Generates an appropriate .pem file containing the user's public/private
-    key pair for use with the drogulus.
+    Generates appropriate files containing the user's public/private key pair
+    for use with the drogulus.
 
     This command will prompt the user for a passphrase to ensure the resulting
-    .pem file is encrypted.
+    private key file is encrypted.
     """
 
     def get_description(self):
@@ -29,19 +28,19 @@ def get_parser(self, prog_name):
         return parser
 
     def take_action(self, parsed_args):
-        while True:
-            passphrase = getpass.getpass('Passphrase (make it tricky): ')
-            confirm = getpass.getpass('Confirm passphrase: ')
-            if passphrase == confirm:
-                break
-            else:
-                print('Passphrase and confirmation did not match.')
-                print('Please try again...')
+        passphrase = getpass.getpass('Passphrase (make it tricky): ')
+        confirm = getpass.getpass('Confirm passphrase: ')
+        if passphrase != confirm:
+            raise ValueError('Passphrase and confirmation did not match.')
         size = parsed_args.size
-        output_file = os.path.join(data_dir(), 'drogulus.pem')
-        print('Generating key...')
-        random_generator = Random.new().read
-        key = RSA.generate(size, random_generator)
-        with open(output_file, 'w') as f:
-            f.write(key.exportKey('PEM', passphrase).decode('ascii'))
-        print('Key written to {}'.format(output_file))
+        print('Generating keys (this may take some time, go have a coffee).')
+        (pub, priv) = rsa.newkeys(size)
+        output_file_pub = os.path.join(data_dir(), '{}.pub'.format(APPNAME))
+        output_file_priv = os.path.join(data_dir(),
+                                        '{}.scrypt'.format(APPNAME))
+        private_key = priv.save_pkcs1().decode('ascii')
+        public_key = pub.save_pkcs1().decode('ascii')
+        save_keys(private_key, public_key, passphrase, output_file_priv,
+                  output_file_pub)
+        print('Private key written to {}'.format(output_file_priv))
+        print('Public key written to {}'.format(output_file_pub))

drogulus/commands/start.py

@@ -4,14 +4,15 @@
 """
 from ..node import Drogulus
 from ..net.http import HttpConnector, HttpRequestHandler
-from .utils import data_dir, log_dir, get_keys, get_whoami, get_alias
+from .utils import data_dir, log_dir, get_keys, get_whoami, APPNAME
 from cliff.command import Command
 from getpass import getpass
 import logging
+import logging.handlers
 import asyncio
 import json
-import sys
 import os
+import os.path
 
 
 class Start(Command):
@@ -23,21 +24,20 @@ def get_description(self):
         return 'Starts a local drogulus node.'
 
     def get_parser(self, prog_name):
-        # TODO: Non positional args
         parser = super(Start, self).get_parser(prog_name)
         parser.add_argument('--passphrase', '-p', nargs='?', default='',
-                            type=str, help='The passphrase for the RSA keys.')
-        parser.add_argument('--keyfile', '-k', nargs='?', default='', type=str,
-                            help='The pem file of the RSA keys to use.')
+                            type=str, help='The passphrase for the private ' +
+                            'RSA key.')
+        parser.add_argument('--keys', '-k', nargs='?', default='', type=str,
+                            help='The directory containing the RSA public ' +
+                            'and private keys.')
         parser.add_argument('--peers', nargs='?', default='', type=str,
                             help='The peer.json file used to seed the ' +
                             'local node\'s routing table.')
         parser.add_argument('--port', nargs='?', default=1908, type=int,
                             help='The incoming port (defaults to 1908).')
         parser.add_argument('--whoami', nargs='?', default='', type=str,
                             help='The whoami.json file to use.')
-        parser.add_argument('--alias', nargs='?', default='', type=str,
-                            help='The alias.json file to use.')
         return parser
 
     def take_action(self, parsed_args):
@@ -47,24 +47,15 @@ def take_action(self, parsed_args):
         """
         passphrase = parsed_args.passphrase
         if not passphrase:
-            print('You must supply a passphrase')
-            passphrase = getpass()
+            print('You must supply a passphrase.')
+            passphrase = getpass().strip()
             if not passphrase:
-                sys.exit(1)
+                raise ValueError('You must supply a passphrase.')
         port = parsed_args.port
         whoami = parsed_args.whoami
-        alias = parsed_args.alias
-        key_file = parsed_args.keyfile
+        key_dir = parsed_args.keys
         peer_file = parsed_args.peers
 
-        # RSA key config.
-        try:
-            private_key, public_key = get_keys(passphrase, key_file)
-        except Exception as ex:
-            print('Unable to get keys from {}'.format(key_file))
-            print('{}'.format(repr(ex)))
-            sys.exit(1)
-
         # Setup logging
         logfile = os.path.join(log_dir(), 'drogulus.log')
         handler = logging.handlers.TimedRotatingFileHandler(logfile,
@@ -79,30 +70,38 @@ def take_action(self, parsed_args):
         log = logging.getLogger(__name__)
         print('Logging to {}'.format(logfile))
 
-        # Whoami and alias
+        # RSA key config.
+        priv_path = None
+        pub_path = None
+        if key_dir:
+            priv_path = os.path.join(key_dir, '{}.scrypt'.format(APPNAME))
+            pub_path = os.path.join(key_dir, '{}.pub'.format(APPNAME))
+        try:
+            private_key, public_key = get_keys(passphrase, priv_path,
+                                               pub_path)
+        except Exception as ex:
+            log.error('Unable to get keys from {}'.format(key_dir))
+            log.error(ex)
+            raise ex
+
+        # Whoami
         try:
             whoami = get_whoami(whoami)
         except:
             log.error('Unable to get whoami file.')
             whoami = None
-        try:
-            alias = get_alias(alias)
-        except:
-            log.error('Unable to get alias file.')
-            alias = None
 
         # Asyncio boilerplate.
         event_loop = asyncio.get_event_loop()
         connector = HttpConnector(event_loop)  # NetstringConnector(event_loop)
-        instance = Drogulus(public_key, private_key, event_loop, connector,
-                            port, alias, whoami)
+        instance = Drogulus(private_key, public_key, event_loop, connector,
+                            port, whoami)
 
         def protocol_factory(connector=connector, node=instance._node):
             """
             Returns an appropriately configured Protocol object for
             each connection.
             """
-            # return NetstringProtocol(connector, node)
             return HttpRequestHandler(connector, node)
 
         setup_server = event_loop.create_server(protocol_factory, port=port)
@@ -120,16 +119,12 @@ def protocol_factory(connector=connector, node=instance._node):
         except KeyboardInterrupt:
             log.info('Manual exit')
         finally:
-            # dump alias
-            with open(os.path.join(data_dir(), 'alias.json'), 'w') as output:
-                json.dump(instance.alias, output, indent=2)
-                log.info('Dumped alias')
             # dump peers
             if not peer_file:
                 peer_file = os.path.join(data_dir(), 'peers.json')
             with open(peer_file, 'w') as output:
-                json.dump(instance._node.routing_table.all_contacts(),
-                          output, indent=2)
+                json.dump(instance._node.routing_table.dump(), output,
+                          indent=2)
                 log.info('Dumped peers')
             log.info('STOPPED')
             server.close()

drogulus/commands/utils.py

@@ -4,9 +4,10 @@
 """
 from ..version import get_version
 from ..contrib.appdirs import user_data_dir, user_log_dir
-from Crypto.PublicKey import RSA
 import json
 import os
+import pyscrypt
+from pyscrypt.file import InvalidScryptFileFormat
 
 
 APPNAME = 'drogulus'
@@ -39,33 +40,52 @@ def log_dir():
     return uld
 
 
-def get_keys(passphrase, input_file=None):
+def get_keys(passphrase, priv_file=None, pub_file=None):
     """
     Will return a string representation of both the private and public
-    password protected RSA keys found in the location specified by input_file.
-    If input_file is None then the sane default location and name is used.
+    RSA keys found in the locations specified by priv_file and pub_file args.
+    Since the private key is password protected the passphrase argument is
+    used to decrypt it. If no file paths are given then sane default
+    location and names are used.
     """
-    if not input_file:
-        input_file = os.path.join(data_dir(), '{}.pem'.format(APPNAME))
-    f = open(input_file, 'r')
-    key = RSA.importKey(f.read(), passphrase)
-    return (key.exportKey('PEM').decode('ascii'),
-            key.publickey().exportKey('PEM').decode('ascii'))
+    if not pub_file:
+        pub_file = os.path.join(data_dir(), '{}.pub'.format(APPNAME))
+    if not priv_file:
+        priv_file = os.path.join(data_dir(), '{}.scrypt'.format(APPNAME))
+    pub = open(pub_file, 'rb').read()
+    try:
+        with pyscrypt.ScryptFile(priv_file, passphrase.encode('utf-8')) as f:
+            priv = f.read()
+    except InvalidScryptFileFormat:
+        # Make the exception a bit more human.
+        msg = 'Unable to read private key file. Check your passphrase!'
+        raise ValueError(msg)
+    return (priv, pub)
 
 
-def get_whoami(input_file=None):
+def save_keys(private_key, public_key, passphrase, priv_file, pub_file):
     """
-    Attempts to get the user's whoami information.
+    Given private and public keys as bytes, a passphrase and paths to private
+    and public output files will save the keys in the appropriate file path
+    location. In the case of the private key, will use the scrypt module (see:
+    https://en.wikipedia.org/wiki/Scrypt) and the passphrase to encrypt it.
     """
-    if not input_file:
-        input_file = os.path.join(data_dir(), 'whoami.json')
-    return json.load(open(input_file, 'r'))
+    with open(pub_file, 'wb') as fpub:
+        fpub.write(public_key)
+    # PyScrypt has problems using the 'with' keyword and saving content.
+    fp = open(priv_file, 'wb')
+    try:
+        fpriv = pyscrypt.ScryptFile(fp, passphrase.encode('utf-8'), N=1024,
+                                    r=1, p=1)
+        fpriv.write(private_key)
+    finally:
+        fpriv.close()
 
 
-def get_alias(input_file=None):
+def get_whoami(input_file=None):
     """
-    Attempts to get the user's alias dictionary.
+    Attempts to get the user's whoami information.
     """
     if not input_file:
-        input_file = os.path.join(data_dir(), 'alias.json')
+        input_file = os.path.join(data_dir(), 'whoami.json')
     return json.load(open(input_file, 'r'))

drogulus/commands/whoami.py

@@ -15,6 +15,15 @@ class WhoAmI(Command):
     owner of a public key in the drogulus DHT.
     """
 
+    contact_fields = ['Name', 'Nickname', 'Organizational affiliation',
+                      'Website', 'Contact information (e.g. email)',
+                      'Biography', 'Miscellaneous notes']
+    """
+    This list of contact fields defines the field names used to reference data
+    in the whoami JSON file. They're a bit arbitrary, but vaguely based upon
+    a small basic subset of fields used by vcard (see rfc2426).
+    """
+
     def get_description(self):
         return ' '.join(['Generates a whoami data structure to self-identify',
                         'a user.'])
@@ -25,14 +34,11 @@ def take_action(self, parsed_args):
         is associated with some sort of contact details.
         """
         whoami = {}
-        fields = ['Name', 'Nickname', 'Organizational affiliation', 'Website',
-                  'Contact information (e.g. email)', 'Biography',
-                  'Miscellaneous notes']
         print('Create a whoami profile.')
         print('(Blank fields will be left out of the profile.)')
         while True:
-            for field in fields:
-                val = input('{}: '.format(field)).strip()
+            for field in self.contact_fields:
+                val = str(input('{}: '.format(field))).strip()
                 if val:
                     whoami[field] = val
             print('\nPlease check:')