Jak stwierdzić, czy moja strona Drupal składa się z exploita SA-CORE-2018-002 - 2018 March?

Właśnie wydany exploit: https://www.drupal.org/sa-core-2018-002 --- Rdzeń Drupala - Wysoce krytyczny - Zdalne wykonanie kodu - SA-CORE-2018-002

• Skąd mam wiedzieć, czy ktoś wykorzystał ten exploit do włamania się na moją stronę?
• Co mogą zrobić z tym exploitem, jeśli zostaną poprawnie wykonane?
• Nie mogę teraz zaktualizować moich stron Drupal. Jaka jest dobra alternatywa dla łatwego załatania tej dziury?

Co może się zdarzyć

Miałem osobistą witrynę Drupala zhakowaną podczas Drupalgeddon, exploita o podobnym stopniu ważności (choć innego rodzaju). Jeśli chodzi o „to, co może się zdarzyć”, w takim przypadku haker umieścił kilka plików „tylnych drzwi” w mojej bazie kodu (wtedy bardzo mało wiedziałem o programowaniu i nie miałem repozytorium Git), z których mógł wysyłać spam . Domena, której to dotyczy, została umieszczona na czarnych listach w filtrach spamu, a przesyłanie wiadomości e-mail z tej domeny było ogromne, ponieważ przez kilka miesięcy zachowywałem ją później.

Ponieważ ta luka umożliwia zdalne wykonanie kodu, osoba atakująca może przypuszczalnie zainstalować moduły w celu przeprowadzania ataków phishingowych, wykonywania poleceń w wierszu poleceń za pomocą php exec (), kradzieży haseł, a tym samym narażania dużej części serwera. Szkody mogą obejmować coś tak prostego, jak rekrutacja maszyny jako silnika spamowego lub węzła botnetu, lub jeśli masz poufne informacje, atakujący może je ukraść i odsprzedać lub szantażować, w zależności od informacji i motywów atakującego.

Jak stwierdzić, czy zostałeś zhakowany

W większości przypadków Twoja witryna nie zostanie zniszczona. Kiedy dwie grupy 14-letnich dzieciaków ze skryptów zbliżają się do siebie, możesz zobaczyć stronę ze zdjęciami kozimi (NSFW), ale chyba, że ​​haker ma coś przeciwko tobie osobiście, nie zrobi tego. Celem hakera są pieniądze lub umiejętność popełniania przestępstw przy użyciu komputera innej osoby.

Mając to na uwadze, typowymi rzeczami, które zobaczysz, są tworzeni nowi użytkownicy (szczególnie użytkownicy administracyjni), aw dziennikach możesz zobaczyć konkretny adres IP wysyłający tylko jeden rodzaj (nienormalnego) żądania. W przypadku Drupalgeddon mogłem to rozgryźć, widząc żądania POST dla pliku php w moim dzienniku dostępu.

Jeśli nie możesz od razu załatać swojej witryny

Jeśli nie możesz teraz załatać tej witryny, zaleciłbym odcięcie serwera apache / nginx, aby nikt nie mógł dostać się do twojej witryny. Lub pozwól serwerowi przekierować cały ruch na stronę HTML z informacją, że nie masz możliwości konserwacji, czyli „trybu trudnej konserwacji”. We wszystkich przypadkach nie chcesz, aby odwiedzający mógł strzelać do ładowania Drupala, dopóki nie uzyskasz aktualizacji lub poprawki.

Wracając do hakowania mojej witryny, pamiętajcie, że pierwsze ataki Drupalgeddon rozpoczęły się 7 godzin po wydaniu i miały postać skryptu, który automatycznie zhakował tysiące stron. Poruszać się szybko!

Jeśli zostałeś zhakowany

Mamy nadzieję, że masz kopię zapasową, w którym to przypadku najlepszym rozwiązaniem jest „nuke całej witryny z orbity” i zacząć od nowa z nowym serwerem. Raz wykonałem ręczną kontrolę bazy danych i plików, ponieważ nie miałem Git i regularnych kopii zapasowych - zajmuje to bardzo dużo czasu, ale jeśli tak się stanie, weź głęboki oddech i naucz się Gita i naucz się konfigurować odpowiednie środowisko tworzenia kopii zapasowych. Jeśli masz firmę i witrynę dla klientów, powiedz im z góry prawdę. Prawdopodobnie je stracisz, ale lepiej stracić klienta (możesz zdobyć nowych) niż swoją reputację.

