Summary
SpringBlade versions 2.7.3 through before 5.0.0 contain an authorization flaw in an internal Feign user-creation endpoint exposed through a REST controller. An authenticated attacker who can reach the endpoint, forge an accepted token, or otherwise bypass role checks may create administrator accounts and gain persistent, elevated access.
Affected context
The vulnerability occurs in SpringBlade deployments where an internal user-creation service is exposed without effective authorization checks. Risk increases when the gateway validates only JWT structure or parsing, when caller identity and roles are not enforced, and when signing material is embedded in publicly accessible application artifacts.
Exploit preconditions
- Attack surface: An exposed REST or Feign-backed user-creation endpoint
- Required access: Authentication or another means of presenting a token accepted by the gateway
- Trigger point: A request reaching the user-creation operation without effective role authorization
- Why exploitation is possible: The request path does not sufficiently verify caller privileges, and exposed or weakly protected signing material may allow tokens to be treated as belonging to a more privileged identity
Why this happens
The underlying bug is a failure to enforce authorization at a sensitive administrative operation, mapping to CWE-862: Missing Authorization. Authentication-related token processing is treated as sufficient even though parsing or accepting a JWT does not establish that the caller is permitted to create administrator accounts. The risk is compounded when signing keys are hardcoded in distributable artifacts, allowing trust decisions to depend on credentials that are not kept confidential.
Potential impact
- Attackers may create unauthorized system administrator accounts
- Existing tenant data could be modified or polluted
- Administrative privileges could support persistent backdoor access
- Unauthorized users could access or alter cross-tenant information
- Compromised accounts could enable further application or infrastructure abuse
General mitigation guidance
Mitigation generally focuses on enforcing authorization independently at every sensitive operation and reducing trust in client-supplied identity claims.
Common defensive patterns include:
- Applying explicit role- and permission-based checks to user-creation endpoints
- Ensuring internal Feign routes are not externally reachable unless required
- Validating token signature, issuer, audience, expiry, subject, and roles using centrally managed trust configuration
- Removing hardcoded signing secrets from source code and distributable artifacts
- Storing secrets in protected secret-management systems with controlled rotation
- Separating administrative account creation from ordinary user workflows
- Applying least privilege to service identities and tenant-scoped authorization
- Denying access by default when authorization metadata or caller identity is missing
How teams detect issues like this
Detection approaches can include:
- Static analysis searches for REST or Feign endpoints that mutate users without method-level authorization annotations or equivalent policy checks
- Code review checks that distinguish JWT parsing from authorization and verify role enforcement at the operation boundary
- Scanning repositories and build artifacts for embedded signing keys or other credential-like constants
- API inventory reviews identifying internal administrative endpoints exposed through gateways
- Runtime monitoring for unexpected administrator-account creation, unusual token claims, and cross-tenant write activity
- Policy enforcement requiring authorization tests for privileged endpoint handlers
Automated code review and secret-scanning tools can help identify these patterns during development.

