def chain(self):
"""Build the ROP chain
Returns:
str containing raw ROP bytes
"""
return packing.flat(self.build())
def chain(self):
"""Build the ROP chain
Returns:
str containing raw ROP bytes
"""
return packing.flat(self.build(), word_size=8 * self.align)
def chain(self):
"""Build the ROP chain
Returns:
str containing raw ROP bytes
"""
return packing.flat(self.build())
def chain(self, base=None) -> bytes:
'''Build the ROP chain (and use a `base` if given)
Returns:
str containing raw ROP bytes
'''
return flat(self.build(base=base))
def emulate_plt_instructions(elf, got, address, data, targets):
"""Emulates instructions in ``data``
Arguments:
elf(ELF): ELF that we are emulating
got(int): Address of the GOT, as expected in e.g. EBX
address(int): Address of ``data`` for emulation
data(str): Array of bytes to emulate
targets(list): List of target addresses
Returns:
:class:`dict`: Map of ``{address: target}`` for each address which
reaches one of the selected targets.
"""
rv = {}
# Unicorn doesn't support big-endian for everything yet.
if elf.endian == 'big' and elf.arch == 'mips':
data = packing.unpack_many(data, bits=32, endian='little')
data = packing.flat(data, bits=32, endian='big')
# Brute force addresses, assume that PLT entry points are at 4-byte aligned
# Do not emulate more than a handful of instructions.
for i, pc in enumerate(range(address, address + len(data), 4)):
if log.isEnabledFor(logging.DEBUG):
log.debug('%s %#x', fiddling.enhex(data[i * 4:(i + 1) * 4]), pc)
log.debug(elf.disasm(pc, 4))
target = emulate_plt_instructions_inner(elf, got, pc, data[i * 4:],
targets)
if target in targets:
log.debug("%#x -> %#x", pc, target)
rv[pc] = target
return rv
def emulate_plt_instructions(elf, got, address, data, targets):
"""Emulates instructions in ``data``
Arguments:
elf(ELF): ELF that we are emulating
got(int): Address of the GOT, as expected in e.g. EBX
address(int): Address of ``data`` for emulation
data(str): Array of bytes to emulate
targets(list): List of target addresses
Returns:
:class:`dict`: Map of ``{address: target}`` for each address which
reaches one of the selected targets.
"""
rv = {}
# Unicorn doesn't support big-endian for everything yet.
if elf.endian == 'big' and elf.arch == 'mips':
data = packing.unpack_many(data, bits=32, endian='little')
data = packing.flat(data, bits=32, endian='big')
# Brute force addresses, assume that PLT entry points are at 4-byte aligned
# Do not emulate more than a handful of instructions.
for i, pc in enumerate(range(address, address + len(data), 4)):
if log.isEnabledFor(logging.DEBUG):
log.debug('%s %#x', fiddling.enhex(data[i*4:(i+1) * 4]), pc)
log.debug(elf.disasm(pc, 4))
target = emulate_plt_instructions_inner(elf, got, pc, data[i*4:], targets)
if target in targets:
log.debug("%#x -> %#x", pc, target)
rv[pc] = target
return rv
def hexdump(s,
width=16,
skip=True,
hexii=False,
begin=0,
style=None,
highlight=None,
cyclic=False):
"""hexdump(s, width = 16, skip = True, hexii = False, begin = 0,
style = None, highlight = None, cyclic = False) -> str generator
Return a hexdump-dump of a string.
Arguments:
s(str): The data to hexdump.
width(int): The number of characters per line
skip(bool): Set to True, if repeated lines should be replaced by a "*"
hexii(bool): Set to True, if a hexii-dump should be returned instead of a hexdump.
begin(int): Offset of the first byte to print in the left column
style(dict): Color scheme to use.
highlight(iterable): Byte values to highlight.
cyclic(bool): Attempt to skip consecutive, unmodified cyclic lines
Returns:
A hexdump-dump in the form of a string.
"""
s = packing.flat(s)
return '\n'.join(
hexdump_iter(StringIO.StringIO(s), width, skip, hexii, begin, style,
highlight, cyclic))
def xor(*args, **kwargs):
"""xor(*args, cut = 'max') -> str
Flattens its arguments using :func:`pwnlib.util.packing.flat` and
then xors them together. If the end of a string is reached, it wraps
around in the string.
Arguments:
args: The arguments to be xor'ed together.
cut: How long a string should be returned.
Can be either 'min'/'max'/'left'/'right' or a number.
Returns:
The string of the arguments xor'ed together.
Example:
>>> xor(b'lol', b'hello', 42)
b'. ***'
"""
cut = kwargs.pop('cut', 'max')
if kwargs != {}:
raise TypeError("xor() got an unexpected keyword argument '%s'" %
kwargs.pop()[0])
if len(args) == 0:
raise ValueError("Must have something to xor")
strs = [
packing.flat(s, word_size=8, sign=False, endianness='little')
for s in args
]
strs = [bytearray(s) for s in strs if s]
if strs == []:
return b''
if isinstance(cut, six.integer_types):
cut = cut
elif cut == 'left':
cut = len(strs[0])
elif cut == 'right':
cut = len(strs[-1])
elif cut == 'min':
cut = min(len(s) for s in strs)
elif cut == 'max':
cut = max(len(s) for s in strs)
else:
raise ValueError("Not a valid argument for 'cut'")
def get(n):
rv = 0
for s in strs:
rv ^= s[n % len(s)]
return packing._p8lu(rv)
return b''.join(map(get, range(cut)))
def finishStackDump(self):
dump = flat(self.memdumps)
log.warn("Stack dump @0x%08x written to %s!" %
(self.memdump_addr, self.stack_dump_filename))
f = open(self.stack_dump_filename, "wb")
f.write(dump)
f.close()
# Shut down:
self.stack_dump_has_happend = True
def xor(*args, **kwargs):
"""xor(*args, cut = 'max') -> str
Flattens its arguments using :func:`pwnlib.util.packing.flat` and
then xors them together. If the end of a string is reached, it wraps
around in the string.
Arguments:
args: The arguments to be xor'ed together.
cut: How long a string should be returned.
Can be either 'min'/'max'/'left'/'right' or a number.
Returns:
The string of the arguments xor'ed together.
Example:
>>> xor('lol', 'hello', 42)
'. ***'
"""
cut = kwargs.pop('cut', 'max')
if kwargs != {}:
raise TypeError("xor() got an unexpected keyword argument '%s'" %
kwargs.pop()[0])
if len(args) == 0:
raise ValueError("Must have something to xor")
strs = [
packing.flat(s, word_size=8, sign=False, endianness='little')
for s in args
]
strs = [[ord(c) for c in s] for s in strs if s != '']
if strs == []:
return ''
if isinstance(cut, (int, long)):
cut = cut
elif cut == 'left':
cut = len(strs[0])
elif cut == 'right':
cut = len(strs[-1])
elif cut == 'min':
cut = min(len(s) for s in strs)
elif cut == 'max':
cut = max(len(s) for s in strs)
else:
raise ValueError("Not a valid argument for 'cut'")
def get(n):
return chr(reduce(lambda x, y: x ^ y, [s[n % len(s)] for s in strs]))
return ''.join(get(n) for n in range(cut))
def __call__(self, *args):
self._called = True
old_children = self._children
self._children = concat_all(args)
for n, c in enumerate(self._children):
if not isinstance(c, (Align, Location, Buf)):
self._children[n] = flat(c)
if self._children != old_children:
self._changed = True
return self
def chain(self, base=None):
"""Build the ROP chain
Arguments:
base(int):
The base address to build the rop-chain from. Defaults to
:attr:`base`.
Returns:
str containing raw ROP bytes
"""
return packing.flat(self.build(base=base))
def xor(*args, **kwargs):
"""xor(*args, cut = 'max') -> str
Flattens its arguments using :func:`pwnlib.util.packing.flat` and
then xors them together. If the end of a string is reached, it wraps
around in the string.
Arguments:
args: The arguments to be xor'ed together.
cut: How long a string should be returned.
Can be either 'min'/'max'/'left'/'right' or a number.
Returns:
The string of the arguments xor'ed together.
Example:
>>> xor('lol', 'hello', 42)
'. ***'
"""
cut = kwargs.pop('cut', 'max')
if kwargs != {}:
raise TypeError("xor() got an unexpected keyword argument '%s'" % kwargs.pop()[0])
if len(args) == 0:
raise ValueError("Must have something to xor")
strs = [packing.flat(s, word_size = 8, sign = False, endianness = 'little') for s in args]
strs = [[ord(c) for c in s] for s in strs if s != '']
if strs == []:
return ''
if isinstance(cut, (int, long)):
cut = cut
elif cut == 'left':
cut = len(strs[0])
elif cut == 'right':
cut = len(strs[-1])
elif cut == 'min':
cut = min(len(s) for s in strs)
elif cut == 'max':
cut = max(len(s) for s in strs)
else:
raise ValueError("Not a valid argument for 'cut'")
def get(n):
return chr(reduce(lambda x, y: x ^ y, [s[n % len(s)] for s in strs]))
return ''.join(get(n) for n in range(cut))
def finishStackDump(self):
"""
Write the stack dump to a file once it is finished.
"""
dump = flat(
self.memdumps) # flatten, as we have one entry per address chunk
log.warn("Stack dump @0x%08x written to %s!" %
(self.memdump_addr, self.stack_dump_filename))
f = open(self.stack_dump_filename, "wb")
f.write(dump)
f.close()
# Shut down:
self.stack_dump_has_happend = True
def _slot_len(x):
if isinstance(x, six.integer_types + (Unresolved, Padding, Gadget)):
return context.bytes
else:
return len(packing.flat(x))
def render_body(context, string, append_null=True, **pageargs):
__M_caller = context.caller_stack._push_frame()
try:
__M_locals = __M_dict_builtin(pageargs=pageargs,
string=string,
append_null=append_null)
ord = context.get('ord', UNDEFINED)
isinstance = context.get('isinstance', UNDEFINED)
str = context.get('str', UNDEFINED)
__M_writer = context.writer()
from pwnlib.util import lists, packing, fiddling
from pwnlib.shellcraft import pretty, okay
__M_locals_builtin_stored = __M_locals_builtin()
__M_locals.update(
__M_dict_builtin([
(__M_key, __M_locals_builtin_stored[__M_key]) for __M_key in
['packing', 'fiddling', 'okay', 'pretty', 'lists']
if __M_key in __M_locals_builtin_stored
]))
__M_writer(u'\n')
__M_writer(u'\n')
__M_writer(u'\n')
original = string
string = packing.flat(string)
if append_null:
string += '\x00'
if isinstance(original, str):
original += '\x00'
if not string:
return
if ord(string[-1]) >= 128:
extend = '\xff'
else:
extend = '\x00'
__M_locals_builtin_stored = __M_locals_builtin()
__M_locals.update(
__M_dict_builtin([(__M_key, __M_locals_builtin_stored[__M_key])
for __M_key in ['original', 'extend', 'string']
if __M_key in __M_locals_builtin_stored]))
__M_writer(u' /* push ')
__M_writer(unicode(pretty(original, False)))
__M_writer(u' */\n')
for word in lists.group(4, string, 'fill', extend)[::-1]:
sign = packing.u32(word, endian='little', sign='signed')
__M_locals_builtin_stored = __M_locals_builtin()
__M_locals.update(
__M_dict_builtin([(__M_key, __M_locals_builtin_stored[__M_key])
for __M_key in ['sign']
if __M_key in __M_locals_builtin_stored]))
if sign in [0, 0xa]:
__M_writer(u' push ')
__M_writer(unicode(pretty(sign + 1)))
__M_writer(u'\n dec byte ptr [esp]\n')
elif -0x80 <= sign <= 0x7f and okay(word[0]):
__M_writer(u' push ')
__M_writer(unicode(pretty(sign)))
__M_writer(u'\n')
elif okay(word):
__M_writer(u' push ')
__M_writer(unicode(pretty(sign)))
__M_writer(u'\n')
else:
a, b = fiddling.xor_pair(word, avoid='\x00\n')
a = packing.u32(a, endian='little', sign='unsigned')
b = packing.u32(b, endian='little', sign='unsigned')
__M_locals_builtin_stored = __M_locals_builtin()
__M_locals.update(
__M_dict_builtin([
(__M_key, __M_locals_builtin_stored[__M_key])
for __M_key in ['a', 'b']
if __M_key in __M_locals_builtin_stored
]))
__M_writer(u' push ')
__M_writer(unicode(pretty(a)))
__M_writer(u'\n xor dword ptr [esp], ')
__M_writer(unicode(pretty(b)))
__M_writer(u'\n')
return ''
finally:
context.caller_stack._pop_frame()
def flat(self, address, *a, **kw):
"""Writes a full array of values to the specified address.
See: :func:`.packing.flat`
"""
return self.write(address, packing.flat(*a,**kw))
def rop2(end=0):
rop2 = flat(pop_rdi, end, puts)
end = base + len(rop2)
rop2 += "/bin/sh\x00"
def hexdump(s,
width=16,
skip=True,
hexii=False,
begin=0,
style=None,
highlight=None,
cyclic=False,
groupsize=4,
total=True):
r"""hexdump(s, width = 16, skip = True, hexii = False, begin = 0, style = None,
highlight = None, cyclic = False, groupsize=4, total = True) -> str
Return a hexdump-dump of a string.
Arguments:
s(bytes): The data to hexdump.
width(int): The number of characters per line
groupsize(int): The number of characters per group
skip(bool): Set to True, if repeated lines should be replaced by a "*"
hexii(bool): Set to True, if a hexii-dump should be returned instead of a hexdump.
begin(int): Offset of the first byte to print in the left column
style(dict): Color scheme to use.
highlight(iterable): Byte values to highlight.
cyclic(bool): Attempt to skip consecutive, unmodified cyclic lines
total(bool): Set to True, if total bytes should be printed
Returns:
A hexdump-dump in the form of a string.
Examples:
>>> print(hexdump(b"abc"))
00000000 61 62 63 │abc│
00000003
>>> print(hexdump(b'A'*32))
00000000 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AAAA│AAAA│
*
00000020
>>> print(hexdump(b'A'*32, width=8))
00000000 41 41 41 41 41 41 41 41 │AAAA│AAAA│
*
00000020
>>> print(hexdump(cyclic(32), width=8, begin=0xdead0000, hexii=True))
dead0000 .a .a .a .a .b .a .a .a │
dead0008 .c .a .a .a .d .a .a .a │
dead0010 .e .a .a .a .f .a .a .a │
dead0018 .g .a .a .a .h .a .a .a │
dead0020
>>> print(hexdump(bytearray(range(256))))
00000000 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f │····│····│····│····│
00000010 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f │····│····│····│····│
00000020 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f │ !"#│$%&'│()*+│,-./│
00000030 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f │0123│4567│89:;│<=>?│
00000040 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f │@ABC│DEFG│HIJK│LMNO│
00000050 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f │PQRS│TUVW│XYZ[│\]^_│
00000060 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f │`abc│defg│hijk│lmno│
00000070 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f │pqrs│tuvw│xyz{│|}~·│
00000080 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f │····│····│····│····│
00000090 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f │····│····│····│····│
000000a0 a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af │····│····│····│····│
000000b0 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf │····│····│····│····│
000000c0 c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf │····│····│····│····│
000000d0 d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df │····│····│····│····│
000000e0 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef │····│····│····│····│
000000f0 f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe ff │····│····│····│····│
00000100
>>> print(hexdump(bytearray(range(256)), hexii=True))
00000000 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f │
00000010 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f │
00000020 20 .! ." .# .$ .% .& .' .( .) .* .+ ., .- .. ./ │
00000030 .0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .: .; .< .= .> .? │
00000040 .@ .A .B .C .D .E .F .G .H .I .J .K .L .M .N .O │
00000050 .P .Q .R .S .T .U .V .W .X .Y .Z .[ .\ .] .^ ._ │
00000060 .` .a .b .c .d .e .f .g .h .i .j .k .l .m .n .o │
00000070 .p .q .r .s .t .u .v .w .x .y .z .{ .| .} .~ 7f │
00000080 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f │
00000090 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f │
000000a0 a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af │
000000b0 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf │
000000c0 c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf │
000000d0 d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df │
000000e0 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef │
000000f0 f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe ## │
00000100
>>> print(hexdump(b'X' * 64))
00000000 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
*
00000040
>>> print(hexdump(b'X' * 64, skip=False))
00000000 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
00000010 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
00000020 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
00000030 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
00000040
>>> print(hexdump(fit({0x10: b'X'*0x20, 0x50-1: b'\xff'*20}, length=0xc0) + b'\x00'*32))
00000000 61 61 61 61 62 61 61 61 63 61 61 61 64 61 61 61 │aaaa│baaa│caaa│daaa│
00000010 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
*
00000030 6d 61 61 61 6e 61 61 61 6f 61 61 61 70 61 61 61 │maaa│naaa│oaaa│paaa│
00000040 71 61 61 61 72 61 61 61 73 61 61 61 74 61 61 ff │qaaa│raaa│saaa│taa·│
00000050 ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff │····│····│····│····│
00000060 ff ff ff 61 7a 61 61 62 62 61 61 62 63 61 61 62 │···a│zaab│baab│caab│
00000070 64 61 61 62 65 61 61 62 66 61 61 62 67 61 61 62 │daab│eaab│faab│gaab│
00000080 68 61 61 62 69 61 61 62 6a 61 61 62 6b 61 61 62 │haab│iaab│jaab│kaab│
00000090 6c 61 61 62 6d 61 61 62 6e 61 61 62 6f 61 61 62 │laab│maab│naab│oaab│
000000a0 70 61 61 62 71 61 61 62 72 61 61 62 73 61 61 62 │paab│qaab│raab│saab│
000000b0 74 61 61 62 75 61 61 62 76 61 61 62 77 61 61 62 │taab│uaab│vaab│waab│
000000c0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │····│····│····│····│
*
000000e0
>>> print(hexdump(fit({0x10: b'X'*0x20, 0x50-1: b'\xff'*20}, length=0xc0) + b'\x00'*32, cyclic=1))
00000000 61 61 61 61 62 61 61 61 63 61 61 61 64 61 61 61 │aaaa│baaa│caaa│daaa│
00000010 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
*
00000030 6d 61 61 61 6e 61 61 61 6f 61 61 61 70 61 61 61 │maaa│naaa│oaaa│paaa│
00000040 71 61 61 61 72 61 61 61 73 61 61 61 74 61 61 ff │qaaa│raaa│saaa│taa·│
00000050 ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff │····│····│····│····│
00000060 ff ff ff 61 7a 61 61 62 62 61 61 62 63 61 61 62 │···a│zaab│baab│caab│
00000070 64 61 61 62 65 61 61 62 66 61 61 62 67 61 61 62 │daab│eaab│faab│gaab│
*
000000c0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │····│····│····│····│
*
000000e0
>>> print(hexdump(fit({0x10: b'X'*0x20, 0x50-1: b'\xff'*20}, length=0xc0) + b'\x00'*32, cyclic=1, hexii=1))
00000000 .a .a .a .a .b .a .a .a .c .a .a .a .d .a .a .a │
00000010 .X .X .X .X .X .X .X .X .X .X .X .X .X .X .X .X │
*
00000030 .m .a .a .a .n .a .a .a .o .a .a .a .p .a .a .a │
00000040 .q .a .a .a .r .a .a .a .s .a .a .a .t .a .a ## │
00000050 ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## │
00000060 ## ## ## .a .z .a .a .b .b .a .a .b .c .a .a .b │
00000070 .d .a .a .b .e .a .a .b .f .a .a .b .g .a .a .b │
*
000000c0 │
*
000000e0
>>> print(hexdump(b'A'*16, width=9))
00000000 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│A│
00000009 41 41 41 41 41 41 41 │AAAA│AAA│
00000010
>>> print(hexdump(b'A'*16, width=10))
00000000 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AA│
0000000a 41 41 41 41 41 41 │AAAA│AA│
00000010
>>> print(hexdump(b'A'*16, width=11))
00000000 41 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AAA│
0000000b 41 41 41 41 41 │AAAA│A│
00000010
>>> print(hexdump(b'A'*16, width=12))
00000000 41 41 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AAAA│
0000000c 41 41 41 41 │AAAA│
00000010
>>> print(hexdump(b'A'*16, width=13))
00000000 41 41 41 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AAAA│A│
0000000d 41 41 41 │AAA│
00000010
>>> print(hexdump(b'A'*16, width=14))
00000000 41 41 41 41 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AAAA│AA│
0000000e 41 41 │AA│
00000010
>>> print(hexdump(b'A'*16, width=15))
00000000 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AAAA│AAA│
0000000f 41 │A│
00000010
>>> print(hexdump(b'A'*24, width=16, groupsize=8))
00000000 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 │AAAAAAAA│AAAAAAAA│
00000010 41 41 41 41 41 41 41 41 │AAAAAAAA│
00000018
>>> print(hexdump(b'A'*24, width=16, groupsize=-1))
00000000 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 │AAAAAAAAAAAAAAAA│
00000010 41 41 41 41 41 41 41 41 │AAAAAAAA│
00000018
>>> print(hexdump(b'A'*24, width=16, total=False))
00000000 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AAAA│AAAA│
00000010 41 41 41 41 41 41 41 41 │AAAA│AAAA│
>>> print(hexdump(b'A'*24, width=16, groupsize=8, total=False))
00000000 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 │AAAAAAAA│AAAAAAAA│
00000010 41 41 41 41 41 41 41 41 │AAAAAAAA│
"""
s = packing.flat(s, stacklevel=1)
return '\n'.join(
hexdump_iter(BytesIO(s), width, skip, hexii, begin, style, highlight,
cyclic, groupsize, total))
def __bytes__(self):
return packing.flat(self.resolve())
def hexdump(s, width=16, skip=True, hexii=False, begin=0,
style=None, highlight=None, cyclic=False):
r"""hexdump(s, width = 16, skip = True, hexii = False, begin = 0,
style = None, highlight = None, cyclic = False) -> str generator
Return a hexdump-dump of a string.
Arguments:
s(str): The data to hexdump.
width(int): The number of characters per line
skip(bool): Set to True, if repeated lines should be replaced by a "*"
hexii(bool): Set to True, if a hexii-dump should be returned instead of a hexdump.
begin(int): Offset of the first byte to print in the left column
style(dict): Color scheme to use.
highlight(iterable): Byte values to highlight.
cyclic(bool): Attempt to skip consecutive, unmodified cyclic lines
Returns:
A hexdump-dump in the form of a string.
Examples:
>>> print hexdump("abc")
00000000 61 62 63 │abc│
00000003
>>> print hexdump('A'*32)
00000000 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AAAA│AAAA│
*
00000020
>>> print hexdump('A'*32, width=8)
00000000 41 41 41 41 41 41 41 41 │AAAA│AAAA│
*
00000020
>>> print hexdump(cyclic(32), width=8, begin=0xdead0000, hexii=True)
dead0000 .a .a .a .a .b .a .a .a │
dead0008 .c .a .a .a .d .a .a .a │
dead0010 .e .a .a .a .f .a .a .a │
dead0018 .g .a .a .a .h .a .a .a │
dead0020
>>> print hexdump(list(map(chr, range(256))))
00000000 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f │····│····│····│····│
00000010 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f │····│····│····│····│
00000020 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f │ !"#│$%&'│()*+│,-./│
00000030 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f │0123│4567│89:;│<=>?│
00000040 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f │@ABC│DEFG│HIJK│LMNO│
00000050 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f │PQRS│TUVW│XYZ[│\]^_│
00000060 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f │`abc│defg│hijk│lmno│
00000070 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f │pqrs│tuvw│xyz{│|}~·│
00000080 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f │····│····│····│····│
00000090 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f │····│····│····│····│
000000a0 a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af │····│····│····│····│
000000b0 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf │····│····│····│····│
000000c0 c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf │····│····│····│····│
000000d0 d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df │····│····│····│····│
000000e0 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef │····│····│····│····│
000000f0 f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe ff │····│····│····│····│
00000100
>>> print hexdump(list(map(chr, range(256))), hexii=True)
00000000 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f │
00000010 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f │
00000020 20 .! ." .# .$ .% .& .' .( .) .* .+ ., .- .. ./ │
00000030 .0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .: .; .< .= .> .? │
00000040 .@ .A .B .C .D .E .F .G .H .I .J .K .L .M .N .O │
00000050 .P .Q .R .S .T .U .V .W .X .Y .Z .[ .\ .] .^ ._ │
00000060 .` .a .b .c .d .e .f .g .h .i .j .k .l .m .n .o │
00000070 .p .q .r .s .t .u .v .w .x .y .z .{ .| .} .~ 7f │
00000080 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f │
00000090 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f │
000000a0 a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af │
000000b0 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf │
000000c0 c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf │
000000d0 d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df │
000000e0 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef │
000000f0 f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe ## │
00000100
>>> print hexdump('X' * 64)
00000000 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
*
00000040
>>> print hexdump('X' * 64, skip=False)
00000000 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
00000010 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
00000020 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
00000030 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
00000040
>>> print hexdump(fit({0x10: 'X'*0x20, 0x50-1: '\xff'*20}, length=0xc0) + '\x00'*32)
00000000 61 61 61 61 62 61 61 61 63 61 61 61 64 61 61 61 │aaaa│baaa│caaa│daaa│
00000010 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
*
00000030 6d 61 61 61 6e 61 61 61 6f 61 61 61 70 61 61 61 │maaa│naaa│oaaa│paaa│
00000040 71 61 61 61 72 61 61 61 73 61 61 61 74 61 61 ff │qaaa│raaa│saaa│taa·│
00000050 ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff │····│····│····│····│
00000060 ff ff ff 61 7a 61 61 62 62 61 61 62 63 61 61 62 │···a│zaab│baab│caab│
00000070 64 61 61 62 65 61 61 62 66 61 61 62 67 61 61 62 │daab│eaab│faab│gaab│
00000080 68 61 61 62 69 61 61 62 6a 61 61 62 6b 61 61 62 │haab│iaab│jaab│kaab│
00000090 6c 61 61 62 6d 61 61 62 6e 61 61 62 6f 61 61 62 │laab│maab│naab│oaab│
000000a0 70 61 61 62 71 61 61 62 72 61 61 62 73 61 61 62 │paab│qaab│raab│saab│
000000b0 74 61 61 62 75 61 61 62 76 61 61 62 77 61 61 62 │taab│uaab│vaab│waab│
000000c0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │····│····│····│····│
*
000000e0
>>> print hexdump(fit({0x10: 'X'*0x20, 0x50-1: '\xff'*20}, length=0xc0) + '\x00'*32, cyclic=1)
00000000 61 61 61 61 62 61 61 61 63 61 61 61 64 61 61 61 │aaaa│baaa│caaa│daaa│
00000010 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 │XXXX│XXXX│XXXX│XXXX│
*
00000030 6d 61 61 61 6e 61 61 61 6f 61 61 61 70 61 61 61 │maaa│naaa│oaaa│paaa│
00000040 71 61 61 61 72 61 61 61 73 61 61 61 74 61 61 ff │qaaa│raaa│saaa│taa·│
00000050 ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff │····│····│····│····│
00000060 ff ff ff 61 7a 61 61 62 62 61 61 62 63 61 61 62 │···a│zaab│baab│caab│
00000070 64 61 61 62 65 61 61 62 66 61 61 62 67 61 61 62 │daab│eaab│faab│gaab│
*
000000c0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │····│····│····│····│
*
000000e0
>>> print hexdump(fit({0x10: 'X'*0x20, 0x50-1: '\xff'*20}, length=0xc0) + '\x00'*32, cyclic=1, hexii=1)
00000000 .a .a .a .a .b .a .a .a .c .a .a .a .d .a .a .a │
00000010 .X .X .X .X .X .X .X .X .X .X .X .X .X .X .X .X │
*
00000030 .m .a .a .a .n .a .a .a .o .a .a .a .p .a .a .a │
00000040 .q .a .a .a .r .a .a .a .s .a .a .a .t .a .a ## │
00000050 ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## │
00000060 ## ## ## .a .z .a .a .b .b .a .a .b .c .a .a .b │
00000070 .d .a .a .b .e .a .a .b .f .a .a .b .g .a .a .b │
*
000000c0 │
*
000000e0
>>> print hexdump('A'*16, width=9)
00000000 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│A│
00000009 41 41 41 41 41 41 41 │AAAA│AAA│
00000010
>>> print hexdump('A'*16, width=10)
00000000 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AA│
0000000a 41 41 41 41 41 41 │AAAA│AA│
00000010
>>> print hexdump('A'*16, width=11)
00000000 41 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AAA│
0000000b 41 41 41 41 41 │AAAA│A│
00000010
>>> print hexdump('A'*16, width=12)
00000000 41 41 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AAAA│
0000000c 41 41 41 41 │AAAA││
00000010
>>> print hexdump('A'*16, width=13)
00000000 41 41 41 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AAAA│A│
0000000d 41 41 41 │AAA│
00000010
>>> print hexdump('A'*16, width=14)
00000000 41 41 41 41 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AAAA│AA│
0000000e 41 41 │AA│
00000010
>>> print hexdump('A'*16, width=15)
00000000 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 │AAAA│AAAA│AAAA│AAA│
0000000f 41 │A│
00000010
"""
s = packing.flat(s)
return '\n'.join(hexdump_iter(StringIO.StringIO(s),
width,
skip,
hexii,
begin,
style,
highlight,
cyclic))
def __str__(self):
return packing.flat(self.resolve())
def flat(self, *a, **kw):
return self.send(packing.flat(*a, **kw))
def __str__(self):
return packing.flat(self.resolve())
