@encharm/cws 4.4.1 → 4.5.2

package/src/headers/24/timers.h

@@ -0,0 +1,75 @@
+#ifndef SRC_TIMERS_H_
+#define SRC_TIMERS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "node_snapshotable.h"
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace timers {
+class BindingData : public SnapshotableObject {
+ public:
+  BindingData(Realm* env, v8::Local<v8::Object> obj);
+
+  using InternalFieldInfo = InternalFieldInfoBase;
+
+  SET_BINDING_ID(timers_binding_data)
+  SERIALIZABLE_OBJECT_METHODS()
+
+  SET_NO_MEMORY_INFO()
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void SetupTimers(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void SlowGetLibuvNow(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static double FastGetLibuvNow(v8::Local<v8::Value> receiver);
+  static double GetLibuvNowImpl(BindingData* data);
+
+  static void SlowScheduleTimer(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastScheduleTimer(v8::Local<v8::Object> unused,
+                                v8::Local<v8::Object> receiver,
+                                int64_t duration);
+  static void ScheduleTimerImpl(BindingData* data, int64_t duration);
+
+  static void SlowToggleTimerRef(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastToggleTimerRef(v8::Local<v8::Object> unused,
+                                 v8::Local<v8::Object> receiver,
+                                 bool ref);
+  static void ToggleTimerRefImpl(BindingData* data, bool ref);
+
+  static void SlowToggleImmediateRef(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastToggleImmediateRef(v8::Local<v8::Object> unused,
+                                     v8::Local<v8::Object> receiver,
+                                     bool ref);
+  static void ToggleImmediateRefImpl(BindingData* data, bool ref);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterTimerExternalReferences(
+      ExternalReferenceRegistry* registry);
+
+ private:
+  static v8::CFunction fast_get_libuv_now_;
+  static v8::CFunction fast_schedule_timer_;
+  static v8::CFunction fast_toggle_timer_ref_;
+  static v8::CFunction fast_toggle_immediate_ref_;
+};
+
+}  // namespace timers
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TIMERS_H_

package/src/headers/24/tlscontext.h

@@ -0,0 +1,228 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include <base_object.h>
+#include <crypto/crypto_context.h>
+#include <crypto/crypto_keys.h>
+#include <memory_tracker.h>
+#include <ncrypto.h>
+#include <ngtcp2/ngtcp2_crypto.h>
+#include "bindingdata.h"
+#include "data.h"
+#include "defs.h"
+#include "sessionticket.h"
+
+namespace node::quic {
+
+class Session;
+class TLSContext;
+
+// Every QUIC Session has exactly one TLSSession that maintains the state
+// of the TLS handshake and negotiated keys after the handshake has been
+// completed. It is separated out from the main Session class only as a
+// convenience to help make the code more maintainable and understandable.
+// A TLSSession is created from a TLSContext and maintains a reference to
+// the context.
+class TLSSession final : public MemoryRetainer {
+ public:
+  static const TLSSession& From(const SSL* ssl);
+
+  // The constructor is public in order to satisfy the call to std::make_unique
+  // in TLSContext::NewSession. It should not be called directly.
+  TLSSession(Session* session,
+             std::shared_ptr<TLSContext> context,
+             const std::optional<SessionTicket>& maybeSessionTicket);
+  DISALLOW_COPY_AND_MOVE(TLSSession)
+  ~TLSSession();
+
+  inline operator bool() const { return ssl_ != nullptr; }
+  inline Session& session() const { return *session_; }
+  inline TLSContext& context() const { return *context_; }
+
+  // Returns true if the handshake has been completed and early data was
+  // accepted by the TLS session. This will assert if the handshake has
+  // not been completed.
+  bool early_data_was_accepted() const;
+
+  v8::MaybeLocal<v8::Object> cert(Environment* env) const;
+  v8::MaybeLocal<v8::Object> peer_cert(Environment* env) const;
+  v8::MaybeLocal<v8::Object> ephemeral_key(Environment* env) const;
+  v8::MaybeLocal<v8::Value> cipher_name(Environment* env) const;
+  v8::MaybeLocal<v8::Value> cipher_version(Environment* env) const;
+
+  // The SNI (server name) negotiated for the session
+  const std::string_view servername() const;
+
+  // The ALPN (protocol name) negotiated for the session
+  const std::string_view protocol() const;
+
+  // Triggers key update to begin. This will fail and return false if either a
+  // previous key update is in progress or if the initial handshake has not yet
+  // been confirmed.
+  bool InitiateKeyUpdate();
+
+  struct PeerIdentityValidationError {
+    v8::MaybeLocal<v8::Value> reason;
+    v8::MaybeLocal<v8::Value> code;
+  };
+
+  // Checks the peer identity against the configured CA and CRL. If the peer
+  // certificate is valid, std::nullopt is returned. Otherwise a
+  // PeerIdentityValidationError is returned with the reason and code for the
+  // failure.
+  std::optional<PeerIdentityValidationError> VerifyPeerIdentity(
+      Environment* env);
+
+  inline const std::string_view validation_error() const {
+    return validation_error_;
+  }
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(TLSSession)
+  SET_SELF_SIZE(TLSSession)
+
+ private:
+  operator SSL*() const;
+  ncrypto::SSLPointer Initialize(
+      const std::optional<SessionTicket>& maybeSessionTicket);
+
+  static ngtcp2_conn* connection(ngtcp2_crypto_conn_ref* ref);
+
+  ngtcp2_crypto_conn_ref ref_;
+  std::shared_ptr<TLSContext> context_;
+  Session* session_;
+  ncrypto::SSLPointer ssl_;
+  ncrypto::BIOPointer bio_trace_;
+  std::string validation_error_ = "";
+  bool in_key_update_ = false;
+};
+
+// The TLSContext is used to create a TLSSession. For the client, there is
+// typically only a single TLSContext for each TLSSession. For the server,
+// there is a single TLSContext for the server and a TLSSession for every
+// QUIC session created by that server.
+class TLSContext final : public MemoryRetainer,
+                         public std::enable_shared_from_this<TLSContext> {
+ public:
+  static constexpr auto DEFAULT_CIPHERS = "TLS_AES_128_GCM_SHA256:"
+                                          "TLS_AES_256_GCM_SHA384:"
+                                          "TLS_CHACHA20_POLY1305_"
+                                          "SHA256:TLS_AES_128_CCM_SHA256";
+  static constexpr auto DEFAULT_GROUPS = "X25519:P-256:P-384:P-521";
+
+  struct Options final : public MemoryRetainer {
+    // The SNI servername to use for this session. This option is only used by
+    // the client.
+    std::string servername = "localhost";
+
+    // The ALPN (protocol name) to use for this session. This option is only
+    // used by the client.
+    std::string protocol = NGHTTP3_ALPN_H3;
+
+    // The list of TLS ciphers to use for this session.
+    std::string ciphers = DEFAULT_CIPHERS;
+
+    // The list of TLS groups to use for this session.
+    std::string groups = DEFAULT_GROUPS;
+
+    // When true, enables keylog output for the session.
+    bool keylog = false;
+
+    // When true, the peer certificate is verified against the list of supplied
+    // CA. If verification fails, the connection will be refused. When set,
+    // instructs the server session to request a client auth certificate. This
+    // option is only used by the server side.
+    bool verify_client = false;
+
+    // When true, enables TLS tracing for the session. This should only be used
+    // for debugging.
+    // JavaScript option name "tlsTrace".
+    bool enable_tls_trace = false;
+
+    // When true, causes the private key passed in for the session to be
+    // verified.
+    // JavaScript option name "verifyPrivateKey"
+    bool verify_private_key = false;
+
+    // The TLS private key(s) to use for this session.
+    // JavaScript option name "keys"
+    std::vector<crypto::KeyObjectData> keys;
+
+    // Collection of certificates to use for this session.
+    // JavaScript option name "certs"
+    std::vector<Store> certs;
+
+    // Optional certificate authority overrides to use.
+    // JavaScript option name "ca"
+    std::vector<Store> ca;
+
+    // Optional certificate revocation lists to use.
+    // JavaScript option name "crl"
+    std::vector<Store> crl;
+
+    void MemoryInfo(MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(TLSContext::Options)
+    SET_SELF_SIZE(Options)
+
+    // The default TLS configuration.
+    static const Options kDefault;
+
+    static v8::Maybe<Options> From(Environment* env,
+                                   v8::Local<v8::Value> value);
+
+    std::string ToString() const;
+  };
+
+  static std::shared_ptr<TLSContext> CreateClient(const Options& options);
+  static std::shared_ptr<TLSContext> CreateServer(const Options& options);
+
+  TLSContext(Side side, const Options& options);
+  DISALLOW_COPY_AND_MOVE(TLSContext)
+
+  // Each QUIC Session has exactly one TLSSession. Each TLSSession maintains
+  // a reference to the TLSContext used to create it.
+  std::unique_ptr<TLSSession> NewSession(
+      Session* session, const std::optional<SessionTicket>& maybeSessionTicket);
+
+  inline Side side() const { return side_; }
+  inline const Options& options() const { return options_; }
+  inline operator bool() const { return ctx_ != nullptr; }
+
+  inline const std::string_view validation_error() const {
+    return validation_error_;
+  }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(TLSContext)
+  SET_SELF_SIZE(TLSContext)
+
+ private:
+  ncrypto::SSLCtxPointer Initialize();
+  operator SSL_CTX*() const;
+
+  static void OnKeylog(const SSL* ssl, const char* line);
+  static int OnNewSession(SSL* ssl, SSL_SESSION* session);
+  static int OnSelectAlpn(SSL* ssl,
+                          const unsigned char** out,
+                          unsigned char* outlen,
+                          const unsigned char* in,
+                          unsigned int inlen,
+                          void* arg);
+  static int OnVerifyClientCertificate(int preverify_ok, X509_STORE_CTX* ctx);
+
+  Side side_;
+  Options options_;
+  ncrypto::X509Pointer cert_;
+  ncrypto::X509Pointer issuer_;
+  ncrypto::SSLCtxPointer ctx_;
+  std::string validation_error_ = "";
+
+  friend class TLSSession;
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/24/tokens.h

@@ -0,0 +1,256 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include <memory_tracker.h>
+#include <ngtcp2/ngtcp2_crypto.h>
+#include <node_internals.h>
+#include <node_sockaddr.h>
+#include "cid.h"
+#include "defs.h"
+
+namespace node::quic {
+
+// TokenSecrets are used to generate things like stateless reset tokens,
+// retry tokens, and token packets. They are always QUIC_TOKENSECRET_LEN
+// bytes in length.
+//
+// In the default case, token secrets will always be generated randomly.
+// User code will be given the option to provide a secret directly
+// however.
+class TokenSecret final : public MemoryRetainer {
+ public:
+  static constexpr int QUIC_TOKENSECRET_LEN = 16;
+
+  // Generate a random secret.
+  TokenSecret();
+
+  // Copy the given secret. The uint8_t* is assumed
+  // to be QUIC_TOKENSECRET_LEN in length. Note that
+  // the length is not verified so care must be taken
+  // when this constructor is used.
+  explicit TokenSecret(const uint8_t* secret);
+  ~TokenSecret();
+
+  TokenSecret(const TokenSecret&) = default;
+  TokenSecret& operator=(const TokenSecret&) = default;
+  DISALLOW_MOVE(TokenSecret)
+
+  operator const uint8_t*() const;
+  uint8_t operator[](int pos) const;
+
+  std::string ToString() const;
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(TokenSecret)
+  SET_SELF_SIZE(TokenSecret)
+
+ private:
+  operator const char*() const;
+  uint8_t buf_[QUIC_TOKENSECRET_LEN];
+};
+
+// A stateless reset token is used when a QUIC endpoint receives a QUIC packet
+// with a short header but the associated connection ID cannot be matched to any
+// known Session. In such cases, the receiver may choose to send a subtle opaque
+// indication to the sending peer that state for the Session has apparently been
+// lost. For any on- or off- path attacker, a stateless reset packet resembles
+// any other QUIC packet with a short header. In order to be successfully
+// handled as a stateless reset, the peer must have already seen a reset token
+// issued to it associated with the given CID. The token itself is opaque to the
+// peer that receives is but must be possible to statelessly recreate by the
+// peer that originally created it. The actual implementation is Node.js
+// specific but we currently defer to a utility function provided by ngtcp2.
+//
+// QUIC leaves the generation of stateless session tokens up to the
+// implementation to figure out. The idea, however, is that it ought to be
+// possible to generate a stateless reset token reliably even when all state
+// for a connection has been lost. We use the cid as it is the only reliably
+// consistent bit of data we have when a session is destroyed.
+//
+// StatlessResetTokens are always kStatelessTokenLen bytes,
+// as are the secrets used to generate the token.
+class StatelessResetToken final : public MemoryRetainer {
+ public:
+  static constexpr int kStatelessTokenLen = NGTCP2_STATELESS_RESET_TOKENLEN;
+
+  StatelessResetToken();
+
+  // Generates a stateless reset token using HKDF with the cid and token secret
+  // as input. The token secret is either provided by user code when an Endpoint
+  // is created or is generated randomly.
+  StatelessResetToken(const TokenSecret& secret, const CID& cid);
+
+  // Generates a stateless reset token using the given token storage.
+  // The StatelessResetToken wraps the token and does not take ownership.
+  // The token storage must be at least kStatelessTokenLen bytes in length.
+  // The length is not verified so care must be taken when using this
+  // constructor.
+  StatelessResetToken(uint8_t* token,
+                      const TokenSecret& secret,
+                      const CID& cid);
+
+  // Wraps the given token. Does not take over ownership of the token storage.
+  // The token must be at least kStatelessTokenLen bytes in length.
+  // The length is not verified so care must be taken when using this
+  // constructor.
+  explicit StatelessResetToken(const uint8_t* token);
+
+  StatelessResetToken(const StatelessResetToken& other);
+  DISALLOW_MOVE(StatelessResetToken)
+
+  std::string ToString() const;
+
+  operator const uint8_t*() const;
+  operator bool() const;
+
+  bool operator==(const StatelessResetToken& other) const;
+  bool operator!=(const StatelessResetToken& other) const;
+
+  struct Hash {
+    size_t operator()(const StatelessResetToken& token) const;
+  };
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(StatelessResetToken)
+  SET_SELF_SIZE(StatelessResetToken)
+
+  template <typename T>
+  using Map =
+      std::unordered_map<StatelessResetToken, T, StatelessResetToken::Hash>;
+
+  static StatelessResetToken kInvalid;
+
+ private:
+  operator const char*() const;
+
+  const uint8_t* ptr_;
+  uint8_t buf_[NGTCP2_STATELESS_RESET_TOKENLEN];
+};
+
+// A RETRY packet communicates a retry token to the client. Retry tokens are
+// generated only by QUIC servers for the purpose of validating the network path
+// between a client and server. The content payload of the RETRY packet is
+// opaque to the clientand must not be guessable by on- or off-path attackers.
+//
+// A QUIC server sends a RETRY token as a way of initiating explicit path
+// validation in response to an initial QUIC packet. The client, upon receiving
+// a RETRY, must abandon the initial connection attempt and try again with the
+// received retry token included with the new initial packet sent to the server.
+// If the server is performing explicit validation, it will look for the
+// presence of the retry token and attempt to validate it if found. The internal
+// structure of the retry token must be meaningful to the server, and the server
+// must be able to validate that the token is correct without relying on any
+// state left over from the previous connection attempt. We use an
+// implementation that is provided by ngtcp2.
+//
+// The token secret must be kept private on the QUIC server that generated the
+// retry. When multiple QUIC servers are used in a cluster, it cannot be
+// guaranteed that the same QUIC server instance will receive the subsequent new
+// Initial packet. Therefore, all QUIC servers in the cluster should either
+// share or be aware of the same token secret or a mechanism needs to be
+// implemented to ensure that subsequent packets are routed to the same QUIC
+// server instance.
+class RetryToken final : public MemoryRetainer {
+ public:
+  // The token prefix that is used to differentiate between a retry token
+  // and a regular token.
+  static constexpr uint8_t kTokenMagic = NGTCP2_CRYPTO_TOKEN_MAGIC_RETRY;
+  static constexpr int kRetryTokenLen = NGTCP2_CRYPTO_MAX_RETRY_TOKENLEN;
+
+  static constexpr uint64_t QUIC_DEFAULT_RETRYTOKEN_EXPIRATION =
+      10 * NGTCP2_SECONDS;
+  static constexpr uint64_t QUIC_MIN_RETRYTOKEN_EXPIRATION = 1 * NGTCP2_SECONDS;
+
+  // Generates a new retry token.
+  RetryToken(uint32_t version,
+             const SocketAddress& address,
+             const CID& retry_cid,
+             const CID& odcid,
+             const TokenSecret& token_secret);
+
+  // Wraps the given retry token
+  RetryToken(const uint8_t* token, size_t length);
+
+  // Validates the retry token given the input. If the token is valid,
+  // the embedded original CID will be extracted from the token an
+  // returned. If the token is invalid, std::nullopt will be returned.
+  std::optional<CID> Validate(
+      uint32_t version,
+      const SocketAddress& address,
+      const CID& cid,
+      const TokenSecret& token_secret,
+      uint64_t verification_expiration = QUIC_DEFAULT_RETRYTOKEN_EXPIRATION);
+
+  operator const ngtcp2_vec&() const;
+  operator const ngtcp2_vec*() const;
+  operator bool() const;
+
+  std::string ToString() const;
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(RetryToken)
+  SET_SELF_SIZE(RetryToken)
+
+ private:
+  operator const char*() const;
+  uint8_t buf_[kRetryTokenLen];
+  const ngtcp2_vec ptr_;
+};
+
+// A NEW_TOKEN packet communicates a regular token to a client that the server
+// would like the client to send in the header of an initial packet for a
+// future connection. It is similar to RETRY and used for the same purpose,
+// except a NEW_TOKEN is used in advance of the client establishing a new
+// connection and a RETRY is sent in response to the client trying to open
+// a new connection.
+class RegularToken final : public MemoryRetainer {
+ public:
+  // The token prefix that is used to differentiate between a retry token
+  // and a regular token.
+  static constexpr uint8_t kTokenMagic = NGTCP2_CRYPTO_TOKEN_MAGIC_REGULAR;
+  static constexpr int kRegularTokenLen = NGTCP2_CRYPTO_MAX_REGULAR_TOKENLEN;
+  static constexpr uint64_t QUIC_DEFAULT_REGULARTOKEN_EXPIRATION =
+      10 * NGTCP2_SECONDS;
+  static constexpr uint64_t QUIC_MIN_REGULARTOKEN_EXPIRATION =
+      1 * NGTCP2_SECONDS;
+
+  RegularToken();
+
+  // Generates a new retry token.
+  RegularToken(uint32_t version,
+               const SocketAddress& address,
+               const TokenSecret& token_secret);
+
+  // Wraps the given retry token
+  RegularToken(const uint8_t* token, size_t length);
+
+  // Validates the retry token given the input.
+  bool Validate(
+      uint32_t version,
+      const SocketAddress& address,
+      const TokenSecret& token_secret,
+      uint64_t verification_expiration = QUIC_DEFAULT_REGULARTOKEN_EXPIRATION);
+
+  operator const ngtcp2_vec&() const;
+  operator const ngtcp2_vec*() const;
+
+  operator bool() const;
+
+  std::string ToString() const;
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(RetryToken)
+  SET_SELF_SIZE(RetryToken)
+
+ private:
+  operator const char*() const;
+  uint8_t buf_[kRegularTokenLen];
+  const ngtcp2_vec ptr_;
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/{14/tracing → 24}/trace_event.h

@@ -321,7 +321,9 @@ class TraceEventHelper {
   static inline const uint8_t* GetCategoryGroupEnabled(const char* group) {
     v8::TracingController* controller = GetTracingController();
     static const uint8_t disabled = 0;
-    if (UNLIKELY(controller == nullptr)) return &disabled;
+    if (controller == nullptr) [[unlikely]] {
+      return &disabled;
+    }
     return controller->GetCategoryGroupEnabled(group);
   }
 };
@@ -483,13 +485,13 @@ static V8_INLINE uint64_t AddTraceEventWithTimestampImpl(
     const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
     const char** arg_names, const uint8_t* arg_types,
     const uint64_t* arg_values, unsigned int flags, int64_t timestamp) {
-  std::unique_ptr<v8::ConvertableToTraceFormat> arg_convertables[2];
+  std::unique_ptr<v8::ConvertableToTraceFormat> arg_convertibles[2];
   if (num_args > 0 && arg_types[0] == TRACE_VALUE_TYPE_CONVERTABLE) {
-    arg_convertables[0].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
+    arg_convertibles[0].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
         static_cast<intptr_t>(arg_values[0])));
   }
   if (num_args > 1 && arg_types[1] == TRACE_VALUE_TYPE_CONVERTABLE) {
-    arg_convertables[1].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
+    arg_convertibles[1].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
         static_cast<intptr_t>(arg_values[1])));
   }
   // DCHECK_LE(num_args, 2);
@@ -498,7 +500,7 @@ static V8_INLINE uint64_t AddTraceEventWithTimestampImpl(
   if (controller == nullptr) return 0;
   return controller->AddTraceEventWithTimestamp(
       phase, category_group_enabled, name, scope, id, bind_id, num_args,
-      arg_names, arg_types, arg_values, arg_convertables, flags, timestamp);
+      arg_names, arg_types, arg_values, arg_convertibles, flags, timestamp);
 }
 
 static V8_INLINE void AddMetadataEventImpl(