INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 1 Bewertungen - 5 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Sichere Übertragung mit NRF24
01.04.2014, 17:59
Beitrag #25
RE: Sichere Übertragung mit NRF24
Hallo itsy,

habe gerade mal über deinen Code geguckt. ISt schwer zu checken, da ich weder eine rtc habe noch die passende sha1 - lib gefunden habe Huh
Was mir aber auffällt ist, folgendes:
Code:
void loop() {
long GMT = rtc.getTimestamp();
char* newCode = totp.getCode(GMT);
Ich würde GMT und newCode im Setup() oder höher deklarieren und in der Loop() nur benutzen, auch wenn die Ops um die Variablen zu belegen ein paar Ticks länger dauern. Sonst hast du irgendwann "Speichersalat" (sowas wie eine Fragmentierung).
Weiterhin würde ich kein komplettes " rtc.getTimestamp();" immer wieder in der loop machen. Ich denke das zieht ganz schön Performance. Lieber sowas wie alle 2 Stunden ein getTimestamp() und dann ein setClockwithTimestamp() hinterher.
Die Genauigkeit scheint ja bei der Lib nicht soooo doll zu sein ?? ich lese gerade was von mehreren Minuten Drift pro Tag Huh Es sei denn man nimmt einen externen Quarz.
Zitat:Consider this: the internal oscillator of a micro is said to have an accuracy of +/-10% over the nominal frequency clock... External resonators have similar problems. Using the swRTC on an Arduino UNO with a resonator will result in differences that can reach the value of minutes/day. But you can use the deltaT to try to adjust them. I think that with a 2009, that has an external crystal for the Atmega, you will reach more precision. This lib is intended to be useful for people that need to track the time without the necessity to have a big accuracy.
Sagtest du nicht, du hättest einen Ethernet-Anschluß am Master (und die Lib sowieso eingebunden)? Dann würde ich die RTC rausnehmen und über NTP die Zeit setzen.
Zitat:Wird 29,xx Sekunden nachdem der aktuelle Code erstellt wurde eine Nachricht verschickt, kann der Empfänger bereits in der "Zwischenzeit" durch das Delay der Verarbeitung beim Sender und Empfänger 00,30, ... im Timestamp haben und es wird ein neuer Code generiert, der die Nachricht nicht mehr entschlüsseln kann
Dann müsste man wohl den Zeitpunkt der letzten Codeerstellung festhalten und bei/vor dem Senden prüfen ob noch genügend Zeit bis zur nächsten Codeerstellung bleibt. Wenn nicht dann zeitlich verschieben. Ist das machbar?

Grüße RK

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
01.04.2014, 20:20 (Dieser Beitrag wurde zuletzt bearbeitet: 01.04.2014 20:31 von itsy.)
Beitrag #26
RE: Sichere Übertragung mit NRF24
Hallo Ricardo,

Zitat: Ist schwer zu checken, da ich weder eine rtc habe noch die passende sha1 - lib gefunden habe Huh

Wenn es weiter nichts ist ;-)

Eine funktionierende sha-Lib habe ich auch erst nach längerem Suchen und testen gefunden. Die im Paket enthaltende Lib funktioniert: Klick

Eine RTC benötigst Du gar nicht - habe ich auch nicht. Und man braucht auch keinen Abgleich über NTP.

Zitat:Zitat:
denn es muss auf den Systemen nur die gleiche Zeit eingestellt sein - egal welche

Könnte man im Sinne der TOTP - Lib soghar als Feature verwerten Smile

Wie wir bereits festgestellt haben, benötigt man nicht die genaue Zeit, sondern nur die gleiche Zeit im Master und Client.

Und die Zeit mit der swRTC-Lib kann man ganz einfach im Code einstellen. Ich nutze hierfür eine random-Funktion:

Code:
rtc.stopRTC();
rtc.setDate(random(1,30),random(1,12),random(1970,2030)); //set the date here
rtc.setTime(random(0,24),random(1,59),random(1,59)); //set the time here
rtc.startRTC();

Damit haben wir ohne RTC schon mal die Zeit gesetzt.
Diese wird dann jede Minute an die Clients gesendet. Damit dürfte sich auch das Problem der Ungenauigkeit in Grenzen halten.

Zitat:Ich würde GMT und newCode im Setup() oder höher deklarieren und in der Loop() nur benutzen, auch wenn die Ops um die Variablen zu belegen ein paar Ticks länger dauern. Sonst hast du irgendwann "Speichersalat" (sowas wie eine Fragmentierung).

