def execute_command_list():
from keybone.console.parsers.list_keys import parser
args = parser.parse_args(get_sub_parser_argv())
gee = KeyBone()
table = PrettyTable([
color.grey('keyid'),
color.grey('fingerprint'),
color.grey('email'),
color.grey('private'),
color.grey('public'),
])
for key in gee.list_keys():
if args.private and not key['private']:
continue
if args.public and key['private']:
continue
if args.email:
print key['email']
else:
table.add_row([
color.white(key['keyid']),
color.white(key['fingerprint']),
color.green(key['email']),
bool(key.get('private')) and color.blue('yes') or color.yellow('no'),
bool(key.get('public')) and color.blue('yes') or color.yellow('no'),
])
if not args.email:
print table.get_string()
def execute_command_delete():
from keybone.console.parsers.delete_key import parser
args = parser.parse_args(get_sub_parser_argv())
gee = KeyBone()
key = gee.get_key(args.recipient, private=True, public=True)
if not key['fingerprint']:
print "\033[1;31mno such key\033[0m"
raise SystemExit(1)
parts = map(ensure_unicode, filter(bool, [key[x] for x in ['email', 'keyid', 'fingerprint']]))
msg = b" ".join(parts)
agreed = False
if args.force:
agreed = True
else:
agreed = get_bool(u'Delete the key {0} ?'.format(msg))
if agreed:
print "deleting", msg
print gee.delete_key(key['fingerprint'])
else:
print "\033[1;31mnot deleting", msg, "\033[0m"
def execute_command_decrypt():
from keybone.console.parsers.decrypt import parser
args = parser.parse_args(get_sub_parser_argv())
gee = KeyBone()
if args.secret:
passphrase = args.secret
elif args.no_secret:
passphrase = None
else:
passphrase = get_passphrase()
if is_file_and_exists(args.ciphertext):
ciphertext = io.open(args.ciphertext, 'rb').read()
else:
ciphertext = args.ciphertext
try:
plaintext = gee.decrypt(ciphertext, passphrase)
except InvalidKeyError as e:
logger.error("failed to decrypt: {0}".format(e))
raise SystemExit(1)
if plaintext:
print plaintext
def execute_command_wipe():
from keybone.console.parsers.wipe import parser
args = parser.parse_args(get_sub_parser_argv())
should_backup = not args.no_backup
if should_backup:
manager = BackupManager(conf.key_home, conf.path)
manager.generate_backup(path=args.backup_path)
deleted = False
for node in get_all_keyring_nodes():
if not os.path.exists(node.path):
continue
agreed = False
if args.force:
agreed = True
else:
agreed = get_bool('delete file: {0} ?'.format(node.path))
if agreed:
os.unlink(node.path)
logger.warning('deleting: {0}'.format(node.path))
deleted = True
if not deleted:
print "{0} already empty".format(conf.path)
if should_backup:
logger.info('a backup was generated at: {0}'.format(args.backup_path))
def execute_command_generate_backup():
from keybone.console.parsers.backup import parser
args = parser.parse_args(get_sub_parser_argv())
manager = BackupManager(conf.key_home, conf.path)
print manager.generate_backup(args.path)
def execute_command_show_private():
from keybone.console.parsers.show_private import parser
args = parser.parse_args(get_sub_parser_argv())
args
gee = KeyBone()
key = gee.get_key(args.recipient, private=True, public=False)
if key['private']:
print key['private']
def execute_command_recover_from_backup():
from keybone.console.parsers.recover import parser
args = parser.parse_args(get_sub_parser_argv())
manager = BackupManager(conf.key_home, conf.path)
with io.open(args.path, 'rb') as fd:
data = fd.read()
manager.recover_backup(data, conf.path, args.force)
def execute_command_show():
from keybone.console.parsers.show import parser
args = parser.parse_args(get_sub_parser_argv())
gee = KeyBone()
key = gee.get_key(args.recipient, private=True, public=True)
if not key:
raise SystemExit(1)
print json.dumps(key, indent=2)
def execute_command_show_passphrase():
from keybone.console.parsers.show_passphrase import parser
args = parser.parse_args(get_sub_parser_argv())
args
gee = KeyBone()
key = gee.get_key(args.recipient, private=True, public=False)
passphrase = key.get('passphrase')
if passphrase:
print passphrase
def execute_command_quickstart():
from keybone.console.parsers.quickstart import parser
args = parser.parse_args(get_sub_parser_argv())
data, path = initialize_key_home(args.conf_path, args.home, args.force)
width = max(map(len, data.splitlines()))
print "\033[1;30m{0}".format('-' * width)
print data.strip()
print '-' * width
print "\033[0m\033[1;33myou might want do add the following line to your ~/.bashrc", "\033[0m"
print "export KEYBONE_CONFIG_PATH='{0}'".format(path)
print
def execute_command_encrypt():
from keybone.console.parsers.encrypt import parser
args = parser.parse_args(get_sub_parser_argv())
gee = KeyBone()
if is_file_and_exists(args.plaintext):
plaintext = io.open(args.plaintext, 'rb').read()
else:
plaintext = args.plaintext
try:
print gee.encrypt(args.recipient, plaintext, sign_from=args.sign_from)
except InvalidRecipient as e:
logger.error("failed to encrypt: {0}".format(e))
raise SystemExit(1)
def execute_command_import():
from keybone.console.parsers.import_key import parser
args = parser.parse_args(get_sub_parser_argv())
gee = KeyBone()
key = args.key
if not key:
key = sys.stdin.read()
elif is_file_and_exists(key):
key = io.open(key, 'rb').read()
key = "\n".join([x.strip() for x in key.splitlines()])
try:
result = gee.import_key(key)
except InvalidKeyError as e:
logger.error('failed to import key: {0}'.format(e))
raise SystemExit(1)
for x in result.fingerprints:
logger.info('imported: %s', x)
def execute_command_create():
from keybone.console.parsers.generate_key import parser
args = parser.parse_args(get_sub_parser_argv())
gee = KeyBone()
if args.secret:
passphrase = args.secret
elif args.no_secret:
passphrase = None
else:
passphrase = get_passphrase()
name = args.name
email = args.email
password = passphrase
try:
key = gee.generate_key(name, email, password)
logger.info("Generated: {0}".format(key))
except KeyAlreadyExists as e:
logger.error('key already exists: email={email}, id={keyid}'.format(**e.key))
raise SystemExit(1)
def execute_command_sign():
from keybone.console.parsers.sign import parser
args = parser.parse_args(get_sub_parser_argv())
if args.secret:
passphrase = args.secret
elif args.no_secret:
passphrase = None
else:
passphrase = get_passphrase()
gee = KeyBone()
if is_file_and_exists(args.data):
data = io.open(args.data, 'rb').read()
else:
data = args.data
signed = gee.sign(args.recipient, data, passphrase)
if signed:
print signed
def execute_command_verify():
from keybone.console.parsers.verify import parser
args = parser.parse_args(get_sub_parser_argv())
gee = KeyBone()
if is_file_and_exists(args.signed_data):
signed_data = io.open(args.signed_data, 'rb').read()
else:
signed_data = args.signed_data
result = gee.verify(signed_data)
if not result:
print "Failed to verify"
raise SystemExit(1)
status, trust_level = result
if 'signature valid' not in status.strip():
print status, trust_level
raise SystemExit(1)
print ": ".join([status, trust_level])