API Reference Sobelow v0.19.0
View SourceModules
Sobelow is a static analysis tool for discovering vulnerabilities in Phoenix applications.
Command Injection
Command Injection vulnerabilities are a result of passing untrusted input to an operating system shell, and may result in complete system compromise.
Command Injection in :os.cmd
This submodule of the CI module checks for Command Injection
vulnerabilities through usage of the :os.cmd function.
Command Injection via System
This submodule of the CI module checks for Command Injection
vulnerabilities through usage of the System.cmd function.
Configuration
Submodules contained within this vulnerability type are related to common insecurities found in how Phoenix applications are configured.
Missing Content-Security-Policy
Content-Security-Policy is an HTTP header that helps mitigate a number of attacks, including Cross-Site Scripting.
Cross-Site Request Forgery
In a Cross-Site Request Forgery (CSRF) attack, an untrusted application can cause a user's browser to submit requests or perform actions on the user's behalf.
Cross-Site Request Forgery
In a Cross-Site Request Forgery (CSRF) attack, an untrusted application can cause a user's browser to submit requests or perform actions on the user's behalf.
Cross-Site Websocket Hijacking
Websocket connections are not bound by the same-origin policy. Connections that do not validate the origin may leak information to an attacker.
HSTS
The HTTP Strict Transport Security (HSTS) header helps defend against man-in-the-middle attacks by preventing unencrypted connections.
HTTPS
Without HTTPS, attackers in a privileged network position can intercept and modify traffic.
Missing Secure HTTP Headers
By default, Phoenix HTTP responses contain a number of secure HTTP headers that attempt to mitigate XSS, click-jacking, and content-sniffing attacks.
Hard-coded Secrets
In the event of a source-code disclosure via file read vulnerability, accidental commit, etc, hard-coded secrets may be exposed to an attacker. This may result in database access, cookie forgery, and other issues.
Disabled TLS certificate verification
Reports literal verify: :verify_none in TLS options, including Gun's
tls_opts map entries. It also catches hackney's :insecure and
insecure: true options and
the direct verify option in WebTransport connections. Disabling
verification lets an attacker impersonate the remote server. Use
:verify_peer and a trusted CA, including for self-signed services.
Legacy TLS and SSL protocol versions
Explicit SSL 2/3, TLS 1.0/1.1 and DTLS 1.0 selections in TLS versions
options receive high confidence. These legacy protocols should be removed
from both client and server configurations; use TLS 1.2 or 1.3 as required
by the protocol. DTLS 1.2 is not flagged.
Cryptography
Checks literal hash and cipher algorithm choices. These checks do not prove that a cryptographic construction is secure.
Weak ciphers and unauthenticated encryption
DES, 3DES, RC2, RC4, Blowfish and ECB modes receive high confidence. Prefer authenticated encryption such as AES-GCM or ChaCha20-Poly1305.
Weak or inappropriate hashing
MD4, MD5 and SHA-1 are unsuitable when collision resistance is required. RIPEMD-160 is reported as a legacy choice, not as a proven collision break. Prefer SHA-256 or stronger for security-sensitive digests. Non-security checksums and cache keys may legitimately use legacy hashes.
Weak digests in digital signatures
MD5 and SHA-1 lack the collision resistance required for new digital signatures. Prefer a modern signature scheme and an appropriate digest such as SHA-256 or stronger. HMAC is a different construction and is not classified by this check.
Denial of Service
The Denial of Service (DOS) attack is focused on making a resource (site, application, server) unavailable for the purpose it was designed.
Denial of Service via Unsafe Atom Interpolation
In Elixir, atoms are not garbage collected. As such, if user input
is used to create atoms (as in :"foo#{bar}", or in :erlang.binary_to_atom),
it may result in memory exhaustion. Prefer the String.to_existing_atom
function for untrusted user input.
Potential resource exhaustion in full compressed-file reads
Files opened with :compressed or :compressed_one decompress while reading.
IO.read/2 and IO.binread/2 with :all or :eof can materialize the entire
expanded contents. A small on-disk file or an output-size check after reading
does not establish a decompressed-byte budget. :eof requires Elixir 1.13+.
Atom exhaustion through Erlang term files
:file.consult/1 and :file.path_consult/2 parse Erlang terms from a
text file. Untrusted contents can create arbitrary atoms and exhaust VM
resources. These functions have no :safe option. They parse terms;
they do not evaluate arbitrary expressions like :file.eval/1.
Atom exhaustion through decoders
Jason and Poison can create new atoms with keys: :atoms. YamlElixir's
string readers can create atoms with atoms: true. Decoding untrusted
input with these options can exhaust the VM's atom table because atoms
are not garbage collected.
Resource exhaustion through decompression
:zlib.gunzip/1, :zlib.uncompress/1, :zlib.unzip/1 and
:zlib.inflate/2,3 can expand untrusted compressed data without an
application-defined output limit. Here :zlib.unzip/1 decodes raw DEFLATE
data, not a ZIP container; archive extraction is covered by DOS.Zip.
Small compressed input or input chunks can produce much larger output.
Checking output size after these calls may be too late to prevent exhaustion.
Denial of Service via List.to_atom and :erlang.list_to_atom
In Elixir, atoms are not garbage collected. As such, if user input
is passed to the List.to_atom function, or to its Erlang equivalent
:erlang.list_to_atom, it may result in memory exhaustion. Prefer the
List.to_existing_atom function for untrusted user input.
Atom exhaustion through dynamic module names
Module.concat/1,2 creates module-name atoms. Unbounded names derived from
request input can exhaust the VM's atom table, even if no module is loaded
under those names. Atoms are not garbage collected.
Potential resource risk in dynamic regex compilation
Compiling an attacker-influenced pattern can impose compilation costs and
allow expensive matching behavior when the result is later used. This check
reports dynamic patterns passed to Regex.compile/1,2, compile!/1,2 and
:re.compile/1,2. Controller pattern parameters receive medium confidence;
other dynamic patterns receive low confidence. A finding does not demonstrate
pathological runtime or prove that the pattern is untrusted or later matched.
Denial of Service via String.to_atom
In Elixir, atoms are not garbage collected. As such, if user input
is passed to the String.to_atom function, it may result in memory
exhaustion. Prefer the String.to_existing_atom function for untrusted
user input.
Potential resource exhaustion in TAR extraction
:erl_tar.extract/1,2 can consume memory, disk space and execution resources
when extracting untrusted archives. Compressed input and sparse entries can
amplify resource use. Selected files, disk write chunks and post-extraction
checks do not establish a cumulative expanded-byte budget.
Potential resource exhaustion with explicit XML entity options
Entity expansion can amplify XML processing work and memory. External resource loading is a separate concern: it can consume resources and, depending on the resolver and context, may also expose files or enable unwanted requests. This check does not establish file disclosure, SSRF or exploitability.
Resource exhaustion through ZIP extraction
:zip.unzip/1,2, :zip.extract/1,2 and :zip.zip_get/1,2 can expand
untrusted archives without a limit on actual output bytes. A single entry
can exhaust memory, disk space or CPU; nested archives are not required.
The :memory, :file_list and :file_filter options do not establish an
expanded-byte limit. ZIP-declared sizes can be forged.
IO helpers. Mostly mirror Mix.Shell.IO, but Mix will not always be available to Sobelow.
Miscellaneous
This suite of tests is to be a catch-all for checks that don't fall neatly into the other detection categories.
Insecure use of binary_to_term
Decoding untrusted Erlang terms without :safe can create atoms and
exhaust VM resources. The :safe option prevents new atoms, but still
permits executable terms. Decoding a function does not itself execute it;
later application code may invoke it, including indirectly via protocols.
Remote Code Execution
Remote Code Execution vulnerabilities are a result of untrusted user input being executed or interpreted by the system and may result in complete system compromise.
Code Execution in eval function
Arbitrary strings passed to the Code.eval_* functions can be
executed as malicious code.
Code execution through compilation and loading
Code.compile_string/1,2 and Code.compile_quoted/1,2 execute code while
compiling it. Code.compile_file/1,2 and Code.require_file/1,2 compile
and execute a source file; requiring a file only once does not make its
contents trusted. Use these APIs only with trusted application code.
Insecure EEx evaluation
If user input is passed to EEx eval functions, it may result in arbitrary code execution. The root cause of these issues is often directory traversal.
Code execution through Erlang files
:file.eval/1,2, :file.script/1,2, :file.path_eval/2 and :file.path_script/2,3 read and execute Erlang expressions from a file. Only execute trusted application files. Avoid selecting executable files using request input, uploaded files or attacker-writable directories.
SQL Injection
SQL Injection occurs when untrusted input is interpolated
directly into a SQL query. In a typical Phoenix application,
this would mean using the Ecto.Adapters.SQL.query method
and not using the parameterization feature.
SQL Injection in Query
This submodule of the SQL module checks for SQL injection
vulnerabilities through usage of the Ecto.Adapters.SQL.query
and Ecto.Adapters.SQL.query!.
SQL Injection in Stream
This submodule of the SQL module checks for SQL injection
vulnerabilities through usage of the Ecto.Adapters.SQL.stream.
Path Traversal
Path traversal vulnerabilities are a result of interacting with the filesystem using untrusted input. This class of vulnerability may result in file disclosure, code execution, denial of service, and other issues.
Directory Traversal in send_download
This submodule checks for directory traversal vulnerabilities in the
send_download function of a Phoenix Controller.
Directory Traversal in send_file
This submodule checks for directory traversal vulnerabilities in the
send_file function.
Known Vulnerable Dependencies
An application with known vulnerabilities is more easily subjected to automated or targeted attacks.
Coherence Version Vulnerable to Privilege Escalation
For more information visit: https://github.com/advisories/GHSA-mrq8-53r4-3j5m
Plug Version Vulnerable to Arbitrary Code Execution in Cookie Serialization
For more information visit: https://github.com/advisories/GHSA-5v4m-c73v-c7gq
Ecto Version Lacks Protection Mechanism
For more information visit: https://github.com/advisories/GHSA-2xxx-fhc8-9qvq
Plug Version Vulnerable to Header Injection
For more information visit: https://github.com/advisories/GHSA-9h73-w7ch-rh73
Plug Version Vulnerable to Null Byte Injection
For more information visit: https://github.com/advisories/GHSA-2q6v-32mr-8p8x
Phoenix Version Vulnerable to Arbitrary URL Redirection
For more information visit: https://github.com/advisories/GHSA-cmfh-8f8r-fj96
Cross-Site Scripting
Cross-Site Scripting (XSS) vulnerabilities are a result of rendering untrusted input on a page without proper encoding. XSS may allow an attacker to perform actions on behalf of other users, steal session tokens, or access private data.
XSS in put_resp_content_type
If an attacker is able to set arbitrary content types for an HTTP response containing user input, the attacker is likely to be able to leverage this for cross-site scripting (XSS).
XSS in html
This submodule looks for XSS vulnerabilities in html
calls from the Phoenix Controller.
XSS in raw
This submodule checks for the use of raw in templates
as this can lead to XSS vulnerabilities if taking user input.
XSS in send_resp
This submodule looks for XSS vulnerabilities in the body
argument of Conn.send_resp.
Mix Tasks
Sobelow is a static analysis tool for discovering vulnerabilities in Phoenix applications.