Forum: Mikrocontroller und Digitale Elektronik AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen


AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
von Sam M. (sam_m229)

Lesenswert?
• ▲
▼ 
Hallo zusammen,

ich versuche, mit meinem ESP32 einen HTTP GET request auf einen 
WebServer, der auf einer speziellen Maschine läuft, auszuführen, 
allerdings mittels einer sicheren Verbindung (HTTPS).

Wenn ich in dem Code zum BasicHTTPSClient.ino-Beispiel aus der Arduino 
IDE nur den WLAN-Namen und das WLAN-Passwort in WiFi.begin() ändere und 
anschließend hochlade (ich hänge den Code nachher noch an, also siehe 
unten), sieht mein Output auf dem Serial Monitor ungefähr so aus:

1
Waiting for WiFi to connect................ connected

2
Waiting for NTP time sync: ..

3
Current time: Fri Nov 20 12:57:33 2020

4
[HTTPS] begin...

5
[HTTPS] GET...

6
[HTTPS] GET... code: 200

7
<HTML>

8
<HEAD>

9
<!-- Created with AOLpress/2.0 -->

10
<TITLE>Connection Header</TITLE>

11
</HEAD>

usw.

Ändere ich nun auch noch das Zertifikat und die Ziel-URL in 
https.begin() (also von https://jigsaw.w3.org/HTTP/connection.html zu 
https://192.168.200.146/api/unlock/generate_pin, wobei 192.168.200.146 
die IP der speziellen Maschine ist, auf der der WebServer läuft), so 
ändert sich der Outcome in folgendes:

1
Waiting for WiFi to connect......... connected

2
Waiting for NTP time sync: .

3
Current time: Fri Nov 20 13:13:10 2020

4
[HTTPS] begin...

5
[HTTPS] GET...

6
[HTTPS] GET... failed, error: connection refused


Also habe ich mal mit WireShark auf die Leitung gehört, um 
herauszufinden, warum der Server die Verbindung verweigert. Dabei ist 
mir folgende Zeile aufgefallen:

1
Cipher Suite: TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (0xc030)


Es scheint, als erwarte der Server also AES256 bzw. SHA384 Chiffren, 
aber der ESP diese nicht standardmäßig unterstützt/beherrscht.

Kann mir jemand vielleicht sagen, wie ich meinem ESP32 beibringe, 
AES256/SHA384 zu unterstützen?

Freue mich über jede Antwort, vielen Dank im voraus, und sorry falls ich 
an irgend einer Stelle Probleme hatte, mich auszudrücken bzw. mein 
Problem zu beschreiben, ich hoffe es war dennoch irgendwie verständlich.

Liebe Grüße

PS: Der Vollständigkeit halber hier noch der Code, den ich versucht 
habe, auszuführen:

1
/**

2
   BasicHTTPSClient.ino

3
    Created on: 14.10.2018

4
*/

5
6
#include <Arduino.h>

7
#include <WiFi.h>

8
#include <HTTPClient.h>

9
#include <WiFiClientSecure.h>

10
11
// This is GandiStandardSSLCA2.pem, the root Certificate Authority that signed 

12
// the server certifcate for the demo server https://jigsaw.w3.org in this

13
// example. This certificate is valid until Sep 11 23:59:59 2024 GMT

14
const char* rootCACertificate = \

15
"-----BEGIN CERTIFICATE-----\n" \

16
"MIIF6TCCA9GgAwIBAgIQBeTcO5Q4qzuFl8umoZhQ4zANBgkqhkiG9w0BAQwFADCB\n" \

17
"iDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0pl\n" \

18
"cnNleSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNV\n" \

19
"BAMTJVVTRVJUcnVzdCBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTQw\n" \

20
"OTEyMDAwMDAwWhcNMjQwOTExMjM1OTU5WjBfMQswCQYDVQQGEwJGUjEOMAwGA1UE\n" \

21
"CBMFUGFyaXMxDjAMBgNVBAcTBVBhcmlzMQ4wDAYDVQQKEwVHYW5kaTEgMB4GA1UE\n" \

22
"AxMXR2FuZGkgU3RhbmRhcmQgU1NMIENBIDIwggEiMA0GCSqGSIb3DQEBAQUAA4IB\n" \

