Como saber se meu site Drupal é composto pela exploração de março do SA-CORE-2018-002 - 2018?

Exploração recém- lançada: https://www.drupal.org/sa-core-2018-002 --- Núcleo Drupal - Altamente crítico - Execução remota de código - SA-CORE-2018-002

• Como posso saber se alguém usou essa exploração para invadir meu site?
• O que eles podem fazer com essa exploração se executados corretamente?
• Não posso atualizar meus sites Drupal agora, qual é uma boa alternativa para consertar esse buraco facilmente?

O que poderia acontecer

Eu tive um site pessoal do Drupal hackeado durante o Drupalgeddon, uma exploração de gravidade semelhante (embora de um tipo diferente). Em termos de "o que poderia acontecer", nesse caso, o hacker colocou vários arquivos "back door" em minha base de código (eu sabia muito pouco sobre desenvolvimento na época e não tinha repositório Git), a partir do qual ele podia enviar e-mails de spam . O domínio envolvido estava na lista negra de filtros de spam, e era uma bagunça enorme poder enviar e-mails desse domínio pelos vários meses em que eu o mantive depois.

Como essa vulnerabilidade permite a execução remota de código, presumivelmente o invasor pode instalar módulos para realizar ataques de phishing, executar comandos na linha de comando com php exec (), roubar senhas e comprometer grande parte do seu servidor. O dano pode variar de algo tão simples quanto a sua máquina ser recrutada como um mecanismo de spam ou nó de botnet ou, se você tiver informações confidenciais, o invasor poderá roubá-lo e revendê-lo ou chantagear você, dependendo das informações e dos motivos do invasor.

Como saber se você foi hackeado

Na maioria das vezes, seu site não será desfigurado. Quando dois grupos de crianças de script de 14 anos se enfrentam, você pode ver um site desfigurado com imagens Goatse (NSFW), mas, a menos que o hacker tenha algo contra você pessoalmente, ele não fará isso. O objetivo do hacker é dinheiro ou a capacidade de cometer crimes com o computador de outra pessoa.

Agora, com isso em mente, coisas comuns que você verá são novos usuários sendo criados (especialmente usuários administrativos) e, nos logs, você pode ver um IP específico enviando apenas um tipo de solicitação (anormal). No caso Drupalgeddon, consegui descobrir isso vendo solicitações POST para um arquivo php no meu log de acesso.

Se você não pode corrigir seu site imediatamente

Se você não pode corrigir o site agora, eu recomendaria cortar o servidor apache / nginx para que ninguém possa acessá-lo. Ou peça ao servidor que direcione todo o tráfego para uma página HTML, explicando que você está em manutenção, também conhecido como "modo de manutenção pesada". Em todos os casos, você não deseja permitir que um visitante tenha uma chance de inicializar o Drupal, até conseguir uma atualização ou patch.

E lembrando que meu site foi invadido, lembre-se de que os primeiros ataques ao Drupalgeddon começaram 7 horas após o lançamento, e foi na forma de um script que invadiu automaticamente milhares de sites. Mova-se rapidamente!

Se você for hackeado

Espero que você tenha um backup; nesse caso, a melhor opção é "remover todo o site da órbita" e começar de novo com um novo servidor. Fiz uma auditoria manual de banco de dados e arquivos uma vez porque não tinha o Git e backups regulares no lugar - leva muito tempo, mas se isso acontecer, respire fundo e aprenda o Git e saiba como configurar um ambiente de backup adequado. Se você tem um negócio e é um site de clientes, conte a verdade com antecedência. Você provavelmente os perderá, mas é melhor perder um cliente (você pode obter novos) do que sua reputação.

Como posso saber se alguém usou essa exploração para invadir meu site?

Seu site Drupal 7 ou 8 pode sofrer perda ou roubo de dados, dados podem ser removidos, excluídos ou alterados, causando estragos no site de várias maneiras diferentes.

Consulte esta postagem do Stack Exchange para obter informações gerais sobre como verificar se seu site foi invadido.

O que eles podem fazer com essa exploração se executados corretamente?

A exploração é uma vulnerabilidade de execução remota de código, o que significa que qualquer dado pode ser afetado.

Essa exploração recebeu uma pontuação de risco de 21/25, quase a mais alta possível. Esse escore de risco também define as seguintes vulnerabilidades, entre outras:

• AC (complexidade do acesso): fácil (sem habilidade) para acessar e explorar
• A (autenticação): não é necessária autenticação especial
• Cl (impacto na confidencialidade): todos os dados não públicos são acessíveis
• II (impacto na integridade): todos os dados podem ser modificados ou excluídos

Leia mais sobre pontuação e definições de risco aqui .

Não posso atualizar meus sites Drupal agora, qual é uma boa alternativa para consertar esse buraco facilmente?

Existe um patch disponível se você não conseguir atualizar o núcleo imediatamente. Do Drupal.org:

Se você estiver executando o 7.x, atualize para o Drupal 7.58 . (Se você não conseguir atualizar imediatamente, poderá tentar aplicar esse patch para corrigir a vulnerabilidade até o momento em que conseguir atualizar completamente.)

Se você estiver executando o 8.5.x, atualize para o Drupal 8.5.1 . (Se você não conseguir atualizar imediatamente, poderá tentar aplicar esse patch para corrigir a vulnerabilidade até o momento em que conseguir atualizar completamente.)

Para ler mais, aqui está uma FAQ sobre a exploração

Como corrigir o Drupal 7.x manualmente contra o núcleo do Drupal - Altamente crítico - Execução remota de código - SA-CORE-2018-00

