"""

def write(self, fp):

"""

if self._defaults:

fp.write("[%s]\n" % _configparser.DEFAULTSECT)

for (key, value) in self._defaults.items():

fp.write("%s = %s" % (key, getUnicode(value, UNICODE_ENCODING)))

fp.write("\n")

for section in self._sections:

fp.write("[%s]\n" % section)

for (key, value) in self._sections[section].items():

if key != "__name__":

if value is None:

fp.write("%s\n" % (key))

elif not isListLike(value):

fp.write("%s = %s\n" % (key, getUnicode(value, UNICODE_ENCODING)))

@staticmethod

def humanize(values, chain=" or "):

return chain.join(values)

# Get methods

@staticmethod

def getDbms(versions=None):

"""

if versions is None and Backend.getVersionList():

versions = Backend.getVersionList()

# NOTE: preventing ugly (e.g.) "back-end DBMS: MySQL Unknown"

if isListLike(versions) and UNKNOWN_DBMS_VERSION in versions:

versions = None

return Backend.getDbms() if versions is None else "%s %s" % (Backend.getDbms(), " and ".join(filterNone(versions)))

@staticmethod

def getErrorParsedDBMSes():

"""

htmlParsed = None

if len(kb.htmlFp) == 0 or kb.heuristicTest != HEURISTIC_TEST.POSITIVE:

pass

elif len(kb.htmlFp) == 1:

htmlParsed = kb.htmlFp[0]

elif len(kb.htmlFp) > 1:

htmlParsed = " or ".join(kb.htmlFp)

return htmlParsed

@staticmethod

def getOs(target, info):

"""

infoStr = ""

infoApi = {}

if info and "type" in info:

if conf.api:

infoApi["%s operating system" % target] = info

else:

infoStr += "%s operating system: %s" % (target, Format.humanize(info["type"]))

if "distrib" in info:

infoStr += " %s" % Format.humanize(info["distrib"])

if "release" in info:

infoStr += " %s" % Format.humanize(info["release"])

if "sp" in info:

infoStr += " %s" % Format.humanize(info["sp"])

if "codename" in info:

infoStr += " (%s)" % Format.humanize(info["codename"])

if "technology" in info:

if conf.api:

infoApi["web application technology"] = Format.humanize(info["technology"], ", ")

else:

infoStr += "\nweb application technology: %s" % Format.humanize(info["technology"], ", ")

if conf.api:

return infoApi

else:

@staticmethod

def setDbms(dbms):

dbms = aliasToDbmsEnum(dbms)

if dbms is None:

return None

# Little precaution, in theory this condition should always be false

elif kb.dbms is not None and kb.dbms != dbms:

warnMsg = "there appears to be a high probability that "

warnMsg += "this could be a false positive case"

logger.warning(warnMsg)

msg = "sqlmap previously fingerprinted back-end DBMS as "

msg += "%s. However now it has been fingerprinted " % kb.dbms

msg += "as %s. " % dbms

msg += "Please, specify which DBMS should be "

msg += "correct [%s (default)/%s] " % (kb.dbms, dbms)

while True:

choice = readInput(msg, default=kb.dbms)

if aliasToDbmsEnum(choice) == kb.dbms:

kb.dbmsVersion = []

kb.resolutionDbms = kb.dbms

break

elif aliasToDbmsEnum(choice) == dbms:

kb.dbms = aliasToDbmsEnum(choice)

break

else:

warnMsg = "invalid value"

logger.warning(warnMsg)

elif kb.dbms is None:

kb.dbms = aliasToDbmsEnum(dbms)

return kb.dbms

@staticmethod

def setVersion(version):

if isinstance(version, six.string_types):

kb.dbmsVersion = [version]

return kb.dbmsVersion

@staticmethod

def setVersionList(versionsList):

if isinstance(versionsList, list):

kb.dbmsVersion = versionsList

elif isinstance(versionsList, six.string_types):

Backend.setVersion(versionsList)

else:

logger.error("invalid format of versionsList")

@staticmethod

def forceDbms(dbms, sticky=False):

if not kb.stickyDBMS:

kb.forcedDbms = aliasToDbmsEnum(dbms)

kb.stickyDBMS = sticky

@staticmethod

def flushForcedDbms(force=False):

if not kb.stickyDBMS or force:

kb.forcedDbms = None

kb.stickyDBMS = False

@staticmethod

def setOs(os):

if os is None:

return None

# Little precaution, in theory this condition should always be false

elif kb.os is not None and isinstance(os, six.string_types) and kb.os.lower() != os.lower():

msg = "sqlmap previously fingerprinted back-end DBMS "

msg += "operating system %s. However now it has " % kb.os

msg += "been fingerprinted to be %s. " % os

msg += "Please, specify which OS is "

msg += "correct [%s (default)/%s] " % (kb.os, os)

while True:

choice = readInput(msg, default=kb.os)

if choice == kb.os:

break

elif choice == os:

kb.os = choice.capitalize()

break

else:

warnMsg = "invalid value"

logger.warning(warnMsg)

elif kb.os is None and isinstance(os, six.string_types):

kb.os = os.capitalize()

return kb.os

@staticmethod

def setOsVersion(version):

if version is None:

return None

elif kb.osVersion is None and isinstance(version, six.string_types):

kb.osVersion = version

@staticmethod

def setOsServicePack(sp):

if sp is None:

return None

elif kb.osSP is None and isinstance(sp, int):

kb.osSP = sp

@staticmethod

def setArch():

msg = "what is the back-end database management system architecture?"

msg += "\n[1] 32-bit (default)"

msg += "\n[2] 64-bit"

while True:

choice = readInput(msg, default='1')

if hasattr(choice, "isdigit") and choice.isdigit() and int(choice) in (1, 2):

kb.arch = 32 if int(choice) == 1 else 64

break

else:

warnMsg = "invalid value. Valid values are 1 and 2"

logger.warning(warnMsg)

return kb.arch

# Get methods

@staticmethod

def getForcedDbms():

return aliasToDbmsEnum(conf.get("forceDbms")) or aliasToDbmsEnum(kb.get("forcedDbms"))

@staticmethod

def getDbms():

return aliasToDbmsEnum(kb.get("dbms"))

@staticmethod

def getErrorParsedDBMSes():

"""

