diff --git a/benchmarks/appsec_iast_aspects/config.yaml b/benchmarks/appsec_iast_aspects/config.yaml index 9d79d7fdd58..03369c2a4c2 100644 --- a/benchmarks/appsec_iast_aspects/config.yaml +++ b/benchmarks/appsec_iast_aspects/config.yaml @@ -1,234 +1,294 @@ add_aspect: &add_aspect warmups: 1 function_name: "iast_add_aspect" + iast_enabled: true add_noaspect: <<: *add_aspect function_name: "add_noaspect" + iast_enabled: false add_inplace_aspect: &add_inplace_aspect warmups: 1 function_name: "iast_add_inplace_aspect" + iast_enabled: true add_inplace_noaspect: <<: *add_inplace_aspect function_name: "add_inplace_noaspect" + iast_enabled: false bytearray_aspect: &bytearray_aspect warmups: 1 function_name: "iast_bytearray_aspect" + iast_enabled: true bytearray_noaspect: <<: *bytearray_aspect function_name: "bytearray_noaspect" + iast_enabled: false bytearray_extend_aspect: &bytearray_extend_aspect warmups: 1 function_name: "iast_bytearray_extend_aspect" + iast_enabled: true bytearray_extend_noaspect: <<: *bytearray_extend_aspect function_name: "bytearray_extend_noaspect" + iast_enabled: false bytes_aspect: &bytes_aspect warmups: 1 function_name: "iast_bytes_aspect" + iast_enabled: true bytes_noaspect: <<: *bytes_aspect function_name: "bytes_noaspect" + iast_enabled: false bytesio_aspect: &bytesio_aspect warmups: 1 function_name: "iast_bytesio_aspect" + iast_enabled: true bytesio_noaspect: <<: *bytesio_aspect function_name: "bytesio_noaspect" + iast_enabled: false capitalize_aspect: &capitalize_aspect warmups: 1 function_name: "iast_capitalize_aspect" + iast_enabled: true capitalize_noaspect: <<: *capitalize_aspect function_name: "capitalize_noaspect" + iast_enabled: false casefold_aspect: &casefold_aspect warmups: 1 function_name: "iast_casefold_aspect" + iast_enabled: true casefold_noaspect: <<: *casefold_aspect function_name: "casefold_noaspect" + iast_enabled: false decode_aspect: &decode_aspect warmups: 1 function_name: "iast_decode_aspect" + iast_enabled: true decode_noaspect: <<: *decode_aspect function_name: "decode_noaspect" + iast_enabled: false encode_aspect: &encode_aspect warmups: 1 function_name: "iast_encode_aspect" + iast_enabled: true encode_noaspect: <<: *encode_aspect function_name: "encode_noaspect" + iast_enabled: false format_aspect: &format_aspect warmups: 1 function_name: "iast_format_aspect" + iast_enabled: true format_noaspect: <<: *format_aspect function_name: "format_noaspect" + iast_enabled: false format_map_aspect: &format_map_aspect warmups: 1 function_name: "iast_format_map_aspect" + iast_enabled: true format_map_noaspect: <<: *format_map_aspect function_name: "format_map_noaspect" + iast_enabled: false index_aspect: &index_aspect warmups: 1 function_name: "iast_index_aspect" + iast_enabled: true index_noaspect: <<: *index_aspect function_name: "index_noaspect" + iast_enabled: false join_aspect: &join_aspect warmups: 1 function_name: "iast_join_aspect" + iast_enabled: true join_noaspect: <<: *join_aspect function_name: "join_noaspect" + iast_enabled: false strip_aspect: &strip_aspect warmups: 1 function_name: "iast_strip_aspect" + iast_enabled: true strip_noaspect: <<: *strip_aspect function_name: "strip_noaspect" + iast_enabled: false rstrip_aspect: &rstrip_aspect warmups: 1 function_name: "iast_rstrip_aspect" + iast_enabled: true rstrip_noaspect: <<: *rstrip_aspect function_name: "rstrip_noaspect" + iast_enabled: false lstrip_aspect: &lstrip_aspect warmups: 1 function_name: "iast_lstrip_aspect" + iast_enabled: true lstrip_noaspect: <<: *lstrip_aspect function_name: "lstrip_noaspect" + iast_enabled: false lower_aspect: &lower_aspect warmups: 1 function_name: "iast_lower_aspect" + iast_enabled: true lower_noaspect: <<: *lower_aspect function_name: "lower_noaspect" + iast_enabled: false ljust_aspect: &ljust_aspect warmups: 1 function_name: "iast_ljust_aspect" + iast_enabled: true ljust_noaspect: <<: *ljust_aspect function_name: "ljust_noaspect" + iast_enabled: false modulo_aspect: &modulo_aspect warmups: 1 function_name: "iast_modulo_aspect" + iast_enabled: true modulo_aspect_for_bytes: <<: *modulo_aspect function_name: "iast_modulo_aspect_for_bytes" + iast_enabled: true modulo_aspect_for_bytes_bytearray: <<: *modulo_aspect function_name: "iast_modulo_aspect_for_bytes_bytearray" + iast_enabled: true modulo_aspect_for_bytearray_bytearray: <<: *modulo_aspect function_name: "iast_modulo_aspect_for_bytearray_bytearray" + iast_enabled: true modulo_noaspect: <<: *modulo_aspect function_name: "modulo_noaspect" + iast_enabled: false replace_aspect: &replace_aspect warmups: 1 function_name: "iast_replace_aspect" + iast_enabled: true replace_noaspect: <<: *replace_aspect function_name: "replace_noaspect" + iast_enabled: false repr_aspect: &repr_aspect warmups: 1 function_name: "iast_repr_aspect" + iast_enabled: true repr_noaspect: <<: *repr_aspect function_name: "repr_noaspect" + iast_enabled: false + slice_aspect: &slice_aspect warmups: 1 function_name: "iast_slice_aspect" + iast_enabled: true slice_noaspect: <<: *slice_aspect function_name: "slice_noaspect" + iast_enabled: false stringio_aspect: &stringio_aspect warmups: 1 function_name: "iast_stringio_aspect" + iast_enabled: true stringio_noaspect: <<: *stringio_aspect function_name: "stringio_noaspect" + iast_enabled: false swapcase_aspect: &swapcase_aspect warmups: 1 function_name: "iast_swapcase_aspect" + iast_enabled: true swapcase_noaspect: <<: *swapcase_aspect function_name: "swapcase_noaspect" + iast_enabled: false title_aspect: &title_aspect warmups: 1 function_name: "iast_title_aspect" + iast_enabled: true title_noaspect: <<: *title_aspect function_name: "title_noaspect" + iast_enabled: false translate_aspect: &translate_aspect warmups: 1 function_name: "iast_translate_aspect" + iast_enabled: true translate_noaspect: <<: *translate_aspect function_name: "translate_noaspect" + iast_enabled: false upper_aspect: &upper_aspect warmups: 1 function_name: "iast_upper_aspect" + iast_enabled: true upper_noaspect: <<: *upper_aspect function_name: "upper_noaspect" + iast_enabled: false \ No newline at end of file diff --git a/benchmarks/appsec_iast_aspects/functions.py b/benchmarks/appsec_iast_aspects/functions.py index bd8f62d378e..7a58651a1da 100644 --- a/benchmarks/appsec_iast_aspects/functions.py +++ b/benchmarks/appsec_iast_aspects/functions.py @@ -62,422 +62,423 @@ print("Warning: symbols not found in the tested version [%s]: %s" % (version.version, str(notfound_symbols))) -def iast_add_aspect(): - return add_aspect(3, 4) # noqa: F821 +def iast_add_aspect(tainted_str="test"): + return add_aspect(tainted_str, " world") # noqa: F821 -def add_noaspect(): - return 3 + 4 +def add_noaspect(tainted_str="test"): + return tainted_str + " world" -def iast_add_inplace_aspect(): - return add_inplace_aspect(42, 1) # noqa: F821 +def iast_add_inplace_aspect(tainted_str="test"): + return add_inplace_aspect(tainted_str, "second_string") # noqa: F821 -def add_inplace_noaspect(): - a = 42 - a += 1 - return a +def add_inplace_noaspect(tainted_str="test"): + tainted_str = "second_string" + return tainted_str -def iast_bytearray_aspect(): - return bytearray_aspect(bytearray, 0, b"test") # noqa: F821 +def iast_bytearray_aspect(tainted_ba=b"test"): + return bytearray_aspect(bytearray, 0, tainted_ba) # noqa: F821 -def bytearray_noaspect(): - return bytearray(b"test") +def bytearray_noaspect(tainted_ba=b"test"): + return bytearray(tainted_ba) -def iast_bytearray_extend_aspect(): - ba = bytearray(b"hello") +def iast_bytearray_extend_aspect(tainted_ba=b"test"): + ba = bytearray(tainted_ba) bytearray_extend_aspect(None, 0, ba, b" world") # noqa: F821 + return ba -def bytearray_extend_noaspect(): - ba = bytearray(b"hello") +def bytearray_extend_noaspect(tainted_ba=b"test"): + ba = bytearray(tainted_ba) ba.extend(b" world") + return ba -def iast_bytes_aspect(): - return bytes_aspect(bytes, 0, "hello", "utf-8") # noqa: F821 +def iast_bytes_aspect(tainted_str="test"): + return bytes_aspect(bytes, 0, tainted_str, "utf-8") # noqa: F821 -def bytes_noaspect(): - return bytes("hello", "utf-8") +def bytes_noaspect(tainted_str="test"): + return bytes(tainted_str, "utf-8") -def iast_bytesio_aspect(): - x = bytesio_aspect(None, 0, b"data") # noqa: F821 +def iast_bytesio_aspect(tainted_b=b"data"): + x = bytesio_aspect(None, 0, tainted_b) # noqa: F821 return x.read() -def bytesio_noaspect(): - x = _io.BytesIO(b"data") +def bytesio_noaspect(tainted_b=b"data"): + x = _io.BytesIO(tainted_b) return x.read() -def iast_capitalize_aspect(): - return capitalize_aspect(str, 0, "example") # noqa: F821 +def iast_capitalize_aspect(tainted_str="example"): + return capitalize_aspect(str, 0, tainted_str) # noqa: F821 -def capitalize_noaspect(): - return "example".capitalize() +def capitalize_noaspect(tainted_str="example"): + return tainted_str.capitalize() -def iast_casefold_aspect(): - return casefold_aspect(str, 0, "EXAMPLE") # noqa: F821 +def iast_casefold_aspect(tainted_str="EXAMPLE"): + return casefold_aspect(str, 0, tainted_str) # noqa: F821 -def casefold_noaspect(): - return "EXAMPLE".casefold() +def casefold_noaspect(tainted_str="EXAMPLE"): + return tainted_str.casefold() -def iast_decode_aspect(): - return decode_aspect(str, 0, b"hello", "utf-8") # noqa: F821 +def iast_decode_aspect(tainted_b=b"data"): + return decode_aspect(str, 0, tainted_b, "utf-8") # noqa: F821 -def decode_noaspect(): - return b"hello".decode("utf-8") +def decode_noaspect(tainted_b=b"data"): + return tainted_b.decode("utf-8") -def iast_encode_aspect(): - return encode_aspect(bytes, 0, "hello", "utf-8") # noqa: F821 +def iast_encode_aspect(tainted_str="hello"): + return encode_aspect(bytes, 0, tainted_str, "utf-8") # noqa: F821 -def encode_noaspect(): - return "hello".encode("utf-8") +def encode_noaspect(tainted_str="hello"): + return tainted_str.encode("utf-8") -def iast_format_aspect(): - return format_aspect(None, 1, "Hello, {}!", "World") # noqa: F821 +def iast_format_aspect(tainted_str="Hello, {}!"): + return format_aspect(None, 1, tainted_str, "World") # noqa: F821 -def format_noaspect(): - return "Hello, {}!".format("World") +def format_noaspect(tainted_str="Hello, {}!"): + return tainted_str.format("World") -def iast_format_map_aspect(): +def iast_format_map_aspect(*args, **kwargs): return format_map_aspect(None, 1, "{greeting}, World!", {"greeting": "Hello"}) # noqa: F821 -def format_map_noaspect(): +def format_map_noaspect(*args, **kwargs): return "{greeting}, World!".format_map({"greeting": "Hello"}) -def iast_index_aspect(): - return index_aspect("example", 3) # noqa: F821 +def iast_index_aspect(tainted_str="example"): + return index_aspect(tainted_str, 3) # noqa: F821 -def index_noaspect(): - return "example"[3] +def index_noaspect(tainted_str="example"): + return tainted_str[3] -def iast_join_aspect(): +def iast_join_aspect(*args, **kwargs): return join_aspect(None, 1, ", ", ["one", "two", "three"]) # noqa: F821 -def join_noaspect(): +def join_noaspect(*args, **kwargs): return ", ".join(["one", "two", "three"]) -def iast_lower_aspect(): - return lower_aspect(None, 1, "EXAMPLE") # noqa: F821 +def iast_lower_aspect(tainted_str="EXAMPLE"): + return lower_aspect(None, 1, tainted_str) # noqa: F821 -def lower_noaspect(): - return "EXAMPLE".lower() +def lower_noaspect(tainted_str="EXAMPLE"): + return tainted_str.lower() -def iast_ljust_aspect(): - return ljust_aspect(None, 1, "example", 10) # noqa: F821 +def iast_ljust_aspect(tainted_str="example"): + return ljust_aspect(None, 1, tainted_str, 10) # noqa: F821 -def ljust_noaspect(): - return "example".ljust(10) +def ljust_noaspect(tainted_str="example"): + return tainted_str.ljust(10) -def iast_modulo_aspect(): +def iast_modulo_aspect(*args, **kwargs): return modulo_aspect("hello %s", "foo") # noqa: F821 -def iast_modulo_aspect_for_bytes(): +def iast_modulo_aspect_for_bytes(*args, **kwargs): return modulo_aspect(b"hello %s", b"foo") # noqa: F821 -def iast_modulo_aspect_for_bytes_bytearray(): +def iast_modulo_aspect_for_bytes_bytearray(*args, **kwargs): return modulo_aspect(b"hello %s", bytearray(b"foo")) # noqa: F821 -def iast_modulo_aspect_for_bytearray_bytearray(): +def iast_modulo_aspect_for_bytearray_bytearray(*args, **kwargs): return modulo_aspect(bytearray(b"hello %s"), bytearray(b"foo")) # noqa: F821 -def modulo_noaspect(): +def modulo_noaspect(*args, **kwargs): return "{} {}".format("hello", "world") -def iast_ospathbasename_aspect(): +def iast_ospathbasename_aspect(*args, **kwargs): return ospathbasename_aspect("/path/to/file") # noqa: F821 -def ospathbasename_noaspect(): +def ospathbasename_noaspect(*args, **kwargs): return os.path.basename("/path/to/file") -def iast_ospathdirname_aspect(): +def iast_ospathdirname_aspect(*args, **kwargs): return ospathdirname_aspect("/path/to/file") # noqa: F821 -def ospathdirname_noaspect(): +def ospathdirname_noaspect(*args, **kwargs): return os.path.dirname("/path/to/file") -def iast_ospathjoin_aspect(): +def iast_ospathjoin_aspect(*args, **kwargs): return ospathjoin_aspect("/path", "to", "file") # noqa: F821 -def ospathjoin_noaspect(): +def ospathjoin_noaspect(*args, **kwargs): return os.path.join("/path", "to", "file") -def iast_ospathnormcase_aspect(): +def iast_ospathnormcase_aspect(*args, **kwargs): return ospathnormcase_aspect("example") # noqa: F821 -def ospathnormcase_noaspect(): +def ospathnormcase_noaspect(*args, **kwargs): return os.path.normcase("example") -def iast_ospathsplit_aspect(): +def iast_ospathsplit_aspect(*args, **kwargs): return ospathsplit_aspect("/path/to/file") # noqa: F821 -def ospathsplit_noaspect(): +def ospathsplit_noaspect(*args, **kwargs): return os.path.split("/path/to/file") -def iast_ospathsplitdrive_aspect(): +def iast_ospathsplitdrive_aspect(*args, **kwargs): return ospathsplitdrive_aspect("/path/to/file") # noqa: F821 -def ospathsplitdrive_noaspect(): +def ospathsplitdrive_noaspect(*args, **kwargs): return os.path.splitdrive("/path/to/file") -def iast_ospathsplitext_aspect(): +def iast_ospathsplitext_aspect(*args, **kwargs): return ospathsplitext_aspect("/path/to/file") # noqa: F821 -def ospathsplitext_noaspect(): +def ospathsplitext_noaspect(*args, **kwargs): return os.path.splitext("/path/to/file") -def iast_re_sub_aspect(): +def iast_re_sub_aspect(*args, **kwargs): return re_sub_aspect(None, 1, re.compile("/"), "_", "foo/bar") # noqa: F821 -def re_sub_noaspect(): +def re_sub_noaspect(*args, **kwargs): return re.sub("/", "_", "foo/bar") -def iast_rsplit_aspect(): +def iast_rsplit_aspect(*args, **kwargs): return rsplit_aspect(None, 0, "foo bar baz") # noqa: F821 -def rsplit_noaspect(): - return "foo bar baz".rsplit() +def rsplit_noaspect(*args, **kwargs): + return "foo bar baz".rsplit(*args, **kwargs) -def iast_splitlines_aspect(): +def iast_splitlines_aspect(*args, **kwargs): return splitlines_aspect(None, 0, "line1\nline2\nline3") # noqa: F821 -def splitlines_noaspect(): - return "line1\nline2\nline3".splitlines() +def splitlines_noaspect(*args, **kwargs): + return "line1\nline2\nline3".splitlines(*args, **kwargs) -def iast_str_aspect(): +def iast_str_aspect(*args, **kwargs): return str_aspect(str, 0, 42) # noqa: F821 -def str_noaspect(): +def str_noaspect(*args, **kwargs): return str(42) -def iast_stringio_aspect(): +def iast_stringio_aspect(*args, **kwargs): io = stringio_aspect(None, 0, "data") # noqa: F821 - return io.read() + return io.read(*args, **kwargs) -def stringio_noaspect(): +def stringio_noaspect(*args, **kwargs): io = _io.StringIO("data") - return io.read() + return io.read(*args, **kwargs) -def iast_repr_aspect(): +def iast_repr_aspect(*args, **kwargs): return repr_aspect(None, 0, 42) # noqa: F821 -def repr_noaspect(): +def repr_noaspect(*args, **kwargs): return repr(42) -def iast_slice_aspect(): +def iast_slice_aspect(tainted_str="example"): return slice_aspect( # noqa: F821 - "example", + tainted_str, 1, 3, 1, ) -def slice_noaspect(): - return "example"[1:3:1] +def slice_noaspect(tainted_str="example"): + return tainted_str[1:3:1] -def iast_replace_aspect(): - return replace_aspect(None, 1, "example", "example", "foo") # noqa: F821 +def iast_replace_aspect(tainted_str="example"): + return replace_aspect(None, 1, tainted_str, "example", "foo") # noqa: F821 -def replace_noaspect(): - return "example".replace("example", "foo") +def replace_noaspect(tainted_str="example"): + return tainted_str.replace("example", "foo") -def iast_re_subn_aspect(): +def iast_re_subn_aspect(*args, **kwargs): return re_subn_aspect(None, 1, re.compile("/"), "_", "foo/bar") # noqa: F821 -def re_subn_noaspect(): +def re_subn_noaspect(*args, **kwargs): return re.subn("/", "_", "foo/bar") -def iast_re_search_aspect(): +def iast_re_search_aspect(*args, **kwargs): return re_search_aspect(None, 1, re.compile("foo"), "foo bar") # noqa: F821 -def re_search_noaspect(): +def re_search_noaspect(*args, **kwargs): return re.search("foo", "foo bar") -def iast_re_match_aspect(): +def iast_re_match_aspect(*args, **kwargs): return re_match_aspect(None, 1, re.compile("foo"), "foo bar") # noqa: F821 -def re_match_noaspect(): +def re_match_noaspect(*args, **kwargs): return re.match("foo", "foo bar") -def iast_re_groups_aspect(): +def iast_re_groups_aspect(*args, **kwargs): return re_groups_aspect(None, 0, re.match(r"(\w+) (\w+)", "Hello World")) # noqa: F821 -def re_groups_noaspect(): - return re.match(r"(\w+) (\w+)", "Hello World").groups() +def re_groups_noaspect(*args, **kwargs): + return re.match(r"(\w+) (\w+)", "Hello World").groups(*args, **kwargs) -def iast_re_group_aspect(): +def iast_re_group_aspect(*args, **kwargs): return re_group_aspect(None, 0, re.match(r"(\w+) (\w+)", "Hello World")) # noqa: F821 -def re_group_noaspect(): - return re.match(r"(\w+) (\w+)", "Hello World").group() +def re_group_noaspect(*args, **kwargs): + return re.match(r"(\w+) (\w+)", "Hello World").group(*args, **kwargs) -def iast_re_fullmatch_aspect(): +def iast_re_fullmatch_aspect(*args, **kwargs): return re_fullmatch_aspect(None, 1, re.compile("foo"), "foo") # noqa: F821 -def re_fullmatch_noaspect(): +def re_fullmatch_noaspect(*args, **kwargs): return re.fullmatch("foo", "foo") -def iast_re_finditer_aspect(): +def iast_re_finditer_aspect(*args, **kwargs): return re_finditer_aspect(None, 1, re.compile("foo"), "foo bar foo") # noqa: F821 -def re_finditer_noaspect(): +def re_finditer_noaspect(*args, **kwargs): return re.finditer("foo", "foo bar foo") -def iast_re_findall_aspect(): +def iast_re_findall_aspect(*args, **kwargs): return re_findall_aspect(None, 1, re.compile("foo"), "foo bar foo") # noqa: F821 -def re_findall_noaspect(): +def re_findall_noaspect(*args, **kwargs): return re.findall("foo", "foo bar foo") -def iast_re_expand_aspect(): +def iast_re_expand_aspect(*args, **kwargs): re_obj = re.compile(r"(\w+) (\w+)") match = re.match(re_obj, "Hello World") return re_expand_aspect(None, 1, match, "Salute: \\1 Subject: \\2") # noqa: F821 -def re_expand_noaspect(): +def re_expand_noaspect(*args, **kwargs): re_obj = re.compile(r"(\w+) (\w+)") match = re.match(re_obj, "Hello World") return match.expand("Salute: \\1 Subject: \\2") -def iast_upper_aspect(): - return upper_aspect(None, 1, "example") # noqa: F821 +def iast_upper_aspect(tainted_str="example"): + return upper_aspect(None, 1, tainted_str) # noqa: F821 -def upper_noaspect(): - return "example".upper() +def upper_noaspect(tainted_str="example"): + return tainted_str.upper() -def iast_translate_aspect(): - return translate_aspect(None, 1, "example", {101: 105}) # noqa: F821 +def iast_translate_aspect(tainted_str="example"): + return translate_aspect(None, 1, tainted_str, {101: 105}) # noqa: F821 -def translate_noaspect(): - return "example".translate({101: 105}) +def translate_noaspect(tainted_str="example"): + return tainted_str.translate({101: 105}) -def iast_title_aspect(): - return title_aspect(None, 1, "hello world") # noqa: F821 +def iast_title_aspect(tainted_str="hello world"): + return title_aspect(None, 1, tainted_str) # noqa: F821 -def title_noaspect(): - return "hello world".title() +def title_noaspect(tainted_str="hello world"): + return tainted_str.title() -def iast_swapcase_aspect(): - return swapcase_aspect(None, 1, "Hello World") # noqa: F821 +def iast_swapcase_aspect(tainted_str="Hello World"): + return swapcase_aspect(None, 1, tainted_str) # noqa: F821 -def swapcase_noaspect(): - return "Hello World".swapcase() +def swapcase_noaspect(tainted_str="Hello World"): + return tainted_str.swapcase() -def iast_split_aspect(): - return split_aspect(None, 1, "foo bar baz") # noqa: F821 +def iast_split_aspect(tainted_str="foo bar baz"): + return split_aspect(None, 1, tainted_str) # noqa: F821 -def split_noaspect(): - return "foo bar baz".split() +def split_noaspect(tainted_str="foo bar baz"): + return tainted_str.split() -def iast_strip_aspect(): - return strip_aspect(None, 1, " foo bar baz ") # noqa: F821 +def iast_strip_aspect(tainted_str=" foo bar baz "): + return strip_aspect(None, 1, tainted_str) # noqa: F821 -def strip_noaspect(): - return " foo bar baz ".strip() +def strip_noaspect(tainted_str=" foo bar baz "): + return tainted_str.strip() -def iast_rstrip_aspect(): - return rstrip_aspect(None, 1, " foo bar baz ") # noqa: F821 +def iast_rstrip_aspect(tainted_str=" foo bar baz "): + return rstrip_aspect(None, 1, tainted_str) # noqa: F821 -def rstrip_noaspect(): - return " foo bar baz ".rstrip() +def rstrip_noaspect(tainted_str=" foo bar baz "): + return tainted_str.rstrip() -def iast_lstrip_aspect(): - return lstrip_aspect(None, 1, " foo bar baz ") # noqa: F821 +def iast_lstrip_aspect(tainted_str=" foo bar baz "): + return lstrip_aspect(None, 1, tainted_str) # noqa: F821 -def lstrip_noaspect(): - return " foo bar baz ".lstrip() +def lstrip_noaspect(tainted_str=" foo bar baz "): + return tainted_str.lstrip()