NaxsiRules.__validate_dummy() - Code Metrics - Inspection of "make warnings and error per-instance, clean-up war..." - nbs-system/spike - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 128957...29e3f0 )

unknown

created 2016-03-16 14:12 UTC

NaxsiRules.__validate_dummy() A

↳ Parent: NaxsiRules

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Metric	Value
cc	1
dl	0
loc	2
rs	10
ccs	2
cts	2
cp	1
crap	1

from time import strftime, localtime

from spike.model import db
from shlex import shlex


class NaxsiRules(db.Model):
    __bind_key__ = 'rules'
    __tablename__ = 'naxsi_rules'

    id = db.Column(db.Integer, primary_key=True)
    msg = db.Column(db.String(), nullable=False)
    detection = db.Column(db.String(1024), nullable=False)
    mz = db.Column(db.String(1024), nullable=False)
    score = db.Column(db.String(1024), nullable=False)
    sid = db.Column(db.Integer, nullable=False, unique=True)
    ruleset = db.Column(db.String(1024), nullable=False)
    rmks = db.Column(db.Text, nullable=True, server_default="")
    active = db.Column(db.Integer, nullable=False, server_default="1")
    negative = db.Column(db.Integer, nullable=False, server_default='0')
    timestamp = db.Column(db.Integer, nullable=False)


    mr_kw = ["MainRule", "BasicRule", "main_rule", "basic_rule"]
    static_mz = {"$ARGS_VAR", "$BODY_VAR", "$URL", "$HEADERS_VAR"}
    full_zones = {"ARGS", "BODY", "URL", "HEADERS", "FILE_EXT", "RAW_BODY"}
    rx_mz = {"$ARGS_VAR_X", "$BODY_VAR_X", "$URL_X", "$HEADERS_VAR_X"}
    sub_mz = list(static_mz) + list(full_zones) + list(rx_mz)

    def __init__(self, msg="", detection="", mz="", score="", sid=42000, ruleset="", rmks="", active=0, negative=0, timestamp=0):

        self.msg = msg
        self.detection = detection
        self.mz = mz
        self.score = score
        self.sid = sid
        self.ruleset = ruleset
        self.rmks = rmks
        self.active = active
        self.negative = 1 if negative == 'checked' else 0
        self.timestamp = timestamp
        self.warnings = []
        self.error = []

    def fullstr(self):
        rdate = strftime("%F - %H:%M", localtime(float(str(self.timestamp))))
        rmks = "# ".join(self.rmks.strip().split("\n"))
        return "#\n# sid: {0} | date: {1}\n#\n# {2}\n#\n{3}".format(self.sid, rdate, rmks, self.__str__())

    def __str__(self):
        negate = 'negative' if self.negative == 1 else ''
        return 'MainRule {} "{}" "msg:{}" "mz:{}" "s:{}" id:{} ;'.format(
            negate, self.detection, self.msg, self.mz, self.score, self.sid)

    def validate(self):
        self.__validate_matchzone(self.mz)
        self.__validate_id(self.sid)
        self.__validate_detection(self.detection)

        if not self.msg:
            self.warnings.append("Rule has no 'msg:'.")
        if not self.score:
            self.error.append("Rule has no score.")

    def __fail(self, msg):
        self.error.append(msg)
        return False

    # Bellow are parsers for specific parts of a rule
    def __validate_dummy(self, s, assign=False):