return kb.htmlFp if kb.get("heuristicTest") == HEURISTIC_TEST.POSITIVE else []

@staticmethod

def getIdentifiedDbms():

"""

dbms = None

if not kb:

pass

elif not kb.get("testMode") and conf.get("dbmsHandler") and getattr(conf.dbmsHandler, "_dbms", None):

dbms = conf.dbmsHandler._dbms

elif Backend.getForcedDbms() is not None:

dbms = Backend.getForcedDbms()

elif Backend.getDbms() is not None:

dbms = Backend.getDbms()

elif kb.get("injection") and kb.injection.dbms:

dbms = unArrayizeValue(kb.injection.dbms)

elif Backend.getErrorParsedDBMSes():

dbms = unArrayizeValue(Backend.getErrorParsedDBMSes())

elif conf.get("dbms"):

dbms = conf.get("dbms")

return aliasToDbmsEnum(dbms)

@staticmethod

def getVersion():

versions = filterNone(flattenValue(kb.dbmsVersion)) if not isinstance(kb.dbmsVersion, six.string_types) else [kb.dbmsVersion]

if not isNoneValue(versions):

return versions[0]

else:

return None

@staticmethod

def getVersionList():

versions = filterNone(flattenValue(kb.dbmsVersion)) if not isinstance(kb.dbmsVersion, six.string_types) else [kb.dbmsVersion]

if not isNoneValue(versions):

return versions

else:

return None

@staticmethod

def getOs():

return kb.os

@staticmethod

def getOsVersion():

return kb.osVersion

@staticmethod

def getOsServicePack():

return kb.osSP

@staticmethod

def getArch():

if kb.arch is None:

Backend.setArch()

return kb.arch

# Comparison methods

@staticmethod

def isDbms(dbms):

if not kb.get("testMode") and all((Backend.getDbms(), Backend.getIdentifiedDbms())) and Backend.getDbms() != Backend.getIdentifiedDbms():

singleTimeWarnMessage("identified ('%s') and fingerprinted ('%s') DBMSes differ. If you experience problems in enumeration phase please rerun with '--flush-session'" % (Backend.getIdentifiedDbms(), Backend.getDbms()))

return Backend.getIdentifiedDbms() == aliasToDbmsEnum(dbms)

@staticmethod

def isFork(fork):

return hashDBRetrieve(HASHDB_KEYS.DBMS_FORK) == fork

@staticmethod

def isDbmsWithin(aliases):

return Backend.getDbms() is not None and Backend.getDbms().lower() in aliases

@staticmethod

def isVersion(version):

return Backend.getVersion() is not None and Backend.getVersion() == version

@staticmethod

def isVersionWithin(versionList):

if Backend.getVersionList() is None:

return False

for _ in Backend.getVersionList():

if _ != UNKNOWN_DBMS_VERSION and _ in versionList:

return True

return False

@staticmethod

def isVersionGreaterOrEqualThan(version):

retVal = False

if all(_ not in (None, UNKNOWN_DBMS_VERSION) for _ in (Backend.getVersion(), version)):

_version = unArrayizeValue(Backend.getVersion())

_version = re.sub(r"[<>= ]", "", _version)

try:

retVal = LooseVersion(_version) >= LooseVersion(version)

except:

retVal = str(_version) >= str(version)

return retVal

@staticmethod

def isOs(os):

"""