Guten Tip - vielen Dank :-)

Zitat:Weiterhin würde ich kein komplettes " rtc.getTimestamp();" immer wieder in der loop machen. Ich denke das zieht ganz schön Performance. Lieber sowas wie alle 2 Stunden ein getTimestamp() und dann ein setClockwithTimestamp() hinterher.

Ich denke, dass wir damit dann wieder in der Anfangsproblematik hängen, weshalb Du diese Möglichkeit überhaupt gesucht hast ;-)

Ohne einen neuen Timestamp für die TOTP wird immer der gleiche newCode erzeugt - dieser basiert ja auf dem Timestamp. Oder habe ich da etwas falsch verstanden? Sonst könnten wir auch gleich einfach nur mit AES verschlüsseln, oder?

Zitat:Dann müsste man wohl den Zeitpunkt der letzten Codeerstellung festhalten und bei/vor dem Senden prüfen ob noch genügend Zeit bis zur nächsten Codeerstellung bleibt. Wenn nicht dann zeitlich verschieben. Ist das machbar?

Wie gesagt, dass ist nur ein theoretisches Problem, da ich ja mehrfach hintereinander abfrage, sollte keine Antwort kommen (und das wäre ja der Fall, wenn nicht richtig entschlüsselt werden kann). Ansonsten kann man es auch so machen, wie Du sagst, in dem man auch immer den letzten Code noch speichert und schaut mit welchem man entschlüsseln kann.

Viele Grüße
itsy

P.S. mit den eingebundenen Libs läuft der Sketch bereits, den ich gepostet habe - zumindest der 2. (also mein erster Versuch).
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
02.04.2014, 07:52 (Dieser Beitrag wurde zuletzt bearbeitet: 02.04.2014 07:59 von rkuehle.)
Beitrag #27
RE: Sichere Übertragung mit NRF24
Moin itsy,

so wie ich das sehe, war ich gestern etwas umnachtet Huh Jetzt verstehe ich erst, dass du wirklich "nur" eine SW-Uhr benutzt (hätte ich aber aus dem Namen der Lib schon schließen können).
Zitat:Und die Zeit mit der swRTC-Lib kann man ganz einfach im Code einstellen. Ich nutze hierfür eine random-Funktion:
rtc.stopRTC();
rtc.setDate(random(1,30),random(1,12),random(1970,2030)); //set the date here
rtc.setTime(random(0,24),random(1,59),random(1,59)); //set the time here
rtc.startRTC();
Damit haben wir ohne RTC schon mal die Zeit gesetzt. Diese wird dann jede Minute an die Clients gesendet.
Und wieder mehr kapiert, was du in deinem Code machst.

Mach mich bitte schlau Smile

Grüße Ricardo

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
02.04.2014, 18:30
Beitrag #28
RE: Sichere Übertragung mit NRF24
Hi Ricardo,

schön, dass wir wieder auf dem gleichen Stand sind :-)

Gehen wir also vom funktionieren Sketch aus, den ich gepostet habe.

Jetzt gibt es folgende todos:

1. Für uint8_t TOTPKey[] sollte das Passwort im Klartext eingegeben werden können z.B. "MeinPasswd" -> Konvertierung

2. In char TOTPCode[] wird der Code gespeichert, der aus dem Timestamp und dem TOTPKey generiert wird. Dieser wird dann zur Verschlüsselung mit AES verwendet. Folglich muss der Inhalt in uint8_t AESKey gespeichert werden -> Konvertierung

3. die AES-Funktion verschlüsselt die Daten in uint8_t AESData[]. Zum senden über NRF wird ein int-Array für die Daten verwendet int message[]. Demnach müssen zunächst die Daten aus message in AESData gespeichert werden -> Konvertierung

4. Beim Empfänger muss das empfangene int message[] zum entschlüsseln wieder in AESData gespeichert werden.

Hinweise:
- Wir haben beim Empfänger nur 8K frei - wir müssen also sogrsam mit den Ressourcen umgehen
-int message[] hat immer 6 Felder also int message [6] - ggf. muss man hierbei dann mit der Passwortlänge spielen, damit es passt.

Die Konvertierung bekomme ich einfach nicht vernünftig hin Undecided

Viele Grüße
itsy
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
02.04.2014, 21:17
Beitrag #29
RE: Sichere Übertragung mit NRF24
Hallo itsy,

