libcrypto 1.1.6__tar.gz → 1.2.0__tar.gz

{libcrypto-1.1.6/src/libcrypto.egg-info → libcrypto-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libcrypto
-Version: 1.1.6
+Version: 1.2.0
 Summary: A professional library For Cryptography and Cryptocurrencies in Python.
 Home-page: https://github.com/pymmdrza/libcrypto
 Author: Mmdrza
@@ -11,7 +11,7 @@ Project-URL: Repository, https://github.com/Pymmdrza/libcrypto
 Project-URL: Bug Tracker, https://github.com/Pymmdrza/libcrypto/issues
 Project-URL: Documentation, https://libcrypto.readthedocs.io
 Project-URL: PyPI, https://pypi.org/project/libcrypto/
-Keywords: cryptocurrency,bitcoin,ethereum,wallet,bip39,bip32,bip44,mnemonic,private-key,public-key,address,hdwallet,crypto,blockchain,litecoin,dash,dogecoin,bitcoin-cash,secp256k1,pycryptodome,cryptography
+Keywords: cryptocurrency,bitcoin,ethereum,wallet,bip39,bip32,bip44,mnemonic,private-key,public-key,address,hdwallet,crypto,blockchain,litecoin,dash,dogecoin,bitcoin-cash,secp256k1,cryptography,pure-python
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -22,6 +22,8 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Security :: Cryptography
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Office/Business :: Financial
@@ -30,10 +32,9 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pycryptodome>=3.23.0
-Requires-Dist: rich>=14.0.0
-Requires-Dist: wheel>=0.45.1
-Requires-Dist: setuptools>=80.9.0
+Requires-Dist: rich
+Requires-Dist: wheel
+Requires-Dist: setuptools
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -82,6 +83,50 @@ Install the library using pip:
 pip install libcrypto
 ```
 
+#### Install On Debian/Ubuntu
+```bash
+sudo apt-get install build-essential python3-dev
+pip3 install libcrypto
+```
+
+#### Install On Fedora
+```bash
+sudo yum install gcc gmp python-devel
+pip3 install libcrypto
+```
+
+#### Windows Installation
+> [!NOTE]
+> **Once only**
+>  Download [Build Tools for Visual Studio 2019](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2019).
+   In the installer, select the `C++ build tools`, the `Windows 10 SDK`, and the latest version of `MSVC v142 x64/x86 build tools`.
+
+
+
+
+### Dependencies
+
+**Core Library**: Zero external cryptographic dependencies! 🎉
+
+The library uses:
+- **Python stdlib**: `hashlib`, `hmac`, `os.urandom` for hashing and random number generation
+- **Pure Python**: Custom secp256k1 elliptic curve implementation
+
+**Optional Dependencies** (installed automatically):
+- `rich` - Terminal formatting for CLI
+- `typer` - CLI interface framework
+
+**Note on Ethereum Support**: 
+- Bitcoin, Litecoin, Dogecoin, Dash, Ripple: ✅ **Fully functional** with stdlib only
+- Ethereum, Tron: ⚠️ Use SHA3-256 fallback for address generation. For production Ethereum support, optionally install `pycryptodome>=3.18.0` to enable true Keccak256 hashing.
+
+### Verification
+
+Verify the library works without external crypto dependencies:
+```bash
+python verify_no_deps.py
+```
+
 ## Quick Start (Library Usage)
 
 ```python

{libcrypto-1.1.6 → libcrypto-1.2.0}/README.md

@@ -31,6 +31,50 @@ Install the library using pip:
 pip install libcrypto
 ```
 
+#### Install On Debian/Ubuntu
+```bash
+sudo apt-get install build-essential python3-dev
+pip3 install libcrypto
+```
+
+#### Install On Fedora
+```bash
+sudo yum install gcc gmp python-devel
+pip3 install libcrypto
+```
+
+#### Windows Installation
+> [!NOTE]
+> **Once only**
+>  Download [Build Tools for Visual Studio 2019](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2019).
+   In the installer, select the `C++ build tools`, the `Windows 10 SDK`, and the latest version of `MSVC v142 x64/x86 build tools`.
+
+
+
+
+### Dependencies
+
+**Core Library**: Zero external cryptographic dependencies! 🎉
+
+The library uses:
+- **Python stdlib**: `hashlib`, `hmac`, `os.urandom` for hashing and random number generation
+- **Pure Python**: Custom secp256k1 elliptic curve implementation
+
+**Optional Dependencies** (installed automatically):
+- `rich` - Terminal formatting for CLI
+- `typer` - CLI interface framework
+
+**Note on Ethereum Support**: 
+- Bitcoin, Litecoin, Dogecoin, Dash, Ripple: ✅ **Fully functional** with stdlib only
+- Ethereum, Tron: ⚠️ Use SHA3-256 fallback for address generation. For production Ethereum support, optionally install `pycryptodome>=3.18.0` to enable true Keccak256 hashing.
+
+### Verification
+
+Verify the library works without external crypto dependencies:
+```bash
+python verify_no_deps.py
+```
+
 ## Quick Start (Library Usage)
 
 ```python

{libcrypto-1.1.6 → libcrypto-1.2.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["setuptools>=61.0", "wheel"]
+requires = ["setuptools", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "libcrypto"
-version = "1.1.6"
+version = "1.2.0"
 description = "A professional library For Cryptography and Cryptocurrencies in Python."
 readme = "README.md"
 requires-python = ">=3.8"
@@ -16,7 +16,7 @@ keywords = [
     "cryptocurrency", "bitcoin", "ethereum", "wallet", "bip39", "bip32", "bip44",
     "mnemonic", "private-key", "public-key", "address", "hdwallet", "crypto",
     "blockchain", "litecoin", "dash", "dogecoin", "bitcoin-cash", "secp256k1",
-    "pycryptodome", "cryptography",
+    "cryptography", "pure-python",
 ]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -29,6 +29,8 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Security :: Cryptography",
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Office/Business :: Financial",
@@ -36,10 +38,9 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "pycryptodome>=3.23.0",
-    "rich>=14.0.0",
-    "wheel>=0.45.1",
-    "setuptools>=80.9.0",
+    "rich",
+    "wheel",
+    "setuptools",
 ]
 
 [project.optional-dependencies]

{libcrypto-1.1.6 → libcrypto-1.2.0}/setup.py

@@ -17,8 +17,8 @@ def get_long_description():
 
 setup(
     name="libcrypto",
-    version="1.1.6",
-    description="Comprehensive cryptocurrency wallet library with BIP39/BIP32 support using only pycryptodome",
+    version="1.2.0",
+    description="Comprehensive cryptocurrency wallet library with BIP39/BIP32 support using embedded cryptographic primitives",
     long_description=get_long_description(),
     long_description_content_type="text/markdown",
     author="Mmdrza",
@@ -34,9 +34,12 @@ setup(
     license="MIT",
     packages=find_packages(where="src"),
     package_dir={"": "src"},
+    include_package_data=True,
+    package_data={
+        "libcrypto.cryptod": ["**/*.py", "**/*.pyi", "**/*.so", "**/*.pyd", "**/*.dll"],
+    },
     python_requires=">=3.8",
     install_requires=[
-        "pycryptodome>=3.23.0",
         "rich>=14.0.0",
         "wheel>=0.45.1",
         "setuptools>=80.9.0",
@@ -73,10 +76,27 @@ setup(
         "Typing :: Typed",
     ],
     keywords=[
-        "cryptocurrency", "bitcoin", "ethereum", "wallet", "bip39", "bip32", "bip44",
-        "mnemonic", "private-key", "public-key", "address", "hdwallet", "crypto",
-        "blockchain", "litecoin", "dash", "dogecoin", "bitcoin-cash", "secp256k1",
-        "pycryptodome", "cryptography",
+        "cryptocurrency",
+        "bitcoin",
+        "ethereum",
+        "wallet",
+        "bip39",
+        "bip32",
+        "bip44",
+        "mnemonic",
+        "private-key",
+        "public-key",
+        "address",
+        "hdwallet",
+        "crypto",
+        "blockchain",
+        "litecoin",
+        "dash",
+        "dogecoin",
+        "bitcoin-cash",
+        "secp256k1",
+        "cryptography",
+        "pure-python",
     ],
     zip_safe=False,
     entry_points={

{libcrypto-1.1.6 → libcrypto-1.2.0}/src/libcrypto/__init__.py

@@ -30,7 +30,7 @@ from .formats import (
     InvalidFormatError
 )
 
-__version__ = "1.1.6"
+__version__ = "1.2.0"
 __all__ = [
     # Library Version
     '__version__',

libcrypto-1.2.0/src/libcrypto/cryptod/Crypto/Cipher/AES.py

@@ -0,0 +1,235 @@
+# -*- coding: utf-8 -*-
+#
+#  Cipher/AES.py : AES
+#
+# ===================================================================
+# The contents of this file are dedicated to the public domain.  To
+# the extent that dedication to the public domain is not available,
+# everyone is granted a worldwide, perpetual, royalty-free,
+# non-exclusive license to exercise all rights associated with the
+# contents of this file for any purpose whatsoever.
+# No rights are reserved.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+# ===================================================================
+
+import sys
+
+from ...Crypto.Cipher import _create_cipher
+from ...Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
+                                  VoidPointer, SmartPointer,
+                                  c_size_t, c_uint8_ptr)
+
+from ...Crypto.Util import _cpu_features
+from ...Crypto.Random import get_random_bytes
+
+MODE_ECB = 1        #: Electronic Code Book (:ref:`ecb_mode`)
+MODE_CBC = 2        #: Cipher-Block Chaining (:ref:`cbc_mode`)
+MODE_CFB = 3        #: Cipher Feedback (:ref:`cfb_mode`)
+MODE_OFB = 5        #: Output Feedback (:ref:`ofb_mode`)
+MODE_CTR = 6        #: Counter mode (:ref:`ctr_mode`)
+MODE_OPENPGP = 7    #: OpenPGP mode (:ref:`openpgp_mode`)
+MODE_CCM = 8        #: Counter with CBC-MAC (:ref:`ccm_mode`)
+MODE_EAX = 9        #: :ref:`eax_mode`
+MODE_SIV = 10       #: Synthetic Initialization Vector (:ref:`siv_mode`)
+MODE_GCM = 11       #: Galois Counter Mode (:ref:`gcm_mode`)
+MODE_OCB = 12       #: Offset Code Book (:ref:`ocb_mode`)
+MODE_KW = 13        #: Key Wrap (:ref:`kw_mode`)
+MODE_KWP = 14       #: Key Wrap with Padding (:ref:`kwp_mode`)
+
+_cproto = """
+        int AES_start_operation(const uint8_t key[],
+                                size_t key_len,
+                                void **pResult);
+        int AES_encrypt(const void *state,
+                        const uint8_t *in,
+                        uint8_t *out,
+                        size_t data_len);
+        int AES_decrypt(const void *state,
+                        const uint8_t *in,
+                        uint8_t *out,
+                        size_t data_len);
+        int AES_stop_operation(void *state);
+        """
+
+
+# Load portable AES
+_raw_aes_lib = load_pycryptodome_raw_lib("Crypto.Cipher._raw_aes",
+                                         _cproto)
+
+# Try to load AES with AES NI instructions
+try:
+    _raw_aesni_lib = None
+    if _cpu_features.have_aes_ni():
+        _raw_aesni_lib = load_pycryptodome_raw_lib("Crypto.Cipher._raw_aesni",
+                                                   _cproto.replace("AES",
+                                                                   "AESNI"))
+# _raw_aesni may not have been compiled in
+except OSError:
+    pass
+
+
+def _create_base_cipher(dict_parameters):
+    """This method instantiates and returns a handle to a low-level
+    base cipher. It will absorb named parameters in the process."""
+
+    use_aesni = dict_parameters.pop("use_aesni", True)
+
+    try:
+        key = dict_parameters.pop("key")
+    except KeyError:
+        raise TypeError("Missing 'key' parameter")
+
+    if len(key) not in key_size:
+        raise ValueError("Incorrect AES key length (%d bytes)" % len(key))
+
+    if use_aesni and _raw_aesni_lib:
+        start_operation = _raw_aesni_lib.AESNI_start_operation
+        stop_operation = _raw_aesni_lib.AESNI_stop_operation
+    else:
+        start_operation = _raw_aes_lib.AES_start_operation
+        stop_operation = _raw_aes_lib.AES_stop_operation
+
+    cipher = VoidPointer()
+    result = start_operation(c_uint8_ptr(key),
+                             c_size_t(len(key)),
+                             cipher.address_of())
+    if result:
+        raise ValueError("Error %X while instantiating the AES cipher"
+                         % result)
+    return SmartPointer(cipher.get(), stop_operation)
+
+
+def _derive_Poly1305_key_pair(key, nonce):
+    """Derive a tuple (r, s, nonce) for a Poly1305 MAC.
+
+    If nonce is ``None``, a new 16-byte nonce is generated.
+    """
+
+    if len(key) != 32:
+        raise ValueError("Poly1305 with AES requires a 32-byte key")
+
+    if nonce is None:
+        nonce = get_random_bytes(16)
+    elif len(nonce) != 16:
+        raise ValueError("Poly1305 with AES requires a 16-byte nonce")
+
+    s = new(key[:16], MODE_ECB).encrypt(nonce)
+    return key[16:], s, nonce
+
+
+def new(key, mode, *args, **kwargs):
+    """Create a new AES cipher.
+
+    Args:
+      key(bytes/bytearray/memoryview):
+        The secret key to use in the symmetric cipher.
+
+        It must be 16 (*AES-128)*, 24 (*AES-192*) or 32 (*AES-256*) bytes long.
+
+        For ``MODE_SIV`` only, it doubles to 32, 48, or 64 bytes.
+      mode (a ``MODE_*`` constant):
+        The chaining mode to use for encryption or decryption.
+        If in doubt, use ``MODE_EAX``.
+
+    Keyword Args:
+      iv (bytes/bytearray/memoryview):
+        (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
+        and ``MODE_OPENPGP`` modes).
+
+        The initialization vector to use for encryption or decryption.
+
+        For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 16 bytes long.
+
+        For ``MODE_OPENPGP`` mode only,
+        it must be 16 bytes long for encryption
+        and 18 bytes for decryption (in the latter case, it is
+        actually the *encrypted* IV which was prefixed to the ciphertext).
+
+        If not provided, a random byte string is generated (you must then
+        read its value with the :attr:`iv` attribute).
+
+      nonce (bytes/bytearray/memoryview):
+        (Only applicable for ``MODE_CCM``, ``MODE_EAX``, ``MODE_GCM``,
+        ``MODE_SIV``, ``MODE_OCB``, and ``MODE_CTR``).
+
+        A value that must never be reused for any other encryption done
+        with this key (except possibly for ``MODE_SIV``, see below).
+
+        For ``MODE_EAX``, ``MODE_GCM`` and ``MODE_SIV`` there are no
+        restrictions on its length (recommended: **16** bytes).
+
+        For ``MODE_CCM``, its length must be in the range **[7..13]**.
+        Bear in mind that with CCM there is a trade-off between nonce
+        length and maximum message size. Recommendation: **11** bytes.
+
+        For ``MODE_OCB``, its length must be in the range **[1..15]**
+        (recommended: **15**).
+
+        For ``MODE_CTR``, its length must be in the range **[0..15]**
+        (recommended: **8**).
+
+        For ``MODE_SIV``, the nonce is optional, if it is not specified,
+        then no nonce is being used, which renders the encryption
+        deterministic.
+
+        If not provided, for modes other than ``MODE_SIV``, a random
+        byte string of the recommended length is used (you must then
+        read its value with the :attr:`nonce` attribute).
+
+      segment_size (integer):
+        (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
+        are segmented in. It must be a multiple of 8.
+        If not specified, it will be assumed to be 8.
+
+      mac_len (integer):
+        (Only ``MODE_EAX``, ``MODE_GCM``, ``MODE_OCB``, ``MODE_CCM``)
+        Length of the authentication tag, in bytes.
+
+        It must be even and in the range **[4..16]**.
+        The recommended value (and the default, if not specified) is **16**.
+
+      msg_len (integer):
+        (Only ``MODE_CCM``). Length of the message to (de)cipher.
+        If not specified, ``encrypt`` must be called with the entire message.
+        Similarly, ``decrypt`` can only be called once.
+
+      assoc_len (integer):
+        (Only ``MODE_CCM``). Length of the associated data.
+        If not specified, all associated data is buffered internally,
+        which may represent a problem for very large messages.
+
+      initial_value (integer or bytes/bytearray/memoryview):
+        (Only ``MODE_CTR``).
+        The initial value for the counter. If not present, the cipher will
+        start counting from 0. The value is incremented by one for each block.
+        The counter number is encoded in big endian mode.
+
+      counter (object):
+        (Only ``MODE_CTR``).
+        Instance of ``Crypto.Util.Counter``, which allows full customization
+        of the counter block. This parameter is incompatible to both ``nonce``
+        and ``initial_value``.
+
+      use_aesni: (boolean):
+        Use Intel AES-NI hardware extensions (default: use if available).
+
+    Returns:
+        an AES object, of the applicable mode.
+    """
+
+    kwargs["add_aes_modes"] = True
+    return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
+
+
+# Size of a data block (in bytes)
+block_size = 16
+# Size of a key (in bytes)
+key_size = (16, 24, 32)

libcrypto-1.2.0/src/libcrypto/cryptod/Crypto/Cipher/AES.pyi

@@ -0,0 +1,156 @@
+from typing import Dict, Optional, Tuple, Union, overload
+from typing_extensions import Literal
+
+Buffer=bytes|bytearray|memoryview
+
+from Crypto.Cipher._mode_ecb import EcbMode
+from Crypto.Cipher._mode_cbc import CbcMode
+from Crypto.Cipher._mode_cfb import CfbMode
+from Crypto.Cipher._mode_ofb import OfbMode
+from Crypto.Cipher._mode_ctr import CtrMode
+from Crypto.Cipher._mode_openpgp import OpenPgpMode
+from Crypto.Cipher._mode_ccm import CcmMode
+from Crypto.Cipher._mode_eax import EaxMode
+from Crypto.Cipher._mode_gcm import GcmMode
+from Crypto.Cipher._mode_siv import SivMode
+from Crypto.Cipher._mode_ocb import OcbMode
+
+MODE_ECB: Literal[1]
+MODE_CBC: Literal[2]
+MODE_CFB: Literal[3]
+MODE_OFB: Literal[5]
+MODE_CTR: Literal[6]
+MODE_OPENPGP: Literal[7]
+MODE_CCM: Literal[8]
+MODE_EAX: Literal[9]
+MODE_SIV: Literal[10]
+MODE_GCM: Literal[11]
+MODE_OCB: Literal[12]
+
+# MODE_ECB
+@overload
+def new(key: Buffer,
+        mode: Literal[1],
+        use_aesni : bool = ...) -> \
+        EcbMode: ...
+
+# MODE_CBC
+@overload
+def new(key: Buffer,
+        mode: Literal[2],
+        iv : Optional[Buffer] = ...,
+        use_aesni : bool = ...) -> \
+        CbcMode: ...
+
+@overload
+def new(key: Buffer,
+        mode: Literal[2],
+        IV : Optional[Buffer] = ...,
+        use_aesni : bool = ...) -> \
+        CbcMode: ...
+
+# MODE_CFB
+@overload
+def new(key: Buffer,
+        mode: Literal[3],
+        iv : Optional[Buffer] = ...,
+        segment_size : int = ...,
+        use_aesni : bool = ...) -> \
+        CfbMode: ...
+
+@overload
+def new(key: Buffer,
+        mode: Literal[3],
+        IV : Optional[Buffer] = ...,
+        segment_size : int = ...,
+        use_aesni : bool = ...) -> \
+        CfbMode: ...
+
+# MODE_OFB
+@overload
+def new(key: Buffer,
+        mode: Literal[5],
+        iv : Optional[Buffer] = ...,
+        use_aesni : bool = ...) -> \
+        OfbMode: ...
+
+@overload
+def new(key: Buffer,
+        mode: Literal[5],
+        IV : Optional[Buffer] = ...,
+        use_aesni : bool = ...) -> \
+        OfbMode: ...
+
+# MODE_CTR
+@overload
+def new(key: Buffer,
+        mode: Literal[6],
+        nonce : Optional[Buffer] = ...,
+        initial_value : Union[int, Buffer] = ...,
+        counter : Dict = ...,
+        use_aesni : bool = ...) -> \
+        CtrMode: ...
+
+# MODE_OPENPGP
+@overload
+def new(key: Buffer,
+        mode: Literal[7],
+        iv : Optional[Buffer] = ...,
+        use_aesni : bool = ...) -> \
+        OpenPgpMode: ...
+
+@overload
+def new(key: Buffer,
+        mode: Literal[7],
+        IV : Optional[Buffer] = ...,
+        use_aesni : bool = ...) -> \
+        OpenPgpMode: ...
+
+# MODE_CCM
+@overload
+def new(key: Buffer,
+        mode: Literal[8],
+        nonce : Optional[Buffer] = ...,
+        mac_len : int = ...,
+        assoc_len : int = ...,
+        use_aesni : bool = ...) -> \
+        CcmMode: ...
+
+# MODE_EAX
+@overload
+def new(key: Buffer,
+        mode: Literal[9],
+        nonce : Optional[Buffer] = ...,
+        mac_len : int = ...,
+        use_aesni : bool = ...) -> \
+        EaxMode: ...
+
+# MODE_GCM
+@overload
+def new(key: Buffer,
+        mode: Literal[10],
+        nonce : Optional[Buffer] = ...,
+        use_aesni : bool = ...) -> \
+        SivMode: ...
+
+# MODE_SIV
+@overload
+def new(key: Buffer,
+        mode: Literal[11],
+        nonce : Optional[Buffer] = ...,
+        mac_len : int = ...,
+        use_aesni : bool = ...) -> \
+        GcmMode: ...
+
+# MODE_OCB
+@overload
+def new(key: Buffer,
+        mode: Literal[12],
+        nonce : Optional[Buffer] = ...,
+        mac_len : int = ...,
+        use_aesni : bool = ...) -> \
+        OcbMode: ...
+
+
+block_size: int
+key_size: Tuple[int, int, int]