testableParameters = OrderedDict()

if place in conf.parameters and not parameters:

parameters = conf.parameters[place]

parameters = re.sub(r"&(\w{1,4});", r"%s\g<1>%s" % (PARAMETER_AMP_MARKER, PARAMETER_SEMICOLON_MARKER), parameters)

if place == PLACE.COOKIE:

splitParams = parameters.split(conf.cookieDel or DEFAULT_COOKIE_DELIMITER)

else:

splitParams = parameters.split(conf.paramDel or DEFAULT_GET_POST_DELIMITER)

for element in splitParams:

element = re.sub(r"%s(.+?)%s" % (PARAMETER_AMP_MARKER, PARAMETER_SEMICOLON_MARKER), r"&\g<1>;", element)

parts = element.split("=")

if len(parts) >= 2:

parameter = urldecode(parts[0].replace(" ", ""))

if not parameter:

continue

if conf.paramDel and conf.paramDel == '\n':

parts[-1] = parts[-1].rstrip()

condition = not conf.testParameter

condition |= conf.testParameter is not None and parameter in conf.testParameter

condition |= place == PLACE.COOKIE and len(intersect((PLACE.COOKIE,), conf.testParameter, True)) > 0

if condition:

value = "=".join(parts[1:])

if parameter in (conf.base64Parameter or []):

try:

kb.base64Originals[parameter] = oldValue = value

value = urldecode(value, convall=True)

value = decodeBase64(value, binary=False, encoding=conf.encoding or UNICODE_ENCODING)

parameters = re.sub(r"\b%s(\b|\Z)" % re.escape(oldValue), value, parameters)

except:

errMsg = "parameter '%s' does not contain " % parameter

errMsg += "valid Base64 encoded value ('%s')" % value

raise SqlmapValueException(errMsg)

testableParameters[parameter] = value

if not conf.multipleTargets and not (conf.csrfToken and re.search(conf.csrfToken, parameter, re.I)):

_ = urldecode(testableParameters[parameter], convall=True)

if (_.endswith("'") and _.count("'") == 1 or re.search(r'\A9{3,}', _) or re.search(r'\A-\d+\Z', _) or re.search(DUMMY_USER_INJECTION, _)) and not parameter.upper().startswith(GOOGLE_ANALYTICS_COOKIE_PREFIX):

warnMsg = "it appears that you have provided tainted parameter values "

warnMsg += "('%s') with most likely leftover " % element

warnMsg += "chars/statements from manual SQL injection test(s). "

warnMsg += "Please, always use only valid parameter values "

warnMsg += "so sqlmap could be able to run properly"

logger.warning(warnMsg)

message = "are you really sure that you want to continue (sqlmap could have problems)? [y/N] "

if not readInput(message, default='N', boolean=True):

raise SqlmapSilentQuitException

elif not _:

warnMsg = "provided value for parameter '%s' is empty. " % parameter

warnMsg += "Please, always use only valid parameter values "

warnMsg += "so sqlmap could be able to run properly"

logger.warning(warnMsg)

if place in (PLACE.POST, PLACE.GET):

for regex in (r"\A((?:<[^>]+>)+\w+)((?:<[^>]+>)+)\Z", r"\A([^\w]+.*\w+)([^\w]+)\Z"):

match = re.search(regex, testableParameters[parameter])

if match:

try:

candidates = OrderedDict()

def walk(head, current=None):

if current is None:

current = head

if isListLike(current):

for _ in current:

walk(head, _)

elif isinstance(current, dict):

for key in current.keys():

value = current[key]

if isinstance(value, (bool, int, float, six.string_types)) or value in (None, []):

original = current[key]

if isinstance(value, bool):

current[key] = "%s%s" % (getUnicode(value).lower(), BOUNDED_INJECTION_MARKER)

elif value is None:

current[key] = "%s%s" % (randomInt(), BOUNDED_INJECTION_MARKER)

elif value == []:

current[key] = ["%s%s" % (randomInt(), BOUNDED_INJECTION_MARKER)]

else:

current[key] = "%s%s" % (value, BOUNDED_INJECTION_MARKER)

candidates["%s (%s)" % (parameter, key)] = re.sub(r"\b(%s\s*=\s*)%s" % (re.escape(parameter), re.escape(testableParameters[parameter])), r"\g<1>%s" % json.dumps(deserialized, separators=(',', ':') if ", " not in testableParameters[parameter] else None), parameters)

current[key] = original

elif isinstance(value, (list, tuple, set, dict)):

if value:

walk(head, value)

# NOTE: for cases with custom injection marker(s) inside (e.g. https://github.com/sqlmapproject/sqlmap/issues/4137#issuecomment-2013783111) - p.s. doesn't care too much about the structure (e.g. injection into the flat array values)

if CUSTOM_INJECTION_MARK_CHAR in testableParameters[parameter]:

for match in re.finditer(r'(\w+)[^\w]*"\s*:[^\w]*\w*%s' % re.escape(CUSTOM_INJECTION_MARK_CHAR), testableParameters[parameter]):

key = match.group(1)

value = testableParameters[parameter].replace(match.group(0), match.group(0).replace(CUSTOM_INJECTION_MARK_CHAR, BOUNDED_INJECTION_MARKER))

candidates["%s (%s)" % (parameter, key)] = re.sub(r"\b(%s\s*=\s*)%s" % (re.escape(parameter), re.escape(testableParameters[parameter])), r"\g<1>%s" % value, parameters)

if not candidates:

deserialized = json.loads(testableParameters[parameter])

walk(deserialized)

if candidates:

message = "it appears that provided value for %sparameter '%s' " % ("%s " % place if place != parameter else "", parameter)

message += "is JSON deserializable. Do you want to inject inside? [y/N] "

if readInput(message, default='N', boolean=True):

del testableParameters[parameter]

testableParameters.update(candidates)

break

except (KeyboardInterrupt, SqlmapUserQuitException):

raise

except Exception:

pass

_ = re.sub(regex, r"\g<1>%s\g<%d>" % (kb.customInjectionMark, len(match.groups())), testableParameters[parameter])

message = "it appears that provided value for %sparameter '%s' " % ("%s " % place if place != parameter else "", parameter)

message += "has boundaries. Do you want to inject inside? ('%s') [y/N] " % getUnicode(_)

if readInput(message, default='N', boolean=True):

testableParameters[parameter] = re.sub(r"\b(%s\s*=\s*)%s" % (re.escape(parameter), re.escape(testableParameters[parameter])), (r"\g<1>%s" % re.sub(regex, r"\g<1>%s\g<2>" % BOUNDED_INJECTION_MARKER, testableParameters[parameter].replace("\\", r"\\"))), parameters)

break

if conf.testParameter:

if not testableParameters:

paramStr = ", ".join(test for test in conf.testParameter)

if len(conf.testParameter) > 1:

warnMsg = "provided parameters '%s' " % paramStr

warnMsg += "are not inside the %s" % place

logger.warning(warnMsg)

else:

parameter = conf.testParameter[0]

if not intersect(USER_AGENT_ALIASES + REFERER_ALIASES + HOST_ALIASES, parameter, True):

debugMsg = "provided parameter '%s' " % paramStr

debugMsg += "is not inside the %s" % place

logger.debug(debugMsg)

elif len(conf.testParameter) != len(testableParameters):

for parameter in conf.testParameter:

if parameter not in testableParameters:

debugMsg = "provided parameter '%s' " % parameter

debugMsg += "is not inside the %s" % place

logger.debug(debugMsg)

if testableParameters:

for parameter, value in testableParameters.items():

if value and not value.isdigit():

for encoding in ("hex", "base64"):

try:

decoded = codecs.decode(value, encoding)

if len(decoded) > MIN_ENCODED_LEN_CHECK and all(_ in getBytes(string.printable) for _ in decoded):

warnMsg = "provided parameter '%s' " % parameter

warnMsg += "appears to be '%s' encoded" % encoding

logger.warning(warnMsg)

break

except:

pass

directories = None

defaultDocRoot = DEFAULT_DOC_ROOTS.get(Backend.getOs(), DEFAULT_DOC_ROOTS[OS.LINUX])

if kb.absFilePaths:

for absFilePath in kb.absFilePaths:

if directories:

break

if directoryPath(absFilePath) == '/':

continue

absFilePath = normalizePath(absFilePath)

windowsDriveLetter = None

if isWindowsDriveLetterPath(absFilePath):

windowsDriveLetter, absFilePath = absFilePath[:2], absFilePath[2:]

absFilePath = ntToPosixSlashes(posixToNtSlashes(absFilePath))

for _ in list(GENERIC_DOC_ROOT_DIRECTORY_NAMES) + [conf.hostname]:

_ = "/%s/" % _

if _ in absFilePath:

directories = "%s%s" % (absFilePath.split(_)[0], _)

break

if not directories and conf.path.strip('/') and conf.path in absFilePath:

directories = absFilePath.split(conf.path)[0]

if directories and windowsDriveLetter:

directories = "%s/%s" % (windowsDriveLetter, ntToPosixSlashes(directories))

directories = normalizePath(directories)

if conf.webRoot:

directories = [conf.webRoot]

infoMsg = "using '%s' as web server document root" % conf.webRoot

logger.info(infoMsg)

elif directories:

infoMsg = "retrieved the web server document root: '%s'" % directories

logger.info(infoMsg)

else:

warnMsg = "unable to automatically retrieve the web server "

warnMsg += "document root"

logger.warning(warnMsg)

directories = []

message = "what do you want to use for writable directory?\n"

message += "[1] common location(s) ('%s') (default)\n" % ", ".join(root for root in defaultDocRoot)

message += "[2] custom location(s)\n"

message += "[3] custom directory list file\n"

message += "[4] brute force search"

choice = readInput(message, default='1')

if choice == '2':

message = "please provide a comma separate list of absolute directory paths: "

directories = readInput(message, default="").split(',')

elif choice == '3':

message = "what's the list file location?\n"

listPath = readInput(message, default="")

checkFile(listPath)

directories = getFileItems(listPath)

elif choice == '4':

targets = set([conf.hostname])

_ = conf.hostname.split('.')

if _[0] == "www":

targets.add('.'.join(_[1:]))

targets.add('.'.join(_[1:-1]))

else:

targets.add('.'.join(_[:-1]))

targets = filterNone(targets)

for prefix in BRUTE_DOC_ROOT_PREFIXES.get(Backend.getOs(), DEFAULT_DOC_ROOTS[OS.LINUX]):

if BRUTE_DOC_ROOT_TARGET_MARK in prefix and re.match(IP_ADDRESS_REGEX, conf.hostname):

continue

for suffix in BRUTE_DOC_ROOT_SUFFIXES:

for target in targets:

if not prefix.endswith("/%s" % suffix):

item = "%s/%s" % (prefix, suffix)

else:

item = prefix

item = item.replace(BRUTE_DOC_ROOT_TARGET_MARK, target).replace("//", '/').rstrip('/')

if item not in directories:

directories.append(item)

if BRUTE_DOC_ROOT_TARGET_MARK not in prefix:

break

infoMsg = "using generated directory list: %s" % ','.join(directories)

logger.info(infoMsg)

msg = "use any additional custom directories [Enter for None]: "

answer = readInput(msg)

if answer:

directories.extend(answer.split(','))

else:

directories = defaultDocRoot

"""

retVal = OrderedSet()

if kb.absFilePaths:

infoMsg = "retrieved web server absolute paths: "

infoMsg += "'%s'" % ", ".join(ntToPosixSlashes(path) for path in kb.absFilePaths)

logger.info(infoMsg)

for absFilePath in kb.absFilePaths:

if absFilePath:

directory = directoryPath(absFilePath)

directory = ntToPosixSlashes(directory)

retVal.add(directory)

else:

warnMsg = "unable to automatically parse any web server path"

logger.warning(warnMsg)

"""

retVal = filePath.replace("/", "_").replace("\\", "_")

retVal = retVal.replace(" ", "_").replace(":", "_")

if flag is None:

flag = hash(message)

if not conf.smokeTest and flag not in kb.singleLogFlags:

kb.singleLogFlags.add(flag)

"""

retVal = message

if any(_ in message for _ in BOLD_PATTERNS):

retVal = setColor(message, bold=True, istty=istty)

"""

retVal = message

if message:

if (IS_TTY or istty) and not conf.get("disableColoring"): # colorizing handler

if level is None:

levels = re.findall(r"\[(?P<result>%s)\]" % '|'.join(_[0] for _ in getPublicTypeMembers(LOGGING_LEVELS)), message)