@encharm/cws 4.4.1 → 4.5.2

package/src/headers/24/node_context_data.h

@@ -0,0 +1,168 @@
+#ifndef SRC_NODE_CONTEXT_DATA_H_
+#define SRC_NODE_CONTEXT_DATA_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "util.h"
+#include "v8.h"
+
+namespace node {
+
+// Pick an index that's hopefully out of the way when we're embedded inside
+// another application. Performance-wise or memory-wise it doesn't matter:
+// Context::SetAlignedPointerInEmbedderData() is backed by a FixedArray,
+// worst case we pay a one-time penalty for resizing the array.
+#ifndef NODE_CONTEXT_EMBEDDER_DATA_INDEX
+#define NODE_CONTEXT_EMBEDDER_DATA_INDEX 32
+#endif
+
+#ifndef NODE_CONTEXT_SANDBOX_OBJECT_INDEX
+#define NODE_CONTEXT_SANDBOX_OBJECT_INDEX 33
+#endif
+
+#ifndef NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX
+#define NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX 34
+#endif
+
+#ifndef NODE_BINDING_DATA_STORE_INDEX
+#define NODE_BINDING_DATA_STORE_INDEX 35
+#endif
+
+#ifndef NODE_CONTEXT_ALLOW_CODE_GENERATION_FROM_STRINGS_INDEX
+#define NODE_CONTEXT_ALLOW_CODE_GENERATION_FROM_STRINGS_INDEX 36
+#endif
+
+#ifndef NODE_CONTEXT_CONTEXTIFY_CONTEXT_INDEX
+#define NODE_CONTEXT_CONTEXTIFY_CONTEXT_INDEX 37
+#endif
+
+#ifndef NODE_CONTEXT_REALM_INDEX
+#define NODE_CONTEXT_REALM_INDEX 38
+#endif
+
+// NODE_CONTEXT_TAG must be greater than any embedder indexes so that a single
+// check on the number of embedder data fields can assure the presence of all
+// embedder indexes.
+#ifndef NODE_CONTEXT_TAG
+#define NODE_CONTEXT_TAG 39
+#endif
+
+/**
+ * These are indexes used to set Node.js-specific data in the V8 contexts
+ * via v8::Context::SetAlignedPointerInEmbedderData() (for pointers) and
+ * v8::Context::SetEmbedderData() (for v8::Values).
+ *
+ * There are five types of contexts in Node.js:
+ * 1. Default V8 context, with nothing Node.js-specific. This is normally only
+ *    created by the embedders that uses v8::Context APIs directly and is not
+ *    available through the Node.js JS APIs. Its context snapshot in the
+ *    built-in v8 startup snapshot is stored using
+ *    v8::SnapshotCreator::SetDefaultContext() - effectively at index 0.
+ * 2. Default Node.js main context. When Node.js is launched typically there is
+ *    a main thread on which a main node::Environment is created. The
+ *    Environment is associated with its own v8::Isolate (env->isolate()) and a
+ *    main v8::Context (env->context()). The corresponding data structure is
+ *    node::NodeMainInstance and the Environment is created in
+ *    node::NodeMainInstance::Run(). Its context snapshot in the built-in V8
+ *    startup snapshot is stored at node::SnapshotData::kNodeMainContextIndex.
+ * 3. Node.js worker context. When a Worker instance is created via
+ *    new worker_threads.Worker(), it gets its own OS thread, its
+ *    own node::Environment, its own v8::Isolate and its own v8::Context.
+ *    The corresponding data structure is node::Worker and the Environment
+ *    is created in node::Worker::Run().
+ *    Its context snapshot in the built-in V8 startup snapshot is stored at
+ *    node::SnapshotData::kNodeBaseContextIndex.
+ * 4. Contextified vm context: When a contextified context is created via
+ *    vm.createContext() or other related vm APIs, the vm.Context instance
+ *    gets its own v8::Context. It shares the thread, the v8::Isolate and
+ *    the node::Environment with the context where the vm APIs are called.
+ *    The corresponding data structure is node::ContextifyContext and
+ *    the initialization code is in node::ContextifyContext::New().
+ *    Its context snapshot in the built-in V8 startup snapshot is stored at
+ *    node::SnapshotData::kNodeVMContextIndex.
+ * 5. ShadowRealm context: When a JS ShadowRealm is created via new ShadowRealm,
+ *    it gets its own v8::Context. It also shares the thread, the v8::Isolate
+ *    and the node::Environment with the context where the ShadowRealm
+ *    constructor is called.  The corresponding data structure is
+ *    node::ShadowRealm and the initialization code is in
+ *    node::ShadowRealm::New().
+ */
+enum ContextEmbedderIndex {
+  // Pointer to the node::Environment associated with the context. Only set for
+  // context type 2-5. Used by Environment::GetCurrent(context) to retrieve
+  // the node::Environment associated with any Node.js context in the
+  // V8 callbacks.
+  kEnvironment = NODE_CONTEXT_EMBEDDER_DATA_INDEX,
+  // A v8::Value which is the sandbox object used to create the contextified vm
+  // context. For example the first argument of vm.createContext().
+  // Only set for context type 4 and used in ContextifyContext methods.
+  kSandboxObject = NODE_CONTEXT_SANDBOX_OBJECT_INDEX,
+  // A v8::Value indicating whether the context allows WebAssembly code
+  // generation.
+  // Only set for context type 2-5, and for them the default is v8::True.
+  // For context type 4 it's configurable via options.codeGeneration.wasm in the
+  // vm APIs. Used in the default v8::AllowWasmCodeGenerationCallback.
+  kAllowWasmCodeGeneration = NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX,
+  // A v8::Value indicating whether the context allows code generation via
+  // eval() or new Function().
+  // Only set for context type 2-5, and for them the default is v8::True.
+  // For context type 4 it's configurable via options.codeGeneration.strings in
+  // the
+  // vm APIs. Used in the default v8::AllowCodeGenerationFromStringsCallback.
+  kAllowCodeGenerationFromStrings =
+      NODE_CONTEXT_ALLOW_CODE_GENERATION_FROM_STRINGS_INDEX,
+  // Pointer to the node::ContextifyContext associated with vm.Contexts.
+  // Only set for context type 4. Used by ContextifyContext::Get() to get
+  // to the ContextifyContext from the property interceptors.
+  kContextifyContext = NODE_CONTEXT_CONTEXTIFY_CONTEXT_INDEX,
+  // Pointer to the node::Realm associated with the context.
+  // Only set for context type 2-3 and 5. For context type 2-3, it points to a
+  // node::PrincipalRealm. For context type 5 it points to a node::ShadowRealm.
+  // Used by Realm::GetCurrent(context) to retrieve the associated node::Realm
+  // with any Node.js context in the V8 callbacks.
+  kRealm = NODE_CONTEXT_REALM_INDEX,
+  // Pointer to a constant address which is
+  // node::ContextEmbedderTag::kNodeContextTagPtr.
+  // Only set for context type 2-5. Used by ContextEmbedderTag::IsNodeContext()
+  // to check whether a context is a Node.js context.
+  kContextTag = NODE_CONTEXT_TAG,
+};
+
+class ContextEmbedderTag {
+ public:
+  static inline void TagNodeContext(v8::Local<v8::Context> context) {
+    // Used by ContextEmbedderTag::IsNodeContext to know that we are on a node
+    // context.
+    context->SetAlignedPointerInEmbedderData(
+        ContextEmbedderIndex::kContextTag,
+        ContextEmbedderTag::kNodeContextTagPtr);
+  }
+
+  static inline bool IsNodeContext(v8::Local<v8::Context> context) {
+    if (context.IsEmpty()) [[unlikely]] {
+      return false;
+    }
+    if (context->GetNumberOfEmbedderDataFields() <=
+        ContextEmbedderIndex::kContextTag) [[unlikely]] {
+      return false;
+    }
+    if (context->GetAlignedPointerFromEmbedderData(
+            ContextEmbedderIndex::kContextTag) !=
+        ContextEmbedderTag::kNodeContextTagPtr) [[unlikely]] {
+      return false;
+    }
+    return true;
+  }
+
+ private:
+  static void* const kNodeContextTagPtr;
+  static int const kNodeContextTag;
+
+  ContextEmbedderTag() = delete;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_CONTEXT_DATA_H_

package/src/headers/24/node_contextify.h

@@ -0,0 +1,261 @@
+#ifndef SRC_NODE_CONTEXTIFY_H_
+#define SRC_NODE_CONTEXTIFY_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object-inl.h"
+#include "cppgc_helpers-inl.h"
+#include "node_context_data.h"
+#include "node_errors.h"
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace contextify {
+
+struct ContextOptions {
+  v8::Local<v8::String> name;
+  v8::Local<v8::String> origin;
+  v8::Local<v8::Boolean> allow_code_gen_strings;
+  v8::Local<v8::Boolean> allow_code_gen_wasm;
+  std::unique_ptr<v8::MicrotaskQueue> own_microtask_queue;
+  v8::Local<v8::Symbol> host_defined_options_id;
+  bool vanilla = false;
+};
+
+/**
+ * The memory management of a vm context is as follows:
+ *
+ *                                                          user code
+ *                                                              │
+ *                          As global proxy or                  ▼
+ *     ┌──────────────┐  kSandboxObject embedder data   ┌────────────────┐
+ * ┌─► │  V8 Context  │────────────────────────────────►│ Wrapper holder │
+ * │   └──────────────┘                                 └───────┬────────┘
+ * │         ▲  Object constructor/creation context             │
+ * │         │                                                  │
+ * │  ┌──────┴────────────┐  contextify_context_private_symbol  │
+ * │  │ ContextifyContext │◄────────────────────────────────────┘
+ * │  │   JS Wrapper      │◄──────────► ┌─────────────────────────┐
+ * │  └───────────────────┘  cppgc      │ node::ContextifyContext │
+ * │                                    │       C++ Object        │
+ * └──────────────────────────────────► └─────────────────────────┘
+ *     v8::TracedReference / ContextEmbedderIndex::kContextifyContext
+ *
+ * There are two possibilities for the "wrapper holder":
+ *
+ * 1. When vm.constants.DONT_CONTEXTIFY is used, the wrapper holder is the V8
+ *    context's global proxy object
+ * 2. Otherwise it's the arbitrary "sandbox object" that users pass into
+ *    vm.createContext() or a new empty object created internally if they pass
+ *    undefined.
+ *
+ * In 2, the global object of the new V8 context is created using
+ * global_object_template with interceptors that perform any requested
+ * operations on the global object in the context first on the sandbox object
+ * living outside of the new context, then fall back to the global proxy of the
+ * new context.
+ *
+ * It's critical for the user-accessible wrapper holder to keep the
+ * ContextifyContext wrapper alive via contextify_context_private_symbol
+ * so that the V8 context is always available to the user while they still
+ * hold the vm "context" object alive.
+ *
+ * It's also critical for the V8 context to keep the wrapper holder
+ * (specifically, the "sandbox object" if users pass one) as well as the
+ * node::ContextifyContext C++ object alive, so that when the code
+ * runs inside the object and accesses the global object, the interceptors
+ * can still access the "sandbox object" and perform operations
+ * on them, even if users already relinquish access to the outer
+ * "sandbox object".
+ *
+ * The v8::TracedReference and the ContextEmbedderIndex::kContextifyContext
+ * slot in the context only act as shortcuts between
+ * the node::ContextifyContext C++ object and the V8 context.
+ */
+class ContextifyContext final : CPPGC_MIXIN(ContextifyContext) {
+ public:
+  SET_CPPGC_NAME(ContextifyContext)
+  void Trace(cppgc::Visitor* visitor) const final;
+  SET_NO_MEMORY_INFO()
+
+  ContextifyContext(Environment* env,
+                    v8::Local<v8::Object> wrapper,
+                    v8::Local<v8::Context> v8_context,
+                    ContextOptions* options);
+
+  // The destructors don't need to do anything because when the wrapper is
+  // going away, the context is already going away or otherwise it would've
+  // been holding the wrapper alive, so there's no need to reset the pointers
+  // in the context. Also, any global handles to the context would've been
+  // empty at this point, and the per-Environment context tracking code is
+  // capable of dealing with empty handles from contexts purged elsewhere.
+  ~ContextifyContext() = default;
+
+  static v8::MaybeLocal<v8::Context> CreateV8Context(
+      v8::Isolate* isolate,
+      v8::Local<v8::ObjectTemplate> object_template,
+      const SnapshotData* snapshot_data,
+      v8::MicrotaskQueue* queue);
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static ContextifyContext* ContextFromContextifiedSandbox(
+      Environment* env, const v8::Local<v8::Object>& wrapper_holder);
+
+  inline v8::Local<v8::Context> context() const {
+    return context_.Get(env()->isolate());
+  }
+
+  inline v8::Local<v8::Object> global_proxy() const {
+    return context()->Global();
+  }
+
+  inline v8::Local<v8::Object> sandbox() const {
+    // Only vanilla contexts have undefined sandboxes. sandbox() is only used by
+    // interceptors who are not supposed to be called on vanilla contexts.
+    v8::Local<v8::Value> result =
+        context()->GetEmbedderData(ContextEmbedderIndex::kSandboxObject);
+    CHECK(!result->IsUndefined());
+    return result.As<v8::Object>();
+  }
+
+  inline v8::MicrotaskQueue* microtask_queue() const {
+    return microtask_queue_.get();
+  }
+
+  template <typename T>
+  static ContextifyContext* Get(const v8::PropertyCallbackInfo<T>& args);
+  static ContextifyContext* Get(v8::Local<v8::Object> object);
+
+  static void InitializeGlobalTemplates(IsolateData* isolate_data);
+
+ private:
+  static ContextifyContext* New(Environment* env,
+                                v8::Local<v8::Object> sandbox_obj,
+                                ContextOptions* options);
+  // Initialize a context created from CreateV8Context()
+  static ContextifyContext* New(v8::Local<v8::Context> ctx,
+                                Environment* env,
+                                v8::Local<v8::Object> sandbox_obj,
+                                ContextOptions* options);
+
+  static bool IsStillInitializing(const ContextifyContext* ctx);
+  static void MakeContext(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsContext(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static v8::Intercepted PropertyQueryCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Integer>& args);
+  static v8::Intercepted PropertyGetterCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& args);
+  static v8::Intercepted PropertySetterCallback(
+      v8::Local<v8::Name> property,
+      v8::Local<v8::Value> value,
+      const v8::PropertyCallbackInfo<void>& args);
+  static v8::Intercepted PropertyDescriptorCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& args);
+  static v8::Intercepted PropertyDefinerCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyDescriptor& desc,
+      const v8::PropertyCallbackInfo<void>& args);
+  static v8::Intercepted PropertyDeleterCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Boolean>& args);
+  static void PropertyEnumeratorCallback(
+      const v8::PropertyCallbackInfo<v8::Array>& args);
+  static v8::Intercepted IndexedPropertyQueryCallback(
+      uint32_t index, const v8::PropertyCallbackInfo<v8::Integer>& args);
+  static v8::Intercepted IndexedPropertyGetterCallback(
+      uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& args);
+  static v8::Intercepted IndexedPropertySetterCallback(
+      uint32_t index,
+      v8::Local<v8::Value> value,
+      const v8::PropertyCallbackInfo<void>& args);
+  static v8::Intercepted IndexedPropertyDescriptorCallback(
+      uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& args);
+  static v8::Intercepted IndexedPropertyDefinerCallback(
+      uint32_t index,
+      const v8::PropertyDescriptor& desc,
+      const v8::PropertyCallbackInfo<void>& args);
+  static v8::Intercepted IndexedPropertyDeleterCallback(
+      uint32_t index, const v8::PropertyCallbackInfo<v8::Boolean>& args);
+  static void IndexedPropertyEnumeratorCallback(
+      const v8::PropertyCallbackInfo<v8::Array>& args);
+
+  v8::TracedReference<v8::Context> context_;
+  std::unique_ptr<v8::MicrotaskQueue> microtask_queue_;
+};
+
+class ContextifyScript final : CPPGC_MIXIN(ContextifyScript) {
+ public:
+  SET_CPPGC_NAME(ContextifyScript)
+  void Trace(cppgc::Visitor* visitor) const final;
+  SET_NO_MEMORY_INFO()
+
+  ContextifyScript(Environment* env, v8::Local<v8::Object> object);
+  ~ContextifyScript() override;
+
+  v8::Local<v8::UnboundScript> unbound_script() const;
+  void set_unbound_script(v8::Local<v8::UnboundScript>);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+  static ContextifyScript* New(Environment* env, v8::Local<v8::Object> object);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static bool InstanceOf(Environment* env, const v8::Local<v8::Value>& args);
+  static void CreateCachedData(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void RunInContext(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static bool EvalMachine(v8::Local<v8::Context> context,
+                          Environment* env,
+                          const int64_t timeout,
+                          const bool display_errors,
+                          const bool break_on_sigint,
+                          const bool break_on_first_line,
+                          v8::MicrotaskQueue* microtask_queue,
+                          const v8::FunctionCallbackInfo<v8::Value>& args);
+
+ private:
+  v8::TracedReference<v8::UnboundScript> script_;
+};
+
+class ContextifyFunction final {
+ public:
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+
+  static void CompileFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static v8::MaybeLocal<v8::Object> CompileFunctionAndCacheResult(
+      Environment* env,
+      v8::Local<v8::Context> parsing_context,
+      v8::ScriptCompiler::Source* source,
+      v8::LocalVector<v8::String> params,
+      v8::LocalVector<v8::Object> context_extensions,
+      v8::ScriptCompiler::CompileOptions options,
+      bool produce_cached_data,
+      v8::Local<v8::Symbol> id_symbol,
+      const errors::TryCatchScope& try_catch);
+
+ private:
+  ContextifyFunction() = delete;
+  ~ContextifyFunction() = delete;
+};
+
+v8::Maybe<void> StoreCodeCacheResult(
+    Environment* env,
+    v8::Local<v8::Object> target,
+    v8::ScriptCompiler::CompileOptions compile_options,
+    const v8::ScriptCompiler::Source& source,
+    bool produce_cached_data,
+    std::unique_ptr<v8::ScriptCompiler::CachedData> new_cached_data);
+
+}  // namespace contextify
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_CONTEXTIFY_H_

package/src/headers/{18 → 24}/node_crypto.h

@@ -29,26 +29,31 @@
 // remains for convenience for any code that still imports it. New
 // code should include the relevant src/crypto headers directly.
 #include "crypto/crypto_aes.h"
+#include "crypto/crypto_argon2.h"
 #include "crypto/crypto_bio.h"
+#include "crypto/crypto_chacha20_poly1305.h"
 #include "crypto/crypto_cipher.h"
 #include "crypto/crypto_context.h"
 #include "crypto/crypto_dh.h"
 #include "crypto/crypto_dsa.h"
 #include "crypto/crypto_ec.h"
-#include "crypto/crypto_groups.h"
 #include "crypto/crypto_hash.h"
 #include "crypto/crypto_hkdf.h"
 #include "crypto/crypto_hmac.h"
+#if OPENSSL_VERSION_MAJOR >= 3
+#include "crypto/crypto_kem.h"
+#endif
 #include "crypto/crypto_keygen.h"
 #include "crypto/crypto_keys.h"
+#include "crypto/crypto_ml_dsa.h"
 #include "crypto/crypto_pbkdf2.h"
 #include "crypto/crypto_random.h"
 #include "crypto/crypto_rsa.h"
 #include "crypto/crypto_scrypt.h"
 #include "crypto/crypto_sig.h"
 #include "crypto/crypto_spkac.h"
-#include "crypto/crypto_tls.h"
 #include "crypto/crypto_timing.h"
+#include "crypto/crypto_tls.h"
 #include "crypto/crypto_util.h"
 #include "crypto/crypto_x509.h"
 

package/src/headers/24/node_debug.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#ifdef DEBUG
+#include "util.h"
+#endif  // DEBUG
+
+namespace node {
+namespace debug {
+
+#ifdef DEBUG
+void TrackV8FastApiCall(FastStringKey key);
+int GetV8FastApiCallCount(FastStringKey key);
+
+#define TRACK_V8_FAST_API_CALL(key)                                            \
+  node::debug::TrackV8FastApiCall(FastStringKey(key))
+#else  // !DEBUG
+#define TRACK_V8_FAST_API_CALL(key)
+#endif  // DEBUG
+
+}  // namespace debug
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/24/node_dotenv.h

@@ -0,0 +1,45 @@
+#ifndef SRC_NODE_DOTENV_H_
+#define SRC_NODE_DOTENV_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "util-inl.h"
+#include "v8.h"
+
+#include <map>
+
+namespace node {
+
+class Dotenv {
+ public:
+  enum ParseResult { Valid, FileError, InvalidContent };
+  struct env_file_data {
+    std::string path;
+    bool is_optional;
+  };
+
+  Dotenv() = default;
+  Dotenv(const Dotenv& d) = delete;
+  Dotenv(Dotenv&& d) noexcept = default;
+  Dotenv& operator=(Dotenv&& d) noexcept = default;
+  Dotenv& operator=(const Dotenv& d) = delete;
+  ~Dotenv() = default;
+
+  void ParseContent(const std::string_view content);
+  ParseResult ParsePath(const std::string_view path);
+  void AssignNodeOptionsIfAvailable(std::string* node_options) const;
+  v8::Maybe<void> SetEnvironment(Environment* env);
+  v8::MaybeLocal<v8::Object> ToObject(Environment* env) const;
+
+  static std::vector<env_file_data> GetDataFromArgs(
+      const std::vector<std::string>& args);
+
+ private:
+  std::map<std::string, std::string> store_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_DOTENV_H_