Exemplo n.º 1
0
    def test_parse_linus_binary(self):
        with open('linus.gpg', 'rb') as keyfile:
            rawdata = keyfile.read()
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(44, len(packets))
        seen = 0
        for packet in packets:
            # all 44 packets are of the known 'old' variety
            self.assertFalse(packet.new)
            if isinstance(packet, SignaturePacket):
                # a random signature plucked off the key
                if packet.key_id == 0xE7BFC8EC95861109:
                    seen += 1
                    self.check_sig_packet(packet, 540, 4, 0x10, 1319560576,
                            0xE7BFC8EC95861109, 1, 8)
                    self.assertEqual(2, len(packet.subpackets))
                # a particularly dastardly sig- a ton of hashed sub parts,
                # this is the "positive certification packet"
                elif packet.key_id == 0x79BE3E4300411886 and \
                        packet.raw_sig_type == 0x13:
                    seen += 1
                    self.check_sig_packet(packet, 312, 4, 0x13, 1316554898,
                            0x79BE3E4300411886, 1, 2)
                    self.assertEqual(8, len(packet.subpackets))
                # another sig from key above, the "subkey binding sig"
                elif packet.key_id == 0x79BE3E4300411886 and \
                        packet.raw_sig_type == 0x18:
                    seen += 1
                    self.check_sig_packet(packet, 287, 4, 0x18, 1316554898,
                            0x79BE3E4300411886, 1, 2)
                    self.assertEqual(3, len(packet.subpackets))

        self.assertEqual(3, seen)
Exemplo n.º 2
0
    def test_parse_v3_pubkeys(self):
        '''Two older version 3 public keys.'''
        rawdata = self.load_data('v3pubkeys.gpg')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(2, len(packets))

        packet = packets[0]
        self.assertTrue(isinstance(packet, PublicKeyPacket))
        self.assertEqual(1, packet.raw_pub_algorithm)
        self.assertEqual("rsa", packet.pub_algorithm_type)
        self.assertEqual(944849149, packet.raw_creation_time)
        self.assertIsNone(packet.expiration_time)
        self.assertIsNotNone(packet.modulus)
        self.assertEqual(2048, packet.modulus_bitlen)
        self.assertIsNotNone(packet.exponent)
        self.assertEqual(b"3FC0BF6B", packet.key_id)
        self.assertEqual(b"7D263C88A1AB7737E31150CB4F3A211A",
                packet.fingerprint)

        packet = packets[1]
        self.assertTrue(isinstance(packet, PublicKeyPacket))
        self.assertEqual(1, packet.raw_pub_algorithm)
        self.assertEqual("rsa", packet.pub_algorithm_type)
        self.assertEqual(904151571, packet.raw_creation_time)
        self.assertIsNone(packet.expiration_time)
        self.assertIsNotNone(packet.modulus)
        self.assertEqual(1024, packet.modulus_bitlen)
        self.assertIsNotNone(packet.exponent)
        self.assertEqual(b"3DDE776D", packet.key_id)
        self.assertEqual(b"48A4F9F891F093019BC7FC532A3C5692",
                packet.fingerprint)
Exemplo n.º 3
0
    def test_parse_v3_pubkeys(self):
        '''Two older version 3 public keys.'''
        rawdata = self.load_data('v3pubkeys.gpg')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(2, len(packets))

        packet = packets[0]
        self.assertTrue(isinstance(packet, PublicKeyPacket))
        self.assertEqual(1, packet.raw_pub_algorithm)
        self.assertEqual("rsa", packet.pub_algorithm_type)
        self.assertEqual(944849149, packet.raw_creation_time)
        self.assertIsNone(packet.expiration_time)
        self.assertIsNotNone(packet.modulus)
        self.assertEqual(2048, packet.modulus_bitlen)
        self.assertIsNotNone(packet.exponent)
        self.assertEqual(b"3FC0BF6B", packet.key_id)
        self.assertEqual(b"7D263C88A1AB7737E31150CB4F3A211A",
                packet.fingerprint)

        packet = packets[1]
        self.assertTrue(isinstance(packet, PublicKeyPacket))
        self.assertEqual(1, packet.raw_pub_algorithm)
        self.assertEqual("rsa", packet.pub_algorithm_type)
        self.assertEqual(904151571, packet.raw_creation_time)
        self.assertIsNone(packet.expiration_time)
        self.assertIsNotNone(packet.modulus)
        self.assertEqual(1024, packet.modulus_bitlen)
        self.assertIsNotNone(packet.exponent)
        self.assertEqual(b"3DDE776D", packet.key_id)
        self.assertEqual(b"48A4F9F891F093019BC7FC532A3C5692",
                packet.fingerprint)
