add support for encoding

Author: tomato42

src/ecdsa/der.py

@@ -16,6 +16,32 @@ def encode_constructed(tag, value):
     return int2byte(0xA0 + tag) + encode_length(len(value)) + value
 
 
+def encode_implicit(tag, value, cls="context-specific"):
+    """
+    Encode and IMPLICIT value using :term:`DER`.
+
+    :param int tag: the tag value to encode, must be between 0 an 31 inclusive
+    :param bytes value: the data to encode
+    :param str cls: the class of the tag to encode: "application",
+      "context-specific", or "private"
+    :rtype: bytes
+    """
+    if cls not in ("application", "context-specific", "private"):
+        raise ValueError("invalid tag class")
+    if tag > 31:
+        raise ValueError("Long tags not supported")
+
+    if cls == "application":
+        tag_class = 0b01000000
+    elif cls == "context-specific":
+        tag_class = 0b10000000
+    else:
+        assert cls == "private"
+        tag_class = 0b11000000
+
+    return int2byte(tag_class + tag) + encode_length(len(value)) + value
+
+
 def encode_integer(r):
     assert r >= 0  # can't support negative numbers yet
     h = ("%x" % r).encode()

src/ecdsa/test_der.py

@@ -25,6 +25,7 @@
     remove_implicit,
     remove_octet_string,
     remove_sequence,
+    encode_implicit,
 )
 
 
@@ -463,6 +464,62 @@ def test_with_constructed(self):
 
         self.assertIn("wanted type primitive, got 0xa6 tag", str(e.exception))
 
+    def test_encode_decode(self):
+        data = b"some longish string"
+
+        tag, body, rest = remove_implicit(
+            encode_implicit(6, data, "application"),
+            "application"
+        )
+
+        self.assertEqual(tag, 6)
+        self.assertEqual(body, data)
+        self.assertEqual(rest, b"")
+
+
+class TestEncodeImplicit(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.data = b"\x0a\x0b"
+        # data with application tag class
+        cls.data_application = b"\x46\x02\x0a\x0b"
+        # data with context-specific tag class
+        cls.data_context_specific = b"\x86\x02\x0a\x0b"
+        # data with private tag class
+        cls.data_private = b"\xc6\x02\x0a\x0b"
+
+    def test_encode_with_default_class(self):
+        ret = encode_implicit(6, self.data)
+
+        self.assertEqual(ret, self.data_context_specific)
+
+    def test_encode_with_application_class(self):
+        ret = encode_implicit(6, self.data, "application")
+
+        self.assertEqual(ret, self.data_application)
+
+    def test_encode_with_context_specific_class(self):
+        ret = encode_implicit(6, self.data, "context-specific")
+
+        self.assertEqual(ret, self.data_context_specific)
+
+    def test_encode_with_private_class(self):
+        ret = encode_implicit(6, self.data, "private")
+
+        self.assertEqual(ret, self.data_private)
+
+    def test_encode_with_invalid_class(self):
+        with self.assertRaises(ValueError) as e:
+            encode_implicit(6, self.data, "foobar")
+
+        self.assertIn("invalid tag class", str(e.exception))
+
+    def test_encode_with_too_large_tag(self):
+        with self.assertRaises(ValueError) as e:
+            encode_implicit(32, self.data)
+
+        self.assertIn("Long tags not supported", str(e.exception))
+
 
 class TestRemoveOctetString(unittest.TestCase):
     def test_simple(self):