diff --git a/doc/api/cli.md b/doc/api/cli.md
index e9357fb1bee5c6..100c4554cfc31a 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -357,6 +357,57 @@ Error: Access to this API has been restricted
 }
 ```
 
+### `--allow-net-udp`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1.1 - Active development
+
+When using the [Permission Model][], the process will not be able to create,
+receive, and send UDP packages by default. Attempts to do so will throw an
+`ERR_ACCESS_DENIED` unless the user explicitly passes the `--allow-net-udp` flag
+when starting Node.js.
+
+The argument format is `--allow-net-udp=domain_or_ip[/netmask][:port]`.
+The valid arguments are:
+
+* `*` - To allow all operations.
+* `--allow-net-udp=nodejs.org`
+* `--allow-net-udp=127.0.0.1`
+* `--allow-net-udp=127.0.0.1:8888`
+* `--allow-net-udp=127.0.0.1:*`
+* `--allow-net-udp=*:9999`
+* `--allow-net-udp=127.0.0.1/24:*`
+* `--allow-net-udp=127.0.0.1/255.255.255.0:*`
+* `--allow-net-udp=127.0.0.1:8080 --allow-net-udp=127.0.0.1:9090`
+* `--allow-net-udp=127.0.0.1:8080,localhost:9090`
+
+Example:
+
+```js
+const dgram = require('node:dgram');
+dgram.createSocket('udp4').bind(9297, '127.0.0.1')
+```
+
+```console
+$ node --experimental-permission --allow-fs-read=./index.js index.js
+node:events:498
+      throw er; // Unhandled 'error' event
+      ^
+
+Error [ERR_ACCESS_DENIED]: Access to this API has been restricted. Permission: bind to 127.0.0.1/9297
+    at node:dgram:379:18
+    at process.processTicksAndRejections (node:internal/process/task_queues:77:11)
+Emitted 'error' event on Socket instance at:
+    at afterDns (node:dgram:337:12)
+    at node:dgram:379:9
+    at process.processTicksAndRejections (node:internal/process/task_queues:77:11) {
+  code: 'ERR_ACCESS_DENIED'
+}
+```
+
 ### `--build-snapshot`
 
 <!-- YAML
@@ -1014,6 +1065,7 @@ following permissions are restricted:
 * Child Process - manageable through [`--allow-child-process`][] flag
 * Worker Threads - manageable through [`--allow-worker`][] flag
 * WASI - manageable through [`--allow-wasi`][] flag
+* UDP - manageable through [`--allow-net-udp`][] flag
 
 ### `--experimental-require-module`
 
@@ -2835,6 +2887,7 @@ one is included in the list below.
 * `--allow-child-process`
 * `--allow-fs-read`
 * `--allow-fs-write`
+* `--allow-net-udp`
 * `--allow-wasi`
 * `--allow-worker`
 * `--conditions`, `-C`
@@ -3390,6 +3443,7 @@ node --stack-trace-limit=12 -p -e "Error.stackTraceLimit" # prints 12
 [`--allow-child-process`]: #--allow-child-process
 [`--allow-fs-read`]: #--allow-fs-read
 [`--allow-fs-write`]: #--allow-fs-write
+[`--allow-net-udp`]: #--allow-net-udp
 [`--allow-wasi`]: #--allow-wasi
 [`--allow-worker`]: #--allow-worker
 [`--build-snapshot`]: #--build-snapshot
diff --git a/doc/api/permissions.md b/doc/api/permissions.md
index d41c94d74f676d..973064b8f131ad 100644
--- a/doc/api/permissions.md
+++ b/doc/api/permissions.md
@@ -509,6 +509,8 @@ using the [`--allow-child-process`][] and [`--allow-worker`][] respectively.
 To allow native addons when using permission model, use the [`--allow-addons`][]
 flag. For WASI, use the [`--allow-wasi`][] flag.
 
+For UDP, use [`--allow-net-udp`][] flag.
+
 #### Runtime API
 
 When enabling the Permission Model through the [`--experimental-permission`][]
@@ -583,6 +585,7 @@ There are constraints you need to know before using this system:
   * Inspector protocol
   * File system access
   * WASI
+  * UDP
 * The Permission Model is initialized after the Node.js environment is set up.
   However, certain flags such as `--env-file` or `--openssl-config` are designed
   to read files before environment initialization. As a result, such flags are
@@ -607,6 +610,7 @@ There are constraints you need to know before using this system:
 [`--allow-child-process`]: cli.md#--allow-child-process
 [`--allow-fs-read`]: cli.md#--allow-fs-read
 [`--allow-fs-write`]: cli.md#--allow-fs-write
+[`--allow-net-udp`]: cli.md#--allow-net-udp
 [`--allow-wasi`]: cli.md#--allow-wasi
 [`--allow-worker`]: cli.md#--allow-worker
 [`--experimental-permission`]: cli.md#--experimental-permission
diff --git a/doc/node.1 b/doc/node.1
index dabf354689a967..939bcf7e18776d 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -91,6 +91,9 @@ Allow execution of WASI when using the permission model.
 .It Fl -allow-worker
 Allow creating worker threads when using the permission model.
 .
+.It Fl -allow-net-udp
+Allow create, receive, and, send UDP packages when using the permission model.
+.
 .It Fl -completion-bash
 Print source-able bash completion script for Node.js.
 .
diff --git a/lib/dgram.js b/lib/dgram.js
index 9b411246afc545..5472bf0118a9a7 100644
--- a/lib/dgram.js
+++ b/lib/dgram.js
@@ -38,6 +38,7 @@ const {
   ErrnoException,
   ExceptionWithHostPort,
   codes: {
+    ERR_ACCESS_DENIED,
     ERR_BUFFER_OUT_OF_BOUNDS,
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_FD_TYPE,
@@ -81,6 +82,7 @@ const {
 
 const dc = require('diagnostics_channel');
 const udpSocketChannel = dc.channel('udp.socket');
+const permission = require('internal/process/permission');
 
 const BIND_STATE_UNBOUND = 0;
 const BIND_STATE_BINDING = 1;
@@ -327,12 +329,9 @@ Socket.prototype.bind = function(port_, address_ /* , callback */) {
     else
       address = '::';
   }
-
-  // Resolve address first
-  state.handle.lookup(address, (err, ip) => {
+  const afterDns = (err, ip) => {
     if (!state.handle)
       return; // Handle has been closed in the mean time
-
     if (err) {
       state.bindState = BIND_STATE_UNBOUND;
       this.emit('error', err);
@@ -372,7 +371,22 @@ Socket.prototype.bind = function(port_, address_ /* , callback */) {
 
       startListening(this);
     }
-  });
+  };
+  if (permission.isEnabled()) {
+    const resource = `${address}/${port || '*'}`;
+    if (!permission.has('net.udp', resource)) {
+      process.nextTick(() => {
+        afterDns(new ERR_ACCESS_DENIED(
+          `bind to ${resource}`,
+          resource,
+          'NetUDP'
+        ));
+      });
+      return this;
+    }
+  }
+  // Resolve address first
+  state.handle.lookup(address, afterDns);
 
   return this;
 };
@@ -413,13 +427,35 @@ function _connect(port, address, callback) {
     this.once('connect', callback);
 
   const afterDns = (ex, ip) => {
+    if (!ex && !address && permission.isEnabled()) {
+      const resource = `${ip}/${port}`;
+      if (!permission.has('net.udp', resource)) {
+        ex = new ERR_ACCESS_DENIED(
+          `connect to ${resource}`,
+          resource,
+          'NetUDP'
+        );
+      }
+    }
     defaultTriggerAsyncIdScope(
       this[async_id_symbol],
       doConnect,
       ex, this, ip, address, port, callback,
     );
   };
-
+  if (address && permission.isEnabled()) {
+    const resource = `${address}/${port}`;
+    if (!permission.has('net.udp', resource)) {
+      process.nextTick(() => {
+        afterDns(new ERR_ACCESS_DENIED(
+            `connect to ${resource}`,
+            resource,
+            'NetUDP'
+          ));
+      });
+      return;
+    }
+  }
   state.handle.lookup(address, afterDns);
 }
 
@@ -430,9 +466,13 @@ function doConnect(ex, self, ip, address, port, callback) {
     return;
 
   if (!ex) {
-    const err = state.handle.connect(ip, port);
-    if (err) {
-      ex = new ExceptionWithHostPort(err, 'connect', address, port);
+    try {
+      const err = state.handle.connect(ip, port);
+      if (err) {
+        ex = new ExceptionWithHostPort(err, 'connect', address, port);
+      }
+    } catch (e) {
+      ex = e;
     }
   }
 
@@ -663,6 +703,17 @@ Socket.prototype.send = function(buffer,
   }
 
   const afterDns = (ex, ip) => {
+    // If we have not checked before dns, check it now
+    if (!ex && !connected && !address && permission.isEnabled()) {
+      const resource = `${ip}/${port}`;
+      if (!permission.has('net.udp', resource)) {
+        ex = new ERR_ACCESS_DENIED(
+          `send to ${resource}`,
+          resource,
+          'NetUDP'
+        );
+      }
+    }
     defaultTriggerAsyncIdScope(
       this[async_id_symbol],
       doSend,
@@ -671,6 +722,20 @@ Socket.prototype.send = function(buffer,
   };
 
   if (!connected) {
+    // If address is not empty, check it
+    if (address && permission.isEnabled()) {
+      const resource = `${address}/${port}`;
+      if (!permission.has('net.udp', resource)) {
+        process.nextTick(() => {
+          afterDns(new ERR_ACCESS_DENIED(
+            `send to ${resource}`,
+            resource,
+            'NetUDP'
+          ));
+        });
+        return;
+      }
+    }
     state.handle.lookup(address, afterDns);
   } else {
     afterDns(null, null);
diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js
index 2c8d77f39e102c..268af1bb2c0c81 100644
--- a/lib/internal/process/pre_execution.js
+++ b/lib/internal/process/pre_execution.js
@@ -597,6 +597,7 @@ function initializePermission() {
       '--allow-child-process',
       '--allow-wasi',
       '--allow-worker',
+      '--allow-net-udp',
     ];
     ArrayPrototypeForEach(availablePermissionFlags, (flag) => {
       const value = getOptionValue(flag);
diff --git a/node.gyp b/node.gyp
index 9617596760a281..4de8c70756c754 100644
--- a/node.gyp
+++ b/node.gyp
@@ -158,6 +158,7 @@
       'src/permission/permission.cc',
       'src/permission/wasi_permission.cc',
       'src/permission/worker_permission.cc',
+      'src/permission/net_permission.cc',
       'src/pipe_wrap.cc',
       'src/process_wrap.cc',
       'src/signal_wrap.cc',
@@ -283,6 +284,7 @@
       'src/permission/permission.h',
       'src/permission/wasi_permission.h',
       'src/permission/worker_permission.h',
+      'src/permission/net_permission.h',
       'src/pipe_wrap.h',
       'src/req_wrap.h',
       'src/req_wrap-inl.h',
diff --git a/src/env.cc b/src/env.cc
index 799b36aaebdded..40df77294c02f1 100644
--- a/src/env.cc
+++ b/src/env.cc
@@ -950,6 +950,10 @@ Environment::Environment(IsolateData* isolate_data,
                           options_->allow_fs_write,
                           permission::PermissionScope::kFileSystemWrite);
     }
+    if (!options_->allow_net_udp.empty()) {
+      permission()->Apply(
+          this, options_->allow_net_udp, permission::PermissionScope::kNetUDP);
+    }
   }
 }
 
diff --git a/src/node_options.cc b/src/node_options.cc
index 1f4e402964c9ac..e3a64ed4cb9487 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -3,6 +3,7 @@
 
 #include "env-inl.h"
 #include "node_binding.h"
+#include "permission/net_permission.h"
 #include "node_external_reference.h"
 #include "node_internals.h"
 #include "node_sea.h"
@@ -224,6 +225,47 @@ void EnvironmentOptions::CheckOptions(std::vector<std::string>* errors,
 
   debug_options_.CheckOptions(errors, argv);
 #endif  // HAVE_INSPECTOR
+
+  // The flag --experimental_permission maybe set after --allow-net-udp
+  if (allow_net_udp.size() > 0) {
+    using std::string_view_literals::operator""sv;
+    // Allow multiple item in one flag, such as --allow-net-udp=127.0.0.1,localhost
+    for (const std::string& res : allow_net_udp) {
+      const std::vector<std::string_view> addresses = SplitString(res, ","sv);
+      for (const auto& address : addresses) {
+        if (address != "*"sv && address != "*:*"sv) {
+          // Parse string to get IP, port and netmask
+          std::unique_ptr<PermissionAddressInfo> result = ParseAddress(address);
+          // Address can be *, host and IP, do we need to check it ?
+          // Check port
+          if (result->port != "*" && (
+            !IsDigit(result->port) ||
+            std::stoi(result->port) > 0xFFFF
+          )) {
+            errors->push_back("invalid port: " + result->port);
+          }
+          // Check netmask
+          if (!result->netmask.empty()) {
+            int ip_version = IsIP(result->address);
+            if (ip_version == 0) {
+              errors->push_back("can not use netmask when IP is not an IPV4 or IPV6 address");
+            } else if (IsDigit(result->netmask)) {  // 127.0.0.1/24
+              int netmask_len = std::stoi(result->netmask);
+              if ((ip_version == 4 && netmask_len > 32) ||
+                  (ip_version == 6 && netmask_len > 128)) {
+                errors->push_back("invalid netmask: " + result->netmask);
+              }
+            } else { // 127.0.0.1/255.0.0.0
+              int netmask_ip_version = IsIP(result->netmask);
+              if (netmask_ip_version == 0 || netmask_ip_version != ip_version) {
+                errors->push_back("invalid netmask: " + result->netmask);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
 }
 
 namespace options_parser {
@@ -476,6 +518,11 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "allow worker threads when any permissions are set",
             &EnvironmentOptions::allow_worker_threads,
             kAllowedInEnvvar);
+  AddOption("--allow-net-udp",
+            "allow host:port or ip:port to bind and connect by UDP socket "
+            "when any permissions are set",
+            &EnvironmentOptions::allow_net_udp,
+            kAllowedInEnvvar);
   AddOption("--experimental-repl-await",
             "experimental await keyword support in REPL",
             &EnvironmentOptions::experimental_repl_await,
diff --git a/src/node_options.h b/src/node_options.h
index 7ffc7448cabc44..d30dba96654107 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -135,6 +135,7 @@ class EnvironmentOptions : public Options {
   bool allow_child_process = false;
   bool allow_wasi = false;
   bool allow_worker_threads = false;
+  std::vector<std::string> allow_net_udp;
   bool experimental_repl_await = true;
   bool experimental_vm_modules = false;
   bool expose_internals = false;
diff --git a/src/permission/net_permission.cc b/src/permission/net_permission.cc
new file mode 100755
index 00000000000000..7d210495844da4
--- /dev/null
+++ b/src/permission/net_permission.cc
@@ -0,0 +1,173 @@
+#include "net_permission.h"
+#include "debug_utils-inl.h"
+#include "json_utils.h"
+
+#include <cctype>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace node {
+
+namespace permission {
+
+bool ConvertIPToBitset(std::bitset<IPV6_BIT_LEN>* bitset,
+                       const std::string& str,
+                      int ip_version) {
+  int family = ip_version == 6 ? AF_INET6 : AF_INET;
+  int char_len = ip_version == 6 ? IPV6_CHAR_LEN : IPV4_CHAR_LEN;
+  int position = 0;
+  char buf[IPV6_CHAR_LEN];
+  // IP(like 127.0.0.1) in buf is [01111111][00000000][00000000][00000001]
+  if (uv_inet_pton(family, str.c_str(), &buf) == 0) {
+    // Handle char by char
+    for (int i = char_len - 1; i >= 0; i--) {
+      // Handle byte by byte
+      for (int j = 0; j < 8; j++) {
+        bitset->set(position++, !!(buf[i] & (1 << j)));
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+void NetPermission::Apply(Environment* env,
+                          const std::vector<std::string>& allow,
+                          PermissionScope scope) {
+  // For Debug
+  auto cleanup = OnScopeLeave([&]() { Print(); });
+  using std::string_view_literals::operator""sv;
+  for (const std::string& res : allow) {
+    // Allow multiple item in one flag, like --allow-net-udp=127.0.0.1,localhost
+    const std::vector<std::string_view> addresses = SplitString(res, ","sv);
+    for (const auto& address : addresses) {
+      switch (scope) {
+        case PermissionScope::kNetUDP:
+          // address is like *, *:*, host, host:*, host:port, *:port,
+          // host/netmask:port
+          if (address == "*"sv || address == "*:*"sv) {
+            deny_all_udp_ = false;
+            allow_all_udp_ = true;
+            granted_udp_.clear();
+            return;
+          }
+          GrantAccess(scope, address);
+          continue;
+        default:
+          continue;
+      }
+    }
+  }
+}
+
+void NetPermission::GrantAccess(PermissionScope scope,
+                                const std::string_view& param) {
+  std::unique_ptr<PermissionAddressInfo> result = ParseAddress(param);
+  std::bitset<IPV6_BIT_LEN> ip;
+  std::bitset<IPV6_BIT_LEN> netmask;
+  std::unique_ptr<NetMaskNode> net_mask_node;
+  int ip_version = IsIP(result->address);
+
+  if (ip_version > 0 && !result->netmask.empty()) {
+    if (IsDigit(result->netmask)) {  // 127.0.0.1/24
+      int netmask_len = std::stoi(result->netmask);
+      CHECK_GE(netmask_len, 0);
+      int position = ip_version == 6 ? IPV6_BIT_LEN : IPV4_BIT_LEN;
+      while (netmask_len--) {
+        netmask.set(--position, true);
+      }
+    } else { // 127.0.0.1/255.255.255.0
+      CHECK(ConvertIPToBitset(&netmask, result->netmask, ip_version));
+    }
+    CHECK(ConvertIPToBitset(&ip, result->address, ip_version));
+    std::bitset<IPV6_BIT_LEN> network = netmask & ip;
+    net_mask_node = std::make_unique<NetMaskNode>(netmask, network);
+  }
+  auto node = std::make_unique<NetNode>(
+      result->address, result->port, std::move(net_mask_node));
+  granted_udp_.push_back(std::move(node));
+  deny_all_udp_ = false;
+}
+
+bool NetPermission::is_granted(Environment* env,
+                               PermissionScope perm,
+                               const std::string_view& param = "") const {
+  switch (perm) {
+    case PermissionScope::kNetUDP:
+      return !deny_all_udp_ &&
+             (allow_all_udp_ || CheckoutResource(granted_udp_, param));
+    default:
+      return false;
+  }
+}
+
+bool NetPermission::CheckoutResource(
+    const std::vector<std::unique_ptr<NetNode>>& list,
+    const std::string_view& param) const {
+  if (param.empty()) {
+    return false;
+  }
+  using std::string_view_literals::operator""sv;
+  const std::vector<std::string_view> address_port = SplitString(param, "/"sv);
+  int size = address_port.size();
+  CHECK(size == 1 || size == 2);
+  std::string address;
+  std::string port;
+  if (size == 2) {
+    address = address_port[0];
+    port = address_port[1];
+  } else {
+    address = address_port[0];
+    port = "*";
+  }
+  for (uint32_t i = 0; i < list.size(); i++) {
+    auto node = list[i].get();
+    int ip_version = IsIP(address);
+    if (ip_version > 0 && node->net_mask_node) {
+      std::bitset<IPV6_BIT_LEN> ip;
+      if (!ConvertIPToBitset(&ip, address, ip_version)) {
+        return false;
+      }
+      std::bitset<IPV6_BIT_LEN> network = node->net_mask_node->netmask & ip;
+      if (node->net_mask_node->network == network &&
+          (node->port == "*" || node->port == port)) {
+        return true;
+      }
+    } else if ((node->address == "*" || node->address == address) &&
+               (node->port == "*" || node->port == port)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+
+void NetPermission::Print() const {
+  if (UNLIKELY(per_process::enabled_debug_list.enabled(
+          DebugCategory::PERMISSION_MODEL))) {
+    std::cout << "net-udp-net: " << std::endl;
+    std::cout << "  deny_all_udp_: " << deny_all_udp_ << std::endl;
+    std::cout << "  allow_all_udp_: " << allow_all_udp_ << std::endl;
+    JSONWriter writer(std::cout, false);
+    writer.json_arraystart("Nodes");
+    for (uint32_t i = 0; i < granted_udp_.size(); i++) {
+      auto node = granted_udp_[i].get();
+      writer.json_start();
+      writer.json_keyvalue("address", node->address);
+      writer.json_keyvalue("port", node->port);
+      if (node->net_mask_node) {
+        writer.json_keyvalue("netmask",
+                             node->net_mask_node->netmask.to_string());
+        writer.json_keyvalue("network",
+                             node->net_mask_node->network.to_string());
+      }
+      writer.json_end();
+    }
+    writer.json_arrayend();
+    std::cout << std::endl;
+  }
+}
+
+}  // namespace permission
+}  // namespace node
diff --git a/src/permission/net_permission.h b/src/permission/net_permission.h
new file mode 100755
index 00000000000000..49fcabcb577c1c
--- /dev/null
+++ b/src/permission/net_permission.h
@@ -0,0 +1,61 @@
+#ifndef SRC_PERMISSION_NET_PERMISSION_H_
+#define SRC_PERMISSION_NET_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <bitset>
+#include "permission/permission_base.h"
+#include "uv.h"
+#include "util.h"
+
+namespace node {
+
+namespace permission {
+
+class NetPermission final : public PermissionBase {
+ public:
+  void Apply(Environment* env,
+             const std::vector<std::string>& allow,
+             PermissionScope scope) override;
+  bool is_granted(Environment* env,
+                  PermissionScope perm,
+                  const std::string_view& param) const override;
+
+  struct NetMaskNode {
+    std::bitset<IPV6_BIT_LEN> netmask;
+    std::bitset<IPV6_BIT_LEN> network;
+    explicit NetMaskNode(const std::bitset<IPV6_BIT_LEN>& netmask_,
+                         const std::bitset<IPV6_BIT_LEN>& network_)
+        : netmask(netmask_), network(network_) {}
+  };
+
+  struct NetNode {
+    std::string address;
+    std::string port;
+    std::unique_ptr<NetMaskNode> net_mask_node;
+    explicit NetNode(const std::string& address_,
+                     const std::string& port_,
+                     std::unique_ptr<NetMaskNode> net_mask_node_)
+        : address(address_),
+          port(port_),
+          net_mask_node(std::move(net_mask_node_)) {}
+  };
+
+
+ private:
+  void GrantAccess(PermissionScope scope, const std::string_view& param);
+  bool CheckoutResource(const std::vector<std::unique_ptr<NetNode>>& list,
+                        const std::string_view& param = "") const;
+  void Print() const;
+
+  std::vector<std::unique_ptr<NetNode>> granted_udp_;
+  bool deny_all_udp_ = true;
+  bool allow_all_udp_ = false;
+};
+
+}  // namespace permission
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_NET_PERMISSION_H_
diff --git a/src/permission/permission.cc b/src/permission/permission.cc
index ad393df0e38976..010504533d6e2c 100644
--- a/src/permission/permission.cc
+++ b/src/permission/permission.cc
@@ -83,6 +83,7 @@ Permission::Permission() : enabled_(false) {
   std::shared_ptr<PermissionBase> inspector =
       std::make_shared<InspectorPermission>();
   std::shared_ptr<PermissionBase> wasi = std::make_shared<WASIPermission>();
+  std::shared_ptr<PermissionBase> net = std::make_shared<NetPermission>();
 #define V(Name, _, __)                                                         \
   nodes_.insert(std::make_pair(PermissionScope::k##Name, fs));
   FILESYSTEM_PERMISSIONS(V)
@@ -103,6 +104,10 @@ Permission::Permission() : enabled_(false) {
   nodes_.insert(std::make_pair(PermissionScope::k##Name, wasi));
   WASI_PERMISSIONS(V)
 #undef V
+#define V(Name, _, __)                                                         \
+  nodes_.insert(std::make_pair(PermissionScope::k##Name, net));
+  NET_PERMISSIONS(V)
+#undef V
 }
 
 Local<Value> CreateAccessDeniedError(Environment* env,
diff --git a/src/permission/permission.h b/src/permission/permission.h
index 55309b6ba551c2..a1bff1579cc79d 100644
--- a/src/permission/permission.h
+++ b/src/permission/permission.h
@@ -8,6 +8,7 @@
 #include "permission/child_process_permission.h"
 #include "permission/fs_permission.h"
 #include "permission/inspector_permission.h"
+#include "permission/net_permission.h"
 #include "permission/permission_base.h"
 #include "permission/wasi_permission.h"
 #include "permission/worker_permission.h"
diff --git a/src/permission/permission_base.h b/src/permission/permission_base.h
index d4ab33d10142f2..297bb035f64ef0 100644
--- a/src/permission/permission_base.h
+++ b/src/permission/permission_base.h
@@ -28,12 +28,17 @@ namespace permission {
 
 #define INSPECTOR_PERMISSIONS(V) V(Inspector, "inspector", PermissionsRoot)
 
+#define NET_PERMISSIONS(V)                                                     \
+  V(Net, "net", PermissionsRoot)                                               \
+  V(NetUDP, "net.udp", Net)
+
 #define PERMISSIONS(V)                                                         \
   FILESYSTEM_PERMISSIONS(V)                                                    \
   CHILD_PROCESS_PERMISSIONS(V)                                                 \
   WASI_PERMISSIONS(V)                                                          \
   WORKER_THREADS_PERMISSIONS(V)                                                \
-  INSPECTOR_PERMISSIONS(V)
+  INSPECTOR_PERMISSIONS(V)                                                     \
+  NET_PERMISSIONS(V)
 
 #define V(name, _, __) k##name,
 enum class PermissionScope {
diff --git a/src/util.cc b/src/util.cc
index 305d66f2f02a56..e8a43c83afd390 100644
--- a/src/util.cc
+++ b/src/util.cc
@@ -861,4 +861,58 @@ v8::Maybe<int> GetValidFileMode(Environment* env,
   return v8::Just(mode);
 }
 
+bool IsDigit(const std::string& str) {
+  return !str.empty() && std::all_of(str.begin(), str.end(), ::isdigit);
+}
+
+int IsIP(const std::string& address) {
+  char buf[IPV6_CHAR_LEN];
+  if (uv_inet_pton(AF_INET, address.c_str(), &buf) == 0) {
+    return 4;
+  }
+  if (uv_inet_pton(AF_INET6, address.c_str(), &buf) == 0) {
+    return 6;
+  }
+  return 0;
+}
+
+std::unique_ptr<PermissionAddressInfo> ParseAddress(const std::string_view& param) {
+  using std::string_view_literals::operator""sv;
+  size_t ipv6_idx = param.find("]"sv);
+  bool is_ipv6 = ipv6_idx != std::string::npos;
+  size_t net_mask_idx = param.find("/"sv);
+  bool has_net_mask = net_mask_idx != std::string::npos;
+  size_t port_idx = param.find(":"sv, is_ipv6 ? ipv6_idx : 0);
+  bool has_port = port_idx != std::string::npos;
+  std::string address;
+  std::string net_mask;
+  std::string port;
+  if (is_ipv6) {
+    address = param.substr(1, ipv6_idx - 1);
+  } else {
+    if (has_net_mask) {
+      address = param.substr(0, net_mask_idx);
+    } else if (has_port) {
+      address = param.substr(0, port_idx);
+    } else {
+      address = param;
+    }
+  }
+  if (has_net_mask) {
+    if (has_port) {
+      net_mask = param.substr(net_mask_idx + 1, port_idx - net_mask_idx - 1);
+    } else {
+      net_mask = param.substr(net_mask_idx + 1);
+    }
+  }
+  if (has_port) {
+    port = param.substr(port_idx + 1);
+  }
+  if (port.empty()) {
+    port = "*";
+  }
+  return std::unique_ptr<PermissionAddressInfo>(
+    new PermissionAddressInfo(address, net_mask, port));
+}
+
 }  // namespace node
diff --git a/src/util.h b/src/util.h
index 1bb352537d6e51..be70a85e9a2edd 100644
--- a/src/util.h
+++ b/src/util.h
@@ -1009,6 +1009,25 @@ v8::Maybe<int> GetValidFileMode(Environment* env,
 // case insensitive.
 inline bool IsWindowsBatchFile(const char* filename);
 
+constexpr int IPV4_CHAR_LEN = sizeof(struct in_addr);
+constexpr int IPV6_CHAR_LEN = sizeof(struct in6_addr);
+constexpr int IPV4_BIT_LEN = IPV4_CHAR_LEN << 3;
+constexpr int IPV6_BIT_LEN = IPV6_CHAR_LEN << 3;
+
+struct PermissionAddressInfo {
+  std::string address;
+  std::string netmask;
+  std::string port;
+  explicit PermissionAddressInfo(const std::string& address_,
+                                 const std::string& netmask_,
+                                 const std::string& port_)
+      : address(address_), netmask(netmask_), port(port_) {}
+};
+
+bool IsDigit(const std::string& str);
+int IsIP(const std::string& address);
+std::unique_ptr<PermissionAddressInfo> ParseAddress(const std::string_view& param);
+
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/test/parallel/test-permission-allow-net-udp-socket.js b/test/parallel/test-permission-allow-net-udp-socket.js
new file mode 100644
index 00000000000000..437cf7767cbb20
--- /dev/null
+++ b/test/parallel/test-permission-allow-net-udp-socket.js
@@ -0,0 +1,348 @@
+'use strict';
+
+const common = require('../common');
+const { spawnSync } = require('child_process');
+const assert = require('assert');
+
+common.skipIfWorker();
+
+{
+  const example = () => {
+    const assert = require('node:assert');
+    const dgram = require('dgram');
+
+    const tests = [
+      // [port, ip]
+      [],
+      [9999],
+      [9999, '127.0.0.1'],
+      [9999, 'localhost'],
+    ];
+
+    tests.forEach((test, i) => {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(test[0], test[1]).on('error', (err) => {
+        assert.ok(err.code === 'ERR_ACCESS_DENIED', err.message);
+        socket.close();
+      });
+    });
+  };
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-permission',
+      '-e',
+      `(${example.toString()})()`,
+    ]
+  );
+  if (status !== 0) {
+    console.error(stderr.toString());
+  }
+  assert.strictEqual(status, 0);
+}
+
+{
+  const example = () => {
+    const assert = require('assert');
+    const dgram = require('dgram');
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind().on('listening', (err) => {
+        assert.ok(!err);
+        socket.close();
+      });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(9999)
+        .on('listening', () => {
+          socket.close();
+        })
+        .on('error', (err) => {
+          assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(9999, 'localhost')
+        .on('listening', () => {
+          socket.close();
+        })
+        .on('error', (err) => {
+          assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.connect(9999, '127.0.0.1', (err) => {
+        if (err) {
+          assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+        }
+        socket.close();
+      });
+    }
+  };
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-permission',
+      '--allow-net-udp=*',
+      '-e',
+      `(${example.toString()})()`,
+    ]
+  );
+  if (status !== 0) {
+    console.error(stderr.toString());
+  }
+  assert.strictEqual(status, 0);
+}
+
+{
+  const example = () => {
+    const assert = require('assert');
+    const dgram = require('dgram');
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(5555, '127.0.0.1')
+        .on('listening', () => {
+          socket.close();
+        })
+        .on('error', (err) => {
+          assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(6666, 'localhost')
+        .on('error', (err) => {
+          assert.ok(err.code === 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(7777, '127.0.0.1')
+        .on('listening', () => {
+          socket.connect(8888, '127.0.0.1', (err) => {
+            if (err) {
+              assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+            }
+            socket.close();
+          });
+        })
+        .on('error', (err) => {
+          assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(9999, '127.0.0.1')
+        .on('listening', () => {
+          socket.connect(10000, 'localhost', (err) => {
+            assert.ok(err.code === 'ERR_ACCESS_DENIED', err.message);
+            socket.close();
+          });
+        })
+        .on('error', (err) => {
+          assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+  };
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-permission',
+      '--allow-net-udp=127.0.0.1:*',
+      '-e',
+      `(${example.toString()})()`,
+    ]
+  );
+  if (status !== 0) {
+    console.error(stderr.toString());
+  }
+  assert.strictEqual(status, 0);
+}
+
+{
+  const example = () => {
+    const assert = require('assert');
+    const dgram = require('dgram');
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(9999, '127.0.0.2')
+        .on('listening', () => {
+          socket.close();
+        })
+        .on('error', (err) => {
+          assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(8888, '127.0.0.2')
+        .on('error', (err) => {
+          assert.ok(err.code === 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(9999, '127.0.0.1')
+        .on('listening', () => {
+          socket.connect(9999, '127.0.0.1', (err) => {
+            if (err) {
+              assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+            }
+            socket.close();
+          });
+        })
+        .on('error', (err) => {
+          assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(9999, 'localhost')
+        .on('listening', () => {
+          socket.connect(10000, 'localhost', (err) => {
+            assert.ok(err.code === 'ERR_ACCESS_DENIED', err.message);
+            socket.close();
+          });
+        })
+        .on('error', (err) => {
+          assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+  };
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-permission',
+      '--allow-net-udp=*:9999',
+      '-e',
+      `(${example.toString()})()`,
+    ]
+  );
+  if (status !== 0) {
+    console.error(stderr.toString());
+  }
+  assert.strictEqual(status, 0);
+}
+
+{
+  const example = () => {
+    const assert = require('assert');
+    const dgram = require('dgram');
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(12345, '127.0.0.1')
+        .on('listening', () => {
+          socket.close();
+        })
+        .on('error', (err) => {
+          assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(7777, 'localhost')
+        .on('listening', () => {
+          socket.close();
+        })
+        .on('error', (err) => {
+          assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(9999, 'localhost')
+        .on('error', (err) => {
+          assert.ok(err.code === 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(8888, '127.0.0.1');
+      socket.connect(9999, '127.0.0.2', (err) => {
+        assert.ok(err.code === 'ERR_ACCESS_DENIED', err.message);
+        socket.close();
+      });
+    }
+  };
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-permission',
+      '--allow-net-udp=127.0.0.1:*',
+      '--allow-net-udp=localhost:7777,localhost:8888',
+      '-e',
+      `(${example.toString()})()`,
+    ]
+  );
+  if (status !== 0) {
+    console.error(stderr.toString());
+  }
+  assert.strictEqual(status, 0);
+}
+
+{
+  const example = () => {
+    const assert = require('assert');
+    const dgram = require('dgram');
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(9999, '127.255.0.2')
+        .on('listening', () => {
+          socket.close();
+        })
+        .on('error', (err) => {
+          assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(8888, '1:1:1:1:1:1:1:2')
+        .on('listening', () => {
+          socket.close();
+        })
+        .on('error', (err) => {
+          assert.ok(err.code !== 'ERR_ACCESS_DENIED', err.message);
+          socket.close();
+        });
+    }
+    {
+      const socket = dgram.createSocket('udp4');
+      socket.bind(7777, '127.0.0.1', (err) => {
+        assert.ok(err.code === 'ERR_ACCESS_DENIED', err.message);
+        socket.close();
+      });
+    }
+  };
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-permission',
+      '--allow-net-udp=127.255.0.1/16:9999',
+      '--allow-net-udp=127.255.0.1/16:9999',
+      '--allow-net-udp=[1:1:1:1:1:1:1:1]/8:8888',
+      '-e',
+      `(${example.toString()})()`,
+    ]
+  );
+  if (status !== 0) {
+    console.error(stderr.toString());
+  }
+  assert.strictEqual(status, 0);
+}
diff --git a/test/parallel/test-permission-allow-net-udp.js b/test/parallel/test-permission-allow-net-udp.js
new file mode 100644
index 00000000000000..9940242fa91408
--- /dev/null
+++ b/test/parallel/test-permission-allow-net-udp.js
@@ -0,0 +1,181 @@
+'use strict';
+
+const common = require('../common');
+
+const { spawnSync } = require('child_process');
+const assert = require('assert');
+
+common.skipIfWorker();
+
+{
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-permission',
+      '-e',
+      `
+        const assert = require('assert');
+        assert.ok(!process.permission.has('net.udp'));
+        assert.ok(!process.permission.has('net.udp', 'localhost'));
+        assert.ok(!process.permission.has('net.udp', '127.0.0.1/*'));
+        assert.ok(!process.permission.has('net.udp', '127.0.0.1/9999'));
+        assert.ok(!process.permission.has('net.udp', '*/9999'));
+        assert.ok(!process.permission.has('net.udp', '::1/*'));
+        assert.ok(!process.permission.has('net.udp', '::1/9999'));
+      `,
+    ]
+  );
+  if (status !== 0) {
+    console.error(stderr.toString());
+  }
+  assert.strictEqual(status, 0);
+}
+
+{
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-permission',
+      '--allow-net-udp=*',
+      '-e',
+      `
+        const assert = require('assert');
+        assert.ok(process.permission.has('net.udp'));
+        assert.ok(process.permission.has('net.udp', 'localhost'));
+        assert.ok(process.permission.has('net.udp', '127.0.0.1/*'));
+        assert.ok(process.permission.has('net.udp', '127.0.0.1/9999'));
+        assert.ok(process.permission.has('net.udp', '*/9999'));
+        assert.ok(process.permission.has('net.udp', '::1/*'));
+        assert.ok(process.permission.has('net.udp', '::1/9999'));
+      `,
+    ]
+  );
+  if (status !== 0) {
+    console.error(stderr.toString());
+  }
+  assert.strictEqual(status, 0);
+}
+
+{
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-permission',
+      '--allow-net-udp=*:9999',
+      '-e',
+      `
+        const assert = require('assert');
+        assert.ok(process.permission.has('net.udp', '127.0.0.1/9999'));
+        assert.ok(process.permission.has('net.udp', '*/9999'));
+        assert.ok(process.permission.has('net.udp', '::1/9999'));
+        assert.ok(!process.permission.has('net.udp', '127.0.0.1/8888'));
+      `,
+    ]
+  );
+  if (status !== 0) {
+    console.error(stderr.toString());
+  }
+  assert.strictEqual(status, 0);
+}
+
+{
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-permission',
+      '--allow-net-udp=127.0.0.1:*',
+      '--allow-net-udp=[::1]:*',
+      '-e',
+      `
+        const assert = require('assert');
+        assert.ok(process.permission.has('net.udp', '127.0.0.1/9999'));
+        assert.ok(process.permission.has('net.udp', '127.0.0.1/*'));
+        assert.ok(process.permission.has('net.udp', '::1/9999'));
+        assert.ok(process.permission.has('net.udp', '::1/*'));
+        assert.ok(!process.permission.has('net.udp', '127.0.0.2/9999'));
+        assert.ok(!process.permission.has('net.udp', '::2/9999'));
+      `,
+    ]
+  );
+  if (status !== 0) {
+    console.error(stderr.toString());
+  }
+  assert.strictEqual(status, 0);
+}
+
+{
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-permission',
+      '--allow-net-udp=127.0.0.1:9999',
+      '--allow-net-udp=[::1]:9999',
+      '-e',
+      `
+        const assert = require('assert');
+        assert.ok(process.permission.has('net.udp', '127.0.0.1/9999'));
+        assert.ok(process.permission.has('net.udp', '::1/9999'));
+        assert.ok(!process.permission.has('net.udp', '127.0.0.2/9999'));
+        assert.ok(!process.permission.has('net.udp', '127.0.0.1/8888'));
+        assert.ok(!process.permission.has('net.udp', '::2/9999'));
+        assert.ok(!process.permission.has('net.udp', '::1/8888'));
+      `,
+    ]
+  );
+  if (status !== 0) {
+    console.error(stderr.toString());
+  }
+  assert.strictEqual(status, 0);
+}
+
+{
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-permission',
+      '--allow-net-udp=127.0.0.1:5555,[::1]:6666',
+      '--allow-net-udp=127.0.0.2:8888,[::1]:9999',
+      '-e',
+      `
+        const assert = require('assert');
+        assert.ok(process.permission.has('net.udp', '127.0.0.1/5555'));
+        assert.ok(process.permission.has('net.udp', '::1/6666'));
+        assert.ok(process.permission.has('net.udp', '127.0.0.2/8888'));
+        assert.ok(process.permission.has('net.udp', '::1/9999'));
+        assert.ok(!process.permission.has('net.udp', '127.0.0.1/7777'));
+        assert.ok(!process.permission.has('net.udp', '::2/9999'));
+      `,
+    ]
+  );
+  if (status !== 0) {
+    console.error(stderr.toString());
+  }
+  assert.strictEqual(status, 0);
+}
+
+{
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-permission',
+      '--allow-net-udp=127.255.255.1/8:9999',
+      '--allow-net-udp=128.255.255.1/255.255.0.0:*',
+      '--allow-net-udp=[1:1:1:1:1:1:1:1]/16',
+      '-e',
+      `
+        const assert = require('assert');
+        assert.ok(process.permission.has('net.udp', '127.1.1.1/9999'));
+        assert.ok(process.permission.has('net.udp', '127.1.1.2/9999'));
+        assert.ok(!process.permission.has('net.udp', '127.1.1.2/8888'));
+        assert.ok(process.permission.has('net.udp', '128.255.0.0/9999'));
+        assert.ok(!process.permission.has('net.udp', '128.254.0.0/9999'));
+        assert.ok(process.permission.has('net.udp', '1:2:1:1:1:1:1:1/6666'));
+        assert.ok(!process.permission.has('net.udp', '0:1:1:1:1:1:1:1/6666'));
+      `,
+    ]
+  );
+  if (status !== 0) {
+    console.error(stderr.toString());
+  }
+  assert.strictEqual(status, 0);
+}