From 9cd0619e2bf498d727771bf6cb0f4c763641d1e3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Fri, 30 Oct 2026 17:31:39 +0100 Subject: [PATCH 01/93] Dummy update --- lib/core/settings.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index b82c17527..5ad34c3a9 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.0" +VERSION = "1.10.11.1" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) @@ -114,7 +114,7 @@ BOOLEAN_MODEL_MATCH_RATIO = 0.9 PARAMETER_MINING_BUCKET_SIZE = 25 # For filling in case of dumb push updates -DUMMY_JUNK = "Phah5jue" +DUMMY_JUNK = "rie8kooZ" # Markers for special cases when parameter values contain html encoded characters PARAMETER_AMP_MARKER = "__PARAMETER_AMP__" From c15f4bf0552e9d50d4cf1d6a308fa15ccee99161 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Mon, 2 Nov 2026 11:13:40 +0100 Subject: [PATCH 02/93] Fixes #6168 --- lib/core/common.py | 2 +- lib/core/settings.py | 2 +- lib/utils/har.py | 22 ++++++++++++++-------- tests/test_har.py | 8 ++++++++ 4 files changed, 24 insertions(+), 10 deletions(-) diff --git a/lib/core/common.py b/lib/core/common.py index dcb60caad..3a99cc794 100644 --- a/lib/core/common.py +++ b/lib/core/common.py @@ -3236,7 +3236,7 @@ def logHTTPTraffic(requestLogMsg, responseLogMsg, startTime=None, endTime=None): """ if conf.harFile: - conf.httpCollector.collectRequest(requestLogMsg, responseLogMsg, startTime, endTime) + conf.httpCollector.collectRequest(requestLogMsg, responseLogMsg, startTime, endTime, scheme=conf.scheme) if conf.trafficFile: with kb.locks.log: diff --git a/lib/core/settings.py b/lib/core/settings.py index 5ad34c3a9..1886520a3 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.1" +VERSION = "1.10.11.2" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/utils/har.py b/lib/utils/har.py index 0eb31a1c1..c684ed499 100644 --- a/lib/utils/har.py +++ b/lib/utils/har.py @@ -36,10 +36,10 @@ class HTTPCollector(object): def setExtendedArguments(self, arguments): self.extendedArguments = arguments - def collectRequest(self, requestMessage, responseMessage, startTime=None, endTime=None): + def collectRequest(self, requestMessage, responseMessage, startTime=None, endTime=None, scheme=None): self.messages.append(RawPair(requestMessage, responseMessage, startTime=startTime, endTime=endTime, - extendedArguments=self.extendedArguments)) + extendedArguments=self.extendedArguments, scheme=scheme)) def obtain(self): return {"log": { @@ -49,15 +49,16 @@ class HTTPCollector(object): }} class RawPair(object): - def __init__(self, request, response, startTime=None, endTime=None, extendedArguments=None): + def __init__(self, request, response, startTime=None, endTime=None, extendedArguments=None, scheme=None): self.request = getBytes(request) self.response = getBytes(response) self.startTime = startTime self.endTime = endTime self.extendedArguments = extendedArguments or {} + self.scheme = scheme # Note: of the target at the time of the request (as origin-form request lines don't carry one) def toEntry(self): - return Entry(request=Request.parse(self.request), response=Response.parse(self.response), + return Entry(request=Request.parse(self.request, self.scheme), response=Response.parse(self.response), startTime=self.startTime, endTime=self.endTime, extendedArguments=self.extendedArguments) @@ -86,7 +87,7 @@ class Entry(object): return out class Request(object): - def __init__(self, method, path, httpVersion, headers, postBody=None, raw=None, comment=None): + def __init__(self, method, path, httpVersion, headers, postBody=None, raw=None, comment=None, scheme=None): self.method = method self.path = path self.httpVersion = httpVersion @@ -94,9 +95,10 @@ class Request(object): self.postBody = postBody self.comment = comment.strip() if comment else comment self.raw = raw + self.scheme = scheme @classmethod - def parse(cls, raw): + def parse(cls, raw, scheme=None): request = HTTPRequest(raw) return cls(method=request.command, path=request.path, @@ -104,12 +106,16 @@ class Request(object): headers=request.headers, postBody=request.rfile.read(), comment=request.comment, - raw=raw) + raw=raw, + scheme=scheme) @property def url(self): + if re.search(r"(?i)\Ahttps?://", self.path or ""): # Note: absolute-form request target (e.g. refreshing/crawling/checking requests) + return self.path + host = self.headers.get("Host", "unknown") - return "http://%s%s" % (host, self.path) + return "%s://%s%s" % (self.scheme or "http", host, self.path) def toDict(self): out = { diff --git a/tests/test_har.py b/tests/test_har.py index 9b6142624..3ca6b547e 100644 --- a/tests/test_har.py +++ b/tests/test_har.py @@ -52,6 +52,14 @@ class TestHTTPCollector(unittest.TestCase): self.assertEqual(entries[0]["request"]["method"], "GET") self.assertEqual(entries[0]["response"]["status"], 200) + def test_request_url_scheme(self): + # Note: origin-form request lines carry no scheme (HTTPS targets used to be logged as 'http://'), while + # absolute-form ones (refreshing/crawling/checking requests) used to get the Host prepended to them + c = H.HTTPCollector() + for line, scheme in (("GET /?id=1", "https"), ("GET /?id=1", None), ("GET https://other.com:8443/x?id=1", "http")): + c.collectRequest(("%s HTTP/1.1\r\nHost: example.com\r\n\r\n" % line).encode(), b"HTTP/1.1 200 OK\r\n\r\n", startTime=1000, endTime=2000, scheme=scheme) + self.assertEqual([_["request"]["url"] for _ in c.obtain()["log"]["entries"]], ["https://example.com/?id=1", "http://example.com/?id=1", "https://other.com:8443/x?id=1"]) + class TestHTTPCollectorFactory(unittest.TestCase): def test_create_returns_collector(self): From 3130623afce1012411af60b1567b9c78495b6287 Mon Sep 17 00:00:00 2001 From: cuteNBD <2905153124@qq.com> Date: Wed, 4 Nov 2026 05:03:38 +0800 Subject: [PATCH 03/93] Preserve non-default ports in Host headers (#6171) Co-authored-by: cuteNBD <206630735+bingdongni@users.noreply.github.com> --- lib/core/common.py | 10 +++++----- tests/test_common_helpers.py | 15 +++++++++++++++ 2 files changed, 20 insertions(+), 5 deletions(-) diff --git a/lib/core/common.py b/lib/core/common.py index 3a99cc794..0195ff821 100644 --- a/lib/core/common.py +++ b/lib/core/common.py @@ -5138,12 +5138,12 @@ def getHostHeader(url): retVal = url if url: - retVal = _urllib.parse.urlparse(url).netloc + parsed = _urllib.parse.urlparse(url) + retVal = parsed.netloc + defaultPort = {"http": 80, "https": 443}.get(parsed.scheme.lower()) - # Note: netloc keeps the IPv6 brackets (and any port), so only the default ports are - # stripped here - mirroring the hostname/IPv4 branch and preserving non-default ports - # (e.g. '[::1]:8080') as required by RFC 7230 - if any(retVal.endswith(':%d' % _) for _ in (80, 443)): + # Keep non-default ports, including 80 on HTTPS and 443 on HTTP. + if defaultPort is not None and retVal.endswith(':%d' % defaultPort): retVal = retVal[:retVal.rfind(':')] if retVal and retVal.count(':') > 1 and not any(_ in retVal for _ in ('[', ']')): diff --git a/tests/test_common_helpers.py b/tests/test_common_helpers.py index ca37d14bd..6c9e88275 100644 --- a/tests/test_common_helpers.py +++ b/tests/test_common_helpers.py @@ -70,6 +70,21 @@ class TestGetHostHeader(unittest.TestCase): def test_without_port(self): self.assertEqual(getHostHeader("http://example.com/path"), "example.com") + def test_default_ports_depend_on_scheme(self): + cases = ( + ("http://example.com:80/path", "example.com"), + ("https://example.com:443/path", "example.com"), + ("http://example.com:443/path", "example.com:443"), + ("https://example.com:80/path", "example.com:80"), + ("HTTP://example.com:443/path", "example.com:443"), + ("http://[::1]:80/path", "[::1]"), + ("https://[::1]:443/path", "[::1]"), + ("http://[::1]:443/path", "[::1]:443"), + ("https://[::1]:80/path", "[::1]:80"), + ) + for url, expected in cases: + self.assertEqual(getHostHeader(url), expected, msg=url) + if __name__ == "__main__": unittest.main(verbosity=2) From 8476cf4d09d7c4784bb83f2b34e7551961569add Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Tue, 3 Nov 2026 22:04:01 +0100 Subject: [PATCH 04/93] Fix related to the #6171 (WebSocket Host port) --- lib/core/common.py | 2 +- lib/core/settings.py | 2 +- lib/request/websocket.py | 2 +- tests/test_websocket.py | 29 +++++++++++++++++++++++++++++ 4 files changed, 32 insertions(+), 3 deletions(-) diff --git a/lib/core/common.py b/lib/core/common.py index 0195ff821..7231fa229 100644 --- a/lib/core/common.py +++ b/lib/core/common.py @@ -5140,7 +5140,7 @@ def getHostHeader(url): if url: parsed = _urllib.parse.urlparse(url) retVal = parsed.netloc - defaultPort = {"http": 80, "https": 443}.get(parsed.scheme.lower()) + defaultPort = {"http": 80, "https": 443, "ws": 80, "wss": 443}.get(parsed.scheme.lower()) # Keep non-default ports, including 80 on HTTPS and 443 on HTTP. if defaultPort is not None and retVal.endswith(':%d' % defaultPort): diff --git a/lib/core/settings.py b/lib/core/settings.py index 1886520a3..ccaea017a 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.2" +VERSION = "1.10.11.3" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/websocket.py b/lib/request/websocket.py index 1d8f56aee..88d58a790 100644 --- a/lib/request/websocket.py +++ b/lib/request/websocket.py @@ -73,7 +73,7 @@ class WebSocket(object): self.sock.settimeout(self._timeout) hostport = "[%s]" % host if ":" in host else host # bracket IPv6 literals - if port not in (80, 443): + if port != (443 if secure else 80): # Note: only the scheme's own default port gets omitted hostport = "%s:%d" % (hostport, port) key = getText(base64.b64encode(os.urandom(16))) diff --git a/tests/test_websocket.py b/tests/test_websocket.py index 6091229a6..6197c3ac7 100644 --- a/tests/test_websocket.py +++ b/tests/test_websocket.py @@ -133,6 +133,35 @@ class TestWebSocket(unittest.TestCase): ws = _client(); ws.sock = _RaisingSock(_ssl.SSLError("decryption failed")) self.assertRaises(_ssl.SSLError, ws.recv) + def test_handshake_host_port(self): + # Note: only the scheme's own default port is omitted (port 443 used to be dropped for 'ws://' too) + import lib.request.websocket as W + + class _Sent(Exception): + pass + + class _Capture(_FakeSock): + def settimeout(self, value): + pass + + def sendall(self, data): + raise _Sent(data) + + original = W.socket.create_connection + try: + W.socket.create_connection = lambda *args, **kwargs: _Capture() + for url, host in (("ws://example.com:443/x", "example.com:443"), ("ws://example.com:80/x", "example.com"), ("ws://example.com:8080/x", "example.com:8080")): + ws = WebSocket.__new__(WebSocket) + ws._timeout = None + try: + ws.connect(url) + except _Sent as ex: + self.assertIn(("Host: %s\r\n" % host).encode(), ex.args[0]) + else: + self.fail("handshake was not sent") + finally: + W.socket.create_connection = original + if __name__ == "__main__": unittest.main() From bf8b9956e047f19c95b0686df0ff03ded3b528b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Tue, 3 Nov 2026 22:04:29 +0100 Subject: [PATCH 05/93] Fixes #6170 --- lib/core/convert.py | 3 +++ lib/core/settings.py | 2 +- tests/test_serialize.py | 13 +++++++++++++ 3 files changed, 17 insertions(+), 1 deletion(-) diff --git a/lib/core/convert.py b/lib/core/convert.py index f3927e60d..ec6ed2015 100644 --- a/lib/core/convert.py +++ b/lib/core/convert.py @@ -125,6 +125,9 @@ def _serializeEncode(value): if isinstance(value, decimal.Decimal): return {_SERIALIZE_TAG: "dec", "v": getUnicode(value)} + if isinstance(value, (datetime.datetime, datetime.time)) and value.tzinfo is not None: + return getUnicode(value) # Note: time zone aware value (e.g. from '-d' connector) kept as displayed, as an arbitrary tzinfo can't be rebuilt + if isinstance(value, datetime.datetime): return {_SERIALIZE_TAG: "dt", "v": [value.year, value.month, value.day, value.hour, value.minute, value.second, value.microsecond]} diff --git a/lib/core/settings.py b/lib/core/settings.py index ccaea017a..b067c067e 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.3" +VERSION = "1.10.11.4" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/tests/test_serialize.py b/tests/test_serialize.py index fb7b72bcb..17b163e26 100644 --- a/tests/test_serialize.py +++ b/tests/test_serialize.py @@ -259,6 +259,19 @@ class TestDbmsScalars(unittest.TestCase): self.assertEqual(restored, value) self.assertIs(type(restored), type(value)) + def test_timezone_aware_kept_as_displayed(self): + # Note: a resumed '-d' session used to drop the offset (e.g. '+05:30'), as only naive fields got stored + class _Offset(datetime.tzinfo): + def utcoffset(self, dt): + return datetime.timedelta(hours=5, minutes=30) + + def dst(self, dt): + return datetime.timedelta(0) + + for value in (datetime.datetime(2024, 1, 2, 3, 4, 0, tzinfo=_Offset()), datetime.time(3, 4, 0, tzinfo=_Offset())): + self.assertEqual(rt(value), getUnicode(value)) + self.assertTrue(rt(value).endswith("+05:30")) + class TestRealSessionObjects(unittest.TestCase): # the exact shapes written with serialize=True across the codebase From 74f50122fbd620652f6369099cdf02e9540b657f Mon Sep 17 00:00:00 2001 From: cuteNBD <2905153124@qq.com> Date: Wed, 4 Nov 2026 17:18:06 +0800 Subject: [PATCH 06/93] Preserve custom Host headers for WebSocket requests (#6172) Co-authored-by: cuteNBD <206630735+bingdongni@users.noreply.github.com> --- lib/request/connect.py | 8 +++- lib/request/websocket.py | 4 +- tests/test_websocket.py | 85 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 95 insertions(+), 2 deletions(-) diff --git a/lib/request/connect.py b/lib/request/connect.py index 04fc3f3a4..d6c043608 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -521,6 +521,8 @@ class Connect(object): # Prepare HTTP headers headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host or getHeader(dict(conf.httpHeaders), HTTP_HEADER.HOST) or getHostHeader(url)}, base=None if target else {}) + # WebSocket builds its own default Host, but must preserve explicit overrides. + customWsHost = webSocket and bool(host or getHeader(dict(conf.httpHeaders), HTTP_HEADER.HOST) or getHeader(auxHeaders, HTTP_HEADER.HOST) is not None) if HTTP_HEADER.COOKIE in headers: cookie = headers[HTTP_HEADER.COOKIE] @@ -573,9 +575,13 @@ class Connect(object): if ':' in line: header, value = line.split(':', 1) headers[header] = value + if webSocket and header.upper() == HTTP_HEADER.HOST.upper(): + headers[HTTP_HEADER.HOST] = value + customWsHost = True if conf.localhost: headers[HTTP_HEADER.HOST] = "localhost" + customWsHost = True for key, value in list(headers.items()): if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper(): @@ -600,7 +606,7 @@ class Connect(object): try: ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout) wsHeaders = tuple("%s: %s" % (getUnicode(key), getUnicode(value)) for key, value in headers.items() if getUnicode(key).upper() != HTTP_HEADER.HOST.upper()) - ws.connect(url, header=wsHeaders, cookie=cookie) # WebSocket will add Host field of headers automatically + ws.connect(url, header=wsHeaders, cookie=cookie, host_header=getHeader(headers, HTTP_HEADER.HOST) if customWsHost else None) ws.send(urldecode(post or "")) _page = [] diff --git a/lib/request/websocket.py b/lib/request/websocket.py index 88d58a790..9cb43ed2c 100644 --- a/lib/request/websocket.py +++ b/lib/request/websocket.py @@ -58,7 +58,7 @@ class WebSocket(object): if self.sock is not None: self.sock.settimeout(timeout) - def connect(self, url, header=None, cookie=None): + def connect(self, url, header=None, cookie=None, host_header=None): parts = _urllib.parse.urlsplit(url) secure = parts.scheme == "wss" host = parts.hostname @@ -75,6 +75,8 @@ class WebSocket(object): hostport = "[%s]" % host if ":" in host else host # bracket IPv6 literals if port != (443 if secure else 80): # Note: only the scheme's own default port gets omitted hostport = "%s:%d" % (hostport, port) + if host_header is not None: + hostport = getText(host_header) key = getText(base64.b64encode(os.urandom(16))) lines = ["GET %s HTTP/1.1" % resource, diff --git a/tests/test_websocket.py b/tests/test_websocket.py index 6197c3ac7..bea72b715 100644 --- a/tests/test_websocket.py +++ b/tests/test_websocket.py @@ -33,6 +33,9 @@ from lib.request.websocket import ( OPCODE_PING, OPCODE_CLOSE, ) +from lib.request.connect import Connect + +_GET_PAGE = Connect.__dict__["getPage"] class _FakeSock(object): @@ -162,6 +165,88 @@ class TestWebSocket(unittest.TestCase): finally: W.socket.create_connection = original + def test_getpage_preserves_host_header(self): + import socket + import tempfile + import lib.request.websocket as W + from lib.core.data import conf, kb + from lib.core.option import _setKnowledgeBaseAttributes + from lib.core.threads import getCurrentThreadData + + class _HandshakeSock(_FakeSock): + def __init__(self): + _FakeSock.__init__(self) + self.handshake = None + self.response = b"" + + def settimeout(self, value): + pass + + def sendall(self, data): + if self.handshake is None: + self.handshake = data + key = next(line.split(b":", 1)[1].strip() for line in data.split(b"\r\n") if line.lower().startswith(b"sec-websocket-key:")) + accept = base64.b64encode(hashlib.sha1(key + _GUID.encode("ascii")).digest()) + self.response = b"HTTP/1.1 101 Switching Protocols\r\nSec-WebSocket-Accept: " + accept + b"\r\n\r\n" + _serverFrame("ok") + + def recv(self, size): + result, self.response = self.response[:size], self.response[size:] + return result + + sockets = [] + def create_socket(*args, **kwargs): + sock = _HandshakeSock() + sockets.append(sock) + return sock + + oldConf, oldKb = dict(conf), dict(kb) + threadData = getCurrentThreadData() + oldThreadData = dict(threadData.__dict__) + oldTimeout = socket.getdefaulttimeout() + original = W.socket.create_connection + oldGetPage = Connect.__dict__["getPage"] + fd, headersFile = tempfile.mkstemp(prefix="sqlmap-ws-headers-") + try: + with os.fdopen(fd, "w") as f: + f.write("hOsT: file.example\n") + threadData.__dict__.clear() + threadData.reset() + _setKnowledgeBaseAttributes(False) + kb.wizardMode, kb.webSocketRecvCount = True, 1 + conf.url = "ws://example.test:8080/test" + conf.hostname, conf.scheme, conf.port, conf.path = "example.test", "ws", 8080, "/test" + conf.parameters, conf.data = {}, None + conf.abortCode, conf.ignoreCode = [], [] + conf.timeout, conf.batch, conf.keepAlive = 3, True, False + conf.retryOn, conf.ignoreRedirects, conf.scope = None, False, None + W.socket.create_connection = create_socket + Connect.getPage = _GET_PAGE + cases = ( + ("ws://example.test:8080/test", [], None, None, None, False, "example.test:8080"), + ("ws://user:pass@example.test:8080/test", [], None, None, None, False, "example.test:8080"), + ("ws://example.test:8080/test", [('hOsT', 'configured.example')], None, None, None, False, "configured.example"), + ("ws://example.test:8080/test", [('Host', 'configured.example')], "override.example:8443", None, None, False, "override.example:8443"), + ("ws://example.test:8080/test", [], None, {'Host': 'aux.example'}, None, False, "aux.example"), + ("ws://example.test:8080/test", [], None, None, headersFile, False, "file.example"), + ("ws://example.test:8080/test", [], None, None, None, True, "localhost"), + ) + for url, headers, host, aux, path, localhost, expected in cases: + conf.url = url + conf.httpHeaders = headers + conf.localhost, kb.headersFile = localhost, path + self.assertEqual(Connect.getPage(url=url, host=host, auxHeaders=aux)[0], "ok") + hostLines = [line for line in sockets[-1].handshake.split(b"\r\n") if line.lower().startswith(b"host:")] + self.assertEqual(len(hostLines), 1) + self.assertEqual(hostLines[0].split(b":", 1)[1].strip(), expected.encode("ascii")) + finally: + Connect.getPage = oldGetPage + W.socket.create_connection = original + socket.setdefaulttimeout(oldTimeout) + conf.clear(); conf.update(oldConf) + kb.clear(); kb.update(oldKb) + threadData.__dict__.clear(); threadData.__dict__.update(oldThreadData) + os.unlink(headersFile) + if __name__ == "__main__": unittest.main() From b333a14d8ba5de058a28e4e4d6391fe57ca8f0b6 Mon Sep 17 00:00:00 2001 From: cuteNBD <2905153124@qq.com> Date: Wed, 4 Nov 2026 17:18:29 +0800 Subject: [PATCH 07/93] Keep WebSocket responses on normal closure (#6173) Co-authored-by: cuteNBD <206630735+bingdongni@users.noreply.github.com> --- lib/request/connect.py | 8 +- lib/request/websocket.py | 8 ++ tests/test_websocket_response.py | 124 +++++++++++++++++++++++++++++++ 3 files changed, 136 insertions(+), 4 deletions(-) create mode 100644 tests/test_websocket_response.py diff --git a/lib/request/connect.py b/lib/request/connect.py index d6c043608..4d292ed15 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -619,17 +619,17 @@ class Connect(object): warnMsg = "too large websocket response detected. Automatically trimming it" singleTimeWarnMessage(warnMsg) break - except websocket.WebSocketTimeoutException: + except (websocket.WebSocketTimeoutException, websocket.WebSocketNormalClosureException): kb.webSocketRecvCount = len(_page) break else: for i in xrange(max(1, kb.webSocketRecvCount)): # Note: a later response may carry fewer frames than the calibration one - # (e.g. a FALSE boolean-blind reply); stop on timeout instead of letting it - # bubble up as a failed request, mirroring the initial recv loop above + # (e.g. a FALSE boolean-blind reply); stop on timeout or normal closure, + # mirroring the initial recv loop above try: _page.append(ws.recv()) - except websocket.WebSocketTimeoutException: + except (websocket.WebSocketTimeoutException, websocket.WebSocketNormalClosureException): break page = "\n".join(_page) diff --git a/lib/request/websocket.py b/lib/request/websocket.py index 9cb43ed2c..f771a939b 100644 --- a/lib/request/websocket.py +++ b/lib/request/websocket.py @@ -39,6 +39,9 @@ class WebSocketTimeoutException(WebSocketException): class WebSocketConnectionClosedException(WebSocketException): pass +class WebSocketNormalClosureException(WebSocketConnectionClosedException): + pass + class WebSocket(object): """ Minimal RFC 6455 client exposing the websocket-client subset used by sqlmap: settimeout(), connect(), @@ -159,10 +162,14 @@ class WebSocket(object): def recv(self): data = bytearray() + receivedFragment = False while True: fin, opcode, payload = self._recvFrame() if opcode == OPCODE_CLOSE: self._closed = True + normal = not payload or (len(payload) >= 2 and struct.unpack("!H", bytes(payload[:2]))[0] in (1000, 1001)) + if normal and not receivedFragment: + raise WebSocketNormalClosureException("WebSocket connection closed") raise WebSocketConnectionClosedException("WebSocket connection closed") elif opcode == OPCODE_PING: self._sendFrame(bytes(payload), OPCODE_PONG) @@ -171,6 +178,7 @@ class WebSocket(object): continue data += payload + receivedFragment = True if fin: break diff --git a/tests/test_websocket_response.py b/tests/test_websocket_response.py new file mode 100644 index 000000000..0d56c95ed --- /dev/null +++ b/tests/test_websocket_response.py @@ -0,0 +1,124 @@ +#!/usr/bin/env python + +""" +Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org) +See the file 'LICENSE' for copying permission +""" + +import base64 +import hashlib +import os +import socket +import struct +import sys +import unittest + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from _testutils import bootstrap +bootstrap() + +from lib.core.data import conf, kb +from lib.core.exception import SqlmapConnectionException +from lib.core.option import _setKnowledgeBaseAttributes +from lib.core.threads import getCurrentThreadData +from lib.request.connect import Connect +import lib.request.websocket as websocket + +_GET_PAGE = Connect.__dict__["getPage"] + + +def _frame(payload, opcode=1, fin=1): + return bytes(bytearray([(fin << 7) | opcode, len(payload)])) + payload + + +class _Socket(object): + def __init__(self, frames): + self.frames = frames + self.response = b"" + self.handshake = None + + def settimeout(self, value): + pass + + def sendall(self, data): + if self.handshake is None: + self.handshake = data + key = next(line.split(b":", 1)[1].strip() for line in data.split(b"\r\n") if line.lower().startswith(b"sec-websocket-key:")) + accept = base64.b64encode(hashlib.sha1(key + websocket._GUID.encode("ascii")).digest()) + self.response = b"HTTP/1.1 101 Switching Protocols\r\nSec-WebSocket-Accept: " + accept + b"\r\n\r\n" + self.frames + + def recv(self, size): + result, self.response = self.response[:size], self.response[size:] + return result + + def close(self): + pass + + +class TestWebSocketResponseClose(unittest.TestCase): + def setUp(self): + self.oldConf, self.oldKb = dict(conf), dict(kb) + self.threadData = getCurrentThreadData() + self.oldThreadData = dict(self.threadData.__dict__) + self.oldTimeout = socket.getdefaulttimeout() + self.oldSocket = websocket.socket.create_connection + self.oldGetPage = Connect.__dict__["getPage"] + self.threadData.__dict__.clear() + self.threadData.reset() + _setKnowledgeBaseAttributes(False) + kb.wizardMode = True + conf.url = "ws://example.test:8080/test" + conf.hostname, conf.scheme, conf.port, conf.path = "example.test", "ws", 8080, "/test" + conf.httpHeaders, conf.parameters, conf.data = [], {}, None + conf.abortCode, conf.ignoreCode = [], [] + conf.timeout, conf.batch, conf.keepAlive, conf.retries = 3, True, False, 0 + conf.retryOn, conf.ignoreRedirects, conf.scope = None, False, None + Connect.getPage = _GET_PAGE + websocket.socket.create_connection = lambda *args, **kwargs: _Socket(self.frames) + + def tearDown(self): + Connect.getPage = self.oldGetPage + websocket.socket.create_connection = self.oldSocket + socket.setdefaulttimeout(self.oldTimeout) + conf.clear(); conf.update(self.oldConf) + kb.clear(); kb.update(self.oldKb) + self.threadData.__dict__.clear(); self.threadData.__dict__.update(self.oldThreadData) + + def test_normal_close_after_response(self): + for status in (b"", struct.pack("!H", 1000), struct.pack("!H", 1001)): + for count in (None, 3): + self.frames = _frame(b"one") + _frame(b"two") + _frame(status, opcode=8) + kb.webSocketRecvCount = count + self.assertEqual(Connect.getPage(url=conf.url)[0], "one\ntwo") + if count is None: + self.assertEqual(kb.webSocketRecvCount, 2) + + def test_normal_close_without_response(self): + self.frames = _frame(struct.pack("!H", 1000), opcode=8) + kb.webSocketRecvCount = None + self.assertEqual(Connect.getPage(url=conf.url)[0], "") + self.assertEqual(kb.webSocketRecvCount, 0) + + def test_abnormal_close_remains_an_error(self): + for status in (b"\x03", struct.pack("!H", 1002), struct.pack("!H", 1011)): + self.frames = _frame(b"one") + _frame(status, opcode=8) + for count in (None, 3): + kb.webSocketRecvCount = count + self.assertRaises(SqlmapConnectionException, Connect.getPage, url=conf.url) + + def test_truncated_frame_remains_an_error(self): + for frames in (_frame(b"one"), _frame(b"one") + b"\x81\x05ab"): + self.frames = frames + for count in (None, 3): + kb.webSocketRecvCount = count + self.assertRaises(SqlmapConnectionException, Connect.getPage, url=conf.url) + + def test_close_during_fragmented_message_remains_an_error(self): + for fragment in (b"", b"partial"): + self.frames = _frame(fragment, fin=0) + _frame(struct.pack("!H", 1000), opcode=8) + kb.webSocketRecvCount = None + self.assertRaises(SqlmapConnectionException, Connect.getPage, url=conf.url) + + +if __name__ == "__main__": + unittest.main() From f65de0e89015eaa1a7ccb228f375aadf3d88c492 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Wed, 4 Nov 2026 10:20:01 +0100 Subject: [PATCH 08/93] Minor update --- lib/core/settings.py | 2 +- lib/request/connect.py | 2 +- lib/request/websocket.py | 6 +++--- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index b067c067e..fcdf5d14e 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.4" +VERSION = "1.10.11.5" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/connect.py b/lib/request/connect.py index 4d292ed15..c97c3244d 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -606,7 +606,7 @@ class Connect(object): try: ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout) wsHeaders = tuple("%s: %s" % (getUnicode(key), getUnicode(value)) for key, value in headers.items() if getUnicode(key).upper() != HTTP_HEADER.HOST.upper()) - ws.connect(url, header=wsHeaders, cookie=cookie, host_header=getHeader(headers, HTTP_HEADER.HOST) if customWsHost else None) + ws.connect(url, header=wsHeaders, cookie=cookie, hostHeader=getHeader(headers, HTTP_HEADER.HOST) if customWsHost else None) ws.send(urldecode(post or "")) _page = [] diff --git a/lib/request/websocket.py b/lib/request/websocket.py index f771a939b..8f579d3e1 100644 --- a/lib/request/websocket.py +++ b/lib/request/websocket.py @@ -61,7 +61,7 @@ class WebSocket(object): if self.sock is not None: self.sock.settimeout(timeout) - def connect(self, url, header=None, cookie=None, host_header=None): + def connect(self, url, header=None, cookie=None, hostHeader=None): parts = _urllib.parse.urlsplit(url) secure = parts.scheme == "wss" host = parts.hostname @@ -78,8 +78,8 @@ class WebSocket(object): hostport = "[%s]" % host if ":" in host else host # bracket IPv6 literals if port != (443 if secure else 80): # Note: only the scheme's own default port gets omitted hostport = "%s:%d" % (hostport, port) - if host_header is not None: - hostport = getText(host_header) + if hostHeader is not None: + hostport = getText(hostHeader) key = getText(base64.b64encode(os.urandom(16))) lines = ["GET %s HTTP/1.1" % resource, From 202d8cc1c4d3e7f76e123417674ab713c8a2c9af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Fri, 6 Nov 2026 09:15:14 +0100 Subject: [PATCH 09/93] Adding some more entries into common files list --- data/txt/common-files.txt | 65 +++++++++++++++++++++++++++++++++++++++ lib/core/settings.py | 2 +- 2 files changed, 66 insertions(+), 1 deletion(-) diff --git a/data/txt/common-files.txt b/data/txt/common-files.txt index 1e378d3c4..97c218e53 100644 --- a/data/txt/common-files.txt +++ b/data/txt/common-files.txt @@ -1818,6 +1818,8 @@ /run/secrets/kubernetes.io/serviceaccount/namespace /var/run/secrets/kubernetes.io/serviceaccount/namespace /run/secrets/kubernetes.io/serviceaccount/ca.crt +/etc/kubernetes/admin.conf +/etc/kubernetes/kubelet.conf # Cloud provider credentials @@ -1825,7 +1827,9 @@ /root/.aws/config /root/.config/gcloud/application_default_credentials.json /root/.config/gcloud/credentials.db +/root/.config/gcloud/access_tokens.db /root/.azure/accessTokens.json +/root/.azure/credentials /root/.kube/config # SSH keys and DB/tool history @@ -1834,6 +1838,10 @@ /root/.ssh/id_ed25519 /root/.ssh/id_ecdsa /root/.ssh/id_dsa +/root/.ssh/config +/etc/ssh/ssh_host_rsa_key +/etc/ssh/ssh_host_ed25519_key +/etc/ssh/ssh_host_ecdsa_key /root/.mysql_history /root/.psql_history /root/.rediscli_history @@ -1852,3 +1860,60 @@ /app/application.properties /app/application.yml /app/docker-compose.yml + +# Developer, package manager and DBMS credential files + +/root/.env +/root/.netrc +/root/.git-credentials +/root/.npmrc +/root/.pypirc +/root/.docker/config.json +/root/.config/gh/hosts.yml +/root/.config/op/config +/root/.my.cnf +/etc/mysql/debian.cnf + +# Hosting control panels + +/etc/psa/.psa.shadow +/etc/psa/private/secret_key + +# AI agent credentials + +/root/.claude/.credentials.json +/root/.claude.json +/root/.codex/auth.json +/root/.config/anthropic/config.json + +# Secrets in the default user's home on common cloud images + +/home/ubuntu/.ssh/id_rsa +/home/ubuntu/.aws/credentials +/home/ubuntu/.kube/config +/home/ubuntu/.git-credentials +/home/ubuntu/.claude/.credentials.json +/home/debian/.ssh/id_rsa +/home/debian/.aws/credentials +/home/debian/.kube/config +/home/debian/.git-credentials +/home/admin/.ssh/id_rsa +/home/admin/.aws/credentials +/home/admin/.kube/config +/home/admin/.git-credentials +/home/ec2-user/.ssh/id_rsa +/home/ec2-user/.aws/credentials +/home/ec2-user/.kube/config +/home/ec2-user/.git-credentials +/home/centos/.ssh/id_rsa +/home/centos/.aws/credentials +/home/centos/.kube/config +/home/opc/.ssh/id_rsa +/home/opc/.aws/credentials +/home/opc/.kube/config + +# Appliance and LFI-to-RCE gadget targets + +/dev/cmdb/sslvpn_websession +/usr/share/php/pearcmd.php +/usr/local/lib/php/pearcmd.php diff --git a/lib/core/settings.py b/lib/core/settings.py index fcdf5d14e..3c59d8acb 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.5" +VERSION = "1.10.11.6" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 097f4d2c37ba3db4dad22377e06a5be1edae3130 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Fri, 6 Nov 2026 15:03:08 +0100 Subject: [PATCH 10/93] Fixes #6176 --- lib/core/common.py | 2 +- lib/core/settings.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/common.py b/lib/core/common.py index 7231fa229..6a4ecd97b 100644 --- a/lib/core/common.py +++ b/lib/core/common.py @@ -4066,7 +4066,7 @@ def decodeIntToUnicode(value): """ retVal = value - if isinstance(value, int): + if isinstance(value, six.integer_types): try: if value > 255: _ = "%x" % value diff --git a/lib/core/settings.py b/lib/core/settings.py index 3c59d8acb..f0f18be3a 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.6" +VERSION = "1.10.11.7" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 397a3bde2e2c2a07680dd9402b16cb37d3721027 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Fri, 6 Nov 2026 15:31:35 +0100 Subject: [PATCH 11/93] Implements #6177 --- lib/core/common.py | 20 ++++++++++++++++++-- lib/core/settings.py | 2 +- lib/parse/cmdline.py | 2 +- sqlmap.conf | 4 ++-- tests/test_common.py | 17 +++++++++++++++++ 5 files changed, 39 insertions(+), 6 deletions(-) diff --git a/lib/core/common.py b/lib/core/common.py index 6a4ecd97b..4b8c8abee 100644 --- a/lib/core/common.py +++ b/lib/core/common.py @@ -5645,7 +5645,7 @@ def pollProcess(process, suppress_errors=False): def parseRequestFile(reqFile, checkParams=True): """ - Parses WebScarab and Burp logs and adds results to the target URL list + Parses WebScarab, Burp and HAR logs and adds results to the target URL list >>> handle, reqFile = tempfile.mkstemp(suffix=".req") >>> content = b"POST / HTTP/1.0\\nUser-agent: foobar\\nHost: www.example.com\\n\\nid=1\\n" @@ -5689,7 +5689,23 @@ def parseRequestFile(reqFile, checkParams=True): Parses Burp logs """ - if not re.search(BURP_REQUEST_REGEX, content, re.I | re.S): + if re.search(r"\A\s*\{.*\"entries\"", content[:1000], re.S): + reqResList = [] + try: + entries = json.loads(content)["log"]["entries"] + except (ValueError, KeyError, TypeError): + entries = [] + for entry in entries: # Note: HAR (HTTP Archive) logs (e.g. ZAP, browsers) - re-serialized into raw requests + try: + request = entry["request"] + url = request["url"] + headers = [(_["name"], _["value"]) for _ in request.get("headers", []) if not _["name"].startswith(':')] + if not any(_[0].upper() == HTTP_HEADER.HOST.upper() for _ in headers): + headers.insert(0, (HTTP_HEADER.HOST, _urllib.parse.urlsplit(url).netloc)) + reqResList.append("%s %s HTTP/1.1\n%s\n\n%s" % (request["method"], url, "\n".join("%s: %s" % _ for _ in headers), (request.get("postData") or {}).get("text") or "")) + except (KeyError, TypeError, AttributeError): + continue + elif not re.search(BURP_REQUEST_REGEX, content, re.I | re.S): if re.search(BURP_XML_HISTORY_REGEX, content, re.I | re.S): reqResList = [] for match in re.finditer(BURP_XML_HISTORY_REGEX, content, re.I | re.S): diff --git a/lib/core/settings.py b/lib/core/settings.py index f0f18be3a..5ab376503 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.7" +VERSION = "1.10.11.8" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/parse/cmdline.py b/lib/parse/cmdline.py index da15f83fe..75cb725aa 100644 --- a/lib/parse/cmdline.py +++ b/lib/parse/cmdline.py @@ -130,7 +130,7 @@ def cmdLineParser(argv=None): help="Connection string for direct database connection") target.add_argument("-l", dest="logFile", - help="Parse target(s) from Burp or WebScarab proxy log file") + help="Parse target(s) from Burp, WebScarab or HAR log file") target.add_argument("-m", dest="bulkFile", help="Scan multiple targets given in a textual file") diff --git a/sqlmap.conf b/sqlmap.conf index b6bbb7d5f..9af192c95 100644 --- a/sqlmap.conf +++ b/sqlmap.conf @@ -12,10 +12,10 @@ url = # oracle://USER:PASSWORD@DBMS_IP:DBMS_PORT/DATABASE_SID direct = -# Parse targets from Burp or WebScarab logs +# Parse targets from Burp, WebScarab or HAR logs # Valid: Burp proxy (http://portswigger.net/suite/) requests log file path # or WebScarab proxy (http://www.owasp.org/index.php/Category:OWASP_WebScarab_Project) -# 'conversations/' folder path +# 'conversations/' folder path or HAR (HTTP Archive) file path logFile = # Scan multiple targets enlisted in a given textual file diff --git a/tests/test_common.py b/tests/test_common.py index a17ecd668..a346caa99 100644 --- a/tests/test_common.py +++ b/tests/test_common.py @@ -21,6 +21,7 @@ stdlib unittest only (no pytest / no pip); works on Python 2.7 and 3.x. import atexit import base64 +import json import os import shutil import sys @@ -537,6 +538,22 @@ class TestParseRequestFileBurp(unittest.TestCase): self.assertEqual([_[0] for _ in targets], ["https://www.target.com:8443/vuln.php?id=1", "http://www.target.com:443/vuln.php?id=1", "https://www.target.com:443/vuln.php?id=1", "http://www.target.com:8080/vuln.php?id=1"]) self.assertTrue(all("://" not in value for _ in targets for key, value in _[4] if key == "Host")) + def test_har_log(self): + # Note: HAR (HTTP Archive) logs (e.g. ZAP, browsers), including HTTP/2 entries (pseudo-headers, no Host) + entries = [ + {"request": {"method": "GET", "url": "https://www.target.com:8443/vuln.php?id=1", "headers": [{"name": "Host", "value": "www.target.com:8443"}, {"name": "Cookie", "value": "SID=xyz"}]}}, + {"request": {"method": "POST", "url": "https://www.target.com/api", "headers": [{"name": ":authority", "value": "www.target.com"}, {"name": "content-type", "value": "application/json"}], "postData": {"text": '{"id": 1}'}}}, + {"request": {"method": "GET", "url": "https://www.target.com/logo.png", "headers": []}}, + ] + path = _write_temp(json.dumps({"log": {"version": "1.2", "entries": entries}}), ".har") + try: + targets = list(parseRequestFile(path)) + finally: + os.unlink(path) + + self.assertEqual([_[:4] for _ in targets], [("https://www.target.com:8443/vuln.php?id=1", HTTPMETHOD.GET, None, "SID=xyz"), ("https://www.target.com/api", HTTPMETHOD.POST, '{"id": 1}', None)]) + self.assertEqual(targets[1][4], (("Host", "www.target.com"), ("content-type", "application/json"))) + def test_post_body_captured(self): content = ( "======================================================\n" From eca9ff2e134f66a69fa64b1715b9cfcf9a1164bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Tue, 10 Nov 2026 15:10:16 +0100 Subject: [PATCH 12/93] Fixes #6180 --- lib/core/settings.py | 2 +- lib/utils/hash.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 5ab376503..125c1a0e2 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.8" +VERSION = "1.10.11.9" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/utils/hash.py b/lib/utils/hash.py index ee3af594c..e23223b6b 100644 --- a/lib/utils/hash.py +++ b/lib/utils/hash.py @@ -1380,7 +1380,8 @@ def dictionaryAttack(attack_dict): else: try: if multiprocessing.cpu_count() > 1: - _multiprocessing = multiprocessing + # Note: 'forkserver' (POSIX default since Python 3.14) re-imports the main script, which breaks for pip installs (#6180) + _multiprocessing = multiprocessing.get_context("fork") if "fork" in getattr(multiprocessing, "get_all_start_methods", lambda: ())() else multiprocessing except NotImplementedError: pass From cb5216564aa94f3f2f64dad732cf3edc2d762081 Mon Sep 17 00:00:00 2001 From: Piyush satyarthi <2025191453.piyush@ug.sharda.ac.in> Date: Thu, 12 Nov 2026 14:16:10 +0530 Subject: [PATCH 13/93] Close leaked sqlite3 connections (ResourceWarning on Python 3.13+) (#6181) Python 3.13+ reports sqlite3 connections that are garbage collected without being closed. The unit tests print a run of "ResourceWarning: unclosed database" lines on Linux/CPython 3.14: - SQLAlchemy.close() only returned its connection to the engine's pool, so the underlying DBAPI connection (e.g. sqlite3 for '-d sqlite://...') stayed open. Dispose the engine on close. - vulnTest() used "with sqlite3.connect(...)", which commits but does not close the connection. Use contextlib.closing(). - test_multibit and test_sqlalchemy never closed what they opened. Co-authored-by: PiyushSatyarthi <244159432+PiyushSatyarthi@users.noreply.github.com> --- lib/core/testing.py | 5 ++++- lib/utils/sqlalchemy.py | 15 +++++++++++++++ tests/test_multibit.py | 16 +++++++++++----- tests/test_sqlalchemy.py | 1 + 4 files changed, 31 insertions(+), 6 deletions(-) diff --git a/lib/core/testing.py b/lib/core/testing.py index 4b74b909b..2923314c8 100644 --- a/lib/core/testing.py +++ b/lib/core/testing.py @@ -5,6 +5,7 @@ Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org) See the file 'LICENSE' for copying permission """ +import contextlib import doctest import json import logging @@ -206,9 +207,11 @@ def vulnTest(tests=None, label="vuln"): os.close(handle) cleanups.append(database) - with sqlite3.connect(database) as conn: + # Note: sqlite3's own context manager only commits (it does not close the connection) + with contextlib.closing(sqlite3.connect(database)) as conn: c = conn.cursor() c.executescript(vulnserver.SCHEMA) + conn.commit() handle, request = tempfile.mkstemp(suffix=".req") os.close(handle) diff --git a/lib/utils/sqlalchemy.py b/lib/utils/sqlalchemy.py index 34c377c5a..9ca71c2e0 100644 --- a/lib/utils/sqlalchemy.py +++ b/lib/utils/sqlalchemy.py @@ -50,6 +50,7 @@ class SQLAlchemy(GenericConnector): self.dialect = dialect self.address = conf.direct + self.engine = None if conf.dbmsUser: self.address = self.address.replace("'%s':" % conf.dbmsUser, "%s:" % _urllib.parse.quote(conf.dbmsUser)) @@ -84,6 +85,7 @@ class SQLAlchemy(GenericConnector): else: engine = _sqlalchemy.create_engine(self.address, connect_args={}) + self.engine = engine self.connector = engine.connect() except (TypeError, ValueError) as ex: if "_get_server_version_info" in traceback.format_exc(): @@ -110,6 +112,19 @@ class SQLAlchemy(GenericConnector): else: raise SqlmapMissingDependence("SQLAlchemy not available (e.g. 'pip%s install SQLAlchemy')" % ('3' if six.PY3 else "")) + def close(self): + try: + GenericConnector.close(self) + finally: + # Note: closing the connection only returns it to the engine's pool (the underlying DBAPI + # connection, e.g. sqlite3, stays open) - disposing the engine is what actually releases it + if self.engine is not None: + try: + self.engine.dispose() + except Exception as ex: + logger.debug(getSafeExString(ex)) + self.engine = None + def fetchall(self): try: retVal = [] diff --git a/tests/test_multibit.py b/tests/test_multibit.py index c69d6b6f5..b51cf5c41 100644 --- a/tests/test_multibit.py +++ b/tests/test_multibit.py @@ -140,8 +140,14 @@ class MultibitTest(unittest.TestCase): multibit._page = self._savedPage multibit.singleTimeWarnMessage, multibit.singleTimeLogMessage = _SAID - def _attempt(self, secret, length=None, **kwargs): + def _target(self, secret, **kwargs): target = _Target(secret, **kwargs) + self.addCleanup(target.db.close) + + return target + + def _attempt(self, secret, length=None, **kwargs): + target = self._target(secret, **kwargs) multibit._page = target.page return self._read(target, secret, length), target @@ -231,7 +237,7 @@ class MultibitTest(unittest.TestCase): # non-ASCII one, and one whose codepoint has an ASCII low byte (U+0141 -> 0x41 'A') all settle # nothing, and none of them may condemn a channel that calibrated cleanly for first in ("", u"\u017eaba pod vodom", u"\u0141ukasz Nowak here"): - target = _Target(first) + target = self._target(first) self.assertIsNone(self._read(target, first, len(first) or None)) good = target.secret("plain ascii value that must still come back") @@ -242,7 +248,7 @@ class MultibitTest(unittest.TestCase): # what the channel did - i.e. exactly the way a channel dropping rows fails it. That is the # data's doing, and a handful of NULLs in one dump must not retire a working channel first = "first value is perfectly readable ascii" - target = _Target(first) + target = self._target(first) self.assertEqual(self._read(target, first, len(first)), first) for _ in range(MULTIBIT_MAX_FAILURES + 1): @@ -253,7 +259,7 @@ class MultibitTest(unittest.TestCase): self.assertEqual(self._read(target, good, len(good)), good) def test_unreadable_value_mid_run_keeps_the_channel(self): - target = _Target("first value is perfectly readable ascii") + target = self._target("first value is perfectly readable ascii") self.assertEqual(self._read(target, "first value is perfectly readable ascii", 39), "first value is perfectly readable ascii") bad = target.secret(u"\u0141ukasz") # reads back as "Aukasz" - right length, wrong char @@ -295,7 +301,7 @@ class MultibitTest(unittest.TestCase): def test_resumed_partial_value_is_left_to_bisection(self): # a resumed value starts mid-string, and multi-bit reads from the first character: it would # re-read what is already cached and then fail its own length read-back - target = _Target("resuming this one is bisection's job") + target = self._target("resuming this one is bisection's job") multibit._page = target.page self.assertIsNone(multibit.attempt("SELECT s FROM v", lambda idx: 'x', 35, None, True)) diff --git a/tests/test_sqlalchemy.py b/tests/test_sqlalchemy.py index 768c12411..a531c5219 100644 --- a/tests/test_sqlalchemy.py +++ b/tests/test_sqlalchemy.py @@ -58,6 +58,7 @@ class TestSQLAlchemySqlitePath(unittest.TestCase): sa = SQLAlchemy(dialect="sqlite") sa.connect() + self.addCleanup(sa.close) # the reformatted URL must resolve to the exact absolute file (not '//...path') self.assertEqual(_sa.engine.url.make_url(sa.address).database, os.path.abspath(dbfile)) From 161af41c9c3549469bdab729173a341c91210b01 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 11:49:07 +0100 Subject: [PATCH 14/93] Fix for chained tamper hints (e.g. luanginx,space2comment) --- lib/core/settings.py | 2 +- lib/request/connect.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 125c1a0e2..b3ee54790 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.9" +VERSION = "1.10.11.10" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/connect.py b/lib/request/connect.py index c97c3244d..5b5207b9c 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -1245,8 +1245,9 @@ class Connect(object): delimiter = conf.paramDel or (DEFAULT_GET_POST_DELIMITER if place != PLACE.COOKIE else DEFAULT_COOKIE_DELIMITER) if not disableTampering and kb.tamperFunctions: + hints = {} # Note: shared among all tamper functions (e.g. 'luanginx,space2comment' must keep the former's HINT.PREPEND) + for function in kb.tamperFunctions: - hints = {} try: payload = function(payload=payload, headers=auxHeaders, delimiter=delimiter, hints=hints) From 3c2384525cee0364634d643bbb69759fb43fb123 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 11:49:07 +0100 Subject: [PATCH 15/93] Fix for --param-del being URL encoded in POST payload requests --- lib/core/settings.py | 2 +- lib/request/connect.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index b3ee54790..2d3c6b130 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.10" +VERSION = "1.10.11.11" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/connect.py b/lib/request/connect.py index 5b5207b9c..bde7336a6 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -1305,7 +1305,7 @@ class Connect(object): if not skip: if place in (PLACE.POST, PLACE.CUSTOM_POST): # potential problems in other cases (e.g. URL encoding of whole URI - including path) - value = urlencode(value, spaceplus=kb.postSpaceToPlus) + value = urlencode(value, safe="%%&=-_%s" % (conf.paramDel or ""), spaceplus=kb.postSpaceToPlus) payload = urlencode(payload, safe='%', spaceplus=kb.postSpaceToPlus) value = agent.replacePayload(value, payload) postUrlEncode = False From f9e53443ed0e261854a382d71124435537d41d96 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 11:50:32 +0100 Subject: [PATCH 16/93] Fix for anti-CSRF tokens containing '+' (and GET token not found with -p) --- lib/core/settings.py | 2 +- lib/core/target.py | 2 +- lib/request/connect.py | 11 +++++++---- 3 files changed, 9 insertions(+), 6 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 2d3c6b130..ea85937cc 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.11" +VERSION = "1.10.11.12" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/core/target.py b/lib/core/target.py index 87feb4d2a..bdd1501a1 100644 --- a/lib/core/target.py +++ b/lib/core/target.py @@ -457,7 +457,7 @@ def _setRequestParams(): raise SqlmapGenericException(errMsg) if conf.csrfToken: - if not any(re.search(conf.csrfToken, ' '.join(_), re.I) for _ in (conf.paramDict.get(PLACE.GET, {}), conf.paramDict.get(PLACE.POST, {}), conf.paramDict.get(PLACE.COOKIE, {}))) and not re.search(r"\b%s\b" % conf.csrfToken, conf.data or "") and conf.csrfToken not in set(_[0].lower() for _ in conf.httpHeaders) and conf.csrfToken not in conf.paramDict.get(PLACE.COOKIE, {}) and not any(re.search(conf.csrfToken, _, re.I) for _ in conf.paramDict.get(PLACE.URI, {}).values()): + if not any(re.search(conf.csrfToken, ' '.join(_), re.I) for _ in (conf.paramDict.get(PLACE.GET, {}), conf.paramDict.get(PLACE.POST, {}), conf.paramDict.get(PLACE.COOKIE, {}))) and not re.search(r"\b%s\b" % conf.csrfToken, "%s %s" % (conf.data or "", conf.parameters.get(PLACE.GET) or "")) and conf.csrfToken not in set(_[0].lower() for _ in conf.httpHeaders) and conf.csrfToken not in conf.paramDict.get(PLACE.COOKIE, {}) and not any(re.search(conf.csrfToken, _, re.I) for _ in conf.paramDict.get(PLACE.URI, {}).values()): errMsg = "anti-CSRF token parameter '%s' not " % conf.csrfToken._original errMsg += "found in provided GET, POST, Cookie or header values" raise SqlmapGenericException(errMsg) diff --git a/lib/request/connect.py b/lib/request/connect.py index bde7336a6..8c0f05088 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -1412,7 +1412,7 @@ class Connect(object): logger.warning(warnMsg) page, headers, code = Connect.getPage(url=conf.csrfUrl or conf.url, post=conf.csrfData or (conf.data if conf.csrfUrl == conf.url and (conf.csrfMethod or "").upper() == HTTPMETHOD.POST else None), method=conf.csrfMethod or (conf.method if conf.csrfUrl == conf.url else None), cookie=conf.parameters.get(PLACE.COOKIE), direct=True, silent=True, ua=conf.parameters.get(PLACE.USER_AGENT), referer=conf.parameters.get(PLACE.REFERER), host=conf.parameters.get(PLACE.HOST)) - page = urldecode(page) # for anti-CSRF tokens with special characters in their name (e.g. 'foo:bar=...') + page = urldecode(page, spaceplus=False) # for anti-CSRF tokens with special characters in their name (e.g. 'foo:bar=...') - Note: '+' is a legitimate (e.g. Base64) token value character match = re.search(r"(?i)]+\bname=[\"']?(?P%s)\b[^>]*\bvalue=[\"']?(?P[^>'\"]*)" % conf.csrfToken, page or "", re.I) @@ -1467,14 +1467,17 @@ class Connect(object): if token: token.value = token.value.strip("'\"") + # Note: (decoded) token value has to be URL encoded for (URL encoded) places (e.g. Base64 token 'ab+cd/ef==' -> 'ab%2Bcd%2Fef%3D%3D') + encoded = urlencode(token.value, convall=True) + for candidate in (PLACE.GET, PLACE.POST, PLACE.CUSTOM_POST, PLACE.URI): if candidate in conf.parameters: if candidate == PLACE.URI and uri: - uri = _adjustParameter(uri, token.name, token.value) + uri = _adjustParameter(uri, token.name, encoded) elif candidate == PLACE.GET and get: - get = _adjustParameter(get, token.name, token.value) + get = _adjustParameter(get, token.name, encoded) elif candidate in (PLACE.POST, PLACE.CUSTOM_POST) and post: - post = _adjustParameter(post, token.name, token.value) + post = _adjustParameter(post, token.name, encoded if candidate == PLACE.POST else token.value) for i in xrange(len(conf.httpHeaders)): if conf.httpHeaders[i][0].lower() == token.name.lower(): From a7a9d7a8fec192d7b429b714785fa59f7d8e088f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 11:50:32 +0100 Subject: [PATCH 17/93] Fix for --eval dropping parameters after an empty one --- lib/core/settings.py | 2 +- lib/request/connect.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index ea85937cc..2fe7195da 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.12" +VERSION = "1.10.11.13" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/connect.py b/lib/request/connect.py index 8c0f05088..338aab7d3 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -1645,7 +1645,7 @@ class Connect(object): found = True post = re.sub(regex, r"\g<1>\g<2>%s" % entry.replace('\\', r'\\'), post) - regex = r"((\A|%s)%s=).+?(%s|\Z)" % (re.escape(delimiter), re.escape(name), re.escape(delimiter)) + regex = r"((\A|%s)%s=).*?(%s|\Z)" % (re.escape(delimiter), re.escape(name), re.escape(delimiter)) if not found and re.search(regex, (post or "")): found = True post = re.sub(regex, r"\g<1>%s\g<3>" % entry.replace('\\', r'\\'), post) @@ -1658,7 +1658,7 @@ class Connect(object): found = True uri = re.sub(regex.replace(r"\A", r"\?"), r"\g<1>%s\g<3>" % entry.replace('\\', r'\\'), uri) - regex = r"((\A|%s\s*)%s=).+?(%s|\Z)" % (re.escape(conf.cookieDel or DEFAULT_COOKIE_DELIMITER), re.escape(name), re.escape(conf.cookieDel or DEFAULT_COOKIE_DELIMITER)) + regex = r"((\A|%s\s*)%s=).*?(%s|\Z)" % (re.escape(conf.cookieDel or DEFAULT_COOKIE_DELIMITER), re.escape(name), re.escape(conf.cookieDel or DEFAULT_COOKIE_DELIMITER)) if re.search(regex, (cookie or "")): found = True cookie = re.sub(regex, r"\g<1>%s\g<3>" % entry.replace('\\', r'\\'), cookie) From 54c5a6582b24c7e3b24f832196098041dca24385 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 11:50:32 +0100 Subject: [PATCH 18/93] Fix for declined forcing of --dbms still restricting fingerprinting --- lib/core/settings.py | 2 +- lib/core/target.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 2fe7195da..40a0535e5 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.13" +VERSION = "1.10.11.14" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/core/target.py b/lib/core/target.py index bdd1501a1..56520f672 100644 --- a/lib/core/target.py +++ b/lib/core/target.py @@ -587,6 +587,7 @@ def _resumeDBMS(): if not readInput(message, default='N', boolean=True): conf.dbms = None + kb.dbmsFilter = [] Backend.setDbms(dbms) Backend.setVersionList(dbmsVersion) else: From d55d1633520a50adc3f7a75ffc30faf565653450 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 11:50:32 +0100 Subject: [PATCH 19/93] Fix for -p matching inside other parameter names (e.g. id in x-id) --- lib/core/agent.py | 9 ++++++--- lib/core/settings.py | 2 +- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/lib/core/agent.py b/lib/core/agent.py index 455e44f35..e062ce079 100644 --- a/lib/core/agent.py +++ b/lib/core/agent.py @@ -278,14 +278,17 @@ class Agent(object): retVal = string[:match.start()] + repl + string[match.end():] return retVal + # Note: parameter name has to start right after a delimiter (e.g. '-p id' must not match inside 'x-id=1') + boundary = r"(\A|(?<=[%s\s]))" % re.escape("%s%s%s" % (DEFAULT_GET_POST_DELIMITER, DEFAULT_COOKIE_DELIMITER, conf.paramDel or "")) + if origValue: - regex = r"(\A|\b)%s=%s%s" % (re.escape(parameter), re.escape(origValue), r"(\Z|\b)" if origValue[-1].isalnum() else "") + regex = r"%s%s=%s%s" % (boundary, re.escape(parameter), re.escape(origValue), r"(\Z|\b)" if origValue[-1].isalnum() else "") retVal = _(regex, "%s=%s" % (parameter, self.addPayloadDelimiters(newValue)), paramString) else: - retVal = _(r"(\A|\b)%s=%s(\Z|%s|%s|\s)" % (re.escape(parameter), re.escape(origValue), DEFAULT_GET_POST_DELIMITER, DEFAULT_COOKIE_DELIMITER), r"%s=%s\g<2>" % (parameter, self.addPayloadDelimiters(newValue)), paramString) + retVal = _(r"%s%s=%s(\Z|%s|%s|\s)" % (boundary, re.escape(parameter), re.escape(origValue), DEFAULT_GET_POST_DELIMITER, DEFAULT_COOKIE_DELIMITER), r"%s=%s\g<2>" % (parameter, self.addPayloadDelimiters(newValue)), paramString) if retVal == paramString and urlencode(parameter) != parameter: - retVal = _(r"(\A|\b)%s=%s" % (re.escape(urlencode(parameter)), re.escape(origValue)), "%s=%s" % (urlencode(parameter), self.addPayloadDelimiters(newValue)), paramString) + retVal = _(r"%s%s=%s" % (boundary, re.escape(urlencode(parameter)), re.escape(origValue)), "%s=%s" % (urlencode(parameter), self.addPayloadDelimiters(newValue)), paramString) if retVal: retVal = retVal.replace(BOUNDARY_BACKSLASH_MARKER, '\\') diff --git a/lib/core/settings.py b/lib/core/settings.py index 40a0535e5..f2bf5ded9 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.14" +VERSION = "1.10.11.15" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 9fa2abb5dda8c876a3b40338e59d8236946cd882 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 11:50:32 +0100 Subject: [PATCH 20/93] Fix for --sql-query dropping duplicate rows and query's ordering --- lib/core/dump.py | 2 +- lib/core/settings.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/dump.py b/lib/core/dump.py index c9235f0e9..0f8571d31 100644 --- a/lib/core/dump.py +++ b/lib/core/dump.py @@ -795,7 +795,7 @@ class Dump(object): self.dbTableColumns(found) def sqlQuery(self, query, queryRes): - self.string(query, queryRes, content_type=CONTENT_TYPE.SQL_QUERY) + self.string(query, queryRes, content_type=CONTENT_TYPE.SQL_QUERY, sort=False) # Note: query's own row order and duplicates have to be preserved def rFile(self, fileData): self.lister("files saved to", fileData, sort=False, content_type=CONTENT_TYPE.FILE_READ) diff --git a/lib/core/settings.py b/lib/core/settings.py index f2bf5ded9..a2c6f77e8 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.15" +VERSION = "1.10.11.16" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From c8422bf1f6abc0127562673f5fb60bde10541d2b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 11:50:33 +0100 Subject: [PATCH 21/93] Fix for --hex with UNION JSON aggregation (SQLite, PgSQL, Oracle, MSSQL) --- lib/core/settings.py | 2 +- lib/techniques/union/use.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index a2c6f77e8..2a15f4060 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.16" +VERSION = "1.10.11.17" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/techniques/union/use.py b/lib/techniques/union/use.py index 5a83f76ab..252a50841 100644 --- a/lib/techniques/union/use.py +++ b/lib/techniques/union/use.py @@ -353,7 +353,8 @@ def unionUse(expression, unpack=True, dump=False): debugMsg += "it does not play well with UNION query SQL injection" singleTimeDebugMessage(debugMsg) - if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.ORACLE, DBMS.PGSQL, DBMS.MSSQL, DBMS.SQLITE, DBMS.H2, DBMS.HSQLDB, DBMS.FIREBIRD) and expressionFields and not any((conf.binaryFields, conf.limitStart, conf.limitStop, conf.disableJson)): + # Note: Oracle, PostgreSQL, Microsoft SQL Server and SQLite aggregate the raw (not hex-converted) fields, while parseUnionPage() decodes them all in case of '--hex' + if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.ORACLE, DBMS.PGSQL, DBMS.MSSQL, DBMS.SQLITE, DBMS.H2, DBMS.HSQLDB, DBMS.FIREBIRD) and expressionFields and not any((conf.binaryFields, conf.limitStart, conf.limitStop, conf.disableJson)) and not (conf.hexConvert and Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.PGSQL, DBMS.MSSQL, DBMS.SQLITE)): match = re.search(r"SELECT\s*(.+?)\bFROM", expression, re.I) if match and not (Backend.isDbms(DBMS.ORACLE) and FROM_DUMMY_TABLE[DBMS.ORACLE] in expression) and not re.search(r"\b(MIN|MAX|COUNT|EXISTS)\(", expression): kb.jsonAggMode = True From 77a31ee5959a081e3a827294eec01609638de4a7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 11:50:33 +0100 Subject: [PATCH 22/93] Fix for SQLite columns with special characters in name (e.g. 'my col') --- lib/core/common.py | 2 +- lib/core/settings.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/common.py b/lib/core/common.py index 4b8c8abee..cbe8caefd 100644 --- a/lib/core/common.py +++ b/lib/core/common.py @@ -3673,7 +3673,7 @@ def parseSqliteTableSchema(value): continue retVal = True - columns[column] = match.group(3) or "TEXT" + columns[safeSQLIdentificatorNaming(column)] = match.group(3) or "TEXT" # Note: stored escaped, as by all other column enumeration paths (e.g. 'my col' -> '`my col`') table[safeSQLIdentificatorNaming(conf.tbl, True)] = columns if conf.db in kb.data.cachedColumns: diff --git a/lib/core/settings.py b/lib/core/settings.py index 2a15f4060..1083e7337 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.17" +VERSION = "1.10.11.18" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 6aa218f7207bb56783d2553a6be70689f35dfa1b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 11:50:33 +0100 Subject: [PATCH 23/93] Fix for --dump-format=SQLITE with double quotes in names --- lib/core/replication.py | 6 +++--- lib/core/settings.py | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/lib/core/replication.py b/lib/core/replication.py index a2cd5e9a3..70028b19a 100644 --- a/lib/core/replication.py +++ b/lib/core/replication.py @@ -58,15 +58,15 @@ class Replication(object): def __init__(self, parent, name, columns=None, create=True, typeless=False): self.parent = parent - self.name = unsafeSQLIdentificatorNaming(name) + self.name = unsafeSQLIdentificatorNaming(name).replace('"', '""') # Note: escaped for its (double quoted) usage in statements below self.columns = columns if create: try: self.execute('DROP TABLE IF EXISTS "%s"' % self.name) if not typeless: - self.execute('CREATE TABLE "%s" (%s)' % (self.name, ','.join('"%s" %s' % (unsafeSQLIdentificatorNaming(colname), coltype) for colname, coltype in self.columns))) + self.execute('CREATE TABLE "%s" (%s)' % (self.name, ','.join('"%s" %s' % (unsafeSQLIdentificatorNaming(colname).replace('"', '""'), coltype) for colname, coltype in self.columns))) else: - self.execute('CREATE TABLE "%s" (%s)' % (self.name, ','.join('"%s"' % unsafeSQLIdentificatorNaming(colname) for colname in self.columns))) + self.execute('CREATE TABLE "%s" (%s)' % (self.name, ','.join('"%s"' % unsafeSQLIdentificatorNaming(colname).replace('"', '""') for colname in self.columns))) except Exception as ex: errMsg = "problem occurred ('%s') while initializing the sqlite database " % getSafeExString(ex, UNICODE_ENCODING) errMsg += "located at '%s'" % self.parent.dbpath diff --git a/lib/core/settings.py b/lib/core/settings.py index 1083e7337..65003524a 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.18" +VERSION = "1.10.11.19" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From eda9b00185f7ba10e86a3d2248275f46a4b6e863 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 11:50:33 +0100 Subject: [PATCH 24/93] Fix for interrupted --first/--last corrupting stored value --- lib/core/settings.py | 2 +- lib/techniques/blind/inference.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 65003524a..097b92890 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.19" +VERSION = "1.10.11.20" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/techniques/blind/inference.py b/lib/techniques/blind/inference.py index aebe5a33c..2bfff59cf 100644 --- a/lib/techniques/blind/inference.py +++ b/lib/techniques/blind/inference.py @@ -327,7 +327,7 @@ def bisection(payload, expression, length=None, charsetType=None, firstChar=None threadData = getCurrentThreadData() threadData.lowCardHit = False # set when this value is confirmed by the (self-verifying) low-card guess timeBasedCompare = (getTechnique() in (PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED)) - retVal = hashDBRetrieve(expression, checkConf=True) + retVal = hashDBRetrieve(expression, checkConf=True) if not (conf.firstChar or conf.lastChar) else None # Note: stored (complete) value doesn't correspond to a --first/--last range if retVal: if conf.repair and INFERENCE_UNKNOWN_CHAR in retVal: @@ -1251,7 +1251,7 @@ def bisection(payload, expression, length=None, charsetType=None, firstChar=None and 0 < len(finalValue) <= PREDICTION_FEEDBACK_MAX_LENGTH and len(kb.commonOutputs.get(kb.partRun) or ()) < PREDICTION_FEEDBACK_MAX_ITEMS): kb.commonOutputs.setdefault(kb.partRun, set()).add(finalValue) - elif partialValue: + elif partialValue and not (conf.firstChar or conf.lastChar): # Note: same as above (otherwise resumed as the start of the complete value) hashDBWrite(expression, "%s%s" % (PARTIAL_VALUE_MARKER if not conf.hexConvert else PARTIAL_HEX_VALUE_MARKER, partialValue)) if conf.hexConvert and not any((abortedFlag, conf.api, kb.bruteMode)): From 3f7f87750a65d5a1481e834b40a61194cddbe4f4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 11:50:33 +0100 Subject: [PATCH 25/93] Fix for tamper 'between' breaking function arguments (e.g. BENCHMARK) --- lib/core/settings.py | 2 +- tamper/between.py | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 097b92890..ffd934540 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.20" +VERSION = "1.10.11.21" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/tamper/between.py b/tamper/between.py index 00da028c6..3e4323bc3 100644 --- a/tamper/between.py +++ b/tamper/between.py @@ -38,6 +38,8 @@ def tamper(payload, **kwargs): '1 AND A BETWEEN B AND B--' >>> tamper('1 AND LAST_INSERT_ROWID()=LAST_INSERT_ROWID()') '1 AND LAST_INSERT_ROWID() BETWEEN LAST_INSERT_ROWID() AND LAST_INSERT_ROWID()' + >>> tamper('1 AND 2314=BENCHMARK(5000000,MD5(0x41))') + '1 AND 2314=BENCHMARK(5000000,MD5(0x41))' >>> tamper('CASE WHEN 1=2 THEN id ELSE 0 END') 'CASE WHEN 1 BETWEEN 2 AND 2 THEN id ELSE 0 END' """ @@ -56,7 +58,7 @@ def tamper(payload, **kwargs): if retVal == payload: match = re.search(r"(?i)(\b(AND|OR)\b\s+)(?!.*\b(AND|OR)\b)([^=]+?)\s*(?!])=(?!=)\s*([\w()]+)\s*", payload) # Note: avoiding compound operators (e.g. >=, !=) - if match: + if match and match.group(5).count('(') == match.group(5).count(')'): # Note: e.g. 'BENCHMARK(5000000,MD5(..))' can't be cut at its comma _ = "%s %s BETWEEN %s AND %s" % (match.group(2), match.group(4), match.group(5), match.group(5)) retVal = retVal.replace(match.group(0), _) From 167956b61c2cdbc2e17c0ddf89237e6cb53ff428 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 12:57:39 +0100 Subject: [PATCH 26/93] Fix for LIMIT n OFFSET m being ignored in SQL queries (e.g. --sql-query) --- lib/core/agent.py | 11 ++++++++++- lib/core/settings.py | 2 +- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/lib/core/agent.py b/lib/core/agent.py index e062ce079..7357f1f35 100644 --- a/lib/core/agent.py +++ b/lib/core/agent.py @@ -1069,6 +1069,7 @@ class Agent(object): topLimit = re.search(r"TOP\s+([\d]+)\s+", expression, re.I) limitRegExp = re.search(queries[Backend.getIdentifiedDbms()].limitregexp.query, expression, re.I) + limitClause = None if hasattr(queries[Backend.getIdentifiedDbms()].limitregexp, "query2"): limitRegExp2 = re.search(queries[Backend.getIdentifiedDbms()].limitregexp.query2, expression, re.I) @@ -1099,6 +1100,12 @@ class Agent(object): elif Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE): if limitRegExp: + + # Note: standard 'LIMIT n OFFSET m' (or 'OFFSET m LIMIT n') isn't (fully) covered by limitregexp (e.g. OFFSET was silently ignored on MySQL) + limitClause = re.search(r"(?i)\s+LIMIT\s+(?P\d+)\s+OFFSET\s+(?P\d+)", expression) or re.search(r"(?i)\s+OFFSET\s+(?P\d+)\s+LIMIT\s+(?P\d+)", expression) + if limitClause: + startLimit, stopLimit = int(limitClause.group("start")), limitClause.group("stop") + limitGroupStart = queries[Backend.getIdentifiedDbms()].limitgroupstart.query limitGroupStop = queries[Backend.getIdentifiedDbms()].limitgroupstop.query @@ -1126,7 +1133,9 @@ class Agent(object): # (or equivalent, depending on the back-end DBMS) word if Backend.getIdentifiedDbms() in limitOffsetAppendDbmses: stopLimit += startLimit - if expression.find(queries[Backend.getIdentifiedDbms()].limitstring.query) > 0: + if limitClause: + _ = limitClause.start() + elif expression.find(queries[Backend.getIdentifiedDbms()].limitstring.query) > 0: _ = expression.index(queries[Backend.getIdentifiedDbms()].limitstring.query) else: _ = re.search(r"\bLIMIT\b", expression, re.I).start() diff --git a/lib/core/settings.py b/lib/core/settings.py index ffd934540..fb34cadf3 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.21" +VERSION = "1.10.11.22" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From b6c4f880a58ae0b913aa6780e7327975209d9146 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 12:57:39 +0100 Subject: [PATCH 27/93] Fix for multiple MIN()/MAX() fields in SQL queries (e.g. SELECT MAX(id),MIN(id)) --- lib/core/agent.py | 18 +++++++++++------- lib/core/settings.py | 2 +- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/lib/core/agent.py b/lib/core/agent.py index 7357f1f35..2e44b910c 100644 --- a/lib/core/agent.py +++ b/lib/core/agent.py @@ -673,6 +673,10 @@ class Agent(object): if re.search(r"\bWHERE\b.+(MIN|MAX)", query, re.I): fieldsMinMaxstr = None + # Note: shortcut is meant only for a single MIN()/MAX() field (e.g. 'SELECT MAX(id),MIN(id) FROM users' has two) + if fieldsMinMaxstr and fieldsSelectFrom and len(splitFields(fieldsSelectFrom.group(1))) > 1: + fieldsMinMaxstr = None + fieldsToCastStr = fieldsNoSelect if fieldsSubstr: @@ -701,8 +705,8 @@ class Agent(object): fieldsToCastStr = fieldsToCastStr or "" - # Function - if re.search(r"\A\w+\(.*\)", fieldsToCastStr, re.I) or (fieldsSelectCase and "WHEN use" not in query) or fieldsSubstr: + # Function (Note: a single one - e.g. 'MAX(id),MIN(id)' are two fields) + if (re.search(r"\A\w+\(.*\)", fieldsToCastStr, re.I) and len(splitFields(fieldsToCastStr)) == 1) or (fieldsSelectCase and "WHEN use" not in query) or fieldsSubstr: fieldsToCastList = [fieldsToCastStr] else: fieldsToCastList = splitFields(fieldsToCastStr) @@ -1065,11 +1069,11 @@ class Agent(object): startLimit = 0 stopLimit = None limitCond = True + limitClause = None topLimit = re.search(r"TOP\s+([\d]+)\s+", expression, re.I) limitRegExp = re.search(queries[Backend.getIdentifiedDbms()].limitregexp.query, expression, re.I) - limitClause = None if hasattr(queries[Backend.getIdentifiedDbms()].limitregexp, "query2"): limitRegExp2 = re.search(queries[Backend.getIdentifiedDbms()].limitregexp.query2, expression, re.I) @@ -1096,16 +1100,16 @@ class Agent(object): # Note: query2 (LIMIT without OFFSET) always has exactly one group (the # count); using limitGroupStart here would IndexError for H2 (groupstart=2) stopLimit = limitRegExp2.group(1) - limitCond = int(stopLimit) > 1 - - elif Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE): - if limitRegExp: # Note: standard 'LIMIT n OFFSET m' (or 'OFFSET m LIMIT n') isn't (fully) covered by limitregexp (e.g. OFFSET was silently ignored on MySQL) limitClause = re.search(r"(?i)\s+LIMIT\s+(?P\d+)\s+OFFSET\s+(?P\d+)", expression) or re.search(r"(?i)\s+OFFSET\s+(?P\d+)\s+LIMIT\s+(?P\d+)", expression) if limitClause: startLimit, stopLimit = int(limitClause.group("start")), limitClause.group("stop") + limitCond = int(stopLimit) > 1 + + elif Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE): + if limitRegExp: limitGroupStart = queries[Backend.getIdentifiedDbms()].limitgroupstart.query limitGroupStop = queries[Backend.getIdentifiedDbms()].limitgroupstop.query diff --git a/lib/core/settings.py b/lib/core/settings.py index fb34cadf3..2971b972c 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.22" +VERSION = "1.10.11.23" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From e85b1bbd9d78a2af69a3509f6d641baab7bc0869 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 12:57:40 +0100 Subject: [PATCH 28/93] Fix for leftover ASC/DESC when stripping ORDER BY in UNION technique --- lib/core/settings.py | 2 +- lib/techniques/union/use.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 2971b972c..eb0d4e4d5 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.23" +VERSION = "1.10.11.24" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/techniques/union/use.py b/lib/techniques/union/use.py index 252a50841..bbdbe681d 100644 --- a/lib/techniques/union/use.py +++ b/lib/techniques/union/use.py @@ -348,7 +348,7 @@ def unionUse(expression, unpack=True, dump=False): # Only remove outer ordering. Nested ORDER BY clauses can select which # rows survive a ROWNUM/TOP limit and must remain intact. positions = set(index for keyword in set(re.findall(r"(?i)ORDER BY", expression)) for index in zeroDepthSearch(expression, keyword)) - expression = re.sub(r"(?i)ORDER BY\s+[\w,]+", lambda match: "" if match.start() in positions else match.group(0), expression) + expression = re.sub(r"(?i)ORDER BY\s+[\w.]+(?:\s+(?:ASC|DESC)\b)?(?:\s*,\s*[\w.]+(?:\s+(?:ASC|DESC)\b)?)*", lambda match: "" if match.start() in positions else match.group(0), expression) debugMsg = "stripping ORDER BY clause from statement because " debugMsg += "it does not play well with UNION query SQL injection" singleTimeDebugMessage(debugMsg) From 7b8e03ef3ef83c575df37ff435fe493a5ccb83a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 13:58:01 +0100 Subject: [PATCH 29/93] Fix for MSSQL row retrieval losing duplicates (OFFSET/FETCH for 2012+ and Azure) --- lib/core/agent.py | 5 +++++ lib/core/settings.py | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/lib/core/agent.py b/lib/core/agent.py index 2e44b910c..37e24a6fc 100644 --- a/lib/core/agent.py +++ b/lib/core/agent.py @@ -1267,6 +1267,11 @@ class Agent(object): orderBy = limitedQuery[limitedQuery.index(" ORDER BY "):] limitedQuery = limitedQuery[:limitedQuery.index(" ORDER BY ")] + # Note: Microsoft SQL Server 2012+ (and Azure) supports OFFSET/FETCH (row position based), while the (old) NOT IN forging is value based (i.e. collapses duplicate values) + if Backend.isDbms(DBMS.MSSQL) and (Backend.isVersionGreaterOrEqualThan("2012") or Backend.isVersionWithin(("Azure",))) and not re.search(r"(?i)\A(SELECT\s+)?(TOP|DISTINCT)\b", limitedQuery): + limitedQuery = "%s%s OFFSET %d ROWS FETCH NEXT 1 ROWS ONLY" % (limitedQuery, orderBy or " ORDER BY %s" % (uniqueField or '1'), num) + return limitedQuery + notDistincts = re.findall(r"DISTINCT[\(\s+](.+?)\)*\s+", limitedQuery, re.I) for notDistinct in notDistincts: diff --git a/lib/core/settings.py b/lib/core/settings.py index eb0d4e4d5..a8f5f7a95 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.24" +VERSION = "1.10.11.25" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From c129692040581121f539b1426400abde55984cdd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:23:22 +0100 Subject: [PATCH 30/93] Fix for --cookie-del (regression from d55d1633) --- lib/core/agent.py | 2 +- lib/core/settings.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/agent.py b/lib/core/agent.py index 37e24a6fc..1d3940e5a 100644 --- a/lib/core/agent.py +++ b/lib/core/agent.py @@ -279,7 +279,7 @@ class Agent(object): return retVal # Note: parameter name has to start right after a delimiter (e.g. '-p id' must not match inside 'x-id=1') - boundary = r"(\A|(?<=[%s\s]))" % re.escape("%s%s%s" % (DEFAULT_GET_POST_DELIMITER, DEFAULT_COOKIE_DELIMITER, conf.paramDel or "")) + boundary = r"(\A|(?<=[%s\s]))" % re.escape("%s%s%s%s" % (DEFAULT_GET_POST_DELIMITER, DEFAULT_COOKIE_DELIMITER, conf.paramDel or "", conf.cookieDel or "")) if origValue: regex = r"%s%s=%s%s" % (boundary, re.escape(parameter), re.escape(origValue), r"(\Z|\b)" if origValue[-1].isalnum() else "") diff --git a/lib/core/settings.py b/lib/core/settings.py index a8f5f7a95..2f7e809d2 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.25" +VERSION = "1.10.11.26" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From dd6356c277b89731e012e44b598775ec9cfa523d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:28:46 +0100 Subject: [PATCH 31/93] Fix for --load-cookies crash with session cookies (Python 3) --- lib/core/common.py | 2 +- lib/core/settings.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/common.py b/lib/core/common.py index cbe8caefd..5c6739220 100644 --- a/lib/core/common.py +++ b/lib/core/common.py @@ -5438,7 +5438,7 @@ def resetCookieJar(cookieJar): cookieJar.load(cookieJar.filename, ignore_expires=True) for cookie in cookieJar: - if getattr(cookie, "expires", MAX_INT) < time.time(): + if (getattr(cookie, "expires", None) or MAX_INT) < time.time(): # Note: session cookies have 'expires' set to None warnMsg = "cookie '%s' has expired" % cookie singleTimeWarnMessage(warnMsg) diff --git a/lib/core/settings.py b/lib/core/settings.py index 2f7e809d2..09b8c3e98 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.26" +VERSION = "1.10.11.27" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From fe6f6c48c32e70e609669f307e611cd2cd1c76f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:28:46 +0100 Subject: [PATCH 32/93] Fix for --ignore-proxy being unusable with environment proxy --- lib/core/option.py | 5 +++-- lib/core/settings.py | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/lib/core/option.py b/lib/core/option.py index 74f8feaa7..58ea9d7b9 100644 --- a/lib/core/option.py +++ b/lib/core/option.py @@ -1394,7 +1394,8 @@ def _setHTTPHandlers(): debugMsg = "creating HTTP requests opener object" logger.debug(debugMsg) - handlers = filterNone([multipartPostHandler, proxyHandler if proxyHandler.proxies else None, authHandler, redirectHandler, rangeHandler, chunkedHandler if conf.chunked else None, httpsHandler]) + # Note: (emptied) proxyHandler is kept in case of --ignore-proxy, as otherwise urllib adds its default one (i.e. using environment proxies) + handlers = filterNone([multipartPostHandler, proxyHandler if proxyHandler.proxies or conf.ignoreProxy else None, authHandler, redirectHandler, rangeHandler, chunkedHandler if conf.chunked else None, httpsHandler]) if not conf.dropSetCookie: if not conf.loadCookies: @@ -2150,7 +2151,7 @@ def _cleanupOptions(): conf.binaryFields = re.split(PARAMETER_SPLITTING_REGEX, conf.binaryFields) envProxy = max(os.environ.get(_, "") for _ in PROXY_ENVIRONMENT_VARIABLES) - if re.search(r"\A(https?|socks[45])://.+:\d+\Z", envProxy) and conf.proxy is None: + if re.search(r"\A(https?|socks[45])://.+:\d+\Z", envProxy) and conf.proxy is None and not conf.ignoreProxy: debugMsg = "using environment proxy '%s'" % envProxy logger.debug(debugMsg) diff --git a/lib/core/settings.py b/lib/core/settings.py index 09b8c3e98..ce7abd4e0 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.27" +VERSION = "1.10.11.28" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From da5c2c66c6c0b54711454dbfba80b53408e4d069 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:28:46 +0100 Subject: [PATCH 33/93] Fix for Set-Cookie merge overwriting other cookies (e.g. id vs x-id) --- lib/core/settings.py | 2 +- lib/request/basic.py | 7 +++++-- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index ce7abd4e0..e1dea6b20 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.28" +VERSION = "1.10.11.29" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/basic.py b/lib/request/basic.py index f7a5c164b..7e1265070 100644 --- a/lib/request/basic.py +++ b/lib/request/basic.py @@ -121,7 +121,10 @@ def forgeHeaders(items=None, base=None): if cookie is None or cookie.domain_specified and not ((conf.hostname or "").endswith(cookie.domain) or (conf.hostname or "") == cookie.domain.lstrip('.')): continue - if ("%s=" % getUnicode(cookie.name)) in getUnicode(headers[HTTP_HEADER.COOKIE]): + # Note: cookie name has to start right after a delimiter (e.g. server's 'id' must not match inside user's 'x-id=2') + boundary = r"(?:\A|(?<=[%s\s]))" % re.escape(conf.cookieDel or DEFAULT_COOKIE_DELIMITER) + + if re.search(r"%s%s=" % (boundary, re.escape(getUnicode(cookie.name))), getUnicode(headers[HTTP_HEADER.COOKIE])): if conf.loadCookies: conf.httpHeaders = filterNone((item if item[0] != HTTP_HEADER.COOKIE else None) for item in conf.httpHeaders) elif kb.mergeCookies is None: @@ -134,7 +137,7 @@ def forgeHeaders(items=None, base=None): if kb.mergeCookies and kb.injection.place != PLACE.COOKIE: def _(value): - return re.sub(r"(?i)\b%s=[^%s]+" % (re.escape(getUnicode(cookie.name)), conf.cookieDel or DEFAULT_COOKIE_DELIMITER), ("%s=%s" % (getUnicode(cookie.name), getUnicode(cookie.value))).replace('\\', r'\\'), value) + return re.sub(r"(?i)%s%s=[^%s]+" % (boundary, re.escape(getUnicode(cookie.name)), conf.cookieDel or DEFAULT_COOKIE_DELIMITER), ("%s=%s" % (getUnicode(cookie.name), getUnicode(cookie.value))).replace('\\', r'\\'), value) headers[HTTP_HEADER.COOKIE] = _(headers[HTTP_HEADER.COOKIE]) From fec03cf6626425655328817bfcf1939d1db21000 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:28:47 +0100 Subject: [PATCH 34/93] Fix for --param-del being URL encoded in GET requests --- lib/core/settings.py | 2 +- lib/request/connect.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index e1dea6b20..8d4ab5070 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.29" +VERSION = "1.10.11.30" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/connect.py b/lib/request/connect.py index 338aab7d3..7834e9c17 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -500,7 +500,7 @@ class Connect(object): get = conf.parameters[PLACE.GET] if not conf.skipUrlEncode: - get = urlencode(get, limit=True) + get = urlencode(get, safe="%%&=-_%s" % (conf.paramDel or ""), limit=True) if get: if '?' in url: @@ -1678,7 +1678,7 @@ class Connect(object): cookie += "%s%s=%s" % (conf.cookieDel or DEFAULT_COOKIE_DELIMITER, name, entry) if not conf.skipUrlEncode: - get = urlencode(get, limit=True) + get = urlencode(get, safe="%%&=-_%s" % (conf.paramDel or ""), limit=True) if post is not None: if place not in (PLACE.POST, PLACE.CUSTOM_POST) and hasattr(post, UNENCODED_ORIGINAL_VALUE): From 04e1162d5a3515c2fca320dcb263d7aecd4e5d57 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:29:08 +0100 Subject: [PATCH 35/93] Fix for --procs crash on DBMSes without stored procedures support --- lib/core/settings.py | 2 +- plugins/generic/databases.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 8d4ab5070..ec063373b 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.30" +VERSION = "1.10.11.31" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/plugins/generic/databases.py b/plugins/generic/databases.py index 226f19e60..1537f8c6e 100644 --- a/plugins/generic/databases.py +++ b/plugins/generic/databases.py @@ -1234,7 +1234,8 @@ class Databases(object): infoMsg = "fetching stored procedures" logger.info(infoMsg) - rootQuery = queries[Backend.getIdentifiedDbms()].procedures + dbms = Backend.getIdentifiedDbms() + rootQuery = queries[dbms].procedures if dbms in queries and "procedures" in queries[dbms] else {} # Generic-first by design: a DBMS is supported iff it declares a query block in # queries.xml (INFORMATION_SCHEMA.ROUTINES / pg_proc / sys.sql_modules / ALL_SOURCE / RDB$PROCEDURES). From d49202eaf11da8b53bce1804681bee867449da3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:31:18 +0100 Subject: [PATCH 36/93] Fix for SQLite --columns with multiple tables (-T a,b) --- lib/core/common.py | 4 ++-- lib/core/settings.py | 2 +- plugins/generic/databases.py | 10 +++++----- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/lib/core/common.py b/lib/core/common.py index 5c6739220..f05579d7e 100644 --- a/lib/core/common.py +++ b/lib/core/common.py @@ -3634,7 +3634,7 @@ def isDBMSVersionAtLeast(minimum): return retVal -def parseSqliteTableSchema(value): +def parseSqliteTableSchema(value, tbl=None): """ Parses table column names and types from specified SQLite table schema @@ -3675,7 +3675,7 @@ def parseSqliteTableSchema(value): columns[safeSQLIdentificatorNaming(column)] = match.group(3) or "TEXT" # Note: stored escaped, as by all other column enumeration paths (e.g. 'my col' -> '`my col`') - table[safeSQLIdentificatorNaming(conf.tbl, True)] = columns + table[safeSQLIdentificatorNaming(tbl or conf.tbl, True)] = columns if conf.db in kb.data.cachedColumns: kb.data.cachedColumns[conf.db].update(table) else: diff --git a/lib/core/settings.py b/lib/core/settings.py index ec063373b..1fa7cc10e 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.31" +VERSION = "1.10.11.32" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/plugins/generic/databases.py b/plugins/generic/databases.py index 1537f8c6e..3df7f8ab0 100644 --- a/plugins/generic/databases.py +++ b/plugins/generic/databases.py @@ -704,9 +704,9 @@ class Databases(object): if dumpMode and colList: if conf.db not in kb.data.cachedColumns: kb.data.cachedColumns[conf.db] = {} - kb.data.cachedColumns[conf.db][safeSQLIdentificatorNaming(conf.tbl, True)] = dict((_, None) for _ in colList) + kb.data.cachedColumns[conf.db][safeSQLIdentificatorNaming(tbl, True)] = dict((_, None) for _ in colList) else: - parseSqliteTableSchema(unArrayizeValue(values)) + parseSqliteTableSchema(unArrayizeValue(values), tbl) elif not isNoneValue(values): table = {} @@ -813,13 +813,13 @@ class Databases(object): if dumpMode and colList: if conf.db not in kb.data.cachedColumns: kb.data.cachedColumns[conf.db] = {} - kb.data.cachedColumns[conf.db][safeSQLIdentificatorNaming(conf.tbl, True)] = dict((_, None) for _ in colList) + kb.data.cachedColumns[conf.db][safeSQLIdentificatorNaming(tbl, True)] = dict((_, None) for _ in colList) else: query = rootQuery.blind.query % unsafeSQLIdentificatorNaming(tbl) value = unArrayizeValue(inject.getValue(query, union=False, error=False)) - parseSqliteTableSchema(unArrayizeValue(value)) + parseSqliteTableSchema(unArrayizeValue(value), tbl) - return kb.data.cachedColumns + continue table = {} columns = {} From 04db324b019d4f96d4fad8fc09410c8f07066af6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:32:03 +0100 Subject: [PATCH 37/93] Fix for --search -T with multiple tables on SQLite/Firebird (blind) --- lib/core/settings.py | 2 +- plugins/generic/search.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 1fa7cc10e..424e4348b 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.32" +VERSION = "1.10.11.33" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/plugins/generic/search.py b/plugins/generic/search.py index 61c9ff6cd..a7fb4c184 100644 --- a/plugins/generic/search.py +++ b/plugins/generic/search.py @@ -279,7 +279,7 @@ class Search(object): foundTbls[db] = [] else: dbName = "SQLite" if Backend.isDbms(DBMS.SQLITE) else "Firebird" - foundTbls["%s%s" % (dbName, METADB_SUFFIX)] = [] + foundTbls.setdefault("%s%s" % (dbName, METADB_SUFFIX), []) # Note: keeping matches of previous tables (e.g. -T users,nonexist) for db in foundTbls: db = safeSQLIdentificatorNaming(db) From b48a14a63ba5cf9957ed0ba9ddeb0dad96e70da4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:32:41 +0100 Subject: [PATCH 38/93] Fix for --sql-query splitting on ';' inside string literals --- lib/controller/action.py | 3 ++- lib/core/settings.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/lib/controller/action.py b/lib/controller/action.py index 531dfa722..daea4e76c 100644 --- a/lib/controller/action.py +++ b/lib/controller/action.py @@ -9,6 +9,7 @@ from lib.controller.handler import setHandler from lib.core.common import Backend from lib.core.common import Format from lib.core.common import hashDBWrite +from lib.core.common import splitFields from lib.core.data import conf from lib.core.data import kb from lib.core.data import logger @@ -251,7 +252,7 @@ def action(): raise if conf.sqlQuery: - for query in conf.sqlQuery.strip(';').split(';'): + for query in splitFields(conf.sqlQuery.strip(';'), delimiter=';'): # Note: e.g. "SELECT 'a;b'" is a single statement query = query.strip() if query: conf.dumper.sqlQuery(query, conf.dbmsHandler.sqlQuery(query)) diff --git a/lib/core/settings.py b/lib/core/settings.py index 424e4348b..5ff454131 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.33" +VERSION = "1.10.11.34" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 7827b2c389edfd993c59db17c39708e64c66271e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:32:41 +0100 Subject: [PATCH 39/93] Fix for --sql-file with comment lines --- lib/core/settings.py | 2 +- plugins/generic/custom.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 5ff454131..b4ac1fa5e 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.34" +VERSION = "1.10.11.35" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/plugins/generic/custom.py b/plugins/generic/custom.py index 4d3ce0b70..cab2fef24 100644 --- a/plugins/generic/custom.py +++ b/plugins/generic/custom.py @@ -152,6 +152,7 @@ class Custom(object): # User SQL is not a bundled procedure template: preserve literals and percent tokens. snippet = readCachedFileContent(filename) + snippet = "\n".join(_ for _ in snippet.split("\n") if not re.match(r"\s*(--|#)", _)) # Note: only whole comment lines (literals stay intact) queries = [_.strip() for _ in splitFields(snippet, delimiter=';' if zeroDepthSearch(snippet, ';') else '\n') if _.strip()] if queries and all(query.upper().startswith("SELECT") for query in queries): From 7944f0e7e84a59fd79ac42f2d9874a36f9fb0e4b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:35:49 +0100 Subject: [PATCH 40/93] Fix for -D/-T lists with spaces after commas (e.g. -T 'users, creds') --- lib/core/option.py | 5 +++-- lib/core/settings.py | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/lib/core/option.py b/lib/core/option.py index 58ea9d7b9..5cc7a6dc9 100644 --- a/lib/core/option.py +++ b/lib/core/option.py @@ -2119,8 +2119,9 @@ def _cleanupOptions(): if conf.torType: conf.torType = conf.torType.upper() - if conf.col: - conf.col = re.sub(r"\s*,\s*", ',', conf.col) + for _ in ("db", "tbl", "col"): + if conf.get(_): + conf[_] = re.sub(r"\s*,\s*", ',', conf[_]) if conf.exclude: regex = False diff --git a/lib/core/settings.py b/lib/core/settings.py index b4ac1fa5e..2cf3e75e9 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.35" +VERSION = "1.10.11.36" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 445516b151c58e19670b04aca7f67e49ccccd9a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:44:08 +0100 Subject: [PATCH 41/93] Fix for retried requests (e.g. timeout, 429, dead proxy) losing the response page --- lib/core/settings.py | 2 +- lib/request/connect.py | 8 +++++--- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 2cf3e75e9..84af1c2d4 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.36" +VERSION = "1.10.11.37" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/connect.py b/lib/request/connect.py index 7834e9c17..a909a3ab3 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -367,7 +367,7 @@ class Connect(object): threadData = getCurrentThreadData() with kb.locks.request: kb.requestCounter += 1 - threadData.lastRequestUID = kb.requestCounter + threadData.lastRequestUID = requestUID = kb.requestCounter if conf.proxyFreq: if kb.requestCounter % conf.proxyFreq == 0: @@ -1115,8 +1115,10 @@ class Connect(object): if kb.postHint == POST_HINT.GRPC_WEB: page = grpcDecodeResponse(page, responseHeaders) - threadData.lastPage = page - threadData.lastCode = code + # Note: in case of a (nested) retried request, its (last) response is the relevant one + if threadData.lastRequestUID == requestUID: + threadData.lastPage = page + threadData.lastCode = code socket.setdefaulttimeout(conf.timeout) From d1ceaf9365719354acb54dd880e4a009a0bb8c29 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:44:50 +0100 Subject: [PATCH 42/93] Fix for --param-exclude partially matching place names (e.g. 'ge' vs GET) --- lib/controller/controller.py | 2 +- lib/core/settings.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/controller/controller.py b/lib/controller/controller.py index 0b1cb2c0d..3a44f6cff 100644 --- a/lib/controller/controller.py +++ b/lib/controller/controller.py @@ -711,7 +711,7 @@ def start(): infoMsg = "skipping %sparameter '%s'" % ("%s " % paramType if paramType != parameter else "", parameter) logger.info(infoMsg) - elif conf.paramExclude and (re.search(conf.paramExclude, parameter, re.I) or kb.postHint and re.search(conf.paramExclude, parameter.split(' ')[-1], re.I) or re.search(conf.paramExclude, place, re.I)): + elif conf.paramExclude and (re.search(conf.paramExclude, parameter, re.I) or kb.postHint and re.search(conf.paramExclude, parameter.split(' ')[-1], re.I) or re.search(r"\A(?:%s)\Z" % conf.paramExclude, place, re.I)): # Note: place (e.g. 'Cookie') has to be fully matched (e.g. 'ge' must not exclude 'GET') testSqlInj = False infoMsg = "skipping %sparameter '%s'" % ("%s " % paramType if paramType != parameter else "", parameter) diff --git a/lib/core/settings.py b/lib/core/settings.py index 84af1c2d4..e34663ae4 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.37" +VERSION = "1.10.11.38" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From b85cd4cc15161fd81750689ce3bc093072f675d4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:46:02 +0100 Subject: [PATCH 43/93] Fix for SSTI --os-cmd reporting fabricated output on shell-less engines (e.g. Freemarker) --- lib/core/settings.py | 2 +- lib/techniques/ssti/inject.py | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index e34663ae4..6f46a774c 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.38" +VERSION = "1.10.11.39" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/techniques/ssti/inject.py b/lib/techniques/ssti/inject.py index 98b3fb8d4..aed7e2fc1 100644 --- a/lib/techniques/ssti/inject.py +++ b/lib/techniques/ssti/inject.py @@ -1019,7 +1019,9 @@ def _executeCommand(place, parameter, engine, cmd): payload = payloadTemplate.replace("{CMD}", framedCmd) page = getUnicode(_send(place, parameter, original + payload) or "") out = _framedOutput(page, start, end) - if out is not None: + # Note: without a shell (e.g. Java's Runtime.exec) printf recycles its format over the rest of the (unexecuted) command + # line (e.g. ';id;printf%s%s'), "reproducing" both markers by itself - leftover format is the telltale + if out is not None and "%s%s" not in out: conf.dumper.singleString("\nos-shell (%s) [%s]:\n%s" % (cmd, description, out)) return From d4d2d1a315474163a559dbd2ffc7f07fa03f0e9b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:46:39 +0100 Subject: [PATCH 44/93] Fix for --proxy-file without usable entries silently connecting directly --- lib/core/option.py | 5 +++++ lib/core/settings.py | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/lib/core/option.py b/lib/core/option.py index 5cc7a6dc9..3fdd10c40 100644 --- a/lib/core/option.py +++ b/lib/core/option.py @@ -2757,6 +2757,11 @@ def _setProxyList(): _, type_, cred, address, port = match.groups() conf.proxyList.append("%s://%s%s:%s" % (type_ or "http", ("%s@" % cred) if cred else "", address, port)) + # Note: otherwise sqlmap would silently connect directly (i.e. without any proxy) + if not conf.proxyList: + errMsg = "no usable proxy entries found in proxy list file '%s' (expected format e.g. 'http://127.0.0.1:8080')" % conf.proxyFile + raise SqlmapSyntaxException(errMsg) + def _setTorProxySettings(): if not conf.tor: return diff --git a/lib/core/settings.py b/lib/core/settings.py index 6f46a774c..8401df549 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.39" +VERSION = "1.10.11.40" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From f1c718c01c3d85f9ac90116f94e396a1ee0ceca2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:48:17 +0100 Subject: [PATCH 45/93] Fix for --oob-token being sent to public OOB servers --- lib/core/settings.py | 2 +- lib/request/interactsh.py | 5 +++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 8401df549..1d041feef 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.40" +VERSION = "1.10.11.41" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/interactsh.py b/lib/request/interactsh.py index 3c1856ace..f7faa5bc4 100644 --- a/lib/request/interactsh.py +++ b/lib/request/interactsh.py @@ -49,6 +49,11 @@ class Interactsh(object): def __init__(self, server=None, token=None): self.server = None self.token = token or conf.get("oobToken") + + # Note: (private) token belongs only to an explicitly provided server (i.e. never to be sent to a public one) + if self.token and not server: + logger.warning("OOB token is used only with an explicitly provided OOB server (option '--oob-server')") + self.token = None self.correlationId = randomStr(OOB_CORRELATION_ID_LENGTH, lowercase=True) self.secret = randomStr(32, lowercase=True) self.registered = False From 3ab05cade08bda458a93f415cfbd8658678ba609 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:50:11 +0100 Subject: [PATCH 46/93] Fix for anti-CSRF tokens in JSON (spaced), header names with dashes and header values with special chars --- lib/core/settings.py | 2 +- lib/core/target.py | 2 +- lib/request/connect.py | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 1d041feef..cf1563953 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.41" +VERSION = "1.10.11.42" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/core/target.py b/lib/core/target.py index 56520f672..b5afa1a08 100644 --- a/lib/core/target.py +++ b/lib/core/target.py @@ -457,7 +457,7 @@ def _setRequestParams(): raise SqlmapGenericException(errMsg) if conf.csrfToken: - if not any(re.search(conf.csrfToken, ' '.join(_), re.I) for _ in (conf.paramDict.get(PLACE.GET, {}), conf.paramDict.get(PLACE.POST, {}), conf.paramDict.get(PLACE.COOKIE, {}))) and not re.search(r"\b%s\b" % conf.csrfToken, "%s %s" % (conf.data or "", conf.parameters.get(PLACE.GET) or "")) and conf.csrfToken not in set(_[0].lower() for _ in conf.httpHeaders) and conf.csrfToken not in conf.paramDict.get(PLACE.COOKIE, {}) and not any(re.search(conf.csrfToken, _, re.I) for _ in conf.paramDict.get(PLACE.URI, {}).values()): + if not any(re.search(conf.csrfToken, ' '.join(_), re.I) for _ in (conf.paramDict.get(PLACE.GET, {}), conf.paramDict.get(PLACE.POST, {}), conf.paramDict.get(PLACE.COOKIE, {}))) and not re.search(r"\b%s\b" % conf.csrfToken, "%s %s" % (conf.data or "", conf.parameters.get(PLACE.GET) or "")) and not any(re.search(r"\A%s\Z" % conf.csrfToken, _[0], re.I) for _ in conf.httpHeaders) and conf.csrfToken not in conf.paramDict.get(PLACE.COOKIE, {}) and not any(re.search(conf.csrfToken, _, re.I) for _ in conf.paramDict.get(PLACE.URI, {}).values()): errMsg = "anti-CSRF token parameter '%s' not " % conf.csrfToken._original errMsg += "found in provided GET, POST, Cookie or header values" raise SqlmapGenericException(errMsg) diff --git a/lib/request/connect.py b/lib/request/connect.py index a909a3ab3..832fc543c 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -1422,10 +1422,10 @@ class Connect(object): match = re.search(r"(?i)]+\bvalue=[\"']?(?P[^>'\"]*)[\"']?[^>]*\bname=[\"']?(?P%s)\b" % conf.csrfToken, page or "", re.I) if not match: - match = re.search(r"(?P%s)[\"']:[\"'](?P[^\"']+)" % conf.csrfToken, page or "", re.I) + match = re.search(r"(?P%s)[\"']\s*:\s*[\"'](?P[^\"']+)" % conf.csrfToken, page or "", re.I) if not match: - match = re.search(r"\b(?P%s)\s*[:=]\s*(?P\w+)" % conf.csrfToken, getUnicode(headers), re.I) + match = re.search(r"\b(?P%s)\s*[:=]\s*(?P[^\s;,]+)" % conf.csrfToken, getUnicode(headers), re.I) if not match: match = re.search(r"\b(?P%s)\s*=\s*['\"]?(?P[^;'\"]+)" % conf.csrfToken, page or "", re.I) From 057e614500249e64774e8947fc0b929757f9dc85 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:51:29 +0100 Subject: [PATCH 47/93] Fix for --safe-url carrying injected cookie payload and --safe-req getting target's GET parameters --- lib/core/settings.py | 2 +- lib/request/connect.py | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index cf1563953..01a3a060c 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.42" +VERSION = "1.10.11.43" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/connect.py b/lib/request/connect.py index 832fc543c..101bfa700 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -1695,10 +1695,11 @@ class Connect(object): if (conf.safeFreq or 0) > 0 and not buildOnly: kb.queryCounter += 1 if kb.queryCounter % conf.safeFreq == 0: + # Note: "safe" visit must not carry the payload (e.g. in case of Cookie injection) if conf.safeUrl: - Connect.getPage(url=conf.safeUrl, post=conf.safePost, cookie=cookie, direct=True, silent=True, ua=ua, referer=referer, host=host) + Connect.getPage(url=conf.safeUrl, post=conf.safePost, cookie=conf.parameters.get(PLACE.COOKIE) if place == PLACE.COOKIE else cookie, direct=True, silent=True, ua=ua, referer=referer, host=host) elif kb.safeReq: - Connect.getPage(url=kb.safeReq.url, post=kb.safeReq.post, method=kb.safeReq.method, auxHeaders=kb.safeReq.headers) + Connect.getPage(url=kb.safeReq.url, post=kb.safeReq.post, method=kb.safeReq.method, auxHeaders=kb.safeReq.headers, direct=True) # When the timeless oracle is engaged (by action() at the start of extraction, so the heavy vector # is in place before any payload is built), a boolean comparison is answered by relative HTTP/2 From 4df83fe7375ef00ea56238c8ef00efd5e5c4467d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:53:41 +0100 Subject: [PATCH 48/93] Fix for user's LIMIT being ignored by UNION JSON aggregation (e.g. --sql-query) --- lib/core/settings.py | 2 +- lib/techniques/union/use.py | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 01a3a060c..f870b537f 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.43" +VERSION = "1.10.11.44" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/techniques/union/use.py b/lib/techniques/union/use.py index bbdbe681d..0a413884a 100644 --- a/lib/techniques/union/use.py +++ b/lib/techniques/union/use.py @@ -353,8 +353,11 @@ def unionUse(expression, unpack=True, dump=False): debugMsg += "it does not play well with UNION query SQL injection" singleTimeDebugMessage(debugMsg) + # Note: (outer) LIMIT/OFFSET/FETCH would apply to the single aggregated row (i.e. being ignored), while Microsoft SQL Server's FOR JSON wraps the whole statement + limited = not Backend.isDbms(DBMS.MSSQL) and any(zeroDepthSearch(expression.upper(), _) for _ in (" LIMIT ", " OFFSET ", " FETCH ")) + # Note: Oracle, PostgreSQL, Microsoft SQL Server and SQLite aggregate the raw (not hex-converted) fields, while parseUnionPage() decodes them all in case of '--hex' - if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.ORACLE, DBMS.PGSQL, DBMS.MSSQL, DBMS.SQLITE, DBMS.H2, DBMS.HSQLDB, DBMS.FIREBIRD) and expressionFields and not any((conf.binaryFields, conf.limitStart, conf.limitStop, conf.disableJson)) and not (conf.hexConvert and Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.PGSQL, DBMS.MSSQL, DBMS.SQLITE)): + if not limited and Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.ORACLE, DBMS.PGSQL, DBMS.MSSQL, DBMS.SQLITE, DBMS.H2, DBMS.HSQLDB, DBMS.FIREBIRD) and expressionFields and not any((conf.binaryFields, conf.limitStart, conf.limitStop, conf.disableJson)) and not (conf.hexConvert and Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.PGSQL, DBMS.MSSQL, DBMS.SQLITE)): match = re.search(r"SELECT\s*(.+?)\bFROM", expression, re.I) if match and not (Backend.isDbms(DBMS.ORACLE) and FROM_DUMMY_TABLE[DBMS.ORACLE] in expression) and not re.search(r"\b(MIN|MAX|COUNT|EXISTS)\(", expression): kb.jsonAggMode = True From 76351cdbd5f655f8730f16ee90055230e4eca6f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:56:44 +0100 Subject: [PATCH 49/93] Fix for --common-columns false positives (columns of injected query's table) --- lib/core/settings.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index f870b537f..e65dd3d78 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.44" +VERSION = "1.10.11.45" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) @@ -849,7 +849,7 @@ PROBLEMATIC_CUSTOM_INJECTION_PATTERNS = r"(;q=[^;'*]+)|(\*/\*)" BRUTE_TABLE_EXISTS_TEMPLATE = "EXISTS(SELECT %d FROM %s)" # Template used for common column existence check -BRUTE_COLUMN_EXISTS_TEMPLATE = "EXISTS(SELECT %s FROM %s)" +BRUTE_COLUMN_EXISTS_TEMPLATE = "EXISTS(SELECT t.%s FROM %s t)" # Note: qualified, otherwise an unknown column would resolve to the (outer) injected query's table # Data inside shellcodeexec to be filled with random string SHELLCODEEXEC_RANDOM_STRING_MARKER = b"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" From 563066e4f55df258bf1832d5e2ccbb6c8aa030e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 14:56:44 +0100 Subject: [PATCH 50/93] Fix for --common-tables/--common-columns false positive on oracle string words --- lib/core/settings.py | 2 +- lib/utils/brute.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index e65dd3d78..0d94c655b 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.45" +VERSION = "1.10.11.46" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/utils/brute.py b/lib/utils/brute.py index eb619fba0..f37dcaf89 100644 --- a/lib/utils/brute.py +++ b/lib/utils/brute.py @@ -55,7 +55,8 @@ def _addPageTextWords(): for word in pageWords: word = word.lower() - if len(word) > 2 and not word[0].isdigit() and word not in wordsList: + # Note: words of the (boolean) oracle string would be "found" (e.g. reflected inside an error message) + if len(word) > 2 and not word[0].isdigit() and word not in wordsList and not (conf.string and word in conf.string.lower()): wordsList.append(word) return wordsList From 71907c80fedf59112bc400ca5c25671207720e2b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 15:00:18 +0100 Subject: [PATCH 51/93] Fix for -c configuration values overriding explicit CLI zeros (e.g. --delay 0, -v 0) --- lib/core/option.py | 2 +- lib/core/settings.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/option.py b/lib/core/option.py index 3fdd10c40..6500bed8c 100644 --- a/lib/core/option.py +++ b/lib/core/option.py @@ -2652,7 +2652,7 @@ def _mergeOptions(inputOptions, overrideOptions): inputOptionsItems = inputOptions.__dict__.items() for key, value in inputOptionsItems: - if key not in conf or value not in (None, False) or overrideOptions: + if key not in conf or (value is not None and value is not False) or overrideOptions: # Note: explicit zero (e.g. '--delay 0') has to win over the configuration file conf[key] = value if not conf.api: diff --git a/lib/core/settings.py b/lib/core/settings.py index 0d94c655b..7caa61073 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.46" +VERSION = "1.10.11.47" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 2530de4c1f4acdd5bda2bf87a36dd5acbbabb1fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 15:03:20 +0100 Subject: [PATCH 52/93] Fix for -r request files with multiple Cookie headers and HTTP/2 pseudo-headers --- lib/core/common.py | 6 +++++- lib/core/settings.py | 2 +- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/lib/core/common.py b/lib/core/common.py index f05579d7e..cc44162ee 100644 --- a/lib/core/common.py +++ b/lib/core/common.py @@ -5793,6 +5793,10 @@ def parseRequestFile(reqFile, checkParams=True): elif "?" in line and "=" in line and ": " not in line: params = True + # HTTP/2 pseudo-headers (e.g. ':authority') + elif line.startswith(':'): + continue + # Headers elif re.search(r"\A\S+:", line): key, value = line.split(":", 1) @@ -5807,7 +5811,7 @@ def parseRequestFile(reqFile, checkParams=True): # Cookie and Host headers if key.upper() == HTTP_HEADER.COOKIE.upper(): - cookie = value + cookie = "%s; %s" % (cookie, value) if cookie else value # Note: (e.g. HTTP/2) cookies can be split into multiple headers elif key.upper() == HTTP_HEADER.HOST.upper(): if '://' in value: scheme, value = value.split('://')[:2] diff --git a/lib/core/settings.py b/lib/core/settings.py index 7caa61073..b714be69f 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.47" +VERSION = "1.10.11.48" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From ca698bb7ec51f7e4f682323d4e34eb7590c091f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 16:14:55 +0100 Subject: [PATCH 53/93] Implementing -T for --graphql dumps (and using it in vuln-test to prevent CI timeouts) --- lib/core/settings.py | 2 +- lib/core/testing.py | 2 +- lib/techniques/graphql/inject.py | 4 ++++ 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index b714be69f..62352e48a 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.48" +VERSION = "1.10.11.49" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/core/testing.py b/lib/core/testing.py index 2923314c8..b919605bc 100644 --- a/lib/core/testing.py +++ b/lib/core/testing.py @@ -95,7 +95,7 @@ def vulnTest(tests=None, label="vuln"): ("-u -z \"tec=B\" --hex --fresh-queries --threads=4 --sql-query=\"SELECT * FROM users\"", ("SELECT * FROM users [30]", "nameisnull")), ("-u \"&echo=foobar*\" --flush-session", ("might be vulnerable to cross-site scripting",)), ("-u \"nosql?name=luther&password=x\" -p password --nosql --flush-session", ("is vulnerable to NoSQL injection", "back-end: 'MongoDB'", "NoSQL: GET parameter 'password'", "s3cr3t")), # NoSQL (MongoDB) operator-injection detection + blind regexp extraction - ("-u \"graphql\" --graphql --flush-session --disable-hashing", ("found GraphQL endpoint", "introspection returned", "enumerated 6 injectable argument slot(s): 4 query, 2 mutation", "SQL injection via GraphQL (boolean-based)", "in-band data exposure", "back-end DBMS: 'SQLite'", "banner: '3.", "GraphQL database tables", "fetched 30 entries from table 'creds'", "db3a16990a0008a3b04707fdef6584a0", "GraphQL scan complete")), # GraphQL: endpoint detection + introspection + query-slots-first (mutations only as fallback) + boolean-blind/in-band + back-end fingerprint + batched blind dump of an injection-only table (SQLite-backed) + ("-u \"graphql\" --graphql -T creds --flush-session --disable-hashing", ("found GraphQL endpoint", "introspection returned", "enumerated 6 injectable argument slot(s): 4 query, 2 mutation", "SQL injection via GraphQL (boolean-based)", "in-band data exposure", "back-end DBMS: 'SQLite'", "banner: '3.", "GraphQL database tables", "fetched 30 entries from table 'creds'", "db3a16990a0008a3b04707fdef6584a0", "GraphQL scan complete")), # GraphQL: endpoint detection + introspection + query-slots-first (mutations only as fallback) + boolean-blind/in-band + back-end fingerprint + batched blind dump of an injection-only table (SQLite-backed) ("-u \"ldap/search?q=x\" --ldap --flush-session --disable-hashing", ("is vulnerable to LDAP injection", "Title: LDAP in-band data exposure", "LDAP: GET parameter 'q' in-band entries", "in-band data exposure", "LDAP scan complete")), # LDAP: error-based detection (unbalanced paren) + boolean oracle + directory attribute extraction via blind substring probing ("-u \"echo?q=x\" --xslt --flush-session --disable-hashing", ("no parameter appears to be injectable", "~is vulnerable to")), # reflection is not evaluation: a pure echo endpoint must not satisfy any non-SQL engine's oracle ("-u \"echo?q=x\" --xpath --flush-session --disable-hashing", ("no parameter appears to be injectable", "~is vulnerable to")), # same gate for --xpath (it used to confirm XPath injection from reflected text alone) diff --git a/lib/techniques/graphql/inject.py b/lib/techniques/graphql/inject.py index a4576f03c..288ffa0eb 100644 --- a/lib/techniques/graphql/inject.py +++ b/lib/techniques/graphql/inject.py @@ -1651,6 +1651,10 @@ def _enumerate(oracle): conf.dumper.singleString("GraphQL database tables [%d]:\n%s" % ( len(tables), _grid(["table"], [[_] for _ in tables]))) + # Note: honoring -T (as in case of regular SQL enumeration) + if conf.tbl: + tables = [_ for _ in tables if _.lower() in set(__.lower() for __ in conf.tbl.split(','))] + for table in tables: parsed = _dumpTable(infer, dialect, table) if not parsed: From d646b00ceb48a043a61b2ab2dd671a074c9d1762 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 16:25:24 +0100 Subject: [PATCH 54/93] Fix for --time-limit producing empty --har file --- lib/core/settings.py | 2 +- sqlmap.py | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 62352e48a..5737e0e34 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.49" +VERSION = "1.10.11.50" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/sqlmap.py b/sqlmap.py index feacbc82c..98446f6dc 100755 --- a/sqlmap.py +++ b/sqlmap.py @@ -648,6 +648,9 @@ def main(): except OSError: pass + # Note: --time-limit must not interrupt the final cleanup (e.g. session flush or HAR file writing) + conf.timeLimit = None + if conf.get("hashDB"): conf.hashDB.flush() conf.hashDB.close() # NOTE: because of PyPy From d0fc7512dfe870c1738b966cf3c6e35bd3653e7c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 16:25:57 +0100 Subject: [PATCH 55/93] Fix for -s with non-existent directory (traceback at the end of run) --- lib/core/settings.py | 2 +- lib/core/target.py | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 5737e0e34..3872c0b95 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.50" +VERSION = "1.10.11.51" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/core/target.py b/lib/core/target.py index b5afa1a08..0c73e59af 100644 --- a/lib/core/target.py +++ b/lib/core/target.py @@ -486,6 +486,10 @@ def _setHashDB(): if not conf.hashDBFile: conf.hashDBFile = conf.sessionFile or os.path.join(conf.outputPath, SESSION_SQLITE_FILE) + if conf.sessionFile and not os.path.isdir(os.path.dirname(os.path.abspath(conf.hashDBFile))): + errMsg = "directory of the provided session file '%s' does not exist" % conf.sessionFile + raise SqlmapFilePathException(errMsg) + if conf.flushSession: if os.path.exists(conf.hashDBFile): if conf.hashDB: From ca2e847ef6e798037ec52b7adec458f25a920333 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 16:25:57 +0100 Subject: [PATCH 56/93] Fix for -p Cookie also testing whole Cookie header (in case of --cookie) --- lib/core/settings.py | 2 +- lib/core/target.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 3872c0b95..f61af8168 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.51" +VERSION = "1.10.11.52" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/core/target.py b/lib/core/target.py index 0c73e59af..b11fb96ad 100644 --- a/lib/core/target.py +++ b/lib/core/target.py @@ -438,7 +438,8 @@ def _setRequestParams(): testableParameters = True else: - condition = intersect(conf.testParameter, [httpHeader], True) + # Note: in case of --cookie, its (Cookie) parameters are tested separately (i.e. not the whole header) + condition = intersect(conf.testParameter, [httpHeader], True) and not (conf.cookie and httpHeader.upper() == HTTP_HEADER.COOKIE.upper()) if condition: conf.parameters[PLACE.CUSTOM_HEADER] = str(conf.httpHeaders) From 4b8c39e424488498eee60ea68130dc5fc4d7f17f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 16:25:57 +0100 Subject: [PATCH 57/93] Fix for --param-filter=POST not matching JSON/XML bodies --- lib/controller/controller.py | 2 +- lib/core/settings.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/controller/controller.py b/lib/controller/controller.py index 3a44f6cff..2413233d0 100644 --- a/lib/controller/controller.py +++ b/lib/controller/controller.py @@ -636,7 +636,7 @@ def start(): skip |= (place == PLACE.REFERER and (kb.testOnlyCustom or conf.level < 3)) # --param-filter - skip |= (len(conf.paramFilter) > 0 and place.upper() not in conf.paramFilter) + skip |= (len(conf.paramFilter) > 0 and place.upper() not in conf.paramFilter and place.upper().replace("(CUSTOM) ", "") not in conf.paramFilter) # Note: e.g. POST for JSON/XML (i.e. '(custom) POST') too # Test Host header only if # --level >= 5 diff --git a/lib/core/settings.py b/lib/core/settings.py index f61af8168..e27142979 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.52" +VERSION = "1.10.11.53" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 8eacffa226bd57da30b2738d0404e5bf360ff7ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 16:25:57 +0100 Subject: [PATCH 58/93] Fix for --crawl dropping GET links having same parameter names as POST forms --- lib/core/settings.py | 2 +- lib/utils/crawler.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index e27142979..1f7c01865 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.53" +VERSION = "1.10.11.54" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/utils/crawler.py b/lib/utils/crawler.py index 05cc4a6b4..9a5b15c52 100644 --- a/lib/utils/crawler.py +++ b/lib/utils/crawler.py @@ -501,7 +501,7 @@ def normalizeCrawlingResults(targets): # action name and parameters (e.g. /users/edit?id= vs /products/edit?id=) are not collapsed match = re.search(r"\A[^?]+\?.+\Z", value) if match: - key = re.sub(r"=[^=&]*", "=", match.group(0)).strip("&?") + key = "%s %s" % (target[1] or "GET", re.sub(r"=[^=&]*", "=", match.group(0)).strip("&?")) # Note: e.g. GET link and POST form with same parameter(s) are distinct targets if '=' in key and key not in seen: results.add(target) seen.add(key) From 3fdf0058746d5d36804988767cc2e525ba2af50a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 16:25:58 +0100 Subject: [PATCH 59/93] Fix for --scope/--crawl-exclude not applied to forms found in scripts (e.g. jQuery's $.post) --- lib/core/common.py | 3 +++ lib/core/settings.py | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/lib/core/common.py b/lib/core/common.py index cc44162ee..4c6e4df1c 100644 --- a/lib/core/common.py +++ b/lib/core/common.py @@ -5078,6 +5078,9 @@ def findPageForms(content, url, raiseException=False, addToTargets=False): data = data.strip("['\"]") retVal.add((url, HTTPMETHOD.POST, data, conf.cookie, None)) + # Note: same filtering for forms found inside scripts (e.g. jQuery's $.post(...)) as for regular ones + retVal = set(_ for _ in retVal if not (conf.crawlExclude and re.search(conf.crawlExclude, _[0]) or conf.scope and not re.search(conf.scope, _[0], re.I) or not checkSameHost(response.geturl(), _[0]))) + if not retVal and not conf.crawlDepth: errMsg = "there were no forms found at the given target URL" if raiseException: diff --git a/lib/core/settings.py b/lib/core/settings.py index 1f7c01865..0da7d33d7 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.54" +VERSION = "1.10.11.55" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From b6761e1825030911b878a767b92c2c516b0aaf33 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 16:25:58 +0100 Subject: [PATCH 60/93] Fix for --dump-file with multiple tables and --start/--stop mixing tables --- lib/core/dump.py | 5 ++++- lib/core/settings.py | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/lib/core/dump.py b/lib/core/dump.py index 0f8571d31..4bbe1c431 100644 --- a/lib/core/dump.py +++ b/lib/core/dump.py @@ -75,6 +75,7 @@ class Dump(object): self._outputFile = None self._outputFP = None self._lock = threading.Lock() + self._dumpFiles = {} # Note: dump file -> table (written during this run) def _write(self, data, newline=True, console=True, content_type=None): text = "%s%s" % (data, "\n" if newline else " ") @@ -513,7 +514,8 @@ class Dump(object): else: dumpFileName = os.path.join(dumpDbPath, "%s.%s" % (safeTable, conf.dumpFormat.lower())) else: - appendToFile = any((conf.limitStart, conf.limitStop)) + # Note: appending (e.g. of --start/--stop ranges) only to the same table's file (i.e. not to a --dump-file shared among multiple tables) + appendToFile = any((conf.limitStart, conf.limitStop)) and self._dumpFiles.get(dumpFileName, table) == table if not appendToFile: count = 1 @@ -528,6 +530,7 @@ class Dump(object): else: count += 1 + self._dumpFiles[dumpFileName] = table dumpFP = openFile(dumpFileName, 'w' if not appendToFile else 'a', buffering=DUMP_FILE_BUFFER_SIZE) count = int(tableValues["__infos__"]["count"]) diff --git a/lib/core/settings.py b/lib/core/settings.py index 0da7d33d7..116f2bfd6 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.55" +VERSION = "1.10.11.56" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 4f94d69783820ede8332b0d1af3abfc34236ea3d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 16:25:58 +0100 Subject: [PATCH 61/93] Fix for --proxy-cred with URL-encoded looking characters (e.g. '%41') --- lib/core/option.py | 3 ++- lib/core/settings.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/lib/core/option.py b/lib/core/option.py index 6500bed8c..fa848099f 100644 --- a/lib/core/option.py +++ b/lib/core/option.py @@ -1374,7 +1374,8 @@ def _setHTTPHandlers(): if conf.proxyCred: # Reference: http://stackoverflow.com/questions/34079/how-to-specify-an-authenticated-proxy-for-a-python-http-connection - proxyString = "%s@" % conf.proxyCred + # Note: (raw) credentials have to be URL-encoded, as urllib decodes them (e.g. '%41' would become 'A') + proxyString = "%s@" % ':'.join(_urllib.parse.quote(_, safe="") for _ in conf.proxyCred.split(':', 1)) elif match: # Note: credentials from the proxy URL itself (kept URL-encoded, as urllib decodes them on its own) proxyString = "%s:%s@" % (match.group(1), match.group(2)) diff --git a/lib/core/settings.py b/lib/core/settings.py index 116f2bfd6..32a19bf9c 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.56" +VERSION = "1.10.11.57" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 11d3ee00e6b0aafc34bec670dbb8006ee0c0038c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 16:54:59 +0100 Subject: [PATCH 62/93] Fix for --timeless with --threads still asking for (unsafe) time-based threading --- lib/core/settings.py | 2 +- lib/request/inject.py | 11 +++++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 32a19bf9c..4baa1707f 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.57" +VERSION = "1.10.11.58" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/inject.py b/lib/request/inject.py index ef2f7ccb5..81a782f07 100644 --- a/lib/request/inject.py +++ b/lib/request/inject.py @@ -112,11 +112,14 @@ def _goInference(payload, expression, charsetType=None, firstChar=None, lastChar timeBasedCompare = (getTechnique() in (PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED)) if timeBasedCompare and conf.threads > 1 and kb.forceThreads is None: - msg = "multi-threading is considered unsafe in " - msg += "time-based data retrieval. Are you sure " - msg += "of your choice (breaking warranty) [y/N] " + if kb.get("timeless") is not None: # Note: (HTTP/2) timeless oracle is concurrency-safe (cf. valueParallelEligible()) + kb.forceThreads = True + else: + msg = "multi-threading is considered unsafe in " + msg += "time-based data retrieval. Are you sure " + msg += "of your choice (breaking warranty) [y/N] " - kb.forceThreads = readInput(msg, default='N', boolean=True) + kb.forceThreads = readInput(msg, default='N', boolean=True) if not (timeBasedCompare and kb.dnsTest): if (conf.eta or conf.threads > 1) and Backend.getIdentifiedDbms() and not re.search(r"(COUNT|LTRIM)\(", expression, re.I) and not (timeBasedCompare and not kb.forceThreads): From c209a97131d1bc242555f34b21fde2594ad67fad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 16:57:46 +0100 Subject: [PATCH 63/93] Fix for direct connections (-d) sharing session data among different databases (e.g. SQLite files) --- lib/core/common.py | 4 ++-- lib/core/settings.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/core/common.py b/lib/core/common.py index 4c6e4df1c..84da2215c 100644 --- a/lib/core/common.py +++ b/lib/core/common.py @@ -5389,7 +5389,7 @@ def hashDBWrite(key, value, serialize=False): """ if conf.hashDB: - _ = '|'.join((str(_) if not isinstance(_, six.string_types) else _) for _ in (conf.hostname, conf.path.strip('/') if conf.path is not None else conf.port, key, HASHDB_MILESTONE_VALUE)) + _ = '|'.join((str(_) if not isinstance(_, six.string_types) else _) for _ in (conf.hostname, conf.path.strip('/') if conf.path is not None else ("%s:%s" % (conf.port, conf.dbmsDb) if conf.direct else conf.port), key, HASHDB_MILESTONE_VALUE)) # Note: in case of direct connection, database (e.g. SQLite file) is part of the key conf.hashDB.write(_, value, serialize) def hashDBRetrieve(key, unserialize=False, checkConf=False): @@ -5400,7 +5400,7 @@ def hashDBRetrieve(key, unserialize=False, checkConf=False): retVal = None if conf.hashDB: - _ = '|'.join((str(_) if not isinstance(_, six.string_types) else _) for _ in (conf.hostname, conf.path.strip('/') if conf.path is not None else conf.port, key, HASHDB_MILESTONE_VALUE)) + _ = '|'.join((str(_) if not isinstance(_, six.string_types) else _) for _ in (conf.hostname, conf.path.strip('/') if conf.path is not None else ("%s:%s" % (conf.port, conf.dbmsDb) if conf.direct else conf.port), key, HASHDB_MILESTONE_VALUE)) # Note: in case of direct connection, database (e.g. SQLite file) is part of the key retVal = conf.hashDB.retrieve(_, unserialize) if kb.resumeValues and not (checkConf and any((conf.flushSession, conf.freshQueries))) else None if not kb.inferenceMode and not kb.fileReadMode and isinstance(retVal, six.string_types) and any(_ in retVal for _ in (PARTIAL_VALUE_MARKER, PARTIAL_HEX_VALUE_MARKER)): diff --git a/lib/core/settings.py b/lib/core/settings.py index 4baa1707f..348d01282 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.58" +VERSION = "1.10.11.59" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 5a2fda4d27d1832e4b10b8d57165c8b6435a3d78 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 16:57:46 +0100 Subject: [PATCH 64/93] Fix for -d with file paths containing special characters (e.g. 'sqlite:///tmp/my dir (old)/t.db') --- lib/core/common.py | 8 ++++++-- lib/core/settings.py | 2 +- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/lib/core/common.py b/lib/core/common.py index 84da2215c..e3d59d4c6 100644 --- a/lib/core/common.py +++ b/lib/core/common.py @@ -1681,10 +1681,14 @@ def parseTargetDirect(): for dbms in SUPPORTED_DBMS: details = re.search(r"^(?P%s)://(?P(?P.*?)\:(?P.*)\@)?(?P(?P[\w.-]+?)\:(?P[\d]+)\/)?(?P[\w\d\ \:\.\_~\-\/\\]*)$" % dbms, conf.direct, re.I) + # Note: database file path of a file-based DBMS (e.g. SQLite) can contain (almost) any character (e.g. '/tmp/my dir (old)/t.db') + if not details and dbms in DBMS_DICT[DBMS.SQLITE][0] + DBMS_DICT[DBMS.ACCESS][0]: + details = re.search(r"^(?P%s)://(?P.+)$" % re.escape(dbms), conf.direct, re.I) + if details: conf.dbms = details.group("dbms") - if details.group("credentials"): + if details.groupdict().get("credentials"): conf.dbmsUser = details.group("user").strip("'\"") conf.dbmsPass = details.group("pass").strip("'\"") else: @@ -1697,7 +1701,7 @@ def parseTargetDirect(): if not conf.dbmsPass: conf.dbmsPass = None - if details.group("remote"): + if details.groupdict().get("remote"): remote = True conf.hostname = details.group("hostname").strip() conf.port = int(details.group("port")) diff --git a/lib/core/settings.py b/lib/core/settings.py index 348d01282..4152cffa2 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.59" +VERSION = "1.10.11.60" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 175dc5dfa4036cd2e5c04b0ad01e0b30a3700354 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 17:00:27 +0100 Subject: [PATCH 65/93] Fix for -l Burp logs losing entry's scheme and port --- lib/core/common.py | 13 ++++++++++--- lib/core/settings.py | 2 +- 2 files changed, 11 insertions(+), 4 deletions(-) diff --git a/lib/core/common.py b/lib/core/common.py index e3d59d4c6..0c3078237 100644 --- a/lib/core/common.py +++ b/lib/core/common.py @@ -5748,6 +5748,12 @@ def parseRequestFile(reqFile, checkParams=True): else: scheme, port = None, None + # Note: Burp's entry header line (e.g. '16:20:47 https://www.target.com:443 [1.2.3.4]') is right above the request's separator + if not isinstance(match, six.string_types): + _ = re.search(r"(?Phttps?)://[^\s/]+:(?P\d+)\s+\[[^\]]*\]\s*\Z", content[:match.start()].rstrip("=\r\n\t "), re.I) + if _: + scheme, port = _.group("scheme"), _.group("port") + if "HTTP/" not in request: continue @@ -5823,11 +5829,12 @@ def parseRequestFile(reqFile, checkParams=True): if '://' in value: scheme, value = value.split('://')[:2] - port = extractRegexResult(r":(?P\d+)\Z", value) - if port: + _ = extractRegexResult(r":(?P\d+)\Z", value) + if _: + port = _ host = value[:-(1 + len(port))] else: - host = value + host = value # Note: keeping port (if any) from e.g. Burp's entry header line # Avoid to add a static content length header to # headers and consider the following lines as diff --git a/lib/core/settings.py b/lib/core/settings.py index 4152cffa2..c089c737e 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.60" +VERSION = "1.10.11.61" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 9d5259ff9878b24805bf605fa26be24a99e2bbd8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 17:01:24 +0100 Subject: [PATCH 66/93] Fix for --auth-file (PKI) failing on self-signed/internal CA certificates --- lib/core/settings.py | 2 +- lib/request/pkihandler.py | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index c089c737e..02cab700b 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.61" +VERSION = "1.10.11.62" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/pkihandler.py b/lib/request/pkihandler.py index 5b1c3495e..9961d2cd7 100644 --- a/lib/request/pkihandler.py +++ b/lib/request/pkihandler.py @@ -37,6 +37,9 @@ class HTTPSPKIAuthHandler(_urllib.request.HTTPSHandler): try: if ssl and hasattr(ssl, "SSLContext") and hasattr(ssl, "create_default_context"): ctx = ssl.create_default_context() + # Note: no server certificate validation (e.g. self-signed/internal CA), as everywhere else (e.g. httpshandler.py) + ctx.check_hostname = False + ctx.verify_mode = ssl.CERT_NONE ctx.load_cert_chain(certfile=self.auth_file, keyfile=self.auth_file) try: return _http_client.HTTPSConnection(host, timeout=timeout, context=ctx) From ed8ad1ec77350a1b7390b89055bf01b131ad2d58 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 17:06:31 +0100 Subject: [PATCH 67/93] Fix for --xpath over POST corrupting special characters (e.g. '+') in payloads --- lib/core/settings.py | 2 +- lib/techniques/xpath/inject.py | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 02cab700b..cea2b5e68 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.62" +VERSION = "1.10.11.63" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/techniques/xpath/inject.py b/lib/techniques/xpath/inject.py index 4df434b63..fd7362835 100644 --- a/lib/techniques/xpath/inject.py +++ b/lib/techniques/xpath/inject.py @@ -43,6 +43,7 @@ from lib.core.settings import XQUERY_HARVEST_CHARS from lib.core.settings import XQUERY_MAX_FILE_LENGTH from lib.request.connect import Connect as Request from lib.utils.xrange import xrange +from thirdparty.six.moves.urllib.parse import quote as _quote SENTINEL = randomStr(length=10, lowercase=True) @@ -154,7 +155,8 @@ def _send(place, parameter, value): time.sleep(conf.delay) old_params = conf.parameters.get(place, "") - conf.parameters[place] = _replaceSegment(place, parameter, value) + # Note: POST body is sent as-is (i.e. raw '+', '&', '%' would be misinterpreted), while GET is URL encoded later on + conf.parameters[place] = _replaceSegment(place, parameter, _quote(value, safe="") if place == PLACE.POST else value) try: kwargs = {"raise404": False, "silent": True} From 6fb39709f2d6c065ac9794ce8b567ea0773d89e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 17:09:04 +0100 Subject: [PATCH 68/93] Fix for --graphql error-based detection ignoring HTTP 5xx error responses --- lib/core/settings.py | 2 +- lib/techniques/graphql/inject.py | 15 ++++++++------- tests/test_graphql.py | 22 +++++++++++----------- 3 files changed, 20 insertions(+), 19 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index cea2b5e68..2928aac7e 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.63" +VERSION = "1.10.11.64" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/techniques/graphql/inject.py b/lib/techniques/graphql/inject.py index 288ffa0eb..7cb8ec0b3 100644 --- a/lib/techniques/graphql/inject.py +++ b/lib/techniques/graphql/inject.py @@ -357,8 +357,9 @@ def _cell(value): # --- HTTP transport --------------------------------------------------------- -def _gqlSend(endpoint, query, variables=None): +def _gqlSend(endpoint, query, variables=None, errorBody=False): # POST a JSON GraphQL request to `endpoint`, returning (body, http_code) + # Note: errorBody keeps 5xx bodies (e.g. SQL error inside GraphQL 'errors') for error-message fingerprinting body = {"query": query} if variables: body["variables"] = variables @@ -382,7 +383,7 @@ def _gqlSend(endpoint, query, variables=None): return None, 0 finally: kb.postHint = oldPostHint - if blockedStatus(code): # WAF / rate-limit / 5xx is not a usable oracle sample + if blockedStatus(code) and not (errorBody and code >= 500): # WAF / rate-limit / 5xx is not a usable oracle sample return None, code return page or "", code @@ -944,16 +945,16 @@ def _detectError(slot, endpoint): # influence. Require the signature to be ABSENT from a benign baseline, appear only AFTER the # injected value, and REPRODUCE before accepting it. benign = _buildQuery(slot, "1") - basePage = _gqlSend(endpoint, benign)[0] if benign else None + basePage = _gqlSend(endpoint, benign, errorBody=True)[0] if benign else None baseErr = _errorText(basePage) or "" def _appearsOnlyAfterInjection(query, matcher): # matcher(text) -> re.Match or None; True only if it hits the injected response, is absent # from the benign baseline, and reproduces on a second injected request - err = _errorText(_gqlSend(endpoint, query)[0]) + err = _errorText(_gqlSend(endpoint, query, errorBody=True)[0]) if not err or not matcher(err) or matcher(baseErr): return None - err2 = _errorText(_gqlSend(endpoint, query)[0]) + err2 = _errorText(_gqlSend(endpoint, query, errorBody=True)[0]) return matcher(err) if (err2 and matcher(err2)) else None for payload in _SQL_ERROR_PAYLOADS: @@ -963,7 +964,7 @@ def _detectError(slot, endpoint): for pattern in ERROR_PARSING_REGEXES: m = _appearsOnlyAfterInjection(query, lambda t, p=pattern: re.search(p, t)) if m: - detail = m.group("result") if "result" in m.groupdict() else _errorText(_gqlSend(endpoint, query)[0])[:200] + detail = m.group("result") if "result" in m.groupdict() else _errorText(_gqlSend(endpoint, query, errorBody=True)[0])[:200] return "error-based", detail, payload for payload in (_NOSQL_NE, _NOSQL_IN): @@ -972,7 +973,7 @@ def _detectError(slot, endpoint): continue m = _appearsOnlyAfterInjection(query, lambda t: re.search(NOSQL_ERROR_REGEX, t)) if m: - return "nosql-error-based", (_errorText(_gqlSend(endpoint, query)[0]) or "")[:200], payload + return "nosql-error-based", (_errorText(_gqlSend(endpoint, query, errorBody=True)[0]) or "")[:200], payload return None, None, None diff --git a/tests/test_graphql.py b/tests/test_graphql.py index 057b6d7b6..fd519ac52 100644 --- a/tests/test_graphql.py +++ b/tests/test_graphql.py @@ -250,7 +250,7 @@ class TestGraphqlBooleanDetection(unittest.TestCase): gi.conf = type("C", (), {"url": "http://test/graphql"})() pages = {"true": MATCH, "false": NOMATCH} - def fakeSend(endpoint, query, variables=None): + def fakeSend(endpoint, query, variables=None, **kwargs): if "'1'='1" in query: return pages["true"], 200 if "'1'='2" in query: @@ -276,7 +276,7 @@ class TestGraphqlBooleanDetection(unittest.TestCase): def test_graphql_two_true_transport_failures_do_not_confirm(self): # the TRUE query fails transport (-> None), the FALSE succeeds: two None trues must NOT be # read as a reproducible page that "differs" from false (the classic fabricated confirmation) - def fakeSend(endpoint, query, variables=None): + def fakeSend(endpoint, query, variables=None, **kwargs): if "'1'='1" in query: return None, 0 # transport failure on the true payload return NOMATCH, 200 @@ -288,7 +288,7 @@ class TestGraphqlBooleanDetection(unittest.TestCase): def test_graphql_false_page_is_replayed(self): # a FALSE page that does not reproduce (jitter) must not establish an oracle state = {"n": 0} - def fakeSend(endpoint, query, variables=None): + def fakeSend(endpoint, query, variables=None, **kwargs): if "'1'='1" in query: return MATCH, 200 state["n"] += 1 @@ -304,7 +304,7 @@ class TestGraphqlBooleanDetection(unittest.TestCase): # P0-3: the FALSE payload trips a stable HTTP-200 resolver error ({data:null, errors:[...]}), # which yields the same {"user":null} observation as a genuine false. That is NOT a boolean # oracle (it belongs to error-based detection) - _detectBoolean must reject the errored pair. - def fakeSend(endpoint, query, variables=None): + def fakeSend(endpoint, query, variables=None, **kwargs): if "'1'='1" in query: # true -> real rows return MATCH, 200 return '{"data":{"user":null},"errors":[{"message":"resolver failed","path":["user"]}]}', 200 @@ -330,7 +330,7 @@ class TestGraphqlErrorDetection(unittest.TestCase): self._conf = gi.conf gi.conf = type("C", (), {"url": "http://test/graphql"})() - def fakeSend(endpoint, query, variables=None): + def fakeSend(endpoint, query, variables=None, **kwargs): if "'" in query and "'1'='1" not in query: return DB_ERROR, 500 return NOMATCH, 200 @@ -349,7 +349,7 @@ class TestGraphqlErrorDetection(unittest.TestCase): # boolean payloads do NOT diverge (both -> NOMATCH) so boolean detection fails; only the error # payloads trip a DB error. The reported reproducer must be the WINNING error payload, never the # generic ' OR '1'='1 boolean payload. - def fakeSend(endpoint, query, variables=None): + def fakeSend(endpoint, query, variables=None, **kwargs): if "'1'='" in query: # both boolean payloads ('1'='1 / '1'='2) -> identical, no oracle return NOMATCH, 200 if "'" in query: # error payloads (', '', '") -> DB error @@ -415,7 +415,7 @@ class TestGraphqlEndpointDetection(unittest.TestCase): def setUp(self): self._gql = gi._gqlSend - def fakeSend(endpoint, query, variables=None): + def fakeSend(endpoint, query, variables=None, **kwargs): if endpoint.endswith("/graphql") and "__typename" in query: return '{"data":{"__typename":"Query"}}', 200 return 'Not Found', 404 @@ -433,7 +433,7 @@ class TestGraphqlEndpointDetection(unittest.TestCase): self.assertEqual(endpoint, "http://test/graphql") def test_not_graphql_endpoint(self): - def fakeSend(endpoint, query, variables=None): + def fakeSend(endpoint, query, variables=None, **kwargs): return 'Not Found', 404 gi._gqlSend = fakeSend endpoint, page = gi._detectEndpoint("http://test", probePaths=True) @@ -454,7 +454,7 @@ class TestGraphqlIntrospectionFallback(unittest.TestCase): def test_fallback_without_specifiedByURL(self): calls = [] - def fakeSend(endpoint, query, variables=None): + def fakeSend(endpoint, query, variables=None, **kwargs): calls.append(query) if "specifiedByURL" in query: return '{"errors":[{"message":"Unknown field specifiedByURL"}]}', 400 @@ -684,7 +684,7 @@ class TestGraphqlInference(unittest.TestCase): NOMATCHV = '{"data":{"user":null}}' saved = gi._gqlSend try: - def fakeSend(endpoint, query, variables=None): + def fakeSend(endpoint, query, variables=None, **kwargs): if "1=1" in query: return MATCHV, 200 if "1=2" in query: @@ -733,7 +733,7 @@ class TestGraphqlMakeOracle(unittest.TestCase): def setUp(self): self._gql = gi._gqlSend - def fakeSend(endpoint, query, variables=None): + def fakeSend(endpoint, query, variables=None, **kwargs): if "a0:" in query: # batched, aliased request data = {} for m in re.finditer(r'(a\d+):\w+\(\w+:"[^"]*\((1=1|1=2)\)', query): From 60dcd8bbb0b52aa7e2c00324c576e76ff6c5f302 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 17:15:33 +0100 Subject: [PATCH 69/93] Fix for --jwt not able to confirm weaknesses when invalid tokens are answered with HTTP 401/403 --- lib/core/settings.py | 2 +- lib/techniques/jwt/inject.py | 5 +++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 2928aac7e..cf0512ca5 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.64" +VERSION = "1.10.11.65" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/techniques/jwt/inject.py b/lib/techniques/jwt/inject.py index df6bdf704..495c3735e 100644 --- a/lib/techniques/jwt/inject.py +++ b/lib/techniques/jwt/inject.py @@ -85,6 +85,10 @@ def _send(token): skipUrlEncode = conf.skipUrlEncode conf.skipUrlEncode = True + # Note: a rejected token is commonly answered with HTTP 401/403 - that is an oracle answer here, not a connection problem + ignoreCode = conf.ignoreCode + conf.ignoreCode = list(set((ignoreCode or []) + [401, 403])) + if conf.delay: time.sleep(conf.delay) @@ -110,6 +114,7 @@ def _send(token): return None finally: conf.skipUrlEncode = skipUrlEncode + conf.ignoreCode = ignoreCode return page From cdb787faea086be2eea2278955e9a69adf91274d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 17:16:26 +0100 Subject: [PATCH 70/93] Fix for --ignore-redirects being ignored with --http2 --- lib/core/settings.py | 2 +- lib/request/connect.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index cf0512ca5..d48811e96 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.65" +VERSION = "1.10.11.66" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/connect.py b/lib/request/connect.py index 101bfa700..afaaf6e5a 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -742,7 +742,7 @@ class Connect(object): raise SqlmapMissingDependence("native HTTP/2 client does not support SOCKS proxies (omit '--http2' or use an HTTP proxy)") try: - conn = http2OpenUrl(url, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET), headers, post, timeout, follow_redirects=kb.choices.redirect != REDIRECTION.NO, proxy=h2proxy, sensitive_headers=tuple(kb.authRefreshHeaders) if conf.authRefresh else ()) + conn = http2OpenUrl(url, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET), headers, post, timeout, follow_redirects=kb.choices.redirect != REDIRECTION.NO and not conf.ignoreRedirects, proxy=h2proxy, sensitive_headers=tuple(kb.authRefreshHeaders) if conf.authRefresh else ()) except IOError as ex: raise _http_client.HTTPException(getSafeExString(ex)) else: From 04f0987e81979d2cc2c38548b1098760cc109ef7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 17:20:51 +0100 Subject: [PATCH 71/93] Fix for --http2 silently ignoring HTTP authentication (Basic sent preemptively, others rejected) --- lib/core/option.py | 5 +++++ lib/core/settings.py | 2 +- lib/request/connect.py | 4 ++++ 3 files changed, 10 insertions(+), 1 deletion(-) diff --git a/lib/core/option.py b/lib/core/option.py index fa848099f..e123c5e1d 100644 --- a/lib/core/option.py +++ b/lib/core/option.py @@ -2894,6 +2894,11 @@ def _basicOptionValidation(): errMsg = "HTTP/2 support is currently incompatible with SOCKS/Tor proxies" raise SqlmapSyntaxException(errMsg) + # Note: native HTTP/2 client bypasses urllib's (challenge-response) authentication handlers (only Basic is sent preemptively) + if conf.http2 and ((conf.authType or "").lower() not in ("", AUTH_TYPE.BASIC, AUTH_TYPE.BEARER) or conf.authFile): + errMsg = "HTTP/2 support is currently incompatible with HTTP authentication type '%s'" % (conf.authType or AUTH_TYPE.PKI) + raise SqlmapSyntaxException(errMsg) + if conf.uValues and conf.uChar: errMsg = "option '--union-values' is incompatible with option '--union-char'" raise SqlmapSyntaxException(errMsg) diff --git a/lib/core/settings.py b/lib/core/settings.py index d48811e96..72882e733 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.66" +VERSION = "1.10.11.67" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/connect.py b/lib/request/connect.py index afaaf6e5a..30088b480 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -736,6 +736,10 @@ class Connect(object): from lib.request.http2 import open_url as http2OpenUrl from lib.request.http2 import proxy_tuple + # Note: (preemptive) Basic authentication, as urllib's handlers are bypassed + if (conf.authType or "").lower() == AUTH_TYPE.BASIC and conf.authUsername is not None and HTTP_HEADER.AUTHORIZATION not in headers: + headers[HTTP_HEADER.AUTHORIZATION] = "Basic %s" % encodeBase64("%s:%s" % (conf.authUsername, conf.authPassword or ""), binary=False) + try: h2proxy = proxy_tuple(conf.proxy, conf.proxyCred) except ValueError: From 2de056aa14c60c2f2907bfc43ad06666a1a9fb16 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 17:27:10 +0100 Subject: [PATCH 72/93] Fix for --http2 not storing/sending cookies (Set-Cookie) --- lib/core/settings.py | 2 +- lib/request/connect.py | 15 +++++++++++++++ lib/request/http2.py | 1 + 3 files changed, 17 insertions(+), 1 deletion(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 72882e733..b91609851 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.67" +VERSION = "1.10.11.68" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/connect.py b/lib/request/connect.py index 30088b480..2cbdb7982 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -745,11 +745,26 @@ class Connect(object): except ValueError: raise SqlmapMissingDependence("native HTTP/2 client does not support SOCKS proxies (omit '--http2' or use an HTTP proxy)") + # Note: cookie jar handling (i.e. Set-Cookie), as urllib's HTTPCookieProcessor is bypassed + if conf.cj is not None and HTTP_HEADER.COOKIE not in headers: + try: + conf.cj.add_cookie_header(req) + if req.get_header(HTTP_HEADER.COOKIE): + headers[HTTP_HEADER.COOKIE] = req.get_header(HTTP_HEADER.COOKIE) + except Exception as ex: + logger.debug("problem occurred while adding HTTP/2 cookies ('%s')" % getSafeExString(ex)) + try: conn = http2OpenUrl(url, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET), headers, post, timeout, follow_redirects=kb.choices.redirect != REDIRECTION.NO and not conf.ignoreRedirects, proxy=h2proxy, sensitive_headers=tuple(kb.authRefreshHeaders) if conf.authRefresh else ()) except IOError as ex: raise _http_client.HTTPException(getSafeExString(ex)) else: + if conf.cj is not None: + try: + conf.cj.extract_cookies(conn, req) + except Exception as ex: + logger.debug("problem occurred while storing HTTP/2 cookies ('%s')" % getSafeExString(ex)) + if conn.code >= 400: raise _urllib.error.HTTPError(conn.geturl(), conn.code, conn.msg, conn.info(), io.BytesIO(conn.read())) diff --git a/lib/request/http2.py b/lib/request/http2.py index fc8ba0fd7..491809a46 100644 --- a/lib/request/http2.py +++ b/lib/request/http2.py @@ -1496,6 +1496,7 @@ class H2Response(object): if not name.startswith(":"): self._info[name] = value self._info.headers = ["%s: %s\r\n" % item for item in self._info.items()] + self._info.getheaders = lambda name: self._info.get_all(name) or [] # Note: Python 2 cookielib's interface (e.g. for Set-Cookie) def info(self): return self._info From c0e75fa98d8480391db5b01d7f7bbeff4182bdb6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 17:31:14 +0100 Subject: [PATCH 73/93] Fix for --tables/--count displaying (and sorting by) escaped table names --- lib/core/dump.py | 8 ++++---- lib/core/settings.py | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/lib/core/dump.py b/lib/core/dump.py index 4bbe1c431..d761f7008 100644 --- a/lib/core/dump.py +++ b/lib/core/dump.py @@ -293,7 +293,7 @@ class Dump(object): lines = "-" * (int(maxlength) + 2) for db, tables in dbTables.items(): - tables = sorted(filter(None, tables)) + tables = sorted(filter(None, tables), key=lambda _: unsafeSQLIdentificatorNaming(getUnicode(_))) # Note: sorted by (displayed) unescaped names self._write("Database: %s" % unsafeSQLIdentificatorNaming(db) if db and METADB_SUFFIX not in db else "") @@ -408,7 +408,7 @@ class Dump(object): for ctables in dbTables.values(): for tables in ctables.values(): for table in tables: - maxlength1 = max(maxlength1, getConsoleLength(getUnicode(table))) + maxlength1 = max(maxlength1, getConsoleLength(unsafeSQLIdentificatorNaming(getUnicode(table)))) for db, counts in dbTables.items(): self._write("Database: %s" % unsafeSQLIdentificatorNaming(db) if db and METADB_SUFFIX not in db else "") @@ -431,10 +431,10 @@ class Dump(object): if count is None: count = "Unknown" - tables.sort(key=lambda _: _.lower() if hasattr(_, "lower") else _) + tables = sorted((unsafeSQLIdentificatorNaming(getUnicode(_)) for _ in tables), key=lambda _: _.lower()) for table in tables: - blank1 = " " * (maxlength1 - getConsoleLength(getUnicode(table))) + blank1 = " " * (maxlength1 - getConsoleLength(table)) blank2 = " " * (maxlength2 - len(str(count))) self._write("| %s%s | %d%s |" % (table, blank1, count, blank2)) diff --git a/lib/core/settings.py b/lib/core/settings.py index b91609851..065d18241 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.68" +VERSION = "1.10.11.69" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 26cb5cdc3139369c3e69eecca6a156e4c5e0d69d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 17:31:14 +0100 Subject: [PATCH 74/93] Fix for --count skipping empty tables --- lib/core/settings.py | 2 +- plugins/generic/databases.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 065d18241..f3b960576 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.69" +VERSION = "1.10.11.70" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/plugins/generic/databases.py b/plugins/generic/databases.py index 3df7f8ab0..75f9577f1 100644 --- a/plugins/generic/databases.py +++ b/plugins/generic/databases.py @@ -1058,7 +1058,7 @@ class Databases(object): query = agent.whereQuery(query) count = inject.getValue(query, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS) - if isNumPosStrValue(count): + if isNumPosStrValue(count) or count in (0, "0"): # Note: including empty tables (i.e. 0 entries) if safeSQLIdentificatorNaming(db) not in kb.data.cachedCounts: kb.data.cachedCounts[safeSQLIdentificatorNaming(db)] = {} From 2bfb53876ce8496237643a04404930564cf7f51d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 17:34:32 +0100 Subject: [PATCH 75/93] Fix for --live-cookies overwriting injected Cookie parameter --- lib/core/settings.py | 2 +- lib/request/connect.py | 14 ++++++++++++-- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index f3b960576..bc6276c15 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.70" +VERSION = "1.10.11.71" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/connect.py b/lib/request/connect.py index 2cbdb7982..69164c37a 100644 --- a/lib/request/connect.py +++ b/lib/request/connect.py @@ -425,8 +425,18 @@ class Connect(object): raise SqlmapValueException(errMsg) with openFile(conf.liveCookies) as f: - cookie = f.read().strip() - cookie = re.sub(r"(?i)\ACookie:\s*", "", cookie) + live = re.sub(r"(?i)\ACookie:\s*", "", f.read().strip()) + + # Note: (live) values are taken, except for the cookie(s) currently carrying the payload (i.e. differing from the original value) + delimiter = conf.cookieDel or DEFAULT_COOKIE_DELIMITER + original = conf.paramDict.get(PLACE.COOKIE) or {} + for part in (cookie or "").split(delimiter): + name, _, value = part.strip().partition('=') + if name in original and value != original[name]: + regex = r"(\A|(?<=[%s\s]))%s=[^%s]*" % (re.escape(delimiter), re.escape(name), re.escape(delimiter)) + live = re.sub(regex, lambda match: "%s=%s" % (name, value), live) if re.search(regex, live) else "%s%s %s=%s" % (live, delimiter, name, value) + + cookie = live if multipart: post = multipart From 910fccb65ea6eb5066efc4d94b8860ea907a875e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 17:37:25 +0100 Subject: [PATCH 76/93] Fix for --dump-format=HTML with --start/--stop appending a whole new document --- lib/core/dump.py | 15 +++++++++++++-- lib/core/settings.py | 2 +- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/lib/core/dump.py b/lib/core/dump.py index d761f7008..b33a6b279 100644 --- a/lib/core/dump.py +++ b/lib/core/dump.py @@ -530,6 +530,17 @@ class Dump(object): else: count += 1 + # Note: appending to HTML means adding rows to the existing table (i.e. not appending a whole new document) + if appendToFile and conf.dumpFormat == DUMP_FORMAT.HTML: + with openFile(dumpFileName, "r") as f: + content = f.read() + + if "" in content: + with openFile(dumpFileName, "w+") as f: + f.write(content[:content.rindex("")]) + else: + appendToFile = False + self._dumpFiles[dumpFileName] = table dumpFP = openFile(dumpFileName, 'w' if not appendToFile else 'a', buffering=DUMP_FILE_BUFFER_SIZE) @@ -603,7 +614,7 @@ class Dump(object): cols.append((unsafeSQLIdentificatorNaming(column), colType if colType else Replication.TEXT)) rtable = replication.createTable(table, cols) - elif conf.dumpFormat == DUMP_FORMAT.HTML: + elif conf.dumpFormat == DUMP_FORMAT.HTML and not appendToFile: dataToDumpFile(dumpFP, "\n\n\n") dataToDumpFile(dumpFP, "\n" % UNICODE_ENCODING) dataToDumpFile(dumpFP, "\n" % VERSION_STRING) @@ -639,7 +650,7 @@ class Dump(object): field += 1 - if conf.dumpFormat == DUMP_FORMAT.HTML: + if conf.dumpFormat == DUMP_FORMAT.HTML and not appendToFile: dataToDumpFile(dumpFP, "\n\n\n\n") self._write("|\n%s" % separator) diff --git a/lib/core/settings.py b/lib/core/settings.py index bc6276c15..610410e75 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.71" +VERSION = "1.10.11.72" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From e2c36885f071f014f7e84f1a1761e41f948e9998 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 17:39:06 +0100 Subject: [PATCH 77/93] Fix for misleading WAF fingerprinting warning with --esperanto --- lib/controller/action.py | 2 +- lib/core/settings.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/controller/action.py b/lib/controller/action.py index daea4e76c..01be69310 100644 --- a/lib/controller/action.py +++ b/lib/controller/action.py @@ -48,7 +48,7 @@ def action(): # automatic WAF-bypass: fingerprinting probes are kept off the WAF/IPS blacklists, so it is tried # first even behind a protection. Only if it comes back empty the back-end DBMS is assumed from # the error page or the heuristic checks, so that the user still gets a usable result - if kb.wafBypass and not conf.forceDbms and not Backend.getIdentifiedDbms(): + if kb.wafBypass and not conf.forceDbms and not conf.esperanto and not Backend.getIdentifiedDbms(): # Note: --esperanto does its own (generic) back-end identification fallback = Backend.getErrorParsedDBMSes() or ([kb.heuristicDbms] if kb.heuristicDbms else []) fallback = next((_ for _ in fallback if _ and _.lower() in SUPPORTED_DBMS), None) if fallback: diff --git a/lib/core/settings.py b/lib/core/settings.py index 610410e75..1861d4e59 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.72" +VERSION = "1.10.11.73" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 937f2b11b19fd3880ed11d8c3acebdcf53d83bdf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 19:03:46 +0100 Subject: [PATCH 78/93] Fix for MSSQL OFFSET/FETCH paging in SQL queries (e.g. --sql-query) with blind techniques --- lib/core/agent.py | 15 ++++++++++++--- lib/core/settings.py | 2 +- 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/lib/core/agent.py b/lib/core/agent.py index 1d3940e5a..a008ca6d1 100644 --- a/lib/core/agent.py +++ b/lib/core/agent.py @@ -1073,6 +1073,9 @@ class Agent(object): topLimit = re.search(r"TOP\s+([\d]+)\s+", expression, re.I) + # Note: Microsoft SQL Server 2012+ paging (e.g. 'ORDER BY id OFFSET 2 ROWS FETCH NEXT 2 ROWS ONLY') + offsetFetch = re.search(r"(?i)\s+OFFSET\s+(?P\d+)\s+ROWS?\s+FETCH\s+(?:NEXT|FIRST)\s+(?P\d+)\s+ROWS?\s+ONLY", expression) if Backend.isDbms(DBMS.MSSQL) else None + limitRegExp = re.search(queries[Backend.getIdentifiedDbms()].limitregexp.query, expression, re.I) if hasattr(queries[Backend.getIdentifiedDbms()].limitregexp, "query2"): @@ -1086,7 +1089,7 @@ class Agent(object): # ClickHouse) and per-row extraction (blind/error) reads bogus offsets - only UNION was unaffected. limitOffsetAppendDbmses = (DBMS.MYSQL, DBMS.PGSQL, DBMS.SQLITE, DBMS.H2, DBMS.CLICKHOUSE, DBMS.CRATEDB, DBMS.SPANNER, DBMS.HANA) - if (limitRegExp or limitRegExp2) or (Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE) and topLimit): + if (limitRegExp or limitRegExp2 or offsetFetch) or (Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE) and topLimit): if Backend.getIdentifiedDbms() in limitOffsetAppendDbmses: limitGroupStart = queries[Backend.getIdentifiedDbms()].limitgroupstart.query limitGroupStop = queries[Backend.getIdentifiedDbms()].limitgroupstop.query @@ -1109,7 +1112,11 @@ class Agent(object): limitCond = int(stopLimit) > 1 elif Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE): - if limitRegExp: + if offsetFetch: + startLimit = int(offsetFetch.group("start")) + stopLimit = offsetFetch.group("stop") + limitCond = int(stopLimit) > 1 + elif limitRegExp: limitGroupStart = queries[Backend.getIdentifiedDbms()].limitgroupstart.query limitGroupStop = queries[Backend.getIdentifiedDbms()].limitgroupstop.query @@ -1130,7 +1137,7 @@ class Agent(object): # (or equivalent depending on the back-end DBMS) can return # multiple entries if limitCond: - if (limitRegExp or limitRegExp2) and stopLimit is not None: + if (limitRegExp or limitRegExp2 or offsetFetch) and stopLimit is not None: stopLimit = int(stopLimit) # From now on we need only the expression until the " LIMIT " @@ -1147,6 +1154,8 @@ class Agent(object): elif Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE): stopLimit += startLimit + if offsetFetch: + expression = expression[:offsetFetch.start()] elif dump: if conf.limitStart: startLimit = conf.limitStart - 1 diff --git a/lib/core/settings.py b/lib/core/settings.py index 1861d4e59..43a5b4055 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.73" +VERSION = "1.10.11.74" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 6206e15d137096070232be5aa53bfef674744074 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 19:05:19 +0100 Subject: [PATCH 79/93] Adding check for --priv-esc without corresponding takeover switch --- lib/core/option.py | 4 ++++ lib/core/settings.py | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/lib/core/option.py b/lib/core/option.py index e123c5e1d..8e5662e79 100644 --- a/lib/core/option.py +++ b/lib/core/option.py @@ -3058,6 +3058,10 @@ def _basicOptionValidation(): errMsg = "option '--crawl-exclude' requires usage of switch '--crawl'" raise SqlmapSyntaxException(errMsg) + if conf.privEsc and not any((conf.osPwn, conf.osSmb, conf.osBof)): + errMsg = "switch '--priv-esc' requires usage of switch '--os-pwn', '--os-smbrelay' or '--os-bof'" + raise SqlmapSyntaxException(errMsg) + if conf.safePost and not conf.safeUrl: errMsg = "option '--safe-post' requires usage of option '--safe-url'" raise SqlmapSyntaxException(errMsg) diff --git a/lib/core/settings.py b/lib/core/settings.py index 43a5b4055..efb8ab228 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.74" +VERSION = "1.10.11.75" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 2351bd82dd5b2d8d62446705540b6da1200da331 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 19:05:50 +0100 Subject: [PATCH 80/93] Fix for --not-string not supporting escape sequences (e.g. '\t'), as --string does --- lib/core/option.py | 3 +++ lib/core/settings.py | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/lib/core/option.py b/lib/core/option.py index 8e5662e79..5a235f44c 100644 --- a/lib/core/option.py +++ b/lib/core/option.py @@ -2107,6 +2107,9 @@ def _cleanupOptions(): if conf.string: conf.string = decodeStringEscape(conf.string) + if conf.notString: + conf.notString = decodeStringEscape(conf.notString) + if conf.getAll: for _ in WIZARD.ALL: conf.__setitem__(_, True) diff --git a/lib/core/settings.py b/lib/core/settings.py index efb8ab228..851ac0b27 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.75" +VERSION = "1.10.11.76" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 32edb6a45eea033e28d1226e408108026c69eb8e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 19:08:34 +0100 Subject: [PATCH 81/93] Treating Cookie header provided with -H/--headers as --cookie (i.e. testable Cookie parameters) --- lib/core/option.py | 6 +++++- lib/core/settings.py | 2 +- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/lib/core/option.py b/lib/core/option.py index 5a235f44c..9d7345274 100644 --- a/lib/core/option.py +++ b/lib/core/option.py @@ -1641,7 +1641,11 @@ def _setHTTPExtraHeaders(): header, value = (_.lstrip() for _ in headerValue.split(":", 1)) if header and value: - conf.httpHeaders.append((header, value)) + # Note: Cookie header provided this way is treated as --cookie (i.e. its parameters become testable) + if header.upper() == HTTP_HEADER.COOKIE.upper() and not conf.cookie: + conf.cookie = value + else: + conf.httpHeaders.append((header, value)) else: errMsg = "invalid header value: %s. Valid header format is 'name:value'" % repr(headerValue).lstrip('u') raise SqlmapSyntaxException(errMsg) diff --git a/lib/core/settings.py b/lib/core/settings.py index 851ac0b27..2493859f8 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.76" +VERSION = "1.10.11.77" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 6f06df414bc64966f7d0033ba42d14ee6c508ecf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 19:10:00 +0100 Subject: [PATCH 82/93] Adding warning for -p being ignored in case of custom injection markers --- lib/core/settings.py | 2 +- lib/core/target.py | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 2493859f8..9f2a30edc 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.77" +VERSION = "1.10.11.78" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/core/target.py b/lib/core/target.py index b11fb96ad..7ca0ae54c 100644 --- a/lib/core/target.py +++ b/lib/core/target.py @@ -329,6 +329,10 @@ def _setRequestParams(): if kb.processUserMarks: kb.testOnlyCustom = True + if conf.testParameter: + warnMsg = "option '-p' is ignored as only the custom injection marker(s) ('%s') will be tested" % kb.customInjectionMark + logger.warning(warnMsg) + if "=%s" % kb.customInjectionMark in _: warnMsg = "it seems that you've provided empty parameter value(s) " warnMsg += "for testing. Please, always use only valid parameter values " From b3608f33caadff2e355b8d0cda66f66b2a38ae3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 19:25:55 +0100 Subject: [PATCH 83/93] Fix for --oob-server with scheme (e.g. 'https://https://host/register') and self-signed certificates --- lib/core/settings.py | 2 +- lib/request/interactsh.py | 26 +++++++++++++++++++------- 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 9f2a30edc..e405a32ba 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.78" +VERSION = "1.10.11.79" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/interactsh.py b/lib/request/interactsh.py index f7faa5bc4..4c58097d8 100644 --- a/lib/request/interactsh.py +++ b/lib/request/interactsh.py @@ -49,6 +49,16 @@ class Interactsh(object): def __init__(self, server=None, token=None): self.server = None self.token = token or conf.get("oobToken") + self._scheme = "https" + self._ownServer = bool(server) + + # Note: explicitly provided server can come with a scheme (e.g. 'http://oob.example.com/') - the rest is used as the (callback) host + if server: + server = server.strip() + for scheme in ("https", "http"): + if server.lower().startswith("%s://" % scheme): + self._scheme, server = scheme, server[len(scheme) + len("://"):] + server = server.rstrip('/') # Note: (private) token belongs only to an explicitly provided server (i.e. never to be sent to a public one) if self.token and not server: @@ -78,12 +88,15 @@ class Interactsh(object): if not candidate: continue body = json.dumps({"public-key": pubKey, "secret-key": self.secret, "correlation-id": self.correlationId}) - if self._request("https://%s/register" % candidate, post=body): + if self._request("%s://%s/register" % (self._scheme, candidate), post=body): self.server = candidate self.registered = True logger.debug("registered with OOB interaction server '%s'" % candidate) break + if self._ownServer and not self.registered: + logger.warning("unable to register with the provided OOB server '%s://%s'" % (self._scheme, server)) + def _request(self, url, post=None): """Direct request to the interactsh server (a fixed service, never the target). Self-contained on urllib so it works regardless of sqlmap's request-stack init @@ -103,11 +116,10 @@ class Interactsh(object): handlers = [] try: - # Verify TLS for the (public, valid-cert) interaction server by default; - # only skip verification when the user has globally opted out (--force-ssl-verify - # off / verifyCert False), matching sqlmap's own TLS posture. + # Note: TLS is verified for the (built-in) public interaction servers, while the explicitly + # provided (own) server is treated as any other target (i.e. self-signed certificates are fine) context = ssl.create_default_context() - if conf.get("verifyCert") is False: + if getattr(self, "_ownServer", False): context.check_hostname = False context.verify_mode = ssl.CERT_NONE handlers.append(HTTPSHandler(context=context)) @@ -265,7 +277,7 @@ class Interactsh(object): if not self.registered: return [] - page = self._request("https://%s/poll?id=%s&secret=%s" % (self.server, self.correlationId, self.secret)) + page = self._request("%s://%s/poll?id=%s&secret=%s" % (getattr(self, "_scheme", "https"), self.server, self.correlationId, self.secret)) if not page: return [] @@ -346,7 +358,7 @@ class Interactsh(object): def _deregister(self): if self.registered: body = json.dumps({"correlation-id": self.correlationId, "secret-key": self.secret}) - self._request("https://%s/deregister" % self.server, post=body) + self._request("%s://%s/deregister" % (getattr(self, "_scheme", "https"), self.server), post=body) self.registered = False From d115a0a4cf5acbc1dc94ab87f0f0b3342b3f62fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 19:28:07 +0100 Subject: [PATCH 84/93] Fix for --oob-server (own) silently allowing usage of public service (webhook.site) for XXE file exfiltration --- lib/core/settings.py | 2 +- lib/techniques/xxe/inject.py | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index e405a32ba..57f5d7b0f 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.79" +VERSION = "1.10.11.80" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/techniques/xxe/inject.py b/lib/techniques/xxe/inject.py index 042177be5..3c2c3aa2a 100644 --- a/lib/techniques/xxe/inject.py +++ b/lib/techniques/xxe/inject.py @@ -821,6 +821,13 @@ def _tryOobExfil(xml, rootName): if not fileName: return None + # Note: provided (own) OOB server is not a consent for contacting a public service (needed for hosting of the external DTD) + if conf.get("oobServer"): + message = "file exfiltration requires hosting of an external DTD, which provided OOB server can't do. " + message += "Do you want to use public service (webhook.site) for that? [y/N] " + if not readInput(message, default='N', boolean=True): + return None + wh = WebhookSite() exfilToken = wh.newToken() if not exfilToken: From c12c457ac11e30a8d4b6d6edab362d3de9f095b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 19:33:52 +0100 Subject: [PATCH 85/93] Fix for SSTI --os-cmd output being URL/HTML decoded (now exact, regardless of engine's autoescaping) --- lib/core/settings.py | 2 +- lib/techniques/ssti/inject.py | 20 ++++++++++++++++++-- 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 57f5d7b0f..25c67992e 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.80" +VERSION = "1.10.11.81" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/techniques/ssti/inject.py b/lib/techniques/ssti/inject.py index aed7e2fc1..c853876b8 100644 --- a/lib/techniques/ssti/inject.py +++ b/lib/techniques/ssti/inject.py @@ -15,7 +15,9 @@ from lib.core.common import beep from lib.core.common import randomInt from lib.core.common import randomStr from lib.core.convert import getUnicode +from lib.core.convert import htmlUnescape from lib.core.data import conf +from lib.core.data import kb from lib.core.data import logger from lib.core.enums import CUSTOM_LOGGING from lib.core.enums import HTTP_HEADER @@ -816,7 +818,8 @@ def _winChallenge(a, b): def _unixFramed(cmd, sa, sb, ea, eb): # printf concatenates its two %s (sa+sb / ea+eb) at runtime; the request carries them separated - return "printf %%s%%s %s %s; %s; printf %%s%%s %s %s" % (sa, sb, cmd, ea, eb) + # Note: a '<' canary is printed right after the start marker - it reveals whether the engine HTML-escapes the output + return "printf %%s%%s %s %s; printf %%s \\<; %s; printf %%s%%s %s %s" % (sa, sb, cmd, ea, eb) def _winFramed(cmd, sa, sb, ea, eb): @@ -1017,11 +1020,24 @@ def _executeCommand(place, parameter, engine, cmd): framedCmd = _escapeSingleQuoted(framed(cmd, sa, sb, ea, eb)) for payloadTemplate, description in engine.rcePayloads: payload = payloadTemplate.replace("{CMD}", framedCmd) - page = getUnicode(_send(place, parameter, original + payload) or "") + + # Note: raw page (i.e. without sqlmap's generic decoding, which would e.g. turn a genuine '%41' into 'A') + disableHtmlDecoding = kb.disableHtmlDecoding + kb.disableHtmlDecoding = _family == "unix" + try: + page = getUnicode(_send(place, parameter, original + payload) or "") + finally: + kb.disableHtmlDecoding = disableHtmlDecoding + out = _framedOutput(page, start, end) # Note: without a shell (e.g. Java's Runtime.exec) printf recycles its format over the rest of the (unexecuted) command # line (e.g. ';id;printf%s%s'), "reproducing" both markers by itself - leftover format is the telltale if out is not None and "%s%s" not in out: + if _family == "unix": + if out.startswith("<"): # engine HTML-escaped the output (e.g. Jinja2 with autoescaping) + out = htmlUnescape(out[len("<"):]).strip() + elif out.startswith("<"): # raw output + out = out[len("<"):].strip() conf.dumper.singleString("\nos-shell (%s) [%s]:\n%s" % (cmd, description, out)) return From 498553d04ec8d8c50d3482e2904640804d565c91 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 19:44:47 +0100 Subject: [PATCH 86/93] Fix for double encoding of original value in JSON/XML (POST) bodies (e.g. 'C:\\temp', 'a&b') --- lib/core/agent.py | 14 +++++++++++++- lib/core/settings.py | 2 +- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/lib/core/agent.py b/lib/core/agent.py index a008ca6d1..d38765dea 100644 --- a/lib/core/agent.py +++ b/lib/core/agent.py @@ -5,6 +5,7 @@ Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org) See the file 'LICENSE' for copying permission """ +import json import re from lib.core.common import Backend @@ -29,6 +30,7 @@ from lib.core.common import zeroDepthSearch from lib.core.compat import xrange from lib.core.convert import encodeBase64 from lib.core.convert import getUnicode +from lib.core.convert import htmlUnescape from lib.core.data import conf from lib.core.data import kb from lib.core.data import queries @@ -137,6 +139,7 @@ class Agent(object): paramString = conf.parameters[place] paramDict = conf.paramDict[place] origValue = getUnicode(paramDict[parameter]) + lookupValue = None newValue = getUnicode(newValue) if newValue else newValue try: # Dirty patch for Python 3.14.7 re.sub() regression (e.g. https://github.com/sqlmapproject/sqlmap/issues/6128) @@ -160,12 +163,21 @@ class Agent(object): elif place == PLACE.CUSTOM_POST: paramString = origValue origValue = origValue.split(kb.customInjectionMark)[0] + # Note: original value is taken in its raw (decoded) form, as the whole payload (including it) gets (re)encoded later on (connect.py) if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML): origValue = re.split(r"['\">]", origValue)[-1] + lookupValue = origValue + origValue = htmlUnescape(origValue) if '&' in origValue else origValue elif kb.postHint in (POST_HINT.JSON, POST_HINT.JSON_LIKE, POST_HINT.GRPC_WEB): match = re.search(r"['\"]", origValue) quote = match.group(0) if match else '"' origValue = extractRegexResult(r"%s\s*:\s*(?P\d+)\Z" % quote, origValue) or extractRegexResult(r"(?P[^%s]*)\Z" % quote, origValue) + lookupValue = origValue + if quote == '"' and kb.postHint != POST_HINT.JSON_LIKE and '\\' in (origValue or ""): + try: + origValue = json.loads('"%s"' % origValue) + except ValueError: + pass else: _ = extractRegexResult(r"(?s)(?P[^\s<>{}();'\"&]+\Z)", origValue) or "" origValue = _.split('=', 1)[1] if '=' in _ else _ @@ -233,7 +245,7 @@ class Agent(object): origValue = encodeBase64(origValue, binary=False, encoding=conf.encoding or UNICODE_ENCODING) if place in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER): - _ = "%s%s" % (_origValue if base64Encoding else origValue, kb.customInjectionMark) + _ = "%s%s" % (_origValue if base64Encoding else (origValue if lookupValue is None else lookupValue), kb.customInjectionMark) # Note: raw value (as found in the request) for the lookup if kb.postHint in (POST_HINT.JSON, POST_HINT.GRPC_WEB) and isNumber(origValue) and not isNumber(newValue) and '"%s"' % _ not in paramString: newValue = '"%s"' % self.addPayloadDelimiters(newValue) diff --git a/lib/core/settings.py b/lib/core/settings.py index 25c67992e..c63ae2343 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.81" +VERSION = "1.10.11.82" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From 3325240680bed4a562934188c8f1a0d7f925e71e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 19:46:38 +0100 Subject: [PATCH 87/93] Fix for JSON string values ending with escaped backslash breaking payload placement --- lib/core/settings.py | 2 +- lib/core/target.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index c63ae2343..3fa82e388 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.82" +VERSION = "1.10.11.83" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/core/target.py b/lib/core/target.py index 7ca0ae54c..f650f3e2c 100644 --- a/lib/core/target.py +++ b/lib/core/target.py @@ -180,7 +180,8 @@ def _setRequestParams(): if not (kb.processUserMarks and kb.customInjectionMark in conf.data): conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data) conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER) - conf.data = re.sub(r'("(?P[^"]+)"\s*:\s*".*?)"(?%s"' % kb.customInjectionMark), conf.data) + # Note: proper JSON string matching (e.g. "x\\" ends with an escaped backslash, not with an escaped quote) + conf.data = re.sub(r'("(?P[^"]+)"\s*:\s*"(?:[^"\\]|\\.)*)"', functools.partial(process, repl=r'\g<1>%s"' % kb.customInjectionMark), conf.data) conf.data = re.sub(r'("(?P[^"]+)"\s*:\s*")"', functools.partial(process, repl=r'\g<1>%s"' % kb.customInjectionMark), conf.data) conf.data = re.sub(r'("(?P[^"]+)"\s*:\s*)(-?\d[\d\.]*)\b', functools.partial(process, repl=r'\g<1>\g<3>%s' % kb.customInjectionMark), conf.data) conf.data = re.sub(r'("(?P[^"]+)"\s*:\s*)((true|false|null))\b', functools.partial(process, repl=r'\g<1>\g<3>%s' % kb.customInjectionMark), conf.data) From 70702c2ce3718f074d9420f9cb2cb07f343a87f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 19:55:05 +0100 Subject: [PATCH 88/93] Fix for SQLite error-based retrieval doubling single quotes (e.g. x"y''z) --- lib/core/settings.py | 2 +- lib/techniques/error/use.py | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 3fa82e388..2bcd0df98 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.83" +VERSION = "1.10.11.84" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/techniques/error/use.py b/lib/techniques/error/use.py index f89b5afee..8062d3b29 100644 --- a/lib/techniques/error/use.py +++ b/lib/techniques/error/use.py @@ -213,6 +213,10 @@ def _oneShotErrorUse(expression, field=None, chunkTest=False): if isinstance(retVal, six.string_types): retVal = htmlUnescape(retVal).replace("
", "\n") + # Note: SQLite's error message of JSON_EXTRACT (e.g. "bad JSON path: '...'") quotes the (path) value by doubling its single quotes + if Backend.isDbms(DBMS.SQLITE) and not conf.hexConvert and "JSON_EXTRACT" in (getTechniqueData().vector or ""): + retVal = retVal.replace("''", "'") + retVal = _errorReplaceChars(retVal) if retVal is not None: From bd8df65b53651055fd082c0320e85002f0de9eb8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 20:06:16 +0100 Subject: [PATCH 89/93] Fix for --hql payloads not being URL encoded (special characters like '+', '&' extracted as '?') --- lib/core/settings.py | 2 +- lib/techniques/hql/inject.py | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 2bcd0df98..dad3e3bd2 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.84" +VERSION = "1.10.11.85" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/techniques/hql/inject.py b/lib/techniques/hql/inject.py index f880e497a..f728462c7 100644 --- a/lib/techniques/hql/inject.py +++ b/lib/techniques/hql/inject.py @@ -37,6 +37,7 @@ from lib.core.settings import HQL_MAX_RECORDS from lib.core.settings import UPPER_RATIO_BOUND from lib.request.connect import Connect as Request from lib.utils.xrange import xrange +from thirdparty.six.moves.urllib.parse import quote as _quote SENTINEL = randomStr(length=10, lowercase=True) @@ -126,7 +127,8 @@ def _send(place, parameter, value): time.sleep(conf.delay) old_params = conf.parameters.get(place, "") - conf.parameters[place] = _replaceSegment(place, parameter, value) + # Note: URL encoded value (raw '+', '&', '%', '#', '?' would be misinterpreted), as with other non-SQL engines (e.g. OData) + conf.parameters[place] = _replaceSegment(place, parameter, _quote(value, safe="")) try: if conf.verbose >= 3: @@ -406,11 +408,9 @@ for _ in xrange(HQL_CHAR_MIN, HQL_CHAR_MAX + 1): # Charset as an HQL string literal for LOCATE()-based binary search: each character's # 1-based index inside this literal is recovered by bisection (~log2(n) requests vs a # linear equality scan), and LOCATE is an index lookup so no lexicographic ordering / -# collation assumption is introduced. URL-structural bytes (%, &, +, #, ?) are excluded -# because they cannot survive a raw GET/POST value; such a byte is surfaced as '?' (as -# it was under the previous linear scan). ', ", \ are already excluded above. -_URL_HOSTILE = set(ord(_) for _ in "%&+#?") -_CS_LITERAL = "".join(chr(_) for _ in _CHARSET if _ not in _URL_HOSTILE) +# collation assumption is introduced. URL-structural bytes (%, &, +, #, ?) are fine, as +# values are URL encoded by _send(). ', ", \ are already excluded above. +_CS_LITERAL = "".join(chr(_) for _ in _CHARSET) def _scalar(entity, attrExpr, pin, after=None): From f4a4ae502723eb2873649c5a0da5ad17fcedab9e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 20:06:17 +0100 Subject: [PATCH 90/93] Fix for vulnserver double decoding POST parameters (e.g. encoded '&' splitting values) --- extra/vulnserver/vulnserver.py | 6 ++++-- lib/core/settings.py | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/extra/vulnserver/vulnserver.py b/extra/vulnserver/vulnserver.py index b348a1c93..0666edc48 100644 --- a/extra/vulnserver/vulnserver.py +++ b/extra/vulnserver/vulnserver.py @@ -1227,7 +1227,8 @@ class ReqHandler(BaseHTTPRequestHandler): params.update(dict((_[0], _[1].replace("'", "'").replace(""", '"').replace("<", '<').replace(">", '>').replace("&", '&')) for _ in re.findall(r'name="([^"]+)" value="([^"]*)"', self.data))) else: self.data = self.data.replace(';', '&') # Note: seems that Python3 started ignoring parameter splitting with ';' - params.update(parse_qs(self.data)) + # Note: parsing the raw (i.e. not yet URL decoded) body, otherwise encoded '&'/'=' inside values would split them + params.update(parse_qs((getattr(self, "rawData", None) or self.data).replace(';', '&'))) for name in self.headers: params[name.lower()] = self.headers[name] @@ -1748,7 +1749,8 @@ class ReqHandler(BaseHTTPRequestHandler): length = int(self.headers.get("Content-length", 0)) if length: data = self.rfile.read(length) - data = unquote_plus(data.decode(UNICODE_ENCODING, "ignore")) + self.rawData = data.decode(UNICODE_ENCODING, "ignore") + data = unquote_plus(self.rawData) self.data = data elif self.headers.get("Transfer-encoding") == "chunked": data, line = b"", b"" diff --git a/lib/core/settings.py b/lib/core/settings.py index dad3e3bd2..d53e6fb14 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.85" +VERSION = "1.10.11.86" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) From f84b7fb70a320ed15d57ed530176cbd5f1e3d889 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 20:07:55 +0100 Subject: [PATCH 91/93] Adding warning for (unsupported) DISTINCT in provided SQL queries --- lib/core/settings.py | 2 +- lib/request/inject.py | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index d53e6fb14..500f2f14d 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.86" +VERSION = "1.10.11.87" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/inject.py b/lib/request/inject.py index 81a782f07..2be4fcc9f 100644 --- a/lib/request/inject.py +++ b/lib/request/inject.py @@ -677,6 +677,8 @@ def getValue(expression, blind=True, union=True, error=True, time=True, fromUser count = 0 if query and not re.search(r"COUNT.*FROM.*\(.*DISTINCT", query, re.I): + if fromUser and re.search(r"(?i)\bDISTINCT\b", query): + singleTimeWarnMessage("DISTINCT is not supported in provided SQL queries (results can contain duplicates)") query = query.replace("DISTINCT ", "") if not conf.forceDns: From 8b78b676c1376ae28feccd957b03bbecea05eff1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 12 Nov 2026 20:52:57 +0100 Subject: [PATCH 92/93] Adding vuln-test coverage for --multi-bit and --timeless (vulnserver listing and HTTP/2 endpoints) --- .github/workflows/tests.yml | 7 +- extra/vulnserver/vulnserver.py | 124 +++++++++++++++++++++++++++++++++ lib/core/settings.py | 2 +- lib/core/testing.py | 34 ++++++++- 4 files changed, 161 insertions(+), 6 deletions(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 98dedd5cd..9955c1ad2 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -97,13 +97,14 @@ jobs: - name: Basic import test run: python -c "import sqlmap; import sqlmapapi" - - name: Install optional test deps (lxml, jinja2) + - name: Install optional test deps (lxml, jinja2, h2, cryptography) # lxml has no PyPy-2.7 wheel and 5.x is Py3-only, so it cannot be pip-installed there. The # tests that use it (test_xpath's real-XPath checks, and the --xpath/--ssti vuln-test # endpoints) skip themselves when the engine is unavailable, so these deps are only needed - # on the Py3 jobs. + # on the Py3 jobs. Same for h2/cryptography (vulnserver's HTTP/2 endpoint for --timeless and + # the reference-peer checks in test_http2). if: matrix.python-version != 'pypy-2.7' - run: python -m pip install -q lxml jinja2 + run: python -m pip install -q lxml jinja2 h2 cryptography - name: Unit tests # -B: do not write .pyc files. On Python 2 / PyPy a cached .pyc makes a module's __file__ diff --git a/extra/vulnserver/vulnserver.py b/extra/vulnserver/vulnserver.py index 0666edc48..d8564abb9 100644 --- a/extra/vulnserver/vulnserver.py +++ b/extra/vulnserver/vulnserver.py @@ -1492,6 +1492,22 @@ class ReqHandler(BaseHTTPRequestHandler): self.wfile.write(json.dumps({"error": {"message": str(ex)}}).encode(UNICODE_ENCODING)) return + if self.url == "/list": + # VULNERABLE: listing page whose (number of) rows depends on the injected 'min' value (e.g. for --multi-bit) + try: + with _lock: + _cursor.execute("SELECT id,name FROM users WHERE id>%s ORDER BY id" % self.params.get("min", "0")) + rows = _cursor.fetchall() + output = "
    %s
