troubadix 25.10.8__tar.gz → 25.10.9__tar.gz

{troubadix-25.10.8 → troubadix-25.10.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: troubadix
-Version: 25.10.8
+Version: 25.10.9
 Summary: A linting and QA check tool for NASL files
 License: GPL-3.0-or-later
 License-File: LICENSE

{troubadix-25.10.8 → troubadix-25.10.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "troubadix"
-version = "25.10.8"
+version = "25.10.9"
 description = "A linting and QA check tool for NASL files"
 authors = ["Greenbone <info@greenbone.net>"]
 license = "GPL-3.0-or-later"

{troubadix-25.10.8 → troubadix-25.10.9}/tests/plugins/test_encoding.py

@@ -44,6 +44,69 @@ class CheckEncodingTestCase(PluginTestCase):
 
             self.assertEqual(len(results), 0)
 
+    def test_ok_iso_8859_1(self):
+        """Test that all valid ISO-8859-1 characters pass encoding validation.
+
+        This covers the issue reported in JIRA VTOPS-281 where characters like 'ä' and '®'
+        should be valid when files are properly encoded as ISO-8859-1.
+        """
+        with self.create_directory() as tempdir:
+            path = tempdir / "file.nasl"
+
+            # All valid ISO-8859-1 characters (0-255)
+            # ASCII printable characters (32-126) + Latin-1 supplement (160-255)
+            latin1_chars = "".join(
+                [chr(i) for i in list(range(32, 127)) + list(range(160, 256))]
+            )
+
+            path.write_text(
+                latin1_chars,
+                encoding="iso-8859-1",
+            )
+            content = path.read_text(encoding=CURRENT_ENCODING)
+            fake_context = self.create_file_plugin_context(
+                nasl_file=path, file_content=content, lines=content.splitlines()
+            )
+            plugin = CheckEncoding(fake_context)
+
+            results = list(plugin.run())
+
+            self.assertEqual(len(results), 0)
+
+    def test_specific_latin1_chars_utf8_encoding_fails(self):
+        """Test that specific Latin-1 characters fail when saved as UTF-8.
+
+        This specifically tests the JIRA VTOPS-281 reported issue where 'ä' and '®'
+        cause encoding problems when saved as UTF-8 but read as ISO-8859-1.
+        """
+        with self.create_directory() as tempdir:
+            path = tempdir / "file.nasl"
+
+            # Specific characters that were problematic: ä (U+00E4) and ® (U+00AE)
+            path.write_text(
+                "This contains ä and ® characters",
+                encoding="utf-8",
+            )
+            content = path.read_text(encoding=CURRENT_ENCODING)
+            fake_context = self.create_file_plugin_context(
+                nasl_file=path, file_content=content, lines=content.splitlines()
+            )
+            plugin = CheckEncoding(fake_context)
+
+            results = list(plugin.run())
+
+            self.assertEqual(len(results), 2)
+            self.assertIsInstance(results[0], LinterError)
+            self.assertEqual(
+                "Detected encoding 'UTF-8' is not Latin-1 compatible.",
+                results[0].message,
+            )
+            self.assertIsInstance(results[1], LinterError)
+            self.assertEqual(
+                "Likely UTF-8 multibyte sequence found in line 1",
+                results[1].message,
+            )
+
     def test_some_invalid_characters(self):
         with self.create_directory() as tempdir:
             path = tempdir / "file.nasl"
@@ -61,22 +124,18 @@ class CheckEncodingTestCase(PluginTestCase):
 
             results = list(plugin.run())
 
-            self.assertEqual(len(results), 3)
+            self.assertEqual(len(results), 2)
 
             self.assertIsInstance(results[0], LinterError)
             self.assertEqual(
-                "VT uses a wrong encoding. "
-                "Allowed encodings are ascii, latin_1.",
+                "Detected encoding 'UTF-8' is not Latin-1 compatible.",
                 results[0].message,
             )
+            self.assertIsInstance(results[1], LinterError)
             self.assertEqual(
-                "Found invalid character in line: 1",
+                "Likely UTF-8 multibyte sequence found in line 1",
                 results[1].message,
             )
-            self.assertEqual(
-                "Found invalid character in line: 2",
-                results[2].message,
-            )
 
     def test_invisible_whitespace(self):
         with self.create_directory() as tempdir:
@@ -95,10 +154,14 @@ class CheckEncodingTestCase(PluginTestCase):
 
             results = list(plugin.run())
 
-            self.assertEqual(len(results), 1)
+            self.assertEqual(len(results), 2)
             self.assertIsInstance(results[0], LinterError)
             self.assertEqual(
-                "VT uses a wrong encoding. "
-                "Allowed encodings are ascii, latin_1.",
+                "Detected encoding 'UTF-8' is not Latin-1 compatible.",
                 results[0].message,
             )
+            self.assertIsInstance(results[1], LinterError)
+            self.assertEqual(
+                "Likely UTF-8 multibyte sequence found in line 1",
+                results[1].message,
+            )

{troubadix-25.10.8 → troubadix-25.10.9}/troubadix/__version__.py

@@ -2,4 +2,4 @@
 
 # THIS IS AN AUTOGENERATED FILE. DO NOT TOUCH!
 
-__version__ = "25.10.8"
+__version__ = "25.10.9"

troubadix-25.10.9/troubadix/plugins/encoding.py

@@ -0,0 +1,78 @@
+# Copyright (C) 2022 Greenbone AG
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import Iterator
+
+import magic
+
+from troubadix.plugin import (
+    FilePlugin,
+    LinterError,
+    LinterResult,
+)
+
+# OpenVAS decodes NASL files using ISO-8859-1 (Latin-1).
+# Files saved in other encodings (like UTF-8)
+# will be misinterpreted and cause errors or garbled text.
+# US-ASCII is also allowed since it's a subset of ISO-8859-1.
+ALLOWED_ENCODINGS = ["iso-8859-1", "us-ascii"]
+
+
+class CheckEncoding(FilePlugin):
+    """
+    Check if the encoding of the NASL file is ISO-8859-1 (Latin-1) encoded.
+    Finds UTF-8 multibyte sequences that are composed of individually valid Latin-1 bytes,
+    but result in garbled text.
+    """
+
+    name = "check_encoding"
+
+    def run(self) -> Iterator[LinterResult]:
+        with open(self.context.nasl_file, "rb") as f:
+            raw = f.read()
+
+        # Use magic to detect encoding
+        detected_encoding = magic.Magic(mime_encoding=True).from_buffer(raw)
+
+        if detected_encoding not in ALLOWED_ENCODINGS:
+            yield LinterError(
+                f"Detected encoding '{detected_encoding.upper()}' is not Latin-1 compatible.",
+                file=self.context.nasl_file,
+                plugin=self.name,
+            )
+
+        def has_utf8_multibyte(data: bytes) -> bool:
+            """
+            Function to detect UTF-8 multibyte sequences by checking the first two bytes.
+            UTF-8 multibyte sequences start with a lead byte followed by continuation bytes.
+
+            Lead byte ranges:
+            - 2-byte: 0xC2–0xDF (110xxxxx, excluding 0xC0–0xC1 to avoid overlongs)
+            - 3-byte: 0xE0–0xEF (1110xxxx)
+            - 4-byte: 0xF0–0xF4 (11110xxx)
+            These ranges are continuous, so we can check 0xC2–0xF4 as a single range.
+            11000010  C2  --  F4  11110111
+
+            Continuation bytes: 0x80–0xBF (10yyyyyy)
+            10000000  80  --  BF  10111111
+
+            Lead and continuation byte values are either not valid Latin-1 or special symbols
+            that are unlikely to be following each other in normal use.
+            """
+
+            for i in range(len(data) - 1):
+                first = data[i]
+                second = data[i + 1]
+                if 0xC2 <= first <= 0xF4 and 0x80 <= second <= 0xBF:
+                    return True
+            return False
+
+        lines = raw.split(b"\n")
+        for i, line_bytes in enumerate(lines, start=1):
+            if has_utf8_multibyte(line_bytes):
+                yield LinterError(
+                    f"Likely UTF-8 multibyte sequence found in line {i}",
+                    file=self.context.nasl_file,
+                    plugin=self.name,
+                    line=i,
+                )

troubadix-25.10.8/troubadix/plugins/encoding.py

@@ -1,62 +0,0 @@
-# Copyright (C) 2022 Greenbone AG
-#
-# SPDX-License-Identifier: GPL-3.0-or-later
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-import re
-from pathlib import Path
-from typing import Iterable, Iterator
-
-import charset_normalizer
-
-from troubadix.plugin import LineContentPlugin, LinterError, LinterResult
-
-# Only the ASCII and extended ASCII for now... # https://www.ascii-code.com/
-# CHAR_SET = r"[^\x00-\xFF]"
-# Temporary only check for chars in between 7f-9f, like in the old Feed-QA...
-INVALID_CHAR_PATTERN = re.compile(r"[\x7F-\x9F]")
-
-ALLOWED_ENCODINGS = ["ascii", "latin_1"]
-
-
-class CheckEncoding(LineContentPlugin):
-    name = "check_encoding"
-
-    def check_lines(
-        self,
-        nasl_file: Path,
-        lines: Iterable[str],
-    ) -> Iterator[LinterResult]:
-        match = charset_normalizer.from_path(
-            nasl_file, threshold=0.4, cp_isolation=ALLOWED_ENCODINGS
-        ).best()
-
-        if not match:
-            yield LinterError(
-                f"VT uses a wrong encoding. "
-                f"Allowed encodings are {', '.join(ALLOWED_ENCODINGS)}.",
-                file=nasl_file,
-                plugin=self.name,
-            )
-
-        for index, line in enumerate(lines, 1):
-            encoding = INVALID_CHAR_PATTERN.search(line)
-            if encoding:
-                yield LinterError(
-                    f"Found invalid character in line: {index}",
-                    file=nasl_file,
-                    plugin=self.name,
-                    line=index,
-                )