php

var (
	// InputMethodPattern matches method names that ALWAYS indicate user input
	// Pattern matches:
	// - Explicit input getters: input, get_input, getInput, get_var, variable
	// - HTTP method getters: getPost, getQuery, getCookie, getHeader, etc.
	// - PSR-7 methods: getQueryParams, getParsedBody, getCookieParams, etc.
	// - All input: all()
	InputMethodPattern = regexp.MustCompile(`(?i)^(get_?)?(input|var|variable|query_?params?|parsed_?body|cookie_?params?|server_?params?|uploaded_?files?|headers?|all)$|^(get_?)?(post|cookie|param)s?$`)

	// InputPropertyPattern matches property names that typically hold user input
	// (for array access patterns like ->input['key'])
	// Matches: input, request, params, query, cookies, headers, body, data, args, post, get, files, server
	InputPropertyPattern = regexp.MustCompile(`(?i)^(input|request|params?|query|cookies?|headers?|body|data|args?|post|get|files?|server|attributes?|payload)s?$`)

	// InputObjectPattern matches object/variable names that suggest the object is an input carrier
	// Also matches chain calls like "->getRequest()" or "Factory::getApplication()->getInput()"
	InputObjectPattern = regexp.MustCompile(`(?i)(request|input|req|params?|http|ctx|context|getRequest\(\)|getApplication\(\))`)

	// ExcludeMethodPattern matches method names to EXCLUDE from input detection (false positive prevention)
	// These are methods that might match patterns but aren't typically user input
	ExcludeMethodPattern = regexp.MustCompile(`(?i)^(getData|getBody|getContent|fetch|find|load|read)$`)

	// ContextDependentMethodPattern matches methods like getVal, getText, getInt, getBool
	// used in MediaWiki on request objects but also on many other objects
	// Only detect these when the object looks like a request
	ContextDependentMethodPattern = regexp.MustCompile(`(?i)^(get_?)?(val|text|int|bool|array|raw_?val|check)$`)
)

var (
	// SQLCurlyBracePattern matches '{$var->prop['key']}' - curly brace interpolation in SQL
	SQLCurlyBracePattern = regexp.MustCompile(`\{\s*\$(\w+)->(\w+)\s*\[\s*['"]([^'"]+)['"]\s*\]\s*\}`)

	// SQLSimpleCurlyPattern matches simple property in curly braces {$var->prop}
	SQLSimpleCurlyPattern = regexp.MustCompile(`\{\s*\$(\w+)->(\w+)\s*\}`)

	// SQLNoCurlyPattern matches "...$var->prop..." without curly braces in strings
	SQLNoCurlyPattern = regexp.MustCompile(`"\s*[^"]*\$(\w+)->(\w+)\s*\[\s*['"]([^'"]+)['"]\s*\]`)
)

var (
	// ConcatPattern matches "' . $var->prop['key'] . '" or similar concatenations
	ConcatPattern = regexp.MustCompile(`\.\s*\$(\w+)->(\w+)\s*\[\s*['"]([^'"]+)['"]\s*\]\s*\.`)

	// SimpleConcatPattern matches simple property concatenation '. $var->prop .'
	SimpleConcatPattern = regexp.MustCompile(`\.\s*\$(\w+)->(\w+)\s*\.`)
)

var (
	// EscapeWithPropArrayPattern matches escape_string($var->prop['key']) or $db->escape_string($var->prop['key'])
	EscapeWithPropArrayPattern = regexp.MustCompile(`(\w*escape\w*)\s*\(\s*\$(\w+)->(\w+)\s*\[\s*['"]([^'"]+)['"]\s*\]\s*\)`)

	// EscapeSimplePropPattern matches escape functions with simple property
	EscapeSimplePropPattern = regexp.MustCompile(`(\w*escape\w*)\s*\(\s*\$(\w+)->(\w+)\s*\)`)

	// EscapeVarPattern matches escape with variable
	EscapeVarPattern = regexp.MustCompile(`(\w*escape\w*)\s*\(\s*\$(\w+)\s*\)`)
)

