Key-File im selben Ordner speichern?

memo1990

Aktives Mitglied
Hallo ihr lieben Java-Coder,

habe eine allgemeine Frage zum Thema Verschlüsselung.

Ich habe ein Programm geschrieben worin man Kundendaten eingeben und als Datei abspeichern kann. Diese werden mit einem AES-Key, den ich ebenfalls als File abspeichere, verschlüsselt. Kann ein fremder die verschlüsselten Kundendaten mit dem Key-File wieder entschlüsseln, ohne das Programm nutzen zu müssen?

MfG
Memo1990
 
wenn das nicht der Fall wäre,hättest du den Besten verschlüsselungs-Algorithmus ausgedacht) Es ist nur die Frage ob sich der Aufwand zum Knacken Lohnt)).Also den Key-File von der Schweizer Bank würde ich keinem vertrauen wenn ich der Bankier wäre))
 
Ein Key sollte niemals irgendwo gespeichert sein außer im kopf des Users. Deshalb solltest du den Key aus dem Passwort des Benutzers erzeugen, welches dieser jedesmal eingeben muss wenn er die Software startet
 
Mein Programm bietet an, sein Benutzer-Passwort ändern zu können. Wenn der Benutzer sein Passwort ändert, muss ich ja alle Kundendaten einlesen, entschlüsseln und mit dem neuen Benutzer-Passwort wieder verschlüsseln.

Außerdem muss ich das Benutzer-Passwort ja auch irgendwo verschlüsselt speichern.
 
Wenn der User sein Passwort ändern, dann verschlüsselst du das alte Passwort mit dem Key des neuen und schon kannst du die Datenbank weiter mit dem alten key entschlüsseln
 
Hallo,

also ich habe mich jetzt mal mit hashen von Passwörtern beschäftigt. Ich wusste bisher nicht wie Passwörter in der Regel abgespeichert werden. Danke an @Wurstkopp.

Wie mach ich das jetzt aber am effizientesten mit der Verschlüsselung der Kundendaten. Ich denke mal am besten ist es, wenn ich den Key, der für die Kundendaten-Verschlüsselung dient, selbst mit dem Benutzer-Passwort verschlüssele.
 
Guten morgen,

ich brauche nochmal eure Hilfe. Ich weiß nicht wie ich das genau umsetzen soll. Denn wenn ich den Key-File (für Kundendaten) mit dem Benutzer-Passwort verschlüssele, habe ich doch wieder ein Key-File den ich abspeichern muss (SecretKeySpec). Das macht ja kein Sinn.
 
Wenn du den Secret key verschlüsselst, indem du das Passwort als Salt für die verschlüsselung benutzt, dann kannst du das Ergebnis ja ruhig speichern. Es kann ja dann keiner entschlüsseln ohne das Passwort zu wissen. Und das muss ja jedesmal eingetippt werden und ist (Hoffentlich) nirgendwo gespeichert.
 
Ich lege meine Passwörter auch immer neben dem Geheimnis ab - viele können trotzdem aber damit nichts anfangen 😀 😀

(Sorry für diese Antwort 😉)
 
Also wenn die Daten zu groß sind um sie beim Passwortwechsel neu zu verschlüsseln (Ist technisch wohl erstmal die einfachste Variante) gibt es noch die Möglichkeit einen Zwischenschlüssel zu nutzen. Diesen verschlüsselst du mit deinem Passwort-Hash und kannst ihn einfach neu verschlüsseln bei einer Passwortänderung. Hier ist z.B. ein interessanter Post dazu: https://security.stackexchange.com/...ting-with-passwords-encryption-of-key-vs-data
 
Hallo,

tut mir leid wenn ich da nochmal nachfrage. Wie wird es denn generell gemacht, wenn Daten von der Anwendung verschlüsselt auf dem lokalen Speicher abgelegt werden? Wird der Key einfach nur versteckt auf der Platte abgelegt? Oder wendet man da eine andere Methode an?

Zum verschlüsseln des SecretKeys nochmal. Wie genau mache ich das, mit welcher Klasse?
 