23
"DwAwggEKAoIBAQCUBC2meZV0/9UAPPWu2JSxKXzAjwsLibmCg5duNyj1ohrP0pIL\n" \

24
"m6jTh5RzhBCf3DXLwi2SrCG5yzv8QMHBgyHwv/j2nPqcghDA0I5O5Q1MsJFckLSk\n" \

25
"QFEW2uSEEi0FXKEfFxkkUap66uEHG4aNAXLy59SDIzme4OFMH2sio7QQZrDtgpbX\n" \

26
"bmq08j+1QvzdirWrui0dOnWbMdw+naxb00ENbLAb9Tr1eeohovj0M1JLJC0epJmx\n" \

27
"bUi8uBL+cnB89/sCdfSN3tbawKAyGlLfOGsuRTg/PwSWAP2h9KK71RfWJ3wbWFmV\n" \

28
"XooS/ZyrgT5SKEhRhWvzkbKGPym1bgNi7tYFAgMBAAGjggF1MIIBcTAfBgNVHSME\n" \

29
"GDAWgBRTeb9aqitKz1SA4dibwJ3ysgNmyzAdBgNVHQ4EFgQUs5Cn2MmvTs1hPJ98\n" \

30
"rV1/Qf1pMOowDgYDVR0PAQH/BAQDAgGGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYD\n" \

31
"VR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMCIGA1UdIAQbMBkwDQYLKwYBBAGy\n" \

32
"MQECAhowCAYGZ4EMAQIBMFAGA1UdHwRJMEcwRaBDoEGGP2h0dHA6Ly9jcmwudXNl\n" \

33
"cnRydXN0LmNvbS9VU0VSVHJ1c3RSU0FDZXJ0aWZpY2F0aW9uQXV0aG9yaXR5LmNy\n" \

34
"bDB2BggrBgEFBQcBAQRqMGgwPwYIKwYBBQUHMAKGM2h0dHA6Ly9jcnQudXNlcnRy\n" \

35
"dXN0LmNvbS9VU0VSVHJ1c3RSU0FBZGRUcnVzdENBLmNydDAlBggrBgEFBQcwAYYZ\n" \

36
"aHR0cDovL29jc3AudXNlcnRydXN0LmNvbTANBgkqhkiG9w0BAQwFAAOCAgEAWGf9\n" \

37
"crJq13xhlhl+2UNG0SZ9yFP6ZrBrLafTqlb3OojQO3LJUP33WbKqaPWMcwO7lWUX\n" \

38
"zi8c3ZgTopHJ7qFAbjyY1lzzsiI8Le4bpOHeICQW8owRc5E69vrOJAKHypPstLbI\n" \

39
"FhfFcvwnQPYT/pOmnVHvPCvYd1ebjGU6NSU2t7WKY28HJ5OxYI2A25bUeo8tqxyI\n" \

40
"yW5+1mUfr13KFj8oRtygNeX56eXVlogMT8a3d2dIhCe2H7Bo26y/d7CQuKLJHDJd\n" \

41
"ArolQ4FCR7vY4Y8MDEZf7kYzawMUgtN+zY+vkNaOJH1AQrRqahfGlZfh8jjNp+20\n" \

42
"J0CT33KpuMZmYzc4ZCIwojvxuch7yPspOqsactIGEk72gtQjbz7Dk+XYtsDe3CMW\n" \

43
"1hMwt6CaDixVBgBwAc/qOR2A24j3pSC4W/0xJmmPLQphgzpHphNULB7j7UTKvGof\n" \

44
"KA5R2d4On3XNDgOVyvnFqSot/kGkoUeuDcL5OWYzSlvhhChZbH2UF3bkRYKtcCD9\n" \

45
"0m9jqNf6oDP6N8v3smWe2lBvP+Sn845dWDKXcCMu5/3EFZucJ48y7RetWIExKREa\n" \

46
"m9T8bJUox04FB6b9HbwZ4ui3uRGKLXASUoWNjDNKD/yZkuBjcNqllEdjB+dYxzFf\n" \

47
"BT02Vf6Dsuimrdfp5gJ0iHRc2jTbkNJtUQoj1iM=\n" \

48
"-----END CERTIFICATE-----\n";

49
50
// Not sure if WiFiClientSecure checks the validity date of the certificate. 

51
// Setting clock just to be sure...

