fix: [wav] embed message bytes in the true LSB of each sample

Two fixes to the wav module, sharing the format break already
introduced for LSB images in the previous commit:

1. Unicode corruption: like the LSB image code, hide() converted each
   character to a fixed-width bit string via ord(), silently corrupting
   code points above U+00FF under UTF-8 ("🔥🔥🔥" revealed as
   'ú\x92ý'). The message is now embedded as its encoded bytes and the
   8-bit length prefix stores the byte count (up to 255 bytes) instead
   of the character count.

2. Per-byte embedding: hide() set the LSB of every byte of the raw
   frame data, ignoring sampwidth. On 16-bit PCM every second message
   bit landed in bit 8 of a sample, changing amplitudes by up to +-257
   (audible and trivially detectable). Bits are now written only to the
   least significant byte of each little-endian sample, so samples
   change by at most +-1. The capacity check counts samples, no longer
   bytes.

Also validate the encoding name (ValueError) and re-raise a decode
failure during reveal as IndexError, matching the LSB behaviour.

BREAKING CHANGE (on-file format): messages hidden in WAV files with
Stegano <= 2.5.0 are only readable by this version if the message is
pure ASCII with the UTF-8 encoding and the carrier has 8-bit samples;
anything else must be hidden again.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: cedricbonhomme

CHANGELOG.md

@@ -13,6 +13,18 @@
   pure ASCII text with the UTF-8 encoding (that case is bit-identical).
   Non-ASCII UTF-8 messages and all UTF-32LE messages use a different bit
   layout and must be hidden again with the new version.
+- Fixed the same Unicode corruption in the wav module: the message is now
+  embedded as its encoded bytes, and the 8-bit length prefix stores the
+  length of the message in bytes (up to 255) instead of characters.
+- Fixed the wav module modifying the least significant bit of every *byte*
+  of the frame data instead of every sample. On 16-bit PCM carriers this
+  changed sample amplitudes by up to ±257 (clearly audible and trivially
+  detectable); samples now change by at most ±1.
+- **Breaking change**: because of the two fixes above, the wav bit layout
+  changed as well. Messages hidden in WAV files with Stegano <= 2.5.0 can
+  only be revealed by this version if the message is pure ASCII with the
+  UTF-8 encoding *and* the carrier uses 8-bit samples; anything else must
+  be hidden again with the new version.
 
 
 ### 2.5.0 (2026-07-10)

stegano/wav/wav.py