Exemplo n.º 4
0
    def test_parse_encrypted(self):
        rawdata = self.load_data("v4_secret_encrypted.gpg")
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(7, len(packets))
        subs_seen = 0
        for packet in packets:
            self.assertFalse(packet.new)

            if isinstance(packet, SecretSubkeyPacket):
                subs_seen += 1
                if subs_seen == 1:  # elg packet
                    self.assertEqual("elg", packet.pub_algorithm_type)
                    self.assertEqual(254, packet.s2k_id)
                    self.assertEqual("Iterated and Salted S2K", packet.s2k_type)
                    self.assertEqual("8d 89 bd df 01 0e 22 cd", packet.s2k_iv)
                elif subs_seen == 2:  # rsa packet
                    self.assertEqual("rsa", packet.pub_algorithm_type)
                    self.assertEqual(254, packet.s2k_id)
                    self.assertEqual("Iterated and Salted S2K", packet.s2k_type)
                    self.assertEqual("09 97 6b f5 d4 28 41 1d", packet.s2k_iv)
            elif isinstance(packet, SecretKeyPacket):
                self.assertEqual("dsa", packet.pub_algorithm_type)
                self.assertEqual(254, packet.s2k_id)
                self.assertEqual("Iterated and Salted S2K", packet.s2k_type)
                self.assertEqual("CAST5", packet.s2k_cipher)
                self.assertEqual("SHA1", packet.s2k_hash)
                self.assertEqual("c3 87 eb ca 9b ce bc 78", packet.s2k_iv)
Exemplo n.º 5
0
    def test_parse_linus_binary(self):
        with open('linus.gpg', 'rb') as keyfile:
            rawdata = keyfile.read()
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(44, len(packets))
        seen = 0
        for packet in packets:
            # all 44 packets are of the known 'old' variety
            self.assertFalse(packet.new)
            if isinstance(packet, SignaturePacket):
                # a random signature plucked off the key
                if packet.key_id == 0xE7BFC8EC95861109:
                    seen += 1
                    self.check_sig_packet(packet, 540, 4, 0x10, 1319560576,
                                          0xE7BFC8EC95861109, 1, 8)
                    self.assertEqual(2, len(packet.subpackets))
                # a particularly dastardly sig- a ton of hashed sub parts,
                # this is the "positive certification packet"
                elif packet.key_id == 0x79BE3E4300411886 and \
                        packet.raw_sig_type == 0x13:
                    seen += 1
                    self.check_sig_packet(packet, 312, 4, 0x13, 1316554898,
                                          0x79BE3E4300411886, 1, 2)
                    self.assertEqual(8, len(packet.subpackets))
                # another sig from key above, the "subkey binding sig"
                elif packet.key_id == 0x79BE3E4300411886 and \
                        packet.raw_sig_type == 0x18:
                    seen += 1
                    self.check_sig_packet(packet, 287, 4, 0x18, 1316554898,
                                          0x79BE3E4300411886, 1, 2)
                    self.assertEqual(3, len(packet.subpackets))

        self.assertEqual(3, seen)
Exemplo n.º 6
0
 def signature(self):
     try:
         data = b64decode(self.pgp_signature)
     except TypeError:
         return None
     data = BinaryData(data)
     packets = list(data.packets())
     return packets[0]
Exemplo n.º 7
0
    def test_parse_partial_length(self):
        '''This file contains an encrypted message with a Partial Body Length header
           Reference: http://tools.ietf.org/html/rfc4880#section-4.2.2.4
        '''

        rawdata = self.load_data('partial_length.gpg')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(2, len(packets))
Exemplo n.º 8
0
    def test_parse_partial_length(self):
        '''This file contains an encrypted message with a Partial Body Length header
           Reference: http://tools.ietf.org/html/rfc4880#section-4.2.2.4
        '''

        rawdata = self.load_data('partial_length.gpg')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(2, len(packets))
