def send(self, data):
"""send(data)
Sends data.
If log level ``DEBUG`` is enabled, also prints out the data
received.
If it is not possible to send anymore because of a closed
connection, it raises ``exceptions.EOFError``
Examples:
>>> def p(x): print repr(x)
>>> t = tube()
>>> t.send_raw = p
>>> t.send('hello')
'hello'
"""
if self.isEnabledFor(logging.DEBUG):
self.debug('Sent %#x bytes:' % len(data))
if len(set(data)) == 1:
self.indented('%r * %#x' % (data[0], len(data)))
elif all(c in string.printable for c in data):
for line in data.splitlines(True):
self.indented(repr(line), level=logging.DEBUG)
else:
self.indented(fiddling.hexdump(data), level=logging.DEBUG)
self.send_raw(data)
def show(self):
"""
show the log data after format
"""
log.info('%s:%d get a connnection to %s at %s' % (self._data['ip'],
self._data['sport'],
self._data['target'],
ctime(self._data['con_time'])))
log.info('The connection from %s:%d' % (self._data['host'], self._data['dport']))
if self._data['token'] != '':
log.info('Token is: %s' % self._data['token'])
datas = self._data['data']
for data in datas:
if data[1] == sqllog.recv:
log.recv('Received %#x bytes At %s: ' % (len(data[2]), ctime(data[0])))
elif data[1] == sqllog.send:
log.send('Sent %#x bytes At %s:' % (len(data[2]), ctime(data[0])))
if len(set(data[2])) == 1:
log.indented('%r * %#x' % (data[2][0], len(data[2])), level=logging.INFO)
elif all(c in string.printable for c in data[2]):
for line in data[2].splitlines(True):
log.indented(repr(line), level=logging.INFO)
else:
log.indented(fiddling.hexdump(data[2]), level=logging.INFO)
def encode(raw_bytes, avoid=None, expr=None, force=0, pcreg=''):
"""encode(raw_bytes, avoid, expr, force) -> str
Encode shellcode ``raw_bytes`` such that it does not contain
any bytes in ``avoid`` or ``expr``.
Arguments:
raw_bytes(str): Sequence of shellcode bytes to encode.
avoid(str): Bytes to avoid
expr(str): Regular expression which matches bad characters.
force(bool): Force re-encoding of the shellcode, even if it
doesn't contain any bytes in ``avoid``.
"""
orig_avoid = avoid
avoid = set(avoid or '')
if expr:
for char in all_chars:
if re.search(expr, char):
avoid.add(char)
if not (force or avoid & set(raw_bytes)):
return raw_bytes
encoders = Encoder._encoders[context.arch]
random.shuffle(encoders)
for encoder in encoders:
if encoder.blacklist & avoid:
continue
try:
v = encoder(raw_bytes, avoid, pcreg)
except NotImplementedError:
continue
if avoid & set(v):
log.warning_once("Encoder %s did not succeed" % encoder)
continue
return v
avoid_errmsg = ''
if orig_avoid and expr:
avoid_errmsg = '%r and %r' % (orig_avoid, expr)
elif expr:
avoid_errmsg = repr(expr)
else:
avoid_errmsg = repr(bytes(avoid))
args = (context.arch, avoid_errmsg, hexdump(raw_bytes))
msg = "No encoders for %s which can avoid %s for\n%s" % args
msg = msg.replace('%', '%%')
log.error(msg)
def _fillbuffer(self, timeout=default):
"""_fillbuffer(timeout = default)
Fills the internal buffer from the pipe, by calling
:meth:`recv_raw` exactly once.
Returns:
The bytes of data received, or ``''`` if no data was received.
Examples:
>>> t = tube()
>>> t.recv_raw = lambda *a: 'abc'
>>> len(t.buffer)
0
>>> t._fillbuffer()
'abc'
>>> len(t.buffer)
3
"""
data = b''
with self.local(timeout):
data = self.recv_raw(self.buffer.get_fill_size())
if data and self.isEnabledFor(logging.DEBUG):
self.debug('Received %#x bytes:' % len(data))
if len(set(data)) == 1 and len(data) > 1:
self.indented('%r * %#x' % (data[0], len(data)),
level=logging.DEBUG)
elif all(c in string.printable for c in data):
for line in data.splitlines(True):
self.indented(repr(line), level=logging.DEBUG)
else:
self.indented(fiddling.hexdump(data), level=logging.DEBUG)
if data:
self.buffer.add(data)
return data
