desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
''
| def post(self, url, data=None, **kwargs):
| return self.request('post', url, data=data, **kwargs)
|
''
| def put(self, url, data=None, **kwargs):
| return self.request('put', url, data=data, **kwargs)
|
''
| def patch(self, url, data=None, **kwargs):
| return self.request('patch', url, data=data, **kwargs)
|
''
| def delete(self, url, **kwargs):
| return self.request('delete', url, **kwargs)
|
''
| def __init__(self, ns, parsers, multi=False, **kwargs):
| self.prompt = ('(%s) > ' % self.name)
self.ns = ns
self.parsers = parsers
self.payload = None
self.action_help = {}
self.action_types = {}
for parser in self.parsers:
for a in parser._actions:
self.action_help[a.dest] = a.help
self.action_types[a.dest] =... |
''
| def cmdloop(self, **kwargs):
| try:
Cmd.cmdloop(self, **kwargs)
except ExitException as e:
return
except Exception as e:
self.log.error(('cmdloop caught error: %s' % e))
self.continue_prompt('A critical error occurred. Would you like to keep this shell open?')
... |
''
| @excmd
def do_touch(self, arg=None):
| (res, resp) = ([], None)
if (hasattr(self, 'target_url') and self.target_url):
resp = self.head(self.target_url)
res.append(('HEAD %s - %s' % (self.target_url, resp.status_code)))
for (key, val) in resp.headers.items():
res.append(('Header: %s -- %s' % (key,... |
''
| @excmd
def do_probe(self, arg=None):
| res = self.probe()
if (not res):
self.log.info('Target is vulnerable. Safe to proceed.')
else:
self.log.error('Target appears not to be vulnerable.')
self.log.error(('Reason given: %s' % res))
|
''
| @excmd
def do_survey(self, arg=None):
| res = self.survey()
if (not res):
self.log.info('Survey complete.')
else:
self.log.error('Survey failed.')
self.log.error(('Reason given: %s' % res))
|
''
| @excmd
def do_exploit(self, arg=None):
| res = self.exploit()
if (not res):
self.log.info('Exploit complete. Got root?')
else:
self.log.error('Exploit failed')
self.log.error(('Reason given: %s' % res))
|
''
| @excmd
def do_clean(self, arg=None):
| res = self.clean()
if (not res):
self.log.info('Cleanup completed successfully.')
else:
self.log.error(('Cleanup failed: %s' % res))
|
''
| def do_show(self, args=None):
| if args:
args = args.strip()
try:
print ('%s = %s :: %s' % (args, self.ns.__dict__[args], self.action_help[args]))
except KeyError:
self.log.warning('Variable does not exist.')
else:
print 'Exploit variables'
print '========... |
''
| def do_set(self, args):
| if args:
args = split(args)
if (len(args) >= 2):
if (args[0] in self.ns.__dict__):
try:
self._update_var(args[0], args[1])
except ArgumentTypeError as e:
self.log.warning(('Setting %s failed: %s' % (args[0],... |
''
| def do_guided(self, args=None):
| for cmd in self.excmds:
if (cmd in dir(self)):
res = raw_input(('About to execute %s. Continue, skip, interact, or quit? (C/s/i/q) ' % cmd))
if (res.lower() == 's'):
continue
elif (res.lower() == 'q'):
return
... |
''
| def request(self, mthd, url, **kwargs):
| quiet = False
if ('quiet' in kwargs):
quiet = kwargs['quiet']
del kwargs['quiet']
if quiet:
l = logging.getLogger('fosho.requests.packages.urllib3.connectionpool')
old = l.getEffectiveLevel()
l.setLevel(logging.ERROR)
if (not self.multi):
url = (self.targe... |
''
| def prompt_for_settings(self, names):
| for name in names:
try:
res = getattr(self, ('_get_' + name))()
except AttributeError as e:
res = None
if (not hasattr(self.ns, name)):
self.ns.__dict__[name] = None
if ((not self.ask) and (not res)):
res = self.ns.__dict__[name]
... |
''
| def continue_prompt(self, msg, default='n'):
| other = ('y' if (default == 'n') else 'n')
opts = '(y/n)'.replace(default, default.upper())
res = raw_input(('%s %s ' % (msg, opts)))
if (res.lower() != 'y'):
try:
self._do_finish()
except:
pass
sys.exit('Stopping exploit...')
|
''
| def get_etag(self, path):
| res = self.head(path)
return self._parse_etag(res.headers['etag'])
|
''
| def _parse_etag(self, etag):
| return (etag, 'Could not parse etag')
|
''
| def _apply_settings(self):
| for (key, val) in self.ns.__dict__.items():
if (key in ['quiet', 'debug']):
level = logging.DEBUG
if self.ns.quiet:
level = logging.INFO
self.log.setLevel(level)
logging.getLogger('fosho.requests.packages.urllib3.connectionpool').setLevel(level... |
''
| def _update_var(self, key, val):
| if (val == 'False'):
val = False
cur = self.ns.__dict__[key]
if (cur == None):
cur = ''
t = type(self.ns.__dict__[key])
if ((key in self.action_types) and self.action_types[key]):
t = self.action_types[key]
try:
self.ns.__dict__[key] = t(val)
except TypeError:... |
''
| @classmethod
def add_args(cur, cls):
| parser = ArgumentParser(prog=sys.argv[0], description=('%s %s - %s' % (cls.name, cls.version, cls.desc)))
subparsers = parser.add_subparsers(help='Exploit Commands')
if cls.interact:
inparse = subparsers.add_parser('interact', help='Run tool in interactive mode')
inpa... |
''
| def clean(self):
| self.log.info('Cleaning up /tmp/ ...')
self._run_cmd('rm -f /t*/cgi*')
self._run_cmd('rm -f /t*/.a')
self._run_cmd('rm -f /t*/.te*')
|
''
| def _get_cid(self):
| if self.cid:
self.log.info(('Already know cookie id: %s' % self.cid))
return self.cid
try:
cid = self.get(self.exploit_url).cookies.keys()[0]
self.log.info(('Detected cookie id: %s' % cid))
return cid
except IndexError:
self.log.warning("C... |
''
| def value_decode(self, val):
| return (val, val)
|
''
| def value_encode(self, val):
| strval = str(val)
return (strval, strval)
|
''
| def __set(self, key, real_value, coded_value):
| M = self.get(key, Morsel())
M.set(key, real_value, coded_value)
dict.__setitem__(self, key, M)
|
''
| def __setitem__(self, key, value):
| (rval, cval) = self.value_encode(value)
self.__set(key, rval, cval)
|
''
| def output(self, attrs=None, header='Set-Cookie:', sep='\r\n'):
| result = []
items = self.items()
items.sort()
for (K, V) in items:
result.append(V.output(attrs, header))
return sep.join(result)
|
''
| def js_output(self, attrs=None):
| result = []
items = self.items()
items.sort()
for (K, V) in items:
result.append(V.js_output(attrs))
return _nulljoin(result)
|
''
| def load(self, rawdata):
| if (type(rawdata) == type('')):
self.__ParseString(rawdata)
else:
for (k, v) in rawdata.items():
self[k] = v
return
|
''
| def get(self, key, default=None, type=None):
| try:
rv = self[key]
if (type is not None):
rv = type(rv)
except (KeyError, ValueError):
rv = default
return rv
|
''
| def __getitem__(self, key):
| if (key in self):
return dict.__getitem__(self, key)[0]
raise KeyError(key)
|
''
| def __setitem__(self, key, value):
| dict.__setitem__(self, key, [value])
|
''
| def add(self, key, value):
| dict.setdefault(self, key, []).append(value)
|
''
| def getlist(self, key, type=None):
| try:
rv = dict.__getitem__(self, key)
except KeyError:
return []
if (type is None):
return list(rv)
result = []
for item in rv:
try:
result.append(type(item))
except ValueError:
pass
return result
|
''
| def setlist(self, key, new_list):
| dict.__setitem__(self, key, list(new_list))
|
''
| def setdefault(self, key, default=None):
| if (key not in self):
self[key] = default
else:
default = self[key]
return default
|
''
| def setlistdefault(self, key, default_list=None):
| if (key not in self):
default_list = list((default_list or ()))
dict.__setitem__(self, key, default_list)
else:
default_list = dict.__getitem__(self, key)
return default_list
|
''
| def items(self, multi=False):
| return list(self.iteritems(multi))
|
''
| def lists(self):
| return list(self.iterlists())
|
''
| def values(self):
| return [self[key] for key in self.iterkeys()]
|
''
| def listvalues(self):
| return list(self.iterlistvalues())
|
''
| def iteritems(self, multi=False):
| for (key, values) in dict.iteritems(self):
if multi:
for value in values:
(yield (key, value))
else:
(yield (key, values[0]))
|
''
| def iterlists(self):
| for (key, values) in dict.iteritems(self):
(yield (key, list(values)))
|
''
| def itervalues(self):
| for values in dict.itervalues(self):
(yield values[0])
|
''
| def iterlistvalues(self):
| return dict.itervalues(self)
|
''
| def copy(self):
| return self.__class__(self)
|
''
| def to_dict(self, flat=True):
| if flat:
return dict(self.iteritems())
return dict(self.lists())
|
''
| def update(self, other_dict):
| for (key, value) in iter_multi_items(other_dict):
MultiDict.add(self, key, value)
|
''
| def pop(self, key, default=_missing):
| try:
return dict.pop(self, key)[0]
except KeyError as e:
if (default is not _missing):
return default
raise KeyError(str(e))
|
''
| def popitem(self):
| try:
item = dict.popitem(self)
return (item[0], item[1][0])
except KeyError as e:
raise KeyError(str(e))
|
''
| def poplist(self, key):
| return dict.pop(self, key, [])
|
''
| def popitemlist(self):
| try:
return dict.popitem(self)
except KeyError as e:
raise KeyError(str(e))
|
''
| def get_redirect_location(self):
| if (self.status in [301, 302, 303, 307]):
return self.headers.get('location')
return False
|
''
| def read(self, amt=None, decode_content=None, cache_content=False):
| content_encoding = self.headers.get('content-encoding')
decoder = self.CONTENT_DECODERS.get(content_encoding)
if (decode_content is None):
decode_content = self._decode_content
if (self._fp is None):
return
try:
if (amt is None):
data = self._fp.read()
els... |
''
| @classmethod
def from_httplib(ResponseCls, r, **response_kw):
| headers = {}
for (k, v) in r.getheaders():
k = k.lower()
has_value = headers.get(k)
if has_value:
v = ', '.join([has_value, v])
headers[k] = v
strict = getattr(r, 'strict', 0)
return ResponseCls(body=r, headers=headers, status=r.status, version=r.version, r... |
''
| def connection_from_host(self, host, port=80, scheme='http'):
| pool_key = (scheme, host, port)
pool = self.pools.get(pool_key)
if pool:
return pool
pool_cls = pool_classes_by_scheme[scheme]
pool = pool_cls(host, port, **self.connection_pool_kw)
self.pools[pool_key] = pool
return pool
|
''
| def connection_from_url(self, url):
| (scheme, host, port) = get_host(url)
port = (port or port_by_scheme.get(scheme, 80))
return self.connection_from_host(host, port=port, scheme=scheme)
|
''
| def urlopen(self, method, url, **kw):
| conn = self.connection_from_url(url)
try:
return conn.urlopen(method, url, **kw)
except HostChangedError as e:
kw['retries'] = e.retries
return self.urlopen(method, e.url, **kw)
|
''
| def urlopen(self, method, url, **kw):
| kw['assert_same_host'] = False
kw['headers'] = self._set_proxy_headers(kw.get('headers'))
return self.proxy_pool.urlopen(method, url, **kw)
|
''
| def _invalidate_entry(self, key):
| old_entry = self.access_lookup.get(key)
if old_entry:
old_entry.is_valid = False
return old_entry
|
''
| def _push_entry(self, key):
| self._invalidate_entry(key)
new_entry = AccessEntry(key)
self.access_lookup[key] = new_entry
self.access_log_lock.acquire()
self.access_log.appendleft(new_entry)
self.access_log_lock.release()
|
''
| def _prune_entries(self, num):
| while (num > 0):
self.access_log_lock.acquire()
p = self.access_log.pop()
self.access_log_lock.release()
if (not p.is_valid):
continue
dict.pop(self, p.key, None)
self.access_lookup.pop(p.key, None)
num -= 1
|
''
| def _prune_invalidated_entries(self):
| self.access_log_lock.acquire()
self.access_log = deque((e for e in self.access_log if e.is_valid))
self.access_log_lock.release()
|
''
| def _get_ordered_access_keys(self):
| self.access_log_lock.acquire()
r = [e.key for e in self.access_log if e.is_valid]
self.access_log_lock.release()
return r
|
''
| def _new_conn(self):
| self.num_connections += 1
log.debug(('Starting new HTTP connection (%d): %s' % (self.num_connections, self.host)))
return HTTPConnection(host=self.host, port=self.port)
|
''
| def _get_conn(self, timeout=None):
| conn = None
try:
conn = self.pool.get(block=self.block, timeout=timeout)
if (conn and is_connection_dropped(conn)):
log.info(('Resetting dropped connection: %s' % self.host))
conn.close()
except Empty:
if self.block:
raise EmptyPoolError(s... |
''
| def _put_conn(self, conn):
| try:
self.pool.put(conn, block=False)
except Full:
log.warning(('HttpConnectionPool is full, discarding connection: %s' % self.host))
|
''
| def _make_request(self, conn, method, url, timeout=_Default, **httplib_request_kw):
| self.num_requests += 1
if (timeout is _Default):
timeout = self.timeout
conn.timeout = timeout
conn.request(method, url, **httplib_request_kw)
sock = getattr(conn, 'sock', False)
if sock:
sock.settimeout(timeout)
httplib_response = conn.getresponse()
log.debug(('"%s %s... |
''
| def is_same_host(self, url):
| (scheme, host, port) = get_host(url)
if (self.port and (not port)):
port = port_by_scheme.get(scheme)
return (url.startswith('/') or ((scheme, host, port) == (self.scheme, self.host, self.port)))
|
''
| def urlopen(self, method, url, body=None, headers=None, retries=3, redirect=True, assert_same_host=True, timeout=_Default, pool_timeout=None, release_conn=None, **response_kw):
| if (headers is None):
headers = self.headers
if (retries < 0):
raise MaxRetryError(self, url)
if (timeout is _Default):
timeout = self.timeout
if (release_conn is None):
release_conn = response_kw.get('preload_content', True)
if (assert_same_host and (not self.is_same... |
''
| def _new_conn(self):
| self.num_connections += 1
log.debug(('Starting new HTTPS connection (%d): %s' % (self.num_connections, self.host)))
if (not ssl):
if ((not HTTPSConnection) or (HTTPSConnection is object)):
raise SSLError("Can't connect to HTTPS URL because the SSL m... |
''
| def request(self, method, url, fields=None, headers=None, **urlopen_kw):
| method = method.upper()
if (method in self._encode_url_methods):
return self.request_encode_url(method, url, fields=fields, headers=headers, **urlopen_kw)
else:
return self.request_encode_body(method, url, fields=fields, headers=headers, **urlopen_kw)
|
''
| def request_encode_url(self, method, url, fields=None, **urlopen_kw):
| if fields:
url += ('?' + urlencode(fields))
return self.urlopen(method, url, **urlopen_kw)
|
''
| def request_encode_body(self, method, url, fields=None, headers=None, encode_multipart=True, multipart_boundary=None, **urlopen_kw):
| if encode_multipart:
(body, content_type) = encode_multipart_formdata((fields or {}), boundary=multipart_boundary)
else:
(body, content_type) = (urlencode((fields or {})), 'application/x-www-form-urlencoded')
headers = (headers or {})
headers.update({'Content-Type': content_type})
re... |
''
| def _build_response(self, resp):
| def build(resp):
response = Response()
response.config = self.config
if resp:
response.status_code = getattr(resp, 'status', None)
response.headers = CaseInsensitiveDict(getattr(resp, 'headers', None))
response.encoding = get_encoding_from_headers(response... |
''
| @staticmethod
def _encode_params(data):
| if isinstance(data, bytes):
return (data, data)
if (hasattr(data, '__iter__') and (not isinstance(data, str))):
data = dict(data)
if hasattr(data, 'items'):
result = []
for (k, vs) in list(data.items()):
for v in ((isinstance(vs, list) and vs) or [vs]):
... |
''
| @property
def full_url(self):
| if (not self.url):
raise URLRequired()
url = self.url
(scheme, netloc, path, params, query, fragment) = urlparse(url)
if (not scheme):
raise MissingSchema(('Invalid URL %r: No schema supplied' % url))
if (not (scheme in SCHEMAS)):
raise InvalidSchema(('Invalid ... |
''
| @property
def path_url(self):
| url = []
p = urlsplit(self.full_url)
if (p.scheme in self.proxies):
return self.full_url
path = p.path
if (not path):
path = '/'
url.append(path)
query = p.query
if query:
url.append('?')
url.append(query)
return ''.join(url)
|
''
| def register_hook(self, event, hook):
| return self.hooks[event].append(hook)
|
''
| def send(self, anyway=False, prefetch=False):
| url = self.full_url
if self.config.get('verbose'):
self.config.get('verbose').write(('%s %s %s\n' % (datetime.now().isoformat(), self.method, url)))
body = None
content_type = None
if self.files:
if (not isinstance(self.data, str)):
try:
... |
''
| def __bool__(self):
| return self.ok
|
''
| def __nonzero__(self):
| return self.ok
|
''
| def iter_content(self, chunk_size=(10 * 1024), decode_unicode=False):
| if self._content_consumed:
raise RuntimeError('The content for this response was already consumed')
def generate():
while 1:
chunk = self.raw.read(chunk_size)
if (not chunk):
break
(yield chunk)
self._content_consum... |
''
| def iter_lines(self, chunk_size=(10 * 1024), decode_unicode=None):
| pending = None
for chunk in self.iter_content(chunk_size=chunk_size, decode_unicode=decode_unicode):
if (pending is not None):
chunk = (pending + chunk)
lines = chunk.splitlines()
if (lines[(-1)][(-1)] == chunk[(-1)]):
pending = lines.pop()
else:
... |
''
| @property
def content(self):
| if (self._content is None):
try:
if self._content_consumed:
raise RuntimeError('The content for this response was already consumed')
if (self.status_code is 0):
self._content = None
else:
self._content =... |
''
| @property
def text(self):
| content = None
encoding = self.encoding
if (self.encoding is None):
encoding = self._detected_encoding()
try:
content = str(self.content, encoding, errors='replace')
except LookupError:
content = str(self.content, errors='replace')
except (UnicodeError, TypeError):
... |
''
| def raise_for_status(self, allow_redirects=True):
| if self.error:
raise self.error
if ((self.status_code >= 300) and (self.status_code < 400) and (not allow_redirects)):
http_error = HTTPError(('%s Redirection' % self.status_code))
http_error.response = self
raise http_error
elif ((self.status_code >= 400) and (self.status... |
''
| def handle_401(self, r):
| s_auth = r.headers.get('www-authenticate', '')
if ('digest' in s_auth.lower()):
last_nonce = ''
nonce_count = 0
chal = parse_dict_header(s_auth.replace('Digest ', ''))
realm = chal['realm']
nonce = chal['nonce']
qop = chal.get('qop')
algorithm = chal.ge... |
''
| def request(self, method, url, params=None, data=None, headers=None, cookies=None, files=None, auth=None, timeout=None, allow_redirects=True, proxies=None, hooks=None, return_response=True, config=None, prefetch=False, verify=None, cert=None):
| method = str(method).upper()
cookies = ({} if (cookies is None) else cookies)
data = ({} if (data is None) else data)
files = ({} if (files is None) else files)
headers = ({} if (headers is None) else headers)
params = ({} if (params is None) else params)
hooks = ({} if (hooks is None) else ... |
''
| def get(self, url, **kwargs):
| kwargs.setdefault('allow_redirects', True)
return self.request('get', url, **kwargs)
|
''
| def options(self, url, **kwargs):
| kwargs.setdefault('allow_redirects', True)
return self.request('options', url, **kwargs)
|
''
| def head(self, url, **kwargs):
| kwargs.setdefault('allow_redirects', False)
return self.request('head', url, **kwargs)
|
''
| def post(self, url, data=None, **kwargs):
| return self.request('post', url, data=data, **kwargs)
|
''
| def put(self, url, data=None, **kwargs):
| return self.request('put', url, data=data, **kwargs)
|
''
| def patch(self, url, data=None, **kwargs):
| return self.request('patch', url, data=data, **kwargs)
|
''
| def delete(self, url, **kwargs):
| return self.request('delete', url, **kwargs)
|
''
| def __init__(self, ns, parsers, multi=False, **kwargs):
| self.prompt = ('(%s) > ' % self.name)
self.ns = ns
self.parsers = parsers
self.payload = None
self.action_help = {}
self.action_types = {}
for parser in self.parsers:
for a in parser._actions:
self.action_help[a.dest] = a.help
self.action_types[a.dest] =... |
''
| def cmdloop(self, **kwargs):
| try:
Cmd.cmdloop(self, **kwargs)
except ExitException as e:
return
except Exception as e:
self.log.error(('cmdloop caught error: %s' % e))
self.continue_prompt('A critical error occurred. Would you like to keep this shell open?')
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.