Come sapere se il mio sito Drupal è compreso nell'exploit SA-CORE-2018-002 - 2018 di marzo?

Exploit appena rilasciato: https://www.drupal.org/sa-core-2018-002 --- Drupal core - Altamente critico - Esecuzione di codice in modalità remota - SA-CORE-2018-002

• Come posso sapere se qualcuno ha usato questo exploit per hackerare il mio sito?
• Cosa possono fare con questo exploit se eseguiti correttamente?
• Non riesco ad aggiornare i miei siti Drupal ora, qual è una buona alternativa per correggere facilmente questo buco?

Cosa potrebbe succedere

Ho avuto un sito Drupal personale hackerato durante Drupalgeddon, un exploit di gravità simile (anche se di tipo diverso). In termini di "cosa potrebbe accadere", in quel caso l'hacker ha inserito diversi file "backdoor" nel mio codebase (all'epoca sapevo molto poco dello sviluppo e non avevo un repository Git), dal quale poteva inviare e-mail di spam . Il dominio in questione è stato inserito nella lista nera dei filtri antispam ed è stato un gran casino poter inviare e-mail da quel dominio per i diversi mesi che l'avevo tenuto in seguito.

Poiché questa vulnerabilità consente l'esecuzione di codice in modalità remota, l'utente malintenzionato potrebbe presumibilmente installare moduli per eseguire attacchi di phishing, eseguire comandi sulla riga di comando con php exec (), rubare password e quindi compromettere gran parte del server. Il danno può variare da qualcosa di semplice come il tuo computer che viene reclutato come motore di spam o nodo botnet, o se hai informazioni sensibili, l'attaccante potrebbe rubarlo e rivenderlo o ricattarti, a seconda delle informazioni e delle motivazioni dell'attaccante.

Come sapere se sei stato violato

Il più delle volte, il tuo sito non verrà deturpato. Quando due gruppi di sceneggiatori di quattordici anni si incontrano, potresti vedere un sito deturpato dalle immagini di Goatse (NSFW), ma a meno che l'hacker non abbia qualcosa contro di te personalmente non lo farà. L'obiettivo dell'hacker è il denaro o la capacità di commettere crimini con il computer di qualcun altro.

Ora tenendo a mente ciò, vedrai che vengono creati nuovi utenti (in particolare gli utenti admin) e nei registri potresti vedere un IP particolare che invia un solo tipo di richiesta (anormale). Nel caso Drupalgeddon, sono stato in grado di capirlo vedendo le richieste POST a un file php nel mio registro di accesso.

Se non riesci a correggere subito il tuo sito

Se non riesci a correggere il sito ora, ti consiglio di tagliare il server apache / nginx in modo che nessuno possa accedere al tuo sito. Oppure, fai in modo che il server indirizzi tutto il traffico verso una pagina HTML spiegando che sei inattivo per manutenzione, ovvero "modalità di manutenzione intensa". In tutti i casi, non si desidera consentire a un visitatore di avere alcun colpo al bootstrap Drupal, fino a quando non è possibile ottenere un aggiornamento o una patch.

E ripensando al mio sito che viene violato, ricorda che i primi attacchi di Drupalgeddon sono iniziati 7 ore dopo il rilascio, ed è stato sotto forma di uno script che ha hackerato automaticamente migliaia di siti. Muoviti rapidamente!

Se vieni violato

Spero che tu abbia un backup, nel qual caso la scommessa migliore è "nuotare l'intero sito dall'orbita" e ricominciare da capo con un nuovo server. Ho eseguito un DB manuale e il controllo dei file una volta perché non disponevo di Git e backup regolari - impiega molto tempo, ma se succede, fai un respiro profondo, impara Git e impara come impostare un ambiente di backup adeguato. Se hai un'attività e un sito per i clienti, dì loro la verità in anticipo. Probabilmente li perderai, ma è meglio perdere un cliente (puoi ottenerne di nuovi) rispetto alla tua reputazione.

Come posso sapere se qualcuno ha usato questo exploit per hackerare il mio sito?

Il tuo sito Drupal 7 o 8 può subire la perdita o il furto di dati, i dati possono essere rimossi, cancellati o modificati, causando il caos sul sito in molti modi diversi.

Vedi questo post di Stack Exchange per informazioni generali su come verificare se il tuo sito Web è stato violato.

Cosa possono fare con questo exploit se eseguiti correttamente?

L'exploit è una vulnerabilità legata all'esecuzione di codice in modalità remota, il che significa che qualsiasi dato ha il potenziale per essere interessato.

A questo exploit è stato assegnato un punteggio di rischio di 21/25, che è quasi il più alto che ottiene. Questo punteggio di rischio definisce anche le seguenti vulnerabilità:

• AC (Access complessità): facile (nessuna competenza) per accedere e sfruttare
• A (Autenticazione): nessuna autenticazione speciale necessaria
• Cl (Impatto sulla riservatezza): tutti i dati non pubblici sono accessibili
• II (impatto sull'integrità): tutti i dati possono essere modificati o cancellati

Maggiori informazioni sul punteggio di rischio e le definizioni qui .

Non riesco ad aggiornare i miei siti Drupal ora, qual è una buona alternativa per correggere facilmente questo buco?

È disponibile una patch se non è possibile aggiornare subito il core. Da Drupal.org:

Se stai eseguendo 7.x, esegui l'upgrade a Drupal 7.58 . (Se non si è in grado di aggiornare immediatamente, è possibile provare ad applicare questa patch per correggere la vulnerabilità fino a quando non si è in grado di aggiornare completamente.)

Se stai eseguendo 8.5.x, esegui l'upgrade a Drupal 8.5.1 . (Se non si è in grado di aggiornare immediatamente, è possibile provare ad applicare questa patch per correggere la vulnerabilità fino a quando non si è in grado di aggiornare completamente.)

Per saperne di più, ecco una FAQ sull'exploit

Come patchare Drupal 7.x a mano contro il core di Drupal - Altamente critico - Esecuzione di codice in modalità remota - SA-CORE-2018-00

Se sei su Drupal 7.x e non riesci ad aggiornare il tuo sito live alla 7.58, non hai familiarità con l'applicazione di patch o sei su una versione di Drupal per cui la patch non riesce, procedi come segue:

1> Scarica ed estrai Drupal 7.58.

2> Copia il file /includes/request-sanitizer.inc dalla distribuzione 7.58 nella directory / Includes del tuo sito web (più semplice tramite FTP o il file manager del pannello di controllo dell'hosting).

3> Modifica la versione di /includes/bootstrap.inc sul tuo sito web live (esegui prima il backup!). Trova la funzione _drupal_bootstrap_configuration (). Aggiungi le 3 righe seguenti dopo l'istruzione drupal_settings_initialize (); :

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

Salva.

Rilassare.

Ecco un semplice processo 1-2-3 tutto qui:

1. Copia il codice negli appunti da qui https://cgit.drupalcode.org/drupal/rawdiff/?h=7.x&id=2266d2a83db50e2f97682d9a0fb8a18e2722cba5 o come indicato di seguito.
2. creare un file vuoto chiamato file 2018march.patch nella cartella principale della directory di drupal.
3. Incolla il codice nel file
4. Esegui il comando nel terminale: patch -p1 <2018march.patch

Se non si dispone dell'accesso SSH o del terminale. Dovrai farlo manualmente usando la soluzione @elb dell'utente.

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;
+  }
+
+}