Exemplo n.º 9
0
 def signature(self):
     try:
         data = b64decode(self.pgp_signature.encode('utf-8'))
     except TypeError:
         return None
     if not data:
         return None
     data = BinaryData(data)
     packets = list(data.packets())
     return packets[0]
Exemplo n.º 10
0
    def test_parse_plain(self):
        """ The raw values below were extracted from the c version of pgpdump.
             The hex strings it outputs were converted to base 10 by running the
             following function over the hex strings:
                def to_int(x):
                    return  int(x.replace(' ', ''), 16)
        """
        rawdata = self.load_data("v4_secret_plain.gpg")
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(7, len(packets))
        subs_seen = 0
        for packet in packets:
            self.assertFalse(packet.new)

            if isinstance(packet, SecretSubkeyPacket):
                subs_seen += 1
                if subs_seen == 1:  # elg packet
                    self.assertEqual("elg", packet.pub_algorithm_type)
                    self.assertEqual(0, packet.s2k_id)
                    self.assertEqual(None, packet.s2k_type)
                    self.assertEqual(None, packet.s2k_iv)
                    self.assertEqual(
                        245799026332407193298181926223748572866928987611495184689013385965880161244176879821250061522687647728L,
                        packet.exponent_x,
                    )
                elif subs_seen == 2:  # rsa packet
                    self.assertEqual("rsa", packet.pub_algorithm_type)
                    self.assertEqual(0, packet.s2k_id)
                    self.assertEqual(None, packet.s2k_type)
                    self.assertEqual(None, packet.s2k_iv)
                    self.assertEqual(
                        107429307998432888320715351604215972074903508478185926034856042440678824041847327442082101397552291647796540657257050768251344941490371163761048934745124363183224819621105784780195398083026664006729876758821509430352212953204518272377415915285011886868211417421097179985188014641310204357388385968166040278287L,
                        packet.multiplicative_inverse,
                    )
                    self.assertEqual(
                        139930219416447408374822893460828502304441966752753468842648203646336195082149424690339775194932419616945814365656771053789999508162542355224095838373016952414720809190039261860912609841054241835835137530162417625471114503804567967161522096406622711734972153324109508774000862492521907132111400296639152885151L,
                        packet.prime_p,
                    )
                    self.assertEqual(
                        141774976438365791329330227605232641244334061384594969589427240157587195987726021563323880620442249788289724672124037112182500862823754846020398652238714637523098123565121790819658975965315629614215592460191153065569430777288475743983312129144619017542854009503581558744199305796137178366407180728113362644607L,
                        packet.prime_q,
                    )
                    self.assertEqual(
                        5830467418164177455383939797360032476940913805978768568081128075462505586965694225559897974113088818228809697270431492119090365699278285350171676334156873270109344274747057694689185206358606371235913423003163252354603704380371252575866102476793736443620998412227609599802054206292004785471167177881398711806191315950196087041018693839148033680564198494910540148825273531803832541184563811332315506727878483469747798396155096313345751606322830230368849084875744911041500024805242117661173352379509490605300753957220916597285056567409410296154792321206401452887335121085203916552891062930596871199021743741984622581173L,
                        packet.exponent_d,
                    )
            elif isinstance(packet, SecretKeyPacket):
                self.assertEqual("dsa", packet.pub_algorithm_type)
                self.assertEqual(254, packet.s2k_id)
                self.assertEqual("GnuPG S2K", packet.s2k_type)
                self.assertEqual("CAST5", packet.s2k_cipher)
                self.assertEqual("SHA1", packet.s2k_hash)
                self.assertEqual(None, packet.s2k_iv)
