rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
if self.replace[1]: newattrs[self.replace[1][0]] = self.replace[1][1] else: | for f in self.replace[1].split(): if '=' in self.replace[1]: k,v = f.split('=') newattrs[k] = v else: newattrs[self.replace[1]] = None elif part==ATTRVAL: | def filter_tag (self, tag, attrs): #debug(NIGHTMARE, "rule %s filter_tag" % self.title) part = self.replace[0] #debug(NIGHTMARE, "original tag", `tag`, "attrs", attrs) #debug(NIGHTMARE, "replace", num_part(part), "with", `self.replace[1]`) if part==TAGNAME: return (STARTTAG, self.replace[1], attrs) if part==TAG: return... |
if self.replace[0]==ATTR: val = self.replace[0][0]+'="'+self.replace[0][1]+'"' else: val = self.replace[1] s += '>'+xmlify(val)+"</replace>\n" | s += '>'+xmlify(self.replace[1])+"</replace>\n" | def toxml (self): s = UrlRule.toxml(self) if self.tag!='a': s += '\n tag="%s"' % self.tag if not (self.attrs or self.replace or self.enclosed): return s+"/>\n" s += ">\n" for key,val in self.attrs.items(): s += "<attr" if key!='href': s += ' name="%s"' % key if val: s += ">"+xmlify(val)+"</attr>\n" else: s += "/>\n" if... |
print "XXX", currule | def _form_selrule (index): """ Select a rule. """ try: index = int(index) global currule currule = [r for r in curfolder.rules if r.oid == index][0] print "XXX", currule # fill ruletype flags for rt in rulenames: ruletype[rt] = (currule.name == rt) # XXX this side effect is bad :( # fill part flags if currule.name == u... | |
self.request = "%s %s %s" % (self.method, self.url, self.protocol) wc.log.debug(wc.LOG_PROXY, "%s request %r", self, self.request) | request = "%s %s %s" % (self.method, self.url, self.protocol) wc.log.debug(wc.LOG_PROXY, "%s request %r", self, request) | def process_request (self): """read request, split it up and filter it""" # One newline ends request i = self.recv_buffer.find('\r\n') if i < 0: return # self.read(i) is not including the newline self.request = self.read(i) # basic request checking (more will be done below) try: self.method, self.url, protocol = self.r... |
self.request = wc.filter.applyfilter(self.request, "finish", attrs) | self.request = wc.filter.applyfilter(request, "finish", attrs) | def process_request (self): """read request, split it up and filter it""" # One newline ends request i = self.recv_buffer.find('\r\n') if i < 0: return # self.read(i) is not including the newline self.request = self.read(i) # basic request checking (more will be done below) try: self.method, self.url, protocol = self.r... |
data = wc.filter.applyfilter("", "finish", attrs) | data = wc.filter.applyfilter(data, "finish", attrs) | def process_content (self): """read and filter client request content""" data = self.read(self.bytes_remaining) if self.bytes_remaining is not None: # Just pass everything through to the server # NOTE: It's possible to have 'chunked' encoding here, # and then the current system of counting bytes remaining # won't work;... |
return (2L<<n-1)-1 | return (1L << (32 - n)) - 1 | def suffix2mask (n): "return a mask of n bits as a long integer" return (2L<<n-1)-1 |
return int(math.log(mask+1, 2)) | return 32 - int(math.log(mask+1, 2)) | def mask2suffix (mask): """return suff for given bit mask""" return int(math.log(mask+1, 2)) |
hosts = ["192.168.1.1/16"] hostmap = hosts2map(hosts) print hostmap print map2hosts(hostmap) | hosts, nets = hosts2map([ "192.168.2.1", "192.168.2.1/32", "192.168.2.1/31", "192.168.2.1/30", "192.168.2.1/29", "192.168.2.1/28", "192.168.2.1/27", "192.168.2.1/26", "192.168.2.1/25", "192.168.2.1/24", "192.168.2.1/23", "192.168.2.1/22", "192.168.2.1/21", "192.168.2.1/20", "192.168.2.1/19", "192.168.2.1/18", "192.168.... | def _test (): hosts = ["192.168.1.1/16"] hostmap = hosts2map(hosts) print hostmap print map2hosts(hostmap) |
if buf.len >= self.minimal_size_bytes: | if buf.tell() >= self.minimal_size_bytes: | def filter (self, data, **attrs): """feed data to recognizer""" if not attrs.has_key('mimerecognizer_buf'): return data buf = attrs['mimerecognizer_buf'] buf.write(data) if buf.len >= self.minimal_size_bytes: return self.recognize(buf, attrs) return '' |
if not self.allow.scheme(self.scheme): wc.log.warn(wc.LOG_PROXY, "%s forbidden scheme %r encountered", self, self.scheme) | if not self.allow.is_allowed(self.method, self.scheme, self.port): wc.log.warn(wc.LOG_PROXY, "Unallowed request %s", self.url) | def fix_request (self): # refresh with filtered request data self.method, self.url, self.protocol = self.request.split() # enforce a maximum url length if len(self.url) > 2048: wc.log.error(wc.LOG_PROXY, "%s request url length %d chars is too long", self, len(self.url)) self.error(400, _("URL too long"), txt=_('URL len... |
wc.log.error(wc.LOG_PROXY, "%s got %s status %d %r", | wc.log.debug(wc.LOG_PROXY, "%s got %s status %d %r", | def server_response (self, server, response, status, headers): """ Follow redirects, and finish on errors. For HTTP status 2xx continue. """ self.server = server assert self.server.connected wc.log.debug(wc.LOG_PROXY, '%s server_response %r', self, response) version, status, msg = \ wc.http.parse_http_response(response... |
if line.startswith("install_") or line.startswith("config_"): | if line.startswith("install_") or \ line.startswith("config_") or \ line.startswith("template_"): | def fix_configdata (): """fix install and config paths in the config file""" name = "_webcleaner2_configdata.py" conffile = os.path.join(sys.prefix, "Lib", "site-packages", name) lines = [] for line in file(conffile): if line.startswith("install_") or line.startswith("config_"): lines.append(fix_install_path(line)) els... |
curfolder.oid = len(config['folderrules']) | if not config['folderrules']: curfolder.oid = 0 else: curfolder.oid = config['folderrules'][-1].oid+1 | def _form_newfolder (foldername): if not foldername: error['newfolder'] = True return fd, filename = tempfile.mkstemp(".zap", "local_", ConfigDir, text=True) # select the new folder global curfolder curfolder = _FolderRule(title=foldername, desc="", disable=0, filename=filename) _register_rule(curfolder) _generate_sids... |
curfolder.rules.remove(rule) | rules = curfolder.rules rules.remove(rule) for i in range(rule.oid, len(rules)): rules[i].oid = i curfolder.write() | def _form_removerule (rule): # XXX error handling curfolder.rules.remove(rule) global currule currule = None curfolder.write() info['removerule'] = True |
curfolder.write() | def _form_removerule (rule): # XXX error handling curfolder.rules.remove(rule) global currule currule = None curfolder.write() info['removerule'] = True | |
def create_tcp_socket (self, sockinfo): | def create_tcp_socket (self): | def create_tcp_socket (self, sockinfo): """create tcp socket, connect to it and return socket object""" host = self.get('TCPAddr', 'localhost') port = int(self['TCPSocket']) sockinfo = get_sockinfo(host, port=port) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: sock.connect(sockinfo[0][4]) except socket.... |
"charset": wc.ConfigCharset, | "charset": wc.configuration.ConfigCharset, | def write_filters (res, filename): if os.path.exists(filename): remove(filename) zapfile = file(filename, 'w') d = { "charset": wc.ConfigCharset, "title_en": wc.XmlUtils.xmlquote("AdZapper filters"), "title_de": wc.XmlUtils.xmlquote("AdZapper Filter"), "desc_en": wc.XmlUtils.xmlquote("Automatically generated by adzap2w... |
p.feed("""<!------>""") | s = """< a>""" for c in s: p.feed(c) | def _broken (): p = HtmlPrinter() p.feed("""<!------>""") p.flush() |
data_url = "& "C:\\foo.mht!${PATH}/"+ "EXPLOIT.CHM::"+ | data_url = "& "C:\\foo.mht!${PATH}/"+ \ "EXPLOIT.CHM::"+ \ | def testITSVuln (self): """Microsoft Internet Explorer ITS Protocol Zone Bypass Vulnerability""" # To avoid virus alarms we obfuscate the exploit URL. This # code is harmless. data_url = "ms-its:mhtml:file://"+ "C:\\foo.mht!${PATH}/"+ "EXPLOIT.CHM::"+ "/exploit.htm" self.filt("""<object data="%s">""" % data_url, "... |
for ro in self.mimes: if ro.match(mime): self.mime_cache[mime] = True else: self.mime_cache[mime] = False | self.mime_cache[mime] = \ [ro for ro in self.mimes if ro.match(mime)] | def applies_to_mime (self, mime): """ Ask if this filter applies to a mime type. """ if mime not in self.mime_cache: if not self.mimes: self.mime_cache[mime] = True elif mime is None: self.mime_cache[mime] = False else: for ro in self.mimes: if ro.match(mime): self.mime_cache[mime] = True else: self.mime_cache[mime] = ... |
if not data: return debug(HURT_ME_PLENTY, 'Proxy: read', len(data), '<=', self) | def handle_read (self): if not self.connected: # It's been closed (presumably recently) return | |
raise wc.filter.FilterProxyError((406, _("Not acceptable"), | raise wc.filter.FilterProxyError(406, _("Not acceptable"), | def size_error (self): """ Raise an exceptionto cause a 406 HTTP return code. """ wc.log.warn(wc.LOG_FILTER, "Virus filter size exceeded.") raise wc.filter.FilterProxyError((406, _("Not acceptable"), _("Maximum data size (%s) exceeded") % \ wc.strformat.strsize(VirusFilter.MAX_FILE_BYTES))) |
wc.strformat.strsize(VirusFilter.MAX_FILE_BYTES))) | wc.strformat.strsize(VirusFilter.MAX_FILE_BYTES)) | def size_error (self): """ Raise an exceptionto cause a 406 HTTP return code. """ wc.log.warn(wc.LOG_FILTER, "Virus filter size exceeded.") raise wc.filter.FilterProxyError((406, _("Not acceptable"), _("Maximum data size (%s) exceeded") % \ wc.strformat.strsize(VirusFilter.MAX_FILE_BYTES))) |
print "XXX new rule", rule | def _form_newrule (rtype, lang): if rtype not in rulenames: error['newrule'] = True return # add new rule rule = _GetRuleFromName(rtype) rule.parent = curfolder rule.titles[lang] = _("No title") # compile data and register rule.compile_data() if config['development']: prefix = u"wc" else: prefix = u"lc" _generate_sids(... | |
"unsupported content encoding in %r", encoding) | "unsupported content encoding in %r", cenc) | def server_set_encoding_headers (server, filename=None): """ Set encoding headers. """ rewrite = server.is_rewrite() bytes_remaining = get_content_length(server.headers) to_remove = sets.Set() if server.headers.has_key('Transfer-Encoding'): to_remove.add('Transfer-Encoding') tencs = server.headers['Transfer-Encoding'].... |
if data and self.statuscode != 407: | if data and self.statuscode != 407 and hasattr(self.client, "server_content"): | def flush (self): """ Flush data of decoders (if any) and filters and write it to the client. return True if flush was successful. """ assert None == wc.log.debug(wc.LOG_PROXY, "%s HttpServer.flush", self) if not self.statuscode and self.method != 'CONNECT': wc.log.warn(wc.LOG_PROXY, "%s flush without status", self) re... |
return p.flush() | return p.getoutput() | def filter (self, data, **attrs): if not attrs.has_key('rewriter_filter'): return data p = attrs['rewriter_filter'] p.feed(data) return p.flush() |
return p.flush(finish=True) | p.flush() p.tagbuf2data() return p.getoutput() | def finish (self, data, **attrs): if not attrs.has_key('rewriter_filter'): return data p = attrs['rewriter_filter'] # note: feed even if data is empty p.feed(data) return p.flush(finish=True) |
return unicode(htmlentitydefs.entitydefs.get(ent, s)) | entdef = htmlentitydefs.entitydefs.get(ent) if entdef is None: return s return entdef.decode("iso8859-1") | def _resolve_html_entity (mo): """resolve html entity, helper function for resolve_html_entities""" ent = mo.group("entity") s = mo.group() return unicode(htmlentitydefs.entitydefs.get(ent, s)) |
body = random_chars(self.body_length) data = 'HTTP/1.1 200 OK\r\n' | self.server.log.write("server got request path %r\n"%self.path) if not jsfiles.has_key(self.path): data = "HTTP/1.1 404 Oops\r\n" body = "" else: data = 'HTTP/1.1 200 OK\r\n' body = jsfiles[self.path] | def do_GET (self): """send chunk data""" body = random_chars(self.body_length) data = 'HTTP/1.1 200 OK\r\n' data += "Date: %s\r\n" % self.date_time_string() data += "Transfer-Encoding: chunked\r\n" data += "Connection: close\r\n" data += "\r\n" data += "0000000000%s\r\n" % hex(self.body_length)[2:] data += "%s\r\n" % b... |
data += "Transfer-Encoding: chunked\r\n" | def do_GET (self): """send chunk data""" body = random_chars(self.body_length) data = 'HTTP/1.1 200 OK\r\n' data += "Date: %s\r\n" % self.date_time_string() data += "Transfer-Encoding: chunked\r\n" data += "Connection: close\r\n" data += "\r\n" data += "0000000000%s\r\n" % hex(self.body_length)[2:] data += "%s\r\n" % b... | |
data += "0000000000%s\r\n" % hex(self.body_length)[2:] data += "%s\r\n" % body data += "0\r\n\r\n" | data += body | def do_GET (self): """send chunk data""" body = random_chars(self.body_length) data = 'HTTP/1.1 200 OK\r\n' data += "Date: %s\r\n" % self.date_time_string() data += "Transfer-Encoding: chunked\r\n" data += "Connection: close\r\n" data += "\r\n" data += "0000000000%s\r\n" % hex(self.body_length)[2:] data += "%s\r\n" % b... |
class ChunkRequest (HttpRequest): def check_response (self, response): """check for 200 status and correct body data length""" if response.status!=200: return (self.VIOLATION, "Invalid HTTP status %r"%response.status) body = response.read() if len(body) != ChunkRequestHandler.body_length: return (self.VIOLATION, "Expec... | class TestScriptSrc (StandardTest): """All these tests work with a _default_ filter configuration. If you change any of the *.zap filter configs, tests can fail...""" | def do_GET (self): """send chunk data""" body = random_chars(self.body_length) data = 'HTTP/1.1 200 OK\r\n' data += "Date: %s\r\n" % self.date_time_string() data += "Transfer-Encoding: chunked\r\n" data += "Connection: close\r\n" data += "\r\n" data += "0000000000%s\r\n" % hex(self.body_length)[2:] data += "%s\r\n" % b... |
def name (self): return 'chunked-leading-zeros' | def init (self): wc.config = wc.Configuration() disable_rating_rules(wc.config) wc.config['filters'] = ['Rewriter',] wc.config.init_filter_modules() initlog(os.path.join("test", "logging.conf")) self.headers = WcMessage() self.headers['Content-Type'] = "text/html" self.log = sys.stdout self.serverthread = HttpServer.s... | def name (self): return 'chunked-leading-zeros' |
class TestChunkedEncoding (ProxyTest): def __init__ (self, methodName='runTest'): ProxyTest.__init__(self, methodName=methodName) request = ChunkRequest() self.addTest(request, handler_class=ChunkRequestHandler) | def testScriptSrc1 (self): self.filt( """<script src="http://localhost:%d/1.js"></script> </html>""" % HttpServer.defaultconfig['port'], """<script type="text/javascript"> <!-- %s//--> </script> </html>""" % jsfiles['/1.js']) def testScriptSrc2 (self): self.filt( """<script src="http://localhost:%d/1.js"> </script... | def name (self): return 'chunked-leading-zeros' |
unittest.main(defaultTest='TestChunkedEncoding') | unittest.main(defaultTest='TestScriptSrc') | def __init__ (self, methodName='runTest'): ProxyTest.__init__(self, methodName=methodName) request = ChunkRequest() self.addTest(request, handler_class=ChunkRequestHandler) |
suite = unittest.makeSuite(TestChunkedEncoding, 'test') | suite = unittest.makeSuite(TestScriptSrc, 'test') | def __init__ (self, methodName='runTest'): ProxyTest.__init__(self, methodName=methodName) request = ChunkRequest() self.addTest(request, handler_class=ChunkRequestHandler) |
return self.recognize(buf) | return self.recognize(buf, attrs) | def finish (self, data, **attrs): """feed data to recognizer""" if not attrs.has_key('mimerecognizer_buf'): return data buf = attrs['mimerecognizer_buf'] buf.write(data) return self.recognize(buf) |
if mime != attrs['mime']: | if not attrs['mime'].startswith(mime): | def recognize (self, buf, attrs): # note: recognizing a mime type fixes exploits like # CVE-2002-0025 and CVE-2002-0024 try: mime = wc.magic.classify(buf) if mime != attrs['mime']: wc.log.warn(wc.LOG_FILTER, "Adjusting MIME %r -> %r", attrs['mime'], mime) attrs['headers']['data']['Content-Type'] = "%s\r" % mime except ... |
del attrs['mimerecognizer_buf'] | def recognize (self, buf, attrs): # note: recognizing a mime type fixes exploits like # CVE-2002-0025 and CVE-2002-0024 try: mime = wc.magic.classify(buf) if mime != attrs['mime']: wc.log.warn(wc.LOG_FILTER, "Adjusting MIME %r -> %r", attrs['mime'], mime) attrs['headers']['data']['Content-Type'] = "%s\r" % mime except ... | |
lib_dir = distutils.get_python_lib(plat_specific=1) | lib_dir = distutils.sysconfig.get_python_lib(plat_specific=1) | def install_shortcuts (): """create_shortcut(target, description, filename[, arguments[, \ workdir[, iconpath[, iconindex]]]]) file_created(path) - register 'path' so that the uninstaller removes it directory_created(path) - register 'path' so that the uninstaller removes it get_special_folder_location(csidl_string)... |
script = os.path.join(script_dir, "webcleaner-certificates") | script = os.path.join(wc.ScriptDir, "webcleaner-certificates") | def install_certificates (): """generate SSL certificates for SSL gateway functionality""" pythonw = os.path.join(sys.prefix, "pythonw.exe") script = os.path.join(script_dir, "webcleaner-certificates") execute(pythonw, script, ["install"]) |
script = os.path.join(script_dir, "webcleaner-certificates") | script = os.path.join(wc.ScriptDir, "webcleaner-certificates") | def remove_certificates (): """generate SSL certificates for SSL gateway functionality""" pythonw = os.path.join(sys.prefix, "pythonw.exe") script = os.path.join(script_dir, "webcleaner-certificates") execute(pythonw, script, ["remove"]) |
wc.log.warn(wc.LOG_JS, | wc.log.debug(wc.LOG_JS, | def js_end_element (self, item): """ Parse generated html for scripts. """ wc.log.debug(wc.LOG_JS, "%s js_end_element buf %r", self, self.htmlparser.tagbuf) if len(self.htmlparser.tagbuf)<2: # syntax error, ignore wc.log.warn(wc.LOG_JS, "JS syntax error, self.tagbuf %r", self.htmlparser.tagbuf) return if self.js_src: w... |
res = {} | res = [] | def parse_adzapper_file (filename): res = {} is_comment = re.compile('^\s*(#.*)?$').match content = False # skip content until __DATA__ marker for line in open(filename): if not content: content = line.startswith('__DATA__') elif not is_comment(line): parse_adzapper_line(line.strip(), res) return res |
adclass, pattern = line.split(None, 1) res.setdefault(adclass.lower(), []).append(pattern) def write_filters (ads): | res.append(line.split(None, 1)) def write_filters (res): | def parse_adzapper_line (line, res): adclass, pattern = line.split(None, 1) res.setdefault(adclass.lower(), []).append(pattern) |
for adclass, pattern in res.items(): pattern = convert_adzapper_pattern(pattern) if adclass=='pass': write_allow(pattern) elif adclass='print': | for adclass, pattern in res: if adclass=='NOZAP': continue elif adclass=='PASS': pattern = convert_adzapper_pattern(pattern) write_allow(zapfile, adclass, pattern) elif adclass=='PRINT': | def write_filters (ads): filename = os.path.join("config", "adzapper.zap") if os.path.exists(filename): remove(filename) zapfile = file(filename, 'w') d = {"title": xmlify("AdZapper filters"), "desc": xmlify("Automatically generated on %s" % date), } zapfile.write("""<?xml version="1.0"?> |
pattern = re.sub(r"[^.]*[^?]", pattern, "[^/]*") | pattern = re.sub(r"([^.])\*([^?])", r"\1[^/]*\2", pattern) | def convert_adzapper_pattern (pattern): pattern = pattern.replace(".", "\\.") pattern = pattern.replace("?", "\\?") pattern = pattern.replace("**", ".*?") pattern = re.sub(r"[^.]*[^?]", pattern, "[^/]*") return pattern |
replace = re.sub(r"$(\d)", replace, r"\\1") | replace = re.sub(r"\$(\d)", r"\\1", replace) | def convert_adzapper_replace (replace): # replace Perl back references with Python ones replace = re.sub(r"$(\d)", replace, r"\\1") return replace |
def write_allow (zapfile, pattern): title = "AdZapper PASS filter" desc = "Automatically generated, you should not edit this filter." scheme, host, path, query, fragment = urlparse.urlsplit(pattern) d = locals() for key, value in d: d[key] = xmlify(value) | def write_allow (zapfile, adclass, pattern): d = get_rule_dict(adclass, pattern) | def write_allow (zapfile, pattern): title = "AdZapper PASS filter" desc = "Automatically generated, you should not edit this filter." scheme, host, path, query, fragment = urlparse.urlsplit(pattern) d = locals() for key, value in d: d[key] = xmlify(value) zapfile.write("""<allow title="%(title)s" desc="%(desc)s" scheme... |
scheme="%(scheme)s" host="%(host)s" path="%(path)s" query="%(query)s" fragment="%(fragment)s"/> | url="%(url)s" | def write_allow (zapfile, pattern): title = "AdZapper PASS filter" desc = "Automatically generated, you should not edit this filter." scheme, host, path, query, fragment = urlparse.urlsplit(pattern) d = locals() for key, value in d: d[key] = xmlify(value) zapfile.write("""<allow title="%(title)s" desc="%(desc)s" scheme... |
title = "AdZapper %s filter" % adclass desc = "Automatically generated, you should not edit this filter." scheme, host, path, query, fragment = urlparse.urlsplit(pattern) d = locals() for key, value in d: d[key] = xmlify(value) | d = get_rule_dict(adclass, pattern) | def write_block (zapfile, adclass, pattern, replacement=None): title = "AdZapper %s filter" % adclass desc = "Automatically generated, you should not edit this filter." scheme, host, path, query, fragment = urlparse.urlsplit(pattern) d = locals() for key, value in d: d[key] = xmlify(value) zapfile.write("""<block title... |
scheme="%(scheme)s" host="%(host)s" path="%(path)s" query="%(query)s" fragment="%(fragment)s" """ % d) if replacement: zapfile.write(">%(replacement)s</block>" % d) | url="%(url)s" """ % d) if replacement is not None: zapfile.write(">%s</block>" % xmlify(replacement)) | def write_block (zapfile, adclass, pattern, replacement=None): title = "AdZapper %s filter" % adclass desc = "Automatically generated, you should not edit this filter." scheme, host, path, query, fragment = urlparse.urlsplit(pattern) d = locals() for key, value in d: d[key] = xmlify(value) zapfile.write("""<block title... |
f = file(proxyconf_file()) | f = file(proxyconf_file(), 'w') | def write_proxyconf (self): """write proxy configuration""" f = file(proxyconf_file()) f.write("""<?xml version="1.0"?> |
""" | """) | def write_proxyconf (self): """write proxy configuration""" f = file(proxyconf_file()) f.write("""<?xml version="1.0"?> |
if self.allowedhosts: | if self['allowedhosts']: | def write_proxyconf (self): """write proxy configuration""" f = file(proxyconf_file()) f.write("""<?xml version="1.0"?> |
from glob import glob | def read_filterconf (self): """read filter rules""" from glob import glob # filter configuration for f in filterconf_files(): ZapperParser().parse(f, self) for f in self['rules']: f.sort() self['rules'].sort() filter.rules.FolderRule.recalc_oids(self['rules']) | |
if self.scheme != 'https': | if scheme != 'https': | def is_allowed (self, method, scheme, port): if not self.method(method): wc.log.warn(wc.LOG_PROXY, "illegal method %s", method) return False if scheme not in self.schemes: wc.log.warn(wc.LOG_PROXY, "illegal scheme %s", scheme) return False if method == 'CONNECT': # CONNECT method sanity if port not in self.connect_port... |
p.feed("<hTml>") | def _test(): p = HtmlPrinter() #p.feed("<hTml>") p.feed("<a href>") #p.feed("<a href=''>") #p.feed('<a href="">') #p.feed("<a href='a'>") #p.feed('<a href="a">') p.feed("<a href=a>") #p.feed("<a href='\"'>") #p.feed("<a href=\"'\">") #p.feed("<a href=' '>") #p.feed("<a href=a href=b>") #p.feed("<a/>") #p.feed("<a href/... | |
p.feed("<a href=''>") p.feed('<a href="">') p.feed("<a href='a'>") p.feed('<a href="a">') | def _test(): p = HtmlPrinter() #p.feed("<hTml>") p.feed("<a href>") #p.feed("<a href=''>") #p.feed('<a href="">') #p.feed("<a href='a'>") #p.feed('<a href="a">') p.feed("<a href=a>") #p.feed("<a href='\"'>") #p.feed("<a href=\"'\">") #p.feed("<a href=' '>") #p.feed("<a href=a href=b>") #p.feed("<a/>") #p.feed("<a href/... | |
p.feed("<a href='\"'>") p.feed("<a href=\"'\">") p.feed("<a href=' '>") p.feed("<a href=a href=b>") p.feed("<a/>") p.feed("<a href/>") p.feed("<a href=a />") p.feed("</a>") p.feed("<?bla foo?>") p.feed("<?bla?>") p.feed("<!-- - comment -->") p.feed("<!---->") p.feed("<!DOCTYPE \"vla foo>") | def _test(): p = HtmlPrinter() #p.feed("<hTml>") p.feed("<a href>") #p.feed("<a href=''>") #p.feed('<a href="">') #p.feed("<a href='a'>") #p.feed('<a href="a">') p.feed("<a href=a>") #p.feed("<a href='\"'>") #p.feed("<a href=\"'\">") #p.feed("<a href=' '>") #p.feed("<a href=a href=b>") #p.feed("<a/>") #p.feed("<a href/... | |
p.feed("") | p.feed("<img bo\\\nrder=0>") | def _broken (): p = HtmlPrinter() p.feed("") p.flush() |
_test() | _broken() | def _broken (): p = HtmlPrinter() p.feed("") p.flush() |
if not challenge.startswith('NTLMSSP\x00'): | if "," in challenge: chal, remainder = challenge.split(",", 1) else: chal, remainder = challenge, "" chal = base64.decodestring(chal.strip()) if not chal.startswith('NTLMSSP\x00'): res['type'] = 0 | def parse_ntlm_challenge (challenge): """parse both type0 and type2 challenges""" res = {} if not challenge.startswith('NTLMSSP\x00'): return res, challenge res['nonce'] = challenge[24:32] return res, challenge[40:] |
res['nonce'] = challenge[24:32] return res, challenge[40:] | res['nonce'] = chal[24:32] res['type'] = 2 return res, remainder.strip() | def parse_ntlm_challenge (challenge): """parse both type0 and type2 challenges""" res = {} if not challenge.startswith('NTLMSSP\x00'): return res, challenge res['nonce'] = challenge[24:32] return res, challenge[40:] |
pass | res = {} if "," in credentials: creds, remainder = credentials.split(",", 1) else: creds, remainder = credentials, "" creds = base64.decodestring(creds.strip()) if not creds.startswith('NTLMSSP\x00'): return res, remainder.strip() type = creds[8] if type==1: res['type'] = 1 domain_len = int(creds[16:18]) domain_off = ... | def parse_ntlm_credentials (credentials): """parse both type1 and type3 credentials""" # XXX pass |
def create_message2 (flags="\x82\x01"): | def create_message2 (): | def create_message2 (flags="\x82\x01"): protocol = 'NTLMSSP\x00' #name type = '\x02' msglen = '\x28' nonce = "%08f" % (random.random()*10) assert nonce not in nonces nonces[nonce] = None zero2 = '\x00' * 2 zero7 = '\x00' * 7 zero8 = '\x00' * 8 return "%(protocol)s%(type)s%(zero7)s%(msglen)s%(zero2)s%(nonce)s%(zero8)... |
nonce = "%08f" % (random.random()*10) | zero2 = '\x00'*2 flags="\x82\x01" nonce = "%08d" % (random.random()*100000000) | def create_message2 (flags="\x82\x01"): protocol = 'NTLMSSP\x00' #name type = '\x02' msglen = '\x28' nonce = "%08f" % (random.random()*10) assert nonce not in nonces nonces[nonce] = None zero2 = '\x00' * 2 zero7 = '\x00' * 7 zero8 = '\x00' * 8 return "%(protocol)s%(type)s%(zero7)s%(msglen)s%(zero2)s%(nonce)s%(zero8)... |
zero2 = '\x00' * 2 zero7 = '\x00' * 7 zero8 = '\x00' * 8 return "%(protocol)s%(type)s%(zero7)s%(msglen)s%(zero2)s%(nonce)s%(zero8)s" % locals() | zero8 = '\x00'*8 return "%(protocol)s%(type)s%(zero7)s%(msglen)s%(zero2)s%(flags)s%(zero2)s%(nonce)s%(zero8)s" % locals() | def create_message2 (flags="\x82\x01"): protocol = 'NTLMSSP\x00' #name type = '\x02' msglen = '\x28' nonce = "%08f" % (random.random()*10) assert nonce not in nonces nonces[nonce] = None zero2 = '\x00' * 2 zero7 = '\x00' * 7 zero8 = '\x00' * 8 return "%(protocol)s%(type)s%(zero7)s%(msglen)s%(zero2)s%(nonce)s%(zero8)... |
protocol = 'NTLMSSP\000' type = '\003\000' head = protocol + type + '\000\000' | protocol = 'NTLMSSP\x00' type = '\x03' head = protocol + type + '\x00'*3 | def create_message3 (nonce, domain, username, host, flags="\x82\x01", lm_hashed_pw=None, nt_hashed_pw=None, ntlm_mode=0): protocol = 'NTLMSSP\000' #name type = '\003\000' #type 3 head = protocol + type + '\000\000' domain_rec = record(domain) user_rec = record(username) host_rec = record(ho... |
def parse_message2 (msg2): msg2 = base64.decodestring(msg2) nonce = msg2[24:32] return nonce | def parse_message2 (msg2): msg2 = base64.decodestring(msg2) # protocol = msg2[0:7] # msg_type = msg2[7:9] nonce = msg2[24:32] return nonce | |
def debug_message1 (msg): m_ = base64.decodestring(msg) m_hex = utils.str2hex(m_) res = '==============================================================\n' res += 'NTLM Message 1 report:\n' res += '---------------------------------\n' res += 'Base64: %s\n' % msg res += 'String: %s\n' % utils.str2prn_str(m_) res += 'Hex:... | def unknown_part (bin_str): res = 'Hex : %s\n' % utils.str2hex(bin_str, ' ') res += 'String : %s\n' % utils.str2prn_str(bin_str, ' ') res += 'Decimal: %s\n' % utils.str2dec(bin_str, ' ') return res | |
return end | return end-size | def size_number (text): base = which_base(text) if base == 0: return 0 length = len(text) size = size_base(base) end = size+1 while end < length and text[end] in _hex[:base]: end += 1 return end |
end = size_number(text) | end = start+size_number(text) | def convert (text): base = which_base(text) start = size_base(base) end = size_number(text) return base10(text[start:end], base) |
if __name__ == '__main__': print "---" print "base10(\"FF\",16) = ", 255, "\tgot ", base10("FF",16) print "base10(\"77\", 8) = ", 63, "\tgot ", base10("77",8) print "---" print "convert(\"0xFF\" ) = ", 255, "\tgot ", convert("0xFF") print "convert(\"\\xFF\" ) = ", 255, "\tgot ", convert("\\xFF") print "convert(\"07... | def local4 (number): if sys.byteorder == 'big': return big4(number) return little4(number) | |
debug(PROXY, "%s closed, got empty data") | debug(PROXY, "%s closed, got empty data", self) | def handle_read (self): """read data from connection, put it into recv_buffer and call process_read""" assert self.connected |
debug(FILTER, "blocked url %s", url) | debug(FILTER, "blocked url %s: %s", url, str(blocked)) | def doit (self, data, **args): # note: data is the complete request method, url, httpver = data.split() debug(FILTER, "block filter working on url %s", `url`) if self.allowed(url): return data blocked = self.strict_whitelist or self.blocked(url) if blocked: debug(FILTER, "blocked url %s", url) if isinstance(blocked, ba... |
self.log.debug("Translating %s" % `args`) | self.log.debug("Translating %s with %s", `args`, str(self.translator)) | def cmdOutput (self, command, args): if self.translator is not None and self.translateContent: self.log.debug("Translating %s" % `args`) self.file.write(self.translator.gettext(args) % \ self.context.getVariableMap()) else: self.file.write (args) self.programCounter += 1 |
self.log.debug("Translating %s" % `result.value()`) | self.log.debug("Translating %s with %s", `result.value()`, str(self.translator)) | def cmdI18nTranslate (self, command, args): """ args: translation string, translation args, endTagSymbol Translate tag content. If the translation string is an empty string, the translate message id is the tag content. Otherwise, the value of the tag content is the message id. """ # an empty string means use tag conten... |
self.log.debug("Translating %s" % `attExpr`) | self.log.debug("Translating %s with %s", `attExpr`, str(self.translator)) | def cmdI18nAttributes (self, command, args): |
def _write_color_nt (text, color): | def _write_color_nt (fp, text, color): | def _write_color_nt (text, color): """ Assumes WConio has been imported at module level. """ oldcolor = WConio.gettextinfo()[4] oldtextcolor = oldcolor & 0x000F if ";" in color: control, color = color.split(";", 1) WConio.textcolor(WConioColor.get(color, oldtextcolor)) fp.write(text) WConio.textattr(oldcolor) |
logging.getLogger(log).debug(msg, *args) | def debug (log, msg, *args): #logging.getLogger(log).debug("collected %d"%gc.collect()) #logging.getLogger(log).debug("objects %d"%len(gc.get_objects())) #logging.getLogger(log).debug("garbage %d"%len(gc.garbage)) #logging.getLogger(log).debug("Mem: %s"%usedmemory()) logging.getLogger(log).debug(msg, *args) | |
% tag) | ) | def testImgWidthHeight (self): for tag in ("width", "height"): self.filt("""<img %s="9999">""" % tag, """<img %s="9999">""" % tag) self.filt("""<img %s="12345">""" % tag, """<img>""" % tag) |
JSFilter(self.url, **opts) | return JSFilter(self.url, opts) | def new_instance (self, **opts): JSFilter(self.url, **opts) |
super(SetList), self).__setitem__(key, value) | super(SetList, self).__setitem__(key, value) | def __setitem__ (self, key, value): if value not in self: super(SetList), self).__setitem__(key, value) |
def do_install (): """ Install shortcuts and NT service. """ fix_configdata() import wc wc.init_i18n() install_shortcuts() install_certificates() install_service() restart_service() open_browser_config() | def fix_install_path (line): """ Replace placeholders written by bdist_wininst with those specified in win_path_scheme. """ key, eq, val = line.split() # unescape string (do not use eval()) val = val[1:-1].replace("\\\\", "\\") for d in win_path_scheme.keys(): # look for placeholders to replace oldpath, newpath = win_p... | |
def state_nt_service (name): """ Return status of NT service. """ try: return win32serviceutil.QueryServiceStatus(name)[1] except pywintypes.error, msg: print _("Service status error: %s") % str(msg) return None def install_service (): """ Install WebCleaner as NT service. """ import wc import wc.win32start oldargs =... | def install_adminpassword (): """ Ask for admin password if not already set. """ if has_adminpassword(): return import wc import Tkinter as tk root = init_tk() import tkSimpleDialog class PasswordDialog (tkSimpleDialog.Dialog): """ Admin password dialog. """ def body(self, master): d = {"appname": wc.AppName} msg = ... | def state_nt_service (name): """ Return status of NT service. """ try: return win32serviceutil.QueryServiceStatus(name)[1] except pywintypes.error, msg: print _("Service status error: %s") % str(msg) return None |
from Tkinter import tkMessageBox answer = tkMessageBox.askyesno(_("Purge local config"), _("""Do you want to remove your local filter rules? They can be re-used in other installations of %s, but are useless otherwise.""")) | init_tk() import tkMessageBox answer = tkMessageBox.askyesno(_("%s config purge") % wc.AppName, _("""There are local filter rules in the configuration directory. Do you want to remove them? They can be re-used in other installations of %s, but are useless otherwise.""") % wc.AppName) | def purge_tempfiles (): """ Ask if user wants to purge local config files. """ files = glob.glob(os.path.join(wc.ConfigDir, "local_*.zap")) if not files: return from Tkinter import tkMessageBox answer = tkMessageBox.askyesno(_("Purge local config"), _("""Do you want to remove your local filter rules? |
print _("Could not remove %r: %s") % (fname, str(msg)) | print _("Could not remove file %r: %s") % (fname, str(msg)) def is_empty_dir (name): """ Check if given name is a non-empty directory. """ return os.path.isdir(name) and not os.listdir(name) def remove_empty_directories (dname): """ Remove empty directory structure. """ try: if is_empty_dir(dname): os.rmdir(dname) ... | def remove_file (fname): """ Remove a single file if it exists. Errors are printed to stdout. """ if os.path.exists(fname): try: os.remove(fname) except OSError, msg: print _("Could not remove %r: %s") % (fname, str(msg)) |
se_offset_abs = "^\(([0\\\][xX][\dA-Fa-f]+|[0\\\][0-7]*|\d+)" \ "(\.[bslBSL])*\)" se_offset_add = "^\(([0\\\][xX][\dA-Fa-f]+|[0\\\][0-7]*|\d+)" \ "(\.[bslBSL])*([-+])([0\\\][xX][\dA-Fa-f]+|[0\\\][0-7]*|\d+)\)" | se_offset_abs = re.compile( r"^\(([0\\\][xX][\dA-Fa-f]+|[0\\\][0-7]*|\d+)" \ r"(\.[bslBSL])*\)").match se_offset_add = re.compile( r"^\(([0\\\][xX][\dA-Fa-f]+|[0\\\][0-7]*|\d+)" \ r"(\.[bslBSL])*([-+])([0\\\][xX][\dA-Fa-f]+|[0\\\][0-7]*|\d+)\)").match | def dump (o, f): """pickle object o to file f""" cPickle.dump(o, f, pickle.HIGHEST_PROTOCOL) |
match_abs = re.compile(self.se_offset_abs).match(text) match_add = re.compile(self.se_offset_add).match(text) | match_abs = self.se_offset_abs(text) match_add = self.se_offset_add(text) | def _offset (self, text): direct = self._direct_offset(text) offset_type = 'l' offset_delta = 0L offset_relatif = 0L |
if line and not line.startswith(' part = self._split(line) while len(part) < 4: part.append('\b') level = self._level(part[0]) offset_string = self._strip_start('&', part[0][level:]) (direct, offset_type, offset_delta, offset_relatif) = \ self._offset(offset_string) (oper, mask, rest) = self._oper_mask(part... | if not line or line.startswith(' continue part = self._split(line) while len(part) < 4: part.append(r'\b') level = self._level(part[0]) offset_string = self._strip_start('&', part[0][level:]) (direct, offset_type, offset_delta, offset_relatif) = \ self._offset(offset_string) (oper, mask, rest) = self._oper... | def read_magic (self, magic_file): self.magic = [] |
value = 0 | value = data | def _convert (self, kind, endian, data): # Can raise StandardError and IOError value = 0 |
s = u'<Rule %s sid="%s"' % (self.get_name(), | s = u'<%s sid="%s"' % (self.get_name(), | def toxml (self): """Rule data as XML for storing, must be overridden in subclass""" s = u'<Rule %s sid="%s"' % (self.get_name(), wc.XmlUtils.xmlquoteattr(self.sid)) if self.disable: s += u' disable="%d"' % self.disable return s |
self.filt("""<frameset><frame src="aaa"><embed name="sp", style><applet hspace="file:\\">""", """<frameset><frame src="aaa"><embed name="sp", style><applet>""") | self.filt("""<frameset><frame src="aaa"><embed name="sp" style><applet hspace="file:\\\\">""", """<frameset><frame src="aaa"><embed name="sp" style><applet>""") | def testAppletHspace (self): self.filt("""<frameset><frame src="aaa"><embed name="sp", style><applet hspace="file:\\">""", """<frameset><frame src="aaa"><embed name="sp", style><applet>""") |
self.jsScript(script, ver) return 1 | return self.jsScript(script, ver) | def jsScriptSrc (self, url, language): if not url: return url = urlparse.urljoin(self.url, url) #debug(HURT_ME_PLENTY, "jsScriptSrc", url, language) try: script = urlutils.open_url(url).read() except: print >>sys.stderr, "exception fetching script url", `url` return if not script: return ver = 0.0 if language: mo = re.... |
self.jsfilter.flush() self.data.append(self.jsfilter.flushbuf()) self.buffer += self.jsfilter.buffer self.rulestack += self.jsfilter.rulestack | if self.output_counter: self.jsfilter.flush() self.data.append(self.jsfilter.flushbuf()) self.buffer += self.jsfilter.buffer self.rulestack += self.jsfilter.rulestack | def jsScript (self, script, ver): """execute given script with javascript version ver""" #debug(HURT_ME_PLENTY, "jsScript", script, ver) self.jsEnv.attachListener(self) self.jsfilter = HtmlFilter(self.rules, self.url, comments=self.comments, javascript=self.javascript) self.jsEnv.executeScript(script, ver) self.jsEnv.d... |
if not filtered and self.javascript and tag=='script': self.jsEndElement(tag) | if not filtered and self.javascript and tag=='script' and \ self.jsEndElement(tag): del self.buffer[-1] del self.buffer[-1] | def endElement (self, tag): """We know the following: if a rule matches, it must be the one on the top of the stack. So we look only at the top rule. |
if not self.buffer: print >>sys.stderr, "empty buffer on </script>" | if len(self.buffer)<2: | def jsEndElement (self, tag): """parse generated html for scripts""" if not self.buffer: print >>sys.stderr, "empty buffer on </script>" return if self.buffer[-1][0]!=DATA: print >>sys.stderr, "missing data for </script>", self.buffer[-1:] return script = self.buffer[-1][1].strip() del self.buffer[-1] if not (self.buff... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.