Passwörter mit Masterpasswort ver- und entschlüsseln

OP #7095129
Lesenswert?

Hallo,
ich möchte gerne in c/c++ (Arduino) Zugangsdaten ver- und endschlüsseln 
mittels eines "Masterpasswortes" das man natürlich eingeben / übertragen 
muss. Das ganze wird dann auf einem EEPROM gespeichert.

Leider finde ich hierfür kein passendes Beispiel, ich vermute da brauche 
ich ja keinen shared key etc. Meine Idee ist dass ich einen Key aus 
einem Passworthashwert erstelle. Ich habe schon ein wenig mit AES.h uns 
crypto.h experimentiert, leider bisher ohne Erfolg.

Was ich eigenlich nur brauche ist eine Methode zum ver - und eine zum 
entschlüsseln mittels eines Keys, wobei dieser natürlich jeweils gleich 
sein muss, damit am Ende wieder das gleiche rauskommt. Also in etwa 
sowas:

String ciphertext = decypt(String message, byte* key);
wobei
message der klartext ist,
ciphertext der verschlüsselte Text,
key der key.

und

String message = encypt(String ciphertext, byte* key);

Kann mir jemand ein passenden, möglichst einfachen, funktionierendes 
Beispielcode verlinken oder nennen oder wenigstens ein paar tips geben, 
z.B. welche verschlüsselungsmethode dafür genommen werden sollte?

Danke und viele Grüße

Thomas
#7095158
Lesenswert?

Thomas H. schrieb:
> Hallo, nein der Masterkey soll nicht im Flash liegen, er soll aus einem
> eingegebenem Passwort "generiert" werden.

Je nachdem welche Angriffsvektoren es da gibt, bleibt XOR eine 
Möglichkeit.

Problem wäre z.B. wenn der Angreifer den EEPROM-Inhalt kennt und ein 
entschlüsseltes Passwort bei Verwendung mitlesen kann, kann er die 
anderen Passwörter und den Masterkey errechnen.
Gast #7095987
Lesenswert?

warscheinlich Overkill, aber bitte,
1
#include <avr/pgmspace.h>
2
#include "xtea.h"
3
unsigned char EE_KEY[XTEA_KEYSIZEB] PROGMEM = { 246,26,39,117,100,240,254,48,107,192,108,56,234,54,195,3 };
4
unsigned char TEST_KEY[XTEA_KEYSIZEB] PROGMEM = { 193,104,46,209,249,154,141,242,31,247,183,73,175,133,168,105 };
5

6
uint8_t IV[XTEA_BLOCKSIZEB];
7

8
void load_key(const unsigned char*val) { uint8_t i; for(i=0;i<16;i++) key[i]^= pgm_read_byte(val++); }
9
void xor_IV(char*dat,char dst) {
10
    uint8_t i,j;
11
     for(i=XTEA_BLOCKSIZEB;i--;) if(dst) dat[i]^=IV[i]; else IV[i]^=dat[i];
12
}
13
void eeprom_read(uint8_t i, char*dat) {  
14
  uint16_t addr=8+i*XTEA_BLOCKSIZEB;
15
   for(i=XTEA_BLOCKSIZEB;i--;dat[i]=eeprom_read_byte((uint8_t*)addr++));
16
}
17
void eeprom_write(uint8_t i, char*dat) {  
18
  uint16_t addr=8+i*XTEA_BLOCKSIZEB;
19
   for(i=XTEA_BLOCKSIZEB;i--;eeprom_update_byte((uint8_t*)addr++,dat[i]));
20
}
21
void eeprom_ecb_read(uint8_t i, char*dat) {  
22
  load_key(EE_KEY); eeprom_read(i,dat);
23
  xtea_dec(dat,dat,key);   
24
}
25
void eeprom_ecb_write(uint8_t i, char*dat) {  
26
  load_key(EE_KEY);
27
  xtea_enc(dat,dat,key);   
28
  eeprom_write(i,dat);
29
  xtea_dec(dat,dat,key);  // restore data
30
}
31
void eeprom_cbc_read(uint8_t i, char*dat, uint8_t cnt) {  
32
  uint8_t j;
33
    eeprom_ecb_read(0,IV);
34
  while(cnt--) {
35
    eeprom_ecb_read(i,dat);
36
    load_key(TEST_KEY);
37
    xtea_dec(dat,dat,key);
38
    xor_IV(dat,1);
39
    dat+=XTEA_BLOCKSIZEB;
40
    eeprom_ecb_read(i++,IV);
41
  }
42
}
43
void eeprom_cbc_write(uint8_t i, char*dat, uint8_t cnt) {  
44
    eeprom_ecb_read(0,IV);
45
  while(cnt--) {
46
    xor_IV(dat,0);
47
    load_key(TEST_KEY);
48
    xtea_enc(IV,IV,key);
49
    eeprom_write(i++,IV); dat+=XTEA_BLOCKSIZEB;
50
  }
51
}
52
void data_set(uint8_t idx, uint8_t val) { IV[idx&(XTEA_BLOCKSIZEB-1)]=val; } // helper for IV initialisation
Gast #7095994
Lesenswert?

Bei load_key,
1
 
2
key[i]^= pgm_read_byte(val++); 
3
durch 
4
key[i] = pgm_read_byte(val++);
ersetzen, ich verwende xor, damit ich nach dem init einen Bereich von
Daten zugreifen kann, mit anderer Verschluesselung, was danach nicht 
mehr
moeglich ist.
OP #7100406
Lesenswert?

chris schrieb:
> key[i]^= pgm_read_byte(val++);
> durch
> key[i] = pgm_read_byte(val++);

chris schrieb:
> Bei load_key,
> key[i]^= pgm_read_byte(val++);
> durch
> key[i] = pgm_read_byte(val++);
> ersetzen, ich verwende xor, damit ich nach dem init einen Bereich von
> Daten zugreifen kann, mit anderer Verschluesselung, was danach nicht
> mehr
> moeglich ist.

Hallo und danke für den Beispielcode!
Muss ich für das Beispiel die "XTEA-Cipher library for Arduino" 
installieren?

Ich bekomme es noch nicht ans laufen, die lib hat keine Methoden 
"xtea_dec" und "xtea_end".

Des weiteren habe ich, um erstmal das kompilieren zu testen, die defines

#define XTEA_KEYSIZEB 16
#define XTEA_BLOCKSIZEB 16

gesetzt, Keysize müsste ja 16 sein und blocksize?
und noch die Variable

unsigned char key[XTEA_KEYSIZEB] = { 
193,104,46,209,249,154,141,242,31,247,183,73,175,133,168,105 };

deklariert.
Ist das so richtig?

Danke!
Gast #7102625
Lesenswert?

Es ist die Standard Implementation fuer AVR, hier als Anhang.
Blocksize ist aber 64bits, also 8 bytes, keysize ist 128bits/16 bytes.

Zudem ist bei dem Code EEprom slot 0 mit IV (Initialisation Vector)
zu fuellen.
Angehängte Dateien:

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren