Spectre e Meltdown.

Já mencionamos isso no Top Des domingo passado, mas agora eu volto para explicar o que são essas falhas de segurança que ameaçam basicamente todos os computadores (inclusive o que você carrega por aí na forma de um smartphone). Spectre e Meltdown são os nomes dados para essas falhas, e a única certeza de se livrar deles é trocar o processador, fisicamente. Isso é, quando lançarem um à prova dessas ameaças. Porque hoje em dia, eles ainda não existem.

Mas como eu sei que muitos de vocês não conhecem ou mesmo não se importam com os duendes que fazem a informática funcionar nos dias atuais, vamos nos situar primeiro: todo computador (de mesa ou de bolso) precisa de uma peça chamada processador, que pega as informações que chegam de todos os lados e as transformam nas coisas que queremos. Se você perguntar pro computador qual o resultado de uma conta, o processador vai descobrir isso pra você e devolver uma resposta. É basicamente uma pessoa que faz todas as contas do escritório.

Há algumas décadas atrás, as empresas que fabricam processadores conseguiam dobrar o Q.I. dessa pessoa que fazia as contas ano após ano. De uma certa forma, ainda tinha bastante espaço dentro da “cabeça” do processador para colocar mais e mais neurônios. Mas como não é surpresa pra ninguém, quanto mais coisa você enfia dentro de um espaço limitado, mais complicado fica colocar outras. Os processadores evoluíram por muitos anos só colocando mais e mais capacidade dentro das peças. Mas aí, ficou apertado.

De uma forma mais técnica, começamos a bater num limite físico de quão pequeno poderia ser cada um dos transistores de silício. Aí, as empresas produtoras precisaram ficar mais criativas. Além de começar a multiplicar o número de pessoas fazendo contas dentro de cada processador (uma forma simples de falar daquele lance todo de quantos “cores” tem um processador), procuraram todo tipo de atalho para não deixar que o avanço de capacidade entre uma versão e outra ficasse pequeno demais. E essas falhas descobertas recentemente tem tudo a ver com esses atalhos.

Vejam bem, não estou falando de atalhos de forma pejorativa, não é que fizeram gambiarras com o processador, mas sim de ideias brilhantes de engenheiros geniais que mantiveram o avanço da tecnologia de processamento sempre em frente. Infelizmente, existe uma forma ainda mais brilhante de explorar essas táticas e roubar informação confidencial dos nossos computadores. Os processadores foram projetados para evitar quase todos os tipos de ataques, menos esse. Estão batendo bastante na Intel (a maior produtora de processadores do mundo) por isso, mas não precisamos ser tão duros, Spectre e Meltdown são exemplos praticamente perfeitos de “cisnes negros”.

E quais são essas ideias brilhantes exploradas pelas falhas? Cache, execução fora de ordem e execução especulativa. Não adianta fazer cara feia, vou falar de cada uma delas do mesmo jeito:

Cache: se você já viu um computador aberto, vai perceber que todas as peças estão muito próximas umas das outras. E via de regra, processador e memória (a famosa RAM) ficam ainda mais próximos. Podem parecer meros centímetros (se tanto) para nós, mas pra sistemas que realizam bilhões de cálculos por segundo, correr um centímetro quase que na velocidade da luz pode ser meio lento. A sacada do cache foi criar uma memória pequena dentro do processador, para coisas mais rápidas. Ao invés da pessoa que faz as contas ir ficar pegando papelada na estante da parede, deixa alguns papéis mais importantes em cima da sua mesa mesmo. É só bater o olho quando precisar. Processadores modernos usam e abusam dessa tática, tentando completar o máximo possível da sua tarefa antes de precisar levantar e ir até a estante. Ah, e nessa analogia, o HD é mais ou menos como uma sala em outro andar.

Execução fora de ordem: antigamente, quando um processador recebia uma série de instruções da memória do computador, pegava o pacote todo, lia o que tinha que fazer e ia fazendo uma por uma, na ordem. O cidadão recebia uma lista de contas, conferia se eram todas contas mesmo e ia preenchendo o seu papel com as respostas. Dava pra fazer melhor, dava pra fazer bem melhor. Tanto que hoje em dia o nosso funcionário processador tem uma equipe ao seu dispor, cada um especialista num tipo de conta. Ele pega o pedido de contas que recebeu e passa uma parte para cada um de sua equipe mais capaz de resolvê-la. Assim, todo mundo trabalha ao mesmo tempo e ninguém fica segurando o outro. Não tem gargalo. Quando todas as contas estão feitas, aí sim que o processador coloca todo mundo na ordem pedida originalmente e entrega o resultado. Novamente, para evitar esperas desnecessárias.

Execução especulativa: essa é genial. Normalmente códigos de computador tem bifurcações. Pontos onde o processador toma uma decisão baseado numa condição anteriormente definida. Exemplo simples de novo: “se o resultado da conta anterior for 2, escreva oi; se o resultado da conta anterior for 3, escreva tchau”. Antigamente isso seguia a lógica esperada, enquanto o processador não tivesse feito a conta cujo resultado é condição para essa decisão, não fazia nada.

Mas, lembram que eu falei que o cache são os papéis na mesa e memória RAM é a estante na parede? O processador costuma colocar o resultado de cada conta na estante para evitar que a mesa fique lotada. Nessa analogia de processadores, as mesas são muito menores que as estantes, e é vital para o funcionamento de toda a operação que só fique o essencial e urgente em cima da mesa. Quando o processador precisa do resultado da conta anterior para tomar a próxima decisão, manda um estagiário buscar na estante. O que os engenheiros de processadores perceberam é que é mais eficiente o processador “chutar” o resultado da conta e já deixar pronta a próxima etapa do código do que sempre esperar o estagiário voltar. Tecnicamente, chutar o resultado da conta é 200 vezes mais rápido que esperar a resposta dela voltar da estante.

