Merge remote-tracking branch 'origin/main' into nektro-patch-10080

src/bun.js/api/bun/socket/Listener.zig

@@ -782,6 +782,7 @@ pub fn getsockname(this: *Listener, globalThis: *JSC.JSGlobalObject, callFrame:
     }
 
     const out = callFrame.argumentsAsArray(1)[0];
+    if (!out.isObject()) return globalThis.throwInvalidArgumentTypeValue("sockname", "object", out);
     const socket = this.listener.uws;
 
     var buf: [64]u8 = [_]u8{0} ** 64;

test/harness.ts

@@ -590,6 +590,20 @@ if (expect.extend)
         message: () => `Expected ${actual} to be a UTF16 string`,
       };
     },
+    // meant to be called like `expect(() => ....).not.toCrash()`
+    // when fuzzing exposed internals, the important piece is that it finishes without sefaulting, not whether it throws an error or not
+    toCrash(fn: unknown) {
+      if (typeof fn !== "function") throw new Error("toCrash expects a function");
+      try {
+        fn();
+      } catch (e) {
+        // ignore
+      }
+      return {
+        pass: false,
+        message: () => `Expected 'fn' to cause a crash`,
+      };
+    },
   });
 
 export function ospath(path: string) {

test/js/node/tls/node-tls-server.test.ts

@@ -686,3 +686,22 @@ it("connectionListener should emit the right amount of times, and with alpnProto
   await Promise.all(promises);
   expect(count).toBe(50);
 });
+
+describe("should fuzz the native handle and not crash", () => {
+  const handle = require("tls").Server().listen().unref()._handle;
+  const proto = Object.getPrototypeOf(handle);
+  const descs = Object.getOwnPropertyDescriptors(proto);
+  for (const k in descs) {
+    for (const v of [undefined, null, "", "a", 24, -3.4, {}, [], Symbol("b")]) {
+      it(`${k}(${String(v)})`, () => {
+        const descriptor = descs[k];
+        expect(() => descriptor.get?.call(handle)).not.toCrash();
+        if (typeof descriptor.value !== "function") return;
+        expect(() => descriptor.value.call(handle, v)).not.toCrash();
+        expect(() => descriptor.value.call(undefined, v)).not.toCrash();
+        expect(() => descriptor.value.call(null, v)).not.toCrash();
+        expect(() => descriptor.set?.call(handle, v)).not.toCrash();
+      });
+    }
+  }
+});