def searchExploit(exploit_list, soft_name, soft_version):
""" Search affected packages in exploit_list """
result = []
version_search = versionVartions(soft_version, args.level)
for exploit in exploit_list:
if exploit[5] in valid_platforms and (args.dos or exploit[6]!='dos' or args.type == 'dos'): # Platform and DoS
if args.filter == None or args.filter.lower() in exploit[2].lower(): # Filter
if args.type == None or args.type == exploit[6]: # Type
query = "(^(\w*\s){0,%s}|/\s?)%s(\s|\s.*\s|\/).* -" % (args.level, soft_name.replace('+', '\+'))
if re.search(query, exploit[2],re.IGNORECASE):
affected_versions = extractVersions(exploit[2])
for affected_version in affected_versions:
if args.level == 5 or LooseVersion(version_search) <= LooseVersion(affected_version):
if args.duplicates == False: exploit_list.remove(exploit) # Duplicates
printOutput(exploit, soft_name, soft_version)
result.append([exploit, soft_name, soft_version])
break
return result
python类IGNORECASE的实例源码
linux-soft-exploit-suggester.py 文件源码
项目：linux-soft-exploit-suggester
作者: belane
项目源码
文件源码
阅读 32
收藏 0
点赞 0
评论 0
def __fmt_key(self, key):
"""Formats the hash key for more consistent hits; hence fetching the
'Message-ID' key should still be fetched even if the user indexes
with 'message-id'.
"""
def _fmt(_k):
return _k.group(1) + _k.group(2).upper()
if not isinstance(key, basestring):
# Handle invalid key entries types
key = str(key)
key = re.sub(
# Flip -id to ID (short for Identifier)
# Flip -crc to CRC (short for Cyclic Redundancy Check)
r'([_-])((id|crc)([^a-z0-9]|$))',
_fmt,
re.sub(r'(^|\s|[_-])(\S)', _fmt, key.strip().lower()),
flags=re.IGNORECASE,
)
if key in VALID_HEADER_ENTRIES or key.startswith(UNKNOWN_PREFIX):
return key
return UNKNOWN_PREFIX + key
def scan_thread(keyword, catalog_json):
# Check each thread, threads who contains the keyword are returned
matched_threads = []
for i in range(len(catalog_json)):
for thread in catalog_json[i]["threads"]:
regex = r'\b{0}\b'.format(keyword)
# Search thread title
if 'sub' in thread:
if re.search(regex, str(thread["sub"]), re.IGNORECASE):
matched_threads.append(thread["no"])
# Search OPs post body
if 'com' in thread:
if re.search(regex, str(thread["com"]), re.IGNORECASE):
matched_threads.append(thread["no"])
return matched_threads
def parse150(resp):
'''Parse the '150' response for a RETR request.
Returns the expected transfer size or None; size is not guaranteed to
be present in the 150 message.
'''
if resp[:3] != '150':
raise error_reply, resp
global _150_re
if _150_re is None:
import re
_150_re = re.compile("150 .* \((\d+) bytes\)", re.IGNORECASE)
m = _150_re.match(resp)
if not m:
return None
s = m.group(1)
try:
return int(s)
except (OverflowError, ValueError):
return long(s)
def pickline(file, key, casefold = 1):
try:
f = open(file, 'r')
except IOError:
return None
pat = re.escape(key) + ':'
prog = re.compile(pat, casefold and re.IGNORECASE)
while 1:
line = f.readline()
if not line: break
if prog.match(line):
text = line[len(key)+1:]
while 1:
line = f.readline()
if not line or not line[0].isspace():
break
text = text + line
return text.strip()
return None
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
r = client.request(urlparse.urljoin(self.base_link, self.conf_link), XHR=True)
r = json.loads(r).get('streamer')
r = client.request(r + '%s.mp4/master.m3u8' % url, XHR=True)
r = re.findall('RESOLUTION\s*=\s*\d+x(\d+).*?\n(http.*?)(?:\n|$)', r, re.IGNORECASE)
r = [(source_utils.label_to_quality(i[0]), i[1]) for i in r]
for quality, link in r:
sources.append({'source': 'CDN', 'quality': quality, 'language': 'de', 'url': link, 'direct': True, 'debridonly': False})
return sources
except:
return sources
def checkTextodefinitivoarray(type,array,aprobdef):
tpe = AmendmentFlow.hasfinishTextorEnmienda(type)
if tpe:
if aprobdef:
for element in array:
if re.search("aprobaci(.+?)n(.*?)definitiva", element, re.IGNORECASE):
return True
return None
else:
amendfinish = AmendmentFlow.getFinishText(type)
for element in array:
for texa in amendfinish:
if re.search(texa, element, re.IGNORECASE):
return True
return None
else:
return None
def funMatch(args, **options):
try:
[2, 3].index(len(args))
except ValueError:
raise ParseError("match expects either two or three arguments")
flags = 0
if len(args) == 3:
if args[2] == 'i':
flags = re.IGNORECASE
else:
raise ParseError('match only supports the ignore case flag "i"')
if re.search(args[1],args[0],flags):
return "true"
else:
return "false"
def str_flags_to_int(str_flags):
flags = 0
if "i" in str_flags:
flags |= re.IGNORECASE
if "l" in str_flags:
flags |= re.LOCALE
if "m" in str_flags:
flags |= re.MULTILINE
if "s" in str_flags:
flags |= re.DOTALL
if "u" in str_flags:
flags |= re.UNICODE
if "x" in str_flags:
flags |= re.VERBOSE
return flags
def __init__(self, pattern, flags=0):
"""BSON regular expression data.
This class is useful to store and retrieve regular expressions that are
incompatible with Python's regular expression dialect.
:Parameters:
- `pattern`: string
- `flags`: (optional) an integer bitmask, or a string of flag
characters like "im" for IGNORECASE and MULTILINE
"""
if not isinstance(pattern, (text_type, bytes)):
raise TypeError("pattern must be a string, not %s" % type(pattern))
self.pattern = pattern
if isinstance(flags, string_type):
self.flags = str_flags_to_int(flags)
elif isinstance(flags, int):
self.flags = flags
else:
raise TypeError(
"flags must be a string or int, not %s" % type(flags))
def _encode_regex(name, value, dummy0, dummy1):
"""Encode a python regex or bson.regex.Regex."""
flags = value.flags
# Python 2 common case
if flags == 0:
return b"\x0B" + name + _make_c_string_check(value.pattern) + b"\x00"
# Python 3 common case
elif flags == re.UNICODE:
return b"\x0B" + name + _make_c_string_check(value.pattern) + b"u\x00"
else:
sflags = b""
if flags & re.IGNORECASE:
sflags += b"i"
if flags & re.LOCALE:
sflags += b"l"
if flags & re.MULTILINE:
sflags += b"m"
if flags & re.DOTALL:
sflags += b"s"
if flags & re.UNICODE:
sflags += b"u"
if flags & re.VERBOSE:
sflags += b"x"
sflags += b"\x00"
return b"\x0B" + name + _make_c_string_check(value.pattern) + sflags
def _adjust_header(type_, orig_header):
"""
Make sure 'pythonw' is used for gui and and 'python' is used for
console (regardless of what sys.executable is).
"""
pattern = 'pythonw.exe'
repl = 'python.exe'
if type_ == 'gui':
pattern, repl = repl, pattern
pattern_ob = re.compile(re.escape(pattern), re.IGNORECASE)
new_header = pattern_ob.sub(string=orig_header, repl=repl)
clean_header = new_header[2:-1].strip('"')
if sys.platform == 'win32' and not os.path.exists(clean_header):
# the adjusted version doesn't exist, so return the original
return orig_header
return new_header
def parse_str(self, gen_str):
"""Attempts to extract the information from a generic interface."""
# Right now I'm going to punt. There are so many variations
# on these that it's difficult to write a RE for it. Also
# there are few ways to have to rewrite it. We will extract
# a name, and then a type string (which may include defaults)
gen_pattern = r'\s?(?P<name>.*?)\s?(?::)\s?(?P<type>.*)'
gp = re.compile(gen_pattern, re.IGNORECASE)
s = re.search(gp, gen_str)
if s:
self.name = s.group('name')
# Sometimes the type has a trailing space. Eliminating it.
self.type = re.sub(r'\s*$', '', s.group('type'))
self.success = True
else:
print('vhdl-mode: Could not parse generic string.')
self.success = False
def str_flags_to_int(str_flags):
flags = 0
if "i" in str_flags:
flags |= re.IGNORECASE
if "l" in str_flags:
flags |= re.LOCALE
if "m" in str_flags:
flags |= re.MULTILINE
if "s" in str_flags:
flags |= re.DOTALL
if "u" in str_flags:
flags |= re.UNICODE
if "x" in str_flags:
flags |= re.VERBOSE
return flags
def __init__(self, pattern, flags=0):
"""BSON regular expression data.
This class is useful to store and retrieve regular expressions that are
incompatible with Python's regular expression dialect.
:Parameters:
- `pattern`: string
- `flags`: (optional) an integer bitmask, or a string of flag
characters like "im" for IGNORECASE and MULTILINE
"""
if not isinstance(pattern, string_types):
raise TypeError("pattern must be a string, not %s" % type(pattern))
self.pattern = pattern
if isinstance(flags, string_types):
self.flags = str_flags_to_int(flags)
elif isinstance(flags, int):
self.flags = flags
else:
raise TypeError(
"flags must be a string or int, not %s" % type(flags))
def _adjust_header(type_, orig_header):
"""
Make sure 'pythonw' is used for gui and and 'python' is used for
console (regardless of what sys.executable is).
"""
pattern = 'pythonw.exe'
repl = 'python.exe'
if type_ == 'gui':
pattern, repl = repl, pattern
pattern_ob = re.compile(re.escape(pattern), re.IGNORECASE)
new_header = pattern_ob.sub(string=orig_header, repl=repl)
clean_header = new_header[2:-1].strip('"')
if sys.platform == 'win32' and not os.path.exists(clean_header):
# the adjusted version doesn't exist, so return the original
return orig_header
return new_header
def str_flags_to_int(str_flags):
flags = 0
if "i" in str_flags:
flags |= re.IGNORECASE
if "l" in str_flags:
flags |= re.LOCALE
if "m" in str_flags:
flags |= re.MULTILINE
if "s" in str_flags:
flags |= re.DOTALL
if "u" in str_flags:
flags |= re.UNICODE
if "x" in str_flags:
flags |= re.VERBOSE
return flags
def __init__(self, pattern, flags=0):
"""BSON regular expression data.
This class is useful to store and retrieve regular expressions that are
incompatible with Python's regular expression dialect.
:Parameters:
- `pattern`: string
- `flags`: (optional) an integer bitmask, or a string of flag
characters like "im" for IGNORECASE and MULTILINE
"""
if not isinstance(pattern, string_types):
raise TypeError("pattern must be a string, not %s" % type(pattern))
self.pattern = pattern
if isinstance(flags, string_types):
self.flags = str_flags_to_int(flags)
elif isinstance(flags, int):
self.flags = flags
else:
raise TypeError(
"flags must be a string or int, not %s" % type(flags))
def _adjust_header(type_, orig_header):
"""
Make sure 'pythonw' is used for gui and and 'python' is used for
console (regardless of what sys.executable is).
"""
pattern = 'pythonw.exe'
repl = 'python.exe'
if type_ == 'gui':
pattern, repl = repl, pattern
pattern_ob = re.compile(re.escape(pattern), re.IGNORECASE)
new_header = pattern_ob.sub(string=orig_header, repl=repl)
clean_header = new_header[2:-1].strip('"')
if sys.platform == 'win32' and not os.path.exists(clean_header):
# the adjusted version doesn't exist, so return the original
return orig_header
return new_header
def str_flags_to_int(str_flags):
flags = 0
if "i" in str_flags:
flags |= re.IGNORECASE
if "l" in str_flags:
flags |= re.LOCALE
if "m" in str_flags:
flags |= re.MULTILINE
if "s" in str_flags:
flags |= re.DOTALL
if "u" in str_flags:
flags |= re.UNICODE
if "x" in str_flags:
flags |= re.VERBOSE
return flags
def __init__(self, pattern, flags=0):
"""BSON regular expression data.
This class is useful to store and retrieve regular expressions that are
incompatible with Python's regular expression dialect.
:Parameters:
- `pattern`: string
- `flags`: (optional) an integer bitmask, or a string of flag
characters like "im" for IGNORECASE and MULTILINE
"""
if not isinstance(pattern, string_types):
raise TypeError("pattern must be a string, not %s" % type(pattern))
self.pattern = pattern
if isinstance(flags, string_types):
self.flags = str_flags_to_int(flags)
elif isinstance(flags, int):
self.flags = flags
else:
raise TypeError(
"flags must be a string or int, not %s" % type(flags))
def __init__(self, pattern, flags=0):
"""BSON regular expression data.
This class is useful to store and retrieve regular expressions that are
incompatible with Python's regular expression dialect.
:Parameters:
- `pattern`: string
- `flags`: (optional) an integer bitmask, or a string of flag
characters like "im" for IGNORECASE and MULTILINE
"""
if not isinstance(pattern, string_types):
raise TypeError("pattern must be a string, not %s" % type(pattern))
self.pattern = pattern
if isinstance(flags, string_types):
self.flags = str_flags_to_int(flags)
elif isinstance(flags, int):
self.flags = flags
else:
raise TypeError(
"flags must be a string or int, not %s" % type(flags))
def get_year(self):
try:
yre = '(dei:DocumentFiscalYearFocus$)'
year = self.ins_sp.find(name=re.compile(yre, re.IGNORECASE | re.MULTILINE)).get_text()
except AttributeError:
try:
yre = '(dei:DocumentPeriodEndDate$)'
year = self.ins_sp.find(name=re.compile(yre, re.IGNORECASE | re.MULTILINE)).get_text()
year = year[:4]
except AttributeError:
return False
try:
year = int(year)
sure_years = [2001, 2002, 2003, 2004, 2005,
2006, 2007, 2008, 2009, 2011,
2012, 2013, 2014, 2016]
if year in sure_years:
self.xbrl_year = str(year)
if year == 2010:
self.xbrl_year = '2009'
if year == 2015:
self.xbrl_year = '2014'
return True
except:
return False
def searchMessageBodies(self, term=None):
if (not self.srv):
return
if (not term):
return
self.getMessages()
matched = []
i = 1
for (server_msg, body, octets) in self.msg_list:
body = '\n'.join(body)
for search_term in term:
if re.search(search_term, body, re.IGNORECASE):
print "MATCHED ON [%s]" % (search_term)
if not i in matched:
matched.append(i)
i=i+1
return matched
def searchMessageSubjects(self, term=None):
if (not self.srv):
return
if (not term):
return
self.getMessages()
matched = []
i = 1
for (server_msg, body, octets) in self.msg_list:
msg = email.message_from_string('\n'.join(body))
for search_term in term:
if re.search(search_term, msg['subject'], re.IGNORECASE):
print "MATCHED ON [%s]" % (search_term)
if not i in matched:
matched.append(i)
i=i+1
return matched
def search (self,pattern,caseSens=True,debug=0):
"Intenta hacer Matching entre el pattern pasado por parametro y la ultima linea leida"
if not caseSens:
self.regexp=re.compile(pattern,re.IGNORECASE)
else:
self.regexp=re.compile(pattern)
self.matches=self.regexp.findall(self.lastline)
j=0
for i in self.matches:
if not type(i)==type(()):
self.matches[j]=tuple([self.matches[j]])
j+=1
# DEBUG PARA MATCHING
if (debug==1):
print "[",self.lastline,"-",pattern,"]"
print len(self.matches)
print self.matches
if len(self.matches)==0:
return False
else:
return True
def parse(self, data):
state = "init"
for line in data.splitlines():
if state == "init":
self.parseRequest(line)
state = "host"
continue
if state == "host":
match = re.match("host: (.*)$", line, re.IGNORECASE)
if match:
self.host = match.group(1)
state = "keys"
continue
if not line:
continue
line = line.split(":", 1)
if len(line) == 1:
raise SyntaxError("Unable to parse client header: %r" % line[0])
key, value = line
self.headers.append( (key, value) )
def compilePatterns(self):
for text, score, match in self.regexs:
self.debug("Add regex pattern: %r" % text)
yield (text, score, match)
for text, score in self.patterns.iteritems():
regex = r'%s' % re.escape(text.lower())
self.debug("Create pattern regex: %r" % regex)
match = re.compile(regex, re.IGNORECASE).search
yield (text, score, match)
for text, score in self.words.iteritems():
regex = r'(?:^|\W)%s(?:$|\W)' % re.escape(text.lower())
self.debug("Create word regex: %r" % regex)
match = re.compile(regex, re.IGNORECASE).search
yield (text, score, match)
def search (self,pattern,caseSens=True,debug=0):
"Intenta hacer Matching entre el pattern pasado por parametro y la ultima linea leida"
if not caseSens:
self.regexp=re.compile(pattern,re.IGNORECASE)
else:
self.regexp=re.compile(pattern)
self.matches=self.regexp.findall(self.lastline)
j=0
for i in self.matches:
if not type(i)==type(()):
self.matches[j]=tuple([self.matches[j]])
j+=1
# DEBUG PARA MATCHING
if (debug==1):
print "[",self.lastline,"-",pattern,"]"
print len(self.matches)
print self.matches
if len(self.matches)==0:
return False
else:
return True
def analyse_text(text):
"""
Check for inital comment and patterns that distinguish Rexx from other
C-like languages.
"""
if re.search(r'/\*\**\s*rexx', text, re.IGNORECASE):
# Header matches MVS Rexx requirements, this is certainly a Rexx
# script.
return 1.0
elif text.startswith('/*'):
# Header matches general Rexx requirements; the source code might
# still be any language using C comments such as C++, C# or Java.
lowerText = text.lower()
result = sum(weight
for (pattern, weight) in RexxLexer.PATTERNS_AND_WEIGHTS
if pattern.search(lowerText)) + 0.01
return min(result, 1.0)