class Foo:
    def some_method(self, x, y):
        return x + y;
        return True

    def __validate_detection(self, p_str, assign=False):
        if not p_str.startswith("str:") and not p_str.startswith("rx:"):
            self.__fail("detection {} is neither rx: or str:".format(p_str))
        if not p_str.islower():
            self.warnings.append("detection {} is not lower-case. naxsi is case-insensitive".format(p_str))
        if assign is True:
            self.detection = p_str
        return True

    def __validate_genericstr(self, p_str, assign=False):

        if p_str and not p_str.islower():
            self.warnings.append("Pattern ({0}) is not lower-case.".format(p_str))
        return True

    def __validate_matchzone(self, p_str, assign=False):
        has_zone = False
        mz_state = set()
        locs = p_str.split('|')
        for loc in locs:
            keyword, arg = loc, None
            if loc.startswith("$"):
                if loc.find(":") == -1:
                    return self.__fail("Missing 2nd part after ':' in {0}".format(loc))
                keyword, arg = loc.split(":")
            # check it is a valid keyword
            if keyword not in self.sub_mz:
                return self.__fail("'{0}' no a known sub-part of mz : {1}".format(keyword, self.sub_mz))
            mz_state.add(keyword)
            # verify the rule doesn't attempt to target REGEX and STATIC _VAR/URL at the same time
            if len(self.rx_mz & mz_state) and len(self.static_mz & mz_state):
                return self.__fail("You can't mix static $* with regex $*_X ({})".format(str(mz_state)))
            # just a gentle reminder
            if arg and arg.islower() is False:
                self.warnings.append("{0} in {1} is not lowercase. naxsi is case-insensitive".format(arg, loc))
            # the rule targets an actual zone
            if keyword not in ["$URL", "$URL_X"] and keyword in (self.rx_mz | self.full_zones | self.static_mz):

                has_zone = True
        if has_zone is False:
            return self.__fail("The rule/whitelist doesn't target any zone.")
        if assign is True:
            self.mz = p_str
        return True

    def __validate_id(self, p_str, assign=False):
        try:
            num = int(p_str)
            if num < 10000:
                self.warnings.append("rule IDs below 10k are reserved ({0})".format(num))
        except ValueError:
            self.error.append("id:{0} is not numeric".format(p_str))
            return False
        if assign is True:
            self.sid = num
        return True

    @staticmethod
    def splitter(s):

        lexer = shlex(s)
        lexer.whitespace_split = True
        items = list(iter(lexer.get_token, ''))
        return items

    def parse_rule(self, full_str):
        """
        Parse and validate a full naxsi rule
        :param full_str: raw rule
        :return: [True|False, dict]
        """
        self.warnings = []
        self.error = []

        func_map = {"id:": self.__validate_id, "str:": self.__validate_genericstr,
                    "rx:": self.__validate_genericstr, "msg:": self.__validate_dummy, "mz:": self.__validate_matchzone,
                    "negative": self.__validate_dummy, "s:": self.__validate_dummy}
        ret = False
        split = self.splitter(full_str)  # parse string
        intersection = set(split).intersection(set(self.mr_kw))

        if not intersection:
            return self.__fail("No mainrule/basicrule keyword.")
        elif len(intersection) > 1:
            return self.__fail("Multiple mainrule/basicrule keywords.")

        split.remove(intersection.pop())  # remove the mainrule/basicrule keyword

        if ";" in split:
            split.remove(";")

        while split:  # iterate while there is data, as handlers can defer
            for keyword in split:
                orig_kw = keyword
                keyword = keyword.strip()

                if keyword.endswith(";"):  # remove semi-colons
                    keyword = keyword[:-1]
                if keyword.startswith(('"', "'")) and (keyword[0] == keyword[-1]):  # remove (double-)quotes
                    keyword = keyword[1:-1]
                for frag_kw in func_map:
                    ret = False
                    if keyword.startswith(frag_kw):
                        # parser funcs returns True/False
                        ret = func_map[frag_kw](keyword[len(frag_kw):], assign=True)
                        if ret is True:
                            split.remove(orig_kw)
                        else:
                            return self.__fail("parsing of element '{0}' failed.".format(keyword))
                        break
                # we have an item that wasn't successfully parsed
                if orig_kw in split and ret is not None:
                    return False
        return True


1	1	from time import strftime, localtime
2
3	1	from spike.model import db
4	1	from shlex import shlex
5
6
7	1	class NaxsiRules(db.Model):
8	1	__bind_key__ = 'rules'
9	1	__tablename__ = 'naxsi_rules'
10
11	1	id = db.Column(db.Integer, primary_key=True)
12	1	msg = db.Column(db.String(), nullable=False)
13	1	detection = db.Column(db.String(1024), nullable=False)
14	1	mz = db.Column(db.String(1024), nullable=False)
15	1	score = db.Column(db.String(1024), nullable=False)
16	1	sid = db.Column(db.Integer, nullable=False, unique=True)
17	1	ruleset = db.Column(db.String(1024), nullable=False)
18	1	rmks = db.Column(db.Text, nullable=True, server_default="")
19	1	active = db.Column(db.Integer, nullable=False, server_default="1")
20	1	negative = db.Column(db.Integer, nullable=False, server_default='0')
21	1	timestamp = db.Column(db.Integer, nullable=False)
22
23
24	1	mr_kw = ["MainRule", "BasicRule", "main_rule", "basic_rule"]
25	1	static_mz = {"$ARGS_VAR", "$BODY_VAR", "$URL", "$HEADERS_VAR"}
26	1	full_zones = {"ARGS", "BODY", "URL", "HEADERS", "FILE_EXT", "RAW_BODY"}
27	1	rx_mz = {"$ARGS_VAR_X", "$BODY_VAR_X", "$URL_X", "$HEADERS_VAR_X"}
28	1	sub_mz = list(static_mz) + list(full_zones) + list(rx_mz)
29
30	1	def __init__(self, msg="", detection="", mz="", score="", sid=42000, ruleset="", rmks="", active=0, negative=0, timestamp=0):
		0 ignored issues – show Coding Style introduced 2016-03-03 14:14 UTC by Report Bug Copy Issue Report This line is too long as per the coding-style (129/120). This check looks for lines that are too long. You can specify the maximum line length. Loading history...