Exemplo n.º 11
0
    def test_parse_linus_binary(self):
        rawdata = self.load_data("linus.gpg")
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(44, len(packets))
        seen = 0
        for packet in packets:
            # all 44 packets are of the known 'old' variety
            self.assertFalse(packet.new)

            if isinstance(packet, SignaturePacket):
                # a random signature plucked off the key
                if packet.key_id == b"E7BFC8EC95861109":
                    seen += 1
                    self.check_sig_packet(packet, 540, 4, 0x10, 1319560576, b"E7BFC8EC95861109", 1, 8)
                    self.assertEqual(2, len(packet.subpackets))
                # a particularly dastardly sig- a ton of hashed sub parts,
                # this is the "positive certification packet"
                elif packet.key_id == b"79BE3E4300411886" and packet.raw_sig_type == 0x13:
                    seen += 1
                    self.check_sig_packet(packet, 312, 4, 0x13, 1316554898, b"79BE3E4300411886", 1, 2)
                    self.assertEqual(8, len(packet.subpackets))
                # another sig from key above, the "subkey binding sig"
                elif packet.key_id == b"79BE3E4300411886" and packet.raw_sig_type == 0x18:
                    seen += 1
                    self.check_sig_packet(packet, 287, 4, 0x18, 1316554898, b"79BE3E4300411886", 1, 2)
                    self.assertEqual(3, len(packet.subpackets))

            elif isinstance(packet, PublicSubkeyPacket):
                seen += 1
                self.assertEqual(4, packet.pubkey_version)
                self.assertEqual(1316554898, packet.raw_creation_time)
                self.assertEqual(1, packet.raw_pub_algorithm)
                self.assertIsNotNone(packet.modulus)
                self.assertEqual(65537, packet.exponent)
                self.assertEqual(b"012F54CA", packet.fingerprint[32:])

            elif isinstance(packet, PublicKeyPacket):
                seen += 1
                self.assertEqual(4, packet.pubkey_version)
                self.assertEqual(1316554898, packet.raw_creation_time)
                self.assertEqual(1, packet.raw_pub_algorithm)
                self.assertEqual("RSA Encrypt or Sign", packet.pub_algorithm)
                self.assertIsNotNone(packet.modulus)
                self.assertEqual(65537, packet.exponent)
                self.assertEqual(b"ABAF11C65A2970B130ABE3C479BE3E4300411886", packet.fingerprint)
                self.assertEqual(b"79BE3E4300411886", packet.key_id)

            elif isinstance(packet, UserIDPacket):
                seen += 1
                self.assertEqual("Linus Torvalds", packet.user_name)
                self.assertEqual("*****@*****.**", packet.user_email)

        self.assertEqual(6, seen)
Exemplo n.º 12
0
 def test_parse_single_sig_packet(self):
     base64_sig = b"iEYEABECAAYFAk6A4a4ACgkQXC5GoPU6du1ATACgodGyQne3Rb7"\
             b"/eHBMRdau1KNSgZYAoLXRWt2G2wfp7haTBjJDFXMGsIMi"
     sig = base64.b64decode(base64_sig)
     data = BinaryData(sig)
     packets = list(data.packets())
     self.assertEqual(1, len(packets))
     sig_packet = packets[0]
     self.assertFalse(sig_packet.new)
     self.check_sig_packet(sig_packet, 70, 4, 0, 1317069230,
             0x5C2E46A0F53A76ED, 17, 2)
     self.assertEqual(2, len(sig_packet.subpackets))
Exemplo n.º 13
0
 def test_parse_single_sig_packet(self):
     base64_sig = b"iEYEABECAAYFAk6A4a4ACgkQXC5GoPU6du1ATACgodGyQne3Rb7"\
             b"/eHBMRdau1KNSgZYAoLXRWt2G2wfp7haTBjJDFXMGsIMi"
     sig = base64.b64decode(base64_sig)
     data = BinaryData(sig)
     packets = list(data.packets())
     self.assertEqual(1, len(packets))
     sig_packet = packets[0]
     self.assertFalse(sig_packet.new)
     self.check_sig_packet(sig_packet, 70, 4, 0, 1317069230,
                           0x5C2E46A0F53A76ED, 17, 2)
     self.assertEqual(2, len(sig_packet.subpackets))
Exemplo n.º 14
0
 def test_parse_single_sig_packet(self):
     base64_sig = (
         b"iEYEABECAAYFAk6A4a4ACgkQXC5GoPU6du1ATACgodGyQne3Rb7" b"/eHBMRdau1KNSgZYAoLXRWt2G2wfp7haTBjJDFXMGsIMi"
     )
     sig = base64.b64decode(base64_sig)
     data = BinaryData(sig)
     packets = list(data.packets())
     self.assertEqual(1, len(packets))
     sig_packet = packets[0]
     self.assertFalse(sig_packet.new)
     self.check_sig_packet(sig_packet, 70, 4, 0, 1317069230, b"5C2E46A0F53A76ED", 17, 2)
     self.assertEqual(2, len(sig_packet.subpackets))
     self.assertEqual(["Signature Creation Time", "Issuer"], [sp.name for sp in sig_packet.subpackets])
