p115cipher 0.0.1__py3-none-any.whl

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ChenyangGao <https://github.com/ChenyangGao>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.

p115cipher/__init__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python3
+# encoding: utf-8
+
+__author__ = "ChenyangGao <https://chenyanggao.github.io>"
+__version__ = (0, 0, 1)
+
+from .fast import *
+from .normal import *

p115cipher/common.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+# encoding: utf-8
+
+__author__ = "ChenyangGao <https://chenyanggao.github.io>"
+__all__ = [
+    "Buffer", "RSA_encrypt", "from_bytes", "to_bytes", 
+    "bytes_xor", "bytes_xor_reverse", "xor", "gen_key", 
+]
+
+from functools import partial
+from typing import Final
+
+from Crypto.Cipher import PKCS1_v1_5
+from Crypto.PublicKey import RSA
+from ecdsa import ECDH, NIST224p, SigningKey # type: ignore
+from iterutils import acc_step
+
+from .const import G_kts, ECDH_REMOTE_PUBKEY, NIST224P_BASELEN, RSA_PUBLIC_KEY
+
+try:
+    from collections.abc import Buffer # type: ignore
+except ImportError:
+    from abc import ABC, abstractmethod
+    from array import array
+
+    def _check_methods(C, *methods):
+        mro = C.__mro__
+        for method in methods:
+            for B in mro:
+                if method in B.__dict__:
+                    if B.__dict__[method] is None:
+                        return NotImplemented
+                    break
+            else:
+                return NotImplemented
+        return True
+
+    class Buffer(ABC): # type: ignore
+        __slots__ = ()
+
+        @abstractmethod
+        def __buffer__(self, flags: int, /) -> memoryview:
+            raise NotImplementedError
+
+        @classmethod
+        def __subclasshook__(cls, C):
+            if cls is Buffer:
+                return _check_methods(C, "__buffer__")
+            return NotImplemented
+
+    Buffer.register(bytes)
+    Buffer.register(bytearray)
+    Buffer.register(memoryview)
+    Buffer.register(array)
+
+
+RSA_encrypt: Final = PKCS1_v1_5.new(RSA_PUBLIC_KEY).encrypt
+to_bytes = partial(int.to_bytes, byteorder="big", signed=False)
+from_bytes = partial(int.from_bytes, byteorder="big", signed=False)
+
+
+def bytes_xor(v1: Buffer, v2: Buffer, /, size: int = 0) -> Buffer:
+    if size:
+        v1 = v1[:size]
+        v2 = v2[:size]
+    else:
+        size = len(v1)
+    return to_bytes(from_bytes(v1) ^ from_bytes(v2), size)
+
+
+def bytes_xor_reverse(v1: Buffer, v2: Buffer, /, size: int = 0) -> Buffer:
+    if size:
+        v1 = v1[:size]
+        v2 = v2[:size]
+    else:
+        size = len(v1)
+    return to_bytes(from_bytes(v1) ^ from_bytes(v2), size, "little")
+
+
+def xor(src: Buffer, key: Buffer, /) -> bytearray:
+    src = memoryview(src)
+    key = memoryview(key)
+    secret = bytearray()
+    if i := len(src) & 0b11:
+        secret += bytes_xor(src, key, i)
+    for i, j, s in acc_step(i, len(src), len(key)):
+        secret += bytes_xor(src[i:j], key[:s])
+    return secret
+
+
+def gen_key(
+    rand_key: Buffer, 
+    sk_len: int = 4, 
+    /, 
+) -> bytearray:
+    xor_key = bytearray()
+    if rand_key and sk_len > 0:
+        length = sk_len * (sk_len - 1)
+        index = 0
+        for i in range(sk_len):
+            x = (rand_key[i] + G_kts[index]) & 0xff
+            xor_key.append(G_kts[length] ^ x)
+            length -= sk_len
+            index += sk_len
+    return xor_key
+
+
+def generate_ecdh_pair() -> tuple[bytes, bytes]:
+    sk = SigningKey.generate(NIST224p)
+    pk = sk.verifying_key
+    ecdh = ECDH(NIST224p)
+    ecdh.load_private_key(sk)
+    ecdh.load_received_public_key_bytes(ECDH_REMOTE_PUBKEY)
+    public = pk.pubkey.point.to_bytes()
+    x, y = public[:NIST224P_BASELEN], public[NIST224P_BASELEN:]
+    pub_key = bytes((NIST224P_BASELEN + 1, 0x02 + (from_bytes(y) & 1))) + x
+    # NOTE: Roughly equivalent to
+    # n = int((ecdh.public_key.pubkey.point * from_bytes(sk.to_string())).x())
+    # secret = to_bytes(n, (n.bit_length() + 0b111) >> 3)
+    secret = ecdh.generate_sharedsecret_bytes()
+    return pub_key, secret
+

