Bug 1658869 - Propagate the InterceptedHttpChannel information to fetch's channel casued by FetchEvent.request. r=dom-worker-reviewers,dragana,jesup

When a network load needs to be intercepted by ServiceWorker, we extract the Request from the InterceptedHttpChannel, and propagate the Request through FetchEvent.request.

However, some needed information is not extracted or is modified during the Request propagation, so getting the wrong result when using the Request to fetch resources in the ServiceWorker script.

Differential Revision: https://phabricator.services.mozilla.com/D145969

Author: edenchuang

dom/fetch/Fetch.cpp

@@ -487,6 +487,27 @@ already_AddRefed<Promise> FetchRequest(nsIGlobalObject* aGlobal,
   }
 
   SafeRefPtr<InternalRequest> r = request->GetInternalRequest();
+
+  // Restore information of InterceptedHttpChannel if they are passed with the
+  // Request. Since Request::Constructor would not copy these members.
+  if (aInput.IsRequest()) {
+    RefPtr<Request> inputReq = &aInput.GetAsRequest();
+    SafeRefPtr<InternalRequest> inputInReq = inputReq->GetInternalRequest();
+    if (inputInReq->GetInterceptionTriggeringPrincipalInfo()) {
+      r->SetInterceptionContentPolicyType(
+          inputInReq->InterceptionContentPolicyType());
+      r->SetInterceptionTriggeringPrincipalInfo(
+          MakeUnique<mozilla::ipc::PrincipalInfo>(
+              *(inputInReq->GetInterceptionTriggeringPrincipalInfo().get())));
+      if (!inputInReq->InterceptionRedirectChain().IsEmpty()) {
+        r->SetInterceptionRedirectChain(
+            inputInReq->InterceptionRedirectChain());
+      }
+      r->SetInterceptionFromThirdParty(
+          inputInReq->InterceptionFromThirdParty());
+    }
+  }
+
   RefPtr<AbortSignalImpl> signalImpl = request->GetSignalImpl();
 
   if (signalImpl && signalImpl->Aborted()) {

dom/fetch/FetchDriver.cpp

@@ -12,6 +12,7 @@
 #include "nsICookieJarSettings.h"
 #include "nsIFile.h"
 #include "nsIInputStream.h"
+#include "nsIInterceptionInfo.h"
 #include "nsIOutputStream.h"
 #include "nsIFileChannel.h"
 #include "nsIHttpChannel.h"
@@ -21,6 +22,7 @@
 #include "nsIUploadChannel2.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "nsIPipe.h"
+#include "nsIRedirectHistoryEntry.h"
 
 #include "nsContentPolicyUtils.h"
 #include "nsDataHandler.h"
@@ -38,6 +40,7 @@
 #include "mozilla/dom/UserActivation.h"
 #include "mozilla/dom/WorkerCommon.h"
 #include "mozilla/PreloaderBase.h"
+#include "mozilla/net/InterceptionInfo.h"
 #include "mozilla/net/NeckoChannelParams.h"
 #include "mozilla/ipc/PBackgroundSharedTypes.h"
 #include "mozilla/StaticPrefs_browser.h"
@@ -647,6 +650,33 @@ nsresult FetchDriver::HttpFetch(
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
+  // If the fetch is created by FetchEvent.request or NavigationPreload request,
+  // corresponding InterceptedHttpChannel information need to propagte to the
+  // channel of the fetch.
+  if (mRequest->GetInterceptionTriggeringPrincipalInfo()) {
+    auto principalOrErr = mozilla::ipc::PrincipalInfoToPrincipal(
+        *(mRequest->GetInterceptionTriggeringPrincipalInfo().get()));
+    if (!principalOrErr.isErr()) {
+      nsCOMPtr<nsIPrincipal> principal = principalOrErr.unwrap();
+
+      nsTArray<nsCOMPtr<nsIRedirectHistoryEntry>> redirectChain;
+      if (!mRequest->InterceptionRedirectChain().IsEmpty()) {
+        for (const RedirectHistoryEntryInfo& entryInfo :
+             mRequest->InterceptionRedirectChain()) {
+          nsCOMPtr<nsIRedirectHistoryEntry> entry =
+              mozilla::ipc::RHEntryInfoToRHEntry(entryInfo);
+          redirectChain.AppendElement(entry);
+        }
+      }
+
+      nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
+      MOZ_ASSERT(loadInfo);
+      loadInfo->SetInterceptionInfo(new mozilla::net::InterceptionInfo(
+          principal, mRequest->InterceptionContentPolicyType(), redirectChain,
+          mRequest->InterceptionFromThirdParty()));
+    }
+  }
+
   if (mDocument && mDocument->GetEmbedderElement() &&
       mDocument->GetEmbedderElement()->IsAnyOfHTMLElements(nsGkAtoms::object,
                                                            nsGkAtoms::embed)) {

dom/fetch/FetchTypes.ipdlh

@@ -5,6 +5,7 @@
 include IPCStream;
 include PBackgroundSharedTypes;
 include PerformanceTimingTypes;
+include NeckoChannelParams;
 
 include "mozilla/dom/FetchIPCTypes.h";
 include "mozilla/ipc/TransportSecurityInfoUtils.h";
@@ -13,7 +14,6 @@ using HeadersGuardEnum from "mozilla/dom/HeadersBinding.h";
 using ReferrerPolicy from "mozilla/dom/ReferrerPolicyBinding.h";
 using RequestCache from "mozilla/dom/RequestBinding.h";
 using RequestCredentials from "mozilla/dom/RequestBinding.h";
-using RequestMode from "mozilla/dom/RequestBinding.h";
 using RequestRedirect from "mozilla/dom/RequestBinding.h";
 using ResponseType from "mozilla/dom/ResponseBinding.h";
 using struct nsID from "nsID.h";
@@ -66,6 +66,10 @@ struct IPCInternalRequest {
   nsString integrity;
   nsCString fragment;
   PrincipalInfo? principalInfo;
+  PrincipalInfo? interceptionTriggeringPrincipalInfo;
+  uint32_t interceptionContentPolicyType;
+  RedirectHistoryEntryInfo[] interceptionRedirectChain;
+  bool interceptionFromThirdParty;
 };
 
 struct InternalResponseMetadata {

dom/fetch/InternalRequest.cpp

@@ -139,8 +139,17 @@ InternalRequest::InternalRequest(const InternalRequest& aOther,
       mSynchronous(aOther.mSynchronous),
       mUnsafeRequest(aOther.mUnsafeRequest),
       mUseURLCredentials(aOther.mUseURLCredentials),
-      mContentPolicyTypeOverridden(aOther.mContentPolicyTypeOverridden) {
+      mContentPolicyTypeOverridden(aOther.mContentPolicyTypeOverridden),
+      mInterceptionContentPolicyType(aOther.mInterceptionContentPolicyType),
+      mInterceptionRedirectChain(aOther.mInterceptionRedirectChain),
+      mInterceptionFromThirdParty(aOther.mInterceptionFromThirdParty) {
   // NOTE: does not copy body stream... use the fallible Clone() for that
+
+  if (aOther.GetInterceptionTriggeringPrincipalInfo()) {
+    mInterceptionTriggeringPrincipalInfo =
+        MakeUnique<mozilla::ipc::PrincipalInfo>(
+            *(aOther.GetInterceptionTriggeringPrincipalInfo().get()));
+  }
 }
 
 InternalRequest::InternalRequest(const IPCInternalRequest& aIPCRequest)
@@ -159,12 +168,22 @@ InternalRequest::InternalRequest(const IPCInternalRequest& aIPCRequest)
       mCacheMode(aIPCRequest.cacheMode()),
       mRedirectMode(aIPCRequest.requestRedirect()),
       mIntegrity(aIPCRequest.integrity()),
-      mFragment(aIPCRequest.fragment()) {
+      mFragment(aIPCRequest.fragment()),
+      mInterceptionContentPolicyType(static_cast<nsContentPolicyType>(
+          aIPCRequest.interceptionContentPolicyType())),
+      mInterceptionRedirectChain(aIPCRequest.interceptionRedirectChain()),
+      mInterceptionFromThirdParty(aIPCRequest.interceptionFromThirdParty()) {
   if (aIPCRequest.principalInfo()) {
     mPrincipalInfo = MakeUnique<mozilla::ipc::PrincipalInfo>(
         aIPCRequest.principalInfo().ref());
   }
 
+  if (aIPCRequest.interceptionTriggeringPrincipalInfo()) {
+    mInterceptionTriggeringPrincipalInfo =
+        MakeUnique<mozilla::ipc::PrincipalInfo>(
+            aIPCRequest.interceptionTriggeringPrincipalInfo().ref());
+  }
+
   const Maybe<BodyStreamVariant>& body = aIPCRequest.body();
 
   // This constructor is (currently) only used for parent -> child communication
@@ -188,6 +207,11 @@ void InternalRequest::OverrideContentPolicyType(
   mContentPolicyTypeOverridden = true;
 }
 
+void InternalRequest::SetInterceptionContentPolicyType(
+    nsContentPolicyType aContentPolicyType) {
+  mInterceptionContentPolicyType = aContentPolicyType;
+}
+
 /* static */
 RequestDestination InternalRequest::MapContentPolicyTypeToRequestDestination(
     nsContentPolicyType aContentPolicyType) {
@@ -399,4 +423,8 @@ void InternalRequest::SetPrincipalInfo(
   mPrincipalInfo = std::move(aPrincipalInfo);
 }
 
+void InternalRequest::SetInterceptionTriggeringPrincipalInfo(
+    UniquePtr<mozilla::ipc::PrincipalInfo> aPrincipalInfo) {
+  mInterceptionTriggeringPrincipalInfo = std::move(aPrincipalInfo);
+}
 }  // namespace mozilla::dom

dom/fetch/InternalRequest.h

@@ -17,12 +17,15 @@
 #include "nsIChannelEventSink.h"
 #include "nsIInputStream.h"
 #include "nsISupportsImpl.h"
+#include "mozilla/net/NeckoChannelParams.h"
 #ifdef DEBUG
 #  include "nsIURLParser.h"
 #  include "nsNetCID.h"
 #  include "nsServiceManagerUtils.h"
 #endif
 
+using mozilla::net::RedirectHistoryEntryInfo;
+
 namespace mozilla {
 
 namespace ipc {
@@ -326,7 +329,6 @@ class InternalRequest final : public AtomicSafeRefCounted<InternalRequest> {
 
   // Takes ownership of the principal info.
   void SetPrincipalInfo(UniquePtr<mozilla::ipc::PrincipalInfo> aPrincipalInfo);
-
   const UniquePtr<mozilla::ipc::PrincipalInfo>& GetPrincipalInfo() const {
     return mPrincipalInfo;
   }
@@ -351,6 +353,36 @@ class InternalRequest final : public AtomicSafeRefCounted<InternalRequest> {
     return mEmbedderPolicy;
   }
 
+  void SetInterceptionTriggeringPrincipalInfo(
+      UniquePtr<mozilla::ipc::PrincipalInfo> aPrincipalInfo);
+
+  const UniquePtr<mozilla::ipc::PrincipalInfo>&
+  GetInterceptionTriggeringPrincipalInfo() const {
+    return mInterceptionTriggeringPrincipalInfo;
+  }
+
+  nsContentPolicyType InterceptionContentPolicyType() const {
+    return mInterceptionContentPolicyType;
+  }
+  void SetInterceptionContentPolicyType(nsContentPolicyType aContentPolicyType);
+
+  const nsTArray<RedirectHistoryEntryInfo>& InterceptionRedirectChain() const {
+    return mInterceptionRedirectChain;
+  }
+
+  void SetInterceptionRedirectChain(
+      const nsTArray<RedirectHistoryEntryInfo>& aRedirectChain) {
+    mInterceptionRedirectChain = aRedirectChain;
+  }
+
+  const bool& InterceptionFromThirdParty() const {
+    return mInterceptionFromThirdParty;
+  }
+
+  void SetInterceptionFromThirdParty(bool aFromThirdParty) {
+    mInterceptionFromThirdParty = aFromThirdParty;
+  }
+
  private:
   struct ConstructorGuard {};
 
@@ -425,6 +457,26 @@ class InternalRequest final : public AtomicSafeRefCounted<InternalRequest> {
       nsILoadInfo::EMBEDDER_POLICY_NULL;
 
   UniquePtr<mozilla::ipc::PrincipalInfo> mPrincipalInfo;
+
+  // Following members are specific for the FetchEvent.request or
+  // NavigationPreload request which is extracted from the
+  // InterceptedHttpChannel.
+  // Notice that these members would not be copied when calling
+  // InternalRequest::GetRequestConstructorCopy() since these information should
+  // not be propagated when copying the Request in ServiceWorker script.
+
+  // This is the trigging principalInfo of the InterceptedHttpChannel.
+  UniquePtr<mozilla::ipc::PrincipalInfo> mInterceptionTriggeringPrincipalInfo;
+
+  // This is the contentPolicyType of the InterceptedHttpChannel.
+  nsContentPolicyType mInterceptionContentPolicyType{
+      nsIContentPolicy::TYPE_INVALID};
+
+  // This is the redirect history of the InterceptedHttpChannel.
+  CopyableTArray<RedirectHistoryEntryInfo> mInterceptionRedirectChain;
+
+  // This indicates that the InterceptedHttpChannel is a third party channel.
+  bool mInterceptionFromThirdParty{false};
 };
 
 }  // namespace dom

dom/serviceworkers/ServiceWorkerPrivate.cpp

@@ -14,6 +14,7 @@
 #include "ServiceWorkerRegistrationInfo.h"
 #include "ServiceWorkerUtils.h"
 #include "js/ErrorReport.h"
+#include "mozIThirdPartyUtil.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/CycleCollectedJSContext.h"  // for MicroTaskRunnable
 #include "mozilla/ErrorResult.h"
@@ -56,7 +57,9 @@
 #include "nsINetworkInterceptController.h"
 #include "nsINamed.h"
 #include "nsIObserverService.h"
+#include "nsIRedirectHistoryEntry.h"
 #include "nsIScriptError.h"
+#include "nsIScriptSecurityManager.h"
 #include "nsISupportsImpl.h"
 #include "nsIURI.h"
 #include "nsIUploadChannel2.h"
@@ -362,11 +365,32 @@ Result<IPCInternalRequest, nsresult> GetIPCInternalRequest(
   }
 
   Maybe<PrincipalInfo> principalInfo;
-
+  Maybe<PrincipalInfo> interceptionPrincipalInfo;
   if (loadInfo->TriggeringPrincipal()) {
     principalInfo.emplace();
+    interceptionPrincipalInfo.emplace();
     MOZ_ALWAYS_SUCCEEDS(PrincipalToPrincipalInfo(
         loadInfo->TriggeringPrincipal(), principalInfo.ptr()));
+    MOZ_ALWAYS_SUCCEEDS(PrincipalToPrincipalInfo(
+        loadInfo->TriggeringPrincipal(), interceptionPrincipalInfo.ptr()));
+  }
+
+  nsTArray<RedirectHistoryEntryInfo> redirectChain;
+  for (const nsCOMPtr<nsIRedirectHistoryEntry>& redirectEntry :
+       loadInfo->RedirectChain()) {
+    RedirectHistoryEntryInfo* entry = redirectChain.AppendElement();
+    MOZ_ALWAYS_SUCCEEDS(RHEntryToRHEntryInfo(redirectEntry, entry));
+  }
+
+  bool isThirdPartyChannel;
+  // ThirdPartyUtil* thirdPartyUtil = ThirdPartyUtil::GetInstance();
+  nsCOMPtr<mozIThirdPartyUtil> thirdPartyUtil =
+      do_GetService(THIRDPARTYUTIL_CONTRACTID);
+  if (thirdPartyUtil) {
+    nsCOMPtr<nsIURI> uri;
+    MOZ_TRY(underlyingChannel->GetURI(getter_AddRefs(uri)));
+    MOZ_TRY(thirdPartyUtil->IsThirdPartyChannel(underlyingChannel, uri,
+                                                &isThirdPartyChannel));
   }
 
   // Note: all the arguments are copied rather than moved, which would be more
@@ -375,7 +399,8 @@ Result<IPCInternalRequest, nsresult> GetIPCInternalRequest(
       method, {spec}, ipcHeadersGuard, ipcHeaders, Nothing(), -1,
       alternativeDataType, contentPolicyType, referrer, referrerPolicy,
       requestMode, requestCredentials, cacheMode, requestRedirect, integrity,
-      fragment, principalInfo);
+      fragment, principalInfo, interceptionPrincipalInfo, contentPolicyType,
+      redirectChain, isThirdPartyChannel);
 }
 
 nsresult MaybeStoreStreamForBackgroundThread(nsIInterceptedChannel* aChannel,