Hubuum client library (Rust): Sensitive data may be exposed through default diagnostics
Low
Network
Low
Low
None
Summary
hubuum_client diagnostics can expose sensitive request, response, import/export, task, delivery, or server-provided data when applications format or log errors and public models.
Affected behavior
Native reqwest::Error values retain the full request URL. Converting those errors into ApiError::Http, or exhausting retries and storing the error text in ApiError::RetryExhausted, preserves query parameter values. Detailed HTTP and decoding errors can retain server-provided messages, response bodies, or payload details, including through error source chains.
Several public response and model types also derived or implemented diagnostics over untrusted or secret-adjacent fields. These include raw response bodies and cursors; rendered and JSON export payloads; import schemas and object data; task summaries, links, output URLs, events, and import-result details; event-delivery claims and errors; event sink configuration; subscription routing; and remote-call failure details. High-level backup and export runners additionally copied unsuccessful server task summaries into ApiError::Api.
Applications commonly log errors and response values, so credentials, tokens, cursors, filters, echoed request content, imported object data, schema defaults, task or delivery details, and other sensitive payloads can be written to logs even though normal request logging redacts query values.
Remediation
The proposed fix redacts query values from embedded request URLs before storing native HTTP errors and applies the same sanitization to exhausted retries. Default error and model diagnostics now report safe metadata rather than server messages, payloads, cursors, links, configuration, or secret-adjacent details. JSON codec errors no longer appear in the standard source chain, and unsuccessful high-level backup/export operations use the structured TaskUnsuccessful variant without copying task summaries.
Explicit response, error, task, import, export, event, and delivery APIs continue to expose original values for applications that deliberately inspect them.
Validation
Regression coverage exercises direct HTTP conversion, async and blocking retry exhaustion, response and decoding diagnostics, import/export/raw-response containers, unsuccessful async and blocking task runners, task/event/import-result models, and secret-bearing event and remote models. The workspace format, lint, documentation, test, feature-matrix, Rust 1.88 MSRV, OpenAPI validation, release-metadata, and combined library plus consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Configured custom transports may be bypassed, exposing credentials and network traffic
Medium
Network
Low
None
None
Summary
When an application configures hubuum_client with ClientBuilder::with_transport, several client operations still use the built-in reqwest client directly. The bypass includes password login, bearer-token validation, authentication-provider discovery, health and readiness probes, export-output downloads, and unified-search streams.
Impact
Applications may use a custom transport as a security boundary for network isolation, proxy enforcement, request signing, audit logging, or policy checks. Affected operations bypass those controls and make direct network requests to the configured base URL. Password login can therefore send plaintext credentials outside the intended transport, while token validation can send a bearer token outside it. Other bypassing calls can evade audit and routing policy.
The issue affects custom transports introduced in 0.3.0. Applications that do not configure a custom transport are not affected by the bypass.
Defense in depth
The same private fix disables redirect following for built-in async and blocking clients so an authenticated request remains at the endpoint validated and constructed by the client. Applications supplying a preconfigured reqwest client continue to control its redirect policy.
Remediation
The proposed fix routes authentication, public discovery and probe calls, export downloads, unified-search streams, raw requests, and typed requests through the configured transport in both async and blocking clients. It preserves retry and error-body policies, documents the buffering semantics of custom transports, and surfaces built-in-client redirects as 3xx API errors.
Validation
Regression tests assert async and blocking routing, paths, login bodies, bearer headers, streaming bodies, retries, error handling, and redirect behavior. Formatting, Clippy with warnings denied, rustdoc warnings, the complete workspace suite, all supported feature combinations, Rust 1.88 MSRV, OpenAPI validation, and the combined library plus downstream-consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Authenticated requests may escape the configured base path through redirects
Medium
Network
Low
None
None
Impact
The built-in async and blocking clients used reqwest's default redirect policy. BaseUrl constrains the initial request to the configured origin and path prefix, but redirect processing occurs after that validation. reqwest retains sensitive headers when a redirect changes only the path on the same scheme, host, and port. A redirect from a Hubuum endpoint to another path on a shared origin could therefore carry the bearer Authorization header outside the configured Hubuum path prefix.
Exploitation requires an attacker, compromised server, or intermediary to influence a 3xx response. Cross-origin redirects are not affected because reqwest strips sensitive headers when scheme, host, or port changes.
Patches
Version 0.6.1 configures both built-in HTTP clients with reqwest::redirect::Policy::none(). Redirect responses are returned as 3xx API errors instead of being followed. Supplying a preconfigured reqwest client remains an explicit opt-in to that client's redirect policy.
Workarounds
On affected versions, construct a reqwest client with reqwest::redirect::Policy::none() and pass it through with_http_client. Deployments can also reduce exposure by ensuring the Hubuum origin is not shared with other applications and that trusted infrastructure never redirects API requests outside the configured path prefix.
Hubuum client library (Rust): Sensitive data may be exposed through default diagnostics
Low
Network
Low
Low
None
Summary
hubuum_client diagnostics can expose sensitive request, response, import/export, task, delivery, or server-provided data when applications format or log errors and public models.
Affected behavior
Native reqwest::Error values retain the full request URL. Converting those errors into ApiError::Http, or exhausting retries and storing the error text in ApiError::RetryExhausted, preserves query parameter values. Detailed HTTP and decoding errors can retain server-provided messages, response bodies, or payload details, including through error source chains.
Several public response and model types also derived or implemented diagnostics over untrusted or secret-adjacent fields. These include raw response bodies and cursors; rendered and JSON export payloads; import schemas and object data; task summaries, links, output URLs, events, and import-result details; event-delivery claims and errors; event sink configuration; subscription routing; and remote-call failure details. High-level backup and export runners additionally copied unsuccessful server task summaries into ApiError::Api.
Applications commonly log errors and response values, so credentials, tokens, cursors, filters, echoed request content, imported object data, schema defaults, task or delivery details, and other sensitive payloads can be written to logs even though normal request logging redacts query values.
Remediation
The proposed fix redacts query values from embedded request URLs before storing native HTTP errors and applies the same sanitization to exhausted retries. Default error and model diagnostics now report safe metadata rather than server messages, payloads, cursors, links, configuration, or secret-adjacent details. JSON codec errors no longer appear in the standard source chain, and unsuccessful high-level backup/export operations use the structured TaskUnsuccessful variant without copying task summaries.
Explicit response, error, task, import, export, event, and delivery APIs continue to expose original values for applications that deliberately inspect them.
Validation
Regression coverage exercises direct HTTP conversion, async and blocking retry exhaustion, response and decoding diagnostics, import/export/raw-response containers, unsuccessful async and blocking task runners, task/event/import-result models, and secret-bearing event and remote models. The workspace format, lint, documentation, test, feature-matrix, Rust 1.88 MSRV, OpenAPI validation, release-metadata, and combined library plus consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Configured custom transports may be bypassed, exposing credentials and network traffic
Medium
Network
Low
None
None
Summary
When an application configures hubuum_client with ClientBuilder::with_transport, several client operations still use the built-in reqwest client directly. The bypass includes password login, bearer-token validation, authentication-provider discovery, health and readiness probes, export-output downloads, and unified-search streams.
Impact
Applications may use a custom transport as a security boundary for network isolation, proxy enforcement, request signing, audit logging, or policy checks. Affected operations bypass those controls and make direct network requests to the configured base URL. Password login can therefore send plaintext credentials outside the intended transport, while token validation can send a bearer token outside it. Other bypassing calls can evade audit and routing policy.
The issue affects custom transports introduced in 0.3.0. Applications that do not configure a custom transport are not affected by the bypass.
Defense in depth
The same private fix disables redirect following for built-in async and blocking clients so an authenticated request remains at the endpoint validated and constructed by the client. Applications supplying a preconfigured reqwest client continue to control its redirect policy.
Remediation
The proposed fix routes authentication, public discovery and probe calls, export downloads, unified-search streams, raw requests, and typed requests through the configured transport in both async and blocking clients. It preserves retry and error-body policies, documents the buffering semantics of custom transports, and surfaces built-in-client redirects as 3xx API errors.
Validation
Regression tests assert async and blocking routing, paths, login bodies, bearer headers, streaming bodies, retries, error handling, and redirect behavior. Formatting, Clippy with warnings denied, rustdoc warnings, the complete workspace suite, all supported feature combinations, Rust 1.88 MSRV, OpenAPI validation, and the combined library plus downstream-consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Authenticated requests may escape the configured base path through redirects
Medium
Network
Low
None
None
Impact
The built-in async and blocking clients used reqwest's default redirect policy. BaseUrl constrains the initial request to the configured origin and path prefix, but redirect processing occurs after that validation. reqwest retains sensitive headers when a redirect changes only the path on the same scheme, host, and port. A redirect from a Hubuum endpoint to another path on a shared origin could therefore carry the bearer Authorization header outside the configured Hubuum path prefix.
Exploitation requires an attacker, compromised server, or intermediary to influence a 3xx response. Cross-origin redirects are not affected because reqwest strips sensitive headers when scheme, host, or port changes.
Patches
Version 0.6.1 configures both built-in HTTP clients with reqwest::redirect::Policy::none(). Redirect responses are returned as 3xx API errors instead of being followed. Supplying a preconfigured reqwest client remains an explicit opt-in to that client's redirect policy.
Workarounds
On affected versions, construct a reqwest client with reqwest::redirect::Policy::none() and pass it through with_http_client. Deployments can also reduce exposure by ensuring the Hubuum origin is not shared with other applications and that trusted infrastructure never redirects API requests outside the configured path prefix.
Hubuum client library (Rust): Sensitive data may be exposed through default diagnostics
Low
Network
Low
Low
None
Summary
hubuum_client diagnostics can expose sensitive request, response, import/export, task, delivery, or server-provided data when applications format or log errors and public models.
Affected behavior
Native reqwest::Error values retain the full request URL. Converting those errors into ApiError::Http, or exhausting retries and storing the error text in ApiError::RetryExhausted, preserves query parameter values. Detailed HTTP and decoding errors can retain server-provided messages, response bodies, or payload details, including through error source chains.
Several public response and model types also derived or implemented diagnostics over untrusted or secret-adjacent fields. These include raw response bodies and cursors; rendered and JSON export payloads; import schemas and object data; task summaries, links, output URLs, events, and import-result details; event-delivery claims and errors; event sink configuration; subscription routing; and remote-call failure details. High-level backup and export runners additionally copied unsuccessful server task summaries into ApiError::Api.
Applications commonly log errors and response values, so credentials, tokens, cursors, filters, echoed request content, imported object data, schema defaults, task or delivery details, and other sensitive payloads can be written to logs even though normal request logging redacts query values.
Remediation
The proposed fix redacts query values from embedded request URLs before storing native HTTP errors and applies the same sanitization to exhausted retries. Default error and model diagnostics now report safe metadata rather than server messages, payloads, cursors, links, configuration, or secret-adjacent details. JSON codec errors no longer appear in the standard source chain, and unsuccessful high-level backup/export operations use the structured TaskUnsuccessful variant without copying task summaries.
Explicit response, error, task, import, export, event, and delivery APIs continue to expose original values for applications that deliberately inspect them.
Validation
Regression coverage exercises direct HTTP conversion, async and blocking retry exhaustion, response and decoding diagnostics, import/export/raw-response containers, unsuccessful async and blocking task runners, task/event/import-result models, and secret-bearing event and remote models. The workspace format, lint, documentation, test, feature-matrix, Rust 1.88 MSRV, OpenAPI validation, release-metadata, and combined library plus consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Configured custom transports may be bypassed, exposing credentials and network traffic
Medium
Network
Low
None
None
Summary
When an application configures hubuum_client with ClientBuilder::with_transport, several client operations still use the built-in reqwest client directly. The bypass includes password login, bearer-token validation, authentication-provider discovery, health and readiness probes, export-output downloads, and unified-search streams.
Impact
Applications may use a custom transport as a security boundary for network isolation, proxy enforcement, request signing, audit logging, or policy checks. Affected operations bypass those controls and make direct network requests to the configured base URL. Password login can therefore send plaintext credentials outside the intended transport, while token validation can send a bearer token outside it. Other bypassing calls can evade audit and routing policy.
The issue affects custom transports introduced in 0.3.0. Applications that do not configure a custom transport are not affected by the bypass.
Defense in depth
The same private fix disables redirect following for built-in async and blocking clients so an authenticated request remains at the endpoint validated and constructed by the client. Applications supplying a preconfigured reqwest client continue to control its redirect policy.
Remediation
The proposed fix routes authentication, public discovery and probe calls, export downloads, unified-search streams, raw requests, and typed requests through the configured transport in both async and blocking clients. It preserves retry and error-body policies, documents the buffering semantics of custom transports, and surfaces built-in-client redirects as 3xx API errors.
Validation
Regression tests assert async and blocking routing, paths, login bodies, bearer headers, streaming bodies, retries, error handling, and redirect behavior. Formatting, Clippy with warnings denied, rustdoc warnings, the complete workspace suite, all supported feature combinations, Rust 1.88 MSRV, OpenAPI validation, and the combined library plus downstream-consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Authenticated requests may escape the configured base path through redirects
Medium
Network
Low
None
None
Impact
The built-in async and blocking clients used reqwest's default redirect policy. BaseUrl constrains the initial request to the configured origin and path prefix, but redirect processing occurs after that validation. reqwest retains sensitive headers when a redirect changes only the path on the same scheme, host, and port. A redirect from a Hubuum endpoint to another path on a shared origin could therefore carry the bearer Authorization header outside the configured Hubuum path prefix.
Exploitation requires an attacker, compromised server, or intermediary to influence a 3xx response. Cross-origin redirects are not affected because reqwest strips sensitive headers when scheme, host, or port changes.
Patches
Version 0.6.1 configures both built-in HTTP clients with reqwest::redirect::Policy::none(). Redirect responses are returned as 3xx API errors instead of being followed. Supplying a preconfigured reqwest client remains an explicit opt-in to that client's redirect policy.
Workarounds
On affected versions, construct a reqwest client with reqwest::redirect::Policy::none() and pass it through with_http_client. Deployments can also reduce exposure by ensuring the Hubuum origin is not shared with other applications and that trusted infrastructure never redirects API requests outside the configured path prefix.
Hubuum client library (Rust): Sensitive data may be exposed through default diagnostics
Low
Network
Low
Low
None
Summary
hubuum_client diagnostics can expose sensitive request, response, import/export, task, delivery, or server-provided data when applications format or log errors and public models.
Affected behavior
Native reqwest::Error values retain the full request URL. Converting those errors into ApiError::Http, or exhausting retries and storing the error text in ApiError::RetryExhausted, preserves query parameter values. Detailed HTTP and decoding errors can retain server-provided messages, response bodies, or payload details, including through error source chains.
Several public response and model types also derived or implemented diagnostics over untrusted or secret-adjacent fields. These include raw response bodies and cursors; rendered and JSON export payloads; import schemas and object data; task summaries, links, output URLs, events, and import-result details; event-delivery claims and errors; event sink configuration; subscription routing; and remote-call failure details. High-level backup and export runners additionally copied unsuccessful server task summaries into ApiError::Api.
Applications commonly log errors and response values, so credentials, tokens, cursors, filters, echoed request content, imported object data, schema defaults, task or delivery details, and other sensitive payloads can be written to logs even though normal request logging redacts query values.
Remediation
The proposed fix redacts query values from embedded request URLs before storing native HTTP errors and applies the same sanitization to exhausted retries. Default error and model diagnostics now report safe metadata rather than server messages, payloads, cursors, links, configuration, or secret-adjacent details. JSON codec errors no longer appear in the standard source chain, and unsuccessful high-level backup/export operations use the structured TaskUnsuccessful variant without copying task summaries.
Explicit response, error, task, import, export, event, and delivery APIs continue to expose original values for applications that deliberately inspect them.
Validation
Regression coverage exercises direct HTTP conversion, async and blocking retry exhaustion, response and decoding diagnostics, import/export/raw-response containers, unsuccessful async and blocking task runners, task/event/import-result models, and secret-bearing event and remote models. The workspace format, lint, documentation, test, feature-matrix, Rust 1.88 MSRV, OpenAPI validation, release-metadata, and combined library plus consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Configured custom transports may be bypassed, exposing credentials and network traffic
Medium
Network
Low
None
None
Summary
When an application configures hubuum_client with ClientBuilder::with_transport, several client operations still use the built-in reqwest client directly. The bypass includes password login, bearer-token validation, authentication-provider discovery, health and readiness probes, export-output downloads, and unified-search streams.
Impact
Applications may use a custom transport as a security boundary for network isolation, proxy enforcement, request signing, audit logging, or policy checks. Affected operations bypass those controls and make direct network requests to the configured base URL. Password login can therefore send plaintext credentials outside the intended transport, while token validation can send a bearer token outside it. Other bypassing calls can evade audit and routing policy.
The issue affects custom transports introduced in 0.3.0. Applications that do not configure a custom transport are not affected by the bypass.
Defense in depth
The same private fix disables redirect following for built-in async and blocking clients so an authenticated request remains at the endpoint validated and constructed by the client. Applications supplying a preconfigured reqwest client continue to control its redirect policy.
Remediation
The proposed fix routes authentication, public discovery and probe calls, export downloads, unified-search streams, raw requests, and typed requests through the configured transport in both async and blocking clients. It preserves retry and error-body policies, documents the buffering semantics of custom transports, and surfaces built-in-client redirects as 3xx API errors.
Validation
Regression tests assert async and blocking routing, paths, login bodies, bearer headers, streaming bodies, retries, error handling, and redirect behavior. Formatting, Clippy with warnings denied, rustdoc warnings, the complete workspace suite, all supported feature combinations, Rust 1.88 MSRV, OpenAPI validation, and the combined library plus downstream-consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Authenticated requests may escape the configured base path through redirects
Medium
Network
Low
None
None
Impact
The built-in async and blocking clients used reqwest's default redirect policy. BaseUrl constrains the initial request to the configured origin and path prefix, but redirect processing occurs after that validation. reqwest retains sensitive headers when a redirect changes only the path on the same scheme, host, and port. A redirect from a Hubuum endpoint to another path on a shared origin could therefore carry the bearer Authorization header outside the configured Hubuum path prefix.
Exploitation requires an attacker, compromised server, or intermediary to influence a 3xx response. Cross-origin redirects are not affected because reqwest strips sensitive headers when scheme, host, or port changes.
Patches
Version 0.6.1 configures both built-in HTTP clients with reqwest::redirect::Policy::none(). Redirect responses are returned as 3xx API errors instead of being followed. Supplying a preconfigured reqwest client remains an explicit opt-in to that client's redirect policy.
Workarounds
On affected versions, construct a reqwest client with reqwest::redirect::Policy::none() and pass it through with_http_client. Deployments can also reduce exposure by ensuring the Hubuum origin is not shared with other applications and that trusted infrastructure never redirects API requests outside the configured path prefix.
Hubuum client library (Rust): Sensitive data may be exposed through default diagnostics
Low
Network
Low
Low
None
Summary
hubuum_client diagnostics can expose sensitive request, response, import/export, task, delivery, or server-provided data when applications format or log errors and public models.
Affected behavior
Native reqwest::Error values retain the full request URL. Converting those errors into ApiError::Http, or exhausting retries and storing the error text in ApiError::RetryExhausted, preserves query parameter values. Detailed HTTP and decoding errors can retain server-provided messages, response bodies, or payload details, including through error source chains.
Several public response and model types also derived or implemented diagnostics over untrusted or secret-adjacent fields. These include raw response bodies and cursors; rendered and JSON export payloads; import schemas and object data; task summaries, links, output URLs, events, and import-result details; event-delivery claims and errors; event sink configuration; subscription routing; and remote-call failure details. High-level backup and export runners additionally copied unsuccessful server task summaries into ApiError::Api.
Applications commonly log errors and response values, so credentials, tokens, cursors, filters, echoed request content, imported object data, schema defaults, task or delivery details, and other sensitive payloads can be written to logs even though normal request logging redacts query values.
Remediation
The proposed fix redacts query values from embedded request URLs before storing native HTTP errors and applies the same sanitization to exhausted retries. Default error and model diagnostics now report safe metadata rather than server messages, payloads, cursors, links, configuration, or secret-adjacent details. JSON codec errors no longer appear in the standard source chain, and unsuccessful high-level backup/export operations use the structured TaskUnsuccessful variant without copying task summaries.
Explicit response, error, task, import, export, event, and delivery APIs continue to expose original values for applications that deliberately inspect them.
Validation
Regression coverage exercises direct HTTP conversion, async and blocking retry exhaustion, response and decoding diagnostics, import/export/raw-response containers, unsuccessful async and blocking task runners, task/event/import-result models, and secret-bearing event and remote models. The workspace format, lint, documentation, test, feature-matrix, Rust 1.88 MSRV, OpenAPI validation, release-metadata, and combined library plus consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Configured custom transports may be bypassed, exposing credentials and network traffic
Medium
Network
Low
None
None
Summary
When an application configures hubuum_client with ClientBuilder::with_transport, several client operations still use the built-in reqwest client directly. The bypass includes password login, bearer-token validation, authentication-provider discovery, health and readiness probes, export-output downloads, and unified-search streams.
Impact
Applications may use a custom transport as a security boundary for network isolation, proxy enforcement, request signing, audit logging, or policy checks. Affected operations bypass those controls and make direct network requests to the configured base URL. Password login can therefore send plaintext credentials outside the intended transport, while token validation can send a bearer token outside it. Other bypassing calls can evade audit and routing policy.
The issue affects custom transports introduced in 0.3.0. Applications that do not configure a custom transport are not affected by the bypass.
Defense in depth
The same private fix disables redirect following for built-in async and blocking clients so an authenticated request remains at the endpoint validated and constructed by the client. Applications supplying a preconfigured reqwest client continue to control its redirect policy.
Remediation
The proposed fix routes authentication, public discovery and probe calls, export downloads, unified-search streams, raw requests, and typed requests through the configured transport in both async and blocking clients. It preserves retry and error-body policies, documents the buffering semantics of custom transports, and surfaces built-in-client redirects as 3xx API errors.
Validation
Regression tests assert async and blocking routing, paths, login bodies, bearer headers, streaming bodies, retries, error handling, and redirect behavior. Formatting, Clippy with warnings denied, rustdoc warnings, the complete workspace suite, all supported feature combinations, Rust 1.88 MSRV, OpenAPI validation, and the combined library plus downstream-consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Authenticated requests may escape the configured base path through redirects
Medium
Network
Low
None
None
Impact
The built-in async and blocking clients used reqwest's default redirect policy. BaseUrl constrains the initial request to the configured origin and path prefix, but redirect processing occurs after that validation. reqwest retains sensitive headers when a redirect changes only the path on the same scheme, host, and port. A redirect from a Hubuum endpoint to another path on a shared origin could therefore carry the bearer Authorization header outside the configured Hubuum path prefix.
Exploitation requires an attacker, compromised server, or intermediary to influence a 3xx response. Cross-origin redirects are not affected because reqwest strips sensitive headers when scheme, host, or port changes.
Patches
Version 0.6.1 configures both built-in HTTP clients with reqwest::redirect::Policy::none(). Redirect responses are returned as 3xx API errors instead of being followed. Supplying a preconfigured reqwest client remains an explicit opt-in to that client's redirect policy.
Workarounds
On affected versions, construct a reqwest client with reqwest::redirect::Policy::none() and pass it through with_http_client. Deployments can also reduce exposure by ensuring the Hubuum origin is not shared with other applications and that trusted infrastructure never redirects API requests outside the configured path prefix.
Hubuum client library (Rust): Sensitive data may be exposed through default diagnostics
Low
Network
Low
Low
None
Summary
hubuum_client diagnostics can expose sensitive request, response, import/export, task, delivery, or server-provided data when applications format or log errors and public models.
Affected behavior
Native reqwest::Error values retain the full request URL. Converting those errors into ApiError::Http, or exhausting retries and storing the error text in ApiError::RetryExhausted, preserves query parameter values. Detailed HTTP and decoding errors can retain server-provided messages, response bodies, or payload details, including through error source chains.
Several public response and model types also derived or implemented diagnostics over untrusted or secret-adjacent fields. These include raw response bodies and cursors; rendered and JSON export payloads; import schemas and object data; task summaries, links, output URLs, events, and import-result details; event-delivery claims and errors; event sink configuration; subscription routing; and remote-call failure details. High-level backup and export runners additionally copied unsuccessful server task summaries into ApiError::Api.
Applications commonly log errors and response values, so credentials, tokens, cursors, filters, echoed request content, imported object data, schema defaults, task or delivery details, and other sensitive payloads can be written to logs even though normal request logging redacts query values.
Remediation
The proposed fix redacts query values from embedded request URLs before storing native HTTP errors and applies the same sanitization to exhausted retries. Default error and model diagnostics now report safe metadata rather than server messages, payloads, cursors, links, configuration, or secret-adjacent details. JSON codec errors no longer appear in the standard source chain, and unsuccessful high-level backup/export operations use the structured TaskUnsuccessful variant without copying task summaries.
Explicit response, error, task, import, export, event, and delivery APIs continue to expose original values for applications that deliberately inspect them.
Validation
Regression coverage exercises direct HTTP conversion, async and blocking retry exhaustion, response and decoding diagnostics, import/export/raw-response containers, unsuccessful async and blocking task runners, task/event/import-result models, and secret-bearing event and remote models. The workspace format, lint, documentation, test, feature-matrix, Rust 1.88 MSRV, OpenAPI validation, release-metadata, and combined library plus consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Authenticated requests may escape the configured base path through redirects
Medium
Network
Low
None
None
Impact
The built-in async and blocking clients used reqwest's default redirect policy. BaseUrl constrains the initial request to the configured origin and path prefix, but redirect processing occurs after that validation. reqwest retains sensitive headers when a redirect changes only the path on the same scheme, host, and port. A redirect from a Hubuum endpoint to another path on a shared origin could therefore carry the bearer Authorization header outside the configured Hubuum path prefix.
Exploitation requires an attacker, compromised server, or intermediary to influence a 3xx response. Cross-origin redirects are not affected because reqwest strips sensitive headers when scheme, host, or port changes.
Patches
Version 0.6.1 configures both built-in HTTP clients with reqwest::redirect::Policy::none(). Redirect responses are returned as 3xx API errors instead of being followed. Supplying a preconfigured reqwest client remains an explicit opt-in to that client's redirect policy.
Workarounds
On affected versions, construct a reqwest client with reqwest::redirect::Policy::none() and pass it through with_http_client. Deployments can also reduce exposure by ensuring the Hubuum origin is not shared with other applications and that trusted infrastructure never redirects API requests outside the configured path prefix.
Hubuum client library (Rust): Sensitive data may be exposed through default diagnostics
Low
Network
Low
Low
None
Summary
hubuum_client diagnostics can expose sensitive request, response, import/export, task, delivery, or server-provided data when applications format or log errors and public models.
Affected behavior
Native reqwest::Error values retain the full request URL. Converting those errors into ApiError::Http, or exhausting retries and storing the error text in ApiError::RetryExhausted, preserves query parameter values. Detailed HTTP and decoding errors can retain server-provided messages, response bodies, or payload details, including through error source chains.
Several public response and model types also derived or implemented diagnostics over untrusted or secret-adjacent fields. These include raw response bodies and cursors; rendered and JSON export payloads; import schemas and object data; task summaries, links, output URLs, events, and import-result details; event-delivery claims and errors; event sink configuration; subscription routing; and remote-call failure details. High-level backup and export runners additionally copied unsuccessful server task summaries into ApiError::Api.
Applications commonly log errors and response values, so credentials, tokens, cursors, filters, echoed request content, imported object data, schema defaults, task or delivery details, and other sensitive payloads can be written to logs even though normal request logging redacts query values.
Remediation
The proposed fix redacts query values from embedded request URLs before storing native HTTP errors and applies the same sanitization to exhausted retries. Default error and model diagnostics now report safe metadata rather than server messages, payloads, cursors, links, configuration, or secret-adjacent details. JSON codec errors no longer appear in the standard source chain, and unsuccessful high-level backup/export operations use the structured TaskUnsuccessful variant without copying task summaries.
Explicit response, error, task, import, export, event, and delivery APIs continue to expose original values for applications that deliberately inspect them.
Validation
Regression coverage exercises direct HTTP conversion, async and blocking retry exhaustion, response and decoding diagnostics, import/export/raw-response containers, unsuccessful async and blocking task runners, task/event/import-result models, and secret-bearing event and remote models. The workspace format, lint, documentation, test, feature-matrix, Rust 1.88 MSRV, OpenAPI validation, release-metadata, and combined library plus consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Authenticated requests may escape the configured base path through redirects
Medium
Network
Low
None
None
Impact
The built-in async and blocking clients used reqwest's default redirect policy. BaseUrl constrains the initial request to the configured origin and path prefix, but redirect processing occurs after that validation. reqwest retains sensitive headers when a redirect changes only the path on the same scheme, host, and port. A redirect from a Hubuum endpoint to another path on a shared origin could therefore carry the bearer Authorization header outside the configured Hubuum path prefix.
Exploitation requires an attacker, compromised server, or intermediary to influence a 3xx response. Cross-origin redirects are not affected because reqwest strips sensitive headers when scheme, host, or port changes.
Patches
Version 0.6.1 configures both built-in HTTP clients with reqwest::redirect::Policy::none(). Redirect responses are returned as 3xx API errors instead of being followed. Supplying a preconfigured reqwest client remains an explicit opt-in to that client's redirect policy.
Workarounds
On affected versions, construct a reqwest client with reqwest::redirect::Policy::none() and pass it through with_http_client. Deployments can also reduce exposure by ensuring the Hubuum origin is not shared with other applications and that trusted infrastructure never redirects API requests outside the configured path prefix.
Hubuum client library (Rust): Sensitive data may be exposed through default diagnostics
Low
Network
Low
Low
None
Summary
hubuum_client diagnostics can expose sensitive request, response, import/export, task, delivery, or server-provided data when applications format or log errors and public models.
Affected behavior
Native reqwest::Error values retain the full request URL. Converting those errors into ApiError::Http, or exhausting retries and storing the error text in ApiError::RetryExhausted, preserves query parameter values. Detailed HTTP and decoding errors can retain server-provided messages, response bodies, or payload details, including through error source chains.
Several public response and model types also derived or implemented diagnostics over untrusted or secret-adjacent fields. These include raw response bodies and cursors; rendered and JSON export payloads; import schemas and object data; task summaries, links, output URLs, events, and import-result details; event-delivery claims and errors; event sink configuration; subscription routing; and remote-call failure details. High-level backup and export runners additionally copied unsuccessful server task summaries into ApiError::Api.
Applications commonly log errors and response values, so credentials, tokens, cursors, filters, echoed request content, imported object data, schema defaults, task or delivery details, and other sensitive payloads can be written to logs even though normal request logging redacts query values.
Remediation
The proposed fix redacts query values from embedded request URLs before storing native HTTP errors and applies the same sanitization to exhausted retries. Default error and model diagnostics now report safe metadata rather than server messages, payloads, cursors, links, configuration, or secret-adjacent details. JSON codec errors no longer appear in the standard source chain, and unsuccessful high-level backup/export operations use the structured TaskUnsuccessful variant without copying task summaries.
Explicit response, error, task, import, export, event, and delivery APIs continue to expose original values for applications that deliberately inspect them.
Validation
Regression coverage exercises direct HTTP conversion, async and blocking retry exhaustion, response and decoding diagnostics, import/export/raw-response containers, unsuccessful async and blocking task runners, task/event/import-result models, and secret-bearing event and remote models. The workspace format, lint, documentation, test, feature-matrix, Rust 1.88 MSRV, OpenAPI validation, release-metadata, and combined library plus consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Authenticated requests may escape the configured base path through redirects
Medium
Network
Low
None
None
Impact
The built-in async and blocking clients used reqwest's default redirect policy. BaseUrl constrains the initial request to the configured origin and path prefix, but redirect processing occurs after that validation. reqwest retains sensitive headers when a redirect changes only the path on the same scheme, host, and port. A redirect from a Hubuum endpoint to another path on a shared origin could therefore carry the bearer Authorization header outside the configured Hubuum path prefix.
Exploitation requires an attacker, compromised server, or intermediary to influence a 3xx response. Cross-origin redirects are not affected because reqwest strips sensitive headers when scheme, host, or port changes.
Patches
Version 0.6.1 configures both built-in HTTP clients with reqwest::redirect::Policy::none(). Redirect responses are returned as 3xx API errors instead of being followed. Supplying a preconfigured reqwest client remains an explicit opt-in to that client's redirect policy.
Workarounds
On affected versions, construct a reqwest client with reqwest::redirect::Policy::none() and pass it through with_http_client. Deployments can also reduce exposure by ensuring the Hubuum origin is not shared with other applications and that trusted infrastructure never redirects API requests outside the configured path prefix.
Hubuum client library (Rust): Sensitive data may be exposed through default diagnostics
Low
Network
Low
Low
None
Summary
hubuum_client diagnostics can expose sensitive request, response, import/export, task, delivery, or server-provided data when applications format or log errors and public models.
Affected behavior
Native reqwest::Error values retain the full request URL. Converting those errors into ApiError::Http, or exhausting retries and storing the error text in ApiError::RetryExhausted, preserves query parameter values. Detailed HTTP and decoding errors can retain server-provided messages, response bodies, or payload details, including through error source chains.
Several public response and model types also derived or implemented diagnostics over untrusted or secret-adjacent fields. These include raw response bodies and cursors; rendered and JSON export payloads; import schemas and object data; task summaries, links, output URLs, events, and import-result details; event-delivery claims and errors; event sink configuration; subscription routing; and remote-call failure details. High-level backup and export runners additionally copied unsuccessful server task summaries into ApiError::Api.
Applications commonly log errors and response values, so credentials, tokens, cursors, filters, echoed request content, imported object data, schema defaults, task or delivery details, and other sensitive payloads can be written to logs even though normal request logging redacts query values.
Remediation
The proposed fix redacts query values from embedded request URLs before storing native HTTP errors and applies the same sanitization to exhausted retries. Default error and model diagnostics now report safe metadata rather than server messages, payloads, cursors, links, configuration, or secret-adjacent details. JSON codec errors no longer appear in the standard source chain, and unsuccessful high-level backup/export operations use the structured TaskUnsuccessful variant without copying task summaries.
Explicit response, error, task, import, export, event, and delivery APIs continue to expose original values for applications that deliberately inspect them.
Validation
Regression coverage exercises direct HTTP conversion, async and blocking retry exhaustion, response and decoding diagnostics, import/export/raw-response containers, unsuccessful async and blocking task runners, task/event/import-result models, and secret-bearing event and remote models. The workspace format, lint, documentation, test, feature-matrix, Rust 1.88 MSRV, OpenAPI validation, release-metadata, and combined library plus consumer integration suites pass against the immutable Hubuum 0.0.3 image.
Hubuum client library (Rust): Authenticated requests may escape the configured base path through redirects
Medium
Network
Low
None
None
Impact
The built-in async and blocking clients used reqwest's default redirect policy. BaseUrl constrains the initial request to the configured origin and path prefix, but redirect processing occurs after that validation. reqwest retains sensitive headers when a redirect changes only the path on the same scheme, host, and port. A redirect from a Hubuum endpoint to another path on a shared origin could therefore carry the bearer Authorization header outside the configured Hubuum path prefix.
Exploitation requires an attacker, compromised server, or intermediary to influence a 3xx response. Cross-origin redirects are not affected because reqwest strips sensitive headers when scheme, host, or port changes.
Patches
Version 0.6.1 configures both built-in HTTP clients with reqwest::redirect::Policy::none(). Redirect responses are returned as 3xx API errors instead of being followed. Supplying a preconfigured reqwest client remains an explicit opt-in to that client's redirect policy.
Workarounds
On affected versions, construct a reqwest client with reqwest::redirect::Policy::none() and pass it through with_http_client. Deployments can also reduce exposure by ensuring the Hubuum origin is not shared with other applications and that trusted infrastructure never redirects API requests outside the configured path prefix.