p115cipher/const.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+# encoding: utf-8
+
+__author__ = "ChenyangGao <https://chenyanggao.github.io>"
+
+from typing import Final
+
+from Crypto.PublicKey import RSA
+
+
+CRC_SALT: Final = b"^j>WD3Kr?J2gLFjD4W2y@"
+MD5_SALT: Final = b"Qclm8MGWUv59TnrR0XPg"
+ECDH_REMOTE_PUBKEY: Final = bytes((
+    0x57, 0xA2, 0x92, 0x57, 0xCD, 0x23, 0x20, 0xE5, 0xD6, 0xD1, 0x43, 0x32, 0x2F, 0xA4, 0xBB, 0x8A, 
+    0x3C, 0xF9, 0xD3, 0xCC, 0x62, 0x3E, 0xF5, 0xED, 0xAC, 0x62, 0xB7, 0x67, 0x8A, 0x89, 0xC9, 0x1A, 
+    0x83, 0xBA, 0x80, 0x0D, 0x61, 0x29, 0xF5, 0x22, 0xD0, 0x34, 0xC8, 0x95, 0xDD, 0x24, 0x65, 0x24, 
+    0x3A, 0xDD, 0xC2, 0x50, 0x95, 0x3B, 0xEE, 0xBA, 
+))
+G_key_l: Final = bytes((
+    0x78, 0x06, 0xad, 0x4c, 0x33, 0x86, 0x5d, 0x18, 0x4c, 0x01, 0x3f, 0x46, 
+))
+G_key_s: Final = bytes((0x29, 0x23, 0x21, 0x5e))
+G_kts: Final = bytes((
+    0xf0, 0xe5, 0x69, 0xae, 0xbf, 0xdc, 0xbf, 0x8a, 0x1a, 0x45, 0xe8, 0xbe, 0x7d, 0xa6, 0x73, 0xb8, 
+    0xde, 0x8f, 0xe7, 0xc4, 0x45, 0xda, 0x86, 0xc4, 0x9b, 0x64, 0x8b, 0x14, 0x6a, 0xb4, 0xf1, 0xaa, 
+    0x38, 0x01, 0x35, 0x9e, 0x26, 0x69, 0x2c, 0x86, 0x00, 0x6b, 0x4f, 0xa5, 0x36, 0x34, 0x62, 0xa6, 
+    0x2a, 0x96, 0x68, 0x18, 0xf2, 0x4a, 0xfd, 0xbd, 0x6b, 0x97, 0x8f, 0x4d, 0x8f, 0x89, 0x13, 0xb7, 
+    0x6c, 0x8e, 0x93, 0xed, 0x0e, 0x0d, 0x48, 0x3e, 0xd7, 0x2f, 0x88, 0xd8, 0xfe, 0xfe, 0x7e, 0x86, 
+    0x50, 0x95, 0x4f, 0xd1, 0xeb, 0x83, 0x26, 0x34, 0xdb, 0x66, 0x7b, 0x9c, 0x7e, 0x9d, 0x7a, 0x81, 
+    0x32, 0xea, 0xb6, 0x33, 0xde, 0x3a, 0xa9, 0x59, 0x34, 0x66, 0x3b, 0xaa, 0xba, 0x81, 0x60, 0x48, 
+    0xb9, 0xd5, 0x81, 0x9c, 0xf8, 0x6c, 0x84, 0x77, 0xff, 0x54, 0x78, 0x26, 0x5f, 0xbe, 0xe8, 0x1e, 
+    0x36, 0x9f, 0x34, 0x80, 0x5c, 0x45, 0x2c, 0x9b, 0x76, 0xd5, 0x1b, 0x8f, 0xcc, 0xc3, 0xb8, 0xf5, 
+))
+RSA_PRIVATE_KEY: Final = RSA.construct((
+    0x8C81424BC166F4918756E9F7B22EFAA03479B081E61896872CB7C51C910D7EC1A4CE2871424D5C9149BD5E08A25959A19AD3C981E6512EFDAB2BB8DA3F1E315C294BD117A9FB9D8CE8E633B4962E087C629DC6CA3A149214B4091EF2B0363CB3AE6C7EE702377F055ED3CD93F6C342256A76554BBEA7F203437BBE65F2DA2741,
+    0x10001, 
+    0x3704DAB00D80C25E464FFB785A16D95F688D0A5823811758C16308D5A1DB55FA800D967A9B4AEDE79AA783ADFFDCDB23541C80B8D436901F172B1CCCA190B224DBE777BF18B96DD9A30AACE8780350793A4F90A645A7747EF695622EADBE23A4C6D88F22E87842B43B35486C2D1B5B1FA77DB3528B0910CA84EDB7A46AFDBED1, 
+))
+RSA_PUBLIC_KEY: Final = RSA.construct((
+    0x8686980c0f5a24c4b9d43020cd2c22703ff3f450756529058b1cf88f09b8602136477198a6e2683149659bd122c33592fdb5ad47944ad1ea4d36c6b172aad6338c3bb6ac6227502d010993ac967d1aef00f0c8e038de2e4d3bc2ec368af2e9f10a6f1eda4f7262f136420c07c331b871bf139f74f3010e3c4fe57df3afb71683, 
+    0x10001, 
+))
+RSA_PUBLIC_KEY_e = RSA_PUBLIC_KEY.e
+RSA_PUBLIC_KEY_n = RSA_PUBLIC_KEY.n
+AES_KEY: bytes = b"\xfb\x1a\x19\xd6R\xf5\xaa\xf7\xbce\x1d\x0fi\xbfB/"
+AES_IV: bytes  = b"i\xbfB/I\x96\x05P\xa0\xadD\xec4F\xcbL"
+
+NIST224P_BASELEN: Final = 28
+RSA_BLOCK_SIZE: Final = RSA_PUBLIC_KEY.size_in_bytes()
+RSA_KEY_SIZE: Final = RSA_BLOCK_SIZE // 8
+

