Beispiel #1
0
def init_parser():
    """Set up the parser with the grammar to be recognized.
    """
    # CORE
    digit   = h.ch_range(0x30, 0x39)
    alpha   = h.choice(h.ch_range(0x41, 0x5a), h.ch_range(0x61, 0x7a))
    space   = h.in_(" \t\n\r\f\v")

    # AUX.
    plus    = h.ch('+')
    slash   = h.ch('/')
    equals  = h.ch('=')

    bsfdig      = h.choice(alpha, digit, plus, slash)
    bsfdig_4bit = h.in_("AEIMQUYcgkosw048")
    bsfdig_2bit = h.in_("AQgw")
    base64_3    = h.repeat_n(bsfdig, 4)
    base64_2    = h.sequence(bsfdig, bsfdig, bsfdig_4bit, equals)
    base64_1    = h.sequence(bsfdig, bsfdig_2bit, equals, equals)
    base64      = h.action(h.sequence(h.many(base64_3),
                                      h.optional(h.choice(base64_2,
                                                          base64_1))),
                           act_base64)

    # TODO This is not quite the same as the C example, with uses act_ignore.
    #      But I can't get hammer to filter any value returned by act_ignore.
    ws          = h.ignore(h.many(space))
    document    = h.action(h.sequence(ws, base64, ws, h.end_p()),
                           act_document)

    # BUG sometimes inputs that should just don't parse.
    # It *seemed* to happen mostly with things like "bbbbaaaaBA==".
    # Using less actions seemed to make it less likely.

    return document
Beispiel #2
0
def init_parser():
    """Set up the parser with the grammar to be recognized.
    """
    # CORE
    digit = h.ch_range(0x30, 0x39)
    alpha = h.choice(h.ch_range(0x41, 0x5a), h.ch_range(0x61, 0x7a))
    space = h.in_(b" \t\n\r\f\v")

    # AUX.
    plus = h.ch(b'+')
    slash = h.ch(b'/')
    equals = h.ch(b'=')

    bsfdig = h.choice(alpha, digit, plus, slash)
    bsfdig_4bit = h.in_(b"AEIMQUYcgkosw048")
    bsfdig_2bit = h.in_(b"AQgw")
    base64_3 = h.repeat_n(bsfdig, 4)
    base64_2 = h.sequence(bsfdig, bsfdig, bsfdig_4bit, equals)
    base64_1 = h.sequence(bsfdig, bsfdig_2bit, equals, equals)
    base64 = h.action(
        h.sequence(h.many(base64_3), h.optional(h.choice(base64_2, base64_1))),
        act_base64)

    # TODO This is not quite the same as the C example, with uses act_ignore.
    #      But I can't get hammer to filter any value returned by act_ignore.
    ws = h.ignore(h.many(space))
    document = h.action(h.sequence(ws, base64, ws, h.end_p()), act_document)

    # BUG sometimes inputs that should just don't parse.
    # It *seemed* to happen mostly with things like "bbbbaaaaBA==".
    # Using less actions seemed to make it less likely.

    return document
Beispiel #3
0
def channel_open_parser():
    parser = h.sequence(
        h.ch('\x01'), # type
        h.uint16(), # Channel
        h.uint32(), # Length
        h.token("\x00\x14"), # Class
        h.token("\x00\x0a"), # Method

        # Arguments
        h.ch('\x00'), # Out-of-bounds
        h.end_p()
    )
    return parser
Beispiel #4
0
def connection_open_vhost_ok_parser():
    parser = h.sequence(
        h.ch('\x01'), # type
        h.uint16(), # Channel
        h.uint32(), # Length
        h.token("\x00\x0a"), # Class
        h.token("\x00\x29"), # Method

        # Arguments
        h.ch('\x00'),# Known-Host # most likely going to change this according to the message
        h.end_p()
    )
    return parser
Beispiel #5
0
def get_version(text):
    version_string = h.right(h.token("SW: Version "), h.sepBy(alphanumeric, h.ch('.')))
    version = h.whitespace(version_string)
    parser = h.action(version, tuple_string)
    for i in text.split("\n"):
        ret = parser.parse(i.encode('ascii','ignore'))
        if ret is not None:
            return {'os_version': ".".join(ret)}
Beispiel #6
0
def fast_meter_message():
    header = h.token('\xa5\xd1')
    any_char = h.ch_range('\x00', '\xff')

    parser = h.sequence(header, h.uint8(), h.ch('\x00'),
                        h.repeat_n(h.uint32(), 7), h.uint64(),
                        h.repeat_n(any_char, 167), any_char)
    return parser