Se você estiver no Drupal 7.x e não puder atualizar o site ativo para a 7.58, não estiver familiarizado com a aplicação de patches ou em uma versão do Drupal cuja falha do patch, faça o seguinte:

1> Faça o download e extraia o Drupal 7.58.

2> Copie o arquivo /includes/request-sanitizer.inc da distribuição 7.58 para o diretório / includes do seu site (mais fácil via FTP ou pelo gerenciador de arquivos do painel de controle de hospedagem).

3> Edite a versão do /includes/bootstrap.inc no seu site ao vivo (faça backup primeiro!). Encontre a função _drupal_bootstrap_configuration (). Adicione as 3 linhas a seguir após a instrução drupal_settings_initialize (); :

// Sanitize unsafe keys from the request.
require_once DRUPAL_ROOT . '/includes/request-sanitizer.inc';
DrupalRequestSanitizer::sanitize();

Salve .

relaxar.

Aqui está um simples processo 1-2-3 aqui:

1. Copie o código para a área de transferência aqui https://cgit.drupalcode.org/drupal/rawdiff/?h=7.x&id=2266d2a83db50e2f97682d9a0fb8a18e2722cba5 ou conforme citado abaixo.
2. crie um arquivo em branco chamado 2018march.patch na pasta raiz do diretório drupal.
3. Cole o código no arquivo
4. Execute o comando no terminal: patch -p1 <2018march.patch

Se você não tiver acesso SSH ou terminal. Você precisará fazer isso manualmente manualmente, usando a solução @elb do usuário.

diff --git a/includes/bootstrap.inc b/includes/bootstrap.inc
index 655db6d..880557e 100644
--- a/includes/bootstrap.inc
+++ b/includes/bootstrap.inc
@@ -2632,6 +2632,10 @@ function _drupal_bootstrap_configuration() {
   timer_start('page');
   // Initialize the configuration, including variables from settings.php.
   drupal_settings_initialize();
+
+  // Sanitize unsafe keys from the request.
+  require_once DRUPAL_ROOT . '/includes/request-sanitizer.inc';
+  DrupalRequestSanitizer::sanitize();
 }

 /**
diff --git a/includes/request-sanitizer.inc b/includes/request-sanitizer.inc
new file mode 100644
index 0000000..1daa6b5
--- /dev/null
+++ b/includes/request-sanitizer.inc
@@ -0,0 +1,82 @@
+<?php
+
+/**
+ * @file
+ * Contains code for sanitizing user input from the request.
+ */
+
+/**
+ * Sanitizes user input from the request.
+ */
+class DrupalRequestSanitizer {
+
+  /**
+   * Tracks whether the request was already sanitized.
+   */
+  protected static $sanitized = FALSE;
+
+  /**
+   * Modifies the request to strip dangerous keys from user input.
+   */
+  public static function sanitize() {
+    if (!self::$sanitized) {
+      $whitelist = variable_get('sanitize_input_whitelist', array());
+      $log_sanitized_keys = variable_get('sanitize_input_logging', FALSE);
+
+      // Process query string parameters.
+      $get_sanitized_keys = array();
+      $_GET = self::stripDangerousValues($_GET, $whitelist, $get_sanitized_keys);
+      if ($log_sanitized_keys && $get_sanitized_keys) {
+        _drupal_trigger_error_with_delayed_logging(format_string('Potentially unsafe keys removed from query string parameters (GET): @keys', array('@keys' => implode(', ', $get_sanitized_keys))), E_USER_NOTICE);
+      }
+
+      // Process request body parameters.
+      $post_sanitized_keys = array();
+      $_POST = self::stripDangerousValues($_POST, $whitelist, $post_sanitized_keys);
+      if ($log_sanitized_keys && $post_sanitized_keys) {
+        _drupal_trigger_error_with_delayed_logging(format_string('Potentially unsafe keys removed from request body parameters (POST): @keys', array('@keys' => implode(', ', $post_sanitized_keys))), E_USER_NOTICE);
+      }
+
+      // Process cookie parameters.
+      $cookie_sanitized_keys = array();
+      $_COOKIE = self::stripDangerousValues($_COOKIE, $whitelist, $cookie_sanitized_keys);
+      if ($log_sanitized_keys && $cookie_sanitized_keys) {
+        _drupal_trigger_error_with_delayed_logging(format_string('Potentially unsafe keys removed from cookie parameters (COOKIE): @keys', array('@keys' => implode(', ', $cookie_sanitized_keys))), E_USER_NOTICE);
+      }
+
+      $request_sanitized_keys = array();
+      $_REQUEST = self::stripDangerousValues($_REQUEST, $whitelist, $request_sanitized_keys);
+
+      self::$sanitized = TRUE;
+    }
+  }
+
+  /**
+   * Strips dangerous keys from the provided input.
+   *
+   * @param mixed $input
+   *   The input to sanitize.
+   * @param string[] $whitelist
+   *   An array of keys to whitelist as safe.
+   * @param string[] $sanitized_keys
+   *   An array of keys that have been removed.
+   *
+   * @return mixed
+   *   The sanitized input.
+   */
+  protected static function stripDangerousValues($input, array $whitelist, array &$sanitized_keys) {
+    if (is_array($input)) {
+      foreach ($input as $key => $value) {
+        if ($key !== '' && $key[0] === '#' && !in_array($key, $whitelist, TRUE)) {
+          unset($input[$key]);
+          $sanitized_keys[] = $key;
+        }
+        else {
+          $input[$key] = self::stripDangerousValues($input[$key], $whitelist, $sanitized_keys);
+        }
+      }
+    }
+    return $input;
+  }
+
+}