postgres.git / summary / log / commit / refs

commit    2171661bd923ada937095b62cb71a9bfec8fa7bb
Author:   Tom Lane <tgl@sss.pgh.pa.us>
Date:     Fri Oct 02 17:30:43 2015 +0000
First released in: 9.6.0, 9.0.23, 9.1.19, 9.2.14, 9.3.10, 9.4.5, 9.5.0

    Docs: add disclaimer about hazards of using regexps from untrusted sources.
    
    It's not terribly hard to devise regular expressions that take large
    amounts of time and/or memory to process.  Recent testing by Greg Stark has
    also shown that machines with small stack limits can be driven to stack
    overflow by suitably crafted regexps.  While we intend to fix these things
    as much as possible, it's probably impossible to eliminate slow-execution
    cases altogether.  In any case we don't want to treat such things as
    security issues.  The history of that code should already discourage
    prudent DBAs from allowing execution of regexp patterns coming from
    possibly-hostile sources, but it seems like a good idea to warn about the
    hazard explicitly.
    
    Currently, similar_escape() allows access to enough of the underlying
    regexp behavior that the warning has to apply to SIMILAR TO as well.
    We might be able to make it safer if we tightened things up to allow only
    SQL-mandated capabilities in SIMILAR TO; but that would be a subtly
    non-backwards-compatible change, so it requires discussion and probably
    could not be back-patched.
    
    Per discussion among pgsql-security list.


doc/src/sgml/func.sgml | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml index 23d622f1f22..e1edbb34f52 100644 --- a/doc/src/sgml/func.sgml +++ b/doc/src/sgml/func.sgml @@ -3584,6 +3584,28 @@ cast(-44 as bit(12)) <lineannotation>111111010100</lineannotation> </para> </tip> + <caution> + <para> + While most regular-expression searches can be executed very quickly, + regular expressions can be contrived that take arbitrary amounts of + time and memory to process. Be wary of accepting regular-expression + search patterns from hostile sources. If you must do so, it is + advisable to impose a statement timeout. + </para> + + <para> + Searches using <function>SIMILAR TO</function> patterns have the same + security hazards, since <function>SIMILAR TO</function> provides many + of the same capabilities as <acronym>POSIX</acronym>-style regular + expressions. + </para> + + <para> + <function>LIKE</function> searches, being much simpler than the other + two options, are safer to use with possibly-hostile pattern sources. + </para> + </caution> + <sect2 id="functions-like"> <title><function>LIKE</function></title> [parent: 35435af38884]