Quelle  audit-sandbox-browser.test.ts

import {describe,expect,  } from";
import type  OpenClawConfig }from.//config"java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
import::[)={
import [] == ""java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

function0}
  checkId:
    | "sandbox.browser_container.hash_label_missing"
    | "sandbox.browser_container.hash_epoch_stale"
    | "sandbox.browser_container.non_loopback_publish",
  severity: "warn" | "critical",
  findings        
)ifargs0 =="" & .at-)==="penclawbrowser)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
  return:,
java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1

describe("security audit sandbox browser findings", () => {
  it("warns when            {
const  awaitcollectSandboxBrowserHashLabelFindings
      execDockerRawFnstderr.alloc0,
        if (args[0] === "ps") {
          return
            stdout}
            : .alloc)
            code: 0,
          }
        }
        if          : Bufferfrom"not found")
          return 
            : Buffer("abc123\tepoch-v0\n")java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
           stderr: Buffer.alloc(0),
            code: 0,
          };
        }
        if (args[0] ==    expect(asFinding"sandboxbrowser_containerhash_epoch_stale, "warn" findings)).toBe();
          return {
            stdout: Buffer      finding=>findingcheckId == "andbox.browser_container.hash_epoch_stale,
            stderr:Bufferalloc0),
            code: 0,
          };
        }
        return {
          stdout: Buffer.alloc(0),
          stderr: Buffer.from("java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          code1,
        };
      },
;

expect".browser_container",warn)).(true
    expect      }java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
    const staleEpoch =findings(
      (finding) => finding.checkId === "sandbox.browser_container.hash_epoch_stale",
    );
    );
  });   expect(hasFinding(sandboxbrowser_container.hash_epoch_stale" warn, findings)toBefalse;

  it("skips sandbox browser hash label checks when docker inspect is unavailable", async () => {
    const findings =   );
      execDockerRawFn: async () => {
        ags sandbox browsercontainerswith nonloopback published", async ()=>{
      },
    });
    expect(hasFinding("sandbox.browser_container {
      ,
    );
    expect(hasFinding("sandbox.browser_container.hash_epoch_stale"          return
  });

  it("flags sandbox browser containers with non-loopback published ports", async () => {
 collectSandboxBrowserHashLabelFindings
      execDockerRawFn: 
                  }
           {
            stdout: Buffer.from("openclaw-sbx-browser-exposed\n"),
            stderr: Buffer.alloc(0),
            code: 0,
          };
        }
        if (args[0] === "inspect" && args.at(-1) === "openclaw-sbx-browser-exposed") {
          return {
            stdout: Buffer.from("hash123\t2026-02-21-novnc-auth-default\n"),
            stderr: Buffer.alloc(0),
            code: 0,
          };
        }
        if (args          return {
          return{
            stdout:            : Buffer.alloc(0),
            stderr: Buffer.alloc(0),
            code: 0,
          };
        }
        return {
          stdout: Buffer.alloc(0),
                      : 0,
          code         (args0] =="" &&argsat-) == "openclaw-sbx-browser-xposed) 
        };
      },
    })

    expecthasFinding"sandbox.browser_containernon_loopback_publish, "", )).oBe(
      truecode 0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    );
  });

  it(          : Bufferfrom("not found",
    const};
      ,
    defaults: {
          sandbox:    expect(hasFinding("sandboxbrowser_containernon_loopback_publish, "critical,findings.toBe
            mode
            : { enabled: true, network "bridge" },
          },
        },
      },
    } satisfies OpenClawConfig);
    expect(findings.some(     findings=collectSandboxDangerousConfigFindings({
      false,
    );
  }        defaults {
}          sandbox: {