pyderasn.py            | 21 ++++++++++++---------
 tests/test_pyderasn.py | 23 +++++++++++++----------

diff --git a/pyderasn.py b/pyderasn.py
index 3837a420bcbf35b1c21bf2c1479760dc43b1e1b87a4f6e51181866c834d70af4..d7e574f8c960f26a21e43c80c4691120ab74bbd9d3661e3e035fa0c7733e9373 100755
--- a/pyderasn.py
+++ b/pyderasn.py
@@ -4188,6 +4188,9 @@     datetime.datetime(2017, 9, 30, 22, 7, 50)
     >>> UTCTime(datetime(2057, 9, 30, 22, 7, 50)).todatetime()
     datetime.datetime(1957, 9, 30, 22, 7, 50)
 
+    If BER encoded value was met, then ``ber_raw`` attribute will hold
+    its raw representation.
+
     .. warning::
 
        Pay attention that UTCTime can not hold full year, so all years
@@ -4201,7 +4204,7 @@
        * minutes are not exceeding 60
        * offset value is not exceeding 14 hours
     """
-    __slots__ = ("_ber_raw",)
+    __slots__ = ("ber_raw",)
     tag_default = tag_encode(23)
     encoding = "ascii"
     asn1_type_name = "UTCTime"
@@ -4229,10 +4232,10 @@         super(UTCTime, self).__init__(
             None, None, impl, expl, None, optional, _decoded, ctx,
         )
         self._value = value
-        self._ber_raw = None
+        self.ber_raw = None
         if value is not None:
-            self._value, self._ber_raw = self._value_sanitize(value, ctx)
-            self.ber_encoded = self._ber_raw is not None
+            self._value, self.ber_raw = self._value_sanitize(value, ctx)
+            self.ber_encoded = self.ber_raw is not None
         if default is not None:
             default, _ = self._value_sanitize(default)
             self.default = self.__class__(
@@ -4312,7 +4315,7 @@                 if (ctx is not None) and ctx.get("bered", False):
                     try:
                         offset, _value = self._strptime_bered(value_decoded)
                         _value = _value - timedelta(seconds=offset)
-                        return self._dt_sanitize(_value), value_decoded
+                        return self._dt_sanitize(_value), value
                     except (TypeError, ValueError, OverflowError) as _err:
                         err = _err
             raise DecodeError(
@@ -4329,26 +4332,26 @@     def _pp_value(self):
         if self.ready:
             value = self._value.isoformat()
             if self.ber_encoded:
-                value += " (%s)" % self._ber_raw
+                value += " (%s)" % self.ber_raw
             return value
 
     def __unicode__(self):
         if self.ready:
             value = self._value.isoformat()
             if self.ber_encoded:
-                value += " (%s)" % self._ber_raw
+                value += " (%s)" % self.ber_raw
             return value
         return text_type(self._pp_value())
 
     def __getstate__(self):
         return UTCTimeState(
             *super(UTCTime, self).__getstate__(),
-            **{"ber_raw": self._ber_raw}
+            **{"ber_raw": self.ber_raw}
         )
 
     def __setstate__(self, state):
         super(UTCTime, self).__setstate__(state)
-        self._ber_raw = state.ber_raw
+        self.ber_raw = state.ber_raw
 
     def __bytes__(self):
         self._assert_ready()
diff --git a/tests/test_pyderasn.py b/tests/test_pyderasn.py
index aaa94f27b8b2379183709f933969003a1844ee93d597e5fd50cd11ba378a01f0..85855460c49e467cc09b3e3773b1f73cb82655261194a8863388cbec53db5114 100644
--- a/tests/test_pyderasn.py
+++ b/tests/test_pyderasn.py
@@ -4085,14 +4085,14 @@                 offset_minute = d.draw(integers(min_value=0, max_value=59))
                 dt -= timedelta(seconds=sign * 60 * offset_minute)
                 data += "%s%02d" % (minutes_separator, offset_minute)
         data = data.encode("ascii")
-        data = GeneralizedTime.tag_default + len_encode(len(data)) + data
+        data_der = GeneralizedTime.tag_default + len_encode(len(data)) + data
         try:
-            GeneralizedTime().decod(data)
+            GeneralizedTime().decod(data_der)
         except DecodeError:
             dered = False
         else:
             dered = True
-        obj = GeneralizedTime().decod(data, ctx={"bered": True})
+        obj = GeneralizedTime().decod(data_der, ctx={"bered": True})
         if dt.year > 1970:
             self.assertEqual(
                 mktime(obj.todatetime().timetuple()),
@@ -4102,7 +4102,8 @@         elif not PY2:
             self.assertEqual(obj.todatetime().timestamp(), dt.timestamp())
         self.assertEqual(obj.ber_encoded, not dered)
         self.assertEqual(obj.bered, not dered)
-        self.assertEqual(obj.encode() == data, dered)
+        self.assertEqual(obj.ber_raw, None if dered else data)
+        self.assertEqual(obj.encode() == data_der, dered)
         repr(obj)
         bytes(obj)
         str(obj)
@@ -4428,13 +4429,14 @@                 (b"8201020700-0500", datetime(1982, 1, 2, 12)),
                 (b"0101021200Z", datetime(2001, 1, 2, 12)),
                 (b"0101020700-0500", datetime(2001, 1, 2, 12)),
         )):
-            data = UTCTime.tag_default + len_encode(len(data)) + data
-            obj = UTCTime().decod(data, ctx={"bered": True})
+            data_der = UTCTime.tag_default + len_encode(len(data)) + data
+            obj = UTCTime().decod(data_der, ctx={"bered": True})
             self.assertEqual(obj, dt)
             self.assertEqual(obj.todatetime(), dt)
             self.assertTrue(obj.ber_encoded)
             self.assertTrue(obj.bered)
-            self.assertNotEqual(obj.encode(), data)
+            self.assertEqual(obj.ber_raw, data)
+            self.assertNotEqual(obj.encode(), data_der)
             repr(obj)
 
     def test_go_vectors_valid_ber(self):
@@ -4488,13 +4490,14 @@                 dt -= offset
                 data += "+"
             data += "%02d%02d" % (offset_hour, offset_minute)
         data = data.encode("ascii")
-        data = UTCTime.tag_default + len_encode(len(data)) + data
-        obj = UTCTime().decod(data, ctx={"bered": True})
+        data_der = UTCTime.tag_default + len_encode(len(data)) + data
+        obj = UTCTime().decod(data_der, ctx={"bered": True})
         self.assertEqual(obj, dt)
         self.assertEqual(obj.todatetime(), dt)
         self.assertEqual(obj.ber_encoded, not dered)
         self.assertEqual(obj.bered, not dered)
-        self.assertEqual(obj.encode() == data, dered)
+        self.assertEqual(obj.ber_raw, None if dered else data)
+        self.assertEqual(obj.encode() == data_der, dered)
         repr(obj)
         bytes(obj)
         str(obj)