var (
	// GlobalsPattern matches $GLOBALS['varname'] or $GLOBALS["varname"]
	GlobalsPattern = regexp.MustCompile(`\$GLOBALS\[['"](\w+)['"]\]`)

	// DIContainerPattern matches DI container pattern: $var->get('service')
	DIContainerPattern = regexp.MustCompile(`\$\w+->get\(['"]([^'"]+)['"]\)`)
)

var (
	// ThisMethodCallPattern matches $this->methodName($arg)
	ThisMethodCallPattern = regexp.MustCompile(`\$this->(\w+)\(([^)]*)\)`)

	// PropertyAssignLoopPattern builds a pattern for $this->property[$key] = $val
	// Use BuildPropertyAssignLoopPattern for dynamic keys
	PropertyAssignLoopPatternTemplate = `\$this->(%s)\[\$%s\]\s*=\s*\$%s`

	// ForeachPattern matches foreach($array as $key => $val)
	ForeachPattern = regexp.MustCompile(`foreach\s*\(\s*\$(\w+)\s+as\s+\$(\w+)\s*=>\s*\$(\w+)\s*\)`)

	// DirectAssignPatternTemplate for $this->property = $something
	// Use BuildDirectAssignPattern for specific properties
	DirectAssignPatternTemplate = `\$this->%s\s*=\s*([^;]+)`

	// ConditionalPatternTemplate for if($_SUPERGLOBAL[anything])
	// Use BuildConditionalPattern for specific superglobals
	ConditionalPatternTemplate = `if\s*\(\s*%s\[['"]?(\w+)['"]?\]`
)

var (
	// ThisPropertyAssignPattern matches $this->property = ...
	// Used to detect constructor/method parameter flow to properties
	ThisPropertyAssignPattern = regexp.MustCompile(`\$this->(\w+)\s*=`)

	// ThisArrayPropertyAssignPattern matches $this->property[...] = ...
	// Used to detect array property assignments
	ThisArrayPropertyAssignPattern = regexp.MustCompile(`\$this->(\w+)\[.*\]\s*=`)

	// ArrayKeyAccessPattern matches ['key'] or ["key"]
	// Used to extract array keys from expressions
	ArrayKeyAccessPattern = regexp.MustCompile(`\[['"](\w+)['"]\]`)

	// VariableKeyAccessPattern matches [$variable]
	// Used to extract variable-based array access
	VariableKeyAccessPattern = regexp.MustCompile(`\[(\$\w+)\]`)

	// ReturnThisPropertyPrefix is the static prefix for return $this->property patterns
	// Use BuildReturnPropertyPattern for dynamic patterns with specific property names
	ReturnThisPropertyPrefix = `return\s+\$this->`

	// MethodCallSuffix is the suffix pattern for method calls
	MethodCallSuffix = `\(`
)

var AllDatabaseFetchMethods = map[string]bool{

	"fetch":       true,
	"fetchAll":    true,
	"fetchColumn": true,
	"fetchObject": true,

	"fetch_array":  true,
	"fetch_assoc":  true,
	"fetch_row":    true,
	"fetch_object": true,
	"fetch_all":    true,
}

var DatabaseQueryMethods = map[string]bool{

	"query":   true,
	"exec":    true,
	"prepare": true,
	"execute": true,

	"real_query":         true,
	"multi_query":        true,
	"send_query":         true,
	"real_escape_string": true,
}

var DatabaseResultObjectPatterns = []string{
	"result",
	"stmt",
	"statement",
	"query",
	"res",
	"row",
	"rows",
}

var DeserializationFunctions = []string{
	"unserialize",
	"json_decode",
	"simplexml_load_string",
	"simplexml_load_file",
	"yaml_parse",
	"yaml_parse_file",
	"yaml_parse_url",
	"msgpack_unpack",
	"igbinary_unserialize",
	"parse_str",
	"mb_parse_str",
}

var DeserializationFunctionsMap = func() map[string]bool {
	m := make(map[string]bool)
	for _, fn := range DeserializationFunctions {
		m[fn] = true
	}
	return m
}()