31	1	self.msg = msg
32	1	self.detection = detection
33	1	self.mz = mz
34	1	self.score = score
35	1	self.sid = sid
36	1	self.ruleset = ruleset
37	1	self.rmks = rmks
38	1	self.active = active
39	1	self.negative = 1 if negative == 'checked' else 0
40	1	self.timestamp = timestamp
41	1	self.warnings = []
42	1	self.error = []
43
44	1	def fullstr(self):
45	1	rdate = strftime("%F - %H:%M", localtime(float(str(self.timestamp))))
46	1	rmks = "# ".join(self.rmks.strip().split("\n"))
47	1	return "#\n# sid: {0} \| date: {1}\n#\n# {2}\n#\n{3}".format(self.sid, rdate, rmks, self.__str__())
48
49	1	def __str__(self):
50	1	negate = 'negative' if self.negative == 1 else ''
51	1	return 'MainRule {} "{}" "msg:{}" "mz:{}" "s:{}" id:{} ;'.format(
52		negate, self.detection, self.msg, self.mz, self.score, self.sid)
53
54	1	def validate(self):
55	1	self.__validate_matchzone(self.mz)
56	1	self.__validate_id(self.sid)
57	1	self.__validate_detection(self.detection)
58
59	1	if not self.msg:
60		self.warnings.append("Rule has no 'msg:'.")
61	1	if not self.score:
62		self.error.append("Rule has no score.")
63
64	1	def __fail(self, msg):
65	1	self.error.append(msg)
66	1	return False
67
68		# Bellow are parsers for specific parts of a rule
69	1	def __validate_dummy(self, s, assign=False):
		0 ignored issues – show Coding Style Naming introduced 2016-03-15 16:16 UTC by Report Bug Copy Issue Report The name `s` does not conform to the argument naming conventions (`[a-z_][a-z0-9_]{1,30}$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history... Unused Code introduced 2016-03-15 16:16 UTC by Report Bug Copy Issue Report The argument `s` seems to be unused. Loading history... Unused Code introduced 2016-03-15 16:16 UTC by Report Bug Copy Issue Report The argument `assign` seems to be unused. Loading history... Coding Style introduced 2016-03-15 16:16 UTC by Report Bug Copy Issue Report This method could be written as a function/class method. If a method does not access any attributes of the class, it could also be implemented as a function or static method. This can help improve readability. For example class Foo: def some_method(self, x, y): return x + y; could be written as class Foo: @classmethod def some_method(cls, x, y): return x + y; Loading history...
70	1	return True
71
72	1	def __validate_detection(self, p_str, assign=False):
73	1	if not p_str.startswith("str:") and not p_str.startswith("rx:"):
74		self.__fail("detection {} is neither rx: or str:".format(p_str))
75	1	if not p_str.islower():
76	1	self.warnings.append("detection {} is not lower-case. naxsi is case-insensitive".format(p_str))
77	1	if assign is True:
78		self.detection = p_str
79	1	return True
80
81	1	def __validate_genericstr(self, p_str, assign=False):
		0 ignored issues – show Unused Code introduced 2016-03-15 16:16 UTC by Report Bug Copy Issue Report The argument `assign` seems to be unused. Loading history...
82	1	if p_str and not p_str.islower():
83		self.warnings.append("Pattern ({0}) is not lower-case.".format(p_str))
84	1	return True
85
86	1	def __validate_matchzone(self, p_str, assign=False):
87	1	has_zone = False
88	1	mz_state = set()
89	1	locs = p_str.split('\|')
90	1	for loc in locs:
91	1	keyword, arg = loc, None
92	1	if loc.startswith("$"):
93	1	if loc.find(":") == -1:
94		return self.__fail("Missing 2nd part after ':' in {0}".format(loc))
95	1	keyword, arg = loc.split(":")
96		# check it is a valid keyword
97	1	if keyword not in self.sub_mz:
98		return self.__fail("'{0}' no a known sub-part of mz : {1}".format(keyword, self.sub_mz))
99	1	mz_state.add(keyword)
100		# verify the rule doesn't attempt to target REGEX and STATIC _VAR/URL at the same time
101	1	if len(self.rx_mz & mz_state) and len(self.static_mz & mz_state):
102	1	return self.__fail("You can't mix static $* with regex $*_X ({})".format(str(mz_state)))
103		# just a gentle reminder
104	1	if arg and arg.islower() is False:
105	1	self.warnings.append("{0} in {1} is not lowercase. naxsi is case-insensitive".format(arg, loc))
106		# the rule targets an actual zone
107	1	if keyword not in ["$URL", "$URL_X"] and keyword in (self.rx_mz \| self.full_zones \| self.static_mz):
		0 ignored issues – show Unused Code Coding Style introduced 2016-03-15 16:16 UTC by Report Bug Copy Issue Report There is an unnecessary parenthesis after `in`. Loading history...
108	1	has_zone = True
109	1	if has_zone is False:
110		return self.__fail("The rule/whitelist doesn't target any zone.")
111	1	if assign is True:
112	1	self.mz = p_str
113	1	return True
114
115	1	def __validate_id(self, p_str, assign=False):
116	1	try:
117	1	num = int(p_str)
118	1	if num < 10000:
119	1	self.warnings.append("rule IDs below 10k are reserved ({0})".format(num))
120		except ValueError:
121		self.error.append("id:{0} is not numeric".format(p_str))
122		return False
123	1	if assign is True:
124	1	self.sid = num
125	1	return True
126
127	1	@staticmethod
128		def splitter(s):
		0 ignored issues – show Coding Style Naming introduced 2016-03-16 11:23 UTC by Report Bug Copy Issue Report The name `s` does not conform to the argument naming conventions (`[a-z_][a-z0-9_]{1,30}$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
129	1	lexer = shlex(s)
130	1	lexer.whitespace_split = True
131	1	items = list(iter(lexer.get_token, ''))
132	1	return items
133
134	1	def parse_rule(self, full_str):
135		"""
136		Parse and validate a full naxsi rule
137		:param full_str: raw rule
138		:return: [True\|False, dict]
139		"""
140	1	self.warnings = []
141	1	self.error = []
142
143	1	func_map = {"id:": self.__validate_id, "str:": self.__validate_genericstr,
144		"rx:": self.__validate_genericstr, "msg:": self.__validate_dummy, "mz:": self.__validate_matchzone,
145		"negative": self.__validate_dummy, "s:": self.__validate_dummy}
146	1	ret = False
147	1	split = self.splitter(full_str) # parse string
148	1	intersection = set(split).intersection(set(self.mr_kw))
149
150	1	if not intersection:
151		return self.__fail("No mainrule/basicrule keyword.")
152	1	elif len(intersection) > 1:
153		return self.__fail("Multiple mainrule/basicrule keywords.")
154
155	1	split.remove(intersection.pop()) # remove the mainrule/basicrule keyword
156
157	1	if ";" in split:
158	1	split.remove(";")
159
160	1	while split: # iterate while there is data, as handlers can defer
161	1	for keyword in split:
162	1	orig_kw = keyword
163	1	keyword = keyword.strip()
164
165	1	if keyword.endswith(";"): # remove semi-colons
166	1	keyword = keyword[:-1]
167	1	if keyword.startswith(('"', "'")) and (keyword[0] == keyword[-1]): # remove (double-)quotes
168	1	keyword = keyword[1:-1]
169	1	for frag_kw in func_map:
170	1	ret = False
171	1	if keyword.startswith(frag_kw):
172		# parser funcs returns True/False
173	1	ret = func_map[frag_kw](keyword[len(frag_kw):], assign=True)
174	1	if ret is True:
175	1	split.remove(orig_kw)
176		else:
177	1	return self.__fail("parsing of element '{0}' failed.".format(keyword))
178	1	break
179		# we have an item that wasn't successfully parsed
180	1	if orig_kw in split and ret is not None:
181		return False
182		return True
183

nbs-system / spike

Push — master ( 128957...29e3f0 )

NaxsiRules.__validate_dummy() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like