Harden screen snapshot format handling (#823)

Validate screen.snapshot image formats before invoking the capture backend, normalize jpg to jpeg, and derive the response data URI MIME type from the validated format instead of the backend echo.

Co-authored-by: Copilot <copilot@github.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 3 people

src/OpenClaw.Shared/Capabilities/ScreenCapability.cs

@@ -46,7 +46,14 @@ public override async Task<NodeInvokeResponse> ExecuteAsync(NodeInvokeRequest re
 
     private async Task<NodeInvokeResponse> HandleCaptureAsync(NodeInvokeRequest request)
     {
-        var format = GetStringArg(request.Args, "format", "png");
+        // The format is interpolated into the data URI, so validate it before
+        // invoking the capture backend.
+        var requestedFormat = GetStringArg(request.Args, "format", "png");
+        if (!TryNormalizeSnapshotFormat(requestedFormat, out var format))
+        {
+            return Error("Unsupported screen snapshot format. Supported formats: png, jpeg.");
+        }
+
         var maxWidth = Clamp(GetIntArg(request.Args, "maxWidth", 1920), MinDimension, MaxScreenWidth);
         var quality = Clamp(GetIntArg(request.Args, "quality", 80), MinQuality, MaxQuality);
         var monitor = GetIntArg(request.Args, "monitor", 0);
@@ -64,17 +71,18 @@ private async Task<NodeInvokeResponse> HandleCaptureAsync(NodeInvokeRequest requ
         {
             var result = await CaptureRequested(new ScreenCaptureArgs
             {
-                Format = format ?? "png",
+                Format = format,
                 MaxWidth = maxWidth,
                 Quality = quality,
                 MonitorIndex = screenIndex,
                 IncludePointer = includePointer
             });
-            
-            var image = $"data:image/{result.Format.ToLowerInvariant()};base64,{result.Base64}";
+
+            // Use the validated format for the MIME type instead of the backend echo.
+            var image = $"data:image/{format};base64,{result.Base64}";
             return Success(new 
             { 
-                format = result.Format,
+                format,
                 width = result.Width,
                 height = result.Height,
                 base64 = result.Base64,
@@ -88,6 +96,30 @@ private async Task<NodeInvokeResponse> HandleCaptureAsync(NodeInvokeRequest requ
         }
     }
 
+    // Keep encoded bytes and advertised MIME type aligned.
+    internal static bool TryNormalizeSnapshotFormat(string? requested, out string normalized)
+    {
+        if (string.IsNullOrWhiteSpace(requested))
+        {
+            normalized = "png";
+            return true;
+        }
+
+        switch (requested.Trim().ToLowerInvariant())
+        {
+            case "png":
+                normalized = "png";
+                return true;
+            case "jpeg":
+            case "jpg":
+                normalized = "jpeg";
+                return true;
+            default:
+                normalized = "png";
+                return false;
+        }
+    }
+
     private async Task<NodeInvokeResponse> HandleRecordAsync(NodeInvokeRequest request)
     {
         var format = GetStringArg(request.Args, "format", "mp4");
@@ -196,4 +228,3 @@ public class ScreenRecordResult
     public int Height { get; set; }
     public bool HasAudio { get; set; }
 }
-

tests/OpenClaw.Shared.Tests/CapabilityTests.cs

@@ -2560,6 +2560,114 @@ public async Task Capture_UsesMonitorAlias_ForScreenIndex()
         Assert.Equal(2, receivedArgs!.MonitorIndex);
     }
 
+    [Fact]
+    public async Task Capture_RejectsUnsupportedFormat()
+    {
+        // Reject before the capture handler runs so a caller-supplied format
+        // cannot reach the data URI MIME type.
+        var cap = new ScreenCapability(NullLogger.Instance);
+        var handlerCalled = false;
+        cap.CaptureRequested += (_) =>
+        {
+            handlerCalled = true;
+            return Task.FromResult(new ScreenCaptureResult { Format = "png", Base64 = "x" });
+        };
+
+        var req = new NodeInvokeRequest
+        {
+            Id = "sfmt1",
+            Command = "screen.snapshot",
+            Args = Parse("""{"format":"svg+xml"}""")
+        };
+
+        var res = await cap.ExecuteAsync(req);
+        Assert.False(res.Ok);
+        Assert.False(handlerCalled);
+        Assert.Contains("Unsupported screen snapshot format", res.Error);
+    }
+
+    [Fact]
+    public async Task Capture_NormalizesJpgToJpeg()
+    {
+        // Normalize the alias before invoking the capture handler.
+        var cap = new ScreenCapability(NullLogger.Instance);
+        ScreenCaptureArgs? received = null;
+        cap.CaptureRequested += (args) =>
+        {
+            received = args;
+            return Task.FromResult(new ScreenCaptureResult { Format = args.Format, Width = 10, Height = 10, Base64 = "data" });
+        };
+
+        var req = new NodeInvokeRequest
+        {
+            Id = "sfmt2",
+            Command = "screen.snapshot",
+            Args = Parse("""{"format":"jpg"}""")
+        };
+
+        var res = await cap.ExecuteAsync(req);
+        Assert.True(res.Ok);
+        Assert.NotNull(received);
+        Assert.Equal("jpeg", received!.Format);
+
+        var json = JsonSerializer.Serialize(res.Payload);
+        using var doc = JsonDocument.Parse(json);
+        var root = doc.RootElement;
+        Assert.Equal("jpeg", root.GetProperty("format").GetString());
+        Assert.StartsWith("data:image/jpeg;base64,", root.GetProperty("image").GetString());
+    }
+
+    [Fact]
+    public async Task Capture_DataUri_IgnoresHandlerEchoedFormat()
+    {
+        // The response MIME type comes from the validated request format.
+        var cap = new ScreenCapability(NullLogger.Instance);
+        cap.CaptureRequested += (_) => Task.FromResult(new ScreenCaptureResult
+        {
+            Format = "svg+xml\";base64,evil",
+            Width = 1,
+            Height = 1,
+            Base64 = "abc123"
+        });
+
+        var req = new NodeInvokeRequest
+        {
+            Id = "sfmt3",
+            Command = "screen.snapshot",
+            Args = Parse("""{"format":"png"}""")
+        };
+
+        var res = await cap.ExecuteAsync(req);
+        Assert.True(res.Ok);
+
+        var json = JsonSerializer.Serialize(res.Payload);
+        using var doc = JsonDocument.Parse(json);
+        var root = doc.RootElement;
+        Assert.Equal("png", root.GetProperty("format").GetString());
+        Assert.Equal("data:image/png;base64,abc123", root.GetProperty("image").GetString());
+    }
+
+    [Fact]
+    public void TryNormalizeSnapshotFormat_AllowsKnownFormats_RejectsOthers()
+    {
+        Assert.True(ScreenCapability.TryNormalizeSnapshotFormat("png", out var png));
+        Assert.Equal("png", png);
+        Assert.True(ScreenCapability.TryNormalizeSnapshotFormat("PNG", out var pngUpper));
+        Assert.Equal("png", pngUpper);
+        Assert.True(ScreenCapability.TryNormalizeSnapshotFormat("jpeg", out var jpeg));
+        Assert.Equal("jpeg", jpeg);
+        Assert.True(ScreenCapability.TryNormalizeSnapshotFormat("  JPG  ", out var jpg));
+        Assert.Equal("jpeg", jpg);
+        Assert.True(ScreenCapability.TryNormalizeSnapshotFormat(null, out var def));
+        Assert.Equal("png", def);
+        Assert.True(ScreenCapability.TryNormalizeSnapshotFormat("", out var empty));
+        Assert.Equal("png", empty);
+
+        Assert.False(ScreenCapability.TryNormalizeSnapshotFormat("webp", out _));
+        Assert.False(ScreenCapability.TryNormalizeSnapshotFormat("gif", out _));
+        Assert.False(ScreenCapability.TryNormalizeSnapshotFormat("png;base64,x", out _));
+    }
+
     [Fact]
     public async Task Record_ReturnsError_WhenNoHandler()
     {

tests/OpenClaw.Shared.Tests/README.md

@@ -68,12 +68,16 @@ dotnet test --filter "FullyQualifiedName~AgentActivityTests"
 - ✅ device.status returns Mac-compatible status payload
 - ✅ Unknown command returns error
 
-#### ScreenCapabilityTests (9 tests)
+#### ScreenCapabilityTests (13 tests)
 - ✅ CanHandle screen.snapshot/screen.record and rejects non-gateway screen.capture/screen.list/start/stop commands
 - ✅ Capture returns error when no handler
 - ✅ Capture calls handler with parsed args (format, maxWidth, quality, screenIndex)
 - ✅ Capture returns error when handler throws
 - ✅ Capture includes data URI response
+- ✅ Capture rejects unsupported format (e.g. svg+xml) before invoking handler
+- ✅ Capture normalizes jpg → jpeg so encoded bytes and MIME type cannot diverge
+- ✅ Capture data URI derives MIME from validated format, not handler echo
+- ✅ TryNormalizeSnapshotFormat allows png/jpeg/jpg, rejects others
 - ✅ Record returns error when no handler
 - ✅ Record calls handler with Mac-compatible args
 - ✅ Record rejects unsupported non-mp4 format