Denial of Service: Regular Expression

Dados não confiáveis são transmitidos ao aplicativo e usados como uma expressão regular. Isso pode fazer com que o thread consuma excessivamente os recursos da CPU.

Há uma vulnerabilidade em implementações de avaliadores de expressão regular e métodos relacionados que pode provocar o travamento do thread durante a avaliação de expressões regulares que contêm uma expressão de agrupamento que se repete. Além disso, qualquer expressão regular que contenha subexpressões alternativas que se sobreponham umas às outras também pode ser explorada. Esse defeito pode ser usado para executar um ataque de Negação de Serviço (DoS).
Exemplo:

  (e+)+
  ([a-zA-Z]+)*
  (e|ee)+

Não existem implementações conhecidas de expressões regulares que sejam imunes a essa vulnerabilidade. Todas as plataformas e linguagens são vulneráveis a esse ataque.

Dados não confiáveis são transmitidos ao aplicativo e usados como uma expressão regular. Isso pode fazer com que o thread consuma excessivamente os recursos da CPU.

Há uma vulnerabilidade em implementações de avaliadores de expressão regular e métodos relacionados que pode provocar o travamento do thread durante a avaliação de expressões regulares que contêm uma expressão de agrupamento que se repete. Além disso, qualquer expressão regular que contenha subexpressões alternativas que se sobreponham umas às outras também pode ser explorada. Esse defeito pode ser usado para executar um ataque de Negação de Serviço (DoS).
Exemplo:

  (e+)+
  ([a-zA-Z]+)*
  (e|ee)+

Não existem implementações conhecidas de expressões regulares que sejam imunes a essa vulnerabilidade. Todas as plataformas e linguagens são vulneráveis a esse ataque.

Dados não confiáveis são transmitidos ao aplicativo e usados como uma expressão regular. Isso pode fazer com que o thread consuma excessivamente os recursos da CPU.

Há uma vulnerabilidade em implementações de avaliadores de expressão regular e métodos relacionados que pode provocar o travamento do thread durante a avaliação de expressões regulares que contêm uma expressão de agrupamento que se repete. Além disso, invasores podem explorar qualquer expressão regular que contenha subexpressões alternativas que se sobreponham umas às outras. Esse defeito pode ser usado para executar um ataque de Negação de Serviço (DoS).
Exemplo:

  (e+)+
  ([a-zA-Z]+)*
  (e|ee)+

Não existem implementações conhecidas de expressões regulares que sejam imunes a essa vulnerabilidade. Todas as plataformas e linguagens são vulneráveis a esse ataque.

Dados não confiáveis são transmitidos ao aplicativo e usados como uma expressão regular. Isso pode fazer com que o thread consuma excessivamente os recursos da CPU.

Há uma vulnerabilidade em implementações de avaliadores de expressão regular e métodos relacionados que pode provocar o travamento do thread durante a avaliação de expressões regulares que contêm uma expressão de agrupamento que se repete. Além disso, qualquer expressão regular que contenha subexpressões alternativas que se sobreponham umas às outras também pode ser explorada. Esse defeito pode ser usado para executar um ataque de Negação de Serviço (DoS).
Exemplo:

  (e+)+
  ([a-zA-Z]+)*
  (e|ee)+

Não existem implementações conhecidas de expressões regulares que sejam imunes a essa vulnerabilidade. Todas as plataformas e linguagens são vulneráveis a esse ataque.

Dados não confiáveis são transmitidos ao aplicativo e usados como uma expressão regular. Isso pode fazer com que o thread consuma excessivamente os recursos da CPU.

Há uma vulnerabilidade em implementações de avaliadores de expressão regular e métodos relacionados que pode provocar o travamento do thread durante a avaliação de expressões regulares que contêm uma expressão de agrupamento que se repete. Além disso, qualquer expressão regular que contenha subexpressões alternativas que se sobreponham umas às outras também pode ser explorada. Os invasores podem usar esse defeito para executar um ataque de DoS (Negação de Serviço).
Exemplo:

  (e+)+
  ([a-zA-Z]+)*
  (e|ee)+

Não existem implementações conhecidas de expressões regulares que sejam imunes a essa vulnerabilidade. Todas as plataformas e linguagens são vulneráveis a esse ataque.

Dados não confiáveis são transmitidos ao aplicativo e usados como uma expressão regular. Isso pode fazer com que o thread consuma excessivamente os recursos da CPU.

Há uma vulnerabilidade em implementações de avaliadores de expressão regular e métodos relacionados que pode provocar o travamento do thread durante a avaliação de expressões regulares que contêm uma expressão de agrupamento que se repete. Além disso, qualquer expressão regular que contenha subexpressões alternativas que se sobreponham umas às outras também pode ser explorada. Esse defeito pode ser usado para executar um ataque de Negação de Serviço (DoS).
Exemplo 1: Se estas expressões regulares forem usadas no código vulnerável identificado, uma negação de serviço pode ocorrer:

  (e+)+
  ([a-zA-Z]+)*
  (e|ee)+

Exemplo de código problemático que depende de expressões regulares falhas:

NSString *regex = @"^(e+)+$";
NSPredicate *pred = [NSPRedicate predicateWithFormat:@"SELF MATCHES %@", regex];
if ([pred evaluateWithObject:mystring]) {
  //do something
}