Então, processadores começaram a chutar a torto e a direito. Quando acertavam, o trabalho já estava pronto antes do estagiário voltar da estante. Quando erravam… bom, azar, tinha que fazer de novo. Mas não estamos falando de chutes aleatórios: programas de computador tendem a ser bem repetitivos no que pedem para o processador. Se nas últimas dez vezes que o processador teve que fazer a decisão do exemplo o resultado foi 2, grandes chances de escrever “oi” e estar certo. Esse tipo de execução especulativa faz o processador fazer contas que nem precisaria fazer só para na (alta) chance de estar certo, utilizar melhor o seu tempo.

Resumo: processadores modernos trabalham com uma memória especial muito rápida e próxima, executam operações fora de ordem para utilizar melhor seus recursos, e ainda por cima arriscam operações aparentemente desnecessárias porque são excelentes em prever que elas vão ser necessárias. Bacana, viva a tecnologia! Você pode ver vídeos de gatos e pessoas irritantes na internet muito mais rápido por causa disso. Mas daí que surge o problema dessas duas falhas de segurança.

Spectre é o nome da falha mais geral, que atinge basicamente qualquer coisa com um processador moderno. Meltdown é uma versão mais específica e perigosa do Spectre que atualmente só ameaça processadores da Intel. Se você tiver um computador Windows, Linux ou mesmo Mac, não faz diferença, o problema está na parte física mesmo da coisa. Em resumo, essa falha abusa dessas habilidades dos processadores modernos para ler o que não deveria da memória do computador. Os sistemas que temos são suficientemente espertos para não deixar portas abertas entre um programa qualquer e o lugar onde guarda suas senhas e outras informações valiosas. Mas essas falhas não precisam de portas: elas “presumem” o que está atrás da porta pelas luzes que passam pelas frestas dela. E depois saem correndo para contar para quem quer que esteja usando isso para bisbilhotar.

Quando entra no seu sistema, o código malicioso manda uma instrução para o processador, como qualquer outro faria. Processadores estão treinados para não aceitar a ordem de “passar informações confidenciais para qualquer um”, mas tecnicamente, precisam saber que essa ordem errada existe para tomar uma decisão. E aí entra o problema do processador ler as coisas fora de ordem e de especular sobre o resultado.

A falha se baseia na ideia de que o processador vai arriscar um código antes de saber se ele é malicioso, com a certeza de que se for, pode ignorar todo o resto e continuar só na parte segura. Mas enquanto o estagiário está buscando a informação que aquele código está fazendo coisa errada lááá na estante, o processador começa a anotar o que pode ser a resposta para aquele pedido errado num dos papéis na mesa. Quando o estagiário voltar, é certeza que o processador vai amassar aquele papel todo errado e parar com aquilo. Até hoje isso sempre foi muito confiável.

E de certa forma, ainda é. O processador não entrega os dados secretos que o código pediu, mas… joga fora o papel onde os anotou “no chute” poucos nanosegundos atrás. Se você ficar pentelhando o processador a ler folha por folha dos arquivos da estante e for espionando os papéis que ele preencheu em cima da mesa nesse meio tempo, vai ter lido o conteúdo da estante. Tecnicamente, o código conta quanto tempo o processador demorou para escrever aquele papel para presumir o conteúdo dele, mas aí eu acho que entramos numa tecnicalidade que não combina com a linguagem deste texto.

E a estante está cheia de coisas que não queremos que ninguém de fora consiga ler. É uma falha sim, mas não há motivo para (muito) pânico: como precisa de muito trabalho para pegar essa informação, e como ela depende de alguns processos bem específicos, as empresas de tecnologia já estão lançando proteções e forma de confundir o código malicioso para ele pegar informações erradas. Se seu computador ou celular estiver bem atualizado (especialmente seu navegador, porque dá pra tomar esse golpe por uma página de internet), o pior que acontece é tudo ficar um pouco mais lento. Afinal, a falha de segurança é baseada em processos que aceleram o processamento. Mantenha tudo bem atualizado e use programas de empresas de confiança e não vai acontecer nada de ruim.

Não tem solução limpa ainda, que permita a velocidade máxima e segurança, mas evidente que logo logo começam a sair versões revisadas para evitar esse tipo de curiosidade indevida. Mas por enquanto, basicamente todos os computadores modernos do mundo tem em si um buraco fundamental na segurança. Não há motivos para acreditar que muita gente sabia dessa falha antes de ser mostrada por técnicos do Google em conjunto com pesquisadores de grandes universidades do mundo.

Mas, antes de achar que foi sacaneado por um bando de vagabundos inescrupulosos, pense com mais calma: olha o trabalho que dá para sequer explicar o que a falha faz. E os benefícios desse sistema usamos todos os dias, acelerando tudo o que fazemos num computador. Merdas acontecem. É o preço da tecnologia e da inventividade. Melhor ter esse bug do que ter computadores lentos, não?

Para dizer que foi surpreendentemente didático, para dizer que morreu de tédio e vai voltar daqui a três dias, ou mesmo para apontar alguma falha técnica na explicação (sempre ajuda): somir@desfavor.com