var FrameworkDetectionPatterns = map[string]FrameworkDetection{
	"laravel": {
		ImportPatterns: []string{"illuminate", "laravel"},
		SourcePatterns: []string{"Illuminate\\", "Laravel\\"},
	},
	"symfony": {
		ImportPatterns: []string{"symfony"},
		SourcePatterns: []string{"Symfony\\"},
	},
}

var InputFunctions = []string{

	"file_get_contents",
	"fgets",
	"fread",
	"fgetc",
	"fgetss",
	"fgetcsv",
	"file",
	"readfile",
	"stream_get_contents",

	"getenv",
	"getallheaders",
	"apache_request_headers",

	"readline",
	"fscanf",
	"fpassthru",
}

var InputFunctionsMap = func() map[string]bool {
	m := make(map[string]bool)
	for _, fn := range InputFunctions {
		m[fn] = true
	}
	return m
}()

var MethodNamePatterns = map[string]common.SourceType{
	"cookie": common.SourceHTTPCookie,
	"header": common.SourceHTTPHeader,
	"server": common.SourceHTTPHeader,
	"post":   common.SourceHTTPPost,
	"body":   common.SourceHTTPPost,
	"parsed": common.SourceHTTPPost,
	"query":  common.SourceHTTPGet,
	"get":    common.SourceHTTPGet,
	"file":   common.SourceHTTPBody,
	"upload": common.SourceHTTPBody,
}

var MySQLiFetchMethods = map[string]bool{
	"fetch_array":  true,
	"fetch_assoc":  true,
	"fetch_row":    true,
	"fetch_object": true,
	"fetch_all":    true,
}

var NetworkFunctions = []string{

	"curl_exec",
	"curl_multi_getcontent",
	"curl_multi_exec",

	"file_get_contents",
	"fopen",
	"fsockopen",
	"pfsockopen",

	"http_get",
	"http_post",
	"http_request",

	"socket_read",
	"socket_recv",
	"socket_recvfrom",

	"stream_socket_recvfrom",
	"stream_get_contents",
}

var NetworkFunctionsMap = func() map[string]bool {
	m := make(map[string]bool)
	for _, fn := range NetworkFunctions {
		m[fn] = true
	}
	return m
}()

var PDOFetchMethods = map[string]bool{
	"fetch":       true,
	"fetchAll":    true,
	"fetchColumn": true,
	"fetchObject": true,
}

var PHPFileExtensions = []string{".php", ".php5", ".php7", ".phtml"}

var PHPInputFunctions = []string{
	"file_get_contents",
	"fread",
	"fgets",
	"fgetc",
	"stream_get_contents",
	"readfile",
}

var PHPInputProperties = []string{"input", "cookies", "query", "request", "files", "server", "headers"}