folgender Gedanke:
uint8_t ist nix weiter als byte oder unsigned char (zumindest auf dem Arduino)
Daher könnte man wie folgt vorgehen:
zu 1.
uint8_t data[] = "Mein Password";
Gleich so deklarieren und die Konvertierung fällt aus.
zur 2.
Sollte umgedreht wie in 1. genauso klappen.
zu 3.
Sollte über einen Cast klappen, den du durch die Arrayelemente laufen lässt.
Soll heißen:
Code:
uint8_t n;
(int)n;
wobei n das jeweilige Element des Arrays ist.

Das mal so ausm Kopp. Wenns nicht klappt einfach mal die bisherigen Codes zu 1 bis 3 posten.

Grüße RK

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.04.2014, 17:57 (Dieser Beitrag wurde zuletzt bearbeitet: 03.04.2014 17:58 von itsy.)
Beitrag #30
RE: Sichere Übertragung mit NRF24
Hallo Ricardo,

im Prinzip funktioniert der Testcode nun schon sehr gut - alle Fehler sind behoben.

Allerdings funktioniert es leider nicht mit der Konvertierung. Pro Array-Feld habe ich beim uint8_t ja nur von 0-255.

Beim TOTPKey wäre es kein Problem dieses Passwort direkt korrekt einzugeben z.B. so:
uint8_t TOTPKey[5] = {175,204,78,194,237};

Aber wenn ich nun den TOTPCode in den AESKey kopieren möchte, habe ich die ersten Konvertierungsfehler:

for(int n = 0; n < sizeof(TOTPCode); n++){
AESKey[n]=(uint8_t)TOTPCode[n];
}

Konsole:
---------------------------------
TOTPCode:8-5-3-7-2-3-
AESKey:56-53-51-55-50-51-0-
---------------------------------

Die müssten identisch sein.
Ist nun zwar auch nicht so sehr schlimm, weil der Fehler beim Sender und Empfänger gleich gemacht wird, allerdings habe ich immer recht ähnliche Zahlen im AESKey?!

Ein wirkliches Problem bekommen wir, wenn ich mein int message[6] einfach versuche in uint8_t AESData[6] zu kopieren, da uint8_t nur bis 255 platz hat und int deutlich größer ist. Damit wird dann die message verfälscht und quasi unentschlüsselbar verschlüsselt ;-)

Viele Grüße
itsy
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
04.04.2014, 14:16
Beitrag #31
RE: Sichere Übertragung mit NRF24
Hallo itsy,
Was du in der Ausgabe siehst sind die ASCII-Werte der Ziffern.
Von ASCII nach Int geht etwa so:
Code:
char conversionBuffer[4];
int myConvertedNumber=0;
conversionBuffer[1]='9';
conversionBuffer[2]='9';
conversionBuffer[3]='9';
conversionBuffer[4]=0; // Endezeichen
myConvertedNumber=atoi(conversionBuffer)
Alternativ könntest du auch folgendes probieren:
Code:
int ival;
char cval;
char conversionbuffer[]="*";
for(int n = 0; n < sizeof(TOTPCode); n++){
ival=(uint8_t)TOTPCode[n];
cval=ival; // wandelt den ASCII Wert in ein char des eigentlichen Zeichens zB. "1"
AESKey[n]=atoi(conversionBuffer); // wandelt zB. das "1" in 1
}
Zitat:Ein wirkliches Problem bekommen wir, wenn ich mein int message[6] einfach versuche in uint8_t AESData[6] zu kopieren, da uint8_t nur bis 255 platz hat und int deutlich größer ist. Damit wird dann die message verfälscht und quasi unentschlüsselbar verschlüsselt ;-)
Für eine Idee brauche ich immer ein Code-/Ausgabebebeispiel. Show me!

Grüße Ricardo

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
04.04.2014, 14:21 (Dieser Beitrag wurde zuletzt bearbeitet: 04.04.2014 14:23 von itsy.)
Beitrag #32
RE: Sichere Übertragung mit NRF24
Hallo Ricardo,

kein Problem - anbei mein aktueller Testcode. Hier habe ich schon versucht in eine Funktion auszulagern usw.. Der Code Funktioniert im Prinzip und hat für alles eine Ausgabe zur Kontrolle :-)

Code:
#include "sha1.h"  
#include "TOTP.h"  
#include "swRTC.h"
#include "aes256.h"  

swRTC rtc;                                  // RTC-Funktion starten
aes256_context ctxt;                        // AES-Funktion starten
uint8_t TOTPKey[5] = {175,204,78,194,237};  // Shared Key für TOTP  
TOTP totp = TOTP(TOTPKey, 5);               // TOTPKey und Länge des generierten Code für Funktion setzen
int CryptAusgabe[6];
byte AktivCrypt = 1;

