From 3ad9ef9200070276702491f2bb2e3f49cba013f4 Mon Sep 17 00:00:00 2001
From: Sergey Matveev <stargrave@stargrave.org>
Date: Sun, 30 Dec 2018 19:34:00 +0300
Subject: [PATCH] ber_encoded at ObjectIdentifier

---
 VERSION                |  2 +-
 doc/news.rst           |  7 +++++++
 pyderasn.py            | 14 +++++++++++---
 tests/test_pyderasn.py |  7 +++++--
 4 files changed, 24 insertions(+), 6 deletions(-)

diff --git a/VERSION b/VERSION
index b3d791d..4f8c639 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-4.6
+4.7
diff --git a/doc/news.rst b/doc/news.rst
index a187825..a6695f3 100644
--- a/doc/news.rst
+++ b/doc/news.rst
@@ -1,6 +1,13 @@
 News
 ====
 
+.. _release4.7:
+
+4.7
+---
+* ObjectIdentifier has ``ber_encoded`` set to True, if non-normalized
+  arc encoding is met
+
 .. _release4.6:
 
 4.6
diff --git a/pyderasn.py b/pyderasn.py
index 4e9def7..5160368 100755
--- a/pyderasn.py
+++ b/pyderasn.py
@@ -384,7 +384,8 @@ constructed primitive types should be parsed successfully.
 
 * If object is encoded in BER form (not the DER one), then ``ber_encoded``
   attribute is set to True. Only ``BOOLEAN``, ``BIT STRING``, ``OCTET
-  STRING``, ``SEQUENCE``, ``SET``, ``SET OF`` can contain it.
+  STRING``, ``OBJECT IDENTIFIER``, ``SEQUENCE``, ``SET``, ``SET OF``
+  can contain it.
 * If object has an indefinite length encoding, then its ``lenindef``
   attribute is set to True. Only ``BIT STRING``, ``OCTET STRING``,
   ``SEQUENCE``, ``SET``, ``SEQUENCE OF``, ``SET OF``, ``ANY`` can
@@ -3223,13 +3224,17 @@ class ObjectIdentifier(Obj):
             )
         v, tail = v[:l], v[l:]
         arcs = []
+        ber_encoded = False
         while len(v) > 0:
             i = 0
             arc = 0
             while True:
                 octet = indexbytes(v, i)
-                if i == 0 and octet == 0x80 and not ctx.get("bered", False):
-                    raise DecodeError("non normalized arc encoding")
+                if i == 0 and octet == 0x80:
+                    if ctx.get("bered", False):
+                        ber_encoded = True
+                    else:
+                        raise DecodeError("non normalized arc encoding")
                 arc = (arc << 7) | (octet & 0x7F)
                 if octet & 0x80 == 0:
                     arcs.append(arc)
@@ -3261,6 +3266,8 @@ class ObjectIdentifier(Obj):
             optional=self.optional,
             _decoded=(offset, llen, l),
         )
+        if ber_encoded:
+            obj.ber_encoded = True
         return obj, tail
 
     def __repr__(self):
@@ -3286,6 +3293,7 @@ class ObjectIdentifier(Obj):
             expl_llen=self.expl_llen if self.expled else None,
             expl_vlen=self.expl_vlen if self.expled else None,
             expl_lenindef=self.expl_lenindef,
+            ber_encoded=self.ber_encoded,
             bered=self.bered,
         )
         for pp in self.pps_lenindef(decode_path):
diff --git a/tests/test_pyderasn.py b/tests/test_pyderasn.py
index 174abb6..68c8861 100644
--- a/tests/test_pyderasn.py
+++ b/tests/test_pyderasn.py
@@ -2410,6 +2410,7 @@ class TestObjectIdentifier(CommonMixin, TestCase):
         repr(err.exception)
         obj = ObjectIdentifier(value)
         self.assertTrue(obj.ready)
+        self.assertFalse(obj.ber_encoded)
         repr(obj)
         list(obj.pps())
         pprint(obj, big_blobs=True, with_decode_path=True)
@@ -2728,7 +2729,8 @@ class TestObjectIdentifier(CommonMixin, TestCase):
             b'\x80' +
             ObjectIdentifier((1, 0)).encode()[-1:]
         )
-        ObjectIdentifier().decode(tampered, ctx={"bered": True})
+        obj, _ = ObjectIdentifier().decode(tampered, ctx={"bered": True})
+        self.assertTrue(obj.ber_encoded)
         with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
             ObjectIdentifier().decode(tampered)
 
@@ -2756,7 +2758,8 @@ class TestObjectIdentifier(CommonMixin, TestCase):
             len_encode(len(tampered)) +
             tampered
         )
-        ObjectIdentifier().decode(tampered, ctx={"bered": True})
+        obj, _ = ObjectIdentifier().decode(tampered, ctx={"bered": True})
+        self.assertTrue(obj.ber_encoded)
         with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
             ObjectIdentifier().decode(tampered)
 
-- 
2.44.0