Exemplo n.º 15
0
    def test_parse_plain(self):
        '''The raw values below were extracted from the C version of pgpdump.
        The hex strings it outputs were converted to base 10 by running the
        following function over the hex strings:
                def to_int(x):
                    return  int(x.replace(' ', ''), 16)
        '''
        rawdata = self.load_data('v4_secret_plain.gpg')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(7, len(packets))
        subs_seen = 0
        for packet in packets:
            self.assertFalse(packet.new)

            if isinstance(packet, SecretSubkeyPacket):
                subs_seen += 1
                if subs_seen == 1:
                    # elg packet
                    self.assertEqual("elg", packet.pub_algorithm_type)
                    self.assertEqual(0, packet.s2k_id)
                    self.assertEqual(None, packet.s2k_type)
                    self.assertEqual(None, packet.s2k_iv)
                    self.assertEqual(
                        245799026332407193298181926223748572866928987611495184689013385965880161244176879821250061522687647728,
                        packet.exponent_x)
                elif subs_seen == 2:
                    # rsa packet
                    self.assertEqual("rsa", packet.pub_algorithm_type)
                    self.assertEqual(0, packet.s2k_id)
                    self.assertEqual(None, packet.s2k_type)
                    self.assertEqual(None, packet.s2k_iv)
                    self.assertEqual(
                        107429307998432888320715351604215972074903508478185926034856042440678824041847327442082101397552291647796540657257050768251344941490371163761048934745124363183224819621105784780195398083026664006729876758821509430352212953204518272377415915285011886868211417421097179985188014641310204357388385968166040278287,
                        packet.multiplicative_inverse)
                    self.assertEqual(
                        139930219416447408374822893460828502304441966752753468842648203646336195082149424690339775194932419616945814365656771053789999508162542355224095838373016952414720809190039261860912609841054241835835137530162417625471114503804567967161522096406622711734972153324109508774000862492521907132111400296639152885151,
                        packet.prime_p)
                    self.assertEqual(
                        141774976438365791329330227605232641244334061384594969589427240157587195987726021563323880620442249788289724672124037112182500862823754846020398652238714637523098123565121790819658975965315629614215592460191153065569430777288475743983312129144619017542854009503581558744199305796137178366407180728113362644607,
                        packet.prime_q)
                    self.assertEqual(
                        5830467418164177455383939797360032476940913805978768568081128075462505586965694225559897974113088818228809697270431492119090365699278285350171676334156873270109344274747057694689185206358606371235913423003163252354603704380371252575866102476793736443620998412227609599802054206292004785471167177881398711806191315950196087041018693839148033680564198494910540148825273531803832541184563811332315506727878483469747798396155096313345751606322830230368849084875744911041500024805242117661173352379509490605300753957220916597285056567409410296154792321206401452887335121085203916552891062930596871199021743741984622581173,
                        packet.exponent_d)
            elif isinstance(packet, SecretKeyPacket):
                self.assertEqual("dsa", packet.pub_algorithm_type)
                self.assertEqual(254, packet.s2k_id)
                self.assertEqual("GnuPG S2K", packet.s2k_type)
                self.assertEqual("CAST5", packet.s2k_cipher)
                self.assertEqual("SHA1", packet.s2k_hash)
                self.assertEqual(None, packet.s2k_iv)
Exemplo n.º 16
0
    def test_parse_mode_1002(self):
        rawdata = self.load_data('secret_key_mode_1002.bin')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(7, len(packets))

        for packet in packets:
            self.assertFalse(packet.new)

            if isinstance(packet, SecretKeyPacket):
                # this block matches both top-level and subkeys
                self.assertEqual("rsa", packet.pub_algorithm_type)
                self.assertEqual(255, packet.s2k_id)
                self.assertEqual("GnuPG S2K", packet.s2k_type)
                self.assertEqual("Plaintext or unencrypted", packet.s2k_cipher)
                self.assertEqual("Unknown", packet.s2k_hash)
                self.assertEqual(None, packet.s2k_iv)
Exemplo n.º 17
0
    def test_parse_mode_1002(self):
        rawdata = self.load_data('secret_key_mode_1002.bin')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(7, len(packets))

        for packet in packets:
            self.assertFalse(packet.new)

            if isinstance(packet, SecretKeyPacket):
                # this block matches both top-level and subkeys
                self.assertEqual("rsa", packet.pub_algorithm_type)
                self.assertEqual(255, packet.s2k_id)
                self.assertEqual("GnuPG S2K", packet.s2k_type)
                self.assertEqual("Plaintext or unencrypted", packet.s2k_cipher)
                self.assertEqual("Unknown", packet.s2k_hash)
                self.assertEqual(None, packet.s2k_iv)
Exemplo n.º 18
0
    def test_parse_junio(self):
        '''This key has a single user attribute packet, which also uses the new
        size format on the outer packet, which is rare.'''
        rawdata = self.load_data('junio.gpg')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(13, len(packets))
        # 3 user ID packets
        self.assertEqual(4, sum(1 for p in packets if p.raw == 13))
        # 4 signature packets
        self.assertEqual(6, sum(1 for p in packets if p.raw == 2))
        # 1 public subkey packet
        self.assertEqual(1, sum(1 for p in packets if p.raw == 14))
        # 1 user attribute packet
        self.assertEqual(1, sum(1 for p in packets if p.raw == 17))

        # check the user attribute packet
        ua_packet = [p for p in packets if p.raw == 17][0]
        self.assertEqual("jpeg", ua_packet.image_format)
        self.assertEqual(1513, len(ua_packet.image_data))
Exemplo n.º 19
0
    def test_parse_junio(self):
        '''This key has a single user attribute packet, which also uses the new
        size format on the outer packet, which is rare.'''
        rawdata = self.load_data('junio.gpg')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(13, len(packets))
        # 3 user ID packets
        self.assertEqual(4, sum(1 for p in packets if p.raw == 13))
        # 4 signature packets
        self.assertEqual(6, sum(1 for p in packets if p.raw == 2))
        # 1 public subkey packet
        self.assertEqual(1, sum(1 for p in packets if p.raw == 14))
        # 1 user attribute packet
        self.assertEqual(1, sum(1 for p in packets if p.raw == 17))

        # check the user attribute packet
        ua_packet = [p for p in packets if p.raw == 17][0]
        self.assertEqual("jpeg", ua_packet.image_format)
        self.assertEqual(1513, len(ua_packet.image_data))
Exemplo n.º 20
0
    def test_parse_encrypted(self):
        rawdata = self.load_data('v4_secret_encrypted.gpg')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(7, len(packets))
        subs_seen = 0
        for packet in packets:
            self.assertFalse(packet.new)

            if isinstance(packet, SecretSubkeyPacket):
                subs_seen += 1
                if subs_seen == 1:
                    # elg packet
                    self.assertEqual("elg", packet.pub_algorithm_type)
                    self.assertEqual(254, packet.s2k_id)
                    self.assertEqual("Iterated and Salted S2K",
                                     packet.s2k_type)
                    self.assertEqual(
                        bytearray(b"\x8d\x89\xbd\xdf\x01\x0e\x22\xcd"),
                        packet.s2k_iv)
                elif subs_seen == 2:
                    # rsa packet
                    self.assertEqual("rsa", packet.pub_algorithm_type)
                    self.assertEqual(254, packet.s2k_id)
                    self.assertEqual("Iterated and Salted S2K",
                                     packet.s2k_type)
                    self.assertEqual(
                        bytearray(b"\x09\x97\x6b\xf5\xd4\x28\x41\x1d"),
                        packet.s2k_iv)
            elif isinstance(packet, SecretKeyPacket):
                self.assertEqual("dsa", packet.pub_algorithm_type)
                self.assertEqual(254, packet.s2k_id)
                self.assertEqual("Iterated and Salted S2K", packet.s2k_type)
                self.assertEqual("CAST5", packet.s2k_cipher)
                self.assertEqual("SHA1", packet.s2k_hash)
                self.assertEqual(
                    bytearray(b"\xc3\x87\xeb\xca\x9b\xce\xbc\x78"),
                    packet.s2k_iv)
