Mihaimaruseac

O TensorFlow é uma plataforma de código aberto para aprendizado de máquina. As macros que o TensorFlow utiliza para escrever asserções (por exemplo, `CHECK LT`, `CHECK GT`, etc.) apresentam uma lógica incorreta ao comparar valores `size t` e `int`. Devido às regras de conversão de tipos, várias dessas macros seriam acionadas incorretamente.

O problema decorre do fato de a função hash `TensorKey` utilizar o total estimado de `AllocatedBytes()`, que é uma estimativa por tensor e uma função hash inadequada para constantes, como `int32 t`. Ela também tenta acessar bytes individuais do tensor por meio de `tensor.data()` com tamanho `AllocatedBytes()`, levando a falhas no ASAN porque `AllocatedBytes()` é uma estimativa do total de bytes alocados por um tensor, incluindo construções apontadas como strings, e não se refere a bytes contíguos no buffer `.data()`. Os descobridores não poderiam usar esse vetor de bytes de qualquer maneira, pois tipos como `tstring` incluem ponteiros, enquanto eles precisavam fazer o hash dos próprios valores da string.

O TensorFlow é uma plataforma de código aberto para aprendizado de máquina. Certos modelos TFLite criados usando o conversor de modelos TFLite travavam ao serem carregados no interpretador TFLite. O problema ocorre porque, durante a quantização, a escala dos valores pode ser maior que 1, mas o código sempre assume uma escala subunitaria. Como resultado, o código chama `QuantizeMultiplierSmallerThanOneExp`, acionando a asserção `TFLITE CHECK LT` e abortando o processo.

A implementação de `tf.ragged.constant` não valida totalmente os argumentos de entrada, resultando em uma negação de serviço ao consumir toda a memória disponível. Essa vulnerabilidade pode ser explorada passando argumentos específicos para a função `tf.ragged.constant`, como `pylist=[]` e `ragged rank=8968073515812833920`.

O problema está relacionado à falta de validação de entrada nas funções `tf.compat.v1.signal.rfft2d` e `tf.compat.v1.signal.rfft3d`, o que pode resultar em falhas devido a erros de `CHECK` em determinadas condições.

O TensorFlow está vulnerável a uma gravação fora dos limites (OOB) da pilha (heap) no `Grappler`. A função `set output` grava em uma matriz no índice especificado, concedendo a um usuário mal-intencionado uma primitiva de gravação.

Um usuário mal-intencionado pode causar uma negação de serviço ao alterar um `SavedModel` de forma que qualquer operação binária acione falhas de `CHECK`. Isso ocorre quando a parte protobuf correspondente aos argumentos do tensor é modificada de forma que o `dtype` não corresponda mais ao `dtype` esperado pela operação. Se `Tin` e `Tout` não corresponderem ao tipo de dados nos tensores `out` e `input *`, então `flat<*>` interpretaria isso incorretamente, resultando em uma falha `CHECK` e, consequentemente, em uma negação de serviço.

Um usuário mal-intencionado pode causar um comportamento de uso após liberação (use after free) ao decodificar imagens PNG. Após a chamada de `png::CommonFreeDecode(&decode)`, os valores de `decode.width` e `decode.height` ficam em um estado não especificado.

Durante a inferência de forma, o TensorFlow pode alocar um vetor de grande porte com base em um valor de um tensor controlado pelo usuário. O problema decorre da alocação de um vetor com base no valor `num dims`, que é controlado pelo usuário por meio de um tensor. Isso pode levar a possíveis problemas de segurança.

O otimizador Grappler no TensorFlow pode ser usado para causar uma negação de serviço ao alterar um `SavedModel` de forma que `SafeToRemoveIdentity` acione falhas de `CHECK`.

A implementação de `Range` sofre de estouros de inteiros, o que pode provocar comportamento indefinido ou alocações extremamente grandes.

Ao decodificar um tensor do protobuf, o TensorFlow pode realizar uma desreferência nula se os atributos de alguns argumentos mutáveis de determinadas operações estiverem ausentes do proto. Esse problema é protegido por um `DCHECK`, que é uma operação nula em compilações de produção, permitindo que a execução prossiga para a desreferência do ponteiro nulo, e uma falha de asserção em compilações de depuração, resultando em uma falha no sistema.

Ao decodificar um tensor de identificador de recurso do protobuf, um processo do TensorFlow pode encontrar casos em que uma asserção `CHECK` é invalidada com base em argumentos controlados pelo usuário. Isso permite que invasores causem negação de serviço nos processos do TensorFlow.

Um invasor pode provocar uma negação de serviço por meio de falha de asserção, alterando um `SavedModel` no disco de forma que os `AttrDef`s de alguma operação sejam duplicados.

O otimizador Grappler no TensorFlow pode ser usado para causar uma negação de serviço ao alterar um `SavedModel` de forma que `IsSimplifiableReshape` acione falhas de `CHECK`.

A implementação de `OpLevelCostEstimator::CalculateTensorSize` é vulnerável a um estouro de inteiro se um invasor conseguir criar uma operação que envolva um tensor com um número de elementos suficientemente grande. Isso ocorre porque `count` e `size` podem ser grandes o suficiente para causar um estouro em `count * size`.

Há um erro de digitação no `SpecializeType` do TensorFlow que resulta em leitura/gravação fora dos limites da pilha. Devido ao erro de digitação, `arg` é inicializado com o `i`-ésimo argumento mutável em um loop onde o índice do loop é `j`, permitindo a atribuição a `arg` de fora do vetor de argumentos. Isso permite tanto a leitura quanto a gravação em dados fora dos limites.

A implementação de `OpLevelCostEstimator::CalculateOutputSize` é vulnerável a um estouro de inteiro se um invasor conseguir criar uma operação que envolva tensores com um número de elementos suficientemente grande. Isso pode ocorrer quando há um número de dimensões suficientemente grande em `output shape.dim()` ou quando um número pequeno de dimensões é grande o suficiente para causar um estouro na multiplicação.

O problema surge quando um nó do gráfico é inválido, fazendo com que o TensorFlow apresente um vazamento de memória na implementação de `ImmutableExecutorState::Initialize`. Isso ocorre porque `item->kernel` é definido como `nullptr`, mas é um simples ponteiro `OpKernel*`, resultando em um vazamento de memória da memória alocada anteriormente.

O TensorFlow pode falhar ao especializar um tipo durante a inferência de forma. Esse problema é abordado pela função `DCHECK`, que é uma operação nula em compilações de produção e uma falha de asserção em compilações de depuração. Como resultado, a execução prossegue para a linha `ValueOrDie`, causando uma falha de asserção porque `ret` contém um `Status` de erro, e não um valor. Em compilações de depuração, isso também resulta em uma falha devido à falha de asserção.