52
void setClock() {

53
  configTime(0, 0, "pool.ntp.org", "time.nist.gov");

54
55
  Serial.print(F("Waiting for NTP time sync: "));

56
  time_t nowSecs = time(nullptr);

57
  while (nowSecs < 8 * 3600 * 2) {

58
    delay(500);

59
    Serial.print(F("."));

60
    yield();

61
    nowSecs = time(nullptr);

62
  }

63
64
  Serial.println();

65
  struct tm timeinfo;

66
  gmtime_r(&nowSecs, &timeinfo);

67
  Serial.print(F("Current time: "));

68
  Serial.print(asctime(&timeinfo));

69
}

70
71
72
void setup() {

73
74
  Serial.begin(115200);

75
  // Serial.setDebugOutput(true);

76
77
  Serial.println();

78
  Serial.println();

79
  Serial.println();

80
81
  WiFi.mode(WIFI_STA);

82
  WiFi.begin("MyWiFiSSID", "MyWiFiPassword");

83
84
  // wait for WiFi connection

85
  Serial.print("Waiting for WiFi to connect...");

86
  while (WiFi.status() != WL_CONNECTED) {

87
    Serial.print(".");

88
  }

89
  Serial.println(" connected");

90
91
  setClock();  

92
}

93
94
void loop() {

95
  WiFiClientSecure *client = new WiFiClientSecure;

96
  if(client) {

97
    client -> setCACert(rootCACertificate);

98
99
    {

100
      // Add a scoping block for HTTPClient https to make sure it is destroyed before WiFiClientSecure *client is 

101
      HTTPClient https;

102
  

103
      Serial.print("[HTTPS] begin...\n");

104
      if (https.begin(*client, "https://jigsaw.w3.org/HTTP/connection.html")) {  // HTTPS

105
        Serial.print("[HTTPS] GET...\n");

106
        // start connection and send HTTP header

107
        int httpCode = https.GET();

108
  

109
        // httpCode will be negative on error

110
        if (httpCode > 0) {

111
          // HTTP header has been send and Server response header has been handled

112
          Serial.printf("[HTTPS] GET... code: %d\n", httpCode);

113
  

114
          // file found at server

115
          if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {

116
            String payload = https.getString();

117
            Serial.println(payload);

118
          }

119
        } else {

120
          Serial.printf("[HTTPS] GET... failed, error: %s\n", https.errorToString(httpCode).c_str());

121
        }

122
  

123
        https.end();

124
      } else {

125
        Serial.printf("[HTTPS] Unable to connect\n");

126
      }

127
128
      // End extra scoping block

129
    }

130
  

131
    delete client;

132
  } else {

133
    Serial.println("Unable to create client");

134
  }

135
136
  Serial.println();

137
  Serial.println("Waiting 10s before the next round...");

138
  delay(10000);

139
}


  


  




  

    Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Εrnst B.
        (ernst)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Bevor du irgendwelche speziellen Cipher/Digest-Algorithmen auspackst:

Hat der Server https://192.168.200.146/ ein gültiges Zertfikat, *was 
auch 192.168.200.146* beinhaltet?
Bei Let's-Encrypt gibt es sowas nicht.
=> Hostnamen statt IP verwenden, ggfs. im DNS tricksen.

Kannst du die URL z.B. mit "curl" ohne Fehlermeldung aufrufen?

Und:

Hast du den richtigen, zugehörigen CA-Root-Key extrahiert und in dein 
Programm einkompiliert?

Da muss der Public-Key rein, mit dem dein Server-Zertifikat signiert 
ist, nicht das Server-Zertifikat selber.

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Sam M.
        (sam_m229)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Hallo @ernst und vielen herzlichen Dank für deine Antwort!

Um ehrlich zu sein, bin ich leider nur ein kleiner Student, der gerade 
in dieser ganzen Mikrocontroller/Arduino/ESP/IOT-Welt anfängt, sorry^^ 
Trotzdem möchte ich versuchen, deine Fragen so adäquat wie möglich zu 
beantworten:

1.) Du frägst, ob das Server-Zertifikat die Host-IP beinhaltet. Das wage 
ich zu bezweifeln, da der Server seine IP über DHCP erhält (sprich die 
könnte sich nach Netzneustart theoretisch ändern). Was meinst du mit 
"Bei Let's-Encrypt gibt es sowas nicht"?^^ Der Server befindet sich auch 
lediglich in meinem lokalen Netz und ist nicht ans Internet angebunden. 
Daher kann ich leider mit deinem Tipp "Hostnamen statt IP verwenden, 
ggfs. im DNS tricksen." grad noch wenig anfangen sorry :-/

2.) Du hast weiterhin gefragt, ob ich die URL z.B. mit "curl" ohne 
Fehlermeldung aufrufen kann. Wenn ich in meiner CMD-Konsole
1
curl https://192.168.200.146/api/unlock/generate_pin

eingebe, kommt folgende Meldung:
1
curl: (77) schannel: next InitializeSecurityContext failed: SEC_E_UNTRUSTED_ROOT (0x80090325) - Die Zertifikatkette wurde von einer nicht vertrauenswürdigen Zertifizierungsstelle ausgestellt.

Wenn ich die URL im Browser aufrufe, so wird mir angezeigt, dass die 
Website nicht sicher sei (Fehlercode: DLG_FLAGS_INVALID_CA
DLG_FLAGS_SEC_CERT_CN_INVALID). Allerdings kann ich unten auf "Details" 
und dann auf "Webseite trotzdem laden" klicken. Gebe ich im nun 
folgenden PopUp den richtigen Benutzernamen sowie das korrekte Passwort 
ein, so erhalte ich den gewünschten JSON-String angezeigt.
Auch in C# kann ich die Zertifikatsvalidierung ganz einfach 
manipulieren:
1
ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };

Bei ESP scheint das leider nicht so einfach zu sein :(

3.) Um des CA-Root-Keys meines Servers habhaft zu werden, bin ich exakt 
nach diesem Tutorial vorgegangen: 
https://techtutorialsx.com/2017/11/18/esp32-arduino-https-get-request/ 
Ich hoffe natürlich, die Anleitung hier war korrekt und ich habe den 
Public-Key und nicht das Server-Zertifikat dadurch bekommen.

Vielen Dank nochmals für deine Hilfsanstrengungen. Liebe Grüße :)

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Εrnst B.
        (ernst)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
der ESP32 (-Arduino-core) verwendet die "MbedTLS"-Bibliothek für TLS, 
diese unterstützt u.A.
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384" und 
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"

d.H. dein Problem ist vermutlich wirklich das ungültige / self-signed 
Zertifikat.

Wenn dir nicht wichtig ist, dass das geprüft wird, lass den Check 
einfach weg.
d.H.:
1
 client -> setCACert(rootCACertificate);

und das "rootCACertificate" auskommentieren, testen.

Evtl. gibt es eine Warn-Meldung beim connect,
1
 log_i("WARNING: Use certificates for a more secure communication!");

Aber verbinden sollte es eigentlich trotzdem.

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Sam M.
        (sam_m229)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Hallo @ernst und vielen Dank erneut für deine Hilfe.

Also ich habe jetzt mal das komplette Zertifikat (also von einschl. der 
Zeile
1
const char* rootCACertificate = \

bis einschl. der Zeile
1
"-----END CERTIFICATE-----\n";

) sowie die Zeile
1
client -> setCACert(rootCACertificate);

