hive-nectar 0.0.2__py3-none-any.whl

nectargraphenebase/aes.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+import base64
+import hashlib
+
+try:
+    from Cryptodome import Random
+    from Cryptodome.Cipher import AES
+except ImportError:
+    try:
+        from Crypto import Random
+        from Crypto.Cipher import AES
+    except ImportError:
+        raise ImportError("Missing dependency: pyCryptodome")
+
+
+class AESCipher(object):
+    """
+    A classical AES Cipher. Can use any size of data and any size of password thanks to padding.
+    Also ensure the coherence and the type of the data with a unicode to byte converter.
+    """
+
+    def __init__(self, key):
+        self.bs = 32
+        self.key = hashlib.sha256(AESCipher.str_to_bytes(key)).digest()
+
+    @staticmethod
+    def str_to_bytes(data):
+        u_type = type(b"".decode("utf8"))
+        if isinstance(data, u_type):
+            return data.encode("utf8")
+        return data
+
+    def _pad(self, s):
+        return s + (self.bs - len(s) % self.bs) * AESCipher.str_to_bytes(
+            chr(self.bs - len(s) % self.bs)
+        )
+
+    @staticmethod
+    def _unpad(s):
+        return s[: -ord(s[len(s) - 1 :])]
+
+    def encrypt(self, raw):
+        raw = self._pad(AESCipher.str_to_bytes(raw))
+        iv = Random.new().read(AES.block_size)
+        cipher = AES.new(self.key, AES.MODE_CBC, iv)
+        return base64.b64encode(iv + cipher.encrypt(raw)).decode("utf-8")
+
+    def decrypt(self, enc):
+        enc = base64.b64decode(enc)
+        iv = enc[: AES.block_size]
+        cipher = AES.new(self.key, AES.MODE_CBC, iv)
+        return self._unpad(cipher.decrypt(enc[AES.block_size :])).decode("utf-8")

nectargraphenebase/base58.py