" % "".join("
  • %s
  • " % (row[0], row[1]) for row in rows) + except Exception: + output = "error" + self.send_response(OK) + self.send_header("Content-type", "text/html; charset=%s" % UNICODE_ENCODING) + self.send_header("Connection", "close") + self.end_headers() + self.wfile.write(output.encode(UNICODE_ENCODING)) + return + if self.url == "/echo": # A pure reflector: no engine of any kind behind it, it only shows the parameter back. Every # non-SQL switch must stay silent here. A differential built on "the page changed" is @@ -1776,6 +1792,114 @@ class ReqHandler(BaseHTTPRequestHandler): def log_message(self, format, *args): return +def run_h2(address=LISTEN_ADDRESS, port=LISTEN_PORT + 1): + """ + Optional HTTP/2 (TLS) endpoint '/?id=1' (e.g. for --http2/--timeless), requiring 'h2' and 'cryptography' + Note: each stream is answered on its own thread with its own database connection (i.e. in order of completion) + """ + + import datetime + import socket + import ssl + + import h2.config + import h2.connection + import h2.events + + from cryptography import x509 + from cryptography.hazmat.primitives import hashes + from cryptography.hazmat.primitives import serialization + from cryptography.hazmat.primitives.asymmetric import ec + from cryptography.x509.oid import NameOID + + key = ec.generate_private_key(ec.SECP256R1()) + name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, u"localhost")]) + now = datetime.datetime.utcnow() + cert = x509.CertificateBuilder().subject_name(name).issuer_name(name).public_key(key.public_key()).serial_number(x509.random_serial_number()).not_valid_before(now - datetime.timedelta(days=1)).not_valid_after(now + datetime.timedelta(days=1)).sign(key, hashes.SHA256()) + + handle, certFile = tempfile.mkstemp(suffix=".pem") + os.close(handle) + with open(certFile, "wb") as f: + f.write(cert.public_bytes(serialization.Encoding.PEM)) + f.write(key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8, serialization.NoEncryption())) + + context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) + context.load_cert_chain(certFile) + context.set_alpn_protocols(["h2"]) + local = threading.local() + + def _respond(conn, lock, sock, streamId, path): + if not hasattr(local, "db"): + local.db = sqlite3.connect(":memory:") + local.db.executescript(SCHEMA) + + try: + value = parse_qs(path.split('?', 1)[-1] if '?' in path else "").get("id", ["1"])[-1] + rows = local.db.execute("SELECT * FROM users WHERE id=%s LIMIT 0, 1" % value).fetchall() + status, body = "200", "%s" % "".join("%s" % _ for row in rows for _ in row) + except Exception as ex: + status, body = "500", "error: %s" % ex + + body = body.encode(UNICODE_ENCODING) + + with lock: + conn.send_headers(streamId, [(":status", status), ("content-length", str(len(body))), ("content-type", "text/html")]) + conn.send_data(streamId, body, end_stream=True) + sock.sendall(conn.data_to_send()) + + def _serve(sock): + conn = h2.connection.H2Connection(config=h2.config.H2Configuration(client_side=False)) + lock = threading.Lock() + paths = {} + + conn.initiate_connection() + sock.sendall(conn.data_to_send()) + + try: + while True: + data = sock.recv(65535) + if not data: + break + + with lock: + events = conn.receive_data(data) + sock.sendall(conn.data_to_send()) + + for event in events: + if isinstance(event, h2.events.RequestReceived): + paths[event.stream_id] = dict((_[0].decode() if isinstance(_[0], bytes) else _[0], _[1].decode() if isinstance(_[1], bytes) else _[1]) for _ in event.headers).get(":path", "/") + elif isinstance(event, h2.events.StreamEnded): + thread = threading.Thread(target=_respond, args=(conn, lock, sock, event.stream_id, paths.pop(event.stream_id, "/"))) + thread.daemon = True + thread.start() + except Exception: + pass + finally: + sock.close() + + server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + server.settimeout(None) # Note: independent of (e.g. sqlmap's) default socket timeout, which would end the accept loop once idle + server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + server.bind((address, port)) + server.listen(50) + + while True: + try: + client, _ = server.accept() + except socket.error: + continue + + try: + client.settimeout(None) + client = context.wrap_socket(client, server_side=True) + except Exception: + client.close() + continue + + thread = threading.Thread(target=_serve, args=(client,)) + thread.daemon = True + thread.start() + def run(address=LISTEN_ADDRESS, port=LISTEN_PORT): global _alive global _server diff --git a/lib/core/settings.py b/lib/core/settings.py index 500f2f14d..76ae2dafe 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.87" +VERSION = "1.10.11.88" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/core/testing.py b/lib/core/testing.py index b919605bc..1f71bc1ec 100644 --- a/lib/core/testing.py +++ b/lib/core/testing.py @@ -96,6 +96,8 @@ def vulnTest(tests=None, label="vuln"): ("-u \"&echo=foobar*\" --flush-session", ("might be vulnerable to cross-site scripting",)), ("-u \"nosql?name=luther&password=x\" -p password --nosql --flush-session", ("is vulnerable to NoSQL injection", "back-end: 'MongoDB'", "NoSQL: GET parameter 'password'", "s3cr3t")), # NoSQL (MongoDB) operator-injection detection + blind regexp extraction ("-u \"graphql\" --graphql -T creds --flush-session --disable-hashing", ("found GraphQL endpoint", "introspection returned", "enumerated 6 injectable argument slot(s): 4 query, 2 mutation", "SQL injection via GraphQL (boolean-based)", "in-band data exposure", "back-end DBMS: 'SQLite'", "banner: '3.", "GraphQL database tables", "fetched 30 entries from table 'creds'", "db3a16990a0008a3b04707fdef6584a0", "GraphQL scan complete")), # GraphQL: endpoint detection + introspection + query-slots-first (mutations only as fallback) + boolean-blind/in-band + back-end fingerprint + batched blind dump of an injection-only table (SQLite-backed) + ("-u \"list?min=0\" --multi-bit --technique=B -T users --dump --flush-session", ("carries a multi-bit channel", "30 entries", "luther")), # --multi-bit: a listing page whose rows depend on the injected value carries several bits per request + ("-u \"?id=1\" --http2 --technique=T --timeless --dbms=sqlite --level=3 --risk=2 --banner --time-sec=5 --flush-session", ("turning on HTTP/2 timeless timing", "banner: '3.")), # --timeless: (SQLite heavy-query) time-based blind read by HTTP/2 response order (Note: --time-sec=5 as heavy queries scale with it) ("-u \"ldap/search?q=x\" --ldap --flush-session --disable-hashing", ("is vulnerable to LDAP injection", "Title: LDAP in-band data exposure", "LDAP: GET parameter 'q' in-band entries", "in-band data exposure", "LDAP scan complete")), # LDAP: error-based detection (unbalanced paren) + boolean oracle + directory attribute extraction via blind substring probing ("-u \"echo?q=x\" --xslt --flush-session --disable-hashing", ("no parameter appears to be injectable", "~is vulnerable to")), # reflection is not evaluation: a pure echo endpoint must not satisfy any non-SQL engine's oracle ("-u \"echo?q=x\" --xpath --flush-session --disable-hashing", ("no parameter appears to be injectable", "~is vulnerable to")), # same gate for --xpath (it used to confirm XPath injection from reflected text alone) @@ -133,6 +135,12 @@ def vulnTest(tests=None, label="vuln"): except ImportError: TESTS = tuple(_ for _ in TESTS if "--ssti" not in _[0]) logger.warning("skipping the SSTI vuln-test entry ('jinja2' not available)") + try: + __import__("h2") + __import__("cryptography") + except ImportError: + TESTS = tuple(_ for _ in TESTS if "" not in _[0]) + logger.warning("skipping the HTTP/2 vuln-test entry ('h2' or 'cryptography' not available)") # --test-filter / --test-skip narrow a (slow) full run to just the entries touching a change: # the needle is matched case-insensitively against each entry's command line and its expected @@ -236,6 +244,28 @@ def vulnTest(tests=None, label="vuln"): f.flush() base = "http://%s:%d/" % (address, port) + h2base = "" + + # optional HTTP/2 (TLS) endpoint (e.g. for --timeless) + if any("" in _[0] for _ in TESTS): + h2port = port + 1 if port < 65535 else port - 1 + thread = threading.Thread(target=vulnserver.run_h2, args=(address, h2port)) + thread.daemon = True + thread.start() + + for _ in xrange(20): + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + try: + if not s.connect_ex((address, h2port)): + h2base = "https://%s:%d/" % (address, h2port) + break + finally: + s.close() + time.sleep(0.5) + + if not h2base: + TESTS = tuple(_ for _ in TESTS if "" not in _[0]) + logger.warning("skipping the HTTP/2 vuln-test entry (unable to start HTTP/2 endpoint)") url = "%s?id=1" % base direct = "sqlite3://%s" % database tmpdir = tempfile.mkdtemp() @@ -260,10 +290,10 @@ def vulnTest(tests=None, label="vuln"): options = options.replace(u"\u0161u\u0107uraj", "sucuraj") checks = [check.replace(u"\u0161u\u0107uraj", "sucuraj") for check in checks] - for tag, value in (("", url), ("", base), ("", direct), ("", tmpdir), ("", request), ("", log), ("", multiple), ("", config), ("", url.replace("id=1", "id=MZ=%3d"))): + for tag, value in (("", url), ("", base), ("", direct), ("", tmpdir), ("", request), ("", log), ("", multiple), ("", config), ("", url.replace("id=1", "id=MZ=%3d")), ("", h2base)): options = options.replace(tag, value) - cmd = "%s \"%s\" %s --batch --non-interactive --debug --time-sec=1" % (sys.executable if ' ' not in sys.executable else '"%s"' % sys.executable, os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "sqlmap.py")), options) + cmd = "%s \"%s\" %s --batch --non-interactive --debug%s" % (sys.executable if ' ' not in sys.executable else '"%s"' % sys.executable, os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "sqlmap.py")), options, "" if "--time-sec" in options else " --time-sec=1") if "" in cmd: handle, tmp = tempfile.mkstemp() From 5db2e62884d91f3ed3b43ec55904737e4051e9d7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0tampar?= Date: Thu, 19 Nov 2026 15:06:30 +0100 Subject: [PATCH 93/93] Fixes #6185 --- lib/core/settings.py | 2 +- lib/request/redirecthandler.py | 5 +++++ tests/test_authrefresh.py | 23 +++++++++++++++++++++++ 3 files changed, 29 insertions(+), 1 deletion(-) diff --git a/lib/core/settings.py b/lib/core/settings.py index 76ae2dafe..081fee1a8 100644 --- a/lib/core/settings.py +++ b/lib/core/settings.py @@ -19,7 +19,7 @@ from lib.core.enums import OS from thirdparty import six # sqlmap version (...) -VERSION = "1.10.11.88" +VERSION = "1.10.11.89" TYPE = "dev" if VERSION.count('.') > 2 and VERSION.split('.')[-1] != '0' else "stable" TYPE_COLORS = {"dev": 33, "stable": 90, "pip": 34} VERSION_STRING = "sqlmap/%s#%s" % ('.'.join(VERSION.split('.')[:-1]) if VERSION.count('.') > 2 and VERSION.split('.')[-1] == '0' else VERSION, TYPE) diff --git a/lib/request/redirecthandler.py b/lib/request/redirecthandler.py index 32f65f992..e214e358e 100644 --- a/lib/request/redirecthandler.py +++ b/lib/request/redirecthandler.py @@ -10,6 +10,7 @@ import re import time import types +from lib.core.common import checkSameHost from lib.core.common import getHostHeader from lib.core.common import getSafeExString from lib.core.common import logHTTPTraffic @@ -180,6 +181,10 @@ class SmartRedirectHandler(_urllib.request.HTTPRedirectHandler): if conf.authRefresh and not authrefresh.sameOrigin(req.get_full_url(), redurl): req.headers = authrefresh.stripHeaders(req.headers) req.unredirected_hdrs = authrefresh.stripHeaders(req.unredirected_hdrs) + + # Note: credentials are not to be forwarded to a different host (like browsers, curl and requests do) (#6185) + if not checkSameHost(req.get_full_url(), redurl): + req.headers = dict((key, value) for key, value in req.headers.items() if key.upper() not in (HTTP_HEADER.COOKIE.upper(), HTTP_HEADER.AUTHORIZATION.upper())) result = _urllib.request.HTTPRedirectHandler.http_error_302(self, req, fp, code, msg, headers) except _urllib.error.HTTPError as ex: result = error = ex diff --git a/tests/test_authrefresh.py b/tests/test_authrefresh.py index 5aff5d687..9fe24f329 100644 --- a/tests/test_authrefresh.py +++ b/tests/test_authrefresh.py @@ -68,6 +68,7 @@ class _Handler(BaseHTTPServer.BaseHTTPRequestHandler): def do_POST(self): body = self.rfile.read(int(self.headers.get('Content-Length', '0'))) token = self.headers.get('X-Auth-Token') + self.server.credentials = (self.headers.get('Cookie'), self.headers.get('Authorization')) if self.path == '/refresh': self.server.refreshes += 1 code, body = 200, b'{"token":"fresh"}' @@ -270,6 +271,28 @@ class TestAuthRefresh(unittest.TestCase): other.server_close() thread.join(5) + def test_redirect_to_another_host_does_not_receive_credentials(self): + # Note: user-supplied Cookie/Authorization must not leak to a different host (#6185), while the same host keeps them + conf.authRefresh = None + conf.httpHeaders = [('X-Auth-Token', 'fresh'), ('Cookie', 'session=secret'), ('Authorization', 'Bearer secret')] + other = _Server(('127.0.0.1', 0), _Handler) + other.requests, other.token, other.expired = [], 'fresh', 0 + other.lock = threading.Lock() + other.syncExpired = False + thread = threading.Thread(target=other.serve_forever) + thread.daemon = True + thread.start() + try: + for host, expected in (('localhost', (None, None)), ('127.0.0.1', ('session=secret', 'Bearer secret'))): + other.credentials = None + self.server.redirect = 'http://%s:%d/landing' % (host, other.server_port) + Connect.getPage(url=conf.url.replace('/test', '/redirect')) + self.assertEqual(other.credentials, expected) + finally: + other.shutdown() + other.server_close() + thread.join(5) + def test_auth_refresh_latency_is_excluded_from_query_timing(self): import lib.request.connect as connect originalPage, originalDelta = Connect.getPage, connect.calculateDeltaSeconds