コード例 #1
0
ファイル: test_crypto.py プロジェクト: chevah/utils
 def test_init_dsa(self):
     """
     Check generation of a DSA key.
     """
     key = Key()
     key.generate(key_type=crypto.TYPE_DSA, key_size=1024)
     self.assertEqual('DSA', key.type())
     self.assertEqual(1024, key.size)
コード例 #2
0
ファイル: test_crypto.py プロジェクト: chevah/utils
 def test_key_init_unknown_type(self):
     """
     An error is raised when generating a key with unknow type.
     """
     with self.assertRaises(UtilsError) as context:
         key = Key(None)
         key.generate(key_type=0)
     self.assertEqual(u'1003', context.exception.event_id)
コード例 #3
0
ファイル: helpers.py プロジェクト: chevah/utils
def generate_ssh_key(options, key=None, open_method=None):
    """
    Generate a SSH RSA or DSA key.

    Return a pair of (exit_code, operation_message).

    For success, exit_code is 0.

    `key` and `open_method` are helpers for dependency injection
    during tests.
    """
    if key is None:
        from chevah.utils.crypto import Key
        key = Key()

    if open_method is None:
        open_method = open

    exit_code = 0
    message = ''
    try:
        key_size = options.key_size

        if options.key_type.lower() == u'rsa':
            key_type = crypto.TYPE_RSA
        elif options.key_type.lower() == u'dsa':
            key_type = crypto.TYPE_DSA
        else:
            key_type = options.key_type

        if not hasattr(options, 'key_file') or options.key_file is None:
            options.key_file = 'id_%s' % (options.key_type.lower())

        private_file = options.key_file

        public_file = u'%s%s' % (
            options.key_file, DEFAULT_PUBLIC_KEY_EXTENSION)

        key.generate(key_type=key_type, key_size=key_size)

        private_file_path = LocalFilesystem.getEncodedPath(private_file)
        public_file_path = LocalFilesystem.getEncodedPath(public_file)

        with open_method(private_file_path, 'wb') as file_handler:
            key.store(private_file=file_handler)

        key_comment = None
        if hasattr(options, 'key_comment') and options.key_comment:
            key_comment = options.key_comment
            message_comment = u'having comment "%s"' % key_comment
        else:
            message_comment = u'without a comment'

        with open_method(public_file_path, 'wb') as file_handler:
            key.store(public_file=file_handler, comment=key_comment)

        message = (
            u'SSH key of type "%s" and length "%d" generated as '
            u'public key file "%s" and private key file "%s" %s.') % (
            options.key_type,
            key_size,
            public_file,
            private_file,
            message_comment,
            )

        exit_code = 0

    except UtilsError, error:
        exit_code = 1
        message = unicode(error)