@@ -38,12 +38,15 @@ def hide(
     """
     Hide a message (string) in a .wav audio file.
 
-    Use the lsb of each PCM encoded sample to hide the message string characters as ASCII values.
-    The first eight bits are used for message_length of the string.
+    Use the LSB of each PCM encoded sample to hide the message bytes.
+    The first eight bits are used for the length of the message in bytes.
     """
-    message_length = len(message)
-    assert message_length != 0, "message message_length is zero"
-    assert message_length < 255, "message is too long"
+    if encoding not in tools.ENCODINGS:
+        raise ValueError(f"Unsupported encoding: {encoding}")
+
+    assert len(message) != 0, "message message_length is zero"
+    message_bytes = message.encode(encoding)
+    assert len(message_bytes) < 256, "message is too long"
 
     output = wave.open(output_file, "wb")
     with wave.open(input_file, "rb") as input:
@@ -53,8 +56,11 @@ def hide(
 
         nsamples = nframes * nchannels
 
-        message_bits = f"{message_length:08b}" + "".join(
-            tools.a2bits_list(message, encoding)
+        # The payload is the byte-length prefix (8 bits) followed by the
+        # message encoded to bytes, 8 bits per byte.
+        message_bits = "".join(
+            bin(byte)[2:].rjust(8, "0")
+            for byte in bytes([len(message_bytes)]) + message_bytes
         )
         assert len(message_bits) <= nsamples, "message is too long"
 
@@ -63,50 +69,50 @@ def hide(
         output.setsampwidth(sampwidth)
         output.setframerate(framerate)
 
-        # encode message in frames
-        frames = bytearray(input.readframes(nsamples))
-        for i in range(nsamples):
-            if i < len(message_bits):
-                if message_bits[i] == "0":
-                    frames[i] = frames[i] & ~1
-                else:
-                    frames[i] = frames[i] | 1
+        # Encode one bit per sample. PCM samples wider than one byte are
+        # little-endian: the LSB of sample i is bit 0 of frames[i * sampwidth].
+        frames = bytearray(input.readframes(nframes))
+        for i, bit in enumerate(message_bits):
+            if bit == "0":
+                frames[i * sampwidth] = frames[i * sampwidth] & ~1
+            else:
+                frames[i * sampwidth] = frames[i * sampwidth] | 1
 
         # write out
         output.writeframes(frames)
 
 
 def reveal(input_file: Union[str, IO[bytes]], encoding: str = "UTF-8"):
     """
-    Find a message in an image.
+    Find a message in a .wav audio file.
 
-    Check the lsb of each PCM encoded sample for hidden message characters (ASCII values).
-    The first eight bits are used for message_length of the string.
+    Check the LSB of each PCM encoded sample for the hidden message bytes.
+    The first eight bits are used for the length of the message in bytes.
     """
-    message = ""
-    encoding_len = tools.ENCODINGS[encoding]
+    if encoding not in tools.ENCODINGS:
+        raise ValueError(f"Unsupported encoding: {encoding}")
+
     with wave.open(input_file, "rb") as input:
-        nchannels, _, _, nframes, comptype, _ = input.getparams()
+        _, sampwidth, _, nframes, comptype, _ = input.getparams()
         assert comptype == "NONE", "only uncompressed files are supported"
 
-        nsamples = nframes * nchannels
-        frames = bytearray(input.readframes(nsamples))
+        frames = bytearray(input.readframes(nframes))
 
-        # Read first 8 bits for message length
+        # Read first 8 bits for the message length in bytes
         length_bits = ""
         for i in range(8):
-            length_bits += str(frames[i] & 1)
+            length_bits += str(frames[i * sampwidth] & 1)
         message_length = int(length_bits, 2)
 
-        # Read message bits
-        message_bits = ""
-        for i in range(8, 8 + message_length * encoding_len):
-            message_bits += str(frames[i] & 1)
-
-        # Convert bits to string
-        chars = [
-            chr(int(message_bits[i : i + encoding_len], 2))
-            for i in range(0, len(message_bits), encoding_len)
-        ]
-        message = "".join(chars)
-    return message
+        # Read the message bytes
+        message_bytes = bytearray()
+        for i in range(message_length):
+            byte_bits = ""
+            for j in range(8):
+                byte_bits += str(frames[(8 + i * 8 + j) * sampwidth] & 1)
+            message_bytes.append(int(byte_bits, 2))
+
+    try:
+        return bytes(message_bytes).decode(encoding)
+    except UnicodeDecodeError as exc:
+        raise IndexError("Impossible to detect message.") from exc

tests/test_wav.py

@@ -22,8 +22,10 @@
 __date__ = "$Date: 2016/05/19 $"
 __license__ = "GPLv3"
 
+import array
 import os
 import unittest
+import wave
 
 from stegano import wav
 
@@ -47,6 +49,61 @@ def test_hide_and_reveal(self):
 
             self.assertEqual(message, clear_message)
 
+    def test_hide_and_reveal_UTF8_unicode(self):
+        messages_to_hide = ["héllo wörld 🔥", "🍕🍕🍕", "café crème"]
+
+        for message in messages_to_hide:
+            wav.hide(
+                "./tests/sample-files/free-software-song.wav", message, "./audio.wav"
+            )
+            clear_message = wav.reveal("./audio.wav")
+
+            self.assertEqual(message, clear_message)
+
+    def test_hide_and_reveal_UTF32LE(self):
+        message = "I love 🍕 and 🍫!"
+        wav.hide(
+            "./tests/sample-files/free-software-song.wav",
+            message,
+            "./audio.wav",
+            encoding="UTF-32LE",
+        )
+        clear_message = wav.reveal("./audio.wav", encoding="UTF-32LE")
+
+        self.assertEqual(message, clear_message)
+
+    def test_sample_distortion(self):
+        """
+        Hiding a message must only change the least significant bit of the
+        samples: on a 16-bit carrier every sample may change by at most 1.
+        """
+        wav.hide(
+            "./tests/sample-files/free-software-song.wav",
+            "Hello World!",
+            "./audio.wav",
+        )
+
+        with wave.open("./tests/sample-files/free-software-song.wav", "rb") as f:
+            original = array.array("h", f.readframes(f.getnframes()))
+        with wave.open("./audio.wav", "rb") as f:
+            encoded = array.array("h", f.readframes(f.getnframes()))
+
+        max_delta = max(abs(a - b) for a, b in zip(original, encoded))
+        self.assertLessEqual(max_delta, 1)
+
+    def test_with_unsupported_encoding(self):
+        with self.assertRaises(ValueError):
+            wav.hide(
+                "./tests/sample-files/free-software-song.wav",
+                "Hello",
+                "./audio.wav",
+                encoding="latin-1",
+            )
+        with self.assertRaises(ValueError):
+            wav.reveal(
+                "./tests/sample-files/free-software-song.wav", encoding="latin-1"
+            )
+
     def test_with_too_long_message(self):
         with open("./tests/sample-files/lorem_ipsum.txt") as f:
             message = f.read()
@@ -55,6 +112,15 @@ def test_with_too_long_message(self):
                 "./tests/sample-files/free-software-song.wav", message, "./audio.wav"
             )
 
+    def test_with_message_over_byte_limit(self):
+        # 64 four-byte characters exceed the 255-byte capacity of the
+        # 8-bit length prefix even though the character count is small.
+        message = "🔥" * 64
+        with self.assertRaises(AssertionError):
+            wav.hide(
+                "./tests/sample-files/free-software-song.wav", message, "./audio.wav"
+            )
+
     def tearDown(self):
         try:
             os.unlink("./audio.wav")