A maioria dos analisadores de expressões regulares constroem estruturas de Máquina de estados finitos não determinística (Nondeterministic Finite Automaton, NFA) ao avaliar expressões regulares. A NFA tenta todas as correspondências possíveis até que uma correspondência completa seja encontrada. Dado o exemplo anterior, se o invasor fornecer a cadeia de correspondência "eeeZ", o analisador regex deverá verificar 16 avaliações internas para identificar uma correspondência. Se o invasor fornecer 16 "e"s ("eeeeeeeeeeeeeeeeZ") como a cadeia de correspondência, o analisador regex deverá verificar 65536 (2^16) avaliações. O invasor pode consumir recursos de computação facilmente por meio do aumento do número de caracteres de correspondência consecutivos. Não existem implementações conhecidas de expressões regulares que sejam imunes a essa vulnerabilidade. Todas as plataformas e linguagens são vulneráveis a esse ataque.

Dados não confiáveis são transmitidos ao aplicativo e usados como uma expressão regular. Isso pode fazer com que o thread consuma excessivamente os recursos da CPU.

Há uma vulnerabilidade em implementações de avaliadores de expressão regular e métodos relacionados que pode provocar o travamento do thread durante a avaliação de expressões regulares que contêm uma expressão de agrupamento que se repete. Além disso, qualquer expressão regular que contenha subexpressões alternativas que se sobreponham umas às outras também pode ser explorada. Esse defeito pode ser usado para executar um ataque de Negação de Serviço (DoS).
Exemplo:

  (e+)+
  ([a-zA-Z]+)*
  (e|ee)+

Não existem implementações conhecidas de expressões regulares que sejam imunes a essa vulnerabilidade. Todas as plataformas e linguagens são vulneráveis a esse ataque.

Dados não confiáveis são transmitidos ao aplicativo e usados como uma expressão regular. Isso pode fazer com que o thread consuma excessivamente os recursos da CPU.

Há uma vulnerabilidade em implementações de avaliadores de expressão regular e métodos relacionados que pode provocar o travamento do thread durante a avaliação de expressões regulares que contêm uma expressão de agrupamento que se repete. Além disso, qualquer expressão regular que contenha subexpressões alternativas que se sobreponham umas às outras também pode ser explorada. Esse defeito pode ser usado para executar um ataque de Negação de Serviço (DoS).
Exemplo:

  (e+)+
  ([a-zA-Z]+)*
  (e|ee)+

Não existem implementações conhecidas de expressões regulares imunes a essa vulnerabilidade. Todas as plataformas e linguagens são vulneráveis a esse ataque.

Dados não confiáveis são transmitidos ao aplicativo e usados como uma expressão regular. Isso pode fazer com que o thread consuma excessivamente os recursos da CPU.

Há uma vulnerabilidade em implementações de avaliadores de expressão regular e métodos relacionados que pode provocar o travamento do thread durante a avaliação da sobreposição repetida e alternada de grupos de expressões regulares aninhados e repetidos. Esse defeito pode ser usado para executar um ataque de Negação de Serviço (DoS).
Exemplo:

(e+)+
([a-zA-Z]+)*

Não existem implementações conhecidas de expressões regulares que sejam imunes a essa vulnerabilidade. Todas as plataformas e linguagens são vulneráveis a esse ataque.

Dados não confiáveis são transmitidos ao aplicativo e usados como uma expressão regular. Isso pode fazer com que o thread consuma excessivamente os recursos da CPU.

Há uma vulnerabilidade em implementações de avaliadores de expressão regular e métodos relacionados que pode provocar o travamento do thread durante a avaliação de expressões regulares que contêm uma expressão de agrupamento que se repete. Além disso, qualquer expressão regular que contenha subexpressões alternativas que se sobreponham umas às outras também pode ser explorada. Esse defeito pode ser usado para executar um ataque de Negação de Serviço (DoS).
Exemplo:

  (e+)+
  ([a-zA-Z]+)*
  (e|ee)+

Não existem implementações conhecidas de expressões regulares que sejam imunes a essa vulnerabilidade. Todas as plataformas e linguagens são vulneráveis a esse ataque.

Dados não confiáveis são transmitidos ao aplicativo e usados como uma expressão regular. Isso pode fazer com que o thread consuma excessivamente os recursos da CPU.

Há uma vulnerabilidade em implementações de avaliadores de expressão regular e métodos relacionados que pode provocar o travamento do thread durante a avaliação de expressões regulares que contêm uma expressão de agrupamento que se repete. Além disso, qualquer expressão regular que contenha subexpressões alternativas que se sobreponham umas às outras também pode ser explorada. Esse defeito pode ser usado para executar um ataque de Negação de Serviço (DoS).

Exemplo 1: Se estas expressões regulares forem usadas no código vulnerável identificado, uma negação de serviço pode ocorrer:

(e+)+
([a-zA-Z]+)*
(e|ee)+

Exemplo de código problemático que depende de expressões regulares falhas:

let regex : String = "^(e+)+$"
let pred : NSPredicate = NSPRedicate(format:"SELF MATCHES \(regex)")
if (pred.evaluateWithObject(mystring)) {
  //do something
}

A maioria dos analisadores de expressões regulares constroem estruturas de Máquina de estados finitos não determinística (Nondeterministic Finite Automaton, NFA) ao avaliar expressões regulares. A NFA tenta todas as correspondências possíveis até que uma correspondência completa seja encontrada. Dado o Example 1, se o invasor fornecer a cadeia de correspondência "eeeZ", o analisador regex deverá verificar 16 avaliações internas para identificar uma correspondência. Se o invasor fornecer 16 "e"s ("eeeeeeeeeeeeeeeeZ") como a cadeia de correspondência, o analisador regex deverá verificar 65536 (2^16) avaliações. O invasor pode consumir recursos de computação facilmente por meio do aumento do número de caracteres de correspondência consecutivos. Não existem implementações conhecidas de expressões regulares que sejam imunes a essa vulnerabilidade. Todas as plataformas e linguagens são vulneráveis a esse ataque.