p115cipher/fast.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+# encoding: utf-8
+
+__author__ = "ChenyangGao <https://chenyanggao.github.io>"
+__all__ = ["rsa_encode", "rsa_decode", "ecdh_aes_encode", "ecdh_aes_decode", "ecdh_encode_token"]
+
+from base64 import b64decode, b64encode
+from binascii import crc32
+
+from iterutils import acc_step
+from lz4.block import decompress as lz4_block_decompress # type: ignore
+from Crypto.Cipher import AES
+
+from .const import RSA_PUBLIC_KEY, RSA_PUBLIC_KEY_e, RSA_PUBLIC_KEY_n, AES_KEY, AES_IV
+from .common import Buffer, RSA_encrypt, gen_key, from_bytes, to_bytes, xor
+
+
+def rsa_encode(data: Buffer, /) -> bytes:
+    "把数据用 RSA 公钥加密"
+    xor_text: Buffer = bytearray(16)
+    tmp = memoryview(xor(data, b"\x8d\xa5\xa5\x8d"))[::-1]
+    xor_text += xor(tmp, b"x\x06\xadL3\x86]\x18L\x01?F")
+    cipher_data = bytearray()
+    xor_text = memoryview(xor_text)
+    for l, r, _ in acc_step(0, len(xor_text), 117):
+        cipher_data += RSA_encrypt(xor_text[l:r])
+    return b64encode(cipher_data)
+
+
+def rsa_decode(cipher_data: Buffer, /) -> bytearray:
+    "把数据用 RSA 公钥解密"
+    cipher_data = memoryview(b64decode(cipher_data))
+    data = bytearray()
+    for l, r, _ in acc_step(0, len(cipher_data), 128):
+        p = pow(from_bytes(cipher_data[l:r]), RSA_PUBLIC_KEY_e, RSA_PUBLIC_KEY_n)
+        b = to_bytes(p, (p.bit_length() + 0b111) >> 3)
+        data += memoryview(b)[b.index(0)+1:]
+    m = memoryview(data)
+    key_l = gen_key(m[:16], 12)
+    tmp = memoryview(xor(m[16:], key_l))[::-1]
+    return xor(tmp, b"\x8d\xa5\xa5\x8d")
+
+
+def ecdh_aes_encode(data: Buffer, /) -> bytes:
+    "用 AES 加密数据，密钥由 ECDH 生成"
+    pad_size = -len(data) & 15
+    return AES.new(AES_KEY, 2, AES_IV).encrypt(
+        data + to_bytes(pad_size) * pad_size)
+
+
+def ecdh_aes_decode(cipher_data: Buffer, /, decompress: bool = False) -> Buffer:
+    "用 AES 解密数据，密钥由 ECDH 生成"
+    data = AES.new(AES_KEY, 2, AES_IV).decrypt(
+        memoryview(cipher_data)[:len(cipher_data) & -16])
+    data = memoryview(data)
+    if decompress:
+        size = data[0] + (data[1] << 8)
+        data = lz4_block_decompress(data[2:size+2], 0x2000)
+    else:
+        padding = data[-1]
+        if data[-padding:] == bytes(data[-1:]) * padding:
+            data = data[:-padding]
+    return data
+
+
+def ecdh_encode_token(timestamp: int, /) -> bytes:
+    "用时间戳生成 token，并包含由 ECDH 生成的公钥"
+    token = bytearray()
+    token += b"\x1d\x03\x0e\x80\xa1x\xdc\xee\xce\xcd\xa3w\xde\x12\x8d\x00s\x00\x00\x00"
+    token += to_bytes(timestamp, 4, "little")
+    token += b"\x8e\xd9\xdd\xcfU\xaea\xedF\xea\x12\x1a\x1c\xfc\x81\x00\x01\x00\x00\x00"
+    token += to_bytes(crc32(b"^j>WD3Kr?J2gLFjD4W2y@" + token), 4, "little")
+    return b64encode(token)
+