auskommentiert, leider hatte dies keinerlei Effekt :( Der Output bleibt 
der gleiche:
1
Waiting for WiFi to connect......... connected

2
Waiting for NTP time sync: .

3
Current time: Tue Nov 24 15:51:14 2020

4
[HTTPS] begin...

5
[HTTPS] GET...

6
[HTTPS] GET... failed, error: connection refused


  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Εrnst B.
        (ernst)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Ich würde an deiner Stelle jetzt anfangen, das Schrittweise zu debuggen.

z.B. erstmal versuchen, ob der WiFiClientSecure eine Verbindung aufbauen 
kann, unabhängig von HTTP, "GET" usw.

Dazu alles rausnehmen, was den http-client benutzt, und übriglassen:

1
  WiFiClientSecure *client = new WiFiClientSecure;

2
  if (!client->connect("192.168.200.146", 443)) {

3
    Serial.println("Fehler");

4
  } else {

5
    Serial.println("Verbunden");

6
  }

7
  client->stop();

8
  delete client;

9
  Serial.println("Waiting 10s before the next round...");

10
  delay(10000);


Evtl. im Fehlerfall client->lastError(char *buf, const size_t size); 
aufrufen, ausgeben.

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Sam M.
        (sam_m229)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Ich muss aber zusätzlich noch mein WLAN irgendwie connecten oder?

Ich habe deinen Code in die loop()-Methode gepackt, folgenden Import 
zugefügt:
1
#include <WiFiClientSecure.h>

sowie folgende Zeilen noch zusätzlich in die setup()-Methode 
geschrieben:
1
  Serial.begin(115200);

2
3
  WiFi.begin("MeinWlanName", "MeinWlanPasswort");

4
5
  // attempt to connect to Wifi network:

6
  while (WiFi.status() != WL_CONNECTED) {

7
8
    Serial.print(".");

9
10
    // wait 1 second for re-trying

11
    delay(1000);

12
  }

13
  Serial.print("Connected to ");

14
  Serial.println("MeinWlanName");

Der Output auf meinem seriellen Monitor sieht jetzt folgendermaßen aus:
1
.Connected to MeinWlanName

2
3
Starting connection to server...

4
Verbunden

5
Waiting 10s before the next round...

Also das scheint ja schonmal zu funktionieren :-)

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Εrnst B.
        (ernst)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Sam M. schrieb:
> Also das scheint ja schonmal zu funktionieren :-)

Na dann, nächster Test: HTTP "von Hand", einbauen:

1
    client->println("GET /api/unlock/generate_pin HTTP/1.0");

2
    client->println("Host: 192.168.200.146"); // ist evtl. optional

3
    client->println();

4
5
    while (client->available()) {

6
      Serial.write(client->read());

7
      yield(); // evtl. auch nicht nötig.

8
    }


  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Sam M.
        (sam_m229)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Hm hier scheint der Knacktus zu liegen.

Ich habe deine Zeilen jetzt einmal in den else-Zweig (also nach
1
Serial.println("Verbunden");

) und einmal direkt nach das komplette if/else-Statement gepackt, leider 
ist nun beides mal der Output der folgende:

1
.Connected to MeinWlanName

2
3
Starting connection to server...

4
Fehler

5
Waiting 10s before the next round...


Oder hab ich es an der falschen Position eingefügt?

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Εrnst B.
        (ernst)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Sam M. schrieb:
> Oder hab ich es an der falschen Position eingefügt?

Nö, das ist bei "Verbunden" schon richtig aufgehoben.

Änder den Fehler-Pfad mal ab:

1
  char message[100];

2
  client->lastError(message, sizeof(message));

3
  Serial.print("Fehler: ");

4
  Serial.println(message);


  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Sam M.
        (sam_m229)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Hä ich checks nicht :D

Jetzt ist der Output wieder

1
.Connected to MeinWlanName

2
3
Starting connection to server...

4
Verbunden

5
Waiting 10s before the next round...


Hier jetzt mal sicherheitshalber der vollständige Code, den ich 
hochgeladen hab:

1
#include <WiFiClientSecure.h>

2
3
void setup() {

4
5
  Serial.begin(115200);

6
7
  WiFi.begin("MeinWlanName", "MeinWlanPasswort");

8
9
  // attempt to connect to Wifi network:

10
  while (WiFi.status() != WL_CONNECTED) {

11
12
    Serial.print(".");

13
14
    // wait 1 second for re-trying

15
    delay(1000);

16
  }

17
  Serial.print("Connected to ");

18
  Serial.println("MeinWlanName");

19
}

20
21
void loop() {

22
  Serial.println("\nStarting connection to server...");

23
  

24
  WiFiClientSecure *client = new WiFiClientSecure;

25
  if (!client->connect("192.168.200.146", 443)) {

26
    char message[100];

27
    client->lastError(message, sizeof(message));

28
    Serial.print("Fehler: ");

29
    Serial.println(message);

30
  } else {

31
    Serial.println("Verbunden"); 

32
33
    client->println("GET /api/unlock/generate_pin HTTP/1.0");

34
    client->println("Host: 192.168.200.146"); // ist evtl. optional

35
    client->println();

36
37
    while (client->available()) {

38
      Serial.write(client->read());

39
      yield(); // evtl. auch nicht nötig.

40
    }

41
  }

42
  

43
  client->stop();

44
  delete client;

45
  Serial.println("Waiting 10s before the next round...");

46
  delay(10000);

47
}


  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Εrnst B.
        (ernst)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Ups. mein Fehler.

