doc/news.rst           |  1 +
 pyderasn.py            | 28 ++++++++++++++++++----------
 tests/test_pyderasn.py | 44 ++++++++++++++++++++++++++++++++++++++++++--

diff --git a/doc/news.rst b/doc/news.rst
index 914c31d3827a65a41a4037f18f081a207ebfbac2073c690bcb4b4e62e9639986..e6a844b0c73b603bc5562e3b8f55ee46163d365d67105590ebbabe4900d7e06a 100644
--- a/doc/news.rst
+++ b/doc/news.rst
@@ -6,6 +6,7 @@
 3.12
 ----
 * Fix possible uncaught TypeError in Py2 with zero bytes inside the value.
+* Fix SequenceOf/SetOf raising BoundsError instead of DecodeError.
 
 .. _release3.11:
 
diff --git a/pyderasn.py b/pyderasn.py
index 1764fcbacd846bb3e0a5ced57066e05ebc31d817a5a68bb54fe4786f9c2e3828..755a2386440f578e83eaa6ee86f9428eee1510fdaecb859856830bf105516daa 100755
--- a/pyderasn.py
+++ b/pyderasn.py
@@ -5025,16 +5025,24 @@             sub_offset += value_len
             vlen += value_len
             v = v_tail
             _value.append(value)
-        obj = self.__class__(
-            value=_value,
-            schema=spec,
-            bounds=(self._bound_min, self._bound_max),
-            impl=self.tag,
-            expl=self._expl,
-            default=self.default,
-            optional=self.optional,
-            _decoded=(offset, llen, vlen + (EOC_LEN if lenindef else 0)),
-        )
+        try:
+            obj = self.__class__(
+                value=_value,
+                schema=spec,
+                bounds=(self._bound_min, self._bound_max),
+                impl=self.tag,
+                expl=self._expl,
+                default=self.default,
+                optional=self.optional,
+                _decoded=(offset, llen, vlen + (EOC_LEN if lenindef else 0)),
+            )
+        except BoundsError as err:
+            raise DecodeError(
+                msg=str(err),
+                klass=self.__class__,
+                decode_path=decode_path,
+                offset=offset,
+            )
         if lenindef:
             if v[:EOC_LEN].tobytes() != EOC:
                 raise DecodeError(
diff --git a/tests/test_pyderasn.py b/tests/test_pyderasn.py
index 0f48dc92d628ca923b04ab515bb05b817d654049cd8a1aa3663644b9233d60c7..81df2dfc862f1f7588024abd339c8f9a6aef8913963db52985aed7efeb031164 100644
--- a/tests/test_pyderasn.py
+++ b/tests/test_pyderasn.py
@@ -809,8 +809,18 @@         values = sorted(values)
         with self.assertRaises(BoundsError) as err:
             Integer(value=values[0], bounds=(values[1], values[2]))
         repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            Integer(bounds=(values[1], values[2])).decode(
+                Integer(values[0]).encode()
+            )
+        repr(err.exception)
         with self.assertRaises(BoundsError) as err:
             Integer(value=values[2], bounds=(values[0], values[1]))
+        repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            Integer(bounds=(values[0], values[1])).decode(
+                Integer(values[2]).encode()
+            )
         repr(err.exception)
 
     @given(data_strategy())
@@ -1762,9 +1772,19 @@         value = d.draw(binary(max_size=bound_min - 1))
         with self.assertRaises(BoundsError) as err:
             OctetString(value=value, bounds=(bound_min, bound_max))
         repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            OctetString(bounds=(bound_min, bound_max)).decode(
+                OctetString(value).encode()
+            )
+        repr(err.exception)
         value = d.draw(binary(min_size=bound_max + 1))
         with self.assertRaises(BoundsError) as err:
             OctetString(value=value, bounds=(bound_min, bound_max))
+        repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            OctetString(bounds=(bound_min, bound_max)).decode(
+                OctetString(value).encode()
+            )
         repr(err.exception)
 
     @given(data_strategy())
@@ -2978,9 +2998,19 @@         value = d.draw(text(alphabet=self.text_alphabet(), max_size=bound_min - 1))
         with self.assertRaises(BoundsError) as err:
             self.base_klass(value=value, bounds=(bound_min, bound_max))
         repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            self.base_klass(bounds=(bound_min, bound_max)).decode(
+                self.base_klass(value).encode()
+            )
+        repr(err.exception)
         value = d.draw(text(alphabet=self.text_alphabet(), min_size=bound_max + 1))
         with self.assertRaises(BoundsError) as err:
             self.base_klass(value=value, bounds=(bound_min, bound_max))
+        repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            self.base_klass(bounds=(bound_min, bound_max)).decode(
+                self.base_klass(value).encode()
+            )
         repr(err.exception)
 
     @given(data_strategy())
@@ -5080,16 +5110,26 @@         class SeqOf(self.base_klass):
             schema = Boolean()
         bound_min = d.draw(integers(min_value=1, max_value=1 << 7))
         bound_max = d.draw(integers(min_value=bound_min, max_value=1 << 7))
-        value = [Boolean()] * d.draw(integers(max_value=bound_min - 1))
+        value = [Boolean(False)] * d.draw(integers(max_value=bound_min - 1))
         with self.assertRaises(BoundsError) as err:
             SeqOf(value=value, bounds=(bound_min, bound_max))
         repr(err.exception)
-        value = [Boolean()] * d.draw(integers(
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            SeqOf(bounds=(bound_min, bound_max)).decode(
+                SeqOf(value).encode()
+            )
+        repr(err.exception)
+        value = [Boolean(True)] * d.draw(integers(
             min_value=bound_max + 1,
             max_value=bound_max + 10,
         ))
         with self.assertRaises(BoundsError) as err:
             SeqOf(value=value, bounds=(bound_min, bound_max))
+        repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            SeqOf(bounds=(bound_min, bound_max)).decode(
+                SeqOf(value).encode()
+            )
         repr(err.exception)
 
     @given(integers(min_value=1, max_value=10))