Hi Leute,
ich arbeite an einem Projekt, welches ich verschlüsseln möchte, bzw die Daten davon.
Meine Frage ist nun, ob mein Ansatz sinnvoll ist oder eher nicht:
Ich habe mir gedacht das Passwort erst zu hashen, dann einen Teil davon zu nehmen und diesen dann mit AES zu verschlüsseln (Key ist das Passwort selbst).
Dieses kann ich dann in meinem System speichern.
Alle anderen Daten würden dann mit dem Originalpasswort (bzw dem Hash davon) verschlüsselt. So speichere ich ein Passwort, dass zuerst entschlüsselt werden müsste, um alles andere zu entschlüsseln.
Ist das sinnvoll so?
Hier bei Beispiel für meinen Code:
[src=java]
private boolean isPasswordCorrect(String pw) {
String saved_password = this.readFile("p.txt");
try {
MessageDigest md = MessageDigest.getInstance("SHA-512");
md.update(pw.getBytes());
pw = new String(md.digest());
byte[] pw2 = pw.getBytes();
pw2 = Arrays.copyOf(pw2, 16);
SecretKeySpec password = new SecretKeySpec(pw2, "AES");
this.ec = new EasyCrypt(password, "AES");
// System.out.println(this.ec.encrypt(pw));
// System.out.println(saved_password);
//Passwort entschlüsseln und vergleichen
if (saved_password.equals(this.ec.encrypt(pw))) {
// System.out.println("##Korrekt##");
return true;
}
this.ec = null;
} catch (IOException ex) {
Logger.getLogger(CLASS1.class.getName()).log(Level.SEVERE, null, ex);
} catch (Exception ex) {
Logger.getLogger(CLASS1.class.getName()).log(Level.SEVERE, null, ex);
}
return false;
}
/* Und dann halt noch die Klasse, die ich von einer Website habe: */
import java.io.InputStream;
import java.io.OutputStream;
import java.security.Key;
import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.CipherOutputStream;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
/**
* @author Alexander Gr
* @see http://blog.axxg.de
*
*/
public class EasyCrypt {
private Key key = null;
private String verfahren = null;
/**
* @param Key verwendeter Schluessel
* @param verfahren bestimmt das verwendete Verschluesselungsverfahren "RSA", "AES", ....
* @throws Exception
*/
public EasyCrypt(Key k, String verfahren) throws Exception {
this.key = k;
this.verfahren = verfahren;
}
/**Verschluesselt einen Outputstream
* @param os Klartext-Outputstream
* @return verschluesselter Outputstream
* @throws Exception
*/
public OutputStream encryptOutputStream(OutputStream os) throws Exception {
// integritaet pruefen
valid();
// eigentliche Nachricht mit RSA verschluesseln
Cipher cipher = Cipher.getInstance(verfahren);
cipher.init(Cipher.ENCRYPT_MODE, key);
os = new CipherOutputStream(os, cipher);
return os;
}
/** Entschluesselt einen Inputstream
* @param is verschluesselter Inputstream
* @return Klartext-Inputstream
* @throws Exception
*/
public InputStream decryptInputStream(InputStream is) throws Exception {
// integritaet pruefen
valid();
// Daten mit AES entschluesseln
Cipher cipher = Cipher.getInstance(verfahren);
cipher.init(Cipher.DECRYPT_MODE, key);
is = new CipherInputStream(is, cipher);
return is;
}
/** Verschluesselt einen Text in BASE64
* @param text Klartext
* @return BASE64 String
* @throws Exception
*/
public String encrypt(String text) throws Exception {
// integritaet pruefen
valid();
// Verschluesseln
Cipher cipher = Cipher.getInstance(verfahren);
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] encrypted = cipher.doFinal(text.getBytes());
// bytes zu Base64-String konvertieren
BASE64Encoder myEncoder = new BASE64Encoder();
String geheim = myEncoder.encode(encrypted);
return geheim;
}
/** Entschluesselt einen BASE64 kodierten Text
* @param geheim BASE64 kodierter Text
* @return Klartext
* @throws Exception
*/
public String decrypt(String geheim) throws Exception {
// integritaet pruefen
valid();
// BASE64 String zu Byte-Array
BASE64Decoder myDecoder = new BASE64Decoder();
byte[] crypted = myDecoder.decodeBuffer(geheim);
// entschluesseln
Cipher cipher = Cipher.getInstance(verfahren);
cipher.init(Cipher.DECRYPT_MODE, key);
byte[] cipherData = cipher.doFinal(crypted);
return new String(cipherData);
}
//++++++++++++++++++++++++++++++
// Validierung
//++++++++++++++++++++++++++++++
private boolean valid() throws Exception{
if(verfahren == null){
throw new NullPointerException("Kein Verfahren angegeben!");
}
if(key == null){
throw new NullPointerException("Keinen Key angegeben!");
}
if(verfahren.isEmpty()){
throw new NullPointerException("Kein Verfahren angegeben!");
}
return true;
}
//++++++++++++++++++++++++++++++
// Getter und Setter
//++++++++++++++++++++++++++++++
public Key getKey() {
return key;
}
public void setKey(Key key) {
this.key = key;
}
public String getVerfahren() {
return verfahren;
}
public void setVerfahren(String verfahren) {
this.verfahren = verfahren;
}
}
[/src]
Gibts es eigentlich die common apache-packages standardmäßig in de JDK 8? Dann könnte man nämlich die Base64 daraus nehmen, da die aktuell verwendeten, eventuell demnächst auslaufen?
ich arbeite an einem Projekt, welches ich verschlüsseln möchte, bzw die Daten davon.
Meine Frage ist nun, ob mein Ansatz sinnvoll ist oder eher nicht:
Ich habe mir gedacht das Passwort erst zu hashen, dann einen Teil davon zu nehmen und diesen dann mit AES zu verschlüsseln (Key ist das Passwort selbst).
Dieses kann ich dann in meinem System speichern.
Alle anderen Daten würden dann mit dem Originalpasswort (bzw dem Hash davon) verschlüsselt. So speichere ich ein Passwort, dass zuerst entschlüsselt werden müsste, um alles andere zu entschlüsseln.
Ist das sinnvoll so?
Hier bei Beispiel für meinen Code:
[src=java]
private boolean isPasswordCorrect(String pw) {
String saved_password = this.readFile("p.txt");
try {
MessageDigest md = MessageDigest.getInstance("SHA-512");
md.update(pw.getBytes());
pw = new String(md.digest());
byte[] pw2 = pw.getBytes();
pw2 = Arrays.copyOf(pw2, 16);
SecretKeySpec password = new SecretKeySpec(pw2, "AES");
this.ec = new EasyCrypt(password, "AES");
// System.out.println(this.ec.encrypt(pw));
// System.out.println(saved_password);
//Passwort entschlüsseln und vergleichen
if (saved_password.equals(this.ec.encrypt(pw))) {
// System.out.println("##Korrekt##");
return true;
}
this.ec = null;
} catch (IOException ex) {
Logger.getLogger(CLASS1.class.getName()).log(Level.SEVERE, null, ex);
} catch (Exception ex) {
Logger.getLogger(CLASS1.class.getName()).log(Level.SEVERE, null, ex);
}
return false;
}
/* Und dann halt noch die Klasse, die ich von einer Website habe: */
import java.io.InputStream;
import java.io.OutputStream;
import java.security.Key;
import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.CipherOutputStream;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
/**
* @author Alexander Gr
* @see http://blog.axxg.de
*
*/
public class EasyCrypt {
private Key key = null;
private String verfahren = null;
/**
* @param Key verwendeter Schluessel
* @param verfahren bestimmt das verwendete Verschluesselungsverfahren "RSA", "AES", ....
* @throws Exception
*/
public EasyCrypt(Key k, String verfahren) throws Exception {
this.key = k;
this.verfahren = verfahren;
}
/**Verschluesselt einen Outputstream
* @param os Klartext-Outputstream
* @return verschluesselter Outputstream
* @throws Exception
*/
public OutputStream encryptOutputStream(OutputStream os) throws Exception {
// integritaet pruefen
valid();
// eigentliche Nachricht mit RSA verschluesseln
Cipher cipher = Cipher.getInstance(verfahren);
cipher.init(Cipher.ENCRYPT_MODE, key);
os = new CipherOutputStream(os, cipher);
return os;
}
/** Entschluesselt einen Inputstream
* @param is verschluesselter Inputstream
* @return Klartext-Inputstream
* @throws Exception
*/
public InputStream decryptInputStream(InputStream is) throws Exception {
// integritaet pruefen
valid();
// Daten mit AES entschluesseln
Cipher cipher = Cipher.getInstance(verfahren);
cipher.init(Cipher.DECRYPT_MODE, key);
is = new CipherInputStream(is, cipher);
return is;
}
/** Verschluesselt einen Text in BASE64
* @param text Klartext
* @return BASE64 String
* @throws Exception
*/
public String encrypt(String text) throws Exception {
// integritaet pruefen
valid();
// Verschluesseln
Cipher cipher = Cipher.getInstance(verfahren);
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] encrypted = cipher.doFinal(text.getBytes());
// bytes zu Base64-String konvertieren
BASE64Encoder myEncoder = new BASE64Encoder();
String geheim = myEncoder.encode(encrypted);
return geheim;
}
/** Entschluesselt einen BASE64 kodierten Text
* @param geheim BASE64 kodierter Text
* @return Klartext
* @throws Exception
*/
public String decrypt(String geheim) throws Exception {
// integritaet pruefen
valid();
// BASE64 String zu Byte-Array
BASE64Decoder myDecoder = new BASE64Decoder();
byte[] crypted = myDecoder.decodeBuffer(geheim);
// entschluesseln
Cipher cipher = Cipher.getInstance(verfahren);
cipher.init(Cipher.DECRYPT_MODE, key);
byte[] cipherData = cipher.doFinal(crypted);
return new String(cipherData);
}
//++++++++++++++++++++++++++++++
// Validierung
//++++++++++++++++++++++++++++++
private boolean valid() throws Exception{
if(verfahren == null){
throw new NullPointerException("Kein Verfahren angegeben!");
}
if(key == null){
throw new NullPointerException("Keinen Key angegeben!");
}
if(verfahren.isEmpty()){
throw new NullPointerException("Kein Verfahren angegeben!");
}
return true;
}
//++++++++++++++++++++++++++++++
// Getter und Setter
//++++++++++++++++++++++++++++++
public Key getKey() {
return key;
}
public void setKey(Key key) {
this.key = key;
}
public String getVerfahren() {
return verfahren;
}
public void setVerfahren(String verfahren) {
this.verfahren = verfahren;
}
}
[/src]
Gibts es eigentlich die common apache-packages standardmäßig in de JDK 8? Dann könnte man nämlich die Base64 daraus nehmen, da die aktuell verwendeten, eventuell demnächst auslaufen?
