Bug 1966443: Skip NUL characters in text that is copied to clipboard or dragged r=gstoll,dom-core,edgar

Windows and GTK do not allow NUL characters in text data types that appear
on the clipboard or in DND payloads.  Mac and Android do not specify if this
is allowed but they use string types that permit it.  This patch normalizes
behavior across platforms by removing NUL ('\0') characters from text
flavors in those cases.

The test has exceptions for the behavior of different platforms when copying
a string that only contains NUL characters. Android and Wayland behave
slightly differently than others but it is not an important edge case.

Differential Revision: https://phabricator.services.mozilla.com/D258092

Author: davidp3

dom/base/nsContentAreaDragDrop.cpp

@@ -640,6 +640,8 @@ nsresult DragDataProducer::Produce(DataTransfer* aDataTransfer, bool* aCanDrag,
     data = do_QueryInterface(supports);
     if (NS_SUCCEEDED(rv)) {
       data->GetData(mHtmlString);
+      // Do not add NULs to DND text.
+      mHtmlString.StripChar(L'\0');
     }
     rv = transferable->GetTransferData(kHTMLContext, getter_AddRefs(supports));
     data = do_QueryInterface(supports);
@@ -655,6 +657,8 @@ nsresult DragDataProducer::Produce(DataTransfer* aDataTransfer, bool* aCanDrag,
     data = do_QueryInterface(supports);
     NS_ENSURE_SUCCESS(rv, rv);  // require plain text at a minimum
     data->GetData(mTitleString);
+    // Do not add NULs to DND text.
+    mTitleString.StripChar(L'\0');
   }
 
   // default text value is the URL

widget/nsBaseClipboard.cpp

@@ -24,6 +24,7 @@
 #include "nsFocusManager.h"
 #include "nsIClipboardOwner.h"
 #include "nsIPromptService.h"
+#include "nsISupportsPrimitives.h"
 #include "nsError.h"
 #include "nsXPCOM.h"
 
@@ -389,6 +390,7 @@ NS_IMETHODIMP nsBaseClipboard::SetData(
     mIgnoreEmptyNotification = true;
     // Reject existing pending asyncSetData request if any.
     RejectPendingAsyncSetDataRequestIfAny(aWhichClipboard);
+    SanitizeForClipboard(aTransferable);
     rv = SetNativeClipboardData(aTransferable, aWhichClipboard);
     mIgnoreEmptyNotification = false;
   }
@@ -988,6 +990,42 @@ void nsBaseClipboard::RequestUserConfirmation(
   promise->AppendNativeHandler(sUserConfirmationRequest);
 }
 
+/* static */
+nsresult nsBaseClipboard::SanitizeForClipboard(nsITransferable* aTransferable) {
+  NS_ENSURE_ARG(aTransferable);
+
+  nsTArray<nsCString> flavors;
+  nsresult rv = aTransferable->FlavorsTransferableCanImport(flavors);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Remove NULs from text flavors.
+  for (const auto& flavor : flavors) {
+    nsCOMPtr<nsISupports> data;
+    rv = aTransferable->GetTransferData(flavor.get(), getter_AddRefs(data));
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (NS_WARN_IF(MOZ_UNLIKELY(!data))) {
+      continue;
+    }
+    nsCOMPtr<nsISupportsString> stringData = do_QueryInterface(data);
+    if (!stringData) {
+      continue;
+    }
+
+    // Remove NULs from stringData.  If that does anything then the size of the
+    // string will be reduced.
+    nsAutoString newString;
+    rv = stringData->GetData(newString);
+    NS_ENSURE_SUCCESS(rv, rv);
+    auto oldLength = newString.Length();
+    newString.StripChar(L'\0');
+    if (newString.Length() != oldLength) {
+      rv = stringData->SetData(newString);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+  return NS_OK;
+}
+
 NS_IMPL_ISUPPORTS(nsBaseClipboard::ClipboardDataSnapshot,
                   nsIClipboardDataSnapshot)
 

widget/nsBaseClipboard.h

@@ -252,6 +252,10 @@ class nsBaseClipboard : public nsIClipboard {
       const nsTArray<nsCString>& aFlavorList, ClipboardType aClipboardType,
       mozilla::dom::WindowContext* aRequestingWindowContext);
 
+  // Clean up data in transferable for posting to clipboard or dragging.  This
+  // guarantees that text data does not include NUL characters.
+  static nsresult SanitizeForClipboard(nsITransferable* aTransferable);
+
   // Track the pending request for each clipboard type separately. And only need
   // to track the latest request for each clipboard type as the prior pending
   // request will be canceled when a new request is made.

widget/tests/mochitest.toml

@@ -46,6 +46,8 @@ skip-if = [
 support-files = "file_test_clipboard_pngPreservesTransparency.js"
 scheme = "https" # ImageDecoder requires secure context
 
+["test_clipboard_read_paste_ignoreNuls.html"]
+
 ["test_contextmenu_by_mouse_on_unix.html"]
 run-if = [
   "os == 'linux'",
@@ -60,6 +62,9 @@ skip-if = [
   "xorigin", # high-frequently intermittent fail
 ]
 
+["test_dnd_ignoreNuls.html"]
+skip-if = ["os == 'android'"]  # Fx on android does not currently support DND
+
 ["test_keypress_event_with_alt_on_mac.html"]
 run-if = ["os == 'mac'"]
 

widget/tests/test_clipboard_read_paste_ignoreNuls.html

@@ -0,0 +1,122 @@
+<!DOCTYPE HTML>
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>Test for Bug 1966443</title>
+  <link rel="stylesheet" href="/tests/SimpleTest/test.css">
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+
+<body>
+  <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1966443">Mozilla Bug 1966443 Clipboard Test</a>
+  <textarea id="source"></textarea>
+  <input type="text" id="target" />
+  <script type="application/javascript">
+    SimpleTest.waitForExplicitFinish();
+    const {AppConstants} = SpecialPowers.ChromeUtils.importESModule(
+      "resource://gre/modules/AppConstants.sys.mjs"
+    );
+    const { AppInfo } = SpecialPowers.ChromeUtils.importESModule(
+      "chrome://remote/content/shared/AppInfo.sys.mjs"
+    );
+
+    // copied from clipboard_helper.js
+    async function getWindowProtocol() {
+      return await SpecialPowers.spawnChrome([], () => {
+        try {
+          return Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo)
+            .windowProtocol;
+        } catch {
+          return "";
+        }
+      });
+    }
+
+    const isAndroid = AppConstants.platform == "android";
+    const isWayland = getWindowProtocol() === "wayland";
+
+    const kNothingCopied = "<nothing copied...>";
+    const kNothingPasted = "<nothing pasted...>";
+    const Ci = SpecialPowers.Ci;
+    let sourceElt = document.getElementById("source");
+    let targetElt = document.getElementById("target");
+
+    function copyToClipboard(actual) {
+      // First, perform a copy that should always succeed so that we know the
+      // clipboard contents before setting them to 'actual'.  This not only
+      // keeps prior checks from influencing this one but also is required
+      // to detect "empty" copies (like "\0") that won't update the
+      // clipboard.
+      sourceElt.textContent = kNothingCopied;
+      sourceElt.focus();
+      sourceElt.select();
+      SpecialPowers.wrap(document).execCommand("copy", false, null);
+
+      sourceElt.textContent = actual;
+      sourceElt.select();
+      SpecialPowers.wrap(document).execCommand("copy", false, null);
+    }
+
+    function pasteFromClipboard() {
+      targetElt.value = kNothingPasted;
+      targetElt.focus();
+      // Select contents so that paste replaces them
+      targetElt.select();
+      SpecialPowers.wrap(document).execCommand("paste", false, null);
+    }
+
+    async function test(actual, expected, paste_is_todo, read_is_todo) {
+      info(`setting and copying: '${actual}'`);
+      copyToClipboard(actual);
+
+      let readTest = read_is_todo ? todo_is : is;
+      readTest(
+        SpecialPowers.getClipboardData("text/plain"), expected,
+        "clipboard read data is correct");
+
+      info(`pasting: '${sourceElt.textContent}'`);
+      pasteFromClipboard();
+
+      let pasteTest = paste_is_todo ? todo_is : is;
+      pasteTest(targetElt.value, expected, `Pasted string is correct`);
+    }
+
+    async function runTests() {
+      for (let currentTest of tests) {
+        await test(currentTest.actual, currentTest.expected, currentTest.paste_is_todo, currentTest.read_is_todo);
+      }
+      SimpleTest.finish();
+    }
+
+    // actual is the string sent to the clipboard.
+    // expected is the result of reading or pasting the clipboard.
+    // paste_is_todo means a paste check is a todo.
+    // read_is_todo means the clipboard read check is a todo.
+    //
+    // At present, pasting a string with only NULs does nothing, even
+    // though clipboard reads report it as the empty string.  Note that an
+    // empty string *without* NULs cannot be copied to the clipboard (in
+    // Gecko).
+    //
+    // Android and Wayland don't allow copying empty strings in either case.
+    let tests = [
+      { actual: "abc", expected: "abc"},
+      { actual: "\0", expected: "", paste_is_todo: true, read_is_todo: isAndroid || isWayland},
+      { actual: " \0", expected: " "},
+      { actual: "\0 ", expected: " "},
+      { actual: " \0 ", expected: "  "},
+      { actual: "\0\0", expected: "", paste_is_todo: true, read_is_todo: isAndroid || isWayland},
+      { actual: " \0\0", expected: " "},
+      { actual: "\0\0 ", expected: " "},
+      { actual: " \0\0 ", expected: "  "},
+      { actual: " \0 \0 ", expected: "   "},
+      { actual: "a\0b\0c", expected: "abc"},
+    ];
+
+    runTests();
+  </script>
+</body>
+</html>

widget/tests/test_dnd_ignoreNuls.html

@@ -0,0 +1,99 @@
+<!DOCTYPE HTML>
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>Test for Bug 1966443</title>
+  <link rel="stylesheet" href="/tests/SimpleTest/test.css">
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script src="/tests/SimpleTest/SpecialPowers.js"></script>
+  <script src="/tests/SimpleTest/EventUtils.js"></script>
+</head>
+
+<body>
+  <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1966443">Mozilla Bug 1966443 DND test</a>
+  <div></div>
+  <textarea style="cursor: pointer;" id="source"></textarea>
+  <div></div>
+  <input type="text" id="target" ondragover="event.preventDefault();"/>
+  <script type="application/javascript">
+    SimpleTest.waitForExplicitFinish();
+    SpecialPowers.contentTransformsReceived(window);
+
+    const Ci = SpecialPowers.Ci;
+    const sourceElt = document.getElementById("source");
+    const targetElt = document.getElementById("target");
+    const scale = window.devicePixelRatio;
+    // For the test, assume the special NUL character is 13px wide.
+    const NULCharWidth = 13;
+
+    async function test(actual, expected) {
+      info(`initializing source to '${actual}' and clearing target`);
+      targetElt.value = "";
+      sourceElt.textContent = actual;
+      sourceElt.select();
+
+      // Find the first non-NUL character and use its position as drag start.
+      // If there are no non-NUL characters then use the first NUL.
+      let nonNulIndex = 0;
+      for (let i = 0; i < actual.length; i++) {
+        if (actual.charAt(i) != '\0') {
+          nonNulIndex = i;
+          break;
+        }
+      }
+
+      info(`dragging '${sourceElt.textContent}' from source to target`);
+      // Add a small offset to cover borders and text margins.
+      const offset = 8;
+      let sourceOffset = [ (nonNulIndex * NULCharWidth) * scale + offset, offset ];
+      let targetOffset = [ offset, offset ];
+      await synthesizeMockDragAndDrop({
+        srcElement: "source",
+        targetElement: "target",
+        sourceOffset,
+        targetOffset,
+        record,
+        info,
+        // No drag should happen if the expected string is empty.
+        expectNoDragEvents: expected === "",
+      });
+
+      is(targetElt.value, expected, "dropped data is correct");
+    }
+
+    async function runTests() {
+      for (let currentTest of tests) {
+        await test(currentTest.actual, currentTest.expected);
+      }
+      SimpleTest.finish();
+    }
+
+    // actual is the string sent to the clipboard.
+    // expected is the result of reading or pasting the clipboard.
+    // Tests that expect the empty string are only sanity checks -- they will
+    // pass because the target is initialized to the empty string.  In those
+    // cases, we should not receive any drag events.  This actually happens
+    // because clicking on a special character representing a NUL undoes the
+    // selection that would be dragged, so there is nowhere to click to start
+    // an empty drag.  This also means that we need to search for a non-NUL
+    // character to click when initiating a drag.
+    let tests = [
+      { actual: "abc", expected: "abc"},
+      { actual: "\0", expected: ""},
+      { actual: "a\0", expected: "a"},
+      { actual: "\0a", expected: "a"},
+      { actual: "a\0b", expected: "ab"},
+      { actual: "\0\0", expected: ""},
+      { actual: "a\0\0", expected: "a"},
+      { actual: "\0\0a", expected: "a"},
+      { actual: "a\0\0b", expected: "ab"},
+      { actual: "a\0b\0c", expected: "abc"},
+    ];
+
+    runTests();
+  </script>
+</body>
+</html>