Zuletzt bearbeitet:
Das musst du doch nicht speichern, es sollte ja reichen wenn das ganze im RAM ist.

Wie meinst du das? Der Schlüssel für den Schlüssel muss ich doch auch aufbewahren, sonst kann ich es doch nicht mehr entschlüsseln. Beim nächsten Start der Anwendung habe ich doch wieder einen neuen Schlüssel (im RAM).
 
Zuletzt bearbeitet:
Der Schlüssel für den Schlüssel muss ich doch auch aufbewahren
Nein, das ist doch der Witz an der Sache. Das Prinzip mal ganz langsam:
  1. Du hast Verschlüsselungsmethode crypt(s,d), die gegebene Daten d mit Schlüssel s verschlüsselt.
  2. Du hast einen zufällig gewählten Schlüssel s.
  3. Jetzt wäre es ... ungeschickt, s einfach so auf die Platte zu speichern. Stattdessen nimmst Du das Passwort pw des Benutzers und verschlüsselt mit diesem den Schlüssel s. Damit erhältst Du einen verschlüsselten Schlüssel v (v = crypt(pw, s)), den Du auf die Platte packst.
  4. Startet jetzt die Anwendung neu, kommt sie nicht an die Daten, weil sie nur v aber s nicht kennt. Um an s zu gelangen, muss der Benutzer sein Passwort pw eingeben, dann kannst Du berechnen s = decrypt(pw, v). Jetzt erst kannst Du die verschlüsselten Daten e wieder mit s entschlüsseln d = decrypt(s, e).
  5. Wenn der Benutzer das Passwort ändert, berechnest Du einfach v mit dem geänderten Passwort neu und speicherst v ab.
 
@mihe7 danke für deine Beschreibung. Soweit habe ich das verstanden.

Zu Punkt 3. Mit welcher Klasse/Methode verschlüssele ich den Schlüssel s? Erstelle ich mir dann nochmal ein AES-Key aus dem Benutzer-Passwort? So wie hier gezeigt?
 
Also wenn ich das jetzt richtig versanden habe sollte der Code so ausschauen (den habe ich zum Test mal schnell zusammengeschrieben):

Code:
package main;

import java.io.*;
import java.util.Arrays;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;

public class Test {
    public void encryptKey(SecretKey customerKey, String userPassword) {
        try {
            byte[] passwordHash = MessageDigest.getInstance("SHA-256").digest(userPassword.getBytes()); //Benutzer-Passwort mittel SHA-256 hashen
            byte[] hash128 = Arrays.copyOf(passwordHash, 16); //Davon die ersten 128 Bit (16 x 8 Bit) verwenden
            SecretKey tempKey = new SecretKeySpec(hash128, "AES"); //AES-Schlüssel mit dem Benutzer-Passwort erstellen
       
            Cipher cip = Cipher.getInstance("AES");
            cip.init(Cipher.ENCRYPT_MODE, tempKey);
            CipherOutputStream cipOut = new CipherOutputStream(new FileOutputStream("C:\\NameOfKey.key"), cip);
            cipOut.write(customerKey.getEncoded());
            cipOut.close();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public SecretKey decryptKey(String userPassword) {
        try {
            byte[] passwordHash = MessageDigest.getInstance("SHA-256").digest(userPassword.getBytes());
            byte[] hash128 = Arrays.copyOf(passwordHash, 16);
            SecretKey tempKey = new SecretKeySpec(hash128, "AES");
       
            Cipher cip = Cipher.getInstance("AES");
            cip.init(Cipher.DECRYPT_MODE, tempKey);
            CipherInputStream cipIn = new CipherInputStream(new FileInputStream("C:\\NameOfKey.key"), cip);
            byte[] readKey = cipIn.readAllBytes();
       
            return new SecretKeySpec(readKey, "AES");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
   
        return null;
    }
}

Die Verschlüsselung für den Key der Kundendaten findet lediglich im RAM statt. Sowie @Dukel es bereits erwähnt hat.
 
Zuletzt bearbeitet:

Zurück
Oben