Exemplo n.º 21
0
    def test_parse_dan(self):
        '''This key has DSA and ElGamal keys, which Linus' does not have.'''
        rawdata = self.load_data('dan.gpg')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(9, len(packets))
        # 3 user ID packets
        self.assertEqual(3, sum(1 for p in packets if p.raw == 13))
        # 4 signature packets
        self.assertEqual(4, sum(1 for p in packets if p.raw == 2))

        seen = 0
        for packet in packets:
            self.assertFalse(packet.new)

            if isinstance(packet, PublicSubkeyPacket):
                seen += 1
                self.assertEqual(16, packet.raw_pub_algorithm)
                self.assertEqual("elg", packet.pub_algorithm_type)
                self.assertIsNotNone(packet.prime)
                self.assertIsNone(packet.group_order)
                self.assertIsNotNone(packet.group_gen)
                self.assertIsNotNone(packet.key_value)
                self.assertEqual(b"C3751D38", packet.fingerprint[32:])

            elif isinstance(packet, PublicKeyPacket):
                seen += 1
                self.assertEqual(17, packet.raw_pub_algorithm)
                self.assertEqual("dsa", packet.pub_algorithm_type)
                self.assertIsNotNone(packet.prime)
                self.assertIsNotNone(packet.group_order)
                self.assertIsNotNone(packet.group_gen)
                self.assertIsNotNone(packet.key_value)
                self.assertEqual(b"A5CA9D5515DC2CA73DF748CA5C2E46A0F53A76ED",
                        packet.fingerprint)

        self.assertEqual(2, seen)
Exemplo n.º 22
0
    def test_parse_dan(self):
        '''This key has DSA and ElGamal keys, which Linus' does not have.'''
        rawdata = self.load_data('dan.gpg')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(9, len(packets))
        # 3 user ID packets
        self.assertEqual(3, sum(1 for p in packets if p.raw == 13))
        # 4 signature packets
        self.assertEqual(4, sum(1 for p in packets if p.raw == 2))

        seen = 0
        for packet in packets:
            self.assertFalse(packet.new)

            if isinstance(packet, PublicSubkeyPacket):
                seen += 1
                self.assertEqual(16, packet.raw_pub_algorithm)
                self.assertEqual("elg", packet.pub_algorithm_type)
                self.assertIsNotNone(packet.prime)
                self.assertIsNone(packet.group_order)
                self.assertIsNotNone(packet.group_gen)
                self.assertIsNotNone(packet.key_value)
                self.assertEqual(b"C3751D38", packet.fingerprint[32:])

            elif isinstance(packet, PublicKeyPacket):
                seen += 1
                self.assertEqual(17, packet.raw_pub_algorithm)
                self.assertEqual("dsa", packet.pub_algorithm_type)
                self.assertIsNotNone(packet.prime)
                self.assertIsNotNone(packet.group_order)
                self.assertIsNotNone(packet.group_gen)
                self.assertIsNotNone(packet.key_value)
                self.assertEqual(b"A5CA9D5515DC2CA73DF748CA5C2E46A0F53A76ED",
                        packet.fingerprint)

        self.assertEqual(2, seen)
Exemplo n.º 23
0
    def test_parse_encrypted(self):
        rawdata = self.load_data('v4_secret_encrypted.gpg')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(7, len(packets))
        subs_seen = 0
        for packet in packets:
            self.assertFalse(packet.new)

            if isinstance(packet, SecretSubkeyPacket):
                subs_seen += 1
                if subs_seen == 1:
                    # elg packet
                    self.assertEqual("elg", packet.pub_algorithm_type)
                    self.assertEqual(254, packet.s2k_id)
                    self.assertEqual("Iterated and Salted S2K", packet.s2k_type)
                    self.assertEqual(
                            bytearray(b"\x8d\x89\xbd\xdf\x01\x0e\x22\xcd"),
                            packet.s2k_iv)
                elif subs_seen == 2:
                    # rsa packet
                    self.assertEqual("rsa", packet.pub_algorithm_type)
                    self.assertEqual(254, packet.s2k_id)
                    self.assertEqual("Iterated and Salted S2K", packet.s2k_type)
                    self.assertEqual(
                            bytearray(b"\x09\x97\x6b\xf5\xd4\x28\x41\x1d"),
                            packet.s2k_iv)
            elif isinstance(packet, SecretKeyPacket):
                self.assertEqual("dsa", packet.pub_algorithm_type)
                self.assertEqual(254, packet.s2k_id)
                self.assertEqual("Iterated and Salted S2K", packet.s2k_type)
                self.assertEqual("CAST5", packet.s2k_cipher)
                self.assertEqual("SHA1", packet.s2k_hash)
                self.assertEqual(
                        bytearray(b"\xc3\x87\xeb\xca\x9b\xce\xbc\x78"),
                        packet.s2k_iv)
