Example #1
0
    def test_ip_memoized(self):
        result_1 = smart_fill('ip')
        result_2 = smart_fill('ip')

        self.assertEquals(result_1, '127.0.0.1')
        self.assertIs(result_1, result_2)

        self.assertIn(('ip',), smart_fill.cache.d)
Example #2
0
    def test_ip_memoized(self):
        result_1 = smart_fill('ip')
        result_2 = smart_fill('ip')

        self.assertEquals(result_1, '127.0.0.1')
        self.assertIs(result_1, result_2)

        self.assertIn(('ip', ), smart_fill.cache.d)
Example #3
0
    def _fill_form(self, fuzzable_req):
        """
        Fill the HTTP request form that is passed as fuzzable_req.
        :return: A filled form
        """
        self._already_filled_form.add(fuzzable_req.get_url())

        to_send = fuzzable_req.get_dc().copy()

        for param_name in to_send:

            # I do not want to mess with the "static" fields
            if isinstance(to_send, form.Form):
                if to_send.get_type(param_name) in ('checkbox', 'file',
                                                    'radio', 'select'):
                    continue

            # Set all the other fields, except from the ones that have a
            # value set (example: hidden fields like __VIEWSTATE).
            for elem_index in xrange(len(to_send[param_name])):

                # TODO: Should I ignore it because it already has a value?
                if to_send[param_name][elem_index] != '':
                    continue

                # SmartFill it!
                to_send[param_name][elem_index] = smart_fill(param_name)

        fuzzable_req.set_dc(to_send)
        return fuzzable_req
Example #4
0
    def smart_fill(self):
        """
        :return: Fills all the empty parameters (which should be filled)
                 using the smart_fill function.
        """
        file_variables = self.get_file_vars()

        for var_name, value, path, setter in self.iter_setters():
            if self.get_parameter_type(var_name) in self.AVOID_FILLING_FORM_TYPES:
                continue

            if isinstance(value, DataToken):
                # This is the value which is being fuzzed (the payload) and
                # I don't want to change/fill it
                continue

            # The basic idea here is that if the form has files in it, we'll
            # need to fill that input with a file (gif, txt, html) in order
            # to go through the form validations
            if var_name in file_variables:
                file_name = self.get_file_name(var_name, None)
                setter(smart_fill_file(var_name, file_name))

            #   Fill only if the parameter does NOT have a value set.
            #
            #   The reason of having this already set would be that the form
            #   has something like this:
            #
            #   <input type="text" name="p" value="foobar">
            #
            elif value == '':
                setter(smart_fill(var_name))
Example #5
0
    def smart_fill(self):
        """
        :return: Fills all the empty parameters (which should be filled)
                 using the smart_fill function.
        """
        file_variables = self.get_file_vars()

        for var_name, value, path, setter in self.iter_setters():
            if self.get_parameter_type(
                    var_name) in self.AVOID_FILLING_FORM_TYPES:
                continue

            if isinstance(value, DataToken):
                # This is the value which is being fuzzed (the payload) and
                # I don't want to change/fill it
                continue

            # The basic idea here is that if the form has files in it, we'll
            # need to fill that input with a file (gif, txt, html) in order
            # to go through the form validations
            if var_name in file_variables:
                file_name = self.get_file_name(var_name, None)
                setter(smart_fill_file(var_name, file_name))

            #   Fill only if the parameter does NOT have a value set.
            #
            #   The reason of having this already set would be that the form
            #   has something like this:
            #
            #   <input type="text" name="p" value="foobar">
            #
            elif value == '':
                setter(smart_fill(var_name))
Example #6
0
    def _get_param_value_for_type_and_spec(self, parameter_type,
                                           parameter_spec):
        """
        :param parameter_type: The type of parameter (string, int32, array, etc.)
        :param parameter_spec: The parameter spec
        :return: The parameter value
        """
        #
        # Easiest cases, the parameter already has a default or example value
        #
        default_value = parameter_spec.get('default', None)

        if default_value is not None:
            return default_value

        example_value = parameter_spec.get('example', None)

        if example_value is not None:
            return example_value

        # This handles the case where the value is an enum and can only be selected
        # from a predefined option list
        if 'enum' in parameter_spec:
            if parameter_spec['enum']:
                return parameter_spec['enum'][0]

        if parameter_type in ('integer', 'float', 'double', 'int32', 'int64'):
            _max = None
            _min = None

            if 'maximum' in parameter_spec:
                _max = parameter_spec['maximum']

            if 'minimum' in parameter_spec:
                _min = parameter_spec['minimum']

            # Only do something if max or min are set
            if _max is not None or _min is not None:
                _max = _max if _max is not None else 56
                _min = _min if _min is not None else 0

                # We always want to generate the same number for the same range
                r = random.Random()
                r.seed(1)

                return r.randint(_min, _max)

        default_value = self.DEFAULT_VALUES_BY_TYPE.get(parameter_type, None)
        if default_value is not None:
            return default_value

        parameter_name = parameter_spec.get('name', None)

        if parameter_type == 'string':
            parameter_name = 'unknown' if parameter_name is None else parameter_name
            return smart_fill(parameter_name)

        if parameter_type == 'file':
            parameter_name = 'unknown' if parameter_name is None else parameter_name
            return smart_fill_file(parameter_name, 'cat.png')
