Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 317 insertions, 0 deletions

diff --git a/netwerk/protocol/http/TlsHandshaker.cpp b/netwerk/protocol/http/TlsHandshaker.cpp
new file mode 100644
index 0000000000..88f0062516
--- /dev/null
+++ b/netwerk/protocol/http/TlsHandshaker.cpp
@@ -0,0 +1,317 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=4 sw=2 sts=2 et cin: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// HttpLog.h should generally be included first
+#include "HttpLog.h"
+
+#include "TlsHandshaker.h"
+#include "mozilla/StaticPrefs_network.h"
+#include "nsHttpConnection.h"
+#include "nsHttpConnectionInfo.h"
+#include "nsHttpHandler.h"
+#include "nsITLSSocketControl.h"
+
+#define TLS_EARLY_DATA_NOT_AVAILABLE 0
+#define TLS_EARLY_DATA_AVAILABLE_BUT_NOT_USED 1
+#define TLS_EARLY_DATA_AVAILABLE_AND_USED 2
+
+namespace mozilla::net {
+
+NS_IMPL_ISUPPORTS(TlsHandshaker, nsITlsHandshakeCallbackListener)
+
+TlsHandshaker::TlsHandshaker(nsHttpConnectionInfo* aInfo,
+                             nsHttpConnection* aOwner)
+    : mConnInfo(aInfo), mOwner(aOwner) {
+  LOG(("TlsHandshaker ctor %p", this));
+}
+
+TlsHandshaker::~TlsHandshaker() { LOG(("TlsHandshaker dtor %p", this)); }
+
+NS_IMETHODIMP
+TlsHandshaker::HandshakeDone() {
+  LOG(("TlsHandshaker::HandshakeDone mOwner=%p", mOwner.get()));
+  if (mOwner) {
+    mTlsHandshakeComplitionPending = true;
+
+    // HandshakeDone needs to be dispatched so that it is not called inside
+    // nss locks.
+    RefPtr<TlsHandshaker> self(this);
+    NS_DispatchToCurrentThread(NS_NewRunnableFunction(
+        "TlsHandshaker::HandshakeDoneInternal", [self{std::move(self)}]() {
+          if (self->mTlsHandshakeComplitionPending && self->mOwner) {
+            self->mOwner->HandshakeDoneInternal();
+            self->mTlsHandshakeComplitionPending = false;
+          }
+        }));
+  }
+  return NS_OK;
+}
+
+void TlsHandshaker::SetupSSL(bool aInSpdyTunnel, bool aForcePlainText) {
+  if (!mOwner) {
+    return;
+  }
+
+  LOG1(("TlsHandshaker::SetupSSL %p caps=0x%X %s\n", mOwner.get(),
+        mOwner->TransactionCaps(), mConnInfo->HashKey().get()));
+
+  if (mSetupSSLCalled) {  // do only once
+    return;
+  }
+  mSetupSSLCalled = true;
+
+  if (mNPNComplete) {
+    return;
+  }
+
+  // we flip this back to false if SetNPNList succeeds at the end
+  // of this function
+  mNPNComplete = true;
+
+  if (!mConnInfo->FirstHopSSL() || aForcePlainText) {
+    return;
+  }
+
+  // if we are connected to the proxy with TLS, start the TLS
+  // flow immediately without waiting for a CONNECT sequence.
+  DebugOnly<nsresult> rv{};
+  if (aInSpdyTunnel) {
+    rv = InitSSLParams(false, true);
+  } else {
+    bool usingHttpsProxy = mConnInfo->UsingHttpsProxy();
+    rv = InitSSLParams(usingHttpsProxy, usingHttpsProxy);
+  }
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+}
+
+nsresult TlsHandshaker::InitSSLParams(bool connectingToProxy,
+                                      bool proxyStartSSL) {
+  LOG(("TlsHandshaker::InitSSLParams [mOwner=%p] connectingToProxy=%d\n",
+       mOwner.get(), connectingToProxy));
+  MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+  if (!mOwner) {
+    return NS_ERROR_ABORT;
+  }
+
+  nsCOMPtr<nsITLSSocketControl> ssl;
+  mOwner->GetTLSSocketControl(getter_AddRefs(ssl));
+  if (!ssl) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // If proxy is use or 0RTT is excluded for a origin, don't use early-data.
+  if (mConnInfo->UsingProxy() || gHttpHandler->Is0RttTcpExcluded(mConnInfo)) {
+    ssl->DisableEarlyData();
+  }
+
+  if (proxyStartSSL) {
+    nsresult rv = ssl->ProxyStartSSL();
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+  }
+
+  if (NS_SUCCEEDED(
+          SetupNPNList(ssl, mOwner->TransactionCaps(), connectingToProxy)) &&
+      NS_SUCCEEDED(ssl->SetHandshakeCallbackListener(this))) {
+    LOG(("InitSSLParams Setting up SPDY Negotiation OK mOwner=%p",
+         mOwner.get()));
+    mNPNComplete = false;
+  }
+
+  return NS_OK;
+}
+
+// The naming of NPN is historical - this function creates the basic
+// offer list for both NPN and ALPN. ALPN validation callbacks are made
+// now before the handshake is complete, and NPN validation callbacks
+// are made during the handshake.
+nsresult TlsHandshaker::SetupNPNList(nsITLSSocketControl* ssl, uint32_t caps,
+                                     bool connectingToProxy) {
+  nsTArray<nsCString> protocolArray;
+
+  // The first protocol is used as the fallback if none of the
+  // protocols supported overlap with the server's list.
+  // When using ALPN the advertised preferences are protocolArray indicies
+  // {1, .., N, 0} in decreasing order.
+  // For NPN, In the case of overlap, matching priority is driven by
+  // the order of the server's advertisement - with index 0 used when
+  // there is no match.
+  protocolArray.AppendElement("http/1.1"_ns);
+
+  if (StaticPrefs::network_http_http2_enabled() &&
+      (connectingToProxy || !(caps & NS_HTTP_DISALLOW_SPDY)) &&
+      !(connectingToProxy && (caps & NS_HTTP_DISALLOW_HTTP2_PROXY))) {
+    LOG(("nsHttpConnection::SetupSSL Allow SPDY NPN selection"));
+    const SpdyInformation* info = gHttpHandler->SpdyInfo();
+    if (info->ALPNCallbacks(ssl)) {
+      protocolArray.AppendElement(info->VersionString);
+    }
+  } else {
+    LOG(("nsHttpConnection::SetupSSL Disallow SPDY NPN selection"));
+  }
+
+  nsresult rv = ssl->SetNPNList(protocolArray);
+  LOG(("TlsHandshaker::SetupNPNList %p %" PRIx32 "\n", mOwner.get(),
+       static_cast<uint32_t>(rv)));
+  return rv;
+}
+
+// Checks if TLS handshake is needed and it is responsible to move it forward.
+bool TlsHandshaker::EnsureNPNComplete() {
+  if (!mOwner) {
+    mNPNComplete = true;
+    return true;
+  }
+
+  nsCOMPtr<nsISocketTransport> transport = mOwner->Transport();
+  MOZ_ASSERT(transport);
+  if (!transport) {
+    // this cannot happen
+    mNPNComplete = true;
+    return true;
+  }
+
+  if (mNPNComplete) {
+    return true;
+  }
+
+  if (mTlsHandshakeComplitionPending) {
+    return false;
+  }
+
+  nsCOMPtr<nsITLSSocketControl> ssl;
+  mOwner->GetTLSSocketControl(getter_AddRefs(ssl));
+  if (!ssl) {
+    FinishNPNSetup(false, false);
+    return true;
+  }
+
+  if (!m0RTTChecked) {
+    // We reuse m0RTTChecked. We want to send this status only once.
+    RefPtr<nsAHttpTransaction> transaction = mOwner->Transaction();
+    nsCOMPtr<nsISocketTransport> transport = mOwner->Transport();
+    if (transaction && transport) {
+      transaction->OnTransportStatus(transport,
+                                     NS_NET_STATUS_TLS_HANDSHAKE_STARTING, 0);
+    }
+  }
+
+  LOG(("TlsHandshaker::EnsureNPNComplete [mOwner=%p] drive TLS handshake",
+       mOwner.get()));
+  nsresult rv = ssl->DriveHandshake();
+  if (NS_FAILED(rv) && rv != NS_BASE_STREAM_WOULD_BLOCK) {
+    FinishNPNSetup(false, true);
+    return true;
+  }
+
+  Check0RttEnabled(ssl);
+  return false;
+}
+
+void TlsHandshaker::EarlyDataDone() {
+  if (mEarlyDataState == EarlyData::USED) {
+    mEarlyDataState = EarlyData::DONE_USED;
+  } else if (mEarlyDataState == EarlyData::CANNOT_BE_USED) {
+    mEarlyDataState = EarlyData::DONE_CANNOT_BE_USED;
+  } else if (mEarlyDataState == EarlyData::NOT_AVAILABLE) {
+    mEarlyDataState = EarlyData::DONE_NOT_AVAILABLE;
+  }
+}
+
+void TlsHandshaker::FinishNPNSetup(bool handshakeSucceeded,
+                                   bool hasSecurityInfo) {
+  LOG(("TlsHandshaker::FinishNPNSetup mOwner=%p", mOwner.get()));
+  mNPNComplete = true;
+
+  mOwner->PostProcessNPNSetup(handshakeSucceeded, hasSecurityInfo,
+                              EarlyDataUsed());
+  EarlyDataDone();
+}
+
+void TlsHandshaker::Check0RttEnabled(nsITLSSocketControl* ssl) {
+  if (!mOwner) {
+    return;
+  }
+
+  if (m0RTTChecked) {
+    return;
+  }
+
+  m0RTTChecked = true;
+
+  if (mConnInfo->UsingProxy()) {
+    return;
+  }
+
+  // There is no ALPN info (yet!). We need to consider doing 0RTT. We
+  // will do so if there is ALPN information from a previous session
+  // (AlpnEarlySelection), we are using HTTP/1, and the request data can
+  // be safely retried.
+  if (NS_FAILED(ssl->GetAlpnEarlySelection(mEarlyNegotiatedALPN))) {
+    LOG1(
+        ("TlsHandshaker::Check0RttEnabled %p - "
+         "early selected alpn not available",
+         mOwner.get()));
+  } else {
+    LOG1(
+        ("TlsHandshaker::Check0RttEnabled %p -"
+         "early selected alpn: %s",
+         mOwner.get(), mEarlyNegotiatedALPN.get()));
+    const SpdyInformation* info = gHttpHandler->SpdyInfo();
+    if (!mEarlyNegotiatedALPN.Equals(info->VersionString)) {
+      // This is the HTTP/1 case.
+      // Check if early-data is allowed for this transaction.
+      RefPtr<nsAHttpTransaction> transaction = mOwner->Transaction();
+      if (transaction && transaction->Do0RTT()) {
+        LOG(
+            ("TlsHandshaker::Check0RttEnabled [mOwner=%p] - We "
+             "can do 0RTT (http/1)!",
+             mOwner.get()));
+        mEarlyDataState = EarlyData::USED;
+      } else {
+        mEarlyDataState = EarlyData::CANNOT_BE_USED;
+        // Poll for read now. Polling for write will cause us to busy wait.
+        // When the handshake is done the polling flags will be set correctly.
+        Unused << mOwner->ResumeRecv();
+      }
+    } else {
+      // We have h2, we can at least 0-RTT the preamble and opening
+      // SETTINGS, etc, and maybe some of the first request
+      LOG(
+          ("TlsHandshaker::Check0RttEnabled [mOwner=%p] - Starting "
+           "0RTT for h2!",
+           mOwner.get()));
+      mEarlyDataState = EarlyData::USED;
+      mOwner->Start0RTTSpdy(info->Version);
+    }
+  }
+}
+
+void TlsHandshaker::EarlyDataTelemetry(int16_t tlsVersion,
+                                       bool earlyDataAccepted,
+                                       int64_t aContentBytesWritten0RTT) {
+  // Send the 0RTT telemetry only for tls1.3
+  if (tlsVersion > nsITLSSocketControl::TLS_VERSION_1_2) {
+    Telemetry::Accumulate(Telemetry::TLS_EARLY_DATA_NEGOTIATED,
+                          (mEarlyDataState == EarlyData::NOT_AVAILABLE)
+                              ? TLS_EARLY_DATA_NOT_AVAILABLE
+                              : ((mEarlyDataState == EarlyData::USED)
+                                     ? TLS_EARLY_DATA_AVAILABLE_AND_USED
+                                     : TLS_EARLY_DATA_AVAILABLE_BUT_NOT_USED));
+    if (EarlyDataUsed()) {
+      Telemetry::Accumulate(Telemetry::TLS_EARLY_DATA_ACCEPTED,
+                            earlyDataAccepted);
+    }
+    if (earlyDataAccepted) {
+      Telemetry::Accumulate(Telemetry::TLS_EARLY_DATA_BYTES_WRITTEN,
+                            aContentBytesWritten0RTT);
+    }
+  }
+}
+
+}  // namespace mozilla::net