PythonSTB
/

pypi312

@@ -1,512 +0,0 @@
-"""
-On-device verification for the cross-compiled cryptography + cffi wheels.
-Run after installing:
-    pip install pycparser-2.22-py2.py3-none-any.whl
-    pip install cffi-2.1.1-cp312-cp312-android_24_<ABI>.whl
-    pip install cryptography-50.0.0-cp312-abi3-android_24_<ABI>.whl
-Usage:
-    python test_crypto_on_device.py [--quick]
-Exit code 0 = everything required PASSed.
-Sections marked [SKIP] are features the bundled OpenSSL 3.2.1 does not
-provide (e.g. post-quantum ML-KEM/ML-DSA) and are informational only.
-Generated by RIMI
-"""
-import sys
-import traceback
-RESULTS = []
-def test(name, fn):
-    try:
-        fn()
-        RESULTS.append((name, "PASS", None))
-    except NotImplementedError as exc:
-        RESULTS.append((name, "SKIP", str(exc)))
-    except Exception as exc:
-        RESULTS.append((name, "FAIL", "%s: %s" % (type(exc).__name__, exc)))
-        print("    ! %s -> %s: %s" % (name, type(exc).__name__, exc))
-def section(title):
-    print("=" * 60)
-    print(title)
-    print("=" * 60)
-# ---------------------------------------------------------------------------
-# 1. cryptography import surface
-# ---------------------------------------------------------------------------
-def imports_core():
-    import cryptography
-    assert cryptography.__version__ == "50.0.0", cryptography.__version__
-    import cryptography.hazmat.bindings._rust  # noqa: F401  (the .so extension)
-    import cryptography.exceptions  # noqa: F401
-    import cryptography.utils  # noqa: F401
-    import cryptography.fernet  # noqa: F401
-    import cryptography.cobblestone  # noqa: F401
-def imports_bindings():
-    import cryptography.hazmat.backends.openssl.backend  # noqa: F401
-    import cryptography.hazmat.bindings.openssl._conditional  # noqa: F401
-    import cryptography.hazmat.bindings.openssl.binding  # noqa: F401
-    import cryptography.hazmat.bindings._rust  # noqa: F401
-def imports_primitives():
-    import cryptography.hazmat.primitives.hashes  # noqa: F401
-    import cryptography.hazmat.primitives.hmac  # noqa: F401
-    import cryptography.hazmat.primitives.cmac  # noqa: F401
-    import cryptography.hazmat.primitives.ciphers  # noqa: F401
-    import cryptography.hazmat.primitives.ciphers.aead  # noqa: F401
-    import cryptography.hazmat.primitives.padding  # noqa: F401
-    import cryptography.hazmat.primitives.constant_time  # noqa: F401
-    import cryptography.hazmat.primitives.keywrap  # noqa: F401
-    import cryptography.hazmat.primitives.poly1305  # noqa: F401
-    import cryptography.hazmat.primitives.hpke  # noqa: F401
-    import cryptography.hazmat.primitives.kdf.hkdf  # noqa: F401
-    import cryptography.hazmat.primitives.kdf.pbkdf2  # noqa: F401
-    import cryptography.hazmat.primitives.kdf.scrypt  # noqa: F401
-    import cryptography.hazmat.primitives.kdf.kbkdf  # noqa: F401
-    import cryptography.hazmat.primitives.kdf.concatkdf  # noqa: F401
-    import cryptography.hazmat.primitives.kdf.x963kdf  # noqa: F401
-    import cryptography.hazmat.primitives.serialization  # noqa: F401
-    import cryptography.hazmat.primitives.serialization.pkcs7  # noqa: F401
-    import cryptography.hazmat.primitives.serialization.pkcs12  # noqa: F401
-    import cryptography.hazmat.primitives.serialization.ssh  # noqa: F401
-    import cryptography.hazmat.primitives.twofactor.hotp  # noqa: F401
-    import cryptography.hazmat.primitives.twofactor.totp  # noqa: F401
-def imports_asymmetric():
-    import cryptography.hazmat.primitives.asymmetric.rsa  # noqa: F401
-    import cryptography.hazmat.primitives.asymmetric.ec  # noqa: F401
-    import cryptography.hazmat.primitives.asymmetric.dsa  # noqa: F401
-    import cryptography.hazmat.primitives.asymmetric.dh  # noqa: F401
-    import cryptography.hazmat.primitives.asymmetric.ed25519  # noqa: F401
-    import cryptography.hazmat.primitives.asymmetric.ed448  # noqa: F401
-    import cryptography.hazmat.primitives.asymmetric.x25519  # noqa: F401
-    import cryptography.hazmat.primitives.asymmetric.x448  # noqa: F401
-    import cryptography.hazmat.primitives.asymmetric.padding  # noqa: F401
-    import cryptography.hazmat.primitives.asymmetric.utils  # noqa: F401
-def imports_x509():
-    import cryptography.x509  # noqa: F401
-    import cryptography.x509.base  # noqa: F401
-    import cryptography.x509.extensions  # noqa: F401
-    import cryptography.x509.general_name  # noqa: F401
-    import cryptography.x509.name  # noqa: F401
-    import cryptography.x509.ocsp  # noqa: F401
-    import cryptography.x509.oid  # noqa: F401
-    import cryptography.x509.verification  # noqa: F401
-    import cryptography.x509.certificate_transparency  # noqa: F401
-# ---------------------------------------------------------------------------
-# 2. hashes / hmac / cmac
-# ---------------------------------------------------------------------------
-def hashes():
-    from cryptography.hazmat.primitives import hashes
-    d = hashes.Hash(hashes.SHA256())
-    d.update(b"hello cryptography")
-    assert d.finalize().hex() == (
-        "a301dc0ba3af7e81df0d99b6b37c4ffca866cb2ee44058bb76158db3b59d02b9"
-    ), "SHA256 mismatch"
-def sha512():
-    from cryptography.hazmat.primitives import hashes
-    d = hashes.Hash(hashes.SHA512())
-    d.update(b"abc")
-    h = d.finalize().hex()
-    assert h.startswith("ddaf35a193617aba"), "SHA512 mismatch"
-def sha3_and_blake2():
-    from cryptography.hazmat.primitives import hashes
-    for cls in (hashes.SHA3_256, hashes.SHA3_512):
-        d = hashes.Hash(cls())
-        d.update(b"data")
-        assert len(d.finalize()) == d.algorithm.digest_size
-    d = hashes.Hash(hashes.BLAKE2b(digest_size=64))
-    d.update(b"data")
-    assert len(d.finalize()) == 64
-    d = hashes.Hash(hashes.SHA256())
-    d.update(b"x")
-    assert len(d.finalize()) == 32
-def hmac_():
-    from cryptography.hazmat.primitives import hashes, hmac
-    h = hmac.HMAC(b"key", hashes.SHA256())
-    h.update(b"message")
-    assert len(h.finalize()) == 32
-def cmac():
-    from cryptography.hazmat.primitives import cmac
-    from cryptography.hazmat.primitives.ciphers import algorithms
-    c = cmac.CMAC(algorithms.AES(b"0" * 16))
-    c.update(b"msg")
-    assert len(c.finalize()) == 16
-# ---------------------------------------------------------------------------
-# 3. symmetric ciphers
-# ---------------------------------------------------------------------------
-def aes_gcm():
-    from cryptography.hazmat.primitives.ciphers.aead import AESGCM
-    key = bytes(range(32))
-    nonce = b"123456789012"
-    ct = AESGCM(key).encrypt(nonce, b"secret message", b"aad")
-    pt = AESGCM(key).decrypt(nonce, ct, b"aad")
-    assert pt == b"secret message"
-def aes_cbc():
-    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-    cipher = Cipher(algorithms.AES(b"0" * 16), modes.CBC(b"0" * 16))
-    enc = cipher.encryptor()
-    ct = enc.update(b"0123456789abcdef") + enc.finalize()
-    cipher2 = Cipher(algorithms.AES(b"0" * 16), modes.CBC(b"0" * 16))
-    dec = cipher2.decryptor()
-    assert dec.update(ct) + dec.finalize() == b"0123456789abcdef"
-def chacha20_poly1305():
-    from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305
-    key = bytes(range(32))
-    nonce = b"123456789012"
-    ct = ChaCha20Poly1305(key).encrypt(nonce, b"hello", None)
-    assert ChaCha20Poly1305(key).decrypt(nonce, ct, None) == b"hello"
-def padding_():
-    from cryptography.hazmat.primitives import padding
-    p = padding.PKCS7(128).padder()
-    data = p.update(b"1234") + p.finalize()
-    u = padding.PKCS7(128).unpadder()
-    assert u.update(data) + u.finalize() == b"1234"
-def keywrap_():
-    from cryptography.hazmat.primitives.keywrap import aes_key_wrap, aes_key_unwrap
-    kek = b"0" * 16
-    wrapped = aes_key_wrap(kek, b"1" * 24)
-    assert aes_key_unwrap(kek, wrapped) == b"1" * 24
-# ---------------------------------------------------------------------------
-# 4. asymmetric
-# ---------------------------------------------------------------------------
-def rsa_sign_verify():
-    from cryptography.hazmat.primitives import hashes, serialization
-    from cryptography.hazmat.primitives.asymmetric import padding, rsa
-    key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
-    sig = key.sign(b"data", padding.PKCS1v15(), hashes.SHA256())
-    key.public_key().verify(sig, b"data", padding.PKCS1v15(), hashes.SHA256())
-    pub_pem = key.public_key().public_bytes(
-        serialization.Encoding.PEM,
-        serialization.PublicFormat.SubjectPublicKeyInfo,
-    )
-    loaded = serialization.load_pem_public_key(pub_pem)
-    loaded.verify(sig, b"data", padding.PKCS1v15(), hashes.SHA256())
-    priv_pem = key.private_bytes(
-        serialization.Encoding.PEM,
-        serialization.PrivateFormat.PKCS8,
-        serialization.NoEncryption(),
-    )
-    assert serialization.load_pem_private_key(priv_pem, None) is not None
-def rsa_oaep():
-    from cryptography.hazmat.primitives import hashes
-    from cryptography.hazmat.primitives.asymmetric import padding, rsa
-    key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
-    ct = key.public_key().encrypt(
-        b"top secret", padding.OAEP(mgf=padding.MGF1(hashes.SHA256()),
-                                    algorithm=hashes.SHA256(), label=None)
-    )
-    assert key.decrypt(ct, padding.OAEP(mgf=padding.MGF1(hashes.SHA256()),
-                                        algorithm=hashes.SHA256(),
-                                        label=None)) == b"top secret"
-def ec_():
-    from cryptography.hazmat.primitives import hashes
-    from cryptography.hazmat.primitives.asymmetric import ec
-    key = ec.generate_private_key(ec.SECP256R1())
-    sig = key.sign(b"msg", ec.ECDSA(hashes.SHA256()))
-    key.public_key().verify(sig, b"msg", ec.ECDSA(hashes.SHA256()))
-def ed25519_():
-    from cryptography.hazmat.primitives.asymmetric import ed25519
-    key = ed25519.Ed25519PrivateKey.generate()
-    sig = key.sign(b"msg")
-    key.public_key().verify(sig, b"msg")
-def ed448_():
-    from cryptography.hazmat.primitives.asymmetric import ed448
-    key = ed448.Ed448PrivateKey.generate()
-    sig = key.sign(b"msg")
-    key.public_key().verify(sig, b"msg")
-def x25519_():
-    from cryptography.hazmat.primitives.asymmetric import x25519
-    a = x25519.X25519PrivateKey.generate()
-    b = x25519.X25519PrivateKey.generate()
-    sa = a.exchange(b.public_key())
-    sb = b.exchange(a.public_key())
-    assert sa == sb
-def x448_():
-    from cryptography.hazmat.primitives.asymmetric import x448
-    a = x448.X448PrivateKey.generate()
-    b = x448.X448PrivateKey.generate()
-    assert a.exchange(b.public_key()) == b.exchange(a.public_key())
-def dh_():
-    from cryptography.hazmat.primitives.asymmetric import dh
-    params = dh.generate_parameters(generator=2, key_size=2048)
-    a = params.generate_private_key()
-    b = params.generate_private_key()
-    assert a.exchange(b.public_key()) == b.exchange(a.public_key())
-def dsa_():
-    from cryptography.hazmat.primitives import hashes
-    from cryptography.hazmat.primitives.asymmetric import dsa
-    key = dsa.generate_private_key(key_size=2048)
-    sig = key.sign(b"m", hashes.SHA256())
-    key.public_key().verify(sig, b"m", hashes.SHA256())
-# ---------------------------------------------------------------------------
-# 5. KDF / password hashing
-# ---------------------------------------------------------------------------
-def hkdf_():
-    from cryptography.hazmat.primitives import hashes
-    from cryptography.hazmat.primitives.kdf.hkdf import HKDF
-    k = HKDF(algorithm=hashes.SHA256(), length=32, salt=None, info=b"i").derive(b"pw")
-    assert len(k) == 32
-def pbkdf2_():
-    from cryptography.hazmat.primitives import hashes
-    from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
-    k = PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=b"s", iterations=1000).derive(b"pw")
-    assert len(k) == 32
-def scrypt_():
-    from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
-    k = Scrypt(salt=b"salt", length=32, n=2**14, r=8, p=1).derive(b"pw")
-    assert len(k) == 32
-# ---------------------------------------------------------------------------
-# 6. x509
-# ---------------------------------------------------------------------------
-def x509_selfsigned():
-    import datetime
-    from cryptography import x509
-    from cryptography.hazmat.primitives import hashes, serialization
-    from cryptography.hazmat.primitives.asymmetric import ec
-    from cryptography.x509.oid import NameOID
-    key = ec.generate_private_key(ec.SECP256R1())
-    name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "test")])
-    now = datetime.datetime.now(datetime.timezone.utc)
-    cert = (
-        x509.CertificateBuilder()
-        .subject_name(name)
-        .issuer_name(name)
-        .public_key(key.public_key())
-        .serial_number(x509.random_serial_number())
-        .not_valid_before(now - datetime.timedelta(days=1))
-        .not_valid_after(now + datetime.timedelta(days=1))
-        .add_extension(x509.BasicConstraints(ca=True, path_length=None), critical=True)
-        .sign(key, hashes.SHA256())
-    )
-    pem = cert.public_bytes(serialization.Encoding.PEM)
-    loaded = x509.load_pem_x509_certificate(pem)
-    assert loaded.subject == name
-    loaded.public_key().verify(
-        cert.signature, cert.tbs_certificate_bytes,
-        ec.ECDSA(hashes.SHA256()),
-    )
-# ---------------------------------------------------------------------------
-# 7. fernet
-# ---------------------------------------------------------------------------
-def fernet_():
-    from cryptography.fernet import Fernet
-    f = Fernet(Fernet.generate_key())
-    t = f.encrypt(b"payload")
-    assert f.decrypt(t) == b"payload"
-# ---------------------------------------------------------------------------
-# 8. cffi
-# ---------------------------------------------------------------------------
-def cffi_import():
-    import _cffi_backend
-    import cffi
-    assert cffi.__version__ == "2.1.1", cffi.__version__
-    # backend version must match the cffi package version
-    assert getattr(_cffi_backend, "__version__", None) in (None, "2.1.1")
-def _open_libc(ffi):
-    import ctypes.util
-    for name in ("libc.so", "libc.so.6", "c"):
-        try:
-            return ffi.dlopen(name)
-        except OSError:
-            continue
-    found = ctypes.util.find_library("c")
-    if found:
-        return ffi.dlopen(found)
-    raise NotImplementedError("no libc available on this platform")
-def cffi_libc_call():
-    import cffi
-    ffi = cffi.FFI()
-    ffi.cdef("size_t strlen(const char *s);")
-    lib = _open_libc(ffi)
-    s = ffi.new("char[]", b"android-cffi")
-    n = lib.strlen(s)
-    assert n == 12, n
-def cffi_abi_mode():
-    import cffi
-    ffi = cffi.FFI()
-    ffi.cdef("int abs(int x);")
-    lib = _open_libc(ffi)
-    assert lib.abs(-5) == 5
-def cffi_struct():
-    import cffi
-    ffi = cffi.FFI()
-    ffi.cdef(
-        "typedef struct { int x; int y; } point_t; "
-        "point_t make_point(int x, int y);"
-    )
-    # use ABI mode call into a trivial function we link ourselves via ctypes-free
-    # path is not available, so just validate the type machinery and FFI().new()
-    p = ffi.new("point_t*")
-    p.x = 3
-    p.y = 4
-    assert p.x == 3 and p.y == 4
-def cffi_callback():
-    import cffi
-    ffi = cffi.FFI()
-    ffi.cdef("typedef int (*cb_t)(int);")
-    calls = []
-    cb = ffi.callback("int(int)", lambda n: (calls.append(n), n + 1)[1])
-    assert cb(10) == 11
-    assert calls == [10]
-# ---------------------------------------------------------------------------
-def main():
-    quick = "--quick" in sys.argv
-    section("1. cryptography imports (full surface)")
-    test("import core (version + _rust.so + fernet)", imports_core)
-    test("import bindings/backends", imports_bindings)
-    test("import primitives", imports_primitives)
-    test("import asymmetric", imports_asymmetric)
-    test("import x509", imports_x509)
-    section("2. hashes / hmac / cmac")
-    test("SHA256", hashes)
-    test("SHA512", sha512)
-    test("SHA3 / BLAKE2", sha3_and_blake2)
-    test("HMAC", hmac_)
-    test("CMAC", cmac)
-    section("3. symmetric ciphers")
-    test("AES-GCM", aes_gcm)
-    test("AES-CBC", aes_cbc)
-    test("ChaCha20-Poly1305", chacha20_poly1305)
-    test("PKCS7 padding", padding_)
-    test("AES keywrap", keywrap_)
-    section("4. asymmetric")
-    test("RSA sign/verify + PEM roundtrip", rsa_sign_verify)
-    test("RSA-OAEP", rsa_oaep)
-    test("EC P-256", ec_)
-    test("Ed25519", ed25519_)
-    test("Ed448", ed448_)
-    test("X25519 key exchange", x25519_)
-    test("X448 key exchange", x448_)
-    test("DH", dh_)
-    test("DSA", dsa_)
-    section("5. KDF")
-    test("HKDF", hkdf_)
-    test("PBKDF2", pbkdf2_)
-    test("scrypt", scrypt_)
-    section("6. X.509")
-    test("self-signed cert build+parse+verify", x509_selfsigned)
-    section("7. Fernet")
-    test("Fernet encrypt/decrypt", fernet_)
-    section("8. cffi")
-    test("cffi import (backend version match)", cffi_import)
-    test("cffi dlopen libc + strlen", cffi_libc_call)
-    test("cffi ABI mode abs()", cffi_abi_mode)
-    test("cffi struct", cffi_struct)
-    test("cffi callback", cffi_callback)
-    print()
-    print("=" * 60)
-    print("SUMMARY")
-    print("=" * 60)
-    fails = 0
-    skips = 0
-    for name, status, why in RESULTS:
-        mark = "  OK" if status == "PASS" else (" SKIP" if status == "SKIP" else "FAIL")
-        print("%s %s" % (mark, name))
-        if why:
-            print("        -> %s" % why)
-        if status == "FAIL":
-            fails += 1
-        elif status == "SKIP":
-            skips += 1
-    print()
-    passed = len(RESULTS) - fails - skips
-    print("passed=%d skipped=%d failed=%d" % (passed, skips, fails))
-    if fails:
-        print("RESULT: FAILED")
-    elif skips and not quick:
-        print("RESULT: PASSED (with informational skips)")
-    else:
-        print("RESULT: PASSED")
-    sys.exit(1 if fails else 0)
-if __name__ == "__main__":
-    main()