The Tor Browser: comparison netwerk/cookie/nsCookieService.cpp

-:888625f834d3
+:0311a3db56de
 if (aCookie) {
 PR_LOG(GetCookieLog(), PR_LOG_DEBUG,("----------------\n"));
 PR_LOG(GetCookieLog(), PR_LOG_DEBUG,("name: %s\n", aCookie->Name().get()));
 PR_LOG(GetCookieLog(), PR_LOG_DEBUG,("value: %s\n", aCookie->Value().get()));
 PR_LOG(GetCookieLog(), PR_LOG_DEBUG,("%s: %s\n", aCookie->IsDomain() ? "domain" : "host", aCookie->Host().get()));
+PR_LOG(GetCookieLog(), PR_LOG_DEBUG,("orighost: %s\n", aCookie->Origin().get()));
 PR_LOG(GetCookieLog(), PR_LOG_DEBUG,("path: %s\n", aCookie->Path().get()));
 PR_ExplodeTime(aCookie->Expiry() * int64_t(PR_USEC_PER_SEC),
 PR_GMTParameters, &explodedTime);
 PR_FormatTimeUSEnglish(timeString, 40, "%c GMT", &explodedTime);
 NS_GetAppInfo(aChannel, &appId, &inBrowserElement);
 }
 bool isPrivate = aChannel && NS_UsePrivateBrowsing(aChannel);
+nsCOMPtr<nsIURI> firstPartyURI;
+mThirdPartyUtil->GetFirstPartyURI(aChannel, nullptr, getter_AddRefs(firstPartyURI));
+bool requireHostMatch;
+nsAutoCString origDomain;
+nsresult rv = GetBaseDomain(firstPartyURI, origDomain, requireHostMatch);
+if (NS_FAILED(rv)) {
+COOKIE_LOGFAILURE(GET_COOKIE, aHostURI, nullptr,
+"couldn't get base domain from URI");
+}
 nsAutoCString result;
 GetCookieStringInternal(aHostURI, isForeign, aHttpBound, appId,
-inBrowserElement, isPrivate, result);
+inBrowserElement, isPrivate, origDomain, result);
 *aCookie = result.IsEmpty() ? nullptr : ToNewCString(result);
 return NS_OK;
 }
 NS_IMETHODIMP
 serverTime, aFromHttp, appId, inBrowserElement,
 isPrivate, aChannel);
 return NS_OK;
 }
+// FIXME:MSvB DEBUG DEBUG - DELETEME DELETEME - debug debug - deleteme deleteme
+// FIXME:MSvB Setting a 3rd party cookie (on third.tld) for URL bar browsed
+// FIXME:MSvB   site first.tld causes aHostURI (and later the origin var) to
+// FIXME:MSvB   contain 'third.tld'
 void
 nsCookieService::SetCookieStringInternal(nsIURI             *aHostURI,
 bool                aIsForeign,
 nsDependentCString &aCookieHeader,
 const nsCString    &aServerTime,
 serverTime = tempServerTime / int64_t(PR_USEC_PER_SEC);
 } else {
 serverTime = PR_Now() / PR_USEC_PER_SEC;
 }
+// double keyed cookie boilerplate
+nsCOMPtr<nsIURI> firstPartyURI;
+mThirdPartyUtil->GetFirstPartyURI(aChannel, nullptr, getter_AddRefs(firstPartyURI));
+nsAutoCString origDomain;
+rv = GetBaseDomain(firstPartyURI, origDomain, requireHostMatch);
+if (NS_FAILED(rv)) {
+COOKIE_LOGFAILURE(GET_COOKIE, aHostURI, nullptr,
+"couldn't get base domain from URI");
+}
 // process each cookie in the header
-while (SetCookieInternal(aHostURI, key, requireHostMatch, cookieStatus,
+while (SetCookieInternal(aHostURI, key, requireHostMatch, origDomain,
-aCookieHeader, serverTime, aFromHttp, aChannel)) {
+cookieStatus, aCookieHeader, serverTime,
+aFromHttp, aChannel)) {
 // document.cookie can only set one cookie at a time
 if (!aFromHttp)
 break;
 }
 }
 NS_ENSURE_SUCCESS(rv, rv);
 int64_t currentTimeInUsec = PR_Now();
 nsRefPtr<nsCookie> cookie =
