luajitos

example_sandbox_runner.lua (5839B)

---

 -- Example: How to run untrusted code in an OrbitManager sandbox
 
 local OrbitManager = require("OrbitManager")
 
 print("=== Sandbox Runner Example ===\n")
 
 -- Example 1: Running a simple app with limited permissions
 print("Example 1: Running user code in a sandbox\n")
 
 local appManifest = [[
 return {
     name = "userapp";
     dev = "untrusteddev";
     perms = {
         fs = false,
         os = false,
         network = false
     };
     allowedPaths = {};
     allowedDomains = {}
 }
 ]]
 
 -- Create the sandbox
 local orbit, sandbox = OrbitManager.newSandbox(appManifest)
 print("Created sandbox for 'userapp' by 'untrusteddev'")
 
 -- Untrusted user code
 local userCode = [[
     -- This code runs in the sandbox
     local function fibonacci(n)
         if n <= 1 then return n end
         return fibonacci(n - 1) + fibonacci(n - 2)
     end
 
     local result = {}
     for i = 1, 10 do
         table.insert(result, fibonacci(i))
     end
 
     return table.concat(result, ", ")
 ]]
 
 print("\nRunning user code...")
 local chunk, err = load(userCode, "userCode", "t", sandbox)
 if chunk then
     local success, result = pcall(chunk)
     if success then
         print("✓ Result:", result)
     else
         print("✗ Error:", result)
     end
 else
     print("✗ Compile error:", err)
 end
 
 print("\n" .. string.rep("-", 60) .. "\n")
 
 -- Example 2: Running code that tries to do something malicious
 print("Example 2: Blocking malicious code\n")
 
 local maliciousCode = [[
     -- Try to access the filesystem (should fail)
     local file = io.open("/etc/passwd", "r")
     if file then
         return "SECURITY BREACH: Accessed /etc/passwd"
     else
         return "Failed to open file (good!)"
     end
 ]]
 
 print("Running malicious code that tries to access /etc/passwd...")
 chunk, err = load(maliciousCode, "maliciousCode", "t", sandbox)
 if chunk then
     local success, result = pcall(chunk)
     if success then
         print("✓ Code ran, result:", result)
     else
         print("✓ Security worked! Error:", result)
     end
 else
     print("✗ Compile error:", err)
 end
 
 print("\n" .. string.rep("-", 60) .. "\n")
 
 -- Example 3: App with filesystem access to specific directory
 print("Example 3: App with limited filesystem access\n")
 
 local fsAppManifest = [[
 return {
     name = "fileprocessor";
     dev = "trusteddev";
     perms = {
         fs = true,
         os = false,
         network = false
     };
     allowedPaths = {
         "/tmp/*"
     };
     allowedDomains = {}
 }
 ]]
 
 local orbit3, sandbox3 = OrbitManager.newSandbox(fsAppManifest)
 print("Created sandbox with /tmp/* access")
 
 local fsCode = [[
     -- Try to open a file in /tmp (should work)
     local tmpFile = io.open("/tmp/test.txt", "w")
     if tmpFile then
         -- In real scenario, this would write to the file
         return "SUCCESS: Can access /tmp/test.txt"
     else
         return "FAILED: Could not access /tmp/test.txt"
     end
 ]]
 
 print("\nRunning code with /tmp access...")
 chunk, err = load(fsCode, "fsCode", "t", sandbox3)
 if chunk then
     local success, result = pcall(chunk)
     print((success and "✓" or "✗") .. " " .. tostring(result))
 else
     print("✗ Compile error:", err)
 end
 
 -- Now try to access something outside allowed paths
 local unauthorizedFsCode = [[
     -- Try to open a file outside allowed paths (should fail)
     local file = io.open("/etc/shadow", "r")
     if file then
         return "SECURITY BREACH: Accessed /etc/shadow"
     else
         return "Correctly blocked"
     end
 ]]
 
 print("Running code trying to access /etc/shadow...")
 chunk, err = load(unauthorizedFsCode, "unauthorizedFsCode", "t", sandbox3)
 if chunk then
     local success, result = pcall(chunk)
     if not success then
         print("✓ Access blocked:", result)
     else
         print("✗ " .. result)
     end
 else
     print("✗ Compile error:", err)
 end
 
 print("\n" .. string.rep("-", 60) .. "\n")
 
 -- Example 4: Demonstrating the complete app lifecycle
 print("Example 4: Complete app lifecycle\n")
 
 local appManifest4 = [[
 return {
     name = "calculator";
     dev = "mathdev";
     version = "1.0";
     perms = {
         fs = false,
         os = false,
         network = false
     };
     allowedPaths = {};
     allowedDomains = {}
 }
 ]]
 
 local orbit4, sandbox4 = OrbitManager.newSandbox(appManifest4)
 local metadata = orbit4:getManifestData()
 
 print("Loaded app:", metadata.name)
 print("Developer:", metadata.dev)
 print("Version:", metadata.version or "N/A")
 
 -- The app's main code
 local appCode = [[
     -- Simple calculator app
     local Calculator = {}
 
     function Calculator.add(a, b)
         return a + b
     end
 
     function Calculator.multiply(a, b)
         return a * b
     end
 
     function Calculator.factorial(n)
         if n <= 1 then return 1 end
         return n * Calculator.factorial(n - 1)
     end
 
     -- Return the API
     return Calculator
 ]]
 
 print("\nLoading calculator app...")
 chunk, err = load(appCode, "calculator", "t", sandbox4)
 if chunk then
     local success, Calculator = pcall(chunk)
     if success then
         print("✓ App loaded successfully")
         print("\nTesting calculator:")
         print("  2 + 3 =", Calculator.add(2, 3))
         print("  4 * 5 =", Calculator.multiply(4, 5))
         print("  5! =", Calculator.factorial(5))
     else
         print("✗ Error:", Calculator)
     end
 else
     print("✗ Compile error:", err)
 end
 
 print("\n" .. string.rep("-", 60) .. "\n")
 print("=== Examples Complete ===")
 print("\nKey takeaways:")
 print("1. newSandbox creates a safe environment based on sandboxEnv.lua")
 print("2. Only whitelisted functions are available to sandboxed code")
 print("3. Permission-controlled functions (io, os) are wrapped with stubs")
 print("4. Stubs check manifest permissions before allowing execution")
 print("5. Filesystem and network access can be restricted to specific paths/domains")