Se você acha que mágica não existe na tecnologia, é porque ainda não viu o que os falsificadores de hardware conseguem fazer com algumas linhas de código. O golpe do pendrive de 2 Terabytes é uma das fraudes mais brilhantes e destrutivas da internet moderna. Hoje, nós vamos abrir o capô dessa fraude. Vamos descer ao nível do firmware e usar a linguagem C para entender como o hardware mente para o Windows, e o melhor: vamos programar o nosso próprio “detetive” em Python para desmascarar esses dispositivos.

A isca perfeita

Você está navegando no AliExpress ou na Shopee em uma noite qualquer. De repente, lá está ela: aquela oferta irresistível. Um pendrive prateado, com o logotipo impecável de uma marca famosa, prometendo nada menos que 2 Terabytes de armazenamento por valor muito baixo.

“Impossível!”, pensa uma parte do seu cérebro. “Mas olha as avaliações de 5 estrelas!”, responde a outra parte, já digitando os dados do cartão.

O pacote chega semanas depois. Você, ansioso, espeta o pendrive na USB do computador e, para sua alegria, confirma no Explorador de Arquivos:

Eufórico, você começa a copiar tudo: filmes, séries, a pasta de fotos da família desde 2005, backups do trabalho. Tudo aparece lá, bonitinho, com suas pastas e ícones. Você acaba de dar o golpe do ano em si mesmo.

Semanas depois, você precisa de um arquivo importante. Clica duas vezes e… nada. Ou pior: um arquivo corrompido, uma imagem ou um vídeo que simplesmente não abre.

Mas a dúvida que fica é: Como isso funciona ? Entenderemos a seguir a engenharia brilhante por trás desse golpe.

A anatomia do golpe

Para entender a fraude, precisamos olhar para dentro do dispositivo. Todo pendrive possui dois componentes fundamentais:

O Chip de Memória Flash (NAND): É onde os seus dados (zeros e uns) são fisicamente armazenados.

O Microcontrolador: É um chip inteligente responsável por conversar com a porta USB do seu computador e organizar onde cada arquivo vai ser guardado.

O golpe acontece na linha de montagem clandestina. Os criminosos compram componentes reais, mas de baixíssima capacidade. Geralmente esses chips de memória suportam apenas 8 GB ou 16 GB. Em seguida, eles conectam esse hardware a um software de alteração de fábrica e reprogramam o Microcontrolador.

Eles inserem um firmware malicioso que altera a identidade do pendrive. Quando você o conecta no PC, o cérebro do dispositivo fala para o sistema operacional: “Olá, eu sou um pendrive de 2048 Gigabytes!”. O sistema operacional, que foi programado para confiar no que o controlador do hardware diz, acredita cegamente e exibe aquele 1,9 TB livre na sua tela.

O Loop da destruição

Mas aí surge a grande dúvida computacional: Como o pendrive não dá erro de “Disco Cheio” quando você tenta colocar 50 GB de arquivos dentro de um espaço físico de apenas 8 GB?

A resposta está em uma técnica clássica de programação de baixo nível chamada Buffer Circular (ou Memory Wrapping). Em vez de avisar que o espaço acabou, o microcontrolador usa uma simples operação matemática de “módulo” para enganar a gravação.

Se pudéssemos ver o código em C rodando dentro do microcontrolador falso, seria algo assustadoramente simples, mais ou menos assim:

void gravar_dados(long endereco_desejado, byte dados) {
    
    long capacidade_real = 8589934592; 
    
    long endereco_real = endereco_desejado % capacidade_real;

    memoria_flash[endereco_real] = dados; 
}
  

O resultado catastrófico

Quando a memória física real enche, o ponteiro de gravação volta para o endereço zero. As suas fotos antigas de 2005 são sobrescritas pelos filmes novos que você acabou de colar.

“Mas Lucas, por que as pastas e os nomes dos arquivos continuam aparecendo lá?”

Porque a Tabela de Alocação de Arquivos fica guardada bem no comecinho da memória, e o firmware pirata é programado para proteger essa área. O sistema operacional lê o índice e acha que o arquivo está lá, mas o conteúdo real já virou poeira digital.

Construindo seu próprio “Detetive de pendrives”

Já sabemos como o golpe funciona, mas agora precisamos saber como identificá-lo. Para isso, usando o Python iremos criar um Deep Scan. Ele vai gravar arquivos de 100 Megabytes continuamente até o pendrive dizer que está cheio. O pulo do gato é que cada arquivo terá um conteúdo único, uma assinatura com o número do bloco.

Depois de encher o pendrive, o Python vai ler todos os arquivos. Se o pendrive for falso, os primeiros arquivos gravados não terão a assinatura correta, pois o microcontrolador apagou o começo para gravar o final.

    import os