-nsCookie::Create(aName, aValue, host, aPath,
+nsCookie::Create(aName, aValue, host, baseDomain, aPath,
 aExpiry,
 currentTimeInUsec,
 nsCookie::GenerateUniqueCreationTime(currentTimeInUsec),
 aIsSession,
 aIsSecure,
 NS_ENSURE_SUCCESS(rv, rv);
 nsListIter matchIter;
 nsRefPtr<nsCookie> cookie;
 if (FindCookie(nsCookieKey(baseDomain, aAppId, aInBrowserElement),
+baseDomain,
 host,
 PromiseFlatCString(aName),
 PromiseFlatCString(aPath),
 matchIter)) {
 cookie = matchIter.Cookie();
 int64_t lastAccessed = aRow->AsInt64(IDX_LAST_ACCESSED);
 int64_t creationTime = aRow->AsInt64(IDX_CREATION_TIME);
 bool isSecure = 0 != aRow->AsInt32(IDX_SECURE);
 bool isHttpOnly = 0 != aRow->AsInt32(IDX_HTTPONLY);
+nsAutoCString baseDomain;
+rv = GetBaseDomainFromHost(host, baseDomain);
+NS_ASSERT_SUCCESS(rv);
 // Create a new nsCookie and assign the data.
-return nsCookie::Create(name, value, host, path,
+return nsCookie::Create(name, value, host, baseDomain, path,
 expiry,
 lastAccessed,
 creationTime,
 false,
 isSecure,
 // creation time, so just use the current time to generate a unique one.
 nsRefPtr<nsCookie> newCookie =
 nsCookie::Create(Substring(buffer, nameIndex, cookieIndex - nameIndex - 1),
 Substring(buffer, cookieIndex, buffer.Length() - cookieIndex),
 host,
+baseDomain,
 Substring(buffer, pathIndex, secureIndex - pathIndex - 1),
 expires,
 lastAccessedCounter,
 nsCookie::GenerateUniqueCreationTime(currentTimeInUsec),
 false,
 bool aIsForeign,
 bool aHttpBound,
 uint32_t aAppId,
 bool aInBrowserElement,
 bool aIsPrivate,
+nsCString &aOrigDomain,
 nsCString &aCookieString)
 {
 NS_ASSERTION(aHostURI, "null host!");
 if (!mDBState) {
 // iterate the cookies!
 const nsCookieEntry::ArrayType &cookies = entry->GetCookies();
 for (nsCookieEntry::IndexType i = 0; i < cookies.Length(); ++i) {
 cookie = cookies[i];
+// Check the origin key. We only continue if the
+// saved origin matches matches the origin domain.
+// FIXME:MSvB, other places iterate cookies too, handle them likewise?
+if (cookie->Origin() != aOrigDomain) {
+continue;
+}
 // check the host, since the base domain lookup is conservative.
 // first, check for an exact host or domain cookie match, e.g. "google.com"
 // or ".google.com"; second a subdomain match, e.g.
 // host = "mail.google.com", cookie domain = ".google.com".
 if (cookie->RawHost() != hostFromURI &&
 // to be processed
 bool
 nsCookieService::SetCookieInternal(nsIURI                        *aHostURI,
 const nsCookieKey             &aKey,
 bool                           aRequireHostMatch,
+const nsCString               &aOrigin,
 CookieStatus                   aStatus,
 nsDependentCString            &aCookieHeader,
 int64_t                        aServerTime,
 bool                           aFromHttp,
 nsIChannel                    *aChannel)
 COOKIE_LOGFAILURE(SET_COOKIE, aHostURI, savedCookieHeader, "failed the path tests");
 return newCookie;
 }
 // create a new nsCookie and copy attributes
+//FIXME:MSvB, The name and value vars are neither host nor key
+//FIXME:MSvB, host shows up in cookie inspector, as a index key
 nsRefPtr<nsCookie> cookie =
 nsCookie::Create(cookieAttributes.name,
 cookieAttributes.value,
 cookieAttributes.host,
+aOrigin,
 cookieAttributes.path,
 cookieAttributes.expiryTime,
 currentTimeInUsec,
 nsCookie::GenerateUniqueCreationTime(currentTimeInUsec),
 cookieAttributes.isSession,
 "cookie is httponly; coming from script");
 return;
 }
 nsListIter matchIter;
-bool foundCookie = FindCookie(aKey, aCookie->Host(),
+bool foundCookie = FindCookie(aKey, aCookie->Origin(),
-aCookie->Name(), aCookie->Path(), matchIter);
+aCookie->Host(), aCookie->Name(), aCookie->Path(), matchIter);
 nsRefPtr<nsCookie> oldCookie;
 nsCOMPtr<nsIArray> purgedList;
 if (foundCookie) {
 oldCookie = matchIter.Cookie();
 if (!mDBState) {
 NS_WARNING("No DBState! Profile already closed?");
 return NS_ERROR_NOT_AVAILABLE;
 }
-nsAutoCString host, name, path;
+nsAutoCString host, origin, name, path;
 nsresult rv = aCookie->GetHost(host);
+NS_ENSURE_SUCCESS(rv, rv);
+rv = aCookie->GetOrigin(origin);
 NS_ENSURE_SUCCESS(rv, rv);
 rv = aCookie->GetName(name);
 NS_ENSURE_SUCCESS(rv, rv);
 rv = aCookie->GetPath(path);
 NS_ENSURE_SUCCESS(rv, rv);
 nsAutoCString baseDomain;
 rv = GetBaseDomainFromHost(host, baseDomain);
 NS_ENSURE_SUCCESS(rv, rv);
 nsListIter iter;
-*aFoundCookie = FindCookie(DEFAULT_APP_KEY(baseDomain), host, name, path, iter);
+*aFoundCookie = FindCookie(DEFAULT_APP_KEY(baseDomain), origin, host, name, path, iter);
 return NS_OK;
 }
 // For a given base domain, find either an expired cookie or the oldest cookie
 // by lastAccessed time.
 }
 // find an exact cookie specified by host, name, and path that hasn't expired.
 bool
 nsCookieService::FindCookie(const nsCookieKey    &aKey,
+const nsAFlatCString &aOrigin,
 const nsAFlatCString &aHost,
 const nsAFlatCString &aName,
 const nsAFlatCString &aPath,
 nsListIter           &aIter)
 {
 const nsCookieEntry::ArrayType &cookies = entry->GetCookies();
 for (nsCookieEntry::IndexType i = 0; i < cookies.Length(); ++i) {
 nsCookie *cookie = cookies[i];
-if (aHost.Equals(cookie->Host()) &&
+if (aOrigin.Equals(cookie->Origin()) &&
+aHost.Equals(cookie->Host()) &&
 aPath.Equals(cookie->Path()) &&
 aName.Equals(cookie->Name())) {
 aIter = nsListIter(entry, i);
 return true;
 }

The Tor Browser / file comparison

comparison: netwerk/cookie/nsCookieService.cpp

netwerk/cookie/nsCookieService.cpp