|
|
#!/usr/bin/env python
|
|
|
|
|
|
"""
|
|
|
Copyright (c) 2006-2024 sqlmap developers (https://sqlmap.org/)
|
|
|
See the file 'LICENSE' for copying permission
|
|
|
"""
|
|
|
|
|
|
import re # 导入re模块，用于正则表达式操作
|
|
|
|
|
|
from lib.core.agent import agent # 导入agent模块，用于处理注入请求
|
|
|
from lib.core.common import arrayizeValue # 导入arrayizeValue函数，用于将值转换为数组
|
|
|
from lib.core.common import Backend # 导入Backend类，用于获取后端数据库信息
|
|
|
from lib.core.common import filterPairValues # 导入filterPairValues函数，用于过滤键值对
|
|
|
from lib.core.common import getLimitRange # 导入getLimitRange函数，用于获取限制范围
|
|
|
from lib.core.common import isInferenceAvailable # 导入isInferenceAvailable函数，用于判断是否可以使用盲注
|
|
|
from lib.core.common import isNoneValue # 导入isNoneValue函数，用于判断值是否为None
|
|
|
from lib.core.common import isNumPosStrValue # 导入isNumPosStrValue函数，用于判断字符串是否为正整数
|
|
|
from lib.core.common import isTechniqueAvailable # 导入isTechniqueAvailable函数，用于判断注入技术是否可用
|
|
|
from lib.core.common import readInput # 导入readInput函数，用于安全地读取用户输入
|
|
|
from lib.core.common import safeSQLIdentificatorNaming # 导入safeSQLIdentificatorNaming函数，用于安全命名SQL标识符
|
|
|
from lib.core.common import safeStringFormat # 导入safeStringFormat函数，用于安全格式化字符串
|
|
|
from lib.core.common import unArrayizeValue # 导入unArrayizeValue函数，用于将数组转换为值
|
|
|
from lib.core.common import unsafeSQLIdentificatorNaming # 导入unsafeSQLIdentificatorNaming函数，用于不安全命名SQL标识符
|
|
|
from lib.core.data import conf # 导入conf对象，存储全局配置信息
|
|
|
from lib.core.data import kb # 导入kb对象，存储全局知识库信息
|
|
|
from lib.core.data import logger # 导入logger对象，用于记录日志
|
|
|
from lib.core.data import paths # 导入paths对象，存储路径信息
|
|
|
from lib.core.data import queries # 导入queries对象，存储查询语句信息
|
|
|
from lib.core.enums import CHARSET_TYPE # 导入CHARSET_TYPE枚举类，定义字符集类型
|
|
|
from lib.core.enums import DBMS # 导入DBMS枚举类，定义数据库类型
|
|
|
from lib.core.enums import EXPECTED # 导入EXPECTED枚举类，定义预期返回类型
|
|
|
from lib.core.enums import PAYLOAD # 导入PAYLOAD枚举类，定义Payload类型
|
|
|
from lib.core.exception import SqlmapMissingMandatoryOptionException # 导入SqlmapMissingMandatoryOptionException异常类，表示缺少必要选项
|
|
|
from lib.core.exception import SqlmapUserQuitException # 导入SqlmapUserQuitException异常类，表示用户退出
|
|
|
from lib.core.settings import CURRENT_DB # 导入CURRENT_DB常量，表示当前数据库
|
|
|
from lib.core.settings import METADB_SUFFIX # 导入METADB_SUFFIX常量，表示元数据后缀
|
|
|
from lib.core.settings import UPPER_CASE_DBMSES # 导入UPPER_CASE_DBMSES常量，表示需要转换为大写的数据库类型
|
|
|
from lib.request import inject # 导入inject模块，用于执行注入
|
|
|
from lib.utils.brute import columnExists # 导入columnExists函数，用于爆破列是否存在
|
|
|
from lib.utils.brute import tableExists # 导入tableExists函数，用于爆破表是否存在
|
|
|
from thirdparty import six # 导入six模块，用于Python2和Python3的兼容
|
|
|
|
|
|
class Search(object):
|
|
|
"""
|
|
|
This class defines search functionalities for plugins.
|
|
|
这个类定义了插件的搜索功能。
|
|
|
"""
|
|
|
|
|
|
def __init__(self):
|
|
|
pass # 初始化方法，此处为空
|
|
|
|
|
|
def searchDb(self):
|
|
|
"""
|
|
|
Searches for database names based on user input.
|
|
|
根据用户输入搜索数据库名称。
|
|
|
"""
|
|
|
foundDbs = [] # 初始化找到的数据库列表
|
|
|
rootQuery = queries[Backend.getIdentifiedDbms()].search_db # 获取当前数据库的搜索数据库查询
|
|
|
dbList = conf.db.split(',') # 获取用户输入的数据库列表，用逗号分割
|
|
|
|
|
|
if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
|
|
|
dbCond = rootQuery.inband.condition2 # 如果是MySQL且没有information_schema，则使用condition2
|
|
|
else:
|
|
|
dbCond = rootQuery.inband.condition # 否则使用condition
|
|
|
|
|
|
dbConsider, dbCondParam = self.likeOrExact("database") # 获取数据库搜索条件
|
|
|
|
|
|
for db in dbList: # 遍历数据库列表
|
|
|
values = [] # 初始化查询结果列表
|
|
|
db = safeSQLIdentificatorNaming(db) # 对数据库名称进行安全命名
|
|
|
|
|
|
if Backend.getIdentifiedDbms() in UPPER_CASE_DBMSES:
|
|
|
db = db.upper() # 如果是需要大写的数据库，则转换为大写
|
|
|
|
|
|
infoMsg = "searching database" # 初始化日志信息
|
|
|
if dbConsider == "1":
|
|
|
infoMsg += "s LIKE" # 如果是LIKE匹配，则添加LIKE
|
|
|
infoMsg += " '%s'" % unsafeSQLIdentificatorNaming(db) # 添加不安全的数据库名称
|
|
|
logger.info(infoMsg) # 打印日志信息
|
|
|
|
|
|
if conf.excludeSysDbs: # 如果排除系统数据库
|
|
|
exclDbsQuery = "".join(" AND '%s' != %s" % (unsafeSQLIdentificatorNaming(db), dbCond) for db in self.excludeDbsList) # 构建排除系统数据库的SQL语句
|
|
|
infoMsg = "skipping system database%s '%s'" % ("s" if len(self.excludeDbsList) > 1 else "", ", ".join(db for db in self.excludeDbsList)) # 构建跳过系统数据库的日志信息
|
|
|
logger.info(infoMsg) # 打印跳过系统数据库的日志信息
|
|
|
else:
|
|
|
exclDbsQuery = "" # 如果不排除系统数据库，则SQL语句为空
|
|
|
|
|
|
dbQuery = "%s%s" % (dbCond, dbCondParam) # 构建数据库查询条件
|
|
|
dbQuery = dbQuery % unsafeSQLIdentificatorNaming(db) # 将数据库名称添加到查询条件中
|
|
|
|
|
|
# 如果支持UNION，ERROR或者QUERY注入，则使用带内注入
|
|
|
if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
|
|
|
if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
|
|
|
query = rootQuery.inband.query2 # 如果是MySQL且没有information_schema，则使用query2
|
|
|
else:
|
|
|
query = rootQuery.inband.query # 否则使用query
|
|
|
|
|
|
query = query % (dbQuery + exclDbsQuery) # 将查询条件添加到SQL语句中
|
|
|
values = inject.getValue(query, blind=False, time=False) # 执行SQL查询
|
|
|
|
|
|
if not isNoneValue(values): # 如果查询结果不为空
|
|
|
values = arrayizeValue(values) # 将查询结果转换为数组
|
|
|
|
|
|
for value in values: # 遍历查询结果
|
|
|
value = safeSQLIdentificatorNaming(value) # 对查询结果进行安全命名
|
|
|
foundDbs.append(value) # 将结果添加到找到的数据库列表中
|
|
|
|
|
|
# 如果带内注入失败，则尝试使用盲注
|
|
|
if not values and isInferenceAvailable() and not conf.direct:
|
|
|
infoMsg = "fetching number of database"
|
|
|
if dbConsider == "1":
|
|
|
infoMsg += "s LIKE" # 如果是LIKE匹配，则添加LIKE
|
|
|
infoMsg += " '%s'" % unsafeSQLIdentificatorNaming(db)
|
|
|
logger.info(infoMsg) # 打印日志信息
|
|
|
|
|
|
if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
|
|
|
query = rootQuery.blind.count2 # 如果是MySQL且没有information_schema，则使用count2
|
|
|
else:
|
|
|
query = rootQuery.blind.count # 否则使用count
|
|
|
|
|
|
query = query % (dbQuery + exclDbsQuery) # 将查询条件添加到SQL语句中
|
|
|
count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS) # 执行盲注，获取数据库数量
|
|
|
|
|
|
if not isNumPosStrValue(count): # 如果数据库数量不是正整数
|
|
|
warnMsg = "no database"
|
|
|
if dbConsider == "1":
|
|
|
warnMsg += "s LIKE" # 如果是LIKE匹配，则添加LIKE
|
|
|
warnMsg += " '%s' found" % unsafeSQLIdentificatorNaming(db)
|
|
|
logger.warning(warnMsg) # 打印日志信息
|
|
|
|
|
|
continue # 跳过当前数据库
|
|
|
|
|
|
indexRange = getLimitRange(count) # 获取索引范围
|
|
|
|
|
|
for index in indexRange: # 遍历索引范围
|
|
|
if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
|
|
|
query = rootQuery.blind.query2 # 如果是MySQL且没有information_schema，则使用query2
|
|
|
else:
|
|
|
query = rootQuery.blind.query # 否则使用query
|
|
|
|
|
|
query = query % (dbQuery + exclDbsQuery) # 将查询条件添加到SQL语句中
|
|
|
query = agent.limitQuery(index, query, dbCond) # 添加限制条件
|
|
|
|
|
|
value = unArrayizeValue(inject.getValue(query, union=False, error=False)) # 执行盲注，获取数据库名称
|
|
|
value = safeSQLIdentificatorNaming(value) # 对查询结果进行安全命名
|
|
|
foundDbs.append(value) # 将结果添加到找到的数据库列表中
|
|
|
|
|
|
conf.dumper.lister("found databases", foundDbs) # 打印找到的数据库列表
|
|
|
|
|
|
def searchTable(self):
|
|
|
"""
|
|
|
Searches for table names based on user input.
|
|
|
根据用户输入搜索表名称。
|
|
|
"""
|
|
|
bruteForce = False # 初始化是否进行爆破
|
|
|
|
|
|
if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
|
|
|
errMsg = "information_schema not available, "
|
|
|
errMsg += "back-end DBMS is MySQL < 5.0"
|
|
|
bruteForce = True # 如果是MySQL且没有information_schema，则设置为进行爆破
|
|
|
|
|
|
if bruteForce: # 如果需要爆破
|
|
|
message = "do you want to use common table existence check? %s" % ("[Y/n/q]" if Backend.getIdentifiedDbms() in (DBMS.ACCESS, DBMS.MCKOI, DBMS.EXTREMEDB) else "[y/N/q]") # 提示用户是否使用常用表名检查
|
|
|
choice = readInput(message, default='Y' if 'Y' in message else 'N').upper() # 读取用户输入
|
|
|
|
|
|
if choice == 'N': # 如果用户选择不使用常用表名检查
|
|
|
return
|
|
|
elif choice == 'Q': # 如果用户选择退出
|
|
|
raise SqlmapUserQuitException
|
|
|
else:
|
|
|
regex = '|'.join(conf.tbl.split(',')) # 构建用于匹配的正则表达式
|
|
|
return tableExists(paths.COMMON_TABLES, regex) # 使用爆破方式检测表是否存在
|
|
|
|
|
|
foundTbls = {} # 初始化找到的表列表
|
|
|
tblList = conf.tbl.split(',') # 获取用户输入的表列表，用逗号分割
|
|
|
rootQuery = queries[Backend.getIdentifiedDbms()].search_table # 获取当前数据库的搜索表查询
|
|
|
tblCond = rootQuery.inband.condition # 获取表查询条件
|
|
|
dbCond = rootQuery.inband.condition2 # 获取数据库查询条件
|
|
|
tblConsider, tblCondParam = self.likeOrExact("table") # 获取表搜索条件
|
|
|
|
|
|
for tbl in tblList: # 遍历表列表
|
|
|
values = [] # 初始化查询结果列表
|
|
|
tbl = safeSQLIdentificatorNaming(tbl, True) # 对表名进行安全命名
|
|
|
|
|
|
if Backend.getIdentifiedDbms() in UPPER_CASE_DBMSES:
|
|
|
tbl = tbl.upper() # 如果是需要大写的数据库，则转换为大写
|
|
|
conf.db = conf.db.upper() if conf.db else conf.db # 如果用户指定了数据库，则转换为大写
|
|
|
|
|
|
infoMsg = "searching table"
|
|
|
if tblConsider == '1':
|
|
|
infoMsg += "s LIKE" # 如果是LIKE匹配，则添加LIKE
|
|
|
infoMsg += " '%s'" % unsafeSQLIdentificatorNaming(tbl) # 添加不安全的表名
|
|
|
|
|
|
if conf.db == CURRENT_DB:
|
|
|
conf.db = self.getCurrentDb() # 如果用户指定当前数据库，则获取当前数据库名
|
|
|
|
|
|
if dbCond and conf.db:
|
|
|
_ = conf.db.split(',') # 获取用户指定的数据库列表，用逗号分割
|
|
|
whereDbsQuery = " AND (" + " OR ".join("%s = '%s'" % (dbCond, unsafeSQLIdentificatorNaming(db)) for db in _) + ")" # 构建数据库查询条件
|
|
|
infoMsg += " for database%s '%s'" % ("s" if len(_) > 1 else "", ", ".join(db for db in _)) # 添加数据库信息到日志信息中
|
|
|
elif conf.excludeSysDbs: # 如果排除系统数据库
|
|
|
whereDbsQuery = "".join(" AND '%s' != %s" % (unsafeSQLIdentificatorNaming(db), dbCond) for db in self.excludeDbsList) # 构建排除系统数据库的SQL语句
|
|
|
msg = "skipping system database%s '%s'" % ("s" if len(self.excludeDbsList) > 1 else "", ", ".join(db for db in self.excludeDbsList)) # 构建跳过系统数据库的日志信息
|
|
|
logger.info(msg) # 打印日志信息
|
|
|
else:
|
|
|
whereDbsQuery = "" # 如果不排除系统数据库，则SQL语句为空
|
|
|
|
|
|
if dbCond and conf.exclude:
|
|
|
whereDbsQuery += " AND %s NOT LIKE '%s'" % (dbCond, re.sub(r"\.[*+]", '%', conf.exclude._original)) # 添加排除条件
|
|
|
|
|
|
logger.info(infoMsg) # 打印日志信息
|
|
|
|
|
|
tblQuery = "%s%s" % (tblCond, tblCondParam) # 构建表查询条件
|
|
|
tblQuery = tblQuery % unsafeSQLIdentificatorNaming(tbl) # 将表名添加到表查询条件中
|
|
|
|
|
|
# 如果支持UNION，ERROR或者QUERY注入，则使用带内注入
|
|
|
if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
|
|
|
query = rootQuery.inband.query # 获取带内查询语句
|
|
|
query = query % (tblQuery + whereDbsQuery) # 将查询条件添加到SQL语句中
|
|
|
values = inject.getValue(query, blind=False, time=False) # 执行SQL查询
|
|
|
|
|
|
# 如果是SQLite或Firebird数据库，则需要特殊处理
|
|
|
if values and Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.FIREBIRD):
|
|
|
newValues = [] # 初始化新的查询结果列表
|
|
|
|
|
|
if isinstance(values, six.string_types): # 如果查询结果是字符串
|
|
|
values = [values] # 转换为列表
|
|
|
for value in values: # 遍历查询结果
|
|
|
dbName = "SQLite" if Backend.isDbms(DBMS.SQLITE) else "Firebird" # 获取数据库名称
|
|
|
newValues.append(["%s%s" % (dbName, METADB_SUFFIX), value]) # 添加数据库名称和表名到查询结果列表
|
|
|
|
|
|
values = newValues # 更新查询结果
|
|
|
|
|
|
for foundDb, foundTbl in filterPairValues(values): # 遍历查询结果
|
|
|
foundDb = safeSQLIdentificatorNaming(foundDb) # 对数据库名称进行安全命名
|
|
|
foundTbl = safeSQLIdentificatorNaming(foundTbl, True) # 对表名进行安全命名
|
|
|
|
|
|
if foundDb is None or foundTbl is None:
|
|
|
continue
|
|
|
|
|
|
if foundDb in foundTbls: # 如果数据库已经存在于结果列表中
|
|
|
foundTbls[foundDb].append(foundTbl) # 则添加表名到该数据库的表列表中
|
|
|
else:
|
|
|
foundTbls[foundDb] = [foundTbl] # 否则新建数据库，并添加表名
|
|
|
|
|
|
# 如果带内注入失败，则尝试使用盲注
|
|
|
if not values and isInferenceAvailable() and not conf.direct:
|
|
|
# 如果不是SQLite或Firebird数据库
|
|
|
if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
|
|
|
if len(whereDbsQuery) == 0:
|
|
|
infoMsg = "fetching number of databases with table"
|
|
|
if tblConsider == "1":
|
|
|
infoMsg += "s LIKE" # 如果是LIKE匹配，则添加LIKE
|
|
|
infoMsg += " '%s'" % unsafeSQLIdentificatorNaming(tbl)
|
|
|
logger.info(infoMsg) # 打印日志信息
|
|
|
|
|
|
query = rootQuery.blind.count # 获取盲注计数查询
|
|
|
query = query % (tblQuery + whereDbsQuery) # 将查询条件添加到SQL语句中
|
|
|
count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS) # 执行盲注获取表数量
|
|
|
|
|
|
if not isNumPosStrValue(count): # 如果表数量不是正整数
|
|
|
warnMsg = "no databases have table"
|
|
|
if tblConsider == "1":
|
|
|
warnMsg += "s LIKE" # 如果是LIKE匹配，则添加LIKE
|
|
|
warnMsg += " '%s'" % unsafeSQLIdentificatorNaming(tbl)
|
|
|
logger.warning(warnMsg) # 打印日志信息
|
|
|
|
|
|
continue # 跳过当前表
|
|
|
|
|
|
indexRange = getLimitRange(count) # 获取索引范围
|
|
|
|
|
|
for index in indexRange:
|
|
|
query = rootQuery.blind.query # 获取盲注查询语句
|
|
|
query = query % (tblQuery + whereDbsQuery) # 将查询条件添加到SQL语句中
|
|
|
query = agent.limitQuery(index, query) # 添加限制条件
|
|
|
|
|
|
foundDb = unArrayizeValue(inject.getValue(query, union=False, error=False)) # 执行盲注，获取数据库名称
|
|
|
foundDb = safeSQLIdentificatorNaming(foundDb) # 对数据库名称进行安全命名
|
|
|
|
|
|
if foundDb not in foundTbls:
|
|
|
foundTbls[foundDb] = [] # 如果数据库不存在于结果列表中，则新建
|
|
|
|
|
|
if tblConsider == "2":
|
|
|
foundTbls[foundDb].append(tbl) # 如果是精确匹配，则直接添加表名
|
|
|
|
|
|
if tblConsider == "2":
|
|
|
continue # 跳过当前表
|
|
|
|
|
|
else: # 如果指定了数据库
|
|
|
for db in conf.db.split(',') if conf.db else (self.getCurrentDb(),): # 遍历数据库列表
|
|
|
db = safeSQLIdentificatorNaming(db) # 对数据库名称进行安全命名
|
|
|
if db not in foundTbls:
|
|
|
foundTbls[db] = [] # 如果数据库不存在于结果列表中，则新建
|
|
|
else: # 如果是SQLite或Firebird数据库
|
|
|
dbName = "SQLite" if Backend.isDbms(DBMS.SQLITE) else "Firebird" # 获取数据库名称
|
|
|
foundTbls["%s%s" % (dbName, METADB_SUFFIX)] = [] # 添加数据库名称到结果列表中
|
|
|
|
|
|
for db in foundTbls: # 遍历数据库列表
|
|
|
db = safeSQLIdentificatorNaming(db) # 对数据库名称进行安全命名
|
|
|
|
|
|
infoMsg = "fetching number of table"
|
|
|
if tblConsider == "1":
|
|
|
infoMsg += "s LIKE" # 如果是LIKE匹配，则添加LIKE
|
|
|
infoMsg += " '%s' in database '%s'" % (unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(db)) # 添加表名和数据库名到日志信息
|
|
|
logger.info(infoMsg) # 打印日志信息
|
|
|
|
|
|
query = rootQuery.blind.count2 # 获取盲注计数查询
|
|
|
if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
|
|
|
query = query % unsafeSQLIdentificatorNaming(db) # 将数据库名称添加到SQL语句中
|
|
|
query += " AND %s" % tblQuery # 将表查询条件添加到SQL语句中
|
|
|
|
|
|
count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS) # 执行盲注获取表数量
|
|
|
|
|
|
if not isNumPosStrValue(count): # 如果表数量不是正整数
|
|
|
warnMsg = "no table"
|
|
|
if tblConsider == "1":
|
|
|
warnMsg += "s LIKE" # 如果是LIKE匹配，则添加LIKE
|
|
|
warnMsg += " '%s' " % unsafeSQLIdentificatorNaming(tbl)
|
|
|
warnMsg += "in database '%s'" % unsafeSQLIdentificatorNaming(db)
|
|
|
logger.warning(warnMsg) # 打印日志信息
|
|
|
|
|
|
continue # 跳过当前数据库
|
|
|
|
|
|
indexRange = getLimitRange(count) # 获取索引范围
|
|
|
|
|
|
for index in indexRange: # 遍历索引范围
|
|
|
query = rootQuery.blind.query2 # 获取盲注查询语句
|
|
|
|
|
|
if " ORDER BY " in query:
|
|
|
query = query.replace(" ORDER BY ", "%s ORDER BY " % (" AND %s" % tblQuery)) # 如果查询语句包含 ORDER BY，则添加 AND 条件
|
|
|
elif query.endswith("'%s')"):
|
|
|
query = query[:-1] + " AND %s)" % tblQuery # 如果查询语句以 ')' 结尾，则添加 AND 条件
|
|
|
else:
|
|
|
query += " AND %s" % tblQuery # 否则直接添加 AND 条件
|
|
|
|
|
|
if Backend.isDbms(DBMS.FIREBIRD):
|
|
|
query = safeStringFormat(query, index) # 如果是Firebird数据库，则格式化查询语句
|
|
|
|
|
|
if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
|
|
|
query = safeStringFormat(query, unsafeSQLIdentificatorNaming(db)) # 如果不是SQLite或Firebird数据库，则格式化查询语句
|
|
|
|
|
|
if not Backend.isDbms(DBMS.FIREBIRD):
|
|
|
query = agent.limitQuery(index, query) # 如果不是Firebird数据库，则添加限制条件
|
|
|
|
|
|
foundTbl = unArrayizeValue(inject.getValue(query, union=False, error=False)) # 执行盲注，获取表名
|
|
|
if not isNoneValue(foundTbl):
|
|
|
kb.hintValue = foundTbl
|
|
|
foundTbl = safeSQLIdentificatorNaming(foundTbl, True) # 对表名进行安全命名
|
|
|
foundTbls[db].append(foundTbl) # 将表名添加到结果列表中
|
|
|
|
|
|
for db in list(foundTbls.keys()): # 遍历数据库列表
|
|
|
if isNoneValue(foundTbls[db]): # 如果某个数据库的表列表为空
|
|
|
del foundTbls[db] # 则删除该数据库
|
|
|
|
|
|
if not foundTbls: # 如果没有找到表
|
|
|
warnMsg = "no databases contain any of the provided tables"
|
|
|
logger.warning(warnMsg) # 打印日志信息
|
|
|
return # 返回
|
|
|
|
|
|
conf.dumper.dbTables(foundTbls) # 打印找到的表列表
|
|
|
self.dumpFoundTables(foundTbls) # 导出找到的表
|
|
|
|
|
|
def searchColumn(self):
|
|
|
"""
|
|
|
Searches for column names based on user input.
|
|
|
根据用户输入搜索列名称。
|
|
|
"""
|
|
|
bruteForce = False # 初始化是否进行爆破
|
|
|
|
|
|
self.forceDbmsEnum() # 强制枚举数据库
|
|
|
|
|
|
if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
|
|
|
errMsg = "information_schema not available, "
|
|
|
errMsg += "back-end DBMS is MySQL < 5.0"
|
|
|
bruteForce = True # 如果是MySQL且没有information_schema，则设置为进行爆破
|
|
|
|
|
|
if bruteForce:
|
|
|
message = "do you want to use common column existence check? %s" % ("[Y/n/q]" if Backend.getIdentifiedDbms() in (DBMS.ACCESS, DBMS.MCKOI, DBMS.EXTREMEDB) else "[y/N/q]")
|
|
|
choice = readInput(message, default='Y' if 'Y' in message else 'N').upper()
|
|
|
|
|
|
if choice == 'N':
|
|
|
return
|
|
|
elif choice == 'Q':
|
|
|
raise SqlmapUserQuitException
|
|
|
else:
|
|
|
regex = '|'.join(conf.col.split(','))
|
|
|
conf.dumper.dbTableColumns(columnExists(paths.COMMON_COLUMNS, regex))
|
|
|
|
|
|
message = "do you want to dump entries? [Y/n] "
|
|
|
|
|
|
if readInput(message, default='Y', boolean=True):
|
|
|
self.dumpAll()
|
|
|
|
|
|
return
|
|
|
|
|
|
rootQuery = queries[Backend.getIdentifiedDbms()].search_column # 获取当前数据库的搜索列查询
|
|
|
foundCols = {} # 初始化找到的列列表
|
|
|
dbs = {} # 初始化数据库列表
|
|
|
whereDbsQuery = "" # 初始化数据库查询条件
|
|
|
whereTblsQuery = "" # 初始化表查询条件
|
|
|
infoMsgTbl = "" # 初始化表日志信息
|
|
|
infoMsgDb = "" # 初始化数据库日志信息
|
|
|
colList = conf.col.split(',') # 获取用户输入的列列表，用逗号分割
|
|
|
|
|
|
if conf.exclude:
|
|
|
colList = [_ for _ in colList if re.search(conf.exclude, _, re.I) is None] # 如果存在排除条件，则过滤列列表
|
|
|
|
|
|
origTbl = conf.tbl
|
|
|
origDb = conf.db
|
|
|
colCond = rootQuery.inband.condition # 获取列查询条件
|
|
|
dbCond = rootQuery.inband.condition2 # 获取数据库查询条件
|
|
|
tblCond = rootQuery.inband.condition3 # 获取表查询条件
|
|
|
colConsider, colCondParam = self.likeOrExact("column") # 获取列搜索条件
|
|
|
|
|
|
for column in colList: # 遍历列列表
|
|
|
values = [] # 初始化查询结果列表
|
|
|
column = safeSQLIdentificatorNaming(column) # 对列名进行安全命名
|
|
|
conf.db = origDb # 重置数据库名称
|
|
|
conf.tbl = origTbl # 重置表名
|
|
|
|
|
|
if Backend.getIdentifiedDbms() in UPPER_CASE_DBMSES:
|
|
|
column = column.upper() # 如果是需要大写的数据库，则转换为大写
|
|
|
conf.db = conf.db.upper() if conf.db else conf.db # 如果用户指定了数据库，则转换为大写
|
|
|
conf.tbl = conf.tbl.upper() if conf.tbl else conf.tbl # 如果用户指定了表，则转换为大写
|
|
|
|
|
|
infoMsg = "searching column"
|
|
|
if colConsider == "1":
|
|
|
infoMsg += "s LIKE" # 如果是LIKE匹配，则添加LIKE
|
|
|
infoMsg += " '%s'" % unsafeSQLIdentificatorNaming(column) # 添加不安全的列名
|
|
|
|
|
|
foundCols[column] = {} # 初始化列结果列表
|
|
|
|
|
|
if tblCond: # 如果指定了表条件
|
|
|
if conf.tbl: # 如果指定了表
|
|
|
tbls = conf.tbl.split(',') # 获取表列表，用逗号分割
|
|
|
if conf.exclude:
|
|
|
tbls = [_ for _ in tbls if re.search(conf.exclude, _, re.I) is None] # 如果存在排除条件，则过滤表列表
|
|
|
whereTblsQuery = " AND (" + " OR ".join("%s = '%s'" % (tblCond, unsafeSQLIdentificatorNaming(tbl)) for tbl in tbls) + ")" # 构建表查询条件
|
|
|
infoMsgTbl = " for table%s '%s'" % ("s" if len(tbls) > 1 else "", ", ".join(unsafeSQLIdentificatorNaming(tbl) for tbl in tbls)) # 添加表信息到日志信息
|
|
|
|
|
|
if conf.db == CURRENT_DB:
|
|
|
conf.db = self.getCurrentDb() # 如果用户指定当前数据库，则获取当前数据库名
|
|
|
|
|
|
if dbCond: # 如果指定了数据库条件
|
|
|
if conf.db: # 如果指定了数据库
|
|
|
_ = conf.db.split(',') # 获取数据库列表，用逗号分割
|
|
|
whereDbsQuery = " AND (" + " OR ".join("%s = '%s'" % (dbCond, unsafeSQLIdentificatorNaming(db)) for db in _) + ")" # 构建数据库查询条件
|
|
|
infoMsgDb = " in database%s '%s'" % ("s" if len(_) > 1 else "", ", ".join(unsafeSQLIdentificatorNaming(db) for db in _)) # 添加数据库信息到日志信息
|
|
|
elif conf.excludeSysDbs: # 如果排除系统数据库
|
|
|
whereDbsQuery = "".join(" AND %s != '%s'" % (dbCond, unsafeSQLIdentificatorNaming(db)) for db in self.excludeDbsList) # 构建排除系统数据库的SQL语句
|
|
|
msg = "skipping system database%s '%s'" % ("s" if len(self.excludeDbsList) > 1 else "", ", ".join(unsafeSQLIdentificatorNaming(db) for db in self.excludeDbsList)) # 构建跳过系统数据库的日志信息
|
|
|
logger.info(msg) # 打印日志信息
|
|
|
else:
|
|
|
infoMsgDb = " across all databases" # 如果不指定数据库，则表示在所有数据库中查找
|
|
|
|
|
|
if conf.exclude:
|
|
|
whereDbsQuery += " AND %s NOT LIKE '%s'" % (dbCond, re.sub(r"\.[*+]", '%', conf.exclude._original)) # 添加排除条件
|
|
|
|
|
|
logger.info("%s%s%s" % (infoMsg, infoMsgTbl, infoMsgDb)) # 打印日志信息
|
|
|
|
|
|
colQuery = "%s%s" % (colCond, colCondParam) # 构建列查询条件
|
|
|
colQuery = colQuery % unsafeSQLIdentificatorNaming(column) # 将列名添加到查询条件中
|
|
|
|
|
|
# 如果支持UNION，ERROR或者QUERY注入，则使用带内注入
|
|
|
if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
|
|
|
if not all((conf.db, conf.tbl)):
|
|
|
# Enumerate tables containing the column provided if
|
|
|
# either of database(s) or table(s) is not provided
|
|
|
query = rootQuery.inband.query # 获取带内查询语句
|
|
|
query = query % (colQuery + whereDbsQuery + whereTblsQuery) # 将查询条件添加到SQL语句中
|
|
|
values = inject.getValue(query, blind=False, time=False) # 执行SQL查询
|
|
|
else:
|
|
|
# Assume provided databases' tables contain the
|
|
|
# column(s) provided
|
|
|
values = [] # 如果指定了数据库和表，则直接使用它们
|
|
|
|
|
|
for db in conf.db.split(','): # 遍历数据库列表
|
|
|
for tbl in conf.tbl.split(','): # 遍历表列表
|
|
|
values.append([safeSQLIdentificatorNaming(db), safeSQLIdentificatorNaming(tbl, True)]) # 将数据库和表添加到查询结果中
|
|
|
|
|
|
for db, tbl in filterPairValues(values): # 遍历查询结果
|
|
|
db = safeSQLIdentificatorNaming(db) # 对数据库名称进行安全命名
|
|
|
tbls = tbl.split(',') if not isNoneValue(tbl) else [] # 如果表名不为空，则按逗号分割
|
|
|
|
|
|
for tbl in tbls: # 遍历表列表
|
|
|
tbl = safeSQLIdentificatorNaming(tbl, True) # 对表名进行安全命名
|
|
|
|
|
|
if db is None or tbl is None:
|
|
|
continue
|
|
|
|
|
|
conf.db = db # 设置数据库名称
|
|
|
conf.tbl = tbl # 设置表名
|
|
|
conf.col = column # 设置列名
|
|
|
|
|
|
self.getColumns(onlyColNames=True, colTuple=(colConsider, colCondParam), bruteForce=False) # 获取列名，不进行爆破
|
|
|
|
|
|
if db in kb.data.cachedColumns and tbl in kb.data.cachedColumns[db]: # 如果列信息已经缓存
|
|
|
if db not in dbs:
|
|
|
dbs[db] = {} # 如果数据库不在dbs中，则添加
|
|
|
|
|
|
if tbl not in dbs[db]:
|
|
|
dbs[db][tbl] = {} # 如果表不在dbs中，则添加
|
|
|
|
|
|
dbs[db][tbl].update(kb.data.cachedColumns[db][tbl]) # 更新缓存的列信息
|
|
|
|
|
|
if db in foundCols[column]:
|
|
|
foundCols[column][db].append(tbl) # 如果数据库已经在foundCols中，则添加表
|
|
|
else:
|
|
|
foundCols[column][db] = [tbl] # 否则新建数据库，并添加表
|
|
|
|
|
|
kb.data.cachedColumns = {} # 清空缓存的列信息
|
|
|
|
|
|
# 如果带内注入失败，则尝试使用盲注
|
|
|
if not values and isInferenceAvailable() and not conf.direct:
|
|
|
# 如果之前的带内注入尝试失败，并且当前可以使用盲注技术，并且没有使用直接连接模式，则执行此代码块。
|
|
|
if not conf.db:
|
|
|
# 如果用户没有指定要搜索的数据库（没有使用 -D 参数）
|
|
|
infoMsg = "fetching number of databases with tables containing column"
|
|
|
# 准备日志消息，表示正在获取包含指定列的表所在的数据库数量
|
|
|
if colConsider == "1":
|
|
|
# 如果列名使用 LIKE 条件匹配
|
|
|
infoMsg += "s LIKE"
|
|
|
# 将 "s LIKE" 添加到日志消息中
|
|
|
infoMsg += " '%s'" % unsafeSQLIdentificatorNaming(column)
|
|
|
# 将不安全的列名添加到日志消息中
|
|
|
logger.info("%s%s%s" % (infoMsg, infoMsgTbl, infoMsgDb))
|
|
|
# 打印带有表和数据库信息的日志消息
|
|
|
|
|
|
query = rootQuery.blind.count
|
|
|
# 获取当前数据库的盲注计数查询语句（用于获取匹配的数据库数量）
|
|
|
query = query % (colQuery + whereDbsQuery + whereTblsQuery)
|
|
|
# 将列的查询条件、数据库的过滤条件和表的过滤条件添加到查询语句中
|
|
|
count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)
|
|
|
# 执行盲注查询，获取匹配的数据库数量，并将结果视为整数类型
|
|
|
|
|
|
if not isNumPosStrValue(count):
|
|
|
# 如果返回的数据库数量不是有效的正整数
|
|
|
warnMsg = "no databases have tables containing column"
|
|
|
# 准备警告消息，表示没有找到包含指定列的表
|
|
|
if colConsider == "1":
|
|
|
# 如果列名使用 LIKE 条件匹配
|
|
|
warnMsg += "s LIKE"
|
|
|
# 将 "s LIKE" 添加到警告消息中
|
|
|
warnMsg += " '%s'" % unsafeSQLIdentificatorNaming(column)
|
|
|
# 将不安全的列名添加到警告消息中
|
|
|
logger.warning("%s%s" % (warnMsg, infoMsgTbl))
|
|
|
# 打印带有表信息的警告消息
|
|
|
|
|
|
continue
|
|
|
# 跳过当前列，继续处理下一个列
|
|
|
|
|
|
indexRange = getLimitRange(count)
|
|
|
# 获取从 1 到数据库数量的索引范围，用于循环遍历数据库
|
|
|
|
|
|
for index in indexRange:
|
|
|
# 遍历每个可能的数据库索引
|
|
|
query = rootQuery.blind.query
|
|
|
# 获取用于盲注提取数据库名称的查询语句
|
|
|
query = query % (colQuery + whereDbsQuery + whereTblsQuery)
|
|
|
# 将列的查询条件、数据库的过滤条件和表的过滤条件添加到查询语句中
|
|
|
query = agent.limitQuery(index, query)
|
|
|
# 将当前索引作为 LIMIT 条件添加到查询语句中，用于分页获取数据库名
|
|
|
|
|
|
db = unArrayizeValue(inject.getValue(query, union=False, error=False))
|
|
|
# 执行盲注查询，获取数据库名称，并将其从数组中提取出来
|
|
|
db = safeSQLIdentificatorNaming(db)
|
|
|
# 对提取到的数据库名称进行安全命名
|
|
|
|
|
|
if db not in dbs:
|
|
|
# 如果数据库名称不在 dbs 字典中
|
|
|
dbs[db] = {}
|
|
|
# 在 dbs 字典中创建一个新的键值对，其中键为数据库名称，值为一个空字典
|
|
|
|
|
|
if db not in foundCols[column]:
|
|
|
# 如果数据库名称不在 foundCols[column] 字典中
|
|
|
foundCols[column][db] = []
|
|
|
# 在 foundCols[column] 字典中创建一个新的键值对，其中键为数据库名称，值为一个空列表
|
|
|
else:
|
|
|
# 如果用户指定了要搜索的数据库（使用了 -D 参数）
|
|
|
for db in conf.db.split(',') if conf.db else (self.getCurrentDb(),):
|
|
|
# 遍历用户指定的所有数据库，如果没有指定数据库，则使用当前数据库
|
|
|
db = safeSQLIdentificatorNaming(db)
|
|
|
# 对数据库名称进行安全命名
|
|
|
if db not in foundCols[column]:
|
|
|
# 如果数据库名称不在 foundCols[column] 字典中
|
|
|
foundCols[column][db] = []
|
|
|
# 在 foundCols[column] 字典中创建一个新的键值对，其中键为数据库名称，值为一个空列表
|
|
|
|
|
|
origDb = conf.db
|
|
|
# 将原始的数据库名称存储在 origDb 变量中
|
|
|
origTbl = conf.tbl
|
|
|
# 将原始的表名称存储在 origTbl 变量中
|
|
|
|
|
|
for column, dbData in foundCols.items():
|
|
|
# 遍历 foundCols 字典中的所有列及其对应的数据库数据
|
|
|
colQuery = "%s%s" % (colCond, colCondParam)
|
|
|
# 构建列的查询条件字符串
|
|
|
colQuery = colQuery % unsafeSQLIdentificatorNaming(column)
|
|
|
# 将不安全的列名添加到列的查询条件字符串中
|
|
|
|
|
|
for db in dbData:
|
|
|
# 遍历当前列对应的所有数据库
|
|
|
conf.db = origDb
|
|
|
# 将数据库名称重置为原始值
|
|
|
conf.tbl = origTbl
|
|
|
# 将表名称重置为原始值
|
|
|
|
|
|
infoMsg = "fetching number of tables containing column"
|
|
|
# 准备日志消息，表示正在获取包含指定列的表的数量
|
|
|
if colConsider == "1":
|
|
|
# 如果列名使用 LIKE 条件匹配
|
|
|
infoMsg += "s LIKE"
|
|
|
# 将 "s LIKE" 添加到日志消息中
|
|
|
infoMsg += " '%s' in database '%s'" % (unsafeSQLIdentificatorNaming(column), unsafeSQLIdentificatorNaming(db))
|
|
|
# 将不安全的列名和数据库名称添加到日志消息中
|
|
|
logger.info(infoMsg)
|
|
|
# 打印日志消息
|
|
|
|
|
|
query = rootQuery.blind.count2
|
|
|
# 获取用于盲注提取表数量的查询语句
|
|
|
if not re.search(r"(?i)%s\Z" % METADB_SUFFIX, db or ""):
|
|
|
# 如果数据库名称不是以元数据后缀结尾
|
|
|
query = query % unsafeSQLIdentificatorNaming(db)
|
|
|
# 将不安全的数据库名称添加到查询语句中
|
|
|
query += " AND %s" % colQuery
|
|
|
# 将列的查询条件添加到查询语句中
|
|
|
else:
|
|
|
# 如果数据库名称以元数据后缀结尾
|
|
|
query = query % colQuery
|
|
|
# 将列的查询条件添加到查询语句中
|
|
|
|
|
|
query += whereTblsQuery
|
|
|
# 将表的过滤条件添加到查询语句中
|
|
|
|
|
|
count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)
|
|
|
# 执行盲注查询，获取匹配的表数量，并将结果视为整数类型
|
|
|
|
|
|
if not isNumPosStrValue(count):
|
|
|
# 如果返回的表数量不是有效的正整数
|
|
|
warnMsg = "no tables contain column"
|
|
|
# 准备警告消息，表示没有找到包含指定列的表
|
|
|
if colConsider == "1":
|
|
|
# 如果列名使用 LIKE 条件匹配
|
|
|
warnMsg += "s LIKE"
|
|
|
# 将 "s LIKE" 添加到警告消息中
|
|
|
warnMsg += " '%s' " % unsafeSQLIdentificatorNaming(column)
|
|
|
# 将不安全的列名添加到警告消息中
|
|
|
warnMsg += "in database '%s'" % unsafeSQLIdentificatorNaming(db)
|
|
|
# 将不安全的数据库名称添加到警告消息中
|
|
|
logger.warning(warnMsg)
|
|
|
# 打印警告消息
|
|
|
|
|
|
continue
|
|
|
# 跳过当前数据库，继续处理下一个数据库
|
|
|
|
|
|
indexRange = getLimitRange(count)
|
|
|
# 获取从 1 到表数量的索引范围，用于循环遍历表
|
|
|
|
|
|
for index in indexRange:
|
|
|
# 遍历每个可能的表索引
|
|
|
query = rootQuery.blind.query2
|
|
|
# 获取用于盲注提取表名称的查询语句
|
|
|
|
|
|
if re.search(r"(?i)%s\Z" % METADB_SUFFIX, db or ""):
|
|
|
# 如果数据库名称以元数据后缀结尾
|
|
|
query = query % (colQuery + whereTblsQuery)
|
|
|
# 将列的查询条件和表的过滤条件添加到查询语句中
|
|
|
elif query.endswith("'%s')"):
|
|
|
# 如果查询语句以 '%s')' 结尾
|
|
|
query = query[:-1] + " AND %s)" % (colQuery + whereTblsQuery)
|
|
|
# 在结尾添加列的查询条件和表的过滤条件
|
|
|
elif " ORDER BY " in query:
|
|
|
# 如果查询语句包含 " ORDER BY "
|
|
|
query = query.replace(" ORDER BY ", " AND %s ORDER BY " % (colQuery + whereTblsQuery))
|
|
|
# 将列的查询条件和表的过滤条件添加到 " ORDER BY " 前面
|
|
|
else:
|
|
|
# 如果查询语句不满足以上所有条件
|
|
|
query += " AND %s" % (colQuery + whereTblsQuery)
|
|
|
# 将列的查询条件和表的过滤条件添加到查询语句中
|
|
|
|
|
|
query = safeStringFormat(query, unsafeSQLIdentificatorNaming(db))
|
|
|
# 对查询语句进行格式化，将不安全的数据库名称添加到查询语句中
|
|
|
query = agent.limitQuery(index, query)
|
|
|
# 将当前索引作为 LIMIT 条件添加到查询语句中，用于分页获取表名
|
|
|
|
|
|
tbl = unArrayizeValue(inject.getValue(query, union=False, error=False))
|
|
|
# 执行盲注查询，获取表名称，并将其从数组中提取出来
|
|
|
kb.hintValue = tbl
|
|
|
# 将提取到的表名称设置为提示值
|
|
|
tbl = safeSQLIdentificatorNaming(tbl, True)
|
|
|
# 对提取到的表名称进行安全命名
|
|
|
|
|
|
conf.db = db
|
|
|
# 设置当前数据库名称
|
|
|
conf.tbl = tbl
|
|
|
# 设置当前表名称
|
|
|
conf.col = column
|
|
|
# 设置当前列名称
|
|
|
|
|
|
self.getColumns(onlyColNames=True, colTuple=(colConsider, colCondParam), bruteForce=False)
|
|
|
# 调用 getColumns 方法获取当前表中的列信息，但不进行爆破
|
|
|
|
|
|
if db in kb.data.cachedColumns and tbl in kb.data.cachedColumns[db]:
|
|
|
# 如果在 kb.data.cachedColumns 中已经缓存了数据库和表的列信息
|
|
|
if db not in dbs:
|
|
|
# 如果数据库不在 dbs 字典中
|
|
|
dbs[db] = {}
|
|
|
# 在 dbs 字典中创建一个新的键值对，其中键为数据库名称，值为一个空字典
|
|
|
|
|
|
if tbl not in dbs[db]:
|
|
|
# 如果表不在 dbs[db] 字典中
|
|
|
dbs[db][tbl] = {}
|
|
|
# 在 dbs[db] 字典中创建一个新的键值对，其中键为表名称，值为一个空字典
|
|
|
|
|
|
dbs[db][tbl].update(kb.data.cachedColumns[db][tbl])
|
|
|
# 将缓存的列信息更新到 dbs[db][tbl] 中
|
|
|
|
|
|
kb.data.cachedColumns = {}
|
|
|
# 清空缓存的列信息
|
|
|
|
|
|
if db in foundCols[column]:
|
|
|
# 如果数据库名称已经在 foundCols[column] 字典中
|
|
|
foundCols[column][db].append(tbl)
|
|
|
# 将表名称添加到 foundCols[column][db] 的列表中
|
|
|
else:
|
|
|
# 如果数据库名称不在 foundCols[column] 字典中
|
|
|
foundCols[column][db] = [tbl]
|
|
|
# 在 foundCols[column] 字典中创建一个新的键值对，其中键为数据库名称，值为一个包含表名称的列表
|
|
|
if dbs:
|
|
|
# 如果找到任何数据库和表
|
|
|
conf.dumper.dbColumns(foundCols, colConsider, dbs)
|
|
|
# 使用 dumper 对象打印找到的列信息
|
|
|
self.dumpFoundColumn(dbs, foundCols, colConsider)
|
|
|
# 调用 dumpFoundColumn 方法，对找到的列进行处理
|
|
|
else:
|
|
|
# 如果没有找到任何数据库和表
|
|
|
warnMsg = "no databases have tables containing any of the "
|
|
|
# 准备警告消息，表示没有找到包含指定列的表
|
|
|
warnMsg += "provided columns"
|
|
|
# 将 "provided columns" 添加到警告消息中
|
|
|
logger.warning(warnMsg)
|
|
|
# 打印警告消息 |
