Traefik from 3.2.0 before 3.7.15 contains a data race in the experimental FastProxy that allows unauthenticated attackers to crash the process by abusing HTTP/1 protocol upgrades. Attackers can repeatedly open and abort upgraded connections such as WebSocket, corrupting the unsynchronized shared bufio.Reader and triggering an unrecovered panic that terminates Traefik.
Traefik 3.7.11 before 3.7.15 contains an authorization bypass in the Kubernetes Ingress NGINX provider that skips the cross-namespace check on the auth-tls-secret annotation when a cached client authentication TLS option is reused. Users who can create Ingresses can reference another namespace's CA secret already used by another Ingress, enforcing it on their own routes and learning whether it exists, without disclosure of its contents.
Traefik from 3.7.0-ea.1 before 3.7.15 contains an authentication bypass vulnerability in the Kubernetes Ingress NGINX provider that silently disables mTLS configured via the auth-tls-secret annotation. When another Ingress declares a path on the same host without matching auth-tls settings, Traefik falls back to default TLS options, letting unauthenticated attackers reach backends requiring client certificates.
Parse Server from 9.7.0 before 9.10.5-alpha.10 contains an authorization flaw that applies _Installation updates addressed by object ID to the installation named in the X-Parse-Installation-Id header. When protectedFieldsTriggerExempt is enabled, attackers knowing another installation's object ID can make a beforeSave trigger process that installation's protected fields while writing elsewhere.
Parse Server from 9.7.0 before 9.10.5-alpha.7 contains an information disclosure vulnerability that allows clients to receive protected field values written by beforeSave triggers using dot notation keys. When protectedFieldsSaveResponseExempt is set to false, clients with create or update permission can read values a trigger writes beneath a protected field in the same request.
Parse Server before 8.6.108 and 9.0.0 before 9.10.5-alpha.9 contains a prototype pollution vulnerability because user-controlled keys are expanded into objects without own-property checks. Clients with class write access can send dot notation field keys or ACL entry names matching built-in object members to corrupt built-in functions, causing all requests to fail until server restart.
CallBackery versions before 0.62.0 for Perl allow session cookie forgery via a signing secret generated with rand().
The secret that signs session cookies is built from two calls to the built-in rand(), which is seeded with 32 bits. The secret therefore has at most 2**32 possible values, and one signed cookie is enough to test each candidate offline.
An attacker who obtains a single session cookie can recover the secret and sign cookies for any user, including an administrator.
CallBackery versions before 0.62.0 for Perl accept session cookies of any age sent in the X-Session-Cookie header.
cookieConf() rejects a cookie older than 300 seconds only when it arrives in the xsc query parameter. The same cookie sent in the X-Session-Cookie header is accepted however old it is.
A session cookie that leaks through a log, a Referer header or browser history authenticates as its user indefinitely.
CallBackery versions prior to 0.62.0 for Perl create a temporary configuration database dump in /tmp with insecure permissions. The dump file is world-readable and not removed after creation, exposing sensitive data including password hashes. A local user can exploit this by reading the dump or redirecting it via a symlink to a file of their choosing.
CallBackery versions prior to 0.62.0 use an insecure method to encrypt configuration backups by deriving the AES key directly from a padded password without salt or key derivation. This allows an attacker who obtains a backup to perform fast offline password guessing at raw AES speed, potentially recovering all credentials stored in the backup.
CallBackery versions before 0.62.0 for Perl contain an OS command injection vulnerability. This occurs because the restoreConfigBlob() function feeds a database dump from a backup to the sqlite3 shell, which executes lines starting with a dot as shell commands. An attacker who can supply a backup to be restored can execute arbitrary OS commands as the application user.
CallBackery versions before 0.62.0 for Perl contain a vulnerability that allows denial of service via inefficient regular expression complexity. The issue arises from unquoted interpolation of the request path as a regular expression in the before_dispatch hook, which processes PATH_INFO from client requests under CGI, FastCGI, and PSGI environments. An unauthenticated attacker can send a crafted request with a backreference in the path that causes exponential backtracking, tying up server worker processes for extended periods.
CallBackery versions prior to 0.62.0 for Perl contain a log injection vulnerability due to improper output neutralization of control characters in login names. The login RPC method does not require authentication, allowing an attacker to inject forged log entries by including newline characters in the login name. This can result in misleading log records, such as fake successful administrator logins from arbitrary IP addresses.
CallBackery versions before 0.62.0 for Perl contain a permissive regular expression vulnerability in the createRxValidator function. The function is intended to anchor patterns strictly but fails to group alternations properly, allowing unintended values to pass validation. This flaw permits authenticated users to submit values that should be rejected, potentially leading to unsafe data being written into generated configuration files.
CallBackery versions prior to 0.62.0 for Perl improperly expose sensitive information through the getUserConfig function. Non-administrative users can access their own password hash and administrator-only notes, which should be restricted. This flaw allows attackers with a session token to retrieve password hashes and potentially crack them offline.
CallBackery versions prior to 0.62.0 for Perl use unsalted HMAC-SHA1 hashes without a key to store user passwords. This hashing approach lacks a salt and computational work factor, making password hashes vulnerable to fast offline guessing attacks if the user table is obtained. The vulnerability is fixed in version 0.62.0.
Business-GoCardless versions before 1.01 for Perl contain an authorization bypass vulnerability where the redirect flow ID is not properly validated against the user session. This allows an attacker who obtains another customer's redirect flow ID to create payments or subscriptions against that customer's mandate without authorization. The flaw exists because the confirm_resource function does not verify the session token and completes redirect flows solely based on the redirect flow ID returned by the GoCardless API. The issue was fixed in version 1.01.
Business-GoCardless versions before 1.01 for Perl improperly verify cryptographic signatures on webhooks when the configured webhook secret is undefined or empty. This allows an attacker to forge webhooks by signing them with an empty key, which the system accepts as valid. The issue arises because the signature validation function does not reject empty or undefined secrets, which Digest::SHA treats as an empty key.
Business-GoCardless versions before 1.01 for Perl contain a vulnerability that allows remote attackers to exhaust memory by sending specially crafted webhook payloads. The flaw arises because legacy webhook payloads are flattened into key-value pairs without limits or throttling before signature verification, causing memory usage proportional to the payload size. This can lead to denial of service via memory exhaustion.
Starlet versions from 0.20 up to but not including 0.33 for Perl contain a vulnerability where unbounded buffering during decoding of chunked request bodies can lead to memory exhaustion. The decoder accumulates input without limits, allowing a remote attacker to exhaust a worker's memory with a single crafted request. This issue is fixed in version 0.33.