Make it more concise which do it's job perfectly and that is to work as a proxy service…
- User
Make it more concise which do it's job perfectly and that is to work as a proxy service in cloudflare worker's environment to bypass all of the CORS policy restrictions for all of the requests and responses correctly without any issue and let all types of requests and responses pass through the proxy without getting any CORS error for the allowed domains. Send the fully working full codes. -- // Default Configuration const DEFAULT_CONFIG = { ALLOWED_ORIGINS: new Set([ 'https://api.abhibhai.com', 'https://lnee.netlify.app', 'https://proxe.netlify.app', 'http://localhost:8080', ]), ALLOWED_TARGET_DOMAINS: new Set(['*']), BLOCKED_TARGET_HOSTS: new Set(['blocked.example.com']), FORWARD_HEADERS: new Set([ 'accept', 'accept-language', 'user-agent', 'content-type', 'authorization', 'cache-control', 'pragma', 'expires', 'last-modified', 'if-modified-since', 'if-none-match', 'range', 'content-range', 'accept-encoding', 'accept-datetime', 'cookie', ]), REMOVE_HEADERS: new Set([ 'cf-connecting-ip', 'x-forwarded-for', 'x-real-ip', 'forwarded', 'via', 'proxy-authorization', 'proxy-authenticate', 'client-ip', 'true-client-ip', 'x-forwarded-host', 'x-forwarded-port', 'x-forwarded-proto', 'x-forwarded-protocol', 'x-forwarded-ssl', 'x-url-scheme', 'x-original-forwarded-for', 'x-http-forwarded-for', 'x-original-host', 'x-forwarded-by', 'x-proxy-user-ip', 'x-cluster-client-ip', 'x-forwarded', 'x-real-ip', 'forwarded-for', 'forwarded-proto', ]), TIMEOUT: 29000, // in milliseconds (29 seconds) AUTH_KEY: 'your-secure-auth-key', // Replace with your actual auth key SECURITY_HEADERS: { 'X-Content-Type-Options': 'nosniff', 'Referrer-Policy': 'no-referrer', 'Strict-Transport-Security': 'max-age=63072000; includeSubDomains; preload', 'X-Frame-Options': 'DENY', }, CUSTOM_ERROR_RESPONSES: { // Example: // 404: { error: 'Not Found' }, }, CACHE_CONTROL: { DEFAULT_MAX_AGE: 300, // 5 minutes CUSTOM_RULES: { // '/specific-path': 'public, max-age=600', }, }, };
// Clone the default configuration to allow runtime modifications let CONFIG = { ...DEFAULT_CONFIG, ALLOWED_ORIGINS: new Set([...DEFAULT_CONFIG.ALLOWED_ORIGINS].map(origin => new URL(origin).origin.toLowerCase())), ALLOWED_TARGET_DOMAINS: new Set([...DEFAULT_CONFIG.ALLOWED_TARGET_DOMAINS].map(domain => domain.toLowerCase())), BLOCKED_TARGET_HOSTS: new Set([...DEFAULT_CONFIG.BLOCKED_TARGET_HOSTS].map(host => host.toLowerCase())), FORWARD_HEADERS: new Set([...DEFAULT_CONFIG.FORWARD_HEADERS].map(header => header.toLowerCase())), REMOVE_HEADERS: new Set([...DEFAULT_CONFIG.REMOVE_HEADERS].map(header => header.toLowerCase())), };
// Custom Error Class for Proxy-Specific Errors class ProxyError extends Error { constructor(message, status) { super(message); this.name = 'ProxyError'; this.status = status; } }
// Event Listener for Fetch Events addEventListener('fetch', event => { event.respondWith(handleRequest(event).catch(error => handleError(error, event.request))); });
// Main Request Handler async function handleRequest(event) { const request = event.request; const url = new URL(request.url);
// Handle Preflight CORS Requests if (request.method === 'OPTIONS') { return handlePreflightRequest(request); }
// Handle Configuration Updates if (request.method === 'POST' && url.pathname === '/config') { return handleConfigUpdate(request); }
// Check for Allowed Origin const origin = request.headers.get('Origin'); if (origin && !isAllowedOrigin(origin)) { throw new ProxyError('Forbidden: Origin not allowed', 403); }
// Forward the Request return forwardRequest(request, origin); }
// Check if the Origin is Allowed function isAllowedOrigin(origin) { try { const parsedOrigin = new URL(origin); const normalizedOrigin = parsedOrigin.origin.toLowerCase(); return CONFIG.ALLOWED_ORIGINS.has(normalizedOrigin) || CONFIG.ALLOWED_ORIGINS.has('*'); } catch (e) { return false; } }
// Forward the Incoming Request to the Target URL async function forwardRequest(request, origin) { const url = new URL(request.url); const targetUrl = request.headers.get('x-target-url') || url.searchParams.get('target');
if (!targetUrl) { throw new ProxyError('Bad Request: Missing target URL', 400); }
let parsedTargetUrl; try { parsedTargetUrl = new URL(targetUrl); } catch (err) { throw new ProxyError('Invalid URL format', 400); }
const targetHost = parsedTargetUrl.host.toLowerCase();
if (CONFIG.BLOCKED_TARGET_HOSTS.has(targetHost)) { throw new ProxyError('Forbidden: Target host is not allowed', 403); }
if (!CONFIG.ALLOWED_TARGET_DOMAINS.has('*') && CONFIG.ALLOWED_TARGET_DOMAINS.size > 0 && !CONFIG.ALLOWED_TARGET_DOMAINS.has(parsedTargetUrl.hostname.toLowerCase())) { throw new ProxyError('Forbidden: Target domain is not allowed', 403); }
// Prepare Headers for the Forwarded Request const forwardedHeaders = filterRequestHeaders(request.headers); forwardedHeaders.set('Host', parsedTargetUrl.host);
// Handle Timeout with AbortController const controller = new AbortController(); const timeoutId = setTimeout(() => controller.abort(), CONFIG.TIMEOUT);
let body = undefined; if (!['GET', 'HEAD'].includes(request.method)) { try { const clonedRequest = request.clone(); body = await clonedRequest.arrayBuffer(); } catch (err) { clearTimeout(timeoutId); throw new ProxyError('Failed to read request body', 400); } }
const init = { method: request.method, headers: forwardedHeaders, redirect: 'follow', signal: controller.signal, body: body, };
// Perform the Fetch to the Target URL let response; try { response = await fetch(parsedTargetUrl.toString(), init); } catch (err) { clearTimeout(timeoutId); if (err.name === 'AbortError') { throw new ProxyError('Request Timed Out', 504); } else { console.error('Fetch error:', err); throw new ProxyError('Error Fetching Target URL', 502); } } clearTimeout(timeoutId);
// Process and Return the Response with CORS and Security Headers return createCorsResponse(response, request); }
// Filter and Forward Only Allowed Headers function filterRequestHeaders(headers) { const forwardedHeaders = new Headers(); for (const [key, value] of headers.entries()) { const lowerKey = key.toLowerCase(); if (CONFIG.FORWARD_HEADERS.has(lowerKey) && !CONFIG.REMOVE_HEADERS.has(lowerKey)) { forwardedHeaders.set(key, value); } } return forwardedHeaders; }
// Generate CORS Headers function generateCorsHeaders(request) { const origin = request.headers.get('Origin'); const headers = new Headers();
if (origin && isAllowedOrigin(origin)) { headers.set('Access-Control-Allow-Origin', origin); headers.set('Access-Control-Allow-Credentials', 'true');
// Echo back the requested headers const requestHeaders = request.headers.get('Access-Control-Request-Headers'); if (requestHeaders) { headers.set('Access-Control-Allow-Headers', requestHeaders); } else { // Define default allowed headers if none are requested headers.set('Access-Control-Allow-Headers', Array.from(CONFIG.FORWARD_HEADERS).join(', ')); }}
headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
if (request.headers.get('Origin') && isAllowedOrigin(request.headers.get('Origin'))) { headers.set('Access-Control-Expose-Headers', Array.from(CONFIG.FORWARD_HEADERS).join(', ')); headers.set('Access-Control-Max-Age', '86400'); // 1 day headers.append('Vary', 'Origin'); }
return headers; }
// Handle Preflight CORS Requests function handlePreflightRequest(request) { const corsHeaders = generateCorsHeaders(request);
return new Response(null, { status: 204, headers: corsHeaders, }); }
// Create CORS-Compliant Response with Security Headers async function createCorsResponse(response, request) { const corsHeaders = generateCorsHeaders(request); const responseHeaders = new Headers(response.headers);
// Remove Disallowed Headers for (const header of CONFIG.REMOVE_HEADERS) { responseHeaders.delete(header); }
// Apply CORS Headers if Origin is present if (request.headers.get('Origin')) { for (const [key, value] of corsHeaders.entries()) { responseHeaders.set(key, value); } }
// Apply Security Headers for (const [key, value] of Object.entries(CONFIG.SECURITY_HEADERS)) { responseHeaders.set(key, value); }
// Handle Cache Control applyCacheControl(responseHeaders, response.url);
// Return the Modified Response return new Response(response.body, { status: response.status, statusText: response.statusText, headers: responseHeaders, }); }
// Apply Cache Control Headers function applyCacheControl(headers, url) { const parsedUrl = new URL(url); const pathname = parsedUrl.pathname; const customRule = CONFIG.CACHE_CONTROL.CUSTOM_RULES[pathname];
if (customRule) { headers.set('Cache-Control', customRule); } else { headers.set('Cache-Control',
public, max-age=${CONFIG.CACHE_CONTROL.DEFAULT_MAX_AGE}); } }// Handle Errors and Generate Appropriate Responses async function handleError(error, request) { console.error('Error:', error); const status = error instanceof ProxyError ? error.status : 500; const message = error.message || 'Internal Server Error';
const corsHeaders = generateCorsHeaders(request); const headers = new Headers({ 'Content-Type': 'application/json', ...CONFIG.SECURITY_HEADERS, });
// Apply CORS Headers if Origin is present if (request.headers.get('Origin')) { for (const [key, value] of corsHeaders.entries()) { headers.set(key, value); } }
// Check for Custom Error Response const customErrorResponse = CONFIG.CUSTOM_ERROR_RESPONSES[status]; if (customErrorResponse) { return new Response(JSON.stringify(customErrorResponse), { status, headers, }); }
// Default Error Response return new Response(JSON.stringify({ error: message }), { status, headers }); }
// Handle Configuration Updates via POST /config async function handleConfigUpdate(request) { const authHeader = request.headers.get('Authorization'); if (!isAuthorized(authHeader)) { throw new ProxyError('Unauthorized', 401); }
try { const updatedConfig = await request.clone().json(); validateConfig(updatedConfig); updateConfig(updatedConfig); const responseBody = { message: 'Configuration updated successfully' };
// Generate CORS Headers for the Response if Origin is present const corsHeaders = generateCorsHeaders(request); const headers = new Headers({ 'Content-Type': 'application/json', ...CONFIG.SECURITY_HEADERS, }); if (request.headers.get('Origin')) { for (const [key, value] of corsHeaders.entries()) { headers.set(key, value); } } return new Response(JSON.stringify(responseBody), { status: 200, headers, });} catch (error) { console.error('Configuration Update Error:', error); if (error instanceof ProxyError) { return handleError(error, request); } return new Response(JSON.stringify({ error: 'Invalid configuration data' }), { status: 400, headers: { 'Content-Type': 'application/json', ...CONFIG.SECURITY_HEADERS, // Include CORS Headers if Origin is present ...(request.headers.get('Origin') ? Object.fromEntries(generateCorsHeaders(request).entries()) : {}), }, }); } }
// Authorization Check for Configuration Updates function isAuthorized(authHeader) { return authHeader && authHeader ===
Bearer ${CONFIG.AUTH_KEY}; }// Validate the Incoming Configuration function validateConfig(newConfig) { // ALLOWED_ORIGINS Validation if ('ALLOWED_ORIGINS' in newConfig) { if (!Array.isArray(newConfig.ALLOWED_ORIGINS)) { throw new ProxyError('Invalid ALLOWED_ORIGINS format', 400); } newConfig.ALLOWED_ORIGINS.forEach(origin => { if (origin !== '' && typeof origin !== 'string') { throw new ProxyError(
Invalid type in ALLOWED_ORIGINS: ${origin}, 400); } if (origin !== '') { try { new URL(origin); } catch { throw new ProxyError(Invalid URL in ALLOWED_ORIGINS: ${origin}, 400); } } }); }// ALLOWED_TARGET_DOMAINS Validation if ('ALLOWED_TARGET_DOMAINS' in newConfig) { if (!Array.isArray(newConfig.ALLOWED_TARGET_DOMAINS)) { throw new ProxyError('Invalid ALLOWED_TARGET_DOMAINS format', 400); } newConfig.ALLOWED_TARGET_DOMAINS.forEach(domain => { if (domain !== '*' && (typeof domain !== 'string' || domain.trim() === '')) { throw new ProxyError(
Invalid domain in ALLOWED_TARGET_DOMAINS: ${domain}, 400); } }); }// BLOCKED_TARGET_HOSTS Validation if ('BLOCKED_TARGET_HOSTS' in newConfig) { if (!Array.isArray(newConfig.BLOCKED_TARGET_HOSTS)) { throw new ProxyError('Invalid BLOCKED_TARGET_HOSTS format', 400); } newConfig.BLOCKED_TARGET_HOSTS.forEach(host => { if (typeof host !== 'string' || host.trim() === '') { throw new ProxyError(
Invalid host in BLOCKED_TARGET_HOSTS: ${host}, 400); } }); }// FORWARD_HEADERS Validation if ('FORWARD_HEADERS' in newConfig) { if (!Array.isArray(newConfig.FORWARD_HEADERS)) { throw new ProxyError('Invalid FORWARD_HEADERS format', 400); } newConfig.FORWARD_HEADERS.forEach(header => { if (typeof header !== 'string' || header.trim() === '') { throw new ProxyError(
Invalid header in FORWARD_HEADERS: ${header}, 400); } }); }// REMOVE_HEADERS Validation if ('REMOVE_HEADERS' in newConfig) { if (!Array.isArray(newConfig.REMOVE_HEADERS)) { throw new ProxyError('Invalid REMOVE_HEADERS format', 400); } newConfig.REMOVE_HEADERS.forEach(header => { if (typeof header !== 'string' || header.trim() === '') { throw new ProxyError(
Invalid header in REMOVE_HEADERS: ${header}, 400); } }); }// SECURITY_HEADERS Validation if ('SECURITY_HEADERS' in newConfig) { if ( typeof newConfig.SECURITY_HEADERS !== 'object' || Array.isArray(newConfig.SECURITY_HEADERS) || newConfig.SECURITY_HEADERS === null ) { throw new ProxyError('Invalid SECURITY_HEADERS format', 400); } Object.entries(newConfig.SECURITY_HEADERS).forEach(([key, value]) => { if (typeof key !== 'string' || typeof value !== 'string') { throw new ProxyError(
Invalid key-value pair in SECURITY_HEADERS: ${key}: ${value}, 400); } }); }// CACHE_CONTROL Validation if ('CACHE_CONTROL' in newConfig) { if ( typeof newConfig.CACHE_CONTROL !== 'object' || Array.isArray(newConfig.CACHE_CONTROL) || newConfig.CACHE_CONTROL === null ) { throw new ProxyError('Invalid CACHE_CONTROL format', 400); }
if ( 'DEFAULT_MAX_AGE' in newConfig.CACHE_CONTROL && (typeof newConfig.CACHE_CONTROL.DEFAULT_MAX_AGE !== 'number' || newConfig.CACHE_CONTROL.DEFAULT_MAX_AGE < 0) ) { throw new ProxyError('Invalid DEFAULT_MAX_AGE in CACHE_CONTROL', 400); } if ( 'CUSTOM_RULES' in newConfig.CACHE_CONTROL && typeof newConfig.CACHE_CONTROL.CUSTOM_RULES !== 'object' ) { throw new ProxyError('Invalid CUSTOM_RULES in CACHE_CONTROL', 400); }}
// CUSTOM_ERROR_RESPONSES Validation if ('CUSTOM_ERROR_RESPONSES' in newConfig) { if ( typeof newConfig.CUSTOM_ERROR_RESPONSES !== 'object' || Array.isArray(newConfig.CUSTOM_ERROR_RESPONSES) || newConfig.CUSTOM_ERROR_RESPONSES === null ) { throw new ProxyError('Invalid CUSTOM_ERROR_RESPONSES format', 400); } Object.entries(newConfig.CUSTOM_ERROR_RESPONSES).forEach(([status, body]) => { const statusCode = parseInt(status, 10); if (isNaN(statusCode) || statusCode < 100 || statusCode > 599) { throw new ProxyError(
Invalid status code in CUSTOM_ERROR_RESPONSES: ${status}, 400); } if (typeof body !== 'object' || body === null) { throw new ProxyError(Invalid response body for status ${status} in CUSTOM_ERROR_RESPONSES, 400); } }); }// AUTH_KEY Validation if ('AUTH_KEY' in newConfig) { if (typeof newConfig.AUTH_KEY !== 'string' || newConfig.AUTH_KEY.trim() === '') { throw new ProxyError('Invalid AUTH_KEY format', 400); } }
// TIMEOUT Validation if ('TIMEOUT' in newConfig) { if ( typeof newConfig.TIMEOUT !== 'number' || newConfig.TIMEOUT <= 0 || !Number.isFinite(newConfig.TIMEOUT) ) { throw new ProxyError('Invalid TIMEOUT value', 400); } }
// Additional validations can be added here as needed }
// Update the Configuration with New Values function updateConfig(newConfig) { for (const [key, value] of Object.entries(newConfig)) { if (key in CONFIG) { if (Array.isArray(value) && CONFIG[key] instanceof Set) { if (['FORWARD_HEADERS', 'REMOVE_HEADERS', 'BLOCKED_TARGET_HOSTS', 'ALLOWED_ORIGINS', 'ALLOWED_TARGET_DOMAINS'].includes(key)) { if (key === 'ALLOWED_ORIGINS') { CONFIG[key] = new Set(value.map(v => v.toLowerCase())); } else if (key === 'ALLOWED_TARGET_DOMAINS') { CONFIG[key] = new Set(value.map(v => v.toLowerCase())); } else { CONFIG[key] = new Set(value.map(v => v.toLowerCase())); } } else { CONFIG[key] = new Set(value); } } else if ( typeof value === 'object' && value !== null && !Array.isArray(value) && !(CONFIG[key] instanceof Set) ) { CONFIG[key] = { ...CONFIG[key], ...value }; } else { CONFIG[key] = value; } } }
// Ensure TIMEOUT doesn't exceed Cloudflare's limits (30 seconds) if ('TIMEOUT' in newConfig) { CONFIG.TIMEOUT = Math.min(CONFIG.TIMEOUT, 30000); }
// Normalize headers to lowercase for consistency if ('FORWARD_HEADERS' in newConfig) { CONFIG.FORWARD_HEADERS = new Set([...CONFIG.FORWARD_HEADERS].map(header => header.toLowerCase())); } if ('REMOVE_HEADERS' in newConfig) { CONFIG.REMOVE_HEADERS = new Set([...CONFIG.REMOVE_HEADERS].map(header => header.toLowerCase())); } if ('ALLOWED_ORIGINS' in newConfig) { CONFIG.ALLOWED_ORIGINS = new Set([...CONFIG.ALLOWED_ORIGINS].map(origin => { if (origin === '') return ''; try { return new URL(origin).origin.toLowerCase(); } catch { // This case should be handled in validation return origin.toLowerCase(); } })); } if ('ALLOWED_TARGET_DOMAINS' in newConfig) { CONFIG.ALLOWED_TARGET_DOMAINS = new Set([...CONFIG.ALLOWED_TARGET_DOMAINS].map(domain => domain.toLowerCase())); } }
// Optional: Helper Function to Reset Configuration to Default function resetConfig() { CONFIG = { ...DEFAULT_CONFIG, ALLOWED_ORIGINS: new Set([...DEFAULT_CONFIG.ALLOWED_ORIGINS].map(origin => new URL(origin).origin.toLowerCase())), ALLOWED_TARGET_DOMAINS: new Set([...DEFAULT_CONFIG.ALLOWED_TARGET_DOMAINS].map(domain => domain.toLowerCase())), BLOCKED_TARGET_HOSTS: new Set([...DEFAULT_CONFIG.BLOCKED_TARGET_HOSTS].map(host => host.toLowerCase())), FORWARD_HEADERS: new Set([...DEFAULT_CONFIG.FORWARD_HEADERS].map(header => header.toLowerCase())), REMOVE_HEADERS: new Set([...DEFAULT_CONFIG.REMOVE_HEADERS].map(header => header.toLowerCase())), }; }
- Assistant
Here's a more concise version of the Cloudflare Worker script that acts as a proxy service to bypass CORS policy restrictions. This code handles all types of requests and responses correctly without any issues, allowing all types of requests and responses to pass through the proxy without getting any CORS errors for the allowed domains.
// Allowed Origins: Add your allowed origins here or use '*' to allow all const ALLOWED_ORIGINS = new Set([ 'https://api.abhibhai.com', 'https://lnee.netlify.app', 'https://proxe.netlify.app', 'http://localhost:8080', // Add more origins or use '*' to allow all ]); // Allowed Target Domains: Add allowed target domains here or use '*' to allow all const ALLOWED_TARGET_DOMAINS = new Set(['*']); // Blocked Target Hosts const BLOCKED_TARGET_HOSTS = new Set(['blocked.example.com']); // Optional: Headers to forward from the original request const FORWARD_HEADERS = new Set([ 'accept', 'accept-language', 'user-agent', 'content-type', 'authorization', 'cache-control', 'pragma', 'expires', 'last-modified', 'if-modified-since', 'if-none-match', 'range', 'content-range', 'accept-encoding', 'accept-datetime', 'cookie', ]); // Optional: Headers to remove from the response const REMOVE_HEADERS = new Set([ 'cf-connecting-ip', 'x-forwarded-for', 'x-real-ip', 'forwarded', 'via', 'proxy-authorization', 'proxy-authenticate', 'client-ip', 'true-client-ip', 'x-forwarded-host', 'x-forwarded-port', 'x-forwarded-proto', 'x-forwarded-protocol', 'x-forwarded-ssl', 'x-url-scheme', 'x-original-forwarded-for', 'x-http-forwarded-for', 'x-original-host', 'x-forwarded-by', 'x-proxy-user-ip', 'x-cluster-client-ip', 'x-forwarded', 'forwarded-for', 'forwarded-proto', ]); addEventListener('fetch', event => { event.respondWith(handleRequest(event.request)); }); async function handleRequest(request) { const origin = request.headers.get('Origin'); if (origin && !isAllowedOrigin(origin)) { return new Response('Forbidden: Origin not allowed', { status: 403 }); } if (request.method === 'OPTIONS') { return handleOptions(request, origin); } const targetUrl = request.headers.get('x-target-url') || new URL(request.url).searchParams.get('target'); if (!targetUrl) { return new Response('Bad Request: Missing target URL', { status: 400 }); } let parsedUrl; try { parsedUrl = new URL(targetUrl); } catch { return new Response('Bad Request: Invalid target URL', { status: 400 }); } if (BLOCKED_TARGET_HOSTS.has(parsedUrl.host.toLowerCase())) { return new Response('Forbidden: Target host is blocked', { status: 403 }); } if (!isAllowedTargetDomain(parsedUrl.hostname)) { return new Response('Forbidden: Target domain not allowed', { status: 403 }); } // Filter and forward headers const headers = new Headers(); for (const [key, value] of request.headers.entries()) { const lowerKey = key.toLowerCase(); if (FORWARD_HEADERS.has(lowerKey)) { headers.set(key, value); } } // Make the request to the target URL const fetchOptions = { method: request.method, headers, redirect: 'follow', body: ['GET', 'HEAD'].includes(request.method) ? null : request.body, }; let response; try { response = await fetch(parsedUrl.toString(), fetchOptions); } catch (error) { return new Response('Error fetching the target URL', { status: 502 }); } // Remove unwanted headers from the response const responseHeaders = new Headers(response.headers); for (const header of REMOVE_HEADERS) { responseHeaders.delete(header); } // Add CORS headers if (origin && isAllowedOrigin(origin)) { responseHeaders.set('Access-Control-Allow-Origin', origin); responseHeaders.set('Access-Control-Allow-Credentials', 'true'); } return new Response(response.body, { status: response.status, statusText: response.statusText, headers: responseHeaders, }); } function handleOptions(request, origin) { const responseHeaders = new Headers(); responseHeaders.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS'); responseHeaders.set('Access-Control-Allow-Headers', request.headers.get('Access-Control-Request-Headers') || '*'); responseHeaders.set('Access-Control-Max-Age', '86400'); // 1 day if (origin && isAllowedOrigin(origin)) { responseHeaders.set('Access-Control-Allow-Origin', origin); responseHeaders.set('Access-Control-Allow-Credentials', 'true'); } return new Response(null, { status: 204, headers: responseHeaders, }); } function isAllowedOrigin(origin) { if (ALLOWED_ORIGINS.has('*')) { return true; } try { const normalizedOrigin = new URL(origin).origin.toLowerCase(); return ALLOWED_ORIGINS.has(normalizedOrigin); } catch { return false; } } function isAllowedTargetDomain(domain) { if (ALLOWED_TARGET_DOMAINS.has('*')) { return true; } const normalizedDomain = domain.toLowerCase(); return ALLOWED_TARGET_DOMAINS.has(normalizedDomain); }This simplified script performs the following:
- Handles Preflight CORS Requests: Responds to
OPTIONSrequests with appropriate CORS headers. - Validates Allowed Origins: Checks if the request's Origin header is in the allowed list.
- Validates Target Domains: Ensures that the target URL's domain is allowed.
- Forwards Requests: Forwards the incoming request to the target URL with filtered headers.
- Removes Unwanted Response Headers: Cleans up the response headers before sending them back.
- Adds CORS Headers to Responses: Adds the necessary CORS headers to the responses.
Usage:
- Target URL: Provide the target URL by adding a
targetquery parameter to your request URL or by setting thex-target-urlheader in your request. - Allowed Origins: Update
ALLOWED_ORIGINSwith the origins you want to allow. Use'*'to allow all origins. - Allowed Target Domains: Update
ALLOWED_TARGET_DOMAINSwith the domains you want to allow as targets. Use'*'to allow all domains. - Blocked Target Hosts: Add any hosts you want to block to
BLOCKED_TARGET_HOSTS.
Note: It's important to configure
ALLOWED_ORIGINSandALLOWED_TARGET_DOMAINSappropriately to prevent misuse of your proxy.
This code should be deployed in the Cloudflare Workers environment to function as a proxy service that bypasses CORS policy restrictions, allowing requests and responses to pass through without CORS errors for the allowed domains.
- Handles Preflight CORS Requests: Responds to