@@ -0,0 +1,192 @@
+# -*- coding: utf-8 -*-
+import hashlib
+import logging
+import string
+from binascii import hexlify, unhexlify
+
+from .prefix import Prefix
+from .py23 import integer_types, py23_bytes, py23_chr, string_types
+
+log = logging.getLogger(__name__)
+
+
+class Base58(Prefix):
+    """Base58 base class
+
+    This class serves as an abstraction layer to deal with base58 encoded
+    strings and their corresponding hex and binary representation throughout the
+    library.
+
+    :param data: Data to initialize object, e.g. pubkey data, address data, ...
+    :type data: hex, wif, bip38 encrypted wif, base58 string
+    :param str prefix: Prefix to use for Address/PubKey strings (defaults to ``GPH``)
+    :return: Base58 object initialized with ``data``
+    :rtype: Base58
+    :raises ValueError: if data cannot be decoded
+
+    * ``bytes(Base58)``: Returns the raw data
+    * ``str(Base58)``:   Returns the readable ``Base58CheckEncoded`` data.
+    * ``repr(Base58)``:  Gives the hex representation of the data.
+    * ``format(Base58,_format)``: Formats the instance according to ``_format``
+
+        * ``"btc"``: prefixed with ``0x80``. Yields a valid btc address
+        * ``"wif"``: prefixed with ``0x00``. Yields a valid wif key
+        * ``"bts"``: prefixed with ``BTS``
+        * etc.
+
+    """
+
+    def __init__(self, data, prefix=None):
+        self.set_prefix(prefix)
+        if isinstance(data, Base58):
+            data = repr(data)
+        if all(c in string.hexdigits for c in data):
+            self._hex = data
+        elif data[0] == "5" or data[0] == "6":
+            self._hex = base58CheckDecode(data)
+        elif data[0] == "K" or data[0] == "L":
+            self._hex = base58CheckDecode(data)[:-2]
+        elif data[: len(self.prefix)] == self.prefix:
+            self._hex = gphBase58CheckDecode(data[len(self.prefix) :])
+        else:
+            raise ValueError("Error loading Base58 object")
+
+    def __format__(self, _format):
+        """Format output according to argument _format (wif,btc,...)
+
+        :param str _format: Format to use
+        :return: formatted data according to _format
+        :rtype: str
+
+        """
+        if _format.upper() == "WIF":
+            return base58CheckEncode(0x80, self._hex)
+        elif _format.upper() == "ENCWIF":
+            return base58encode(self._hex)
+        elif _format.upper() == "BTC":
+            return base58CheckEncode(0x00, self._hex)
+        else:
+            return _format.upper() + str(self)
+
+    def __repr__(self):
+        """Returns hex value of object
+
+        :return: Hex string of instance's data
+        :rtype: hex string
+        """
+        return self._hex
+
+    def __str__(self):
+        """Return graphene-base58CheckEncoded string of data
+
+        :return: Base58 encoded data
+        :rtype: str
+        """
+        return gphBase58CheckEncode(self._hex)
+
+    def __bytes__(self):
+        """Return raw bytes
+
+        :return: Raw bytes of instance
+        :rtype: bytes
+
+        """
+        return unhexlify(self._hex)
+
+
+# https://github.com/tochev/python3-cryptocoins/raw/master/cryptocoins/base58.py
+BASE58_ALPHABET = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+
+
+def base58decode(base58_str):
+    base58_text = py23_bytes(base58_str, "ascii")
+    n = 0
+    leading_zeroes_count = 0
+    for b in base58_text:
+        if isinstance(b, integer_types):
+            n = n * 58 + BASE58_ALPHABET.find(py23_chr(b))
+        else:
+            n = n * 58 + BASE58_ALPHABET.find(b)
+        if n == 0:
+            leading_zeroes_count += 1
+    res = bytearray()
+    while n >= 256:
+        div, mod = divmod(n, 256)
+        res.insert(0, mod)
+        n = div
+    else:
+        res.insert(0, n)
+    return hexlify(bytearray(1) * leading_zeroes_count + res).decode("ascii")
+
+
+def base58encode(hexstring):
+    byteseq = py23_bytes(unhexlify(py23_bytes(hexstring, "ascii")))
+    n = 0
+    leading_zeroes_count = 0
+    for c in byteseq:
+        n = n * 256 + c
+        if n == 0:
+            leading_zeroes_count += 1
+    res = bytearray()
+    while n >= 58:
+        div, mod = divmod(n, 58)
+        res.insert(0, BASE58_ALPHABET[mod])
+        n = div
+    else:
+        res.insert(0, BASE58_ALPHABET[n])
+    return (BASE58_ALPHABET[0:1] * leading_zeroes_count + res).decode("ascii")
+
+
+def ripemd160(s):
+    ripemd160 = hashlib.new("ripemd160")
+    ripemd160.update(unhexlify(s))
+    return ripemd160.digest()
+
+
+def doublesha256(s):
+    return hashlib.sha256(hashlib.sha256(unhexlify(s)).digest()).digest()
+
+
+def b58encode(v):
+    return base58encode(v)
+
+
+def b58decode(v):
+    return base58decode(v)
+
+
+def base58CheckEncode(version, payload):
+    if isinstance(version, string_types):
+        s = version + payload
+    else:
+        s = ("%.2x" % version) + payload
+    checksum = doublesha256(s)[:4]
+    result = s + hexlify(checksum).decode("ascii")
+    return base58encode(result)
+
+
+def base58CheckDecode(s, skip_first_bytes=True):
+    s = unhexlify(base58decode(s))
+    dec = hexlify(s[:-4]).decode("ascii")
+    checksum = doublesha256(dec)[:4]
+    if not (s[-4:] == checksum):
+        raise AssertionError()
+    if skip_first_bytes:
+        return dec[2:]
+    else:
+        return dec
+
+
+def gphBase58CheckEncode(s):
+    checksum = ripemd160(s)[:4]
+    result = s + hexlify(checksum).decode("ascii")
+    return base58encode(result)
+
+
+def gphBase58CheckDecode(s):
+    s = unhexlify(base58decode(s))
+    dec = hexlify(s[:-4]).decode("ascii")
+    checksum = ripemd160(dec)[:4]
+    if not (s[-4:] == checksum):
+        raise AssertionError()
+    return dec