Sicherheitstechnische Frage

Nabend allerseits,

ich habe mal eine Frage in Richtung "Sicherheit":

Folgendes Fallbeispiel:

  • Der ESP baut einen Server + Accesspoint (also WiFi.mode(WIFI_AP) ) auf.
  • Der User verbindet sich mit dem Accesspoint/Server (192.168.4.1) und gelangt zu einem Eingabeformular.
  • Dort gibt er die WLAN-Zugangsdaten (SSID und Passwort) seines Routers ein und drückt auf "Verbinden".
  • Der ESP verbindet sich mit dem Router (wifi.begin(ssid, password)).
  • Der ESP wechselt nun von WIFI_AP auf WIFI_AP_STA (da ich in meinem Fall möchte, dass auch der Accesspoint noch erreichbar ist, soll nicht das Thema in diesem Beitrag sein).

Könnte ein Hacker theoretisch jetzt noch an die WLAN-Zugangsdaten gelangen, wenn diese auf keiner Seite des Servers angezeigt werden (auch nicht im Quelltext versteckt)?

Könnte man Beispielsweise irgendwie den Flash-Speicher des ESP auslesen?

Das einzige, was mir einfallen würde, wäre:
Ich möchte ein Formular auf dem Server integrieren, über das man eine Firmware-Datei auswählen kann, die dann per OTA installiert wird (um den ESP updaten zu können).
Hier wäre ja denkbar, dass ein Hacker eine schadhafte Firmware aufspielt, die wiederum dann die WLAN-Zugangsdaten ausgibt (oder sonst was macht). Aber sowas könnte man ja evtl. durch eine Art Signierung der Firmware abfangen (wobei das ein Extra Thema wäre).

Bitte erklärt mich nicht für verrückt. Ich leide auch nicht unter Verfolgungswahn.
Mich interessiert aber das Thema Sicherheit und ich würde hier gerne was dazulernen.

LG und danke schon mal für eure Tipps.

Ich denke:
Wenn gewöhnte Sicherheitsregel befolgt werden, kann man nur Brute-Force-Hack anwenden, Eingabeverzögerung kann dagegen wirken.
Standard OTA ist absolut "no go". Es muss eine nur dir bekannte Technik realisiert werden, um FW up zu daten. Am besten auch für Kunden unsichtbar. So wie bei Vodafone Routern.

Wenn Sie Ihr ESP der Außenwelt aussetzen, ist es theoretisch gefährdet. Es gibt viele Bots, die ständig alle IP-Adressen auf üblichen und weniger üblichen Ports anpingen, um durch bekannte und weniger bekannte Exploits Einstiegspunkte zu finden.

und Ihr ESP ist nicht fehlersicher ...

Hi,

stimmt, das leuchtet ein.
Wie könnte denn so ein sicheres Firmware-Update aussehen, dass auch der Käufer eines ESP-basierten Produktes selber durchführen kann? Hast du sowas scho n mal gemacht?

Grüßle

was hast du implementiert? Ein HTTP Update oder ein Webbrowser Update?
http://arduino.esp8266.com/Arduino/versions/2.0.0/doc/ota_updates/ota_updates.html

Hi,

bisher habe ich immer HTTP-Update verbaut, d.h. man wählt die bin-Datei über ein Formular aus und startet dann direkt das Update. Den Zugang zum Update-Formular könnte man ja z.B mit einem Passwort schützen. Aber wahrscheinlich kann man das dann auch wieder hacken oder irgendwie umgehen.

LG

dann ist es ein webbrowser Update.

ein HTTP Update wäre, wenn sich der ESP die Dateien von einem HTTP Server über HTTP holt.

Retour zum webbrowser Update. Da kannst imho nicht viel machen: wenn jemand jede ino hochladen kann, hast du keine Kontrolle mehr was da hochgeladen wird.

Ah ok. Dann sollte ich künftige auf HTTP Update umsatteln. Aber da gibts bestimmt auch Fallstricke oder Sicherheitslücken?
Ich les mich später mal in die Links ein, die ihr gepostet habt. Danke schon mal.

Da hake ich mal ein :crazy_face:

Nicht lange, nachdem ich das erste Mal einen ESP32 über WLAN mit meinem Router verbunden hatte, meldete sich "Microsoft" bei mir am Telefon und wollte, daß ich meinen Laptop einschalte. Als ich dann ein paar Monate später neue ESP32 kaufte und mit dem WWW verband, bekam ich einen weiteren Anruf der gleichen Art.

