Summary
ArthurFiorette steam-trader 2.1.1 exposes highly sensitive Steam account data via an unauthenticated /users API endpoint and verbose application logging.
An attacker who can reach the service can retrieve credentials, 2FA secrets, and tokens, enabling full account takeover and unauthorized access to Steam inventory and trading features.
Affected context
The vulnerability appears in the steam-trader backend service where Steam account details are stored and processed to automate trading.
It affects deployments that:
- Expose the /users API endpoint over a network (e.g., internet or internal LAN)
- Store Steam credentials and secrets in the application database or memory
- Log authentication-related artifacts (tokens, session identifiers, secrets) without redaction
Any environment running steam-trader 2.1.1, especially if reachable from untrusted networks, may inadvertently disclose sensitive authentication material.
Exploit preconditions
- Attack surface: HTTP API exposed by steam-trader, specifically the
/usersendpoint, and access to log files where the application runs. - Required access:
- Network access to the running steam-trader instance (no authentication required for the vulnerable endpoint).
- Optional file or log aggregation access to read application logs, if those are accessible to an attacker (e.g., misconfigured log viewers, shared volumes, or centralized logging).
- Trigger point:
- Sending a crafted or even simple HTTP request to
/usersresults in the API returning Steam account details, including username, password, identity secret, and shared secret. - Reviewing application logs exposes access tokens, refresh tokens, and session identifiers tied to Steam accounts.
- Why exploitation is possible:
- The API endpoint lacks proper authentication and authorization, allowing unauthenticated querying of user records.
- Sensitive data fields are not scrubbed, minimized, or masked before being returned in API responses.
- Logging configuration captures and stores authentication artifacts in plaintext without redaction or segregation, violating least-privilege data handling practices.
Why this happens
This vulnerability stems from a combination of insecure data exposure and overly verbose logging.
At the API layer, the /users endpoint appears to return complete user objects, including credentials and 2FA secrets, without enforcing authentication or applying field-level filtering.
This aligns with CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, as data intended to remain confidential is directly exposed to unauthenticated callers.
Additionally, the logging subsystem records authentication artifacts such as access tokens, refresh tokens, and session identifiers in plaintext.
This behavior is characteristic of CWE-532: Insertion of Sensitive Information into Log File, where logs become an unintended secondary data store for secrets.
Conceptually, the root causes are:
- Treating highly sensitive secrets (passwords, identity secrets, shared secrets, tokens) as regular application data rather than protected credentials.
- Failing to enforce strong access control at API boundaries.
- Missing data minimization and redaction steps both in API responses and in logging.
Potential impact
- An attacker may obtain Steam account usernames and passwords.
- An attacker may retrieve Steam Guard–related secrets (identity secret, shared secret) and generate valid 2FA codes.
- An attacker may capture access tokens, refresh tokens, and session identifiers from logs, enabling session hijacking.
- An attacker could gain full control over affected Steam accounts, including access to inventory, trading, and marketplace operations.
- Compromised accounts may be used for fraudulent trades, theft of digital items, or abuse of marketplace functionality.
- Exposed secrets in logs can be reused in other environments if passwords or tokens are reused across services.
General mitigation guidance
Since the project is archived and not maintained, mitigation relies on deployment-side protections and general secure design patterns rather than code fixes in the original repository.
Recommended patterns include:
- Remove or isolate the service:
- Avoid deploying unmaintained services that handle credentials or 2FA secrets.
- If the tool must be used, place it in a strictly isolated, trusted environment without external network exposure.
- Enforce strict access control at the API boundary:
- Introduce an API gateway or reverse proxy to require strong authentication and authorization for all endpoints, especially any that return user data.
- Implement IP allowlists or VPN-only access to the service where possible.
- Apply data minimization and response filtering:
- Ensure only non-sensitive attributes are ever exposed from user-related endpoints via transformation layers (e.g., reverse proxy that strips fields, or a wrapper service).
- Treat passwords, secrets, and tokens as write-only values that are never returned in responses once stored.
- Harden logging practices:
- Configure logging infrastructure to avoid recording secrets, tokens, or full request/response bodies containing sensitive fields.
- Introduce log scrubbing/redaction policies that automatically mask known secret fields before log storage.
- Segregate access to logs so that only a minimal set of administrators can read them.
- Secret management hygiene:
- Store credentials and 2FA secrets in dedicated secret management systems rather than application databases where possible.
- Rotate all passwords, tokens, and Steam Guard secrets that may have been handled by the affected deployment.
- Principle of least privilege:
- Run the service with minimal permissions and isolate it in the network to reduce the blast radius if data is exposed.
- Restrict database access so that only strictly required fields are accessible to the application layer.
How teams detect issues like this
High-level strategies for identifying and monitoring such issues include:
- Static analysis and code review:
- Search for API handlers that return full user records or credential fields without explicit authorization checks.
- Flag any serialization of sensitive attributes (passwords, tokens, secrets) in response bodies.
- Identify logging statements that include authentication headers, tokens, full request objects, or credential-related variables.
- Security-focused API review:
- Catalogue all endpoints and classify the sensitivity of data they handle.
- Verify that endpoints returning user or account information are protected with appropriate authentication and authorization.
- Confirm that any debug or admin endpoints are disabled or locked down in production.
- Logging and telemetry audits:
- Inspect log samples for presence of passwords, tokens, Steam Guard secrets, session identifiers, or full request bodies.
- Configure automated scanners in log pipelines to detect patterns resembling tokens or shared secrets and raise alerts.
- Runtime monitoring and WAF rules:
- Use application firewalls or API gateways to monitor and rate-limit access to sensitive endpoints like
/users. - Detect anomalous enumeration behavior (e.g., repeated unauthenticated calls to user-related endpoints).
- Automated security tooling:
- Apply API security scanners to probe for unauthenticated access to sensitive data.
- Integrate SAST/DAST tools into CI/CD for projects that handle authentication or account management logic.