Exemplo n.º 24
0
def parse_signature(sig_data: bytes) -> Signature:
    date = None
    keyid = None

    try:
        parsed = BinaryData(sig_data)
    except PgpdumpException as e:
        raise SigError(e)

    for x in parsed.packets():
        if x.raw == 2:
            for sub in x.subpackets:
                if sub.subtype == 2:
                    date = datetime.utcfromtimestamp(
                        struct.unpack('>I', sub.data)[0])
                if sub.subtype == 16:
                    keyid = binascii.hexlify(sub.data).decode()

    if keyid is None:
        raise SigError("keyid missing")
    if date is None:
        raise SigError("date missing")

    return Signature(keyid, date)
Exemplo n.º 25
0
 def signature(self):
     if not self.signature_bytes:
         return None
     data = BinaryData(self.signature_bytes)
     packets = list(data.packets())
     return packets[0]
Exemplo n.º 26
0
 def signature(self):
     if not self.signature_bytes:
         return None
     data = BinaryData(self.signature_bytes)
     packets = list(data.packets())
     return SignatureWrapper(packets[0])
Exemplo n.º 27
0
def get_pubkey_id_from_binary(data):
    generator = BinaryData(data)
    for packet in generator.packets():
        if packet.raw == 6:
            return packet.key_id
Exemplo n.º 28
0
    def test_parse_linus_binary(self):
        rawdata = self.load_data('linus.gpg')
        data = BinaryData(rawdata)
        packets = list(data.packets())
        self.assertEqual(44, len(packets))
        seen = 0
        for packet in packets:
            # all 44 packets are of the known 'old' variety
            self.assertFalse(packet.new)

            if isinstance(packet, SignaturePacket):
                # a random signature plucked off the key
                if packet.key_id == b"E7BFC8EC95861109":
                    seen += 1
                    self.check_sig_packet(packet, 540, 4, 0x10, 1319560576,
                            b"E7BFC8EC95861109", 1, 8)
                    self.assertEqual(2, len(packet.subpackets))
                # a particularly dastardly sig- a ton of hashed sub parts,
                # this is the "positive certification packet"
                elif packet.key_id == b"79BE3E4300411886" and \
                        packet.raw_sig_type == 0x13:
                    seen += 1
                    self.check_sig_packet(packet, 312, 4, 0x13, 1316554898,
                            b"79BE3E4300411886", 1, 2)
                    self.assertEqual(8, len(packet.subpackets))
                # another sig from key above, the "subkey binding sig"
                elif packet.key_id == b"79BE3E4300411886" and \
                        packet.raw_sig_type == 0x18:
                    seen += 1
                    self.check_sig_packet(packet, 287, 4, 0x18, 1316554898,
                            b"79BE3E4300411886", 1, 2)
                    self.assertEqual(3, len(packet.subpackets))

            elif isinstance(packet, PublicSubkeyPacket):
                seen += 1
                self.assertEqual(4, packet.pubkey_version)
                self.assertEqual(1316554898, packet.raw_creation_time)
                self.assertEqual(1, packet.raw_pub_algorithm)
                self.assertIsNotNone(packet.modulus)
                self.assertEqual(2048, packet.modulus_bitlen)
                self.assertEqual(65537, packet.exponent)
                self.assertEqual(b"012F54CA", packet.fingerprint[32:])

            elif isinstance(packet, PublicKeyPacket):
                seen += 1
                self.assertEqual(4, packet.pubkey_version)
                self.assertEqual(1316554898, packet.raw_creation_time)
                self.assertEqual(1, packet.raw_pub_algorithm)
                self.assertEqual("RSA Encrypt or Sign", packet.pub_algorithm)
                self.assertIsNotNone(packet.modulus)
                self.assertEqual(2048, packet.modulus_bitlen)
                self.assertEqual(65537, packet.exponent)
                self.assertEqual(b"ABAF11C65A2970B130ABE3C479BE3E4300411886",
                        packet.fingerprint)
                self.assertEqual(b"79BE3E4300411886", packet.key_id)

            elif isinstance(packet, UserIDPacket):
                seen += 1
                self.assertEqual("Linus Torvalds", packet.user_name)
                self.assertEqual("*****@*****.**",
                        packet.user_email)

        self.assertEqual(6, seen)