def testC05DecryptSymmetricCAST(self):
"decrypt_str() symmetric CAST w/integrity"
enc_d = read_test_file(['pgpfiles','enc','sym.cast.cleartext.txt.gpg'])
clrtxt = decrypt_str(enc_d, passphrase='test')
clrmsgs = list_as_signed(clrtxt)
literal_pkt = list_pkts(clrmsgs[0].compressed.body.data)[0]
self.assertEqual(self.lit_data, literal_pkt.body.data)
def testA04DSANativeOnePass(self):
"list: list_as_signed() DSA one-pass signature"
d = read_test_file(['pgpfiles', 'sig', 'sig.DSAELG1.onepass.gpg'])
players = list_as_signed(d)
# looking for players = [signed_msg]
self.assertEqual(SignedMsg, players[0].__class__)
self.assertEqual(1, len(players))
def testA06DSACompressed(self):
"list: list_as_signed() DSA compressed one-pass signature"
d = read_test_file(['pgpfiles', 'sig', 'sig.DSAELG1.comp.gpg'])
players = list_as_signed(d, decompress=True)
# looking for players = [signed_msg], since decompression is automatic
self.assertEqual(SignedMsg, players[0].__class__)
self.assertEqual(1, len(players))
def testF03EncryptPublicKeyID(self):
"encrypt_str()/decrypt_str() ElGamal via key ID"
pubkey_d = read_test_file(['pgpfiles','key','DSAELG1.pub.asc'])
seckey_d = read_test_file(['pgpfiles','key','DSAELG1.sec.asc'])
cphtxt = encrypt_str(self.lit_data, keys=pubkey_d, use_key=[(None,"CB7D6980A1F2BEF6")])
clrtxt = decrypt_str(cphtxt, passphrase="test", keys=seckey_d, decompress=True)
litmsg = list_as_signed(clrtxt)[0] # auto-decompressed above
self.assertEqual(self.lit_data, litmsg.literals[0].body.data)
def testC05DecryptSymmetricCAST(self):
"decrypt_str() symmetric CAST w/integrity"
enc_d = read_test_file(
['pgpfiles', 'enc', 'sym.cast.cleartext.txt.gpg'])
clrtxt = decrypt_str(enc_d, passphrase='test')
clrmsgs = list_as_signed(clrtxt)
literal_pkt = list_pkts(clrmsgs[0].compressed.body.data)[0]
self.assertEqual(self.lit_data, literal_pkt.body.data)
def testC01DecryptDSA(self):
"decrypt_str() DSA AES256 w/integrity"
enc_d = read_test_file(['pgpfiles','enc','pub.elg.aes256.clrtxt.gpg'])
key_d = read_test_file(['pgpfiles','key','DSAELG1.sec.asc'])
clrtxt = decrypt_str(enc_d, passphrase='test', keys=key_d)
compmsg = list_as_signed(clrtxt)[0]
literal_pkt = list_pkts(compmsg.compressed.body.data)[0]
self.assertEqual(self.lit_data, literal_pkt.body.data)
def testC02DecryptDSA_decompression(self):
"decrypt_str() DSA AES256 w/integrity (decompressed)"
enc_d = read_test_file(['pgpfiles','enc','pub.elg.aes256.clrtxt.gpg'])
key_d = read_test_file(['pgpfiles','key','DSAELG1.sec.asc'])
clrtxt = decrypt_str(enc_d, passphrase='test', keys=key_d,
decompress=True)
litmsg = list_as_signed(clrtxt)[0] # no compressed msg to go through
self.assertEqual(self.lit_data, litmsg.literals[0].body.data)
def testA03DSAClearsigned(self):
"list: list_as_signed() DSA clearsigned (ASCII-armored) signature"
d = read_test_file(['pgpfiles', 'sig', 'sig.DSAELG1.clear.asc'])
players = list_as_signed(d)
# looking for players = [([sig], msg)]
self.assertEqual(Signature, players[0][0][0].__class__)
self.assertEqual(True, isinstance(players[0][1], str))
self.assertEqual(1, len(players))
def testA05DSADetached(self):
"list: list_as_signed() DSA detached signature"
d = read_test_file(['pgpfiles', 'sig', 'sig.DSAELG1.detached.gpg'])
det_d = read_test_file(['pgpfiles', 'cleartext.txt'])
players = list_as_signed(d, detached=det_d)
# looking for players = [([sig], msg)]
self.assertEqual(Signature, players[0][0][0].__class__)
self.assertEqual(True, isinstance(players[0][1], str))
self.assertEqual(1, len(players))
def testC01DecryptDSA(self):
"decrypt_str() DSA AES256 w/integrity"
enc_d = read_test_file(
['pgpfiles', 'enc', 'pub.elg.aes256.clrtxt.gpg'])
key_d = read_test_file(['pgpfiles', 'key', 'DSAELG1.sec.asc'])
clrtxt = decrypt_str(enc_d, passphrase='test', keys=key_d)
compmsg = list_as_signed(clrtxt)[0]
literal_pkt = list_pkts(compmsg.compressed.body.data)[0]
self.assertEqual(self.lit_data, literal_pkt.body.data)
def testC03DecryptDSA_armor(self):
"decrypt_str() DSA AES256 w/integrity (armored, decompressed)"
enc_d = read_test_file(['pgpfiles','enc','pub.elg.aes256.clrtxt.gpg'])
key_d = read_test_file(['pgpfiles','key','DSAELG1.sec.asc'])
clrtxt = decrypt_str(enc_d, passphrase='test', keys=key_d,
decompress=True, armor=True)
self.assertEqual(True, looks_armored(clrtxt)) # check armoring
litmsg = list_as_signed(clrtxt)[0]
self.assertEqual(self.lit_data, litmsg.literals[0].body.data)
def testC04DecryptRSA(self):
"decrypt_str() RSA w/integrity"
lit_data = "My secret message."
enc_d = read_test_file(['pgpfiles','enc','sap.2DSAELG1RSA.nocomp.gpg'])
key_d = read_test_file(['pgpfiles','key','RSA1.sec.asc'])
clrtxt = decrypt_str(enc_d, passphrase='test', keys=key_d)
clrmsgs = list_as_signed(clrtxt)
literal_pkt = clrmsgs[0].literals[0]
self.assertEqual(lit_data, literal_pkt.body.data)
def testC04DecryptRSA(self):
"decrypt_str() RSA w/integrity"
lit_data = "My secret message."
enc_d = read_test_file(
['pgpfiles', 'enc', 'sap.2DSAELG1RSA.nocomp.gpg'])
key_d = read_test_file(['pgpfiles', 'key', 'RSA1.sec.asc'])
clrtxt = decrypt_str(enc_d, passphrase='test', keys=key_d)
clrmsgs = list_as_signed(clrtxt)
literal_pkt = clrmsgs[0].literals[0]
self.assertEqual(lit_data, literal_pkt.body.data)
def testC02DecryptDSA_decompression(self):
"decrypt_str() DSA AES256 w/integrity (decompressed)"
enc_d = read_test_file(
['pgpfiles', 'enc', 'pub.elg.aes256.clrtxt.gpg'])
key_d = read_test_file(['pgpfiles', 'key', 'DSAELG1.sec.asc'])
clrtxt = decrypt_str(enc_d,
passphrase='test',
keys=key_d,
decompress=True)
litmsg = list_as_signed(clrtxt)[0] # no compressed msg to go through
self.assertEqual(self.lit_data, litmsg.literals[0].body.data)
def testC03DecryptDSA_armor(self):
"decrypt_str() DSA AES256 w/integrity (armored, decompressed)"
enc_d = read_test_file(
['pgpfiles', 'enc', 'pub.elg.aes256.clrtxt.gpg'])
key_d = read_test_file(['pgpfiles', 'key', 'DSAELG1.sec.asc'])
clrtxt = decrypt_str(enc_d,
passphrase='test',
keys=key_d,
decompress=True,
armor=True)
self.assertEqual(True, looks_armored(clrtxt)) # check armoring
litmsg = list_as_signed(clrtxt)[0]
self.assertEqual(self.lit_data, litmsg.literals[0].body.data)
def testF03EncryptPublicKeyID(self):
"encrypt_str()/decrypt_str() ElGamal via key ID"
pubkey_d = read_test_file(['pgpfiles', 'key', 'DSAELG1.pub.asc'])
seckey_d = read_test_file(['pgpfiles', 'key', 'DSAELG1.sec.asc'])
cphtxt = encrypt_str(self.lit_data,
keys=pubkey_d,
use_key=[(None, "CB7D6980A1F2BEF6")])
clrtxt = decrypt_str(cphtxt,
passphrase="test",
keys=seckey_d,
decompress=True)
litmsg = list_as_signed(clrtxt)[0] # auto-decompressed above
self.assertEqual(self.lit_data, litmsg.literals[0].body.data)
def testE05SignBinaryAsStringUsingUID(self):
"sign_str()/verify_str() check literal data options"
lit_d = read_test_file(['pgpfiles','cleartext.txt'])
seckey_d = read_test_file(['pgpfiles','key','DSAELG1.sec.asc'])
pubkey_d = read_test_file(['pgpfiles','key','DSAELG1.pub.asc'])
signed = sign_str(0x00, seckey_d, target=lit_d,
use_userid=(None,'Tester'),
passphrase='test',
lit_filename='testfilename',
lit_modified=100)
verified = verify_str(signed, pubkey_d) # verified strips sigs..
literal_body = list_as_signed(verified)[0].literals[0].body
self.assertEqual('b', literal_body.format)
self.assertEqual(lit_d, literal_body.data)
self.assertEqual('testfilename', literal_body.filename)
self.assertEqual(100, literal_body.modified)
def testE04SignSubkey(self):
"sign_str()/verify_str() subkey direct (0x1F) w/ lots of subpackets"
seckey_d = read_test_file(['pgpfiles', 'key', 'DSAELG1.sec.asc'])
pubkey_d = read_test_file(['pgpfiles', 'key', 'DSAELG1.pub.asc'])
keyid = "0CFC2B6DCC079DF3"
opts = {
'use_key': (None, keyid),
'passphrase': "test",
'target': pubkey_d,
'target_key': (None, "CB7D6980A1F2BEF6"),
'sig_signerid': keyid,
'sig_created': 100,
'sig_expires': 4294967295,
'sig_keyexpires': 4294967200,
'sig_revoker':
(0x80, 1, "AB06532F70BD5CD68978D0181AC964878A17BAC6"),
#'sig_note':"n1@test::v1 ,, n2@test:: v2,,n3@test:: v3 ",
'sig_note': [("n1@test", "v1"), ("n2@test", "v2"),
("n3@test", "v3")],
'sig_policyurl': "http://policy.com"
}
#keymsg = sign_str(0x1F, seckey_d, **opts)
signed = sign_str(0x1F, seckey_d, **opts)
keymsg = list_as_signed(signed)[0]
sigpkt = keymsg._b_subkeys['CB7D6980A1F2BEF6'].local_direct[0]
# the subpkt order is determined by their order of appendage in
# sign_str() which isn't important, it's just convenient for testing
h = sigpkt.body.hashed_subpkts
[signerid, created, sig_exp, key_exp, n1, n2, n3, url, revoker] = h
self.assertEqual((0x10, keyid), (signerid.type, signerid.value))
self.assertEqual((0x02, 100), (created.type, created.value))
self.assertEqual((0x03, 4294967295), (sig_exp.type, sig_exp.value))
self.assertEqual((0x09, 4294967200), (key_exp.type, key_exp.value))
self.assertEqual((0x14, "n1@test", "v1"),
(n1.type, n1.value[1], n1.value[2]))
self.assertEqual((0x14, "n2@test", "v2"),
(n2.type, n2.value[1], n2.value[2]))
self.assertEqual((0x14, "n3@test", "v3"),
(n3.type, n3.value[1], n3.value[2]))
self.assertEqual((0x1A, "http://policy.com"), (url.type, url.value))
self.assertEqual(
(0x0C, (128, 1, "AB06532F70BD5CD68978D0181AC964878A17BAC6")),
(revoker.type, revoker.value))
# verify new sig (everything in signed is verified against pubkey_d)
verified = verify_str(signed, pubkey_d)
self.assertEqual(verified, signed)
def testE05SignBinaryAsStringUsingUID(self):
"sign_str()/verify_str() check literal data options"
lit_d = read_test_file(['pgpfiles', 'cleartext.txt'])
seckey_d = read_test_file(['pgpfiles', 'key', 'DSAELG1.sec.asc'])
pubkey_d = read_test_file(['pgpfiles', 'key', 'DSAELG1.pub.asc'])
signed = sign_str(0x00,
seckey_d,
target=lit_d,
use_userid=(None, 'Tester'),
passphrase='test',
lit_filename='testfilename',
lit_modified=100)
verified = verify_str(signed, pubkey_d) # verified strips sigs..
literal_body = list_as_signed(verified)[0].literals[0].body
self.assertEqual('b', literal_body.format)
self.assertEqual(lit_d, literal_body.data)
self.assertEqual('testfilename', literal_body.filename)
self.assertEqual(100, literal_body.modified)
def testF06EncryptMultiplePublicUserID(self):
"encrypt_str()/decrypt_str() multiple public (no compression) via user ID"
pubkey1_d = read_test_file(['pgpfiles','key','DSAELG1.pub.asc'])
seckey1_d = read_test_file(['pgpfiles','key','DSAELG1.sec.asc'])
#pubkey2_d = read_test_file(['pgpfiles','key','DSAELG3.pub.asc'])
#seckey2_d = read_test_file(['pgpfiles','key','DSAELG3.sec.asc'])
pubkey3_d = read_test_file(['pgpfiles','key','RSA1.pub.asc'])
seckey3_d = read_test_file(['pgpfiles','key','RSA1.sec.asc'])
pubkey_d = linesep.join([pubkey1_d, pubkey3_d])
uids = [(None,"Tester"),
#(None,"*****@*****.**"),
(None,"testrsa")]
cphtxt = encrypt_str(self.lit_data, keys=pubkey_d, use_userid=uids)
# they all happen to have the same passphrase
passphrase = "test"
for seckey_d in [seckey1_d, seckey3_d]:
clrtxt = decrypt_str(cphtxt, passphrase="test", keys=seckey_d,
decompress=True)
litmsg = list_as_signed(clrtxt)[0]
self.assertEqual(self.lit_data, litmsg.literals[0].body.data)
def testE04SignSubkey(self):
"sign_str()/verify_str() subkey direct (0x1F) w/ lots of subpackets"
seckey_d = read_test_file(['pgpfiles','key','DSAELG1.sec.asc'])
pubkey_d = read_test_file(['pgpfiles','key','DSAELG1.pub.asc'])
keyid = "0CFC2B6DCC079DF3"
opts = {'use_key':(None, keyid),
'passphrase':"test",
'target':pubkey_d,
'target_key':(None,"CB7D6980A1F2BEF6"),
'sig_signerid':keyid,
'sig_created':100,
'sig_expires':4294967295,
'sig_keyexpires':4294967200,
'sig_revoker':(0x80,1,"AB06532F70BD5CD68978D0181AC964878A17BAC6"),
#'sig_note':"n1@test::v1 ,, n2@test:: v2,,n3@test:: v3 ",
'sig_note':[("n1@test","v1"),("n2@test","v2"),("n3@test","v3")],
'sig_policyurl':"http://policy.com"}
#keymsg = sign_str(0x1F, seckey_d, **opts)
signed = sign_str(0x1F, seckey_d, **opts)
keymsg = list_as_signed(signed)[0]
sigpkt = keymsg._b_subkeys['CB7D6980A1F2BEF6'].local_direct[0]
# the subpkt order is determined by their order of appendage in
# sign_str() which isn't important, it's just convenient for testing
h = sigpkt.body.hashed_subpkts
[signerid, created, sig_exp, key_exp, n1, n2, n3, url, revoker] = h
self.assertEqual((0x10, keyid), (signerid.type, signerid.value))
self.assertEqual((0x02, 100), (created.type, created.value))
self.assertEqual((0x03, 4294967295), (sig_exp.type, sig_exp.value))
self.assertEqual((0x09, 4294967200), (key_exp.type, key_exp.value))
self.assertEqual((0x14, "n1@test", "v1"), (n1.type, n1.value[1], n1.value[2]))
self.assertEqual((0x14, "n2@test", "v2"), (n2.type, n2.value[1], n2.value[2]))
self.assertEqual((0x14, "n3@test", "v3"), (n3.type, n3.value[1], n3.value[2]))
self.assertEqual((0x1A, "http://policy.com"), (url.type, url.value))
self.assertEqual((0x0C, (128, 1, "AB06532F70BD5CD68978D0181AC964878A17BAC6")), (revoker.type, revoker.value))
# verify new sig (everything in signed is verified against pubkey_d)
verified = verify_str(signed, pubkey_d)
self.assertEqual(verified, signed)
def testF06EncryptMultiplePublicUserID(self):
"encrypt_str()/decrypt_str() multiple public (no compression) via user ID"
pubkey1_d = read_test_file(['pgpfiles', 'key', 'DSAELG1.pub.asc'])
seckey1_d = read_test_file(['pgpfiles', 'key', 'DSAELG1.sec.asc'])
#pubkey2_d = read_test_file(['pgpfiles','key','DSAELG3.pub.asc'])
#seckey2_d = read_test_file(['pgpfiles','key','DSAELG3.sec.asc'])
pubkey3_d = read_test_file(['pgpfiles', 'key', 'RSA1.pub.asc'])
seckey3_d = read_test_file(['pgpfiles', 'key', 'RSA1.sec.asc'])
pubkey_d = linesep.join([pubkey1_d, pubkey3_d])
uids = [
(None, "Tester"),
#(None,"*****@*****.**"),
(None, "testrsa")
]
cphtxt = encrypt_str(self.lit_data, keys=pubkey_d, use_userid=uids)
# they all happen to have the same passphrase
passphrase = "test"
for seckey_d in [seckey1_d, seckey3_d]:
clrtxt = decrypt_str(cphtxt,
passphrase="test",
keys=seckey_d,
decompress=True)
litmsg = list_as_signed(clrtxt)[0]
self.assertEqual(self.lit_data, litmsg.literals[0].body.data)
def testA02ArmoredRSAPublicKey(self):
"list: list_as_signed() RSA public key, ASCII-armored"
d = read_test_file(['pgpfiles', 'key', 'RSA1.pub.gpg'])
players = list_as_signed(d)
self.assertEqual(PublicKeyMsg, players[0].__class__)
self.assertEqual(1, len(players))
def testB05VerifyKey(self):
"verify_str() verify local key sigs (headers lost in armored output)"
key_d = read_test_file(['pgpfiles', 'key', 'DSAELG1.pub.asc'])
verified = verify_str(key_d, key_d)
self.assertEqual(list_as_signed(key_d), list_as_signed(verified))
def testB05VerifyKey(self):
"verify_str() verify local key sigs (headers lost in armored output)"
key_d = read_test_file(['pgpfiles','key','DSAELG1.pub.asc'])
verified = verify_str(key_d, key_d)
self.assertEqual(list_as_signed(key_d), list_as_signed(verified))
def testF05EncryptSymmetric(self):
"encrypt_str()/decrypt_str() symmetric default"
cphtxt = encrypt_str(self.lit_data, passphrase="test")
clrtxt = decrypt_str(cphtxt, passphrase="test", decompress=True)
litmsg = list_as_signed(clrtxt)[0] # auto-decompressed above
self.assertEqual(self.lit_data, litmsg.literals[0].body.data)
def testA01NativeDSAPublicKey(self):
"list: list_as_signed() DSA public key"
d = read_test_file(['pgpfiles', 'key', 'DSAELG1.pub.gpg'])
players = list_as_signed(d)
self.assertEqual(PublicKeyMsg, players[0].__class__)
self.assertEqual(1, len(players))
def testF05EncryptSymmetric(self):
"encrypt_str()/decrypt_str() symmetric default"
cphtxt = encrypt_str(self.lit_data, passphrase="test")
clrtxt = decrypt_str(cphtxt, passphrase="test", decompress=True)
litmsg = list_as_signed(clrtxt)[0] # auto-decompressed above
self.assertEqual(self.lit_data, litmsg.literals[0].body.data)
