Reject all browser-recognized comment-closing sequences in Comment::set_text.

Previously `Comment::set_text` only rejected the canonical `-->` terminator, but a
WHATWG-conformant browser also closes a comment on three more byte sequences:

1. `--!>` anywhere in the body (comment-end-bang state).
2. A leading `>` (abrupt-closing-of-empty-comment from comment-start).
3. A leading `->` (abrupt-closing-of-empty-comment from comment-start-dash).

Since `serialize_self()` emits `<!--` + text + `-->` verbatim, a caller passing
attacker-influenced data through `set_text` could let the attacker break out of the
comment and inject live markup that lol-html never tokenized. Any sanitizer built on
lol-html that mutates comment text on attacker data was bypassable for stored/reflected
XSS. The error-returning shape of the existing `-->` check implied that the API was
designed to prevent this, just incompletely.

We add a private `contains_comment_closing_sequence(&str)` predicate covering all four
cases and route `set_text` through it. The error variant
`CommentTextError::CommentClosingSequence` keeps its name (so this is API-compatible);
its rustdoc and error message are updated to describe the broader rule.

The existing `comment_closing_sequence_in_text` test is extended to iterate over all
four representative payloads with a per-payload failure message. Existing
`sanitizer_bypass`, `sanitizer_bypass2`, and `modified_text` pass benign text to
`set_text` and continue to pass unchanged.

We do not touch `Comment::before` / `::after` / `::replace`: those insert content
outside the `<!--...-->` envelope under explicit `ContentType` opt-in, with a
different contract.

Author: orium

CHANGELOG.md

@@ -12,6 +12,10 @@
   Currently exposed via the Rust API only; the C API still uses the original behavior.
 - Adding new fields to `MemorySettings` and `Settings` is a SemVer-breaking change for
   existing struct-literal construction, hence the major version bump.
+- `Comment::set_text` now also rejects `--!>`, a leading `>`, and a leading `->`, which
+  WHATWG-conformant browsers treat as comment terminators. Previously only `-->` was
+  rejected, so a caller passing attacker-influenced data could let an attacker break out
+  of the comment and inject HTML (security fix).
 
 ## v2.9.0
 

src/rewritable_units/tokens/comment.rs

@@ -12,8 +12,9 @@ use thiserror::Error;
 /// An error that occurs when invalid value is provided for the HTML comment text.
 #[derive(Error, Debug, Eq, PartialEq, Copy, Clone)]
 pub enum CommentTextError {
-    /// The provided value contains the `-->` character sequence that preemptively closes the comment.
-    #[error("Comment text shouldn't contain comment closing sequence (`-->`).")]
+    /// The provided value contains a byte sequence that a WHATWG-conformant browser
+    /// treats as a comment terminator (`-->`, `--!>`, a leading `>`, or a leading `->`).
+    #[error("Comment text shouldn't contain a comment-closing sequence.")]
     CommentClosingSequence,
 
     /// The provided value contains a character that can't be represented in the document's [`encoding`].
@@ -36,6 +37,20 @@ pub struct Comment<'i> {
     user_data: Box<dyn Any>,
 }
 
+/// Returns `true` if `text`, when emitted between `<!--` and `-->`, would let a
+/// WHATWG-conformant browser close the comment earlier than the trailing `-->`
+/// marker, leaking whatever follows as live markup.
+///
+/// Four sequences trigger this:
+///
+/// 1. `-->` anywhere in the body (comment-end state).
+/// 2. `--!>` anywhere in the body (comment-end-bang state).
+/// 3. A leading `>` (abrupt-closing-of-empty-comment from comment-start).
+/// 4. A leading `->` (abrupt-closing-of-empty-comment from comment-start-dash).
+fn contains_comment_closing_sequence(text: &str) -> bool {
+    text.contains("-->") || text.contains("--!>") || text.starts_with('>') || text.starts_with("->")
+}
+
 impl<'i> Comment<'i> {
     #[inline]
     #[must_use]
@@ -68,22 +83,22 @@ impl<'i> Comment<'i> {
     /// Sets the text of the comment.
     #[inline]
     pub fn set_text(&mut self, text: &str) -> Result<(), CommentTextError> {
-        if text.contains("-->") {
-            Err(CommentTextError::CommentClosingSequence)
-        } else {
-            // NOTE: if character can't be represented in the given
-            // encoding then encoding_rs replaces it with a numeric
-            // character reference. Character references are not
-            // supported in comments, so we need to bail.
-            match BytesCow::owned_from_str_without_replacements(text, self.encoding) {
-                Ok(text) => {
-                    self.text = text;
-                    self.raw.set_modified();
-
-                    Ok(())
-                }
-                Err(_) => Err(CommentTextError::UnencodableCharacter),
+        if contains_comment_closing_sequence(text) {
+            return Err(CommentTextError::CommentClosingSequence);
+        }
+
+        // NOTE: if character can't be represented in the given
+        // encoding then encoding_rs replaces it with a numeric
+        // character reference. Character references are not
+        // supported in comments, so we need to bail.
+        match BytesCow::owned_from_str_without_replacements(text, self.encoding) {
+            Ok(text) => {
+                self.text = text;
+                self.raw.set_modified();
+
+                Ok(())
             }
+            Err(_) => Err(CommentTextError::UnencodableCharacter),
         }
     }
 
@@ -329,11 +344,20 @@ mod tests {
 
     #[test]
     fn comment_closing_sequence_in_text() {
-        rewrite_comment(b"<!-- foo -->", UTF_8, |c| {
-            let err = c.set_text("foo -- bar --> baz").unwrap_err();
-
-            assert_eq!(err, CommentTextError::CommentClosingSequence);
-        });
+        // Every byte sequence here is treated as a comment terminator by a
+        // WHATWG-conformant browser when emitted between `<!--` and `-->`.
+        // See `contains_comment_closing_sequence`.
+        for payload in ["foo -- bar --> baz", "foo --!> bar", ">foo", "->foo"] {
+            rewrite_comment(b"<!-- foo -->", UTF_8, |c| {
+                let err = c.set_text(payload).unwrap_err();
+
+                assert_eq!(
+                    err,
+                    CommentTextError::CommentClosingSequence,
+                    "expected `{payload}` to be rejected",
+                );
+            });
+        }
     }
 
     #[test]