p115cipher/normal.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+# encoding: utf-8
+
+__author__ = "ChenyangGao <https://chenyanggao.github.io>"
+__all__ = ["P115RSACipher", "P115ECDHCipher"]
+
+from base64 import b64decode, b64encode
+from binascii import crc32
+from itertools import pairwise
+from random import randrange
+
+from lz4.block import decompress as lz4_block_decompress # type: ignore
+from Crypto import Random
+from Crypto.Cipher import AES
+
+from .const import G_key_l, CRC_SALT, RSA_PUBLIC_KEY_e, RSA_PUBLIC_KEY_n, RSA_BLOCK_SIZE, RSA_KEY_SIZE
+from .common import Buffer, RSA_encrypt, gen_key, from_bytes, to_bytes, xor, generate_ecdh_pair
+
+
+class P115RSACipher:
+
+    def __init__(self, /):
+        self.rand_key: bytes = Random.new().read(RSA_KEY_SIZE)
+        self.key: bytes = gen_key(self.rand_key)
+
+    def encode(self, text: bytes | bytearray | str, /) -> bytes:
+        if isinstance(text, str):
+            text = bytes(text, "utf-8")
+        tmp = xor(text, self.key)[::-1]
+        xor_text = self.rand_key + xor(tmp, G_key_l)
+        block_size = RSA_BLOCK_SIZE - 11
+        cipher_text = bytearray()
+        for l, r in pairwise(range(0, len(xor_text) + block_size, block_size)):
+            cipher_text += RSA_encrypt(xor_text[l:r])
+        return b64encode(cipher_text)
+
+    def decode(self, cipher_text: bytes | bytearray | str, /) -> bytes:
+        cipher_text = b64decode(cipher_text)
+        text = bytearray()
+        for l, r in pairwise(range(0, len(cipher_text) + RSA_BLOCK_SIZE, RSA_BLOCK_SIZE)):
+            n = from_bytes(cipher_text[l:r])
+            m = pow(n, RSA_PUBLIC_KEY_e, RSA_PUBLIC_KEY_n)
+            b = to_bytes(m, (m.bit_length() + 0b111) >> 3)
+            text += b[b.index(0)+1:]
+        rand_key = text[0:RSA_KEY_SIZE]
+        text = text[RSA_KEY_SIZE:]
+        key_l = gen_key(rand_key, 12)
+        tmp = xor(text, key_l)[::-1]
+        return bytes(xor(tmp, self.key))
+
+
+class P115ECDHCipher:
+
+    def __init__(self):
+        pub_key, secret = generate_ecdh_pair()
+        self.pub_key: bytes = pub_key
+        # NOTE: use AES-128
+        self.aes_key: bytes = secret[:16]
+        self.aes_iv: bytes  = secret[-16:]
+
+    def encode(self, text: bytes | bytearray | str, /) -> bytes:
+        "加密数据"
+        if isinstance(text, str):
+            text = bytes(text, "utf-8")
+        pad_size = 16 - (len(text) & 15)
+        return AES.new(self.aes_key, AES.MODE_CBC, self.aes_iv).encrypt(
+            text + to_bytes(pad_size) * pad_size)
+
+    def decode(
+        self, 
+        cipher_text: bytes | bytearray, 
+        /, 
+        decompress: bool = False, 
+    ) -> bytes:
+        "解密数据"
+        data = AES.new(self.aes_key, AES.MODE_CBC, self.aes_iv).decrypt(
+            cipher_text[:len(cipher_text) & -16])
+        if decompress:
+            size = data[0] + (data[1] << 8)
+            data = lz4_block_decompress(data[2:size+2], 0x2000)
+        else:
+            padding = data[-1]
+            if all(c == padding for c in data[-padding:]):
+                data = data[:-padding]
+        return data
+
+    def encode_token(self, /, timestamp: int) -> bytes:
+        "接受一个时间戳（单位是秒），返回一个 token，会把 pub_key 和 timestamp 都编码在内"
+        r1, r2 = randrange(256), randrange(256)
+        token = bytearray()
+        ts = to_bytes(timestamp, (timestamp.bit_length() + 0b111) >> 3)
+        if isinstance(self, P115ECDHCipher):
+            pub_key = self.pub_key
+        else:
+            pub_key = self
+        token.extend(pub_key[i]^r1 for i in range(15))
+        token.append(r1)
+        token.append(0x73^r1)
+        token.extend((r1,)*3)
+        token.extend(r1^ts[3-i] for i in range(4))
+        token.extend(pub_key[i]^r2 for i in range(15, len(pub_key)))
+        token.append(r2)
+        token.append(0x01^r2)
+        token.extend((r2,)*3)
+        crc = crc32(CRC_SALT+token) & 0xffffffff
+        h_crc32 = to_bytes(crc, 4)
+        token.extend(h_crc32[3-i] for i in range(4))
+        return b64encode(token)
+
+    @staticmethod
+    def decode_token(data: str | bytes) -> tuple[bytes, int]:
+        "解密 token 数据，返回 pub_key 和 timestamp 的元组"
+        data = b64decode(data)
+        r1 = data[15]
+        r2 = data[39]
+        return (
+            bytes(c ^ r1 for c in data[:15]) + bytes(c ^ r2 for c in data[24:39]), 
+            from_bytes(bytes(i ^ r1 for i in data[20:24]), byteorder="little"), 
+        )
+