def testar_pendrive_completo(caminho_pendrive, tamanho_chunk_mb=100):
    print(f"Iniciando Teste Profundo no pendrive: {caminho_pendrive}")
    print("Aviso: Este teste vai encher o dispositivo. Pode demorar dependendo da velocidade da porta USB.\n")

    chunk_size = 1024 * 1024 * tamanho_chunk_mb
    arquivos_escritos = []
    contador = 0

    print("--- ETAPA 1: ESCRITA EM MASSA ---")
    try:
        while True:
            nome_arquivo = os.path.join(caminho_pendrive, f"teste_bloco_{contador:04d}.tmp")
            assinatura = f"BLOCO_{contador}_".encode('utf-8')
            dados_teste = assinatura * (chunk_size // len(assinatura))
            
            with open(nome_arquivo, "wb") as f:
                f.write(dados_teste)
            
            arquivos_escritos.append(nome_arquivo)
            print(f"Gravado bloco {contador} ({tamanho_chunk_mb} MB)...")
            contador += 1
            
    except OSError:
        print(f"\nFim do espaço disponível atingido.")
        print(f"Tentativa de gravação total: {contador * tamanho_chunk_mb} MB")

    print("\n--- ETAPA 2: VALIDAÇÃO DE INTEGRIDADE ---")
    blocos_corrompidos = 0
    blocos_integros = 0

    for i, arquivo in enumerate(arquivos_escritos):
        try:
            assinatura_esperada = f"BLOCO_{i}_".encode('utf-8')
            dados_esperados = assinatura_esperada * (chunk_size // len(assinatura_esperada))
            
            with open(arquivo, "rb") as f:
                dados_lidos = f.read()

            if dados_lidos == dados_esperados:
                blocos_integros += 1
            else:
                blocos_corrompidos += 1
                print(f"CORRUPÇÃO DETECTADA no arquivo {arquivo}!")
                
        except Exception as e:
            print(f"ERRO DE LEITURA no arquivo {arquivo}: {e}")
            blocos_corrompidos += 1

    print("\n--- RESULTADO FINAL DO DETETIVE ---")
    capacidade_real_mb = blocos_integros * tamanho_chunk_mb
    print(f"Capacidade REAL e Íntegra: {capacidade_real_mb} MB")
    print(f"Blocos Corrompidos/Fantasmas: {blocos_corrompidos * tamanho_chunk_mb} MB")

    if blocos_corrompidos > 0:
        print("\n VEREDITO: GOLPE DETECTADO!")
        print("O pendrive sofreu Memory Wrapping. Ele forjou um espaço que não existe fisicamente.")
    else:
        print("\n VEREDITO: Pendrive Íntegro! A capacidade testada é real.")

    print("\nLimpando arquivos de teste...")
    for arquivo in arquivos_escritos:
        if os.path.exists(arquivo):
            os.remove(arquivo)
    print("Teste finalizado com sucesso.")
    
  

Explicação do código

A função testar_pendrive_completo recebe dois parâmetros: o caminho do pendrive a ser testado e o tamanho de cada bloco de teste em megabytes. Na sequência, o código calcula o tamanho do chunk em bytes, multiplicando pelo tamanho desejado. Também são inicializadas duas variáveis de controle: uma lista vazia chamada arquivos_escritos, que vai armazenar os caminhos de todos os arquivos criados durante o teste, e um contador que serve para numerar e identificar cada bloco gravado de forma única.

Primeira fase

Esta é a primeira fase do teste, onde o script tenta preencher todo o espaço disponível no pendrive. O código entra em um loop infinito que só será interrompido quando o sistema operacional reportar que não há mais espaço disponível, capturado pela exceção OSError.

Para cada iteração, o script cria um nome de arquivo único usando formatação com zeros à esquerda, gerando nomes como teste_bloco_0000.tmp, teste_bloco_0001.tmp, e assim por diante. O detalhe mais inteligente aqui é a criação de uma assinatura única para cada bloco: em vez de simplesmente preencher o arquivo com letras “A”, o código grava um padrão que contém o número do bloco (como BLOCO_0_, BLOCO_1_). Essa assinatura é repetida até preencher o tamanho total do chunk. Isso é crucial porque, na etapa de validação, o script consegue identificar não apenas se houve corrupção, mas também qual bloco específico foi sobrescrito pelo Memory Wrapping.

Segunda fase

A segunda fase é onde a mágica do teste realmente acontece. O script percorre cada arquivo que foi gravado na etapa anterior e reconstrói em memória exatamente o que deveria estar armazenado naquele arquivo, usando a mesma lógica de assinatura única. Em seguida, ele lê o conteúdo real do arquivo diretamente do pendrive e compara byte a byte com os dados esperados.

Se os dados coincidirem perfeitamente, o bloco é contabilizado como íntegro. Se houver qualquer diferença o bloco é marcado como corrompido e uma mensagem de alerta é exibida.

Terceira fase

A etapa final do script apresenta um relatório claro e objetivo para o usuário. A capacidade real do pendrive é calculada multiplicando o número de blocos íntegros pelo tamanho de cada bloco. Essa é a informação mais valiosa: se você comprou um “pendrive de 2TB” e o script reporta que a capacidade real é de apenas 7.8GB, você tem a prova concreta do golpe.

O veredito é dado de forma binária: se houver qualquer bloco corrompido, o pendrive é considerado falsificado, pois um dispositivo legítimo não deveria apresentar corrupção de dados em condições normais de teste. Por fim, o script faz a limpeza responsável, removendo todos os arquivos temporários criados durante o teste, deixando o pendrive vazio e pronto para uso ou para ser devolvido ao vendedor com uma reclamação bem fundamentada!

E agora? Como consertar o pendrive falso?

Você rodou o nosso script detetive, e a triste verdade apareceu: o seu pendrive de 2TB, na verdade, só tem 8GB. O que fazer agora? Jogar no lixo?

Não necessariamente! Você não pode transformar 8GB em 2TB magicamente, mas você pode “domar” esse pendrive para que ele pare de mentir para o sistema operacional e passe a funcionar como um pendrive honesto de 8GB, garantindo que você nunca mais perca arquivos por sobrescrita.

Existem duas formas de fazer isso.

Método 1: A Rota Segura

A forma mais fácil e segura de resolver o problema é usar o próprio sistema operacional para criar uma “cerca” virtual, impedindo que o Windows tente gravar dados na área que não existe.

Anote a capacidade real: Olhe no resultado do nosso script Python qual foi a capacidade íntegra encontrada (ex: 7800 MB).

Abra o Gerenciador de Disco. Depois disso, encontre o pendrive na lista, clique com o botão direito na partição (que estará marcando os falsos 1.9 TB) e selecione “Excluir Volume”. O pendrive ficará com o espaço totalmente “Não Alocado”.

Se estiver no Windows, clique com o botão direito no espaço não alocado e selecione “Novo Volume Simples”.

Quando o assistente perguntar o tamanho do volume, NÃO deixe o valor máximo. Digite exatamente o valor real que o Python encontrou (ex: 7800).

Formate normalmente. O restante do espaço ficará isolado e inutilizado pelo seu sistema operacional. Seu pendrive agora é 100% seguro para uso!

Método 2: A Rota Hardcore

Se você tem espírito de hacker e quer resolver o problema na raiz, pode tentar regravar o cérebro do pendrive. O objetivo aqui é usar softwares de fábrica para apagar o firmware pirata e instalar um firmware honesto, corrigindo a capacidade direto no hardware.

Se quiser assumir o risco pelo aprendizado, o caminho é este:

Descubra o chip: Use um software de diagnóstico de hardware como o ChipGenius para escanear o pendrive. Ele vai te dizer exatamente qual é a fabricante do microcontrolador e o modelo exato do chip.

Com o modelo do chip em mãos, você precisará procurar em fóruns especializados como o site russo FlashBoot pelo MPTool (Mass Production Tool) específico para aquele controlador.

Uma vez encontrado o MPTool correto, abra-o e conecte o pendrive, configure o software para a capacidade real e inicie o “Flash”. O software vai apagar a mente do controlador e injetar o código novo e correto.

Se der certo, você acabou de fazer engenharia reversa e consertar um hardware corrompido direto na fábrica!

Conclusão

No mundo da segurança da informação e do hardware, existe uma regra de ouro que nunca falha: se o preço da tecnologia parece bom demais para ser verdade, a matemática da fabricação não fecha.

Chips de memória NAND flash legítimos de 2 Terabytes custam dezenas ou centenas de dólares para serem produzidos e testados. Nenhuma fábrica clandestina tem uma “fórmula mágica” para vender isso por um preço pífio na internet.

Da próxima vez que vir um anúncio de um pendrive de 2TB, 8TB, 16TB, lembre-se do código em C rodando silenciosamente no microcontrolador do dispositivo, apenas esperando para triturar os seus dados de forma irrecuperável.

E você, já perdeu arquivos em um pendrive mágico desses ou conhece alguém que caiu nessa armadilha? Pegue o código em Python, rode aquele pendrive suspeito da gaveta e deixe o resultado real da capacidade dele aqui nos comentários!

Se você curtiu entender como o pendrive guarda as informações, veja também como recuperar os arquivos apagados do pendrive usando a linguagem C.