luuanhduc/cve-2021-35042Vulnerabilidade de injeção SQL no Django
O Django é um framework de aplicação web de código aberto, escrito em Python, construído com base no modelo MVC (Model-View-Controller). Foi originalmente desenvolvido para gerenciar sites de conteúdo de notícias pertencentes ao grupo editorial Lawrence, como um sistema de gerenciamento de conteúdo (CMS).
As versões 3.1.x a 3.1.13 e 3.2.x a 3.2.5 do Django possuem uma vulnerabilidade de injeção SQL.
A causa dessa vulnerabilidade é que a função de filtragem dos dados de entrada controlados pelo usuário no QuerySet.order_by() não é suficiente para prevenir ataques de injeção SQL. Essa vulnerabilidade pode ser explorada para permitir que um atacante realize ações não autorizadas, levando ao vazamento de dados sensíveis.
| CVE-ID | CVE-2021-35042 |
|---|---|
| Severidade | 9.8 - CRÍTICA |
| CWE-ID | CWE-89: Neutralização incorreta de elementos especiais usados em um comando SQL ('Injeção SQL') |
| Data de publicação da vulnerabilidade | 01/07/2021 |
| Software afetado | 3.1.x < 3.1.13, 3.2.x < 3.2.5 |
| Requer autenticação | Não é necessária |
No Django, a criação de tabelas e definição de campos no banco de dados é feita declarando uma classe de modelo no arquivo models.py. Neste exemplo, declaramos uma tabela chamada Wolf e um campo chamado name.
O framework ORM integrado ao Django é usado para manipular o banco de dados, e o resultado de uma consulta é um conjunto, chamado de QuerySet.
order_by(campos)
Por padrão, order_by() retorna um QuerySet ordenado de acordo com a ordem especificada na opção ordering do Meta do Model. Podemos sobrescrever a condição order_by em cada consulta usando o método order_by().
Exemplo
wolves = Wolf.objects.order_by('-name', 'id')
O resultado da consulta acima será ordenado de forma decrescente pelo campo name e depois de forma crescente pelo id. O sinal negativo antes do nome do campo name indica uma ordenação decrescente.
O exemplo a seguir ordena o resultado retornado pelo campo recebido do usuário; se nenhum valor for passado, ordena pelo campo
id.
Resultado
Nas versões 3.1 e 3.2, o Django permite combinar o método de consulta com o nome da tabela na consulta order_by. Essa é a principal causa dessa vulnerabilidade.
Passar um nome de tabela nos dá o mesmo resultado que passar um nome de campo normalmente.
cve202135042_wolf é o nome da tabela
Primeiro, a aplicação chama diretamente a função order_by(). O código que processa a função order_by() está definido em:
django/db/models/query.py
A função
order_by()realiza duas ações:
- Remove todas as ordenações atuais que estão sendo chamadas por
order_by()e remove o parâmetro padrão passado quandoorder_byrecebe um valor diferente.- Passa os parâmetros para
order_by. A funçãoadd_ordering()realiza essa etapa.
def add_ordering(self, *ordering):
"""
Add items from the 'ordering' sequence to the query's "order by"
clause. These items are either field names (not column names) --
possibly with a direction prefix ('-' or '?') -- or OrderBy
expressions.
If 'ordering' is empty, clear all ordering from the query.
"""
errors = []
for item in ordering:
if isinstance(item, str):
if '.' in item:
warnings.warn(
'Passing column raw column aliases to order_by() is '
'deprecated. Wrap %r in a RawSQL expression before '
'passing it to order_by().' % item,
category=RemovedInDjango40Warning,
stacklevel=3,
)
continue
if item == '?':
continue
if item.startswith('-'):
item = item[1:]
if item in self.annotations:
continue
if self.extra and item in self.extra:
continue
# names_to_path() validates the lookup. A descriptive
# FieldError will be raise if it's not.
self.names_to_path(item.split(LOOKUP_SEP), self.model._meta)
elif not hasattr(item, 'resolve_expression'):
errors.append(item)
if getattr(item, 'contains_aggregate', False):
raise FieldError(
'Using an aggregate in order_by() without also including '
'it in annotate() is not allowed: %s' % item
)
if errors:
raise FieldError('Invalid order_by arguments: %s' % errors)
if ordering:
self.order_by += ordering
else:
self.default_ordering = False
O parâmetro passado para add_ordering() é um array.
Exemplo: quando o parâmetro é passado da seguinte forma:
wolves = Wolf.objects.order_by( 'name' , 'id' )A aplicação converte isso em uma consulta SQL no banco de dados:
SELECT "cve202135042_wolf"."id", "cve202135042_wolf"."name" FROM "cve202135042_wolf" ORDER BY "cve202135042_wolf"."name" ASC, "cve202135042_wolf"."id" ASC
Quando recebido, a função add_ordering verifica cada elemento do array; se for uma string, ela é verificada em 5 casos:
if '.' in item:Verifica se é uma consulta com um nome de coluna e se essa coluna tem um nome de tabela especificado na instrução SQL. Se sim, emite um aviso econtinue.if item == '?':Se o valor do elemento for '?', o resultado da saída será ordenado aleatoriamente,continue.if item.startswith('-'):Se o item começar com '-', o resultado da consulta será ordenado DESC (decrescente).if item in self.annotations:Verifica se contém um comentário; se sim,continue.if self.extra and item in self.extra:Verifica se há uma cláusula extra; se sim,continue.
Após as 5 verificações, o parâmetro é passado para a função self.names_to_path(item.split(LOOKUP_SEP), self.model._meta) para verificar se é um nome de coluna válido. Depois, se for válido, é adicionado ao self.ordering da classe Query para processamento.
O ORM do Django realiza a filtragem dos dados inseridos nas consultas de maneira muito rigorosa, mas a mudança no código que levou a essa injeção SQL ocorreu porque o autor assumiu que, se o nome da coluna fosse um UUID (Identificador Único Universal), a consulta order_by não poderia ser executada.
Ou seja, se os dados de entrada estivessem no formato xxx-xxx-xxx-xxx (formato UUID), a consulta não poderia ser executada.