def pgp(ctx, search_string, key_id, all, server):
'''Search for a PGP key on keyservers.
The following keyservers are searched in order until a match is found:
- pool.sks-keyservers.net
- keys.gnupg.net
- pgp.mit.edu
- keyserver.ubuntu.com
- zimmermann.mayfirst.org
'''
servers = []
if server:
servers.append(server)
else:
doc = pgp.__doc__
for line in doc.split("\n"):
delimiter = ' - '
if not line.startswith(delimiter):
continue
server = line.replace(delimiter, '')
servers.append(server)
for server in servers:
addr = 'http://{}'.format(server)
click.echo('Searching {}'.format(addr), err=True)
serv = KeyServer(addr)
try:
responses = serv.search(search_string)
except Exception as e:
msg = "Error from server: {}".format(e.msg)
click.echo(msg, err=True)
continue
# FIXME: DRY up this bit of code with jwk code too
keys = []
for key in responses:
if 'RSA' in key.algo:
keys.append(key)
if not key_id and len(keys) > 1:
click.echo("Multiple keys found: ", err=True)
for key in keys:
click.echo(" - {}".format(key.keyid), err=True)
msg = "Printing the first key ('{}')".format(keys[0].keyid)
click.echo(msg, err=True)
key_id_to_print = None
if key_id:
key_id_to_print = key_id
else:
key_id_to_print = keys[0].keyid
for key in keys:
if key.keyid != key_id_to_print:
continue
print key.key
if not all:
return
def setUp(self):
"""
Set up random KeyServer.
"""
self.server_host = KEY_SERVER
self.serv = KeyServer(self.server_host)
self.begin_header = '-----BEGIN PGP PUBLIC KEY BLOCK-----'
self.end_header = '-----END PGP PUBLIC KEY BLOCK-----'
DINGUS.reset()
DINGUS.return_value = load_fixture('search_answer')
class TestKeyServer(unittest.TestCase):
"""
Unit test for KeyServer class.
"""
def setUp(self):
"""
Set up random KeyServer.
"""
self.server_host = choice(KEY_SERVERS)
self.serv = KeyServer(self.server_host)
self.begin_header = '-----BEGIN PGP PUBLIC KEY BLOCK-----'
self.end_header = '-----END PGP PUBLIC KEY BLOCK-----'
def test_init(self):
"""
Test KeyServer constructor.
"""
self.assertEqual(self.serv.host, self.server_host)
self.assertEqual(self.serv.port, PORT)
def test_search(self):
"""
Test search with keyid, fingerprint and uid.
"""
result = self.serv.search(KEYID)
self.assertEqual(len(result), 1)
result[0].keyid = KEYID
result[0].identities[0].uid = UID
result = self.serv.search(FINGERPRINT)
self.assertEqual(len(result), 1)
result[0].keyid = KEYID
result[0].identities[0].uid = UID
result = self.serv.search(UID)
self.assertEqual(len(result), 1)
result[0].keyid = KEYID
result[0].identities[0].uid = UID
def test_add(self):
"""
Test ASCII armored key upload
"""
stored_key = os.path.join(
os.path.abspath(os.path.dirname(__file__)),
'ubuntu.key',
)
key = open(stored_key, 'r').read()
self.serv.add('%s\n\n%s\n%s' % (
self.begin_header,
key,
self.end_header,
))
def query(self, term):
results = {}
for keyserver in self.keyservers:
url = u'http://%s' % keyserver
server = KeyServer(url)
try:
key_list = server.search(term)
for key in key_list:
results[key.keyid] = key
except:
pass
return results.values()
def query(self, term):
results = {}
for keyserver in self.keyservers:
url = u'http://%s' % keyserver
server = KeyServer(url)
try:
key_list = server.search(term)
for key in key_list:
results[key.keyid] = key
except:
pass
return results.values()
def setUp(self):
"""
Set up random KeyServer.
"""
self.server_host = choice(KEY_SERVERS)
self.serv = KeyServer(self.server_host)
self.begin_header = '-----BEGIN PGP PUBLIC KEY BLOCK-----'
self.end_header = '-----END PGP PUBLIC KEY BLOCK-----'
def setUp(self):
"""
Set up random KeyServer.
"""
self.server_host = KEY_SERVER
self.serv = KeyServer(self.server_host)
self.begin_header = '-----BEGIN PGP PUBLIC KEY BLOCK-----'
self.end_header = '-----END PGP PUBLIC KEY BLOCK-----'
DINGUS.reset()
DINGUS.return_value = load_fixture('search_answer')
class TestKeyServer(unittest.TestCase):
"""
Unit test for KeyServer class.
"""
def setUp(self):
"""
Set up random KeyServer.
"""
self.server_host = KEY_SERVER
self.serv = KeyServer(self.server_host)
self.begin_header = '-----BEGIN PGP PUBLIC KEY BLOCK-----'
self.end_header = '-----END PGP PUBLIC KEY BLOCK-----'
DINGUS.reset()
DINGUS.return_value = load_fixture('search_answer')
def test_init(self):
"""
Test KeyServer constructor.
"""
self.assertEqual(self.serv.host, self.server_host)
self.assertEqual(self.serv.port, PORT)
@patch('urllib2.urlopen', DINGUS)
def test_search_by_id(self):
"""
Test search with keyid.
"""
result = self.serv.search(KEYID)
search_url = (self.server_host + ':11371/pks/lookup'
'?search=' + KEYID + '&exact=off&options=mr&op=index')
self.assertTrue(DINGUS.calls('()', search_url).once())
self.assertEqual(len(result), 1)
self.assertEqual(result[0].keyid, KEYID[2:])
self.assertEqual(result[0].identities[0].uid, FULL_UID)
@patch('urllib2.urlopen', DINGUS)
def test_search_by_fingerprint(self):
"""
Test search with fingerprint.
"""
result = self.serv.search(FINGERPRINT)
search_url = (self.server_host + ':11371/pks/lookup'
'?search=' + FINGERPRINT + '&exact=off&options=mr&op=index')
self.assertTrue(DINGUS.calls('()', search_url).once())
self.assertEqual(len(result), 1)
self.assertEqual(result[0].keyid, KEYID[2:])
self.assertEqual(result[0].identities[0].uid, FULL_UID)
@patch('urllib2.urlopen', DINGUS)
def test_search_by_uid(self):
"""
Test search with uid.
"""
result = self.serv.search(UID)
search_url = (self.server_host + ':11371/pks/lookup'
'?search=' + UID.replace(' ', '+') +
'&exact=off&options=mr&op=index')
self.assertTrue(DINGUS.calls('()', search_url).once())
self.assertEqual(len(result), 1)
self.assertEqual(result[0].keyid, KEYID[2:])
self.assertEqual(result[0].identities[0].uid, FULL_UID)
@patch('urllib2.urlopen', DINGUS)
def test_add(self):
"""
Test ASCII armored key upload
"""
stored_key = 'ubuntu.key'
key = load_fixture(stored_key).read()
keytext = '%s\n\n%s\n%s' % (
self.begin_header,
key,
self.end_header,
)
self.serv.add(keytext)
add_url = self.server_host + ':11371/pks/add'
self.assertTrue(DINGUS.calls('()', add_url,
urlencode({'keytext': keytext})
).once())
class TestKeyServer(unittest.TestCase):
"""
Unit test for KeyServer class.
"""
def setUp(self):
"""
Set up random KeyServer.
"""
self.server_host = KEY_SERVER
self.serv = KeyServer(self.server_host)
self.begin_header = '-----BEGIN PGP PUBLIC KEY BLOCK-----'
self.end_header = '-----END PGP PUBLIC KEY BLOCK-----'
DINGUS.reset()
DINGUS.return_value = load_fixture('search_answer')
def test_init(self):
"""
Test KeyServer constructor.
"""
self.assertEqual(self.serv.host, self.server_host)
self.assertEqual(self.serv.port, PORT)
@patch('urllib2.urlopen', DINGUS)
def test_search_by_id(self):
"""
Test search with keyid.
"""
result = self.serv.search(KEYID)
search_url = (self.server_host + ':11371/pks/lookup'
'?search=' + KEYID + '&exact=off&options=mr&op=index')
self.assertTrue(DINGUS.calls('()', search_url).once())
self.assertEqual(len(result), 1)
self.assertEqual(result[0].keyid, KEYID[2:])
self.assertEqual(result[0].identities[0].uid, FULL_UID)
@patch('urllib2.urlopen', DINGUS)
def test_search_by_fingerprint(self):
"""
Test search with fingerprint.
"""
result = self.serv.search(FINGERPRINT)
search_url = (self.server_host + ':11371/pks/lookup'
'?search=' + FINGERPRINT +
'&exact=off&options=mr&op=index')
self.assertTrue(DINGUS.calls('()', search_url).once())
self.assertEqual(len(result), 1)
self.assertEqual(result[0].keyid, KEYID[2:])
self.assertEqual(result[0].identities[0].uid, FULL_UID)
@patch('urllib2.urlopen', DINGUS)
def test_search_by_uid(self):
"""
Test search with uid.
"""
result = self.serv.search(UID)
search_url = (self.server_host + ':11371/pks/lookup'
'?search=' + UID.replace(' ', '+') +
'&exact=off&options=mr&op=index')
self.assertTrue(DINGUS.calls('()', search_url).once())
self.assertEqual(len(result), 1)
self.assertEqual(result[0].keyid, KEYID[2:])
self.assertEqual(result[0].identities[0].uid, FULL_UID)
@patch('urllib2.urlopen', DINGUS)
def test_add(self):
"""
Test ASCII armored key upload
"""
stored_key = 'ubuntu.key'
key = load_fixture(stored_key).read()
keytext = '%s\n\n%s\n%s' % (
self.begin_header,
key,
self.end_header,
)
self.serv.add(keytext)
add_url = self.server_host + ':11371/pks/add'
self.assertTrue(
DINGUS.calls('()', add_url, urlencode({'keytext':
keytext})).once())
import pyme
from pyme import core, callbacks
from pyme.constants.sig import mode
from hkp import KeyServer
try:
_serv
except:
_serv = KeyServer('http://pool.sks-keyservers.net')
def Sign(content, key_name):
c = core.Context()
#c.set_armor(1)
#c.set_progress_cb(callbacks.progress_stdout, None)
con = core.Data(content)
sig = core.Data()
c.signers_clear()
for sigkey in c.op_keylist_all(key_name, 1):
if sigkey.can_sign:
c.signers_add(sigkey)
if not c.signers_enum(0):
raise Exception('No signing keys found for key name:', key_name)
c.op_sign(con, sig, pyme.constants.SIG_MODE_DETACH)
sig.seek(0, 0)
return sig.read()
def Verify(content, signature):
c = core.Context()
con = core.Data(content)