void DocumentThreadableLoader::handleResponse(unsigned long identifier, const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle) { ASSERT(m_client); if (!m_actualRequest.isNull()) { reportResponseReceived(identifier, response); handlePreflightResponse(response); // |this| may be dead here in async mode. return; } if (response.wasFetchedViaServiceWorker()) { // It's still possible to reach here with null m_fallbackRequestForServiceWorker // if the request was for main resource loading (i.e. for SharedWorker), for which // we create DocumentLoader before the controller ServiceWorker is set. ASSERT(!m_fallbackRequestForServiceWorker.isNull() || m_requestContext == WebURLRequest::RequestContextSharedWorker); if (response.wasFallbackRequiredByServiceWorker()) { // At this point we must have m_fallbackRequestForServiceWorker. // (For SharedWorker the request won't be CORS or CORS-with-preflight, // therefore fallback-to-network is handled in the browser process // when the ServiceWorker does not call respondWith().) ASSERT(!m_fallbackRequestForServiceWorker.isNull()); reportResponseReceived(identifier, response); loadFallbackRequestForServiceWorker(); // |this| may be dead here in async mode. return; } m_fallbackRequestForServiceWorker = ResourceRequest(); m_client->didReceiveResponse(identifier, response, handle); return; } // Even if the request met the conditions to get handled by a Service Worker // in the constructor of this class (and therefore // |m_fallbackRequestForServiceWorker| is set), the Service Worker may skip // processing the request. Only if the request is same origin, the skipped // response may come here (wasFetchedViaServiceWorker() returns false) since // such a request doesn't have to go through the CORS algorithm by calling // loadFallbackRequestForServiceWorker(). // FIXME: We should use |m_sameOriginRequest| when we will support // Suborigins (crbug.com/336894) for Service Worker. ASSERT(m_fallbackRequestForServiceWorker.isNull() || securityOrigin()->canRequest(m_fallbackRequestForServiceWorker.url())); m_fallbackRequestForServiceWorker = ResourceRequest(); if (!m_sameOriginRequest && m_options.crossOriginRequestPolicy == UseAccessControl) { String accessControlErrorDescription; if (!passesAccessControlCheck(response, effectiveAllowCredentials(), securityOrigin(), accessControlErrorDescription, m_requestContext)) { reportResponseReceived(identifier, response); ThreadableLoaderClient* client = m_client; clear(); client->didFailAccessControlCheck(ResourceError(errorDomainBlinkInternal, 0, response.url().string(), accessControlErrorDescription)); // |this| may be dead here. return; } } m_client->didReceiveResponse(identifier, response, handle); }
void DocumentThreadableLoader::makeCrossOriginAccessRequest(const ResourceRequest& request) { ASSERT(m_options.crossOriginRequestPolicy == UseAccessControl); ASSERT(m_client); ASSERT(!resource()); // Cross-origin requests are only allowed certain registered schemes. // We would catch this when checking response headers later, but there // is no reason to send a request, preflighted or not, that's guaranteed // to be denied. if (!SchemeRegistry::shouldTreatURLSchemeAsCORSEnabled(request.url().protocol())) { ThreadableLoaderClient* client = m_client; clear(); client->didFailAccessControlCheck(ResourceError(errorDomainBlinkInternal, 0, request.url().string(), "Cross origin requests are only supported for protocol schemes: " + SchemeRegistry::listOfCORSEnabledURLSchemes() + ".")); // |this| may be dead here in async mode. return; } // We use isSimpleOrForbiddenRequest() here since |request| may have been // modified in the process of loading (not from the user's input). For // example, referrer. We need to accept them. For security, we must reject // forbidden headers/methods at the point we accept user's input. Not here. if ((m_options.preflightPolicy == ConsiderPreflight && FetchUtils::isSimpleOrForbiddenRequest(request.httpMethod(), request.httpHeaderFields())) || m_options.preflightPolicy == PreventPreflight) { ResourceRequest crossOriginRequest(request); ResourceLoaderOptions crossOriginOptions(m_resourceLoaderOptions); updateRequestForAccessControl(crossOriginRequest, securityOrigin(), effectiveAllowCredentials()); // We update the credentials mode according to effectiveAllowCredentials() here for backward compatibility. But this is not correct. // FIXME: We should set it in the caller of DocumentThreadableLoader. crossOriginRequest.setFetchCredentialsMode(effectiveAllowCredentials() == AllowStoredCredentials ? WebURLRequest::FetchCredentialsModeInclude : WebURLRequest::FetchCredentialsModeOmit); loadRequest(crossOriginRequest, crossOriginOptions); } else { m_crossOriginNonSimpleRequest = true; ResourceRequest crossOriginRequest(request); ResourceLoaderOptions crossOriginOptions(m_resourceLoaderOptions); // Do not set the Origin header for preflight requests. updateRequestForAccessControl(crossOriginRequest, 0, effectiveAllowCredentials()); // We update the credentials mode according to effectiveAllowCredentials() here for backward compatibility. But this is not correct. // FIXME: We should set it in the caller of DocumentThreadableLoader. crossOriginRequest.setFetchCredentialsMode(effectiveAllowCredentials() == AllowStoredCredentials ? WebURLRequest::FetchCredentialsModeInclude : WebURLRequest::FetchCredentialsModeOmit); m_actualRequest = crossOriginRequest; m_actualOptions = crossOriginOptions; bool shouldForcePreflight = InspectorInstrumentation::shouldForceCORSPreflight(m_document); bool canSkipPreflight = CrossOriginPreflightResultCache::shared().canSkipPreflight(securityOrigin()->toString(), m_actualRequest.url(), effectiveAllowCredentials(), m_actualRequest.httpMethod(), m_actualRequest.httpHeaderFields()); if (canSkipPreflight && !shouldForcePreflight) { loadActualRequest(); } else { ResourceRequest preflightRequest = createAccessControlPreflightRequest(m_actualRequest, securityOrigin()); // Create a ResourceLoaderOptions for preflight. ResourceLoaderOptions preflightOptions = m_actualOptions; preflightOptions.allowCredentials = DoNotAllowStoredCredentials; loadRequest(preflightRequest, preflightOptions); } } }
void DocumentThreadableLoader::handlePreflightFailure( const String& url, const String& errorDescription) { ResourceError error(errorDomainBlinkInternal, 0, url, errorDescription); // Prevent handleSuccessfulFinish() from bypassing access check. m_actualRequest = ResourceRequest(); ThreadableLoaderClient* client = m_client; clear(); client->didFailAccessControlCheck(error); }
void DocumentThreadableLoader::handleResponse( unsigned long identifier, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle) { DCHECK(m_client); if (!m_actualRequest.isNull()) { reportResponseReceived(identifier, response); handlePreflightResponse(response); return; } if (response.wasFetchedViaServiceWorker()) { if (response.wasFetchedViaForeignFetch()) UseCounter::count(m_document, UseCounter::ForeignFetchInterception); if (response.wasFallbackRequiredByServiceWorker()) { // At this point we must have m_fallbackRequestForServiceWorker. (For // SharedWorker the request won't be CORS or CORS-with-preflight, // therefore fallback-to-network is handled in the browser process when // the ServiceWorker does not call respondWith().) DCHECK(!m_fallbackRequestForServiceWorker.isNull()); reportResponseReceived(identifier, response); loadFallbackRequestForServiceWorker(); return; } m_fallbackRequestForServiceWorker = ResourceRequest(); m_client->didReceiveResponse(identifier, response, std::move(handle)); return; } // Even if the request met the conditions to get handled by a Service Worker // in the constructor of this class (and therefore // |m_fallbackRequestForServiceWorker| is set), the Service Worker may skip // processing the request. Only if the request is same origin, the skipped // response may come here (wasFetchedViaServiceWorker() returns false) since // such a request doesn't have to go through the CORS algorithm by calling // loadFallbackRequestForServiceWorker(). // FIXME: We should use |m_sameOriginRequest| when we will support Suborigins // (crbug.com/336894) for Service Worker. DCHECK( m_fallbackRequestForServiceWorker.isNull() || getSecurityOrigin()->canRequest(m_fallbackRequestForServiceWorker.url())); m_fallbackRequestForServiceWorker = ResourceRequest(); if (!m_sameOriginRequest && m_options.crossOriginRequestPolicy == UseAccessControl) { String accessControlErrorDescription; if (!passesAccessControlCheck( response, effectiveAllowCredentials(), getSecurityOrigin(), accessControlErrorDescription, m_requestContext)) { reportResponseReceived(identifier, response); ThreadableLoaderClient* client = m_client; clear(); client->didFailAccessControlCheck( ResourceError(errorDomainBlinkInternal, 0, response.url().getString(), accessControlErrorDescription)); return; } } m_client->didReceiveResponse(identifier, response, std::move(handle)); }
// In this method, we can clear |request| to tell content::WebURLLoaderImpl of // Chromium not to follow the redirect. This works only when this method is // called by RawResource::willSendRequest(). If called by // RawResource::didAddClient(), clearing |request| won't be propagated to // content::WebURLLoaderImpl. So, this loader must also get detached from the // resource by calling clearResource(). bool DocumentThreadableLoader::redirectReceived( Resource* resource, const ResourceRequest& request, const ResourceResponse& redirectResponse) { DCHECK(m_client); DCHECK_EQ(resource, this->resource()); DCHECK(m_async); m_checker.redirectReceived(); if (!m_actualRequest.isNull()) { reportResponseReceived(resource->identifier(), redirectResponse); handlePreflightFailure(redirectResponse.url().getString(), "Response for preflight is invalid (redirect)"); return false; } if (m_redirectMode == WebURLRequest::FetchRedirectModeManual) { // We use |m_redirectMode| to check the original redirect mode. |request| is // a new request for redirect. So we don't set the redirect mode of it in // WebURLLoaderImpl::Context::OnReceivedRedirect(). DCHECK(request.useStreamOnResponse()); // There is no need to read the body of redirect response because there is // no way to read the body of opaque-redirect filtered response's internal // response. // TODO(horo): If we support any API which expose the internal body, we will // have to read the body. And also HTTPCache changes will be needed because // it doesn't store the body of redirect responses. responseReceived(resource, redirectResponse, WTF::makeUnique<EmptyDataHandle>()); if (m_client) { DCHECK(m_actualRequest.isNull()); notifyFinished(resource); } return false; } if (m_redirectMode == WebURLRequest::FetchRedirectModeError) { ThreadableLoaderClient* client = m_client; clear(); client->didFailRedirectCheck(); return false; } // Allow same origin requests to continue after allowing clients to audit the // redirect. if (isAllowedRedirect(request.url())) { m_client->didReceiveRedirectTo(request.url()); if (m_client->isDocumentThreadableLoaderClient()) { return static_cast<DocumentThreadableLoaderClient*>(m_client) ->willFollowRedirect(request, redirectResponse); } return true; } if (m_corsRedirectLimit <= 0) { ThreadableLoaderClient* client = m_client; clear(); client->didFailRedirectCheck(); return false; } --m_corsRedirectLimit; InspectorInstrumentation::didReceiveCORSRedirectResponse( document().frame(), resource->identifier(), document().frame()->loader().documentLoader(), redirectResponse, resource); bool allowRedirect = false; String accessControlErrorDescription; if (!CrossOriginAccessControl::isLegalRedirectLocation( request.url(), accessControlErrorDescription)) { accessControlErrorDescription = "Redirect from '" + redirectResponse.url().getString() + "' has been blocked by CORS policy: " + accessControlErrorDescription; } else if (!m_sameOriginRequest && !passesAccessControlCheck( redirectResponse, effectiveAllowCredentials(), getSecurityOrigin(), accessControlErrorDescription, m_requestContext)) { // The redirect response must pass the access control check if the original // request was not same-origin. accessControlErrorDescription = "Redirect from '" + redirectResponse.url().getString() + "' to '" + request.url().getString() + "' has been blocked by CORS policy: " + accessControlErrorDescription; } else { allowRedirect = true; } if (!allowRedirect) { ThreadableLoaderClient* client = m_client; clear(); client->didFailAccessControlCheck(ResourceError( errorDomainBlinkInternal, 0, redirectResponse.url().getString(), accessControlErrorDescription)); return false; } m_client->didReceiveRedirectTo(request.url()); // FIXME: consider combining this with CORS redirect handling performed by // CrossOriginAccessControl::handleRedirect(). clearResource(); // If the original request wasn't same-origin, then if the request URL origin // is not same origin with the original URL origin, set the source origin to a // globally unique identifier. (If the original request was same-origin, the // origin of the new request should be the original URL origin.) if (!m_sameOriginRequest) { RefPtr<SecurityOrigin> originalOrigin = SecurityOrigin::create(redirectResponse.url()); RefPtr<SecurityOrigin> requestOrigin = SecurityOrigin::create(request.url()); if (!originalOrigin->isSameSchemeHostPort(requestOrigin.get())) m_securityOrigin = SecurityOrigin::createUnique(); } // Force any subsequent requests to use these checks. m_sameOriginRequest = false; // Since the request is no longer same-origin, if the user didn't request // credentials in the first place, update our state so we neither request them // nor expect they must be allowed. if (m_resourceLoaderOptions.credentialsRequested == ClientDidNotRequestCredentials) m_forceDoNotAllowStoredCredentials = true; // Save the referrer to use when following the redirect. m_overrideReferrer = true; m_referrerAfterRedirect = Referrer(request.httpReferrer(), request.getReferrerPolicy()); ResourceRequest crossOriginRequest(request); // Remove any headers that may have been added by the network layer that cause // access control to fail. crossOriginRequest.clearHTTPReferrer(); crossOriginRequest.clearHTTPOrigin(); crossOriginRequest.clearHTTPUserAgent(); // Add any request headers which we previously saved from the // original request. for (const auto& header : m_requestHeaders) crossOriginRequest.setHTTPHeaderField(header.key, header.value); makeCrossOriginAccessRequest(crossOriginRequest); return false; }
void DocumentThreadableLoader::makeCrossOriginAccessRequest( const ResourceRequest& request) { DCHECK(m_options.crossOriginRequestPolicy == UseAccessControl || request.isExternalRequest()); DCHECK(m_client); DCHECK(!resource()); // Cross-origin requests are only allowed certain registered schemes. We would // catch this when checking response headers later, but there is no reason to // send a request, preflighted or not, that's guaranteed to be denied. if (!SchemeRegistry::shouldTreatURLSchemeAsCORSEnabled( request.url().protocol())) { InspectorInstrumentation:: documentThreadableLoaderFailedToStartLoadingForClient(m_document, m_client); ThreadableLoaderClient* client = m_client; clear(); client->didFailAccessControlCheck(ResourceError( errorDomainBlinkInternal, 0, request.url().getString(), "Cross origin requests are only supported for protocol schemes: " + SchemeRegistry::listOfCORSEnabledURLSchemes() + ".")); return; } // Non-secure origins may not make "external requests": // https://mikewest.github.io/cors-rfc1918/#integration-fetch if (!document().isSecureContext() && request.isExternalRequest()) { ThreadableLoaderClient* client = m_client; clear(); client->didFailAccessControlCheck( ResourceError(errorDomainBlinkInternal, 0, request.url().getString(), "Requests to internal network resources are not allowed " "from non-secure contexts (see https://goo.gl/Y0ZkNV). " "This is an experimental restriction which is part of " "'https://mikewest.github.io/cors-rfc1918/'.")); return; } ResourceRequest crossOriginRequest(request); ResourceLoaderOptions crossOriginOptions(m_resourceLoaderOptions); crossOriginRequest.removeCredentials(); crossOriginRequest.setAllowStoredCredentials(effectiveAllowCredentials() == AllowStoredCredentials); // We update the credentials mode according to effectiveAllowCredentials() // here for backward compatibility. But this is not correct. // FIXME: We should set it in the caller of DocumentThreadableLoader. crossOriginRequest.setFetchCredentialsMode( effectiveAllowCredentials() == AllowStoredCredentials ? WebURLRequest::FetchCredentialsModeInclude : WebURLRequest::FetchCredentialsModeOmit); // We use isSimpleOrForbiddenRequest() here since |request| may have been // modified in the process of loading (not from the user's input). For // example, referrer. We need to accept them. For security, we must reject // forbidden headers/methods at the point we accept user's input. Not here. if (!request.isExternalRequest() && ((m_options.preflightPolicy == ConsiderPreflight && FetchUtils::isSimpleOrForbiddenRequest(request.httpMethod(), request.httpHeaderFields())) || m_options.preflightPolicy == PreventPreflight)) { prepareCrossOriginRequest(crossOriginRequest); loadRequest(crossOriginRequest, crossOriginOptions); } else { bool shouldForcePreflight = request.isExternalRequest() || InspectorInstrumentation::shouldForceCORSPreflight(m_document); bool canSkipPreflight = CrossOriginPreflightResultCache::shared().canSkipPreflight( getSecurityOrigin()->toString(), crossOriginRequest.url(), effectiveAllowCredentials(), crossOriginRequest.httpMethod(), crossOriginRequest.httpHeaderFields()); if (canSkipPreflight && !shouldForcePreflight) { if (getSecurityOrigin()) crossOriginRequest.setHTTPOrigin(getSecurityOrigin()); if (m_overrideReferrer) crossOriginRequest.setHTTPReferrer(m_referrerAfterRedirect); prepareCrossOriginRequest(crossOriginRequest); loadRequest(crossOriginRequest, crossOriginOptions); } else { ResourceRequest preflightRequest = createAccessControlPreflightRequest( crossOriginRequest, getSecurityOrigin()); // Create a ResourceLoaderOptions for preflight. ResourceLoaderOptions preflightOptions = crossOriginOptions; preflightOptions.allowCredentials = DoNotAllowStoredCredentials; m_actualRequest = crossOriginRequest; m_actualOptions = crossOriginOptions; prepareCrossOriginRequest(crossOriginRequest); loadRequest(preflightRequest, preflightOptions); } } }
// In this method, we can clear |request| to tell content::WebURLLoaderImpl of // Chromium not to follow the redirect. This works only when this method is // called by RawResource::willSendRequest(). If called by // RawResource::didAddClient(), clearing |request| won't be propagated // to content::WebURLLoaderImpl. So, this loader must also get detached from // the resource by calling clearResource(). void DocumentThreadableLoader::redirectReceived(Resource* resource, ResourceRequest& request, const ResourceResponse& redirectResponse) { ASSERT(m_client); ASSERT_UNUSED(resource, resource == this->resource()); ASSERT(m_async); if (!m_actualRequest.isNull()) { reportResponseReceived(resource->identifier(), redirectResponse); handlePreflightFailure(redirectResponse.url().string(), "Response for preflight is invalid (redirect)"); // |this| may be dead here. request = ResourceRequest(); return; } if (m_redirectMode == WebURLRequest::FetchRedirectModeManual) { // Keep |this| alive even if the client release a reference in // responseReceived(). RefPtr<DocumentThreadableLoader> protect(this); // We use |m_redirectMode| to check the original redirect mode. // |request| is a new request for redirect. So we don't set the redirect // mode of it in WebURLLoaderImpl::Context::OnReceivedRedirect(). ASSERT(request.useStreamOnResponse()); // There is no need to read the body of redirect response because there // is no way to read the body of opaque-redirect filtered response's // internal response. // TODO(horo): If we support any API which expose the internal body, we // will have to read the body. And also HTTPCache changes will be needed // because it doesn't store the body of redirect responses. responseReceived(resource, redirectResponse, adoptPtr(new EmptyDataHandle())); if (m_client) { ASSERT(m_actualRequest.isNull()); notifyFinished(resource); } request = ResourceRequest(); return; } if (m_redirectMode == WebURLRequest::FetchRedirectModeError || !isAllowedByContentSecurityPolicy(request.url(), ContentSecurityPolicy::DidRedirect)) { ThreadableLoaderClient* client = m_client; clear(); client->didFailRedirectCheck(); // |this| may be dead here. request = ResourceRequest(); return; } // Allow same origin requests to continue after allowing clients to audit the redirect. if (isAllowedRedirect(request.url())) { if (m_client->isDocumentThreadableLoaderClient()) static_cast<DocumentThreadableLoaderClient*>(m_client)->willFollowRedirect(request, redirectResponse); return; } if (m_corsRedirectLimit <= 0) { ThreadableLoaderClient* client = m_client; clear(); client->didFailRedirectCheck(); // |this| may be dead here. } else if (m_options.crossOriginRequestPolicy == UseAccessControl) { --m_corsRedirectLimit; InspectorInstrumentation::didReceiveCORSRedirectResponse(document().frame(), resource->identifier(), document().frame()->loader().documentLoader(), redirectResponse, 0); bool allowRedirect = false; String accessControlErrorDescription; // Non-simple cross origin requests (both preflight and actual one) are // not allowed to follow redirect. if (m_crossOriginNonSimpleRequest) { accessControlErrorDescription = "The request was redirected to '"+ request.url().string() + "', which is disallowed for cross-origin requests that require preflight."; } else { // The redirect response must pass the access control check if the // original request was not same-origin. allowRedirect = CrossOriginAccessControl::isLegalRedirectLocation(request.url(), accessControlErrorDescription) && (m_sameOriginRequest || passesAccessControlCheck(redirectResponse, effectiveAllowCredentials(), securityOrigin(), accessControlErrorDescription, m_requestContext)); } if (allowRedirect) { // FIXME: consider combining this with CORS redirect handling performed by // CrossOriginAccessControl::handleRedirect(). clearResource(); RefPtr<SecurityOrigin> originalOrigin = SecurityOrigin::create(redirectResponse.url()); RefPtr<SecurityOrigin> requestOrigin = SecurityOrigin::create(request.url()); // If the original request wasn't same-origin, then if the request URL origin is not same origin with the original URL origin, // set the source origin to a globally unique identifier. (If the original request was same-origin, the origin of the new request // should be the original URL origin.) if (!m_sameOriginRequest && !originalOrigin->isSameSchemeHostPort(requestOrigin.get())) m_securityOrigin = SecurityOrigin::createUnique(); // Force any subsequent requests to use these checks. m_sameOriginRequest = false; // Since the request is no longer same-origin, if the user didn't request credentials in // the first place, update our state so we neither request them nor expect they must be allowed. if (m_resourceLoaderOptions.credentialsRequested == ClientDidNotRequestCredentials) m_forceDoNotAllowStoredCredentials = true; // Remove any headers that may have been added by the network layer that cause access control to fail. request.clearHTTPReferrer(); request.clearHTTPOrigin(); request.clearHTTPUserAgent(); // Add any CORS simple request headers which we previously saved from the original request. for (const auto& header : m_simpleRequestHeaders) request.setHTTPHeaderField(header.key, header.value); makeCrossOriginAccessRequest(request); // |this| may be dead here. return; } ThreadableLoaderClient* client = m_client; clear(); client->didFailAccessControlCheck(ResourceError(errorDomainBlinkInternal, 0, redirectResponse.url().string(), accessControlErrorDescription)); // |this| may be dead here. } else { ThreadableLoaderClient* client = m_client; clear(); client->didFailRedirectCheck(); // |this| may be dead here. } request = ResourceRequest(); }