def test_load(self, packet):
b = binload(packet) + b'\xca\xfe\xba\xbe'
_b = b[:]
p = Packet(_b)
# parsed all bytes
assert _b == b'\xca\xfe\xba\xbe'
# length is computed correctly
assert p.header.length + len(p.header) == len(p)
assert len(p) == len(b) - 4
assert len(p.__bytes__()) == len(b) - 4
# __bytes__ output is correct
assert p.__bytes__() == b[:-4]
# instantiated class is what we expected
if hasattr(p.header, 'version') and (p.header.tag, p.header.version) in _pclasses:
# versioned packet
assert p.__class__.__name__ == _pclasses[(p.header.tag, p.header.version)]
elif (not hasattr(p.header, 'version')) and p.header.tag in _pclasses:
# unversioned packet
assert p.__class__.__name__ in _pclasses[p.header.tag]
else:
# fallback to opaque
assert isinstance(p, Opaque)
def test_load(self, packet):
b = binload(packet) + _trailer
_b = b[:]
p = Packet(_b)
# parsed all bytes
assert _b == _trailer
# length is computed correctly
assert p.header.length + len(p.header) == len(p)
if packet not in ('tests/testdata/packets/11.partial.literal', ):
assert len(p) == len(b) - len(_trailer)
assert len(p.__bytes__()) == len(b) - len(_trailer)
# __bytes__ output is correct
assert p.__bytes__() == b[:-len(_trailer)]
# instantiated class is what we expected
if hasattr(p.header, 'version') and (p.header.tag,
p.header.version) in _pclasses:
# versioned packet
assert p.__class__.__name__ == _pclasses[(p.header.tag,
p.header.version)]
elif (not hasattr(p.header, 'version')) and p.header.tag in _pclasses:
# unversioned packet
assert p.__class__.__name__ in _pclasses[p.header.tag]
else:
# fallback to opaque
assert isinstance(p, Opaque)
# if this is a key, ensure len(p.keymaterial) == len(bytes(p.keymaterial))
if isinstance(p, (PubKeyV4, PubSubKeyV4, PrivKeyV4, PrivSubKeyV4)):
assert len(p.keymaterial) == len(p.keymaterial.__bytes__())
def test_load(self, packet):
if packet in skip_files:
pytest.skip("not implemented yet")
b = binload(packet) + b'\xca\xfe\xba\xbe'
_b = b[:]
p = Packet(_b)
# parsed all bytes
assert _b == b'\xca\xfe\xba\xbe'
# length is computed correctly
assert p.header.length + len(p.header) == len(p)
assert len(p) == len(b) - 4
assert len(p.__bytes__()) == len(b) - 4
# __bytes__ output is correct
assert p.__bytes__() == b[:-4]
# instantiated class is what we expected
if hasattr(p.header, 'version') and (p.header.tag, p.header.version) in _pclasses:
# versioned packet
assert p.__class__.__name__ == _pclasses[(p.header.tag, p.header.version)]
elif (not hasattr(p.header, 'version')) and p.header.tag in _pclasses:
# unversioned packet
assert p.__class__.__name__ in _pclasses[p.header.tag]
else:
# fallback to opaque
assert isinstance(p, Opaque)
# if this is a key, ensure len(p.keymaterial) == len(bytes(p.keymaterial))
if isinstance(p, (PubKeyV4, PubSubKeyV4, PrivKeyV4, PrivSubKeyV4)):
assert len(p.keymaterial) == len(p.keymaterial.__bytes__())
def test_load(self, packet):
b = binload(packet) + _trailer
_b = b[:]
p = Packet(_b)
# parsed all bytes
assert _b == _trailer
# length is computed correctly
assert p.header.length + len(p.header) == len(p)
if packet not in ('tests/testdata/packets/11.partial.literal',):
assert len(p) == len(b) - len(_trailer)
assert len(p.__bytes__()) == len(b) - len(_trailer)
# __bytes__ output is correct
assert p.__bytes__() == b[:-len(_trailer)]
# instantiated class is what we expected
if hasattr(p.header, 'version') and (p.header.tag, p.header.version) in _pclasses:
# versioned packet
assert p.__class__.__name__ == _pclasses[(p.header.tag, p.header.version)]
elif (not hasattr(p.header, 'version')) and p.header.tag in _pclasses:
# unversioned packet
assert p.__class__.__name__ in _pclasses[p.header.tag]
else:
# fallback to opaque
assert isinstance(p, Opaque)
# if this is a key, ensure len(p.keymaterial) == len(bytes(p.keymaterial))
if isinstance(p, (PubKeyV4, PubSubKeyV4, PrivKeyV4, PrivSubKeyV4)):
assert len(p.keymaterial) == len(p.keymaterial.__bytes__())
def fuzz_pkt(slice, val, exc_type):
d = data[:]
d[slice] = val
if exc_type is not None:
with pytest.raises(exc_type):
Packet(d)
else:
Packet(d)
def test_parse_packet_exceptions(self):
# use a signature packet with fuzzed fields to get some exceptions
# original packet is a DSA signature
data = bytearray(
b'\xc2F\x04\x00\x11\x01\x00\x06\x05\x02W\x16\x80\xb0\x00\n\t\x10G\x15FH\x97D\xbc\x0b46\x00'
b'\x9fD\xbc\xd7\x87`\xe0\xfeT\x05\xcd\x82\xf5\x9ae\xa9\xb5\x01ii,\x00\x9d\x14\x0b<)\xb4\xc3'
b'\x81iu\n\xe3W\xe2\x03\xb1\xc3\xd8p\x89W')
def fuzz_pkt(slice, val, exc_type):
d = data[:]
d[slice] = val
if exc_type is not None:
with pytest.raises(exc_type):
Packet(d)
else:
Packet(d)
# ensure the base packet works, first
Packet(data[:])
class WhatException(Exception):
pass
# unexpected signature type
fuzz_pkt(3, 0x7f, PGPError)
# unexpected pubkey algorithm
fuzz_pkt(4, 0x64, PGPError)
# unexpected hash algorithm - does not raise an exception during parsing
fuzz_pkt(5, 0x64, None)
def list_packets_pgpy(keydata):
if isinstance(keydata, bytes):
data = bytearray(keydata)
elif isinstance(keydata, str):
data = Armorable.ascii_unarmor(keydata)['body']
packets = []
while data:
packets.append(Packet(data))
return packets
def test_add_marker(self):
msg = PGPMessage.new(u"This is a new message")
marker = Packet(bytearray(b'\xa8\x03\x50\x47\x50'))
msg |= marker
def test_parse_versioned_header_exception(self):
# cause an exception during parsing a versioned header by not including the version field
data = bytearray(b'\xc1\x01')
with pytest.raises(PGPError):
Packet(data)
def test_parse_bytes_typeerror(self):
# use a marker packet, but don't wrap it in a bytearray to get a TypeError
data = b'\xa8\x03\x50\x47\x50'
with pytest.raises(TypeError):
Packet(data)
self.iec = iec
self.format = format
def update(self, pbar):
if self.iec:
return self.format.format(Mebibyte(len(self.list)))
return self.format.format(len(self.list))
pb3w = [BetterCounter(packets, False, '{:,} pkts'), '|', BetterCounter(_b, True, '{:,} rem.'), '|', Timer("%s"), '|', Percentage(), Bar()]
pbar3 = ProgressBar(maxval=_mv, widgets=pb3w).start()
while len(_b) > 0:
olen = len(_b)
pkt = Packet(_b)
# if len(packets) == 10132:
# a=0
# try:
# pkt = Packet(_b)
#
# except:
# print("\n\tSomething went wrong!")
# print("\tBad packet followed packet #{:,d}".format(len(packets)))
# print("\tLast packet was: {:s} (tag {:d}) ({:,d} bytes)".format(packets[-1].__class__.__name__, packets[-1].header.tag, packets[-1].header.length))
# print("\t{:,d} bytes left unparsed".format(len(_b)))
# print("\tFailed packet consumed {:,d} bytes".format(olen - len(_b)))
# raise
#
# if (olen - len(_b)) != len(pkt.header) + pkt.header.length:
# print("Incorrect number of bytes consumed. Got: {:,}. Expected: {:,}".format((olen - len(_b)), (len(pkt.header) + pkt.header.length)))
