ESP32 --> String verschlüsseln --> An Server senden --> mit PHP entschlüsseln

Hi zusammen,

nun meld ich mich auch wieder mal, ihr hattet lange genug eure Ruhe :wink:

Kurze Frage:

Hat jemand ein Beispiel für mich, wie ich folgendes machen kann:

Ich möchte den Inhalt eines beliebigen Strings (bzw. char Arrays) mittels eines selbst wählbaren keys (soll ein Alphanumerischer String sein) verschlüsseln, an einen Server schicken und dort mittels PHP wieder entschlüsseln (mit dem gleichen key, d.h. PHP und ESP kennen den gleichen key).

Beispiel:

char pw_unverschluesselt[30] = "Das ist mein Passwort";
char key[15] = "D1445SFFG34&%&";
char pw_verschluesselt[100] = "";

pw_verschluesselt = verschluessle(pw_unverschluesselt, key);

// Das Passwort wird per https-Übertragung an einen Server gesendet, das kann ich ;-)

// Serverseitig soll das Passwort nun über PHP wieder entschlüsselt werden mit dem gleichen key

Wäre echt mega, wenn ihr mir da weiterhelfen könntet.

LG

:question:sowas:

Ist sicher mit Kanonen auf Spatzen....

EIn paar solche Libraries hab ich mir schon angeschaut (auch die AESLib), aber wie du sagst: Kanonen auf Spatzen :wink: Da waren die Beispiele schon teilweise so komplex, dass ich da mit meinem begrenzten Verstand nicht durchgeblickt hab.

Daher hatte ich mir erhofft, dass jemand evtl. ein Steinschleuder auf Spatzen Beispiel aus der Hose zieht.

Ansonsten kuck ich mich mal in die Kanonen-Libs rein.

Edit: WIchtig ist für mich halt dann auch, wie ich das mit PHO wieder (mit dem gleichen key) ENTschlüsselt bekomme.

LG

zu Demozwecke:
am ESP von jedem Byte 42 abziehen,
in PHP zu jedem Byte 42 dazuzählen.

Ich hatte irgendwo mal ne .zip lib gesehen....
Bin jetzt nur über die gestolpert.
Sowas wäre mein Ansatz....

Beide Ansätze klingen gut, Danke @noiasca und @my_xy_projekt .
Ich werd mich mal damit beschäftigen.

Evtl. mach ichs so, dass der key z.B. ein Array aus verschiedenen Zahlen sind und diese dann den Subtrahenden für die bytes bilden, wenn ihr versteht, was ich mein.

So aehnlich waere mein erster Ansatz.
Ein Array mit 8 byte zwischen 0x00 und 0x80
Jedes byte des CharArray mit der PassPhrase jeweils mit +0x80 versehen und dann die entsprechende Position aus dem 8-Bytearray abziehen.
Bei charArray-Position 9 fängt es wieder mit Bytearray 0 an...
Wenn Du verstehst, was ich meine :slight_smile:

Naja, so halb... in der Theorie: ja.
Aber bei mir scheiterts dann meistens in der Umsetzung :laughing:

Ich würde es jetzt nicht "verschlüsseln" nennen; es ist eher "unlesbar machen", was ja für den Anwendungsfall genügen kann.

Programmtechnisch würde ich byteweises XOR verwenden - gerne auch wie vorgeschlagen mit acht verschiedenen Masken. Dann sind ver- und entschleiern identisch.

Naja, unlesbar machen wäre für mich jetzt eher z.B. base64_decode() und base64_encode().
In meinem Fall möchte ich einen Schlüssel verwenden (irgendein alphanumerischer Wert) ohne den man den String quasi nicht mehr entschlüsseln kann.

Ich fürchte ich bekomm das nicht hin :frowning:
Also wenn jemand noch eine gute Tat für heute offen hat bin ich gerne bereit, mich dafür herzugeben. Ich bin nicht zu faul zum coden sondern hab schlichtweg keine Ahnung, wie sowas geht, stell ich gerade fest.

Ansonsten schwimm ich mal durchs Google-Meer und suche nach Ansätzen.

Das hier hab ich gefunden:


// The same function is used to encrypt and
// decrypt
void encryptDecrypt(char inpString[])
{
    // Define XOR key
    // Any character value will work
    char xorKey = 'P';
 
    // calculate length of input string
    int len = strlen(inpString);
 
    // perform XOR operation of key
    // with every character in string
    for (int i = 0; i < len; i++)
    {
        inpString[i] = inpString[i] ^ xorKey;
        printf("%c",inpString[i]);
    }
}
 
// Driver program to test above function
int main()
{
    char sampleString[] = "GeeksforGeeks";
 
    // Encrypt the string
    printf("Encrypted String: ");
    encryptDecrypt(sampleString);
    printf("\n");
 
    // Decrypt the string
    printf("Decrypted String: ");
    encryptDecrypt(sampleString);
 
    return 0;
}

Geht das in die Richtung was ihr meint?
Da ich das aber dann in einer URL per https als Parameter an den Server versenden will (PHP-Datei) sollte der verschlüsselte Wert ja keine Fragezeichen enthalten, da ich sonst Probleme mit dem Versenden bekomme... wahrscheinlich sollte ich das verschlüsselte Passwort dann noch mit base64 dekodieren, oder?

Darf ich mal fragen, warum SSL, bzw. HTTPS, nicht ausreicht?

GET?
Warum nicht POST?

Und ich biete Dir mal was freches an.
Kannst suchen, was Du als PHP umsetzen musst :slight_smile:

// Forensketch
// https://forum.arduino.cc/

#include <Streaming.h>     // https://github.com/janelia-arduino/Streaming

//#define DEBUG              // Wenn aktiviert, werden Zwischenwerte ausgegeben

#ifdef DEBUG
  #define DBG_PRINTLN(...) Serial << __VA_ARGS__ << endl
#else
  #define DBG_PRINTLN(...)
#endif



const char passPhrase[] = {"MeinTextistGanzLang"};
const char salt[] = {"denkste"};
byte sendText[sizeof(passPhrase) + 10] = {'\0'};

void setup()
{
  Serial.begin(115200);
#if (defined(ARDUINO_AVR_MEGA) || defined(ARDUINO_AVR_MEGA2650)) // https://github.com/arduino/Arduino/issues/10764
  delay(300);
#endif
  Serial << (F("\r\nStart...\r\n")) << endl;
  DBG_PRINTLN(__FILE__);
  DBG_PRINTLN( __TIMESTAMP__);
  byte idx = 0;
  sendText[idx] = sizeof(passPhrase);
  Serial << "PassPhrase: " << passPhrase << endl;
  Serial << "salt: " << salt << endl;
  Serial << "sendtext: ";
  for (byte b = 0; b < sizeof(sendText); b++)
  {
    Serial << _HEX(sendText[b]) << ' ';
  }
  Serial << endl;
  idx++;
  byte saltIdx = 0;
  for (byte b = 0; b < sizeof(passPhrase); b++)
  {
    sendText[idx] = passPhrase[b] + salt[saltIdx];
    saltIdx++;
    idx++;
    if (saltIdx >= sizeof(salt))
    { saltIdx = 0; }
  }
  Serial << "sendtext gefüllt: ";
  for (byte b = 0; b < sizeof(sendText); b++)
  {
    Serial << _HEX(sendText[b]) << ' ';
  }
  Serial << endl;
  while (idx < sizeof(sendText))
  {
    sendText[idx] = random(50, 65);
    idx++;
  }
  Serial << "sendtext zum Versand: ";
  for (byte b = 0; b < sizeof(sendText); b++)
  {
    Serial << _HEX(sendText[b]) << ' ';
  }
  Serial << endl;
  Serial << "entschluesseln... \r\n" << "Länge: " << sendText[0] <<endl;
  byte myidx = 0;
  for (byte b = 1; b < sendText[0] + 1; b++)
  {
    Serial << char(sendText[b] - salt[myidx]);
    myidx++;
    if (myidx >= sizeof(salt))
    { myidx = 0; }
  }
  Serial << endl;
}

void  loop()

{}

Ich hab halt eine URL, die ich mit dem ESP32 ansteuer und einen Wert als Parameter übergebe.
Und da die URL theoretisch auch ein bot aufrufen kann, möchte ich auf beiden Seiten einen key, der sicherstellt, dass Sender und Empfänger einander kennen.

OK, jetzt hab ich was zum Kauen :slight_smile:

Das ist doch genau das, was HTTPS bereit stellt. Warum willst Du dann eine eigene Krücke bauen?

Gruß Tommy

Der ist nicht so schwer.

Da ist viel Kosmetik drin, die da nicht hingehört, aber ich war faul.

Wenn du auf beiden Seiten das Programm verändern kannst, und das musst du können, um eine Verschlüsselung unter zu bringen, dann kannst du auch POST statt GET verwenden.
Hier also kein Argument gegen POST.

Auch hier kein Argument gegen POST und keins für eine Verschlüsselung, abseits von SSL/HTTPS

Also:
Ich betrachte dein Verfahren, deine Idee, als mindestens "seltsam".
Noch seltsamer wäre, ein eigenes Verschlüsselungsverfahren zu bauen, und dann zu glauben es wäre irgendwie sicherer/besser, als HTTPS

Aber ok, es ist dein Wille, und ich wünsche dir Erfolg.

Ok, dann bin ich wahrscheinlich echt auf dem Holzweg. Ich geh nochmal in mich und überleg, ob ein einfaches POST doch ausreicht.

Schönen Abend allerseits und sorry für die Verwirrung. Trotzdem Danke für eure Hilfe

Ja, das meinte ich. Allerdings hier nur mit einem Byte "Key".

Auch ja. Unter anderem auch deshalb, weil die XOR-Operation ja auch beliebige nicht druckbare Zeichen erzeugen kann.