Summary
A critical code-injection vulnerability in Interchange's "quick question" administrative feature allows unauthenticated users to submit arbitrary Perl code for server-side execution. The code is typically evaluated inside a Safe container, but deployments that enable the non-default AllowGlobal directive for an affected catalog may expose broader server capabilities.
Affected context
The vulnerability occurs in Interchange installations that expose the "quick question" administrative feature and process user-controlled input as Perl code. Default deployments may constrain execution through a Safe container, while catalog configurations using the non-default AllowGlobal directive can substantially increase the potential impact.
Exploit preconditions
- Attack surface: The Interchange "quick question" administrative feature
- Required access: No authentication may be required when the feature is reachable
- Trigger point: Server-side processing of attacker-controlled quick-question input
- Why exploitation is possible: Input is interpreted as Perl code rather than being treated strictly as data; Safe-container restrictions may limit impact unless broader global access is enabled
Why this happens
The underlying flaw is the evaluation of user-controlled input as executable Perl code. This behavior maps to CWE-94: Improper Control of Generation of Code, because data from an external request can influence or become executable program logic. Although a Safe container may restrict available operations, relying on execution isolation does not remove the unsafe code-generation pattern, particularly when broader global access is configured.
Potential impact
- An attacker may execute Perl code within the Interchange server process
- The attacker could access or alter application data available to that process
- The vulnerability may enable compromise of catalog functionality or administrative workflows
- Deployments with broader global access could experience more extensive host or system impact
- The application could be used for further compromise of connected services
General mitigation guidance
Mitigation generally focuses on ensuring that user input is never evaluated as executable Perl code and on reducing the privileges available to the application process.
Common defensive patterns include:
- Replacing dynamic code evaluation with fixed operations selected from an allowlisted set
- Treating quick-question input strictly as data and applying context-appropriate validation
- Keeping restrictive execution boundaries enabled and avoiding broad global-access configuration
- Limiting the application process to only the files, services, and permissions it requires
- Restricting unauthenticated access to administrative features through authentication and authorization controls
- Using isolated service accounts and segmented runtime environments where practical
How teams detect issues like this
Detection can combine source review, runtime monitoring, and configuration policy checks.
Useful approaches include:
- Static analysis for dynamic Perl evaluation, string-to-code conversion, and execution of request-derived values
- Code review checks for administrative endpoints that pass untrusted input into interpreters
- Configuration audits identifying enabled global-access directives or weakened Safe-container boundaries
- Web and application logs reviewed for unusual requests to the quick-question feature and unexpected server-side errors
- Policy enforcement requiring authentication for administrative functionality and prohibiting unauthenticated code-evaluation paths
- Automated security review tools that flag user-controlled input reaching dynamic execution APIs

