two version of R2R are hereHEADmaster

8 files changed, 310 insertions, 0 deletions

diff --git a/.venv/lib/python3.12/site-packages/ellipticcurve/utils/__init__.py b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/__init__.py
diff --git a/.venv/lib/python3.12/site-packages/ellipticcurve/utils/binary.py b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/binary.py
new file mode 100644
index 00000000..348887f0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/binary.py
@@ -0,0 +1,37 @@
+from base64 import b64encode, b64decode
+from .compatibility import safeHexFromBinary, safeBinaryFromHex, toString
+
+
+def hexFromInt(number):
+    hexadecimal = "{0:x}".format(number)
+    if len(hexadecimal) % 2 == 1:
+        hexadecimal = "0" + hexadecimal
+    return hexadecimal
+
+
+def intFromHex(hexadecimal):
+    return int(hexadecimal, 16)
+
+
+def hexFromByteString(byteString):
+    return safeHexFromBinary(byteString)
+
+
+def byteStringFromHex(hexadecimal):
+    return safeBinaryFromHex(hexadecimal)
+
+
+def numberFromByteString(byteString):
+    return intFromHex(hexFromByteString(byteString))
+
+
+def base64FromByteString(byteString):
+    return toString(b64encode(byteString))
+
+
+def byteStringFromBase64(base64String):
+    return b64decode(base64String)
+
+
+def bitsFromHex(hexadecimal):
+    return format(intFromHex(hexadecimal), 'b').zfill(4 * len(hexadecimal))
diff --git a/.venv/lib/python3.12/site-packages/ellipticcurve/utils/compatibility.py b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/compatibility.py
new file mode 100644
index 00000000..3b22dd3c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/compatibility.py
@@ -0,0 +1,40 @@
+from sys import version_info as pyVersion
+from binascii import hexlify, unhexlify
+
+
+if pyVersion.major == 3:
+    # py3 constants and conversion functions
+
+    stringTypes = (str,)
+    intTypes = (int, float)
+
+    def toString(string, encoding="utf-8"):
+        return string.decode(encoding)
+
+    def toBytes(string, encoding="utf-8"):
+        return string.encode(encoding)
+
+    def safeBinaryFromHex(hexadecimal):
+        if len(hexadecimal) % 2 == 1:
+            hexadecimal = "0" + hexadecimal
+        return unhexlify(hexadecimal)
+
+    def safeHexFromBinary(byteString):
+        return toString(hexlify(byteString))
+else:
+    # py2 constants and conversion functions
+
+    stringTypes = (str, unicode)
+    intTypes = (int, float, long)
+
+    def toString(string, encoding="utf-8"):
+        return string
+
+    def toBytes(string, encoding="utf-8"):
+        return string
+
+    def safeBinaryFromHex(hexadecimal):
+        return unhexlify(hexadecimal)
+
+    def safeHexFromBinary(byteString):
+        return hexlify(byteString)
diff --git a/.venv/lib/python3.12/site-packages/ellipticcurve/utils/der.py b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/der.py
new file mode 100644
index 00000000..84546aea
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/der.py
@@ -0,0 +1,159 @@
+from datetime import datetime
+from .oid import oidToHex, oidFromHex
+from .binary import hexFromInt, intFromHex, byteStringFromHex, bitsFromHex
+
+
+class DerFieldType:
+
+    integer = "integer"
+    bitString = "bitString"
+    octetString = "octetString"
+    null = "null"
+    object = "object"
+    printableString = "printableString"
+    utcTime = "utcTime"
+    sequence = "sequence"
+    set = "set"
+    oidContainer = "oidContainer"
+    publicKeyPointContainer = "publicKeyPointContainer"
+
+
+_hexTagToType = {
+    "02": DerFieldType.integer,
+    "03": DerFieldType.bitString,
+    "04": DerFieldType.octetString,
+    "05": DerFieldType.null,
+    "06": DerFieldType.object,
+    "13": DerFieldType.printableString,
+    "17": DerFieldType.utcTime,
+    "30": DerFieldType.sequence,
+    "31": DerFieldType.set,
+    "a0": DerFieldType.oidContainer,
+    "a1": DerFieldType.publicKeyPointContainer,
+}
+_typeToHexTag = {v: k for k, v in _hexTagToType.items()}
+
+
+def encodeConstructed(*encodedValues):
+    return encodePrimitive(DerFieldType.sequence, "".join(encodedValues))
+
+
+def encodePrimitive(tagType, value):
+    if tagType == DerFieldType.integer:
+        value = _encodeInteger(value)
+    if tagType == DerFieldType.object:
+        value = oidToHex(value)
+    return "{tag}{size}{value}".format(tag=_typeToHexTag[tagType], size=_generateLengthBytes(value), value=value)
+
+
+def parse(hexadecimal):
+    if not hexadecimal:
+        return []
+    typeByte, hexadecimal = hexadecimal[:2], hexadecimal[2:]
+    length, lengthBytes = _readLengthBytes(hexadecimal)
+    content, hexadecimal = hexadecimal[lengthBytes: lengthBytes + length], hexadecimal[lengthBytes + length:]
+    if len(content) < length:
+        raise Exception("missing bytes in DER parse")
+
+    tagData = _getTagData(typeByte)
+    if tagData["isConstructed"]:
+        content = parse(content)
+
+    valueParser = {
+        DerFieldType.null: _parseNull,
+        DerFieldType.object: _parseOid,
+        DerFieldType.utcTime: _parseTime,
+        DerFieldType.integer: _parseInteger,
+        DerFieldType.printableString: _parseString,
+    }.get(tagData["type"], _parseAny)
+    return [valueParser(content)] + parse(hexadecimal)
+
+
+def _parseAny(hexadecimal):
+    return hexadecimal
+
+
+def _parseOid(hexadecimal):
+    return tuple(oidFromHex(hexadecimal))
+
+
+def _parseTime(hexadecimal):
+    string = _parseString(hexadecimal)
+    return datetime.strptime(string, "%y%m%d%H%M%SZ")
+
+
+def _parseString(hexadecimal):
+    return byteStringFromHex(hexadecimal).decode()
+
+
+def _parseNull(_content):
+    return None
+
+
+def _parseInteger(hexadecimal):
+    integer = intFromHex(hexadecimal)
+    bits = bitsFromHex(hexadecimal[0])
+    if bits[0] == "0":  # negative numbers are encoded using two's complement
+        return integer
+    bitCount = 4 * len(hexadecimal)
+    return integer - (2 ** bitCount)
+
+
+def _encodeInteger(number):
+    hexadecimal = hexFromInt(abs(number))
+    if number < 0:
+        bitCount = 4 * len(hexadecimal)
+        twosComplement = (2 ** bitCount) + number
+        return hexFromInt(twosComplement)
+    bits = bitsFromHex(hexadecimal[0])
+    if bits[0] == "1":  # if first bit was left as 1, number would be parsed as a negative integer with two's complement
+        hexadecimal = "00" + hexadecimal
+    return hexadecimal
+
+
+def _readLengthBytes(hexadecimal):
+    lengthBytes = 2
+    lengthIndicator = intFromHex(hexadecimal[0:lengthBytes])
+    isShortForm = lengthIndicator < 128  # checks if first bit of byte is 1 (a.k.a. short-form)
+    if isShortForm:
+        length = lengthIndicator * 2
+        return length, lengthBytes
+
+    lengthLength = lengthIndicator - 128  # nullifies first bit of byte (only used as long-form flag)
+    if lengthLength == 0:
+        raise Exception("indefinite length encoding located in DER")
+    lengthBytes += 2 * lengthLength
+    length = intFromHex(hexadecimal[2:lengthBytes]) * 2
+    return length, lengthBytes
+
+
+def _generateLengthBytes(hexadecimal):
+    size = len(hexadecimal) // 2
+    length = hexFromInt(size)
+    if size < 128:  # checks if first bit of byte should be 0 (a.k.a. short-form flag)
+        return length.zfill(2)
+    lengthLength = 128 + len(length) // 2  # +128 sets the first bit of the byte as 1 (a.k.a. long-form flag)
+    return hexFromInt(lengthLength) + length
+
+
+def _getTagData(tag):
+    bits = bitsFromHex(tag)
+    bit8, bit7, bit6 = bits[:3]
+
+    tagClass = {
+        "0": {
+            "0": "universal",
+            "1": "application",
+        },
+        "1": {
+            "0": "context-specific",
+            "1": "private",
+        },
+    }[bit8][bit7]
+    isConstructed = bit6 == "1"
+
+    return {
+        "class": tagClass,
+        "isConstructed": isConstructed,
+        "type": _hexTagToType.get(tag),
+    }
diff --git a/.venv/lib/python3.12/site-packages/ellipticcurve/utils/file.py b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/file.py
new file mode 100644
index 00000000..c7b1df73
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/file.py
@@ -0,0 +1,9 @@
+
+
+class File:
+
+    @classmethod
+    def read(cls, path, mode="r"):
+        with open(path, mode) as blob:
+            content = blob.read()
+        return content
diff --git a/.venv/lib/python3.12/site-packages/ellipticcurve/utils/integer.py b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/integer.py
new file mode 100644
index 00000000..180f200c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/integer.py
@@ -0,0 +1,16 @@
+from random import SystemRandom
+
+
+class RandomInteger:
+
+    @classmethod
+    def between(cls, min, max):
+        """
+        Return integer x in the range: min <= x <= max
+
+        :param min: minimum value of the integer
+        :param max: maximum value of the integer
+        :return:
+        """
+
+        return SystemRandom().randrange(min, max + 1)
diff --git a/.venv/lib/python3.12/site-packages/ellipticcurve/utils/oid.py b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/oid.py
new file mode 100644
index 00000000..dbfebe79
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/oid.py
@@ -0,0 +1,35 @@
+from .binary import intFromHex, hexFromInt
+
+
+def oidFromHex(hexadecimal):
+    firstByte, remainingBytes = hexadecimal[:2], hexadecimal[2:]
+    firstByteInt = intFromHex(firstByte)
+    oid = [firstByteInt // 40, firstByteInt % 40]
+    oidInt = 0
+    while len(remainingBytes) > 0:
+        byte, remainingBytes = remainingBytes[0:2], remainingBytes[2:]
+        byteInt = intFromHex(byte)
+        if byteInt >= 128:
+            oidInt = (128 * oidInt) + (byteInt - 128)
+            continue
+        oidInt = (128 * oidInt) + byteInt
+        oid.append(oidInt)
+        oidInt = 0
+    return oid
+
+
+def oidToHex(oid):
+    hexadecimal = hexFromInt(40 * oid[0] + oid[1])
+    for number in oid[2:]:
+        hexadecimal += _oidNumberToHex(number)
+    return hexadecimal
+
+
+def _oidNumberToHex(number):
+    hexadecimal = ""
+    endDelta = 0
+    while number > 0:
+        hexadecimal = hexFromInt((number % 128) + endDelta) + hexadecimal
+        number //= 128
+        endDelta = 128
+    return hexadecimal or "00"
diff --git a/.venv/lib/python3.12/site-packages/ellipticcurve/utils/pem.py b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/pem.py
new file mode 100644
index 00000000..1e58b409
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/ellipticcurve/utils/pem.py
@@ -0,0 +1,14 @@
+from re import search
+
+
+def getPemContent(pem, template):
+    pattern = template.format(content="(.*)")
+    return search("".join(pattern.splitlines()), "".join(pem.splitlines())).group(1)
+
+
+def createPem(content, template):
+    lines = [
+        content[start:start + 64]
+        for start in range(0, len(content), 64)
+    ]
+    return template.format(content="\n".join(lines))