diff --git a/javascript/ql/src/Security/CWE-020/ExternalAPISinkExample.js b/javascript/ql/src/Security/CWE-020/ExternalAPISinkExample.js new file mode 100644 index 000000000000..109191caf401 --- /dev/null +++ b/javascript/ql/src/Security/CWE-020/ExternalAPISinkExample.js @@ -0,0 +1,4 @@ +express().get('/news', (req, res) => { + let topic = req.query.topic; + res.send(`
Using unsanitized untrusted data in an external API can cause a variety of security issues. This query reports +all external APIs that are used with untrusted data, along with how frequently the API is used, and how many +unique sources of untrusted data flow to this API. This query is designed primarily to help identify which APIs +may be relevant for security analysis of this application.
+ +An external API is defined as a call to a function that is not defined in the source code, not overridden
+in the source code, and is not modeled as a taint step in the default taint library. External APIs may be from the
+third party dependencies or from internal dependencies. The query will report the external package name, followed
+by an access path leading to the function, followed by [param x]
where x
+indicates the position of the parameter receiving the untrusted data.
For each result:
+ +Otherwise, the result is likely uninteresting. Custom versions of this query can extend the SafeExternalAPIMethod
+class to exclude known safe external APIs from future analysis.
If the query were to return the API express().get.[callback].[param 'res'].send() [param 0]
,
+this could correspond to the X
in express().get('/foo', (req, res) => res.send(X))
.
+First we should consider whether this a security relevant sink. In this case, this is writing to a HTTP response, so we should
+consider whether this is an XSS sink. If it is, we should confirm that it is handled by the reflected XSS query.
If the query were to return the API url.parse java.lang.StringBuilder.append(java.lang.String) [param 0]
, then this should be
+reviewed as a possible taint step, because tainted data would flow from the 0th argument to the qualifier of the call.
Note that both examples are correctly handled by the standard taint tracking library and XSS query.
+Using unsanitized untrusted data in an external API can cause a variety of security issues. This query reports +external APIs that use untrusted data. The results are not filtered so that you can audit all examples. The query provides data for security reviews of the application and you can also use it to identify external APIs that should be modeled as either taint steps, or sinks for specific problems.
+ +An external API is defined as a method call to a method that is not defined in the source code, not overridden +in the source code, and is not modeled as a taint step in the default taint library. External APIs may be from the +third-party dependencies or from internal dependencies. The query reports uses of +untrusted data one of the arguments of external API call or in the return value from a callback passed to an external API.
+ +For each result:
+ +Otherwise, the result is likely uninteresting. Custom versions of this query can extend the SafeExternalAPIMethod
+class to exclude known safe external APIs from future analysis.
In this first example, a query parameter is read from the req
parameter and then ultimately used in a call to the
+res.send
external API:
This is a reflected XSS sink. The XSS query should therefore be reviewed to confirm that this sink is appropriately modeled, +and if it is, to confirm that the query reports this particular result, or that the result is a false positive due to +some existing sanitization.
+ +In this second example, again a query parameter is read from req
.
If the query reported the call to path.join
on line 4, this would suggest that this external API is
+not currently modeled as a taint step in the taint tracking library. The next step would be to model this as a taint step, then
+re-run the query to determine what additional results might be found. In this example, it seems the result of the
+path.join
will be used as a file path, leading to a path traversal vulnerability.
Note that both examples are correctly handled by the standard taint tracking library and security queries.
+