var PHPNodeTypes = struct {
	// Class and function nodes
	ClassDeclaration    string
	MethodDeclaration   string
	FunctionDefinition  string
	PropertyDeclaration string
	DeclarationList     string

	// Variable and expression nodes
	VariableName            string
	SubscriptExpression     string
	MemberAccessExpression  string
	MemberCallExpression    string
	FunctionCallExpression  string
	ScopedCallExpression    string
	AssignmentExpression    string
	BinaryExpression        string
	ParenthesizedExpression string
	EncapsedString          string

	// Parameter types
	SimpleParameter            string
	VariadicParameter          string
	PropertyPromotionParameter string

	// Statement nodes
	ForeachStatement string
	ReturnStatement  string

	// Field names
	FieldName       string
	FieldBaseClause string
	FieldBody       string
	FieldObject     string
	FieldIndex      string
	FieldLeft       string
	FieldRight      string
	FieldFunction   string

	// Modifier types
	VisibilityModifier string
	StaticModifier     string

	// Visibility values
	VisibilityPublic    string
	VisibilityProtected string
	VisibilityPrivate   string
}{
	ClassDeclaration:    "class_declaration",
	MethodDeclaration:   "method_declaration",
	FunctionDefinition:  "function_definition",
	PropertyDeclaration: "property_declaration",
	DeclarationList:     "declaration_list",

	VariableName:            "variable_name",
	SubscriptExpression:     "subscript_expression",
	MemberAccessExpression:  "member_access_expression",
	MemberCallExpression:    "member_call_expression",
	FunctionCallExpression:  "function_call_expression",
	ScopedCallExpression:    "scoped_call_expression",
	AssignmentExpression:    "assignment_expression",
	BinaryExpression:        "binary_expression",
	ParenthesizedExpression: "parenthesized_expression",
	EncapsedString:          "encapsed_string",

	SimpleParameter:            "simple_parameter",
	VariadicParameter:          "variadic_parameter",
	PropertyPromotionParameter: "property_promotion_parameter",

	ForeachStatement: "foreach_statement",
	ReturnStatement:  "return_statement",

	FieldName:       "name",
	FieldBaseClause: "base_clause",
	FieldBody:       "body",
	FieldObject:     "object",
	FieldIndex:      "index",
	FieldLeft:       "left",
	FieldRight:      "right",
	FieldFunction:   "function",

	VisibilityModifier: "visibility_modifier",
	StaticModifier:     "static_modifier",

	VisibilityPublic:    "public",
	VisibilityProtected: "protected",
	VisibilityPrivate:   "private",
}

var PropertyNamePatterns = map[string]common.SourceType{
	"cookie":  common.SourceHTTPCookie,
	"cookies": common.SourceHTTPCookie,
	"header":  common.SourceHTTPHeader,
	"headers": common.SourceHTTPHeader,
	"server":  common.SourceHTTPHeader,
	"post":    common.SourceHTTPPost,
	"body":    common.SourceHTTPPost,
	"query":   common.SourceHTTPGet,
	"get":     common.SourceHTTPGet,
	"file":    common.SourceHTTPBody,
	"files":   common.SourceHTTPBody,
}

var Registry = common.NewFrameworkPatternRegistry("php")

var TaintPatterns = struct {
	// ThisArrayPattern matches $this->prop[$key] = assignments
	ThisArrayPattern *regexp.Regexp

	// DynamicPropPattern matches $this->$key = $val assignments
	DynamicPropPattern *regexp.Regexp

	// ReturnThisPattern matches return $this->prop statements
	ReturnThisPattern *regexp.Regexp

	// SuperglobalKeyPattern extracts keys from superglobal access
	SuperglobalKeyPattern *regexp.Regexp

	// LoopVariablePattern matches foreach loop variable assignments
	LoopVariablePattern *regexp.Regexp

	// ForeachValueOnlyPattern matches foreach($x as $value) without key
	ForeachValueOnlyPattern *regexp.Regexp

	// ThisPropertyOptionalArrayPattern matches $this->prop or $this->prop[...]
	ThisPropertyOptionalArrayPattern *regexp.Regexp

	// ReturnThisPropertyArrayPattern matches return $this->prop[...]
	ReturnThisPropertyArrayPattern *regexp.Regexp
}{
	ThisArrayPattern:                 regexp.MustCompile(`\$this->(\w+)\[\$\w+\]\s*=`),
	DynamicPropPattern:               regexp.MustCompile(`\$this->\$(\w+)\s*=`),
	ReturnThisPattern:                regexp.MustCompile(`return\s+\$this->(\w+)`),
	SuperglobalKeyPattern:            regexp.MustCompile(`\$_[A-Z]+\s*\[\s*['"]([^'"]+)['"]\s*\]`),
	LoopVariablePattern:              regexp.MustCompile(`as\s+\$(\w+)\s*=>\s*\$(\w+)`),
	ForeachValueOnlyPattern:          regexp.MustCompile(`as\s+\$(\w+)\s*\)`),
	ThisPropertyOptionalArrayPattern: regexp.MustCompile(`\$this->(\w+)(?:\[[^\]]*\])?`),
	ReturnThisPropertyArrayPattern:   regexp.MustCompile(`return\s+\$this->(\w+)\[`),
}