feat: 大规模扩充至212个模块/175K行代码 — 覆盖android/java/javax/org/dalvik全包

- android/ 167个模块 (app/content/os/view/widget/graphics/media/hardware/net/telephony/provider等)
- java/ 35个模块 (lang/io/util/net/nio/security/crypto/sql/beans/rmi/awt等)
- javax/ 4个模块 (net/crypto/security/sql)
- org/ 5个模块 (json/w3c_dom/xml_sax/xml_pull/apache_http)
- dalvik/ 1个模块 (system)
- ~3053个类/接口，方法签名完全对齐Android SDK
- 桌面跨平台运行 (Windows/macOS/Linux)
- 修复所有导入错误和Python关键字冲突

android_pyapi/javax/net.py

@@ -0,0 +1,785 @@
+"""
+Java javax.net APIs implemented in Python.
+javax.net package - SocketFactory, SSLServerSocket, SSLSocket, SSLContext, etc.
+Wraps Python ssl module.
+"""
+
+from __future__ import annotations
+
+from .._core import Stub, AndroidOnlyError
+import ssl as _ssl
+import socket as _socket
+import threading as _threading
+from typing import List, Optional
+
+__all__ = [
+    "ServerSocketFactory", "SocketFactory", "SSLServerSocketFactory",
+    "SSLSocketFactory", "SSLServerSocket", "SSLSocket",
+    "HandshakeCompletedEvent", "HandshakeCompletedListener",
+    "HostnameVerifier", "HttpsURLConnection",
+    "TrustManager", "X509TrustManager", "KeyManager", "X509KeyManager",
+    "TrustManagerFactory", "KeyManagerFactory", "SSLContext",
+]
+
+
+# ============================================================
+# SocketFactory
+# ============================================================
+
+class SocketFactory(Stub):
+    """
+    javax.net.SocketFactory
+    Factory for creating sockets.
+    """
+
+    _default = None
+
+    @classmethod
+    def getDefault(cls) -> "SocketFactory":
+        if cls._default is None:
+            cls._default = SocketFactory()
+        return cls._default
+
+    def createSocket(self, host: str = None, port: int = None,
+                     host_inet: Any = None, local_port: int = None,
+                     stream: bool = True) -> _socket.socket:
+        """Creates a socket."""
+        sock = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM)
+        if host and port is not None:
+            sock.connect((host, port))
+        return sock
+
+    def toString(self) -> str:
+        return f"SocketFactory@{hex(id(self))}"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# ServerSocketFactory
+# ============================================================
+
+class ServerSocketFactory(Stub):
+    """
+    javax.net.ServerSocketFactory
+    Factory for creating server sockets.
+    """
+
+    _default = None
+
+    @classmethod
+    def getDefault(cls) -> "ServerSocketFactory":
+        if cls._default is None:
+            cls._default = ServerSocketFactory()
+        return cls._default
+
+    def createServerSocket(self, port: int = 0, backlog: int = 50,
+                           ifAddress: Any = None) -> _socket.socket:
+        """Creates a server socket."""
+        sock = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM)
+        sock.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, 1)
+        if ifAddress:
+            sock.bind((ifAddress, port))
+        else:
+            sock.bind(('0.0.0.0', port))
+        sock.listen(backlog)
+        return sock
+
+    def toString(self) -> str:
+        return f"ServerSocketFactory@{hex(id(self))}"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# SSLServerSocketFactory
+# ============================================================
+
+class SSLServerSocketFactory(ServerSocketFactory):
+    """
+    javax.net.ssl.SSLServerSocketFactory
+    Factory for creating SSL server sockets.
+    """
+
+    _default = None
+
+    @classmethod
+    def getDefault(cls) -> "SSLServerSocketFactory":
+        if cls._default is None:
+            cls._default = SSLServerSocketFactory()
+        return cls._default
+
+    def getDefaultCipherSuites(self) -> List[str]:
+        try:
+            ctx = _ssl.create_default_context(_ssl.Purpose.CLIENT_AUTH)
+            return ctx.get_ciphers()
+        except Exception:
+            return []
+
+    def getSupportedCipherSuites(self) -> List[str]:
+        try:
+            ctx = _ssl.create_default_context(_ssl.Purpose.CLIENT_AUTH)
+            return ctx.get_ciphers()
+        except Exception:
+            return []
+
+    def createServerSocket(self, port: int = 0, backlog: int = 50,
+                           ifAddress: Any = None) -> "SSLServerSocket":
+        sock = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM)
+        sock.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, 1)
+        context = _ssl.create_default_context(_ssl.Purpose.CLIENT_AUTH)
+        ssl_sock = context.wrap_socket(sock, server_side=True)
+        ssl_ss = SSLServerSocket()
+        ssl_ss._socket = ssl_sock
+        if ifAddress:
+            ssl_ss._socket.bind((ifAddress, port))
+        else:
+            ssl_ss._socket.bind(('0.0.0.0', port))
+        ssl_ss._socket.listen(backlog)
+        return ssl_ss
+
+    def toString(self) -> str:
+        return f"SSLServerSocketFactory@{hex(id(self))}"
+
+
+# ============================================================
+# SSLSocketFactory
+# ============================================================
+
+class SSLSocketFactory(SocketFactory):
+    """
+    javax.net.ssl.SSLSocketFactory
+    Factory for creating SSL sockets.
+    """
+
+    _default = None
+
+    @classmethod
+    def getDefault(cls) -> "SSLSocketFactory":
+        if cls._default is None:
+            cls._default = SSLSocketFactory()
+        return cls._default
+
+    def getDefaultCipherSuites(self) -> List[str]:
+        try:
+            ctx = _ssl.create_default_context()
+            return [c['name'] for c in ctx.get_ciphers()]
+        except Exception:
+            return []
+
+    def getSupportedCipherSuites(self) -> List[str]:
+        try:
+            ctx = _ssl.create_default_context()
+            return [c['name'] for c in ctx.get_ciphers()]
+        except Exception:
+            return []
+
+    def createSocket(self, host: str = None, port: int = None,
+                     host_inet: Any = None, local_port: int = None,
+                     stream: bool = True) -> "SSLSocket":
+        sock = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM)
+        context = _ssl.create_default_context()
+        ssl_sock_impl = context.wrap_socket(sock, server_hostname=host)
+        if host and port is not None:
+            ssl_sock_impl.connect((host, port))
+        ss = SSLSocket()
+        ss._socket = ssl_sock_impl
+        ss._connected = True
+        return ss
+
+    def toString(self) -> str:
+        return f"SSLSocketFactory@{hex(id(self))}"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# SSLServerSocket
+# ============================================================
+
+class SSLServerSocket(Stub):
+    """
+    javax.net.ssl.SSLServerSocket
+    A server socket that supports SSL/TLS.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._socket = None
+        self._enabled_cipher_suites = []
+        self._enabled_protocols = []
+        self._need_client_auth = False
+        self._use_client_mode = False
+        self._want_client_auth = False
+        self._enable_session_creation = True
+
+    def getEnabledCipherSuites(self) -> List[str]:
+        return self._enabled_cipher_suites
+
+    def setEnabledCipherSuites(self, suites: List[str]):
+        self._enabled_cipher_suites = suites
+
+    def getSupportedCipherSuites(self) -> List[str]:
+        return ["TLS_AES_256_GCM_SHA384", "TLS_CHACHA20_POLY1305_SHA256",
+                "TLS_AES_128_GCM_SHA256", "ECDHE-RSA-AES256-GCM-SHA384"]
+
+    def setEnabledProtocols(self, protocols: List[str]):
+        self._enabled_protocols = protocols
+
+    def getEnabledProtocols(self) -> List[str]:
+        return self._enabled_protocols or ["TLSv1.3", "TLSv1.2"]
+
+    def getSupportedProtocols(self) -> List[str]:
+        return ["TLSv1", "TLSv1.1", "TLSv1.2", "TLSv1.3"]
+
+    def getNeedClientAuth(self) -> bool:
+        return self._need_client_auth
+
+    def setNeedClientAuth(self, need: bool):
+        self._need_client_auth = need
+
+    def getUseClientMode(self) -> bool:
+        return self._use_client_mode
+
+    def setUseClientMode(self, mode: bool):
+        self._use_client_mode = mode
+
+    def getWantClientAuth(self) -> bool:
+        return self._want_client_auth
+
+    def setWantClientAuth(self, want: bool):
+        self._want_client_auth = want
+
+    def getEnableSessionCreation(self) -> bool:
+        return self._enable_session_creation
+
+    def setEnableSessionCreation(self, flag: bool):
+        self._enable_session_creation = flag
+
+    def accept(self) -> "SSLSocket":
+        if self._socket:
+            conn, addr = self._socket.accept()
+            ss = SSLSocket()
+            ss._socket = conn
+            ss._connected = True
+            ss._remote_address = addr
+            return ss
+        return SSLSocket()
+
+    def close(self):
+        if self._socket:
+            self._socket.close()
+
+    def toString(self) -> str:
+        return f"SSLServerSocket@{hex(id(self))}"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# SSLSocket
+# ============================================================
+
+class SSLSocket(Stub):
+    """
+    javax.net.ssl.SSLSocket
+    A socket that supports SSL/TLS.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._socket = None
+        self._connected = False
+        self._remote_address = None
+        self._enabled_cipher_suites = []
+        self._enabled_protocols = []
+        self._need_client_auth = False
+        self._use_client_mode = False
+        self._want_client_auth = False
+        self._enable_session_creation = True
+        self._handshake_listeners = []
+        self._session = None
+
+    def getEnabledCipherSuites(self) -> List[str]:
+        return self._enabled_cipher_suites or ["TLS_AES_256_GCM_SHA384"]
+
+    def setEnabledCipherSuites(self, suites: List[str]):
+        self._enabled_cipher_suites = suites
+
+    def getSupportedCipherSuites(self) -> List[str]:
+        return ["TLS_AES_256_GCM_SHA384", "TLS_CHACHA20_POLY1305_SHA256",
+                "TLS_AES_128_GCM_SHA256", "ECDHE-RSA-AES256-GCM-SHA384"]
+
+    def setEnabledProtocols(self, protocols: List[str]):
+        self._enabled_protocols = protocols
+
+    def getEnabledProtocols(self) -> List[str]:
+        return self._enabled_protocols or ["TLSv1.3", "TLSv1.2"]
+
+    def getSupportedProtocols(self) -> List[str]:
+        return ["TLSv1", "TLSv1.1", "TLSv1.2", "TLSv1.3"]
+
+    def getNeedClientAuth(self) -> bool:
+        return self._need_client_auth
+
+    def setNeedClientAuth(self, need: bool):
+        self._need_client_auth = need
+
+    def getUseClientMode(self) -> bool:
+        return self._use_client_mode
+
+    def setUseClientMode(self, mode: bool):
+        self._use_client_mode = mode
+
+    def getWantClientAuth(self) -> bool:
+        return self._want_client_auth
+
+    def setWantClientAuth(self, want: bool):
+        self._want_client_auth = want
+
+    def getEnableSessionCreation(self) -> bool:
+        return self._enable_session_creation
+
+    def setEnableSessionCreation(self, flag: bool):
+        self._enable_session_creation = flag
+
+    def getSession(self):
+        """Returns the SSL session."""
+        return self._session
+
+    def startHandshake(self):
+        """Starts or re-starts the SSL handshake."""
+        if self._socket and hasattr(self._socket, 'do_handshake'):
+            try:
+                self._socket.do_handshake()
+                self._session = {"cipher": "TLS_AES_256_GCM_SHA384",
+                                 "protocol": "TLSv1.3"}
+                for listener in self._handshake_listeners:
+                    listener.handshakeCompleted(
+                        HandshakeCompletedEvent(self, self._session))
+            except Exception:
+                pass
+
+    def addHandshakeCompletedListener(self, listener: "HandshakeCompletedListener"):
+        self._handshake_listeners.append(listener)
+
+    def removeHandshakeCompletedListener(self, listener: "HandshakeCompletedListener"):
+        if listener in self._handshake_listeners:
+            self._handshake_listeners.remove(listener)
+
+    def getHandshakeApplicationProtocol(self) -> str:
+        return "http/1.1"
+
+    def getApplicationProtocol(self) -> str:
+        return "http/1.1"
+
+    def getHandshakeSession(self):
+        return self._session
+
+    def setHandshakeApplicationProtocolSelector(self, selector):
+        pass
+
+    def getHandshakeApplicationProtocolSelector(self):
+        return None
+
+    def close(self):
+        if self._socket:
+            self._socket.close()
+        self._connected = False
+
+    def toString(self) -> str:
+        return f"SSLSocket@{hex(id(self))}[connected={self._connected}]"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# HandshakeCompletedEvent
+# ============================================================
+
+class HandshakeCompletedEvent(Stub):
+    """
+    javax.net.ssl.HandshakeCompletedEvent
+    An event indicating that an SSL handshake completed.
+    """
+
+    def __init__(self, sock: SSLSocket = None, session: Any = None):
+        super().__init__()
+        self._socket = sock
+        self._session = session
+
+    def getSession(self):
+        return self._session
+
+    def getCipherSuite(self) -> str:
+        if self._session and isinstance(self._session, dict):
+            return self._session.get("cipher", "UNKNOWN")
+        return "UNKNOWN"
+
+    def getLocalCertificates(self) -> List:
+        return []
+
+    def getPeerCertificates(self) -> List:
+        return []
+
+    def getPeerPrincipal(self):
+        return None
+
+    def getLocalPrincipal(self):
+        return None
+
+    def getSocket(self) -> SSLSocket:
+        return self._socket
+
+    def toString(self) -> str:
+        return f"HandshakeCompletedEvent@{hex(id(self))}[cipher={self.getCipherSuite()}]"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# HandshakeCompletedListener
+# ============================================================
+
+class HandshakeCompletedListener(Stub):
+    """
+    javax.net.ssl.HandshakeCompletedListener
+    A listener for SSL handshake completion events.
+    """
+    def handshakeCompleted(self, event: HandshakeCompletedEvent):
+        raise NotImplementedError
+
+
+# ============================================================
+# HostnameVerifier
+# ============================================================
+
+class HostnameVerifier(Stub):
+    """
+    javax.net.ssl.HostnameVerizer
+    A hostname verifier for HTTPS connections.
+    """
+    def verify(self, hostname: str, session: Any) -> bool:
+        return True
+
+    def toString(self) -> str:
+        return f"HostnameVerifier@{hex(id(self))}"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# HttpsURLConnection
+# ============================================================
+
+class HttpsURLConnection(Stub):
+    """
+    javax.net.ssl.HttpsURLConnection
+    An HTTP URL connection with SSL/TLS support.
+    """
+    _default_hostname_verifier = HostnameVerifier()
+    _default_sslsocket_factory = SSLSocketFactory()
+
+    def __init__(self):
+        super().__init__()
+        self._hostname_verifier = None
+        self._ssl_socket_factory = None
+
+    @classmethod
+    def getDefaultHostnameVerifier(cls) -> HostnameVerifier:
+        return cls._default_hostname_verifier
+
+    @classmethod
+    def setDefaultHostnameVerifier(cls, verifier: HostnameVerifier):
+        cls._default_hostname_verifier = verifier
+
+    @classmethod
+    def getDefaultSSLSocketFactory(cls) -> SSLSocketFactory:
+        return cls._default_sslsocket_factory
+
+    @classmethod
+    def setDefaultSSLSocketFactory(cls, factory: SSLSocketFactory):
+        cls._default_sslsocket_factory = factory
+
+    def getHostnameVerifier(self) -> HostnameVerifier:
+        return self._hostname_verifier or self._default_hostname_verifier
+
+    def setHostnameVerifier(self, verifier: HostnameVerifier):
+        self._hostname_verifier = verifier
+
+    def getSSLSocketFactory(self) -> SSLSocketFactory:
+        return self._ssl_socket_factory or self._default_sslsocket_factory
+
+    def setSSLSocketFactory(self, factory: SSLSocketFactory):
+        self._ssl_socket_factory = factory
+
+    def toString(self) -> str:
+        return f"HttpsURLConnection@{hex(id(self))}"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# TrustManager
+# ============================================================
+
+class TrustManager(Stub):
+    """
+    javax.net.ssl.TrustManager
+    Base interface for trust managers.
+    """
+    pass
+
+
+# ============================================================
+# X509TrustManager
+# ============================================================
+
+class X509TrustManager(TrustManager):
+    """
+    javax.net.ssl.X509TrustManager
+    Trust manager for X.509 certificates.
+    """
+    def checkClientTrusted(self, chain: List, auth_type: str):
+        """Checks if a client certificate is trusted."""
+        pass
+
+    def checkServerTrusted(self, chain: List, auth_type: str):
+        """Checks if a server certificate is trusted."""
+        pass
+
+    def getAcceptedIssuers(self) -> List:
+        """Returns the list of accepted issuer certificates."""
+        return []
+
+    def toString(self) -> str:
+        return f"X509TrustManager@{hex(id(self))}"
+
+
+# ============================================================
+# KeyManager
+# ============================================================
+
+class KeyManager(Stub):
+    """
+    javax.net.ssl.KeyManager
+    Base interface for key managers.
+    """
+    pass
+
+
+# ============================================================
+# X509KeyManager
+# ============================================================
+
+class X509KeyManager(KeyManager):
+    """
+    javax.net.ssl.X509KeyManager
+    Key manager for X.509 keys.
+    """
+    def getClientAliases(self, key_type: str, issuers: List) -> List[str]:
+        return []
+
+    def chooseClientAlias(self, key_types: List, issuers: List, sockets: List) -> str:
+        return None
+
+    def getServerAliases(self, key_type: str, issuers: List) -> List[str]:
+        return []
+
+    def chooseServerAlias(self, key_type: str, issuers: List, sockets: List) -> str:
+        return None
+
+    def getCertificateChain(self, alias: str) -> List:
+        return []
+
+    def getPrivateKey(self, alias: str):
+        return None
+
+    def toString(self) -> str:
+        return f"X509KeyManager@{hex(id(self))}"
+
+
+# ============================================================
+# TrustManagerFactory
+# ============================================================
+
+class TrustManagerFactory(Stub):
+    """
+    javax.net.ssl.TrustManagerFactory
+    Factory for TrustManager instances.
+    """
+
+    def __init__(self, algorithm: str = None):
+        super().__init__()
+        self._algorithm = algorithm or "PKIX"
+        self._trust_managers = []
+
+    @staticmethod
+    def getInstance(algorithm: str) -> "TrustManagerFactory":
+        return TrustManagerFactory(algorithm)
+
+    @staticmethod
+    def getDefaultAlgorithm() -> str:
+        return "PKIX"
+
+    def getAlgorithm(self) -> str:
+        return self._algorithm
+
+    def init(self, ks: Any = None):
+        """Initializes this factory with a key store."""
+        self._trust_managers = [X509TrustManager()]
+
+    def getTrustManagers(self) -> List[TrustManager]:
+        return list(self._trust_managers)
+
+    def toString(self) -> str:
+        return f"TrustManagerFactory@{hex(id(self))}[algorithm={self._algorithm}]"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# KeyManagerFactory
+# ============================================================
+
+class KeyManagerFactory(Stub):
+    """
+    javax.net.ssl.KeyManagerFactory
+    Factory for KeyManager instances.
+    """
+
+    def __init__(self, algorithm: str = None):
+        super().__init__()
+        self._algorithm = algorithm or "PKIX"
+        self._key_managers = []
+
+    @staticmethod
+    def getInstance(algorithm: str) -> "KeyManagerFactory":
+        return KeyManagerFactory(algorithm)
+
+    @staticmethod
+    def getDefaultAlgorithm() -> str:
+        return "PKIX"
+
+    def getAlgorithm(self) -> str:
+        return self._algorithm
+
+    def init(self, ks: Any = None, password: Any = None):
+        """Initializes this factory with a key store."""
+        self._key_managers = [X509KeyManager()]
+
+    def getKeyManagers(self) -> List[KeyManager]:
+        return list(self._key_managers)
+
+    def toString(self) -> str:
+        return f"KeyManagerFactory@{hex(id(self))}[algorithm={self._algorithm}]"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# SSLContext
+# ============================================================
+
+class SSLContext(Stub):
+    """
+    javax.net.ssl.SSLContext
+    An implementation of a secure socket protocol.
+    """
+
+    _default = None
+
+    def __init__(self, protocol: str = "TLS"):
+        super().__init__()
+        self._protocol = protocol
+        self._provider = None
+        self._ssl_context = None
+
+    @staticmethod
+    def getInstance(protocol: str) -> "SSLContext":
+        ctx = SSLContext(protocol)
+        try:
+            ctx._ssl_context = _ssl.create_default_context()
+        except Exception:
+            pass
+        return ctx
+
+    def init(self, km: List[KeyManager] = None, tm: List[TrustManager] = None,
+             random: Any = None):
+        """Initializes this context with key managers, trust managers, and randomness."""
+        pass
+
+    def getSocketFactory(self) -> SSLSocketFactory:
+        return SSLSocketFactory()
+
+    def getServerSocketFactory(self) -> SSLServerSocketFactory:
+        return SSLServerSocketFactory()
+
+    def createSSLEngine(self, host: str = None, port: int = None):
+        """Creates a new SSLEngine (stub)."""
+        return None
+
+    def getProtocol(self) -> str:
+        return self._protocol
+
+    def getProvider(self):
+        return self._provider
+
+    @staticmethod
+    def getDefault() -> "SSLContext":
+        if SSLContext._default is None:
+            SSLContext._default = SSLContext("TLS")
+        return SSLContext._default
+
+    @staticmethod
+    def setDefault(ctx: "SSLContext"):
+        SSLContext._default = ctx
+
+    def toString(self) -> str:
+        return f"SSLContext@{hex(id(self))}[protocol={self._protocol}]"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF

android_pyapi/javax/security.py

@@ -0,0 +1,768 @@
+"""
+Java javax.security APIs implemented in Python.
+javax.security package - Subject, Principal, Policy, Permission, etc.
+Desktop stub implementation.
+"""
+
+from __future__ import annotations
+
+from .._core import Stub, AndroidOnlyError
+from typing import List, Set, Optional
+
+__all__ = [
+    "AuthProvider", "Subject", "Principal", "Policy",
+    "PrivateCredentialPermission", "SubjectDomainCombiner",
+    "Refreshable", "Destroyable",
+    "RefreshFailedException", "DestroyFailedException",
+    "CredentialException", "CredentialExpiredException",
+    "CredentialNotFoundException", "UnrecoverableKeyException",
+    "UnrecoverableEntryException", "KeyStoreCallbackHandler",
+    "DomainLoadStoreParameter",
+    "Certificate", "CodeSource", "ProtectionDomain",
+    "Permissions", "AllPermission", "BasicPermission",
+    "Permission", "PermissionCollection", "UnresolvedPermission",
+    "PermissionsEnumerator", "Guard", "GuardedObject",
+]
+
+
+# ============================================================
+# Principal
+# ============================================================
+
+class Principal(Stub):
+    """
+    java.security.Principal
+    Represents a principal (entity) such as a user or group.
+    """
+
+    def __init__(self, name: str = ""):
+        super().__init__()
+        self._name = name
+
+    def getName(self) -> str:
+        return self._name
+
+    def implies(self, subject: "Subject") -> bool:
+        return False
+
+    def toString(self) -> str:
+        return self._name
+
+    def equals(self, other) -> bool:
+        if isinstance(other, Principal):
+            return self._name == other._name
+        return False
+
+    def hashCode(self) -> int:
+        return hash(self._name) & 0x7FFFFFFF
+
+
+# ============================================================
+# Subject
+# ============================================================
+
+class Subject(Stub):
+    """
+    javax.security.auth.Subject
+    Represents a grouping of related information for a single entity.
+    """
+
+    def __init__(self, read_only: bool = False,
+                 principals: Set[Principal] = None,
+                 pub_creds: Set = None,
+                 priv_creds: Set = None):
+        super().__init__()
+        self._read_only = read_only
+        self._principals = set(principals) if principals else set()
+        self._public_credentials = set(pub_creds) if pub_creds else set()
+        self._private_credentials = set(priv_creds) if priv_creds else set()
+
+    def getPrincipals(self) -> Set[Principal]:
+        return set(self._principals)
+
+    def getPrivateCredentials(self) -> Set:
+        return set(self._private_credentials)
+
+    def getPublicCredentials(self) -> Set:
+        return set(self._public_credentials)
+
+    def setReadOnly(self):
+        self._read_only = True
+
+    def isReadOnly(self) -> bool:
+        return self._read_only
+
+    @staticmethod
+    def doAs(subject: "Subject", action: callable) -> Any:
+        return action()
+
+    @staticmethod
+    def doAsPrivileged(subject: "Subject", action: callable, access: Any) -> Any:
+        return action()
+
+    def toString(self) -> str:
+        return (f"Subject@{hex(id(self))}[principals={len(self._principals)}, "
+                f"read_only={self._read_only}]")
+
+    def equals(self, other) -> bool:
+        if not isinstance(other, Subject):
+            return False
+        return (self._principals == other._principals and
+                self._read_only == other._read_only)
+
+    def hashCode(self) -> int:
+        return hash(frozenset(self._principals)) & 0x7FFFFFFF
+
+
+# ============================================================
+# Policy
+# ============================================================
+
+class Policy(Stub):
+    """
+    java.security.Policy
+    Policy for permissions (stub).
+    """
+    _policy = None
+
+    def __init__(self):
+        super().__init__()
+        self._parameters = None
+
+    @staticmethod
+    def getPolicy() -> "Policy":
+        if Policy._policy is None:
+            Policy._policy = Policy()
+        return Policy._policy
+
+    @staticmethod
+    def setPolicy(policy: "Policy"):
+        Policy._policy = policy
+
+    def getParameters(self):
+        return self._parameters
+
+    def setParameters(self, params):
+        self._parameters = params
+
+    def implies(self, domain: "ProtectionDomain", permission: "Permission") -> bool:
+        return True
+
+    def toString(self) -> str:
+        return f"Policy@{hex(id(self))}"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# AuthProvider
+# ============================================================
+
+class AuthProvider(Stub):
+    """
+    javax.security.auth.AuthProvider
+    Provider for authentication services.
+    """
+    def __init__(self):
+        super().__init__()
+
+    def login(self, subject: Subject, handler: Any):
+        pass
+
+    def logout(self, subject: Subject):
+        pass
+
+    def setCallbackHandler(self, handler: Any):
+        pass
+
+    def toString(self) -> str:
+        return f"AuthProvider@{hex(id(self))}"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# PrivateCredentialPermission
+# ============================================================
+
+class PrivateCredentialPermission(Stub):
+    """
+    javax.security.auth.PrivateCredentialPermission
+    Permission to access private credentials.
+    """
+    def __init__(self, name: str = "", actions: str = "read"):
+        super().__init__()
+        self._name = name
+        self._actions = actions
+
+    def getName(self) -> str:
+        return self._name
+
+    def getActions(self) -> str:
+        return self._actions
+
+    def getCredentialClass(self) -> str:
+        return self._name
+
+    def getPrincipals(self) -> List[List]:
+        return []
+
+    def implies(self, permission: "Permission") -> bool:
+        return isinstance(permission, PrivateCredentialPermission) and self._name == permission._name
+
+    def toString(self) -> str:
+        return f'PrivateCredentialPermission "{self._name}" "{self._actions}"'
+
+    def equals(self, other) -> bool:
+        if isinstance(other, PrivateCredentialPermission):
+            return self._name == other._name and self._actions == other._actions
+        return False
+
+    def hashCode(self) -> int:
+        return hash((self._name, self._actions)) & 0x7FFFFFFF
+
+
+# ============================================================
+# SubjectDomainCombiner
+# ============================================================
+
+class SubjectDomainCombiner(Stub):
+    """
+    javax.security.auth.SubjectDomainCombiner
+    Combines ProtectionDomains with Subject context.
+    """
+    def __init__(self, subject: Subject):
+        super().__init__()
+        self._subject = subject
+
+    def combine(self, current_domains: List, assigned_domains: List) -> List:
+        return list(current_domains or []) + list(assigned_domains or [])
+
+    def getSubject(self) -> Subject:
+        return self._subject
+
+    def toString(self) -> str:
+        return f"SubjectDomainCombiner@{hex(id(self))}"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# Refreshable / Destroyable interfaces
+# ============================================================
+
+class Refreshable(Stub):
+    """
+    javax.security.auth.Refreshable
+    Interface for refreshable credentials.
+    """
+    def isCurrent(self) -> bool:
+        return True
+
+    def refresh(self):
+        raise AndroidOnlyError("refresh not supported on desktop")
+
+
+class Destroyable(Stub):
+    """
+    javax.security.auth.Destroyable
+    Interface for destroyable credentials.
+    """
+    def isDestroyed(self) -> bool:
+        return False
+
+    def destroy(self):
+        pass
+
+
+# ============================================================
+# Exceptions
+# ============================================================
+
+class RefreshFailedException(Exception, Stub):
+    def __init__(self, message: str = None):
+        super().__init__(message or "Refresh failed")
+        self._message = message
+    def toString(self) -> str:
+        return f"RefreshFailedException: {self._message}"
+    def equals(self, other) -> bool:
+        return isinstance(other, RefreshFailedException) and self._message == other._message
+    def hashCode(self) -> int:
+        return hash(self._message) & 0x7FFFFFFF
+
+
+class DestroyFailedException(Exception, Stub):
+    def __init__(self, message: str = None):
+        super().__init__(message or "Destroy failed")
+        self._message = message
+    def toString(self) -> str:
+        return f"DestroyFailedException: {self._message}"
+    def equals(self, other) -> bool:
+        return isinstance(other, DestroyFailedException) and self._message == other._message
+    def hashCode(self) -> int:
+        return hash(self._message) & 0x7FFFFFFF
+
+
+class CredentialException(Exception, Stub):
+    def __init__(self, message: str = None):
+        super().__init__(message or "Credential error")
+        self._message = message
+    def toString(self) -> str:
+        return f"CredentialException: {self._message}"
+
+
+class CredentialExpiredException(CredentialException):
+    def __init__(self, message: str = None):
+        super().__init__(message or "Credential expired")
+
+
+class CredentialNotFoundException(CredentialException):
+    def __init__(self, message: str = None):
+        super().__init__(message or "Credential not found")
+
+
+class UnrecoverableKeyException(Exception, Stub):
+    def __init__(self, message: str = None):
+        super().__init__(message or "Unrecoverable key")
+        self._message = message
+    def toString(self) -> str:
+        return f"UnrecoverableKeyException: {self._message}"
+
+
+class UnrecoverableEntryException(Exception, Stub):
+    def __init__(self, message: str = None):
+        super().__init__(message or "Unrecoverable entry")
+        self._message = message
+    def toString(self) -> str:
+        return f"UnrecoverableEntryException: {self._message}"
+
+
+# ============================================================
+# KeyStoreCallbackHandler
+# ============================================================
+
+class KeyStoreCallbackHandler(Stub):
+    """
+    javax.security.auth.callback.KeyStoreCallbackHandler
+    Handler for key store callbacks.
+    """
+    def __init__(self):
+        super().__init__()
+
+    def handle(self, callbacks: List):
+        pass
+
+    def toString(self) -> str:
+        return f"KeyStoreCallbackHandler@{hex(id(self))}"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# DomainLoadStoreParameter
+# ============================================================
+
+class DomainLoadStoreParameter(Stub):
+    """
+    java.security.DomainLoadStoreParameter
+    Configuration data for loading/storing keystore domains.
+    """
+    def __init__(self, config: dict = None):
+        super().__init__()
+        self._config = config or {}
+
+    def getConfiguration(self) -> dict:
+        return self._config
+
+    def toString(self) -> str:
+        return f"DomainLoadStoreParameter@{hex(id(self))}"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# Certificate
+# ============================================================
+
+class Certificate(Stub):
+    """
+    java.security.cert.Certificate
+    Abstract class for managing certificates.
+    """
+    def __init__(self, cert_type: str = "X.509", encoded: bytes = None):
+        super().__init__()
+        self._cert_type = cert_type
+        self._encoded = encoded or b''
+
+    def getType(self) -> str:
+        return self._cert_type
+
+    def getEncoded(self) -> bytes:
+        return self._encoded
+
+    def getPublicKey(self):
+        return None
+
+    def toString(self) -> str:
+        return f"Certificate@{hex(id(self))}[type={self._cert_type}]"
+
+    def equals(self, other) -> bool:
+        if isinstance(other, Certificate):
+            return self._encoded == other._encoded
+        return False
+
+    def hashCode(self) -> int:
+        return hash(bytes(self._encoded)) & 0x7FFFFFFF
+
+
+# ============================================================
+# Permission & PermissionCollection
+# ============================================================
+
+class Permission(Stub):
+    """
+    java.security.Permission
+    Abstract class for representing access to a system resource.
+    """
+    def __init__(self, name: str = ""):
+        super().__init__()
+        self._name = name
+
+    def getName(self) -> str:
+        return self._name
+
+    def getActions(self) -> str:
+        return ""
+
+    def implies(self, permission: "Permission") -> bool:
+        return self.equals(permission)
+
+    def toString(self) -> str:
+        return f'Permission "{self._name}"'
+
+    def equals(self, other) -> bool:
+        if isinstance(other, Permission):
+            return self._name == other._name
+        return False
+
+    def hashCode(self) -> int:
+        return hash(self._name) & 0x7FFFFFFF
+
+
+class PermissionCollection(Stub):
+    """
+    java.security.PermissionCollection
+    Abstract class for holding a collection of Permission objects.
+    """
+    def __init__(self):
+        super().__init__()
+        self._permissions = []
+        self._read_only = False
+
+    def add(self, permission: Permission):
+        if not self._read_only:
+            self._permissions.append(permission)
+
+    def implies(self, permission: Permission) -> bool:
+        for p in self._permissions:
+            if p.implies(permission):
+                return True
+        return False
+
+    def elements(self):
+        return iter(self._permissions)
+
+    def isReadOnly(self) -> bool:
+        return self._read_only
+
+    def setReadOnly(self):
+        self._read_only = True
+
+    def toString(self) -> str:
+        return f"PermissionCollection@{hex(id(self))}[size={len(self._permissions)}]"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+class Permissions(PermissionCollection):
+    """
+    java.security.Permissions
+    A collection of Permission objects.
+    """
+    def add(self, permission: Permission):
+        super().add(permission)
+
+    def implies(self, permission: Permission) -> bool:
+        return super().implies(permission)
+
+    def elements(self):
+        return super().elements()
+
+    def toString(self) -> str:
+        return f"Permissions@{hex(id(self))}[size={len(self._permissions)}]"
+
+
+class AllPermission(Permission):
+    """
+    java.security.AllPermission
+    A permission that implies all other permissions.
+    """
+    def __init__(self):
+        super().__init__("<all permissions>")
+
+    def implies(self, permission: Permission) -> bool:
+        return True
+
+    def getActions(self) -> str:
+        return "<all actions>"
+
+    def toString(self) -> str:
+        return "AllPermission"
+
+
+class BasicPermission(Permission):
+    """
+    java.security.BasicPermission
+    Base class for basic permissions.
+    """
+    def __init__(self, name: str = "", actions: str = ""):
+        super().__init__(name)
+        self._actions = actions
+
+    def implies(self, permission: Permission) -> bool:
+        if isinstance(permission, BasicPermission):
+            return self._name == permission._name or permission._name.startswith(self._name + ".")
+        return False
+
+    def getActions(self) -> str:
+        return self._actions
+
+    def toString(self) -> str:
+        return f'BasicPermission "{self._name}"'
+
+    def equals(self, other) -> bool:
+        if isinstance(other, BasicPermission):
+            return self._name == other._name
+        return False
+
+    def hashCode(self) -> int:
+        return hash(self._name) & 0x7FFFFFFF
+
+
+class UnresolvedPermission(Permission):
+    """
+    java.security.UnresolvedPermission
+    A permission that was not resolved when the PermissionCollection was built.
+    """
+    def __init__(self, perm_type: str = "", name: str = "", actions: str = "",
+                 certs: List = None):
+        super().__init__(name)
+        self._unresolved_type = perm_type
+        self._unresolved_actions = actions
+        self._unresolved_certs = certs or []
+
+    def getUnresolvedType(self) -> str:
+        return self._unresolved_type
+
+    def getUnresolvedName(self) -> str:
+        return self._name
+
+    def getUnresolvedActions(self) -> str:
+        return self._unresolved_actions
+
+    def getUnresolvedCerts(self) -> List:
+        return list(self._unresolved_certs)
+
+    def implies(self, permission: Permission) -> bool:
+        return False
+
+    def toString(self) -> str:
+        return f'UnresolvedPermission "{self._unresolved_type}" "{self._name}" "{self._unresolved_actions}"'
+
+    def equals(self, other) -> bool:
+        if isinstance(other, UnresolvedPermission):
+            return (self._unresolved_type == other._unresolved_type and
+                    self._name == other._name)
+        return False
+
+    def hashCode(self) -> int:
+        return hash((self._unresolved_type, self._name)) & 0x7FFFFFFF
+
+
+class PermissionsEnumerator(Stub):
+    """
+    java.security.PermissionsEnumerator
+    Enumerator over Permission objects.
+    """
+    def __init__(self, permissions: List):
+        super().__init__()
+        self._permissions = list(permissions)
+        self._index = 0
+
+    def hasMoreElements(self) -> bool:
+        return self._index < len(self._permissions)
+
+    def nextElement(self) -> Permission:
+        if self._index < len(self._permissions):
+            p = self._permissions[self._index]
+            self._index += 1
+            return p
+        return None
+
+    def toString(self) -> str:
+        return f"PermissionsEnumerator@{hex(id(self))}"
+
+
+# ============================================================
+# CodeSource
+# ============================================================
+
+class CodeSource(Stub):
+    """
+    java.security.CodeSource
+    Represents the codebase and certificates from which code originated.
+    """
+    def __init__(self, location: str = None, certs: List = None,
+                 code_signers: List = None):
+        super().__init__()
+        self._location = location
+        self._certificates = certs or []
+        self._code_signers = code_signers or []
+
+    def getCertificates(self) -> List:
+        return list(self._certificates)
+
+    def getCodeSigners(self) -> List:
+        return list(self._code_signers)
+
+    def getLocation(self) -> str:
+        return self._location
+
+    def implies(self, codesource: "CodeSource") -> bool:
+        return self._location == codesource._location
+
+    def toString(self) -> str:
+        return f"CodeSource@{hex(id(self))}[location={self._location}]"
+
+    def equals(self, other) -> bool:
+        if isinstance(other, CodeSource):
+            return self._location == other._location
+        return False
+
+    def hashCode(self) -> int:
+        return hash(self._location) & 0x7FFFFFFF
+
+
+# ============================================================
+# ProtectionDomain
+# ============================================================
+
+class ProtectionDomain(Stub):
+    """
+    java.security.ProtectionDomain
+    Groups a CodeSource and Permissions for code access control.
+    """
+    def __init__(self, codesource: CodeSource = None,
+                 permissions: PermissionCollection = None,
+                 principals: List[Principal] = None,
+                 static_permissions: bool = False):
+        super().__init__()
+        self._codesource = codesource
+        self._permissions = permissions or Permissions()
+        self._principals = principals or []
+        self._static_permissions = static_permissions
+
+    def getCodeSource(self) -> CodeSource:
+        return self._codesource
+
+    def getPermissions(self) -> PermissionCollection:
+        return self._permissions
+
+    def getPrincipals(self) -> List[Principal]:
+        return list(self._principals)
+
+    def implies(self, permission: Permission) -> bool:
+        return self._permissions.implies(permission) if self._permissions else False
+
+    def toString(self) -> str:
+        return f"ProtectionDomain@{hex(id(self))}[codesource={self._codesource}]"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+# ============================================================
+# Guard & GuardedObject
+# ============================================================
+
+class Guard(Stub):
+    """
+    java.security.Guard
+    Interface for objects that guard access to another object.
+    """
+    def checkGuard(self, obj: Any):
+        raise NotImplementedError
+
+    def toString(self) -> str:
+        return f"Guard@{hex(id(self))}"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF
+
+
+class GuardedObject(Stub):
+    """
+    java.security.GuardedObject
+    Wraps an object and guards access to it with a Guard.
+    """
+    def __init__(self, obj: Any = None, guard: Guard = None):
+        super().__init__()
+        self._object = obj
+        self._guard = guard
+
+    def getObject(self) -> Any:
+        if self._guard:
+            self._guard.checkGuard(self._object)
+        return self._object
+
+    def setGuard(self, guard: Guard):
+        self._guard = guard
+
+    def toString(self) -> str:
+        return f"GuardedObject@{hex(id(self))}[guarded={self._guard is not None}]"
+
+    def equals(self, other) -> bool:
+        return self is other
+
+    def hashCode(self) -> int:
+        return hash(self) & 0x7FFFFFFF