Example #7
0
def mutant_smart_fill(freq, dc_copy, ignore_pname, ignore_index,
                      fuzzer_config):
    """
    :param freq: The fuzzable request (original request instance) we're fuzzing
    :param ignore_pname: A parameter name to ignore
    :param ignore_index: The index we want to ignore

    :return: A data container that has been filled using smart_fill, ignoring
             the parameters that I'm fuzzing and filling the file inputs with
             valid image file.
    """
    for var_name_dc in dc_copy:
        for element_index_dc, element_value_dc in enumerate(
                dc_copy[var_name_dc]):

            if (var_name_dc, element_index_dc) == (ignore_pname, ignore_index):
                continue

            if dc_copy.get_type(var_name_dc) in AVOID_FILLING_FORM_TYPES:
                continue

            #   Fill only if the parameter does NOT have a value set.
            #
            #   The reason of having this already set would be that the form
            #   has something like this:
            #
            #   <input type="text" name="p" value="foobar">
            #
            if dc_copy[var_name_dc][element_index_dc] == '':
                #
                #   Fill it smartly
                #
                dc_copy[var_name_dc][element_index_dc] = smart_fill(
                    var_name_dc)

    # Please see the comment above (search for __HERE__) for an explanation
    # of what we are doing here:
    for var_name in freq.get_file_vars():

        # Try to upload a valid file
        extension = fuzzer_config.get('fuzz_form_files') or 'gif'
        success, file_content, file_name = get_file_from_template(extension)

        # I have to create the NamedStringIO with a "name",
        # required for MultipartPostHandler
        str_file = NamedStringIO(file_content, name=file_name)

        # TODO: Is this hard-coded [0] enough?
        dc_copy[var_name][0] = str_file

    return dc_copy
Example #8
0
def mutant_smart_fill(freq, dc_copy, ignore_pname, ignore_index, fuzzer_config):
    """
    :param freq: The fuzzable request (original request instance) we're fuzzing
    :param ignore_pname: A parameter name to ignore
    :param ignore_index: The index we want to ignore

    :return: A data container that has been filled using smart_fill, ignoring
             the parameters that I'm fuzzing and filling the file inputs with
             valid image file.
    """
    for var_name_dc in dc_copy:
        for element_index_dc, element_value_dc in enumerate(dc_copy[var_name_dc]):

            if (var_name_dc, element_index_dc) == (ignore_pname, ignore_index):
                continue

            if dc_copy.get_type(var_name_dc) in AVOID_FILLING_FORM_TYPES:
                continue

            #   Fill only if the parameter does NOT have a value set.
            #
            #   The reason of having this already set would be that the form
            #   has something like this:
            #
            #   <input type="text" name="p" value="foobar">
            #
            if dc_copy[var_name_dc][element_index_dc] == '':
                #
                #   Fill it smartly
                #
                dc_copy[var_name_dc][element_index_dc] = smart_fill(var_name_dc)

    # Please see the comment above (search for __HERE__) for an explanation
    # of what we are doing here:
    for var_name in freq.get_file_vars():

        # Try to upload a valid file
        extension = fuzzer_config.get('fuzz_form_files') or 'gif'
        success, file_content, file_name = get_file_from_template(extension)

        # I have to create the NamedStringIO with a "name",
        # required for MultipartPostHandler
        str_file = NamedStringIO(file_content, name=file_name)

        # TODO: Is this hard-coded [0] enough?
        dc_copy[var_name][0] = str_file

    return dc_copy
Example #9
0
    def _get_param_value_for_type_and_spec(self, parameter_type, parameter_spec):
        """
        :param parameter_type: The type of parameter (string, int32, array, etc.)
        :param parameter_spec: The parameter spec
        :return: The parameter value
        """
        parameter_name = parameter_spec.get('name', None)

        # This handles the case where the value is an enum and can only be selected
        # from a predefined option list
        if 'enum' in parameter_spec:
            if parameter_spec['enum']:
                return parameter_spec['enum'][0]

        if parameter_type in ('integer', 'float', 'double', 'int32', 'int64'):
            _max = None
            _min = None

            if 'maximum' in parameter_spec:
                _max = parameter_spec['maximum']

            if 'minimum' in parameter_spec:
                _min = parameter_spec['minimum']

            # Only do something if max or min are set
            if _max is not None or _min is not None:
                _max = _max if _max is not None else 56
                _min = _min if _min is not None else 0

                # We always want to generate the same number for the same range
                r = random.Random()
                r.seed(1)

                return r.randint(_min, _max)

        default_value = self.DEFAULT_VALUES_BY_TYPE.get(parameter_type, None)
        if default_value is not None:
            return default_value

        if parameter_type == 'string':
            parameter_name = 'unknown' if parameter_name is None else parameter_name
            return smart_fill(parameter_name)

        if parameter_type == 'file':
            parameter_name = 'unknown' if parameter_name is None else parameter_name
            return smart_fill_file(parameter_name, 'cat.png')
Example #10
0
 def test_default(self):
     self.assertEquals(smart_fill('foobar'), '56')
Example #11
0
 def test_ip_case_insensitive(self):
     self.assertEquals(smart_fill('IP'), '127.0.0.1')
Example #12
0
 def test_ip(self):
     self.assertEquals(smart_fill('ip'), '127.0.0.1')
Example #13
0
 def test_address_2(self):
     self.assertEquals(smart_fill('street_address'), 'Bonsai Street 123')
Example #14
0
 def test_ip(self):
     self.assertEquals(smart_fill('ip'), '127.0.0.1')
Example #15
0
 def test_address_2(self):
     self.assertEquals(smart_fill('street_address'), 'Bonsai Street 123')
Example #16
0
 def test_default(self):
     self.assertEquals(smart_fill('foobar'), '56')
Example #17
0
 def test_ip_case_insensitive(self):
     self.assertEquals(smart_fill('IP'), '127.0.0.1')