devday2013

O que há de errado com
expressões regulares?
*elas são NP-completas, só que não.

juanlopes.net/devday2013

Logs de aplicação
Contém muita informação

186.247.10.187 - - GET
/gnews/gnews_600/gnews_1374508780437_1374508780437_1470.ts HTTP/1.1 "200"
346672 "-" 0.232 "AppleCoreMedia/1.0.0.10B329 (iPad; U; CPU OS 6_1_3 like
Mac OS X; pt_br)" "-" - [MISS] 0.006 ms
201.51.232.169 - - GET
552156 "http://globotv.globo.com/globo-news/globo-news-ao-vivo/v/globonewsao-vivo/61910/" 0.480 "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/28.0.1500.72 Safari/537.36" "-" - [MISS] 0.008
ms
201.7.186.60 - - GET /ber2/ber2_400/playlist.m3u8 HTTP/1.1 "200" 538 "http:
//g1.globo.com/jornal-hoje/ao-vivo.html" 0.001 "Mozilla/5.0 (Windows NT
6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/28.0.1500.72
Safari/537.36" "-" - [EXPIRED] 0.001 ms

Logs de aplicação
Exemplo: IP de origem

186.247.10.187 - - GET
201.51.232.169 - - GET
ms

Logs de aplicação
Exemplo: identificador do vídeo

186.247.10.187 - - GET
201.51.232.169 - - GET
ms

Logs de aplicação
Exemplo: URL da página em que o vídeo foi reproduzido

186.247.10.187 - - GET
201.51.232.169 - - GET
ms

Expressões regulares
Para extrair estas informações

(?<ip>[d.]+)s-s-sGETs(?<path>/?(?
<stream>[^/]*)/?[^.]*.?(?<extension>
[^s?]*))(?<querystring>[^s]*)s[^s]*s"
(?<status>d*)"s(?<body_bytes_sent>[d]*)
s"(?<http_referer>[^"]*)"s[d.]+s"(?
<user_agent>[^"]*)"s"(?<forwarded_for>[^"]
*)"s-s[(?<cache_status>[w-]*)]s(?
<upstream_response_time>[^s]*)sms.*

Benchmarks são limitados
Essa palestra é basicamente para dizer o óbvio

sljit.sourceforge.net/regex_perf.html

Russ Cox
Um dos maiores committers da linguagem Go

“RE2, provides most of the
functionality of PCRE using a C++
interface very close to PCRE's, but it
guarantees linear time execution and
a fixed stack footprint. RE2 is now in
widespread use at Google, both in
Code Search and in internal systems
like Sawzall and Bigtable”

PyRex
github.com/juanplopes/pyrex

Complexidade de algoritmos
Como medir a complexidade de:
(?<ip>[d.]+)s-s-sGETs(?<path>/?(?<stream>[^/]*)/?[^.]*.?(?<extension>[^s?]*))
(?<querystring>[^s]*)s[^s]*s"(?<status>d*)"s(?<body_bytes_sent>[d]*)s"(?
<http_referer>[^"]*)"s[d.]+s"(?<user_agent>[^"]*)"s"(?<forwarded_for>[^"]*)"s-s
[(?<cache_status>[w-]*)]s(?<upstream_response_time>[^s]*)sms.*

Repositórios online
Não estão livres de regexes maliciosas

Repositórios online
^([a-zA-Z0-9])(([-.]|[_]+)?([a-zA-Z0-9]+))*(@){1}[a-z0-9]+[.]{1}(([a-z]{2,3})|([a-z]{2,3}[.]{1}[a-z]{2,3}))$

Acontece nos melhores projetos
Mas não deveria

Regex: (a?a)+b
Regexes não deveriam se comportar assim:

Expressões regulares em
tempo linear?

Expressões regulares em
tempo linear?
SIM e NÃO?!

Woody Allen Noam Chomsky
Pai da linguística moderna (e um ativista barulhento)

“A generative grammar
must be a system of rules
that can iterate to
generate an indefinitely
large number of
structures.”

Hierarquia de Chomsky
Essencial para a teoria de linguagens de programação

IRRESTRITAS

SENSÍVEIS AO CONTEXTO

LIVRES DE CONTEXTO

REGULARES

Hierarquia de Chomsky
Cada gramática exige uma máquina para reconhecê-la

Gramática

Autômato

Regras

0

Irrestrita

Máquina de Turing

α→β

1

Sensível ao
contexto

Autômato linearmente
limitado

αSβ → αγβ

2

Livre de contexto

Autômato de pilha

S→γ

Autômato finito

S→ε
S→a
S → aT

3

Regular

Expressões regulares
Denotam linguagens, hum…, regulares.
Forma

Descrição

ER1

∅

Linguagem vazia

ER2

ε

Linguagem contendo apenas cadeia vazia

ER3

a

Linguagem contendo apenas cadeia a

ER4

α|β

União entre Lα e Lβ

ER5

αβ

Concatenação entre Lα e Lβ

ER6

α*

Fecho Kleene sobre Lα

Autômatos finitos
Reconhecem linguagens regulares
abc?d
a

b

c

d

ε

ε

abcd*
a

b

c

d

ε

Uma notação simplificada
Para representar autômatos finitos

Autômato
a

ε

Notação
a

Instrução
CONSUME
JUMP
MATCH

Uma notação simplificada
Mesmos exemplos em nova notação
abc?d
a

b

c

d

abcd*
a

b

c

d

Conversão
Expressão regular → autômato finito
Expressão

Autômato

a

a

αβ

α

β

α|β

α

α?

α

α+
α*

α
α

β

Conversão
Útil para representar o autômato de diversas formas
ER

abc?d

abcd+

(a?a)+b

Autômato
a

a

b

b

a

c

c

a

d

d

b

Array

Instruções

'a', 'b', [1, 2], 'c', 'd'

0000:
0001:
0002:
0003:
0004:
0005:

CONSUME 'a'
CONSUME 'b'
JUMP (1, 2)
CONSUME 'c'
CONSUME 'd'
MATCH!

'a', 'b', 'c', 'd', [1, -1]

0000:
0001:
0002:
0003:
0004:
0005:

CONSUME a
CONSUME b
CONSUME c
CONSUME d
JUMP (1, -1)
MATCH!

[1, 2], 'a', 'a', [1, -3], 'b'

0000:
0001:
0002:
0003:
0004:
0005:

JUMP (1, 2)
CONSUME a
CONSUME a
JUMP (1, -3)
CONSUME b
MATCH!

NFA: Autômato Finito
Não Determinístico

c
INDETERMINISMO

d

Indeterminismo
Potencial exponencial devastador, em alguns casos
Expressão
(a?a)+b

Autômato
a

0000:
0001:
0002:
0003:
0004:
0005:

a

Array
b

[1, 2], 'a', 'a', [1, -3], 'b'

JUMP (1, 2)
CONSUME 'a'
CONSUME 'a'
JUMP (1, -3)
CONSUME 'b'
MATCH!

Simular autômato
Várias formas, com vantagens e desvantagens
Método

Vantagem

Desvantagem

Backtracking

Implementação simples

Simulação exponencial

Backtracking com
memorização

Implementação simples;
complexidade polinomial

Chamadas recursivas;
acesso aleatório à entrada

Converter para DFA

Simulação linear

Conversão exponencial

Simulação paralela

Sem chamadas recursivas;
acesso sequencial à entrada

Simulação superlinear

Conversão
preguiçosa para DFA

Boa localidade de referência;
melhor caso linear

Pior caso ainda superlinear

Simular autômato
Paralela: melhor custo/benefício
Método

Vantagem

Desvantagem

Backtracking

Implementação simples

Simulação exponencial

Backtracking com
memorização

Implementação simples;
complexidade polinomial

Chamadas recursivas;
acesso aleatório à entrada

Converter para DFA

Simulação linear

Conversão exponencial

Simulação paralela

Sem chamadas recursivas;
acesso sequencial à entrada

Simulação superlinear

Conversão
preguiçosa para DFA

Boa localidade de referência;
melhor caso linear

Pior caso ainda superlinear

PyRex
O código cabe num slide o/

Benchmarks: (a?a)+b
Caso O(2^n): exponencialmente melhor

Benchmarks: a*b
Caso O(n): pior por um fator constante

Benchmarks: a*a*a*a*a*b
Caso O(n^5): polinomialmente melhor (e Ruby rouba)

Linguagens não-regulares
O que elas tem a ver com expressões regulares?

IRRESTRITAS


LIVRES DE CONTEXTO

REGULARES

Alguns exemplos

Exemplos
Parênteses
aninhados

(()()(())), (((()))), ...

"Squares"

DogDog, CatCat, WikiWiki, ...

an b n

ab, aabb, aaabbb, ...

Alguns exemplos

IRRESTRITAS


anbncn, "squares"

LIVRES DE CONTEXTO

anbn, parênteses

REGULARES

Expressões regulares que as reconhecem

Expressão
Parênteses
aninhados

(((?1)*))1

"Squares"

(.*)1

an b n

(a(?1)?b)1
1

sintaxe do Perl para recursive capture buffers

Match de regexps com
backreferences é um
problema NP-completo.

P vs NP
De novo essa #&$%@?
*assumindo que P!=NP

NP-HARD

NP-COMPLETE
NP

P

Para provar NP-completude
Eu contaria uma piada sobre NP-completos, mas se você
já ouviu uma, já conhece todas.
Provar pertinência em NP-hard
NP-HARD

Reduzir um problema NP-completo (3SAT, coloração de grafos, etc.) ao
problema em questão.

NP-COMPLETE

Provar pertinência em NP
NP

P

Provar que é possível verificar respostas
positivas às instâncias do problema em
tempo polinomial.

3-SAT
Um problema NP-completo

(¬x1
( x1
( x1
( x2
(¬x1
( x1
(¬x1

∨
∨
∨
∨
∨
∨
∨

x2
¬x3
¬x2
¬x3
x3
x2
¬x2

∨
∨
∨
∨
∨
∨
∨

x4)
x4)
¬x4)
¬x4)
¬x4)
x3)
¬x3)

∧
∧
∧
∧
∧
∧

3-SAT
Reduzindo a expressões regulares (com backreferences)
3-SAT com Regexp
variáveis x1, x2, x3 e x4
(¬x1 ∨

^(x?)(x?)(x?)(x?).*;

x2 ∨

x4) ∧

(x1|2|4),

( x1 ∨ ¬x3 ∨

x4) ∧

(1|x3|4),

( x1 ∨ ¬x2 ∨ ¬x4) ∧

(1|x2|x4),

( x2 ∨ ¬x3 ∨ ¬x4) ∧

(2|x3|x4),

(¬x1 ∨

x3 ∨ ¬x4) ∧

(x1|3|x4),

( x1 ∨

x2 ∨

x3) ∧

(¬x1 ∨ ¬x2 ∨ ¬x3)

(1|2|3),
(x1|x2|x3),$
match 'xxxx;x,x,x,x,x,x,x,'

Conclusão
● Match de expressões regulares com backreferences
é um problema NP-completo.
● É possível reconhecer cadeias em linguagens
regulares com algoritmo polinomial.
● Implementações como a da JDK podem levar a
tempos de execução exponenciais mesmo com
expressões que denotam linguagens regulares.
● O uso de expressões regulares modernas pode levar
a falhas de segurança em aplicações online.

devday2013

devday2013

Recommended

More Related Content

Featured

Featured(20)

devday2013