Skąd mam wiedzieć, czy ktoś wykorzystał ten exploit do włamania się na moją stronę?

Twoja witryna Drupal 7 lub 8 może ulec utracie lub kradzieży, dane można usunąć, usunąć lub zmienić, siejąc spustoszenie na stronie na wiele różnych sposobów.

Zobacz ten artykuł dotyczący wymiany stosów, aby uzyskać ogólne informacje na temat sprawdzania, czy witryna została zaatakowana przez hakerów.

Co mogą zrobić z tym exploitem, jeśli zostaną poprawnie wykonane?

Exploit stanowi lukę w zabezpieczeniach umożliwiającą zdalne wykonanie kodu, co oznacza, że ​​może to mieć wpływ na dowolne dane.

Exploitowi nadano ocenę ryzyka 21/25, czyli prawie najwyższą z możliwych. Ten wynik ryzyka określa także następujące luki w zabezpieczeniach:

• AC (złożoność dostępu): łatwy (bez umiejętności) dostęp i wykorzystanie
• A (Uwierzytelnianie): nie jest wymagane specjalne uwierzytelnianie
• Cl (wpływ na poufność): wszystkie niepubliczne dane są dostępne
• II (Wpływ na integralność): Wszystkie dane można modyfikować lub usuwać

Przeczytaj więcej o punktacji ryzyka i definicjach tutaj .

Nie mogę teraz zaktualizować moich stron Drupal. Jaka jest dobra alternatywa dla łatwego załatania tej dziury?

Dostępna jest łatka, jeśli nie możesz od razu zaktualizować rdzenia. Od Drupal.org:

Jeśli korzystasz z wersji 7.x, uaktualnij do Drupal 7.58 . (Jeśli nie możesz dokonać natychmiastowej aktualizacji, możesz spróbować zastosować tę poprawkę, aby naprawić lukę, aż do momentu pełnej aktualizacji).

Jeśli korzystasz z wersji 8.5.x, uaktualnij do wersji Drupal 8.5.1 . (Jeśli nie możesz dokonać natychmiastowej aktualizacji, możesz spróbować zastosować tę poprawkę, aby naprawić lukę, aż do momentu pełnej aktualizacji).

Aby przeczytać więcej, oto FAQ na temat exploita

Jak ręcznie załatać Drupal 7.x na rdzeń Drupala - Wysoce krytyczny - Zdalne wykonanie kodu - SA-CORE-2018-00

Jeśli korzystasz z Drupal 7.x i nie możesz zaktualizować swojej działającej witryny do wersji 7.58, nie znasz się na stosowaniu poprawek lub korzystasz z wersji Drupal, dla której łatka nie działa, wykonaj następujące czynności:

1> Pobierz i rozpakuj Drupal 7.58.

2> Skopiuj plik /include/request-sanitizer.inc z dystrybucji 7.58 do katalogu / include witryny (najłatwiej za pośrednictwem FTP lub menedżera plików panelu sterowania hosta).

3> Edytuj wersję pliku /include/bootstrap.inc na swojej stronie internetowej (najpierw wykonaj kopię zapasową!). Znajdź funkcję _drupal_bootstrap_configuration (). Dodaj następujące 3 wiersze po instrukcji drupal_settings_initialize (); :

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

Zapisać.

Zrelaksować się.

Oto prosty proces 1-2-3:

1. Skopiuj kod do schowka tutaj https://cgit.drupalcode.org/drupal/rawdiff/?h=7.x&id=2266d2a83db50e2f97682d9a0fb8a18e2722cba5 lub jak podano poniżej.
2. utwórz pusty plik o nazwie 2018march.patch w folderze głównym swojego katalogu drupal.
3. Wklej kod do pliku
4. Uruchom komendę w terminalu: patch -p1 <2018march.patch

Jeśli nie masz dostępu do SSH lub terminala. Musisz to zrobić ręcznie ręcznie, korzystając z rozwiązania @elb użytkownika.

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