Beispiel #7
0
def init_parser():
    """Return a parser with the grammar to be recognized.
    """
    # CORE

    # This is a direct translation of the  C example. In C the literal 0x30
    # is interchangable with the char literal '0' (note the single quotes).
    # This is not the case in Python.
    
    # TODO In the interests of being more Pythonic settle on either string
    #      literals, or integers
    digit   = h.ch_range(0x30, 0x39)
    alpha   = h.choice(h.ch_range(0x41, 0x5a), h.ch_range(0x61, 0x7a))
    space   = h.in_(" \t\n\r\f\v")

    # AUX.
    plus    = h.ch('+')
    slash   = h.ch('/')
    equals  = h.action(h.ch('='), act_equals)

    bsfdig      = h.action(h.choice(alpha, digit, plus, slash), act_bsfdig)
    bsfdig_4bit = h.action(h.in_("AEIMQUYcgkosw048"), act_bsfdig_4bit)
    bsfdig_2bit = h.action(h.in_("AQgw"), act_bsfdig_2bit)
    base64_3    = h.action(h.repeat_n(bsfdig, 4), act_base64_3)
    base64_2    = h.action(h.sequence(bsfdig, bsfdig, bsfdig_4bit, equals),
                           act_base64_2)
    base64_1    = h.action(h.sequence(bsfdig, bsfdig_2bit, equals, equals),
                           act_base64_1)
    base64      = h.action(h.sequence(h.many(base64_3),
                                      h.optional(h.choice(base64_2,
                                                          base64_1))),
                           act_base64)

    # TODO This is not quite the same as the C example, with uses act_ignore.
    #      But I can't get hammer to filter any value returned by act_ignore.
    ws          = h.ignore(h.many(space))
    document    = h.action(h.sequence(ws, base64, ws, h.end_p()),
                           act_document)

    # BUG sometimes inputs that should just don't parse.
    # It *seemed* to happen mostly with things like "bbbbaaaaBA==".
    # Using less actions seemed to make it less likely.

    return document
Beispiel #8
0
def basic_deliver_parser():
    parser = h.sequence(
        h.ch('\x01'),  # type
        h.uint16(),  # Channel
        h.uint32(),  # Length
        h.token("\x00\x3c"),  # Class
        h.token("\x00\x3c"),  # Method
        h.end_p()
    )
    return parser
Beispiel #9
0
def connection_start_ok_parser():
    parser = h.sequence(
        h.ch('\x01'),  # type
        h.uint16(),  # Channel
        h.uint32(),  # Length
        h.token("\x00\x0a"),  # Class
        h.token("\x00\x0b"),  # Method
        h.end_p()
    )
    return parser
Beispiel #10
0
def init_parser():
    # CORE
    digit = h.ch_range(0x30, 0x39)
    alpha = h.choice(h.ch_range(0x41, 0x5a), h.ch_range(0x61, 0x7a))

    # AUX.
    plus = h.ch(b'+')
    slash = h.ch(b'/')
    equals = h.ch(b'=')

    bsfdig = h.choice(alpha, digit, plus, slash)
    bsfdig_4bit = h.in_(b'AEIMQUYcgkosw048')
    bsfdig_2bit = h.in_(b'AQgw')
    base64_3 = h.repeat_n(bsfdig, 4)
    base64_2 = h.sequence(bsfdig, bsfdig, bsfdig_4bit, equals)
    base64_1 = h.sequence(bsfdig, bsfdig_2bit, equals, equals)
    base64 = h.sequence(h.many(base64_3),
                        h.optional(h.choice(base64_2, base64_1)))

    return h.sequence(h.whitespace(base64), h.whitespace(h.end_p()))
Beispiel #11
0
def init_parser():
    # CORE
    digit = h.ch_range(0x30, 0x39)
    alpha = h.choice(h.ch_range(0x41, 0x5a), h.ch_range(0x61, 0x7a))

    # AUX.
    plus = h.ch('+')
    slash = h.ch('/')
    equals = h.ch('=')

    bsfdig = h.choice(alpha, digit, plus, slash)
    bsfdig_4bit = h.in_('AEIMQUYcgkosw048')
    bsfdig_2bit = h.in_('AQgw')
    base64_3 = h.repeat_n(bsfdig, 4)
    base64_2 = h.sequence(bsfdig, bsfdig, bsfdig_4bit, equals)
    base64_1 = h.sequence(bsfdig, bsfdig_2bit, equals, equals)
    base64 = h.sequence(h.many(base64_3),
                        h.optional(h.choice(base64_2, base64_1)))

    return h.sequence(h.whitespace(base64), h.whitespace(h.end_p()))
Beispiel #12
0
def length_block():


    parser = h.sequence(
    h.ch('\x01'),
    h.uint16(),
    h.and_(h._h_length_value(h.uint32(), h.ch_range('\x00', '\xff'))),
    h.uint32(),
    h.many(h.ch_range('\x00', '\xff')),
    h.end_p())
    return parser
Beispiel #13
0
def connection_close_ok_parser():
    parser = h.sequence(
        h.ch('\x01'),  # type
        h.uint16(),  # Channel
        h.uint32(),  # Length
        h.token("\x00\x0a"),  # Class
        h.token("\x00\x33"),  # Method

        # No arguments
        h.end_p()
    )
    return parser
Beispiel #14
0
def basic_consume_ok_parser():
    parser = h.sequence(
        h.ch('\x01'), # type
        h.uint16(), # Channel
        h.uint32(), # Length
        h.token("\x00\x3c"), # Class
        h.token("\x00\x15"), # Method

        # Arguments
        # consumer-tag
        h.end_p()
    )
    return parser
Beispiel #15
0
def channel_open_ok_parser():
    parser = h.sequence(
        h.ch('\x01'), # type
        h.uint16(), # Channel
        h.uint32(), # Length
        h.token("\x16\x28"), # Class
        h.token("\x00\x0b"), # Method

        # Arguments
        h.uint32(), # Channel-Id
        h.end_p()
    )
    return parser
Beispiel #16
0
def connection_tune_ok_parser():
    parser = h.sequence(
        h.ch('\x01'), # type
        h.uint16(), # Channel
        h.uint32(), # Length
        h.token("\x00\x0a"), # Class
        h.token("\x00\x1f"), # Method

        # Arguments
        h.uint16(), # Channel max
        h.uint32(), # Frame max
        h.uint16(), # Heartbeat
        h.end_p()
    )
    return parser
Beispiel #17
0
def queue_declare_ok_parser():
    parser = h.sequence(
        h.ch('\x01'), # type
        h.uint16(), # Channel
        h.uint32(), # Length
        h.token("\x00\x32"), # Class
        h.token("\x00\x0b"), # Method

        # Arguments
        #how do you parse that long message? #Queue
        h.many(h.ch_range('\x00', '\xff')),
        #h.uint32(), # message-count
        #h.uint32(), # consumer-count
        h.end_p()
    )
    return parser
Beispiel #18
0
def connection_close_parser():
    parser = h.sequence(
        h.ch('\x01'),  # type
        h.uint16(),  # Channel
        h.uint32(),  # Length
        h.token("\x00\x0a"),  # Class
        h.token("\x00\x32"),  # Method

        # Arguments
        h.uint16(), # Replay-code
        #Replay-text
        h.uint16(), # Class-Id
        h.uint16(), # Method-Id
        h.end_p()
    )
    return parser
Beispiel #19
0
def basic_consume_parser():
    parser = h.sequence(
        h.ch('\x01'), # type
        h.uint16(), # Channel
        h.uint32(), # Length
        h.token("\x00\x3c"), # Class
        h.token("\x00\x14"), # Method

        # Arguments
        h.uint16(), # Ticket
        # how do you parse that long message? #Queue
        h.many(h.ch_range('\x00', '\xff')),
        # consumer-tag
        h.end_p()
    )
    return parser
Beispiel #20
0
def queue_declare_parser():
    parser = h.sequence(
        h.ch('\x01'), # type
        h.uint16(), # Channel
        h.uint32(), # Length
        h.token("\x00\x32"), # Class
        h.token("\x00\x0a"), # Method

        # Arguments
        h.uint16(), # Ticket
        # how do you parse that long message?#Queue
        h.many(h.ch_range('\x00', '\xff')),
        #When you parse this out... (, ,, , 0L, ('','','',''))
        h.end_p()
    )
    return parser
Beispiel #21
0
 def setUpClass(cls):
     cls.parser = h.repeat_n(h.choice(h.ch(b"a"), h.ch(b"b")), 2)
Beispiel #22
0
 def setUpClass(cls):
     #raise unittest.SkipTest("Bind doesn't work right now")
     cls.parser = h.indirect()
     a = h.ch("a")
     cls.parser.bind(h.choice(h.sequence(a, cls.parser),
                              h.epsilon_p()))
Beispiel #23
0
 def setUpClass(cls):
     cls.parser = h.sequence(h.ch("1"), h.and_(h.ch("2")))
Beispiel #24
0
 def setUpClass(cls):
     cls.parser = h.sequence(h.ch("a"), h.epsilon_p())
Beispiel #25
0
 def setUpClass(cls):
     cls.parser = h.sequence(h.ch("a"), h.ignore(h.ch("b")), h.ch("c"))
Beispiel #26
0
 def setUpClass(cls):
     cls.parser = h.repeat_n(h.choice(h.ch("a"), h.ch("b")), 2)
Beispiel #27
0
 def setUpClass(cls):
     cls.parser = h.difference(h.token("ab"), h.ch("a"))
Beispiel #28
0
import hammer as h


digit   = h.ch_range('0','9')
upper   = h.ch_range('A', 'Z')
lower   = h.ch_range('a', 'z')
chars   = h.choice(digit, upper, lower)

