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.
Starlet versions before 0.33 for Perl improperly send a body in responses to HEAD requests, causing corruption of subsequent responses on persistent or pipelined HTTP connections. This behavior can desynchronize proxies sharing connections across clients due to extra bytes being misinterpreted as the start of new responses. The issue is fixed in version 0.33.
Starlet versions from 0.20 up to but not including 0.33 for Perl contain an inefficient regular expression that can cause CPU exhaustion when decoding chunked request bodies. The flaw arises from a regex backtracking issue in parsing chunk-size lines, allowing a remote attacker to cause high CPU usage with a specially crafted request. This can occupy a worker thread for about a minute using a single 128 KiB request. The issue is fixed in version 0.33.
Starlet versions before 0.33 for Perl contain a vulnerability where a remote attacker can send a request with a large Content-Length header, causing the worker process to exhaust memory and exit with an uncatchable error. This leads to a denial of service by forcing worker restarts with minimal requests.
An improper access control vulnerability in ESET Endpoint Encryption and ESET Full Disk Encryption allow attacker with standard user permissions access a device interface belonging to a privileged kernel driver and send specially crafted requests.