p115cipher-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ChenyangGao <https://github.com/ChenyangGao>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.

p115cipher-0.0.1.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.1
+Name: p115cipher
+Version: 0.0.1
+Summary: 115 cipher module.
+Home-page: https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/p115cipher
+License: MIT
+Keywords: 115,webdisk,cipher
+Author: ChenyangGao
+Author-email: wosiwujm@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: ecdsa
+Requires-Dist: lz4
+Requires-Dist: pycryptodome
+Requires-Dist: python-iterutils (>=0.0.7)
+Project-URL: Repository, https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/p115cipher
+Description-Content-Type: text/markdown
+
+# 115 cipher module
+
+## Installation
+
+You can install via [pypi](https://pypi.org/project/cipher115/)
+
+```console
+pip install -U cipher115
+```
+
+## Usage
+
+```python
+from cipher115.fast import *
+from cipher115.normal import *
+```
+

p115cipher-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+p115cipher/__init__.py,sha256=eCP8DTS9BexYsm6MVxaPfsKN-6uSCWj6qEaMUSrMOIg,168
+p115cipher/common.py,sha256=I5uf-2qER5OR7a9x_0rMZRJ7jtJnAfzCRlD6Crf9NYY,3547
+p115cipher/const.py,sha256=ZT_KIx7D-bCW8ohh9BNVcDkn8cGdXYs--UAAqBdpfdo,2969
+p115cipher/fast.py,sha256=miqtHWGfAGQp-feGOLPwqCcn5TsXRFurF7jfkc-PsQg,2778
+p115cipher/normal.py,sha256=hyznPhRsGHbnfMglBVXGq3xBry0ofBpQurOevpcZ6m0,4402
+p115cipher/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+p115cipher-0.0.1.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+p115cipher-0.0.1.dist-info/METADATA,sha256=2oaZTNMiKqh9OK-ipkwSeGZ9MaZM7b6Haa8u2OaPMo4,1454
+p115cipher-0.0.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+p115cipher-0.0.1.dist-info/RECORD,,

p115cipher-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.8.1
+Root-Is-Purelib: true
+Tag: py3-none-any