alphanumeric = h.many(chars)

words = h.sepBy1(alphanumeric, h.ch(' '))
version = h.token("Version")
allchars = h.ch_range("!", "~")

printable_chars = h.many(allchars)

token = h.many1(printable_chars)
tokens = h.sepBy1(printable_chars, h.choice(h.ch(' '), h.ch('\n'), h.ch('\r')))

# Action Modifiers

def tuple_string(t):
    new_coll = list()
    for c in t:
        if isinstance(c, tuple):
                new_coll.append("".join(c))
        else:
            return "".join(t)
    return tuple(new_coll)

Beispiel #29
0
 def setUpClass(cls):
     cls.parser = h.sequence(h.ch(b"1"), h.and_(h.ch(b"2")))
Beispiel #30
0
 def setUpClass(cls):
     cls.parser = h.sequence(h.ch(b"a"), h.epsilon_p())
Beispiel #31
0
 def setUpClass(cls):
     cls.parser = h.sepBy1(h.choice(h.ch(b"1"), h.ch(b"2"), h.ch(b"3")),
                           h.ch(b","))
Beispiel #32
0
 def setUpClass(cls):
     cls.parser = h.sequence(h.ch(b"a"), h.ignore(h.ch(b"b")), h.ch(b"c"))
Beispiel #33
0
 def setUpClass(cls):
     cls.parser = h.sequence(h.ch(b"a"),
                             h.optional(h.choice(h.ch(b"b"), h.ch(b"c"))),
                             h.ch(b"d"))
Beispiel #34
0
 def setUpClass(cls):
     cls.parser = h.butnot(h.ch("a"), h.token("ab"))
Beispiel #35
0
 def setUpClass(cls):
     cls.parser = h.difference(h.token(b"ab"), h.ch(b"a"))
Beispiel #36
0
 def setUpClass(cls):
     cls.parser = h.butnot(h.ch_range("0", "9"), h.ch("6"))
Beispiel #37
0
 def setUpClass(cls):
     cls.parser = h.whitespace(h.ch("a"))
Beispiel #38
0
 def setUpClass(cls):
     cls.parser = h.many1(h.choice(h.ch("a"), h.ch("b")))
Beispiel #39
0
 def setUpClass(cls):
     cls.parser_int = h.ch(0xa2)
     cls.parser_chr = h.ch("\xa2")
Beispiel #40
0
 def setUpClass(cls):
     cls.parser = h.sequence(h.ch("a"), h.optional(h.choice(h.ch("b"), h.ch("c"))), h.ch("d"))
Beispiel #41
0
 def setUpClass(cls):
     cls.parser = h.right(h.ch(" "), h.ch("a"))
Beispiel #42
0
 def setUpClass(cls):
     cls.parser = h.sepBy1(h.choice(h.ch("1"), h.ch("2"), h.ch("3")), h.ch(","))
Beispiel #43
0
 def setUpClass(cls):
     cls.parser = h.middle(h.ch(" "), h.ch("a"), h.ch(" "))
Beispiel #44
0
 def setUpClass(cls):
     cls.parser = h.attr_bool(h.many1(h.choice(h.ch("a"), h.ch("b"))),
                              lambda x: x[0] == x[1])
Beispiel #45
0
 def setUpClass(cls):
     cls.parser = h.action(h.sequence(h.choice(h.ch("a"), h.ch("A")),
                                      h.choice(h.ch("b"), h.ch("B"))),
                             lambda x: [y.upper() for y in x])
Beispiel #46
0
 def setUpClass(cls):
     cls.parser = h.sequence(h.ch("a"), h.choice(h.sequence(h.ch("+"), h.not_(h.ch("+"))),
                                                 h.token("++")),
                             h.ch("b"))
Beispiel #47
0
 def setUpClass(cls):
     cls.parser = h.sequence(h.ch("a"), h.whitespace(h.ch("b")))
Beispiel #48
0
 def setUpClass(cls):
     cls.parser = h.sequence(
         h.ch(b"a"),
         h.choice(h.sequence(h.ch(b"+"), h.not_(h.ch(b"+"))),
                  h.token(b"++")), h.ch(b"b"))
Beispiel #49
0
 def setUpClass(cls):
     cls.parser = h.many1(h.choice(h.ch(b"a"), h.ch(b"b")))
Beispiel #50
0
 def setUpClass(cls):
     cls.parser = h.attr_bool(h.many1(h.choice(h.ch(b"a"), h.ch(b"b"))),
                              lambda x: x[0] == x[1])
Beispiel #51
0
 def setUpClass(cls):
     #raise unittest.SkipTest(b"Bind doesn't work right now")
     cls.parser = h.indirect()
     a = h.ch(b"a")
     cls.parser.bind(h.choice(h.sequence(a, cls.parser), h.epsilon_p()))