Antipattern: use quantificadores gananciosos na política RegularExpressionProtection

Está a ver a documentação do Apigee e do Apigee Hybrid.
Ver documentação do Apigee Edge.

A política RegularExpressionProtection define expressões regulares que são avaliadas no tempo de execução em parâmetros de entrada ou variáveis de fluxo. Normalmente, usa esta política para se proteger contra ameaças de conteúdo, como injeção de SQL ou JavaScript, ou para verificar parâmetros de pedidos com formato incorreto, como endereços de email ou URLs.

As expressões regulares podem ser definidas para caminhos de pedidos, parâmetros de consulta, parâmetros de formulário, cabeçalhos, elementos XML (num payload XML definido através de XPath) e atributos de objetos JSON (num payload JSON definido através de JSONPath).

A seguinte política RegularExpressionProtection protege o back-end de ataques de injeção de SQL:

<!-- /antipatterns/examples/greedy-1.xml -->
<RegularExpressionProtection async="false" continueOnError="false" enabled="true"
  name="RegexProtection">
    <DisplayName>RegexProtection</DisplayName>
    <Properties/>
    <Source>request</Source>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <QueryParam name="query">
      <Pattern>[\s]*(?i)((delete)|(exec)|(drop\s*table)|
        (insert)|(shutdown)|(update)|(\bor\b))</Pattern>
    </QueryParam>
</RegularExpressionProtection>

Antipattern

Os quantificadores predefinidos (*, + e ?) são gananciosos por natureza: começam a corresponder à sequência mais longa possível. Quando não é encontrada nenhuma correspondência, o robô recua gradualmente para tentar encontrar uma correspondência com o padrão. Se a string resultante que corresponde ao padrão for muito curta, a utilização de quantificadores gananciosos pode demorar mais tempo do que o necessário. Isto é especialmente verdadeiro se a carga útil for grande (na ordem das dezenas ou centenas de KB).

A expressão de exemplo seguinte usa várias instâncias de .*, que são operadores gananciosos:

<Pattern>.*Exception in thread.*</Pattern>

Neste exemplo, a política RegularExpressionProtection tenta primeiro encontrar a sequência mais longa possível, ou seja, a string completa. Se não for encontrada nenhuma correspondência, a política recua gradualmente. Se a string correspondente estiver perto do início ou do meio da carga útil, a utilização de um quantificador ganancioso, como .*, pode demorar muito mais tempo e exigir mais capacidade de processamento do que os quantificadores relutantes, como .*?, ou (menos frequentemente) os quantificadores possessivos, como .*+.

Os quantificadores relutantes (como X*?, X+?, X??) começam por tentar encontrar uma correspondência com um único caráter desde o início da carga útil e adicionam gradualmente carateres. Os quantificadores possessivos (como X?+, X*+, X++) tentam corresponder a todo o payload apenas uma vez.

Dado o seguinte texto de exemplo para o padrão acima:

Hello this is a sample text with Exception in thread
with lot of text after the Exception text.

A utilização do .* ganancioso não tem um bom desempenho neste caso. O padrão .*Exception in thread.* demora 141 passos a corresponder. Se usasse o padrão .*?Exception in thread.* (que usa um quantificador relutante), o resultado seria apenas 55 passos.

Impacto

A utilização de quantificadores gananciosos, como carateres universais (*), com a política RegularExpressionProtection pode originar:

  • Um aumento na latência geral dos pedidos de API para um tamanho de carga útil moderado (até 1 MB)
  • Tempo mais longo para concluir a execução da política RegularExpressionProtection
  • Os pedidos de API com payloads grandes (>1 MB) falham com erros de tempo limite do gateway 504 se o período de tempo limite predefinido expirar no router do Apigee
  • Utilização elevada da CPU nos processadores de mensagens devido à grande quantidade de processamento, o que pode afetar ainda mais outros pedidos de API

Prática recomendada

  • Evite usar quantificadores gananciosos, como .*, em expressões regulares com a política RegularExpressionProtection. Em alternativa, use quantificadores relutantes, como .*?, ou quantificadores possessivos, como .*+ (menos comummente), sempre que possível.

Leitura complementar