+ iHjy7a0t$Rt^RIHt^RIt^RIt^RIt^RIt^RIH t ^RI H t H t ]P!]4tRsR]R&RRltR R lt/tR ]R &]P*!4tR RltR)RRlltRRlt/tR]R&]P*!4tRRltRRltRRltRRltRs R]R&RR lt!R!R"lt"R#RR$RR%R&/R'R(llt#R#)*u@TLS trust for Hermes. One authority, one trust source. Trust comes from the platform verifier via ``truststore``: CryptoAPI on Windows, Security.framework on macOS, and OpenSSL's own store (with a distro candidate sweep) on Linux. That is the machine's real answer to "is this chain valid", so a corporate MITM root installed by MDM, an internal CA, and a locked-down NixOS box all work with no configuration. ``install_truststore()`` runs once at process start and patches ``ssl.SSLContext`` process-wide, so every stack that builds a default context inherits it — httpx, requests/urllib3, aiohttp, AND the stdlib ``urllib.request`` call sites (the llama.cpp engine download among them) that a certifi-only or requests-only approach never reached. An exported ``SSL_CERT_FILE`` bundle is trusted ON TOP of the platform store; only EXPLICIT PER-PROVIDER CONFIG replaces that trust: ``ssl_ca_cert`` (a self-signed or internal endpoint's bundle) and ``ssl_verify: false`` (local development). Those are deliberate statements about one endpoint, not an ambient guess about the machine. ) annotationsN)Path)AnyOptionalz bool | None _installedcV^8dQhRR/#)returnbool)formats"5/home/ubuntu/.hermes/hermes-agent/agent/ssl_verify.py __annotate__r$sDc\e\#^RIpVP4Rs\P R4\# \ d(pRs\P RT4Rp?\#Rp?ii;i)alPoint every default SSLContext at the OS trust store. Idempotent. Returns True when the platform verifier is in force. A False return means truststore could not load (an unsupported platform, or a stripped payload); TLS still works off OpenSSL's compiled-in paths, it just won't see certificates the OS trusts. Call before the first HTTPS client is constructed. NTz&TLS trust: platform store (truststore)Futruststore unavailable (%s); falling back to OpenSSL's default trust paths. Certificates trusted only by the OS store — a corporate root, for instance — will not verify.)r truststoreinject_into_sslloggerdebug Exceptionwarning)rexcs r install_truststorer$sy  ""$  =>     @     s+A A3 A..A3c V^8dQhRRRR/#)r ssl_verifyrr r r )r s"r rrBsrcVRJdR#\V\4'd&VP4P4R9dR#R#)FT>0noofffalse) isinstancestrstriplower)rs&r _coerce_insecurer$Bs:U*c""z'7'7'9'?'?'AE`'` rz-dict[tuple[str | None, bool], ssl.SSLContext] _CA_CONTEXTScV^8dQhRR/#)rr ztype[ssl.SSLContext]r )r s"r rrNs  #7 rcp\PPR8Xd\P#^RIHpV#)uThe un-injected stdlib ``ssl.SSLContext``. An explicit bundle must REPLACE OS trust, and truststore's context falls back to the OS verifier whenever the loaded bundle rejects a chain — so the bundle context has to be built from the stdlib class. Once injected (here, or by pm.launch/pm.worker before this module loads) the only handle on it is truststore's own saved reference; when nothing is injected — truststore absent or not installed — ``ssl.SSLContext`` is already the stdlib class and truststore must not be imported at all. ssl_original_SSLContext)r( SSLContext __module__truststore._ssl_constantsr*r)s r _stdlib_ssl_context_classr.Ns) ~~  E)~~> rc$V^8dQhRRRRRR/#)rca_pathz str | Noneunionr r ssl.SSLContextr )r s"r rr`s!Zrc\;_uu_4\PW34pVfVe(V'g \4!\P 4pM@\P !\P 4p\'gVP4VeVPVR7V\W3&VuuRRR4# +'giR#;i)zA stable context identity lets clients reuse the existing transport pool. ``union`` adds ``ca_path`` to the platform store (the ``SSL_CERT_FILE`` contract) instead of replacing it (a provider ``ssl_ca_cert``). N)cafile) _CA_CONTEXTS_LOCKr%getr.r(PROTOCOL_TLS_CLIENTr+rload_default_certsload_verify_locations)r0r1ctxs&& r _shared_contextr;`s  /0 ;"501#2I2IJnnS%<%<=!z**,")))9-0L') *    s&CAC1C C cV^8dQhRR/#)rr r2r )r s"r rrws ! !n !rc0\4\PPRR4P 4pV'dM\ V4P 4'd.\\\ V4P44RR7#\R4#)zThe process-wide client context (cheap after the first call). An existing ``SSL_CERT_FILE`` bundle is trusted ON TOP of the platform store, as it was for httpx ``verify=True``; a missing or stale path falls back to the platform store alone. SSL_CERT_FILET)r1N) rosenvironr6r"ris_filer;r!resolve)cas r platform_ssl_contextrEwsf  , 2 2 4B d2h  s48#3#3#56dCC 4  rzdict[str, Optional[str]]_STALE_BUNDLE_OUTCOMEScV^8dQhRR/#rr Optional[str]r )r s"r rrs'']'rc^RIpTP4p\T4P 4'dT#\ T4# \dR#i;i)ucertifi's CA bundle path, re-derived when a rotation invalidated it. ``certifi.where()`` resolves its path once, against the ``certifi`` package on the ``sys.path`` of the moment it was first called, and caches it in ``certifi.core``: a process that outlives an install-environment rotation — the package manager creates a new environment directory and deletes the old one — keeps pointing into the deleted directory for the rest of its life, and every TLS client it builds afterwards fails. Re-importing the package against the live ``sys.path`` repairs it process-wide; when even that finds nothing, the platform store is the answer and never an exception. The repair, and its warning, happen ONCE per dead path: a gateway builds clients per turn, per cron run and per model-metadata fetch, so an un-cached reload here would re-execute third-party module code and re-log on every client it builds. Returns a bundle path that exists on disk, else ``None``. N)certifi ImportErrorwhererrB_recover_bundle_once)rKstales r certifi_bundle_pathrPsN$ MMOE E{  && sA AAc V^8dQhRRRR/#)rrOr!r rIr )r s"r rrs rct\;_uu_4V\9d=\V,pVe \V4P4'd VuuRRR4#\ 4pV\V&RRR4Xe\ P RVV4V#\ P RV4R# +'giLE;i)zRe-derive ``stale`` at most once, and report it at most once. A cached outcome is reused while it still holds (a re-derived path that exists, or an unrecoverable one); a later rotation dead-path is a new key and is repaired on its own. NuTLS trust: certifi's CA bundle %s no longer exists — the install environment it belongs to was replaced under this process; re-resolved to %s. TLS clients built before this point used the dead path.zTLS trust: certifi's CA bundle %s no longer exists and certifi could not be re-resolved; using the platform trust store for the rest of this process.)_STALE_BUNDLE_LOCKrFrrB_reload_certifi_bundlerr)rOcached recovereds& r rNrNs   * *+E2F~f!5!5!7!7   +, (1u%  M     NN T  +  s=B'B'' B7 cV^8dQhRR/#rHr )r s"r rrs ; ; ;rc`^RIp^RIpRVP9dR#VP4VPUu.uF$q"R8XgVP R4'gK"VNK& upUu/uFpW1PP V4bK ppVP R4P4pT'd"\T4P4'dT#R#uupiuupi \d?pTPPT4\PRTRR7Rp?R#Rp?ii;i)u$Re-import certifi from the live ``sys.path`` so its ``where()`` follows it. ``importlib.reload`` on its own does NOT re-derive the path with the real package: ``certifi.where`` is ``certifi.core.where`` re-exported by ``__init__``, and ``core`` caches the resolved path in a module global, so re-executing ``__init__`` re-binds ``where`` from the still-loaded ``core`` — the replaced directory, cached a second time. Only dropping the package and its submodules from ``sys.modules`` makes both files re-execute against the live ``sys.path``. They are put back when the import fails, so the process is never left without the ``certifi`` it already had. ``None`` when certifi was never imported or its package is gone from every ``sys.path`` entry — the caller then falls back to the platform store. NrKzcertifi.z$certifi could not be re-resolved: %sTexc_info) importlibsysmodulesinvalidate_caches startswithpop import_modulerMrupdaterrrrB)r[r\nnamedroppedpathrs r rTrTs #!!$ Z 1I~jAYQQ ZZD kkood##Z &&y1779 DJ..004:d:[  7# ;S4 Ps)CC)$CC$$ D-/3D((D-cV^8dQhRR/#)rr z bool | strr )r s"r rrs,,,rc^RIHp\PP R4'g&\PP R4'dR#\ V4P 4'dR#\4pV'dV#\P!4pVPVP3F0pV'gK \ V4P4'gK.Vu# \4;'gR#)u``verify`` for a ``requests`` call in this process. ``requests`` resolves ``verify=True`` through ``DEFAULT_CA_BUNDLE_PATH``, a string frozen when ``requests`` was imported — the one certifi consumer a module reload cannot reach, so a rotated environment leaves every ``requests`` call raising ``OSError: Could not find a suitable TLS CA certificate bundle``. The live bundle (certifi's, re-derived; else OpenSSL's own default) keeps those calls working; ``True`` only when nothing resolves, which is requests' own default. A healthy install keeps ``True`` too: requests reads ``REQUESTS_CA_BUNDLE``/``CURL_CA_BUNDLE`` only for ``verify=True``, and an explicit path would silently bypass a user's proxy CA. )DEFAULT_CA_BUNDLE_PATHREQUESTS_CA_BUNDLECURL_CA_BUNDLET)requests.utilsrir@rAr6rrBrPr(get_default_verify_pathsr4capathexists_platform_store_bundle)ribundledefaults candidates r requests_verifyrts6 zz~~*++rzz~~>N/O/O "#++-- "F  ++-Hoox7 9i//11 8 " # + +t+rrI_PLATFORM_STORE_BUNDLEcV^8dQhRR/#rHr )r s"r rr s"" "rc@\'d*\\4P4'd\#\4!\P 4pVP 4VPRR7pV'gR#^RIH p^RI H pV!4R, R, pVPPRRR7V!VR PR V444\%T4s\# \d$p\ P#R TRR 7Rp?R#Rp?ii;i) zLThe OS store's CA certificates written once to a PEM file under HERMES_HOME.T) binary_formN)get_hermes_home)atomic_write_textcachezplatform-ca-bundle.pem)parentsexist_okr?c3N"TFp\P!V4xK R#5i)N)r(DER_cert_to_PEM_cert).0ders& r )_platform_store_bundle..s 'WQV#(@(@(E(EQVs#%z"platform CA bundle not written: %srY)rurrBr.r(r7r8 get_ca_certshermes_constantsryutilsrzparentmkdirjoinOSErrorrrr!)r:certsryrzrfrs r rprp s$'=">"F"F"H"H%% # %c&=&= >C     .E 0'  w &)A AD $6$'WQV'W WX!Y !!  93 Ns" SSL_CERT_DIRN)rr$rrr"r expanduserrBr;r!rCr@rAr6r)rrr effective_carfs$$$ r resolve_httpx_verifyr,s$ ## 0  4 44  OO**,LL!,,. <<>>"3t||~#67 7 V   zz~~o&&"**..*H*Ht$$  r)F)$__conditional_annotations____doc__ __future__rloggingr@r( threadingpathlibrtypingrr getLogger__name__rr__annotations__rr$r%Lockr5r.r;rErFrSrPrNrTrtrurprr)rs@r rs*#    8 $ K<?A ;@NN$ $. !4605^^%'8> ;F,>)- ,"0D+#++ ++r