void setup() {
  
  Serial.begin(9600);
  
  rtc.stopRTC();
  rtc.setDate(27, 8, 2013);
  rtc.setTime(21, 25, 00);  
  rtc.startRTC();
  
}

void loop() {    

  int message[6] = {111,222,122,222,121,212};
  
    //--------------------------------------------
    Serial.print("message vorher:");  
    for(int n = 0; n < 6; n++){  
      Serial.print(message[n]);
      Serial.print("-");
    }
    Serial.println();
    Serial.println("---------------------------------");
   //--------------------------------------------
  
  if (AktivCrypt == 1) {
    crypt(message);
   for(int n = 0; n < 6; n++) message[n]=CryptAusgabe[n];
  }
  
    //--------------------------------------------
    Serial.print("message nachher:");  
    for(int n = 0; n < 6; n++){  
      Serial.print(message[n]);
      Serial.print("-");
    }
    Serial.println();
    Serial.println("---------------------------------");
   //--------------------------------------------
  
  delay(5000);
  
}


void crypt(int messagecrypt[]) {
  char TOTPCode[5];
  char* newCode = totp.getCode(rtc.getTimestamp());
  if(strcmp(TOTPCode, newCode) != 0) {
    strcpy(TOTPCode, newCode);
  };  
  
  uint8_t AESKey[5];
  for(int n = 0; n < 5; n++) AESKey[n]=uint8_t(TOTPCode[n]);
  aes256_init(&ctxt, AESKey);
  
  
    //--------------------------------------------
     Serial.print("TOTPKey:");  
   for(int n = 0; n < 5; n++){  
     Serial.print(TOTPKey[n]);
     Serial.print("-");
   }
   Serial.println();


    Serial.print("TOTPCode:");  
    for(int n = 0; n < 5; n++){  
      Serial.print(TOTPCode[n]);
      Serial.print("-");
    }
    Serial.println();
    

    Serial.print("AESKey:");  
    for(int n = 0; n < 5; n++){  
      Serial.print(AESKey[n]);
      Serial.print("-");
    }
    Serial.println();
  //--------------------------------------------
  
  
  
  uint8_t AESData[6];
  for(int n = 0; n < 6; n++) AESData[n]=(uint8_t)messagecrypt[n];
  
  //--------------------------------------------
    Serial.print("AESData:");  
    for(int n = 0; n < 6; n++){  
      Serial.print(AESData[n]);
      Serial.print("-");
    }
    Serial.println();
  //--------------------------------------------
    
  aes256_encrypt_ecb(&ctxt, AESData);
  
    //--------------------------------------------
    Serial.print("AESData crypt:");  
    for(int n = 0; n < 6; n++){  
      Serial.print(AESData[n]);
      Serial.print("-");
    }
    Serial.println();
  //--------------------------------------------
  
   aes256_decrypt_ecb(&ctxt, AESData); // AESData entschlüsseln
  
  //--------------------------------------------
    Serial.print("AESData decrypt:");  
    for(int n = 0; n < 6; n++){  
      Serial.print(AESData[n]);
      Serial.print("-");
    }
    Serial.println();
  //--------------------------------------------
  
    Serial.println("---------------------------------");
    
    for(int n = 0; n < 6; n++) CryptAusgabe[n] = int(AESData[n]);
    
  aes256_done(&ctxt);
};

Viele Grüße
itsy

Das Problem wird wohl sein, dass ich ein Array-Feld int in ein Array-Feld uint8_t abbilden kann. Vielleicht muss jedes int-Feld einzeln die Verschlüsselung durchlaufen ...
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  nrf24 an Mega 2560 jgrothe 2 161 10.09.2016 13:39
Letzter Beitrag: jgrothe
  Temperatur mit nrf24 übertragen jgrothe 17 657 09.09.2016 14:01
Letzter Beitrag: jgrothe
  Interrupt bei Serieller Übertragung Binatone 8 357 21.06.2016 14:09
Letzter Beitrag: Scheams
  NRF24 soll Daten empfangen und senden... MaHaI976 2 938 08.06.2015 19:36
Letzter Beitrag: MaHaI976
  float per NRF24 übertragen F2Ingo 9 1.646 14.04.2015 21:21
Letzter Beitrag: F2Ingo
  Accelerometerwert Übertragung via Bluetooth??? Brauche HIlfe Techniker2012 2 4.774 03.07.2014 18:21
Letzter Beitrag: rkuehle

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste