mitmproxy/libpathod/language/base.py

372 lines
9.0 KiB
Python
Raw Normal View History

2014-10-25 01:24:05 +00:00
import operator
import os
import abc
import pyparsing as pp
from .. import utils
from . import generators, exceptions
2012-04-28 00:42:03 +00:00
Sep = pp.Optional(pp.Literal(":")).suppress()
v_integer = pp.Word(pp.nums)\
2012-04-28 00:42:03 +00:00
.setName("integer")\
.setParseAction(lambda toks: int(toks[0]))
v_literal = pp.MatchFirst(
2012-04-28 00:42:03 +00:00
[
2014-10-25 01:24:05 +00:00
pp.QuotedString(
"\"",
unquoteResults=True,
multiline=True
),
pp.QuotedString(
"'",
unquoteResults=True,
multiline=True
),
2012-04-28 00:42:03 +00:00
]
)
v_naked_literal = pp.MatchFirst(
2012-04-28 00:42:03 +00:00
[
v_literal,
pp.Word("".join(i for i in pp.printables if i not in ",:\n@\'\""))
2012-04-28 00:42:03 +00:00
]
)
class Token(object):
"""
A token in the specification language. Tokens are immutable. The token
classes have no meaning in and of themselves, and are combined into
Components and Actions to build the language.
"""
2012-10-28 09:00:19 +00:00
__metaclass__ = abc.ABCMeta
2014-10-25 01:24:05 +00:00
2015-04-19 20:56:47 +00:00
@classmethod
def expr(klass): # pragma: no cover
"""
A parse expression.
"""
2012-10-28 09:00:19 +00:00
return None
@abc.abstractmethod
def spec(self): # pragma: no cover
"""
A parseable specification for this token.
"""
2012-10-28 09:00:19 +00:00
return None
def resolve(self, settings, msg):
"""
Resolves this token to ready it for transmission. This means that
the calculated offsets of actions are fixed.
settings: a language.Settings instance
msg: The containing message
"""
return self
def __repr__(self):
return self.spec()
2012-10-28 09:00:19 +00:00
class _TokValueLiteral(Token):
2012-04-28 00:42:03 +00:00
def __init__(self, val):
self.val = val.decode("string_escape")
2012-04-28 00:42:03 +00:00
def get_generator(self, settings):
return self.val
2012-04-28 00:42:03 +00:00
def freeze(self, settings):
return self
class TokValueLiteral(_TokValueLiteral):
"""
A literal with Python-style string escaping
"""
2012-04-28 00:42:03 +00:00
@classmethod
def expr(klass):
e = v_literal.copy()
2014-10-26 03:27:25 +00:00
return e.setParseAction(klass.parseAction)
@classmethod
def parseAction(klass, x):
v = klass(*x)
return v
2012-04-28 00:42:03 +00:00
def spec(self):
inner = self.val.encode("string_escape")
inner = inner.replace(r"\'", r"\x27")
return "'" + inner + "'"
class TokValueNakedLiteral(_TokValueLiteral):
@classmethod
def expr(klass):
e = v_naked_literal.copy()
return e.setParseAction(lambda x: klass(*x))
2012-04-28 00:42:03 +00:00
def spec(self):
return self.val.encode("string_escape")
2012-04-28 00:42:03 +00:00
class TokValueGenerate(Token):
2012-04-28 00:42:03 +00:00
def __init__(self, usize, unit, datatype):
if not unit:
unit = "b"
self.usize, self.unit, self.datatype = usize, unit, datatype
def bytes(self):
return self.usize * utils.SIZE_UNITS[self.unit]
2012-04-28 00:42:03 +00:00
def get_generator(self, settings):
return generators.RandomGenerator(self.datatype, self.bytes())
2012-04-28 00:42:03 +00:00
def freeze(self, settings):
g = self.get_generator(settings)
return TokValueLiteral(g[:].encode("string_escape"))
2012-04-28 00:42:03 +00:00
@classmethod
def expr(klass):
e = pp.Literal("@").suppress() + v_integer
2012-04-28 00:42:03 +00:00
2014-10-25 01:24:05 +00:00
u = reduce(
operator.or_,
[pp.Literal(i) for i in utils.SIZE_UNITS.keys()]
).leaveWhitespace()
2012-04-28 00:42:03 +00:00
e = e + pp.Optional(u, default=None)
s = pp.Literal(",").suppress()
s += reduce(
operator.or_,
[pp.Literal(i) for i in generators.DATATYPES.keys()]
)
2012-04-28 00:42:03 +00:00
e += pp.Optional(s, default="bytes")
return e.setParseAction(lambda x: klass(*x))
def spec(self):
s = "@%s"%self.usize
if self.unit != "b":
s += self.unit
if self.datatype != "bytes":
s += ",%s"%self.datatype
return s
2012-04-28 00:42:03 +00:00
class TokValueFile(Token):
2012-04-28 00:42:03 +00:00
def __init__(self, path):
self.path = str(path)
2012-04-28 00:42:03 +00:00
@classmethod
def expr(klass):
e = pp.Literal("<").suppress()
e = e + v_naked_literal
2012-04-28 00:42:03 +00:00
return e.setParseAction(lambda x: klass(*x))
def freeze(self, settings):
return self
2012-04-28 00:42:03 +00:00
def get_generator(self, settings):
if not settings.staticdir:
raise exceptions.FileAccessDenied("File access disabled.")
s = os.path.expanduser(self.path)
s = os.path.normpath(
os.path.abspath(os.path.join(settings.staticdir, s))
)
uf = settings.unconstrained_file_access
if not uf and not s.startswith(settings.staticdir):
raise exceptions.FileAccessDenied(
2014-10-25 01:24:05 +00:00
"File access outside of configured directory"
)
if not os.path.isfile(s):
raise exceptions.FileAccessDenied("File not readable")
return generators.FileGenerator(s)
2012-04-28 00:42:03 +00:00
def spec(self):
2014-10-26 03:27:25 +00:00
return "<'%s'"%self.path.encode("string_escape")
2012-04-28 00:42:03 +00:00
TokValue = pp.MatchFirst(
2012-04-28 00:42:03 +00:00
[
TokValueGenerate.expr(),
TokValueFile.expr(),
TokValueLiteral.expr()
2012-04-28 00:42:03 +00:00
]
)
TokNakedValue = pp.MatchFirst(
[
TokValueGenerate.expr(),
TokValueFile.expr(),
TokValueLiteral.expr(),
TokValueNakedLiteral.expr(),
]
)
TokOffset = pp.MatchFirst(
2014-10-25 01:24:05 +00:00
[
v_integer,
pp.Literal("r"),
pp.Literal("a")
]
)
class _Component(Token):
2012-10-28 21:00:41 +00:00
"""
A value component of the primary specification of an message.
Components produce byte values desribe the bytes of the message.
2012-10-28 21:00:41 +00:00
"""
@abc.abstractmethod
2012-10-28 21:00:41 +00:00
def values(self, settings): # pragma: no cover
2012-10-28 04:39:58 +00:00
"""
A sequence of values, which can either be strings or generators.
2012-10-28 04:39:58 +00:00
"""
pass
def string(self, settings=None):
2012-10-28 04:39:58 +00:00
"""
2012-10-28 09:00:19 +00:00
A string representation of the object.
2012-10-28 04:39:58 +00:00
"""
return "".join(i[:] for i in self.values(settings or {}))
2015-05-02 10:32:57 +00:00
class KeyValue(_Component):
"""
A key/value pair.
klass.preamble: leader
"""
def __init__(self, key, value):
self.key, self.value = key, value
@classmethod
def expr(klass):
2015-05-02 10:32:57 +00:00
e = pp.Literal(klass.preamble).suppress()
e += TokValue
e += pp.Literal("=").suppress()
e += TokValue
return e.setParseAction(lambda x: klass(*x))
def spec(self):
2015-05-02 10:32:57 +00:00
return "%s%s=%s"%(self.preamble, self.key.spec(), self.value.spec())
def freeze(self, settings):
2015-05-02 10:32:57 +00:00
return self.__class__(
self.key.freeze(settings), self.value.freeze(settings)
2014-10-25 01:24:05 +00:00
)
class CaselessLiteral(_Component):
"""
A caseless token that can take only one value.
"""
def __init__(self, value):
self.value = value
@classmethod
def expr(klass):
spec = pp.CaselessLiteral(klass.TOK)
spec = spec.setParseAction(lambda x: klass(*x))
return spec
def values(self, settings):
return self.TOK
def spec(self):
return self.TOK
def freeze(self, settings):
return self
class OptionsOrValue(_Component):
"""
Can be any of a specified set of options, or a value specifier.
"""
2015-05-02 10:32:57 +00:00
preamble = ""
2012-06-24 05:23:37 +00:00
def __init__(self, value):
# If it's a string, we were passed one of the options, so we lower-case
2012-06-24 05:23:37 +00:00
# it to be canonical. The user can specify a different case by using a
# string value literal.
2015-05-02 10:32:57 +00:00
self.option_used = False
2012-06-24 05:23:37 +00:00
if isinstance(value, basestring):
value = TokValueLiteral(value.lower())
2015-05-02 10:32:57 +00:00
self.option_used = True
2012-06-24 05:23:37 +00:00
self.value = value
@classmethod
def expr(klass):
parts = [pp.CaselessLiteral(i) for i in klass.options]
2012-06-24 05:23:37 +00:00
m = pp.MatchFirst(parts)
spec = m | TokValue.copy()
2012-06-24 05:23:37 +00:00
spec = spec.setParseAction(lambda x: klass(*x))
2015-05-02 10:32:57 +00:00
if klass.preamble:
spec = pp.Literal(klass.preamble).suppress() + spec
2012-06-24 05:23:37 +00:00
return spec
def values(self, settings):
return [
self.value.get_generator(settings)
]
def spec(self):
s = self.value.spec()
if s[1:-1].lower() in self.options:
s = s[1:-1].lower()
2015-05-02 10:32:57 +00:00
return "%s%s"%(self.preamble, s)
def freeze(self, settings):
return self.__class__(self.value.freeze(settings))
2012-06-24 05:23:37 +00:00
class Integer(_Component):
def __init__(self, value):
self.value = str(value)
2012-10-28 21:00:41 +00:00
@classmethod
def expr(klass):
e = v_integer.copy()
return e.setParseAction(lambda x: klass(*x))
def values(self, settings):
return self.value
2012-10-28 21:00:41 +00:00
def spec(self):
return "%s"%(self.value)
def freeze(self, settings):
return self
2012-10-28 21:00:41 +00:00
2015-05-03 00:54:25 +00:00
class Value(_Component):
"""
A value component lead by an optional preamble.
"""
preamble = ""
2012-10-28 21:00:41 +00:00
def __init__(self, value):
self.value = value
@classmethod
def expr(klass):
e = (TokValue | TokNakedValue)
if klass.preamble:
e = pp.Literal(klass.preamble).suppress() + e
2012-10-28 21:00:41 +00:00
return e.setParseAction(lambda x: klass(*x))
def values(self, settings):
return [self.value.get_generator(settings)]
def spec(self):
return "%s%s"%(self.preamble, self.value.spec())
def freeze(self, settings):
return self.__class__(self.value.freeze(settings))