Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.npmjs.com/package/vuln-regex-detector below:

vuln-regex-detector - npm

In JavaScript, regular expressions (regexes) can be "vulnerable": susceptible to catastrophic backtracking. If your application is used on the client side, this can be a performance issue. On the server side, this can expose you to Regular Expression Denial of Service (REDOS).

This module lets you check a regex for vulnerability.

const vulnRegexDetector = require('vuln-regex-detector');
 
const regex = /(a+)+$/; 
const pattern = regex.source; 
 
const cacheConfig = {
    type: vulnRegexDetector.cacheTypes.persistent
};
const config = {
    cache: cacheConfig
};
 
const result = vulnRegexDetector.testSync(regex, config);
console.log(`I got ${result}`);
 
vulnRegexDetector.test(pattern, config)
    .then((result) => {
        if (result === vulnRegexDetector.responses.vulnerable) {
            console.log('Regex is vulnerable');
        } else if (result === vulnRegexDetector.responses.safe) {
            console.log('Regex is safe');
        } else {
            console.log('Not sure if regex is safe or not');
        }
    });

The module exports:

• functions test and testSync for making queries
• macro cacheTypes for use specifying config.cache
• a set of responses responses for interpreting results

vulnRegexDetector.test (regex, config)

vulnRegexDetector.testSync (regex, config)

NB: This API makes synchronous HTTP queries, which can be slow. You should not use it in server software. On an AWS micro instance this API can be called about 200 times per minute.

This API is intended for use in CI contexts where performance is less critical. For use in CI, see this module. If your application defines many regexes dynamically you might want to write your own CI stage.

If fulfilled, the returned Promise gets one of the following values:

• responses.vulnerable
• responses.safe
• responses.unknown

If rejected, the returned Promise gets the value:

• responses.invalid

This module queries a server hosted at Virginia Tech. When you use it, your regex will be shipped (via HTTPS) to the server and tested there.

If the regex has not been seen before, the server will respond "unknown" and test it in the background. The server cannot test synchronously because testing is expensive (potentially minutes) and there might be a long line.

If the server has not seen the regex before, it should have an answer if you query it again in a few minutes.

If you cannot connect to the server or your query is malformed, you'll get the answer "invalid".

This module maintains a persistent local cache stored in os.tmpdir() to reduce the number of HTTP queries.

By using this module you are consenting to send us your regexes. If your code is not open-source then feel free to host your own service. See here for details, and specify your service's hostname and port in config when you call the API.

We may:

• store them
• analyze properties of your queries
• release the regexes as a public dataset for future researchers

The IP address of any client querying our server will be anonymized.

1. https://github.com/olivo/redos-detector
2. https://github.com/substack/safe-regex
3. https://github.com/google/re2

1. This module guarantees no false positives. If it reports a vulnerable regex, then there is an attack string that produces catastrophic backtracking in JavaScript (Node.js). If you're curious, you can obtain this attack string by using the check-regex.pl tool in this repo.
2. This module guarantees far fewer false negatives. safe-regex uses a heuristic called star height which will miss a lot of regexes that are actually dangerous. safe-regex misses about 90% of vulnerabilities by my estimate.

Issues and PRs welcome.

MIT

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4