Die "client->available()"-Schleife wird nicht richtig betreten, weil 
nicht sofort Daten vorhanden sind.

mach mal  noch eine "while connected" Schleife drum.

also
1
  while (client->connected()) {

2
     while (client->available()) {

3
       Serial.write(client->read());

4
    }

5
    yield();

6
  }



Unabhängig davon: Der Request müsste schon am Server angekommen sein, 
kannst du da ins Logfile schauen?

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Sam M.
        (sam_m229)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Here we go :)

1
.Connected to MeinWlanName

2
3
Starting connection to server...

4
Verbunden

5
HTTP/1.0 401 Unauthorized

6
Content-Length: 136

7
WWW-Authenticate: Basic realm="VDAI-Interface"

8
Access-Control-Allow-Origin: null

9
X-Frame-Options: SAMEORIGIN

10
Content-Type: text/html; charset=utf-8

11
Date: Tue, 24 Nov 2020 17:12:18 GMT

12
13
<html><head><title>Nicht autorisiert</title></head><body><h2>Zugang verweigert. Bitte überprüfen Sie ihre Eingaben.</h2></body></html>


Allerdings bricht er danach ab und loopt nicht weiter gell. Also das ist 
der komplette Output,

1
Waiting 10s before the next round...

kommt nicht mehr, egal wie lang ich warte...

Wir müssen uns jetzt glaube ich noch irgendwie mit Benutzername/Passwort 
authentifizieren oder? :X

Zu deiner Frage noch kurz ob ich irgendwie ins Logfile des Servers 
schauen kann: das wird wahrscheinlich schwer, da das Gerät, auf das ich 
mich zu verbinden versuche, kein "Computer" ist, also kein "normales" 
Windows/Linux hat, sondern ein Spielautomat xD Daher weiß ich leider 
nicht, ob dieser überhaupt Logfiles für Requests führt, und falls doch, 
wo die sein sollen/wie ich an die rankomme :P Ich kann aber morgen mal 
meine Kollegen fragen, vielleicht wissen die das^^

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Εrnst B.
        (ernst)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Sam M. schrieb:
> Allerdings bricht er danach ab und loopt nicht weiter gell. Also das ist
> der komplette Output,
> Waiting 10s before the next round...kommt nicht mehr, egal wie lang ich
> warte...

Liegt daran, dass diese Schleife keine vollwertige HTTP-Implementation 
ist.
Ein "Connection: close" - Header mitzusenden könnte das verbessern.

Aber Egal, Test-Resultat: Am TLS, den Verschlüsselungsalgorithmen, den 
Zertifikaten o.Ä. liegt es nicht.

Insofern wäre der nächste Schritt im soweit funktionierenden 
Testprogramm das "HTTP-von-Hand"-Senden wieder rauszunehmen und durch 
den HTTPClient zu ersetzen.
Damit fällt dann auch das Basic-Auth leichter.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
  


  

    

      von
      
        Sam M.
        (sam_m229)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Εrnst B. schrieb:
> Aber Egal, Test-Resultat: Am TLS, den Verschlüsselungsalgorithmen, den
> Zertifikaten o.Ä. liegt es nicht.
>
> Insofern wäre der nächste Schritt im soweit funktionierenden
> Testprogramm das "HTTP-von-Hand"-Senden wieder rauszunehmen und durch
> den HTTPClient zu ersetzen.
> Damit fällt dann auch das Basic-Auth leichter.

Hallo Ernst und vielen vielen herzlichen Dank für deine Hilfe, du hast 
mir echt meinen A*sch gerettet!^^
Komischerweise hat das jetzt funktioniert - ich habe den Code des 
HTTPClients wieder reingenommen/-kopiert und volià auf einmal erhalte 
ich das gewünschte JSON. Keine Ahnung was das Problem war, ich hab mir 
echt nen Wolf gesucht xD

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  








    

    

       Thread beobachten

      |
         Seitenaufteilung abschalten

    

        


Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.



  Bestehender Account

  


  
  

  
    

      

        
          
        
        
          
        
      

      

        
          
        
        
          
        
      

    


    
    
    





  Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!

  Mit Google-Account einloggen
  





  Noch kein Account? Hier anmelden.