tPj*UdZddlZddlZddlZddlZddlmZddlm Z ddl m Z m Z m Z ddl mZmZddlmZddlmZdd lmZd Zeed <d Zeed <dZeed<ededededZeed<dZeed<ehdZeeeed<ehdZeeeed<dee zdzdede fdZ!dedefdZ"dedefd Z#e d!d!"Gd#d$Z$d%ede$fd&Z%e d!d!"Gd'd(Z&e d!d!"Gd)d*Z'e&e'zZ(eed+<d,e(d-e$defd.Z)d,e(d/ede dzfd0Z*d/ede dzfd1Z+Gd2d3eZ,d/ede dzfd4Z-ej\degeffd5Z/d6e d7e de(dzfd8Z0de(dzfd9Z1y):aMToken-based authentication for the proxy's Postgres connection. Two managed Postgres offerings hand the client a short-lived credential that is used as the Postgres password: AWS RDS with IAM auth, and Azure Database for PostgreSQL Flexible Server with Microsoft Entra ID. Both need the same machinery (mint at startup, read the expiry back off the token, mint again before it lapses) and differ only in how the token is produced and how its expiry is encoded, so the difference lives in a tagged union that is resolved once from the environment and injected into whatever needs a token. N)Callable) dataclass)datetime timedeltatimezone)Final TypeAlias) BaseModel) assert_never)verbose_proxy_loggerIAM_TOKEN_DB_AUTHIAM_TOKEN_DB_AUTH_ENV_VARAZURE_POSTGRESQL_AUTHAZURE_POSTGRESQL_AUTH_ENV_VARz2https://ossrdbms-aad.database.windows.net/.defaultAZURE_POSTGRESQL_SCOPEz and zW are both enabled, but the database password can only come from one token source. Keep z for AWS RDS IAM auth, or zT for Azure Database for PostgreSQL with Microsoft Entra ID, and unset the other one.CONFLICTING_TOKEN_AUTH_MESSAGE5432DEFAULT_POSTGRES_PORT>1tyonyestrueTRUTHY_TOKEN_AUTH_VALUES>0fnnoofffalseFALSY_TOKEN_AUTH_VALUESvalueenv_varreturnc8t|tr|S|y|jj}|tvry|t vryt |d|ddjttddjtdt Dd) aWhether a token-auth toggle is on, rejecting anything it cannot read. The single parser for both toggles. Every entry point (the settings model, the CLI, and the refresh loop's own env lookup) routes through this, so a value like ``"1"`` cannot enable minting in one place and leave the refresh loop convinced token auth is off, which would strand a pod on a token it never renews. A value that is neither recognizably on nor recognizably off raises: silently reading a typo as off would downgrade an operator from token auth to password auth, and the first sign of it would be a connection refused by the server. FT=z/ is not a recognized boolean. Set it to one of z, z to turn it on, or to one of c3&K|] }|s| ywN).0vs `/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/litellm/proxy/db/token_auth.py z*token_auth_flag_enabled..BsD!!ADsz to turn it off.) isinstanceboolstriplowerrr# ValueErrorjoinsorted)r$r% normalizeds r.token_auth_flag_enabledr8*s%  } ++-J--,,  )1UIL 99V45 6 77T 99VD'>DD E FFV X cDtjj|dS)Nrsafe)urllibparsequoter$s r._quoterAFs <<  e"  --r9c~tjjtjj|dS)aPercent-encode a URL component that may already be percent-encoded. ``DATABASE_USER`` used to be interpolated raw, so pre-encoding was the only way to put an ``@`` in it. Encoding such a value again would double-escape it, so decode first: the round trip is idempotent and leaves an already-encoded value byte for byte as it was, while a raw UPN like ``svc@corp`` still comes out encoded. rr;)r=r>r?unquoter@s r._normalize_quoterDJs- <<  fll2259  CCr9T)frozenslotsc^eZdZUdZeed<eed<eed<eed<dZedzed<ded efd Zy) IAMEndpointaFStatic parts of a token-authenticated Postgres connection. The token rotates every few minutes to an hour depending on the provider; everything else (host, port, user, database name, schema) stays fixed. Capturing the static fields once means a refresh only regenerates the token and reassembles the URL. hostportusernameNschematokenr&c dt|jd|d|jd|jdt|j }|j s|S|dt|j S)aAssemble the connection URL, inserting ``token`` verbatim as the password. User, database name, and schema are normalized rather than encoded outright, because an Entra principal is a UPN containing ``@`` while an operator on the older RDS path may already have encoded that ``@`` themselves. The token is left alone: both providers hand it back already in wire form, and re-encoding it would double-escape the password. z postgresql://:@/z?schema=)rDrKrIrJrLrM)selfrNbases r. build_urlzIAMEndpoint.build_urlesw,TYY78%$))Adii[XYZjkoktktZuYv w {{Kx 0 =>??r9)__name__ __module__ __qualname____doc__str__annotations__rMrUr+r9r.rHrHUsA I I I IFC$J@s@s@r9rHurlctjj|}|jr |js t dtjj |jxsdjd}|s t d|jrt|jnt}|jr8tjj|jjdnd}t|j|tjj |j||r |dSdS)zParse an :class:`IAMEndpoint` back out of a Postgres URL. Used so a reader URL can drive its own token refresh without requiring callers to set parallel ``DATABASE_HOST_READ_REPLICA`` / etc. env vars. zurlparsehostnameusernamer4rCpathlstriprJrZrqueryparse_qsgetrH)r\parsedrLrJ schema_valuess r.parse_iam_endpoint_from_urlrhvs LL))#.F ??&//WXX,,&& (:s'B'B3'GHD TUU&,kk#fkk"7LDPVP\P\6<<00>BB8LbfM  __  \\ ! !&// 2 #0}Q   7;  r9c<eZdZdZedefdZedefdZy)RdsIamTokenAuthzRAWS RDS IAM auth: a SigV4-presigned token minted from the ambient AWS credentials.r&cy)Nz RDS IAM tokenr+rSs r.labelzRdsIamTokenAuth.labelsr9ctSr*)rrls r.r%zRdsIamTokenAuth.env_vars((r9N)rVrWrXrYpropertyrZrmr%r+r9r.rjrjs9\ s)))r9rjcReZdZUdZegefed<edefdZedefdZ y)AzureEntraTokenAuthzAzure Database for PostgreSQL auth: a Microsoft Entra ID access token as the password. The provider is injected rather than resolved here so callers (and tests) decide which Azure credential mints the token. token_providerr&cy)NzAzure Entra tokenr+rls r.rmzAzureEntraTokenAuth.labels"r9ctSr*)rrls r.r%zAzureEntraTokenAuth.env_vars,,r9N) rVrWrXrYrrZr[rormr%r+r9r.rqrqsL RW%% #s##---r9rqDatabaseTokenAuthauthendpointc|xtdx2\ddlm}||j|j|j St dx\t|jS t|y)zIMint a fresh database password for ``endpoint``, already percent-encoded.r+Nr)generate_iam_auth_token)db_hostdb_portdb_user) rj litellm.proxy.auth.rds_iam_tokenryrIrJrKrqrArrr )rvrwrys r.mint_database_tokenr~s_  _  P*8==(--aianano o! "$--/0 0#   r9rNc~|xtdx\t|Stdx \t|S t |y)zReturn when ``token`` expires as a naive UTC datetime, or None when unreadable. Callers fall back to a fixed refresh interval on None, so an unparseable token degrades to periodic refresh instead of failing. r+N)rj_parse_rds_token_expirationrq_parse_entra_token_expirationr )rvrNs r.parse_database_token_expirationrs@  _ .u5 5 "07 7#   r9cd|vry tjj|jddd}|j d}|j d}|r|syt j |dd}|tt|dzS#tttf$r }tjd|Yd}~yd}~wwxYw) N?z X-Amz-Expiresz X-Amz-Daterz%Y%m%dT%H%M%SZ)secondsz,Failed to parse RDS IAM token expiration: %s)r=r>rdsplitrerstrptimerintr4 OverflowErrorOSErrorr debug)rNparamsexpires_values date_valuescreatedexcs r.rrs %  --ekk#q.A!.DE & ? ;#ZZ 5 [!**;q>;KL3~a/@+ABBB  w /""#QSVWsAB 3BC(CCceZdZUeed<y)_EntraAccessTokenClaimsexpN)rVrWrXrr[r+r9r.rrs Hr9rc |jd}t|dk7ry|d} tjt j |dt| dzzz}tj|jtjjdS#t $r }tjd|Yd}~yd}~wwxYw) N.rr(z0Failed to parse Azure Entra token expiration: %s)tz)tzinfo)rlenrmodel_validate_jsonbase64urlsafe_b64decoder4r rr fromtimestamprrutcreplace)rNsegmentspayloadclaimsrs r.rrskk#&H 8}a[G/CC  $ $Wss7|ma6G/H%H I   ! !&** > F Fd F SS ""#UWZ[s;B!! C *CC c(ddlm}|tS)aGThe process-wide Entra token provider for the Azure Postgres OSS RDBMS scope. Cached because the writer URL, the reader URL, and the refresh loop each ask for a strategy, and every uncached call would build another Azure credential with its own HTTP transport and its own token cache that nothing ever closes. rget_azure_ad_token_provider) azure_scope)3litellm.secret_managers.get_azure_ad_token_providerrrrs r. build_azure_entra_token_providerrs '3I JJr9iam_token_db_authazure_postgresql_authcn|r|rtt|rttS|r t Sy)zLPick the token strategy the two toggles ask for, or None when neither is on.)rrN) RuntimeErrorrrqrrjrrs r.build_database_token_authrs529::"2R2TUU  r9ctttjttttjt t S)zSResolve the token strategy from the environment, raising when both toggles are set.)r%r)rr8osgetenvrrr+r9r.resolve_database_token_authr sA $1 II/ 0:S 6 II3 4>[  r9)2rYr functoolsr urllib.parser=collections.abcr dataclassesrrrrtypingrr pydanticr typing_extensionsr litellm._loggingr rr[rrrr frozensetrrZr#r1r8rArDrHrhrjrqrur~rrrrcacherrrr+r9r.rs~ $!22#*1#656'>u> TT!!'D&EFC !!;