Das war natürlich Zufall, oder?

Ich bin fest davon überzeugt, der amerikanische Geheimdienst steckt in amerikanischer Software wie beispielsweise Microsoft-Produkten, ebenso wie ich vermute, der chinesische steckt in chinesischer Software und Hardware.

Sicherheit gegen Einbruch gibt es nicht, man kann es den Einbrechern nur möglichst schwer machen.

Aber keine Sorge, ich gehe dennoch durch den Wald, auch wenn mir nach dem letzten Sturm ein Ast auf den Kopf fallen könnte :man_factory_worker:


EDIT: Ich habe Microsoft jetzt in Anführungszeichen gesetzt, damit klarer wird, daß ich Hacker an der Strippe hatte.

Wenn ich eine nur mir bekannte Update System gemacht habe, beschreibe ich es nicht im freien Internet.

Hallo,
das hat damit sicher nichts zu tun. MS ruft grundsätzlich nicht ungebeten irgendwo an. Übrigens passiert das bei mir auch in regelmäßigen Abständen. Das sind Kriminelle die dir einen Virus auf den Rechner schieben wollen. In der Regel haben die Mitarbeiter*inen einen indischen Akzent.
Heinz

Da hast natürlich auch wieder recht :wink:
Aber wenn ich weg von Webupdate gehe und auf HTTP-Update umsattel, sollte es doch leichter sein, Sicherheit reinzubringen. Der ESP hat dann ja nur noch die Möglichkeit, ein Update mit einer Firmware-Datei durchzuführen, die auf einem bestimmten Server in einem bestimmten Verzeichnis liegt. Das man so ein Ding nicht zu 100% sicher bekommt, ist mir klar. Es haben sich ja auch schon Hacker Zugang zur Bundesregierung oder irgendwelchen großen Firmen verschafft.

Yep, das hab ich auch schon desöfteren gehört (von Leuten, die garantiert keinen ESP haben)

Nabend,

ich will das Thema nur nochmal kurz aufgreifen, im Speziellen die Firmware-Update-Sache.
Da will ich definitiv von webupdate (per Formular) wechseln auf http_update oder besser noch https_update.

Mutig und tollkühn wie ich bin, hab ich mich gleich mal an der Sache versucht.
Ich habe den Beispiel-Sketch "httpUpdate" aus der Arduino IDE probiert und es hat auf Anhieb funkioniert --> Juhu. Ein erster Erfolg!

Aaaaber: Dann hab ich voller Euphorie auch noch den "httpsUpdate" - Beispiel eine Chance gegeben und da kam dann als Rückmeldung folgende Serielle Ausgabe:

[SETUP] WAIT 4...
[SETUP] WAIT 3...
[SETUP] WAIT 2...
[SETUP] WAIT 1...
Waiting for NTP time sync: .
Current time: Wed Mar 16 17:32:46 2022
HTTP_UPDATE_FAILED Error (-1): HTTP error: connection refused

Und dann natürlich immer wieder in Schleife

Waiting for NTP time sync: .
Current time: Wed Mar 16 17:32:46 2022
HTTP_UPDATE_FAILED Error (-1): HTTP error: connection refused

Hier ist der Sketch:


#include <WiFi.h>
#include <WiFiMulti.h>
#include <HTTPClient.h>
#include <HTTPUpdate.h>
#include <time.h>

const char* TZ_INFO    = "CET-1CEST-2,M3.5.0/02:00:00,M10.5.0/03:00:00";
WiFiMulti WiFiMulti;

void setClock() {
  configTime(0, 0, "de.pool.ntp.org");
  setenv("TZ", TZ_INFO, 1);

  Serial.print(F("Waiting for NTP time sync: "));
  time_t now = time(nullptr);
  while (now < 8 * 3600 * 2) {
    yield();
    delay(500);
    Serial.print(F("."));
    now = time(nullptr);
  }

  Serial.println(F(""));
  struct tm timeinfo;
  localtime_r(&now, &timeinfo);
  Serial.print(F("Current time: "));
  Serial.print(asctime(&timeinfo));
}

/**
 * This is lets-encrypt-x3-cross-signed.pem
 */
const char* rootCACertificate = \
"-----BEGIN CERTIFICATE-----\n" \
"MIIEkjCCA3qgAwIBAgIQCgFBQgAAAVOFc2oLheynCDANBgkqhkiG9w0BAQsFADA/\n" \
"MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT\n" \
"DkRTVCBSb290IENBIFgzMB4XDTE2MDMxNzE2NDA0NloXDTIxMDMxNzE2NDA0Nlow\n" \
"SjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUxldCdzIEVuY3J5cHQxIzAhBgNVBAMT\n" \
"GkxldCdzIEVuY3J5cHQgQXV0aG9yaXR5IFgzMIIBIjANBgkqhkiG9w0BAQEFAAOC\n" \
"AQ8AMIIBCgKCAQEAnNMM8FrlLke3cl03g7NoYzDq1zUmGSXhvb418XCSL7e4S0EF\n" \
"q6meNQhY7LEqxGiHC6PjdeTm86dicbp5gWAf15Gan/PQeGdxyGkOlZHP/uaZ6WA8\n" \
"SMx+yk13EiSdRxta67nsHjcAHJyse6cF6s5K671B5TaYucv9bTyWaN8jKkKQDIZ0\n" \
"Z8h/pZq4UmEUEz9l6YKHy9v6Dlb2honzhT+Xhq+w3Brvaw2VFn3EK6BlspkENnWA\n" \
"a6xK8xuQSXgvopZPKiAlKQTGdMDQMc2PMTiVFrqoM7hD8bEfwzB/onkxEz0tNvjj\n" \
"/PIzark5McWvxI0NHWQWM6r6hCm21AvA2H3DkwIDAQABo4IBfTCCAXkwEgYDVR0T\n" \
"AQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAYYwfwYIKwYBBQUHAQEEczBxMDIG\n" \
"CCsGAQUFBzABhiZodHRwOi8vaXNyZy50cnVzdGlkLm9jc3AuaWRlbnRydXN0LmNv\n" \
"bTA7BggrBgEFBQcwAoYvaHR0cDovL2FwcHMuaWRlbnRydXN0LmNvbS9yb290cy9k\n" \
"c3Ryb290Y2F4My5wN2MwHwYDVR0jBBgwFoAUxKexpHsscfrb4UuQdf/EFWCFiRAw\n" \
"VAYDVR0gBE0wSzAIBgZngQwBAgEwPwYLKwYBBAGC3xMBAQEwMDAuBggrBgEFBQcC\n" \
"ARYiaHR0cDovL2Nwcy5yb290LXgxLmxldHNlbmNyeXB0Lm9yZzA8BgNVHR8ENTAz\n" \
"MDGgL6AthitodHRwOi8vY3JsLmlkZW50cnVzdC5jb20vRFNUUk9PVENBWDNDUkwu\n" \
"Y3JsMB0GA1UdDgQWBBSoSmpjBH3duubRObemRWXv86jsoTANBgkqhkiG9w0BAQsF\n" \
"AAOCAQEA3TPXEfNjWDjdGBX7CVW+dla5cEilaUcne8IkCJLxWh9KEik3JHRRHGJo\n" \
"uM2VcGfl96S8TihRzZvoroed6ti6WqEBmtzw3Wodatg+VyOeph4EYpr/1wXKtx8/\n" \
"wApIvJSwtmVi4MFU5aMqrSDE6ea73Mj2tcMyo5jMd6jmeWUHK8so/joWUoHOUgwu\n" \
"X4Po1QYz+3dszkDqMp4fklxBwXRsW10KXzPMTZ+sOPAveyxindmjkW8lGy+QsRlG\n" \
"PfZ+G6Z6h7mjem0Y+iWlkYcV4PIWL1iwBi8saCbGS5jN2p8M+X+Q7UNKEkROb3N6\n" \
"KOqkqm57TH2H3eDJAkSnh6/DNFu0Qg==\n" \
"-----END CERTIFICATE-----\n";

void setup() {

  Serial.begin(115200);
  // Serial.setDebugOutput(true);

  Serial.println();
  Serial.println();
  Serial.println();

  for (uint8_t t = 4; t > 0; t--) {
    Serial.printf("[SETUP] WAIT %d...\n", t);
    Serial.flush();
    delay(1000);
  }

  WiFi.mode(WIFI_STA);
  WiFiMulti.addAP("MeineSSID", "MeinPasswort");
}

void loop() {
  if ((WiFiMulti.run() == WL_CONNECTED)) {

    setClock();
    WiFiClientSecure client;
    client.setCACert(rootCACertificate);

    client.setTimeout(12000 / 1000); // timeout argument is defined in seconds for setTimeout

    t_httpUpdate_return ret = httpUpdate.update(client, "URL zu meiner  *.bin-Datei"); // Wenn ich die URL direkt aufrufe, wird die Datei gefunden (der Download-Dialog öffnet sich), d.h. die URL stimmt.
   
    switch (ret) {
      case HTTP_UPDATE_FAILED:
        Serial.printf("HTTP_UPDATE_FAILED Error (%d): %s\n", httpUpdate.getLastError(), httpUpdate.getLastErrorString().c_str());
        break;

      case HTTP_UPDATE_NO_UPDATES:
        Serial.println("HTTP_UPDATE_NO_UPDATES");
        break;

      case HTTP_UPDATE_OK:
        Serial.println("HTTP_UPDATE_OK");
        break;
    }
  }
}

Kann es sein, dass auch Serverseitig noch ein (bzw. das gleiche) Zertifikat eingepflanzt werden muss? Bzw. anders rum, also das Zertifikat des Servers hier in den Sketch rein muss?
Aber wie komm ich da als Reintext dran? Da gabs doch auch noch die Möglichkeit in vereinfachter Form, oder (Fingerprint?)

Bin wieder mal für eure Anteilnahme dankbar :hugs: :laughing:

Natürlich muss der Server über ein offizielles Zertifikat von lets-encrypt verfügen und HTTPS können, wenn Du deren Root-Zertifikat benutzt.

Für den ESP8266 habe ich für den Client hier ein Tutorial für HTTPS geschrieben.

Gruß Tommy

1 Like

Sehr cool!

Top @Tommy56 :blush: Klasse zusammengefasst!

Lg und schönen Tag

Heute hatte ich schon mein erstes "sicherheitstechnisches" Problem.
Bei einem ESP waren auf einmal seltsame Werte im Flash-Speicher.
Ich konnte mir nicht erklären, wie die da reinkommen.
Aber da ich einen Raspberry quasi als Serial-Monitor-Überwacher dran hängen hatte und eine Log-Datei aufzeichne konnte ich mal reinspitzeln, was da die letzen paar Stunden abgegangen ist.

Und da hab ich dann gesehen, dass ein HTML Formular immer wieder neu abgeschickt wurde mit irgendwelchen Werten. Und in einem Wert stand dann das da drin:

<?xml version="1.0" encoding="ISO-8859-1"?><!DOCTYPE xxe_test [ <!ENTITY xxe_test SYSTEM "http://w3af.org/xxe.txt">

Dann hab ich mal gegoogelt und herausgefunden, dass das quasi ne Formular injection war.

In dem Fall war die sicherheitstechnische Lücke, dass ich die IP-Adresse meines ESP über eine einfache Portfreigabe meiner Fritzbox "geöffnet" habe. Das war mir jetzt eine Lehre :wink:

Muss gleich mal googeln, wie man einen Port Passwortgeschützt (oder auf irgendeine andere Art und Weise halbwegs sicher) freigeben kann.

Grüßle und schönes Wochenende an alle hier!

Ich wurde hier insgeheim für paranoid gehalten, weil ich ein Konzept für nicht tragfähig hielt.

Bitte sag mir, das es sich dabei nicht um das selbe Projekt handelt.

Es handelt sich nicht direkt um das selbe Projekt.
Im aktuellen Fall hatte ich einfach einen ESP mit einem kleinen Testserver laufen und diesen eben per Portfreigabe so richtig schön Scheunentor-mäßig ins Internet gestellt :wink:

In dem anderen (von dir verlinkten) Beitrag ging es allgemein um das Thema "wie sicher ist der ESP vor Hackerangriffen", also eher im Bezug auf den eigenen Accespoint des ESP oder wenn dieser in einem internen Netzwerk hängt.

Die Portfreigabe ist natürlich ein ganz anderes Thema. Wer sowas macht, öffnet natürlich Tür und Tor. Daher hab ich die Portfreigabe auch gleich mal wieder deaktiviert.