def decrypt_secret_key(self, passphrase):
if hasattr(passphrase, 'encode'):
passphrase = passphrase.encode('utf-8')
packet = copy.copy(self._message or self._key) # Do not mutate original
cipher, key_bytes, key_block_bytes = self.get_cipher(packet.symmetric_algorithm)
cipher = cipher(packet.s2k.make_key(passphrase, key_bytes))
cipher = cipher(packet.encrypted_data[:key_block_bytes])
material = self._block_pad_unpad(key_block_bytes, packet.encrypted_data[key_block_bytes:], lambda x: cipher.decrypt(x))
if packet.s2k_useage == 254:
chk = material[-20:]
material = material[:-20]
if(chk != hashlib.sha1(material)):
return None
else:
chk = unpack('!H', material[-2:])[0]
material = material[:-2]
if chk != OpenPGP.checksum(material):
return None
packet.s2k_usage = 0
packet.symmetric_alorithm = 0
packet.encrypted_data = None
packet.input = OpenPGP.PushbackGenerator(OpenPGP._gen_one(material))
packet.length = len(material)
packet.key_from_input()
packet.input = None
return packet
def decrypt_secret_key(self, passphrase):
if hasattr(passphrase, "encode"):
passphrase = passphrase.encode("utf-8")
packet = copy.copy(self._message or self._key) # Do not mutate original
cipher, key_bytes, key_block_bytes = self.get_cipher(packet.symmetric_algorithm)
cipher = cipher(packet.s2k.make_key(passphrase, key_bytes))
cipher = cipher(packet.encrypted_data[:key_block_bytes]).decryptor()
pad_amount = key_block_bytes - (len(packet.encrypted_data[key_block_bytes:]) % key_block_bytes)
material = cipher.update(packet.encrypted_data[key_block_bytes:] + (pad_amount * b"\0"))
material += cipher.finalize()
material = material[:-pad_amount]
if packet.s2k_useage == 254:
chk = material[-20:]
material = material[:-20]
if chk != hashlib.sha1(material):
return None
else:
chk = unpack("!H", material[-2:])[0]
material = material[:-2]
if chk != OpenPGP.checksum(material):
return None
packet.s2k_usage = 0
packet.symmetric_alorithm = 0
packet.encrypted_data = None
packet.input = OpenPGP.PushbackGenerator(OpenPGP._gen_one(material))
packet.length = len(material)
packet.key_from_input()
packet.input = None
return packet
def decrypt_secret_key(self, passphrase):
if hasattr(passphrase, 'encode'):
passphrase = passphrase.encode('utf-8')
packet = copy.copy(self._message or self._key) # Do not mutate original
cipher, key_bytes, key_block_bytes = self.get_cipher(packet.symmetric_algorithm)
cipher = cipher(packet.s2k.make_key(passphrase, key_bytes))
cipher = cipher(packet.encrypted_data[:key_block_bytes]).decryptor()
pad_amount = key_block_bytes - (len(packet.encrypted_data[key_block_bytes:]) % key_block_bytes)
material = cipher.update(packet.encrypted_data[key_block_bytes:] + (pad_amount*b'\0'))
material += cipher.finalize()
material = material[:-pad_amount]
if packet.s2k_useage == 254:
chk = material[-20:]
material = material[:-20]
if(chk != hashlib.sha1(material)):
return None
else:
chk = unpack('!H', material[-2:])[0]
material = material[:-2]
if chk != OpenPGP.checksum(material):
return None
packet.s2k_usage = 0
packet.symmetric_alorithm = 0
packet.encrypted_data = None
packet.input = OpenPGP.PushbackGenerator(OpenPGP._gen_one(material))
packet.length = len(material)
packet.key_from_input()
packet.input = None
return packet
def testEncryptSymmetric(self):
data = OpenPGP.LiteralDataPacket('This is text.', 'u', 'stuff.txt')
encrypted = OpenPGP.cryptography.Wrapper(OpenPGP.Message(
[data])).encrypt('secret')
decrypted = OpenPGP.cryptography.Wrapper(encrypted).decrypt_symmetric(
'secret')
nose.tools.assert_equal(decrypted[0].data, b'This is text.')
def sign(self, packet, hash='SHA256', keyid=None):
if self._key and not isinstance(packet, OpenPGP.Packet) and not isinstance(packet, OpenPGP.Message):
packet = OpenPGP.LiteralDataPacket(packet)
else:
packet = self._parse_packet(packet)
if isinstance(packet, OpenPGP.SecretKeyPacket) or isinstance(packet, Crypto.PublicKey.RSA._RSAobj) or isinstance(packet, Crypto.PublicKey.DSA._DSAobj) or (hasattr(packet, '__getitem__') and isinstance(packet[0], OpenPGP.SecretKeyPacket)):
key = packet
message = self._message
else:
key = self._key
message = packet
if not key or not message:
return None # Missing some data
if isinstance(message, OpenPGP.Message):
message = message.signature_and_data()[1]
if not (isinstance(key, Crypto.PublicKey.RSA._RSAobj) or isinstance(packet, Crypto.PublicKey.DSA._DSAobj)):
key = self.__class__(key)
if not keyid:
keyid = key.key().fingerprint()[-16:]
key = key.private_key(keyid)
key_algorithm = None
if isinstance(key, Crypto.PublicKey.RSA._RSAobj):
key_algorithm = 'RSA'
elif isinstance(key, Crypto.PublicKey.DSA._DSAobj):
key_algorithm = 'DSA'
sig = OpenPGP.SignaturePacket(message, key_algorithm, hash.upper())
if keyid:
sig.hashed_subpackets.append(OpenPGP.SignaturePacket.IssuerPacket(keyid))
def doDSA(h, m):
return list(key.sign(h.new(m).digest()[0:int(Crypto.Util.number.size(key.q) / 8)],
Crypto.Random.random.StrongRandom().randint(1,key.q-1)))
sig.sign_data({'RSA': {
'MD5': lambda m: [Crypto.Signature.PKCS1_v1_5.new(key).sign(Crypto.Hash.MD5.new(m))],
'RIPEMD160': lambda m: [Crypto.Signature.PKCS1_v1_5.new(key).sign(Crypto.Hash.RIPEMD.new(m))],
'SHA1': lambda m: [Crypto.Signature.PKCS1_v1_5.new(key).sign(Crypto.Hash.SHA.new(m))],
'SHA224': lambda m: [Crypto.Signature.PKCS1_v1_5.new(key).sign(Crypto.Hash.SHA224.new(m))],
'SHA256': lambda m: [Crypto.Signature.PKCS1_v1_5.new(key).sign(Crypto.Hash.SHA256.new(m))],
'SHA384': lambda m: [Crypto.Signature.PKCS1_v1_5.new(key).sign(Crypto.Hash.SHA384.new(m))],
'SHA512': lambda m: [Crypto.Signature.PKCS1_v1_5.new(key).sign(Crypto.Hash.SHA512.new(m))],
}, 'DSA': {
'MD5': lambda m: doDSA(Crypto.Hash.MD5, m),
'RIPEMD160': lambda m: doDSA(Crypto.Hash.RIPEMD, m),
'SHA1': lambda m: doDSA(Crypto.Hash.SHA, m),
'SHA224': lambda m: doDSA(Crypto.Hash.SHA224, m),
'SHA256': lambda m: doDSA(Crypto.Hash.SHA256, m),
'SHA384': lambda m: doDSA(Crypto.Hash.SHA384, m),
'SHA512': lambda m: doDSA(Crypto.Hash.SHA512, m),
}})
return OpenPGP.Message([sig, message])
def test_partial_results(self):
m = OpenPGP.Message.parse(
OpenPGP.Message([
OpenPGP.UserIDPacket('My name <*****@*****.**>'),
OpenPGP.UserIDPacket('Your name <*****@*****.**>')
]).to_bytes())
m[0] # Just the first one
nose.tools.assert_equal(len(m.force()), 2)
def testEncryptAsymmetric(self):
key = OpenPGP.Message.parse(
open(os.path.dirname(__file__) + '/data/helloKey.gpg',
'rb').read())
data = OpenPGP.LiteralDataPacket('This is text.', 'u', 'stuff.txt')
encrypted = OpenPGP.Crypto.Wrapper(OpenPGP.Message([data
])).encrypt(key)
decryptor = OpenPGP.Crypto.Wrapper(key)
decrypted = decryptor.decrypt(encrypted)
nose.tools.assert_equal(decrypted[0].data, b'This is text.')
def test_enarmor_one(self):
expected = self.readLocalFile('/data/helloKey.asc')
messages = OpenPGP.unarmor(expected) # [(header, data), ...]
header, data = messages[0]
actual = OpenPGP.enarmor(data,
headers=[
keyValue.split(': ', 1)
for keyValue in header.split('\n')
])
nose.tools.assert_equal(actual, expected)
def sign_key_userid(self, packet, hash='SHA256', keyid=None):
if isinstance(packet, list):
packet = OpenPGP.Message(packet)
elif not isinstance(packet, OpenPGP.Message):
packet = OpenPGP.Message.parse(packet)
key = self.key(keyid)
if not key or not packet: # Missing some data
return None
if not keyid:
keyid = key.fingerprint()[-16:]
key = self.private_key(keyid)
sig = None
for p in packet:
if isinstance(p, OpenPGP.SignaturePacket):
sig = p
if not sig:
sig = OpenPGP.SignaturePacket(packet, 'RSA', hash.upper())
sig.signature_type = 0x13
sig.hashed_subpackets.append(OpenPGP.SignaturePacket.KeyFlagsPacket([0x01]))
sig.hashed_subpackets.append(OpenPGP.SignaturePacket.IssuerPacket(keyid))
packet.append(sig)
def doDSA(h, m):
return list(key.sign(h.new(m).digest()[0:int(Crypto.Util.number.size(key.q) / 8)],
Crypto.Random.random.StrongRandom().randint(1,key.q-1)))
def doRSA(h, m):
ctx = key.signer(padding.PKCS1v15(), h())
ctx.update(m)
return [ctx.finalize()]
sig.sign_data({'RSA': {
'MD5': lambda m: doRSA(hashes.MD5, m),
'RIPEMD160': lambda m: doRSA(hashes.RIPEMD160, m),
'SHA1': lambda m: doRSA(hashes.SHA1, m),
'SHA224': lambda m: doRSA(hashes.SHA224, m),
'SHA256': lambda m: doRSA(hashes.SHA256, m),
'SHA384': lambda m: doRSA(hashes.SHA384, m),
'SHA512': lambda m: doRSA(hashes.SHA512, m)
}, 'DSA': {
'MD5': lambda m: doDSA(Crypto.Hash.MD5, m),
'RIPEMD160': lambda m: doDSA(Crypto.Hash.RIPEMD, m),
'SHA1': lambda m: doDSA(Crypto.Hash.SHA, m),
'SHA224': lambda m: doDSA(Crypto.Hash.SHA224, m),
'SHA256': lambda m: doDSA(Crypto.Hash.SHA256, m),
'SHA384': lambda m: doDSA(Crypto.Hash.SHA384, m),
'SHA512': lambda m: doDSA(Crypto.Hash.SHA512, m),
}})
return packet
def encrypt(self, passphrases_and_keys, symmetric_algorithm=9):
cipher, key_bytes, key_block_bytes = self.get_cipher(
symmetric_algorithm)
if not cipher:
raise Exception("Unsupported cipher")
prefix = Crypto.Random.new().read(key_block_bytes)
prefix += prefix[-2:]
key = Crypto.Random.new().read(key_bytes)
session_cipher = cipher(key)(None)
to_encrypt = prefix + self._message.to_bytes()
mdc = OpenPGP.ModificationDetectionCodePacket(
Crypto.Hash.SHA.new(to_encrypt + b'\xD3\x14').digest())
to_encrypt += mdc.to_bytes()
def doEncrypt(cipher):
ctx = cipher.encryptor()
return lambda x: ctx.update(x) + ctx.finalize()
encrypted = [
OpenPGP.IntegrityProtectedDataPacket(
self._block_pad_unpad(key_block_bytes, to_encrypt,
doEncrypt(session_cipher)))
]
if not isinstance(passphrases_and_keys,
collections.Iterable) or hasattr(
passphrases_and_keys, 'encode'):
passphrases_and_keys = [passphrases_and_keys]
for psswd in passphrases_and_keys:
if isinstance(psswd, OpenPGP.PublicKeyPacket):
if not psswd.key_algorithm in [1, 2, 3]:
raise Exception("Only RSA keys are supported.")
rsa = self.__class__(psswd).public_key()
pkcs1 = Crypto.Cipher.PKCS1_v1_5.new(rsa)
esk = pkcs1.encrypt(
pack('!B', symmetric_algorithm) + key +
pack('!H', OpenPGP.checksum(key)))
esk = pack('!H', OpenPGP.bitlength(esk)) + esk
encrypted = [
OpenPGP.AsymmetricSessionKeyPacket(
psswd.key_algorithm, psswd.fingerprint(), esk)
] + encrypted
elif hasattr(psswd, 'encode'):
psswd = psswd.encode('utf-8')
s2k = OpenPGP.S2K(Crypto.Random.new().read(10))
packet_cipher = cipher(s2k.make_key(psswd, key_bytes))(None)
esk = self._block_pad_unpad(
key_block_bytes,
pack('!B', symmetric_algorithm) + key,
doEncrypt(packet_cipher))
encrypted = [
OpenPGP.SymmetricSessionKeyPacket(s2k, esk,
symmetric_algorithm)
] + encrypted
return OpenPGP.Message(encrypted)
def testSigningKeysRSA(self):
k = Crypto.PublicKey.RSA.generate(1024)
nkey = OpenPGP.SecretKeyPacket((Crypto.Util.number.long_to_bytes(k.n),
Crypto.Util.number.long_to_bytes(k.e),
Crypto.Util.number.long_to_bytes(k.d),
Crypto.Util.number.long_to_bytes(k.p),
Crypto.Util.number.long_to_bytes(k.q),
Crypto.Util.number.long_to_bytes(k.u)))
uid = OpenPGP.UserIDPacket('Test <*****@*****.**>')
wkey = OpenPGP.cryptography.Wrapper(nkey)
m = wkey.sign_key_userid([nkey, uid]).to_bytes()
reparsedM = OpenPGP.Message.parse(m)
nose.tools.assert_equal(wkey.verify(reparsedM), reparsedM.signatures())
def testSigningMessagesRSA(self):
wkey = OpenPGP.Message.parse(
open(os.path.dirname(__file__) + '/data/helloKey.gpg',
'rb').read())
data = OpenPGP.LiteralDataPacket('This is text.', 'u', 'stuff.txt')
sign = OpenPGP.cryptography.Wrapper(wkey)
m = sign.sign(data).to_bytes()
reparsedM = OpenPGP.Message.parse(m)
nose.tools.assert_equal(sign.verify(reparsedM), reparsedM.signatures())
def testSigningMessagesDSA(self):
wkey = OpenPGP.Message.parse(
open(os.path.dirname(__file__) + '/data/secring.gpg', 'rb').read())
data = OpenPGP.LiteralDataPacket('This is text.', 'u', 'stuff.txt')
dsa = OpenPGP.Crypto.Wrapper(wkey).private_key('7F69FA376B020509')
m = OpenPGP.Crypto.Wrapper(data).sign(dsa, 'SHA512',
'7F69FA376B020509').to_bytes()
reparsedM = OpenPGP.Message.parse(m)
nose.tools.assert_equal(
OpenPGP.Crypto.Wrapper(wkey).verify(reparsedM),
reparsedM.signatures())
def _parse_packet(cls, packet):
if isinstance(packet, OpenPGP.Packet) or isinstance(packet, OpenPGP.Message) or isinstance(packet, RSAPublicKey) or isinstance(packet, RSAPrivateKey) or isinstance(packet, DSAPublicKey) or isinstance(packet, DSAPrivateKey):
return packet
elif isinstance(packet, tuple) or isinstance(packet, list):
if sys.version_info[0] == 2 and isinstance(packet[0], int) or isinstance(packet[0], int):
data = []
for i in packet:
data.append(Crypto.Util.number.long_to_bytes(i)) # OpenPGP likes bytes
else:
data = packet
return OpenPGP.SecretKeyPacket(keydata=data, algorithm=1, version=3) # V3 for fingerprint with no timestamp
else:
return OpenPGP.Message.parse(packet)
def actionGenerate(self):
self.pubKey, self.secKey = OpenPGP.generateKey(2048)
self.nym = OpenPGP.messages.Message.fromPackets((
OpenPGP.packets.NymPacket.fromParameter(
self.idEntry.get(),
self.pubKey.packets[OpenPGP.TAG_PUBKEY].n),))
self.idEntry.delete(0, END)
self.idEntry.insert(0, self.nym.packets[OpenPGP.TAG_NYM].id)
self.keyVar.set(self.nym.packets[OpenPGP.TAG_NYM].keyID().encode('hex'))
open(self.config.cfg[Config.PUBLICKEY], 'w').write(self.pubKey.rep())
passphrase = tkSimpleDialog.askstring('idgui.py',
'Enter passphrase for secret key:')
open(self.config.cfg[Config.SECRETKEY], 'w').write(
self.secKey.rep(passphrase))
def encrypt(self, passphrases_and_keys, symmetric_algorithm=9):
cipher, key_bytes, key_block_bytes = self.get_cipher(symmetric_algorithm)
if not cipher:
raise Exception("Unsupported cipher")
prefix = Crypto.Random.new().read(key_block_bytes)
prefix += prefix[-2:]
key = Crypto.Random.new().read(key_bytes)
session_cipher = cipher(key)(None)
to_encrypt = prefix + self._message.to_bytes()
mdc = OpenPGP.ModificationDetectionCodePacket(Crypto.Hash.SHA.new(to_encrypt + b'\xD3\x14').digest())
to_encrypt += mdc.to_bytes()
encrypted = [OpenPGP.IntegrityProtectedDataPacket(self._block_pad_unpad(key_block_bytes, to_encrypt, lambda x: session_cipher.encrypt(x)))]
if not isinstance(passphrases_and_keys, collections.Iterable) or hasattr(passphrases_and_keys, 'encode'):
passphrases_and_keys = [passphrases_and_keys]
for psswd in passphrases_and_keys:
if isinstance(psswd, OpenPGP.PublicKeyPacket):
if not psswd.key_algorithm in [1,2,3]:
raise Exception("Only RSA keys are supported.")
rsa = self.__class__(psswd).public_key()
pkcs1 = Crypto.Cipher.PKCS1_v1_5.new(rsa)
esk = pkcs1.encrypt(pack('!B', symmetric_algorithm) + key + pack('!H', OpenPGP.checksum(key)))
esk = pack('!H', OpenPGP.bitlength(esk)) + esk
encrypted = [OpenPGP.AsymmetricSessionKeyPacket(psswd.key_algorithm, psswd.fingerprint(), esk)] + encrypted
elif hasattr(psswd, 'encode'):
psswd = psswd.encode('utf-8')
s2k = OpenPGP.S2K(Crypto.Random.new().read(10))
packet_cipher = cipher(s2k.make_key(psswd, key_bytes))(None)
esk = self._block_pad_unpad(key_block_bytes, pack('!B', symmetric_algorithm) + key, lambda x: packet_cipher.encrypt(x))
encrypted = [OpenPGP.SymmetricSessionKeyPacket(s2k, esk, symmetric_algorithm)] + encrypted
return OpenPGP.Message(encrypted)
def decrypt(self, packet):
if isinstance(packet, list):
packet = OpenPGP.Message(packet)
elif not isinstance(packet, OpenPGP.Message):
packet = OpenPGP.Message.parse(packet)
if isinstance(packet, OpenPGP.SecretKeyPacket) or isinstance(
packet, rsa.RSAPrivateKey) or (
hasattr(packet, '__getitem__')
and isinstance(packet[0], OpenPGP.SecretKeyPacket)):
keys = packet
else:
keys = self._key
self._message = packet
if not keys or not self._message:
return None # Missing some data
if not isinstance(keys, rsa.RSAPrivateKey):
keys = self.__class__(keys)
for p in self._message:
if isinstance(p, OpenPGP.AsymmetricSessionKeyPacket):
if isinstance(keys, rsa.RSAPrivateKey):
sk = self.try_decrypt_session(keys, p.encrypted_data[2:])
elif len(p.keyid.replace('0', '')) < 1:
for k in keys.key:
sk = self.try_decrypt_session(
self.convert_private_key(k), p.encyrpted_data[2:])
if sk:
break
else:
key = keys.private_key(p.keyid)
sk = self.try_decrypt_session(key, p.encrypted_data[2:])
if not sk:
continue
r = self.decrypt_packet(self.encrypted_data(), sk[0], sk[1])
if r:
return r
return None # Failed
def testSign(self):
m = 'Foobar'
auth = 'jdoe:secret'.encode('base64')
s, result = self.client.acquireSignature(m, auth)
self.assertEqual(result, 'ok')
self.assertTrue(OpenPGP.verifySignature(m, s, self.caKey))
def test_unarmor_one(self):
armored = self.readLocalFile('/data/helloKey.asc')
_, unarmored = OpenPGP.unarmor(armored)[0]
message = OpenPGP.Message.parse(unarmored)
nose.tools.assert_equal(message[0].fingerprint(),
'421F28FEAAD222F856C8FFD5D4D54EA16F87040E')
def sign(self, packet, hash='SHA256', keyid=None):
if self._key and not isinstance(packet, OpenPGP.Packet) and not isinstance(packet, OpenPGP.Message):
packet = OpenPGP.LiteralDataPacket(packet)
else:
packet = self._parse_packet(packet)
if isinstance(packet, OpenPGP.SecretKeyPacket) or isinstance(packet, RSAPrivateKey) or isinstance(packet, DSAPrivateKey) or (hasattr(packet, '__getitem__') and isinstance(packet[0], OpenPGP.SecretKeyPacket)):
key = packet
message = self._message
else:
key = self._key
message = packet
if not key or not message:
return None # Missing some data
if isinstance(message, OpenPGP.Message):
message = message.signature_and_data()[1]
if not (isinstance(key, RSAPrivateKey) or isinstance(key, DSAPrivateKey)):
key = self.__class__(key)
if not keyid:
keyid = key.key().fingerprint()[-16:]
key = key.private_key(keyid)
key_algorithm = None
if isinstance(key, RSAPrivateKey):
key_algorithm = 'RSA'
elif isinstance(key, DSAPrivateKey):
key_algorithm = 'DSA'
sig = OpenPGP.SignaturePacket(message, key_algorithm, hash.upper())
if keyid:
sig.hashed_subpackets.append(OpenPGP.SignaturePacket.IssuerPacket(keyid))
def doDSA(h, m):
ctx = key.signer(h())
ctx.update(m)
return list(self._decode_dsa_der(ctx.finalize()))
def doRSA(h, m):
ctx = key.signer(padding.PKCS1v15(), h())
ctx.update(m)
return [ctx.finalize()]
sig.sign_data({'RSA': {
'MD5': lambda m: doRSA(hashes.MD5, m),
'RIPEMD160': lambda m: doRSA(hashes.RIPEMD160, m),
'SHA1': lambda m: doRSA(hashes.SHA1, m),
'SHA224': lambda m: doRSA(hashes.SHA224, m),
'SHA256': lambda m: doRSA(hashes.SHA256, m),
'SHA384': lambda m: doRSA(hashes.SHA384, m),
'SHA512': lambda m: doRSA(hashes.SHA512, m)
}, 'DSA': {
'MD5': lambda m: doDSA(hashes.MD5, m),
'RIPEMD160': lambda m: doDSA(hashes.RIPME160, m),
'SHA1': lambda m: doDSA(hashes.SHA1, m),
'SHA224': lambda m: doDSA(hashes.SHA224, m),
'SHA256': lambda m: doDSA(hashes.SHA256, m),
'SHA384': lambda m: doDSA(hashes.SHA384, m),
'SHA512': lambda m: doDSA(hashes.SHA512, m)
}})
return OpenPGP.Message([sig, message])
def test_name_comment_email_id(self):
packet = OpenPGP.UserIDPacket(
"Human Name (With Comment) <*****@*****.**>")
nose.tools.assert_equal(packet.name, "Human Name")
nose.tools.assert_equal(packet.comment, "With Comment")
nose.tools.assert_equal(packet.email, "*****@*****.**")
def test_email_id(self):
packet = OpenPGP.UserIDPacket("<*****@*****.**>")
nose.tools.assert_equal(packet.name, None)
nose.tools.assert_equal(packet.comment, None)
nose.tools.assert_equal(packet.email, "*****@*****.**")
def test_name_id(self):
packet = OpenPGP.UserIDPacket("Human Name")
nose.tools.assert_equal(packet.name, "Human Name")
nose.tools.assert_equal(packet.comment, None)
nose.tools.assert_equal(packet.email, None)
import OpenPGP
import OpenPGP.Crypto
import sys
wkey = OpenPGP.Message.parse(open('key', 'rb').read())[0]
data = OpenPGP.LiteralDataPacket('This is text.', 'u', 'stuff.txt')
encrypt = OpenPGP.Crypto.Wrapper(data)
encrypted = encrypt.encrypt([wkey])
print list(encrypted)
# Now decrypt it with the same key
decryptor = OpenPGP.Crypto.Wrapper(wkey)
decrypted = decryptor.decrypt(encrypted)
print list(decrypted)
def test_unarmor_one(self):
armored = self.readLocalFile("/data/helloKey.asc")
_, unarmored = OpenPGP.unarmor(armored)[0]
message = OpenPGP.Message.parse(unarmored)
nose.tools.assert_equal(message[0].fingerprint(), "421F28FEAAD222F856C8FFD5D4D54EA16F87040E")
def test_enarmor_one(self):
expected = self.readLocalFile("/data/helloKey.asc")
messages = OpenPGP.unarmor(expected) # [(header, data), ...]
header, data = messages[0]
actual = OpenPGP.enarmor(data, headers=[keyValue.split(": ", 1) for keyValue in header.split("\n")])
nose.tools.assert_equal(actual, expected)
import OpenPGP
import OpenPGP.Crypto
import sys
wkey = OpenPGP.Message.parse(open('key').read())[0]
data = OpenPGP.LiteralDataPacket('This is text.', 'u', 'text/plain')
sign = OpenPGP.Crypto.Wrapper(wkey)
m = sign.sign(data)
sys.stdout.write(m.to_bytes())
import Crypto.PublicKey.RSA
import Crypto.Util.number
import OpenPGP
import OpenPGP.Crypto
import sys
k = Crypto.PublicKey.RSA.generate(1024)
nkey = OpenPGP.SecretKeyPacket((
Crypto.Util.number.long_to_bytes(k.n),
Crypto.Util.number.long_to_bytes(k.e),
Crypto.Util.number.long_to_bytes(k.d),
Crypto.Util.number.long_to_bytes(k.p),
Crypto.Util.number.long_to_bytes(k.q),
Crypto.Util.number.long_to_bytes(k.u)
))
uid = OpenPGP.UserIDPacket('Test <*****@*****.**>')
wkey = OpenPGP.Crypto.Wrapper(nkey)
m = wkey.sign_key_userid([nkey, uid])
sys.stdout.write(m.to_bytes())
