String verschlüsseln - eigener Algorithmus

H

Hag2bard

Bekanntes Mitglied
Hallo und guten Abend,

Ich möchte einen String verschlüsseln, so dass man ihn nur mit einem Key wieder entschlüsseln kann. Ich weiß dass es dafür Bibliotheken gibt, die das ganze wahrscheinlich viel besser machen können als ich, aber darum geht es mir nicht.
Mir geht es darum eine simple Verschlüsselung zu entwickeln. Leider habe ich keinerlei Lösungsansätze und bräuchte einen Denkanstoss.
Meine Idee wäre einen String in ein char Array umzuwandeln und die einzelnen chars dann mit Hilfe des Schlüssels zu verändern.
Aber wie ich das anstellen soll, da fehlt es mir an Ideen.

Vielleicht könnte der Schlüssel ein einfacher int Wert sein der lediglich die chars mit diesem multipliziert.
Wie ich die chars in bytecode oder hexcode umwandel, muss ich mir selber raussuchen.

Welche Ideen hättet ihr für einen Anfänger?

Danke im Voraus
 
Eine einfache "Verschlüsselung" ist es du nimmst das Alphabet und eine zufällige zahl zb 3
jetzt addierst du bei jedem buchstaben in deinem Passwort weiter zb
aus A 3 Zeichen weiter zählen -> verschlüsselt mit D


also du verschiebst das Alphabet sozusagen und zum entschlüsseln braucht der andere die Zufallszahl um die Verschiebung des Alphabets dann auch zu haben um den "Algorithmus" umzudrehen

also vignere Chiffre auf einfach erklärt 😀
 
Sehr einfach ist auch Rot13.
Das ist sogar in einigen Texteditoren eingebaut (per Menü auf den aktuell editierten Text aufrufbar).
 
Was eventuell auch eine gute Uebung in mehrere Hinsicht ist, ist das XORen von CodePoints mit einem zufaelligen Wert.

Also als Grundprinzip kannst du dir aneignen dass ein String nicht aus Bytes oder Characters besteht, sondern aus Unicode CodePoints, welche bei UTF-8 eine Laenge von 1 bis 4 Byte haben koennen. Als Wissen so nebenher, intern innerhalb der JVM werden Strings als UTF-16 gehandhabt, beziehungsweise seit einer neueren Version als LATIN-1, wenn es die verwendeten Zeichen zulassen. Dabei geht es aber nur um Speicherverbrauch innerhalb der JVM. Die Represaentation welche du bekommst wenn du zum Beispiel "String.getBytes(Charset)" aufrufst, entspricht dem gewaehlten Charset Parameter. Das gilt so nicht fuer "String.codePointAt(int)", welches dir immer den Unicode-CodePoint an der gegebenen Position als 4-Byte (int) liefert. Das ist wichtig zu wissen weil ein Character (char) nicht den vollen Unicode-Wertebereich halten kann. Also wenn du "String.charAt" aufrufst, weisz ich ehrlich gesagt gar nicht was passiert wenn an der Stelle ein Zeichen ist welches nicht in einem "char" darstellbar ist, kann auf jeden Fall nichts gutes sein. Daher, Strings immer als Abfolgen von 4-Byte CodePoints behandeln.

Mit diesem Wissen bewaffnet, koenntest du dir nun die CodePoints holen (welche immer 4-Byte lang sind) und diese zum Beispiel mit einem (zufaelligen) 4-Byte int Wert XORen. Damit kann man die Nachricht nur wieder lesbar machen wenn dieser int Wert bekannt ist. Da "int" aber "nur" einen Wertebereich von 4 Milliarden Werten hat, kann man das sogar getrost brute-forcen auf jedem beliebigen Rechner. Also wenn du das implementiert hast, wurde ich sagen du gehst einen Schritt weiter, und verwendest als Schluessel einen "long". Das bedeutet du musst den CodePoint am Index 0 mit dem ersten 4 Bytes in deinem "long" XORen, und dann den CodePoint am Index 1 mit den zweiten 4 Bytes, und den naechsten CodePoint wieder mit dem ersten Byte, und so weiter. Damit wird es schonmal schwieriger den richtigen Wert zu finden. Das kannst du dann auch fuer beliebige Schluesselweiten implementieren, und auch zum Beispiel Padding hinzunehmen, oder anfangen die Byte-Werte vor dem verschluesseln um eine bestimmte Anzahl an Bits zu verschieben, zum Beispiel mit einem zweiten Schluessel, und so weiter.

Das ist aber immer noch relativ einfach zu brechen, denn die Schwierigkeit pro 4-Byte hat sich ja nicht erhoeht. Von hier aus driftet man dann schnell in die "richtige" Kryptographie-Schiene, und vermutlich waere hier ein guter Einstieg DES, welches dann auf einem 32-Byte Wert arbeitet, anstelle eines 4-Byte Werts (also es werden 32-Byte am Stueck verschluesselt, anstelle der einzelnen 4-Byte). Da kann ich aber leider keine Erklaerungen mehr abgeben, ich habe mich nie eingehend damit beschaeftig (ich verwende solche Sache nur, ich mache primaer ERPs).
 
Danke für die Hilfe, ich bin schon ziemlich weit.
Ich melde mich später mit meinem fertigen Code, habe aktuell eine Zwischenfrage.
Ich möchte zu meinem String einen char anhängen mit StringBuilder Append.
Akzeptiert dieser nur Strings oder auch chars?
 
Schau Dir einfach die Klasse an: Java 15 String Builder oder so in Google suchen oder die Doku runter laden und entpacken ...

StringBuilder (Java SE 15 & JDK 15)

declaration: module: java.base, package: java.lang, class: StringBuilder
docs.oracle.com

Und um die Frage zu beantworten: Ja, es gibt auch ein aop3nd, das einen char als Parameter hat.
 
Ich bekomme eine NullPointerException und weiß nicht wie ich die Fehlermeldung interpretieren soll, gerade in Bezug auf die ZeilenNummern.

Der Code wird noch bereinigt
[CODE lang="java" title="Main Klasse"]package com.crypt;

public class m {

public static void main(String[] args) {
Crypt c = new Crypt("Test");
}
}
[/CODE]

[CODE lang="java" title="Klasse Crypt"]package com.crypt;

import java.util.Random;


public class Crypt {
private String unencrypted;
private String encrypted;
private final int key;
private final int length;
private int createdKey;
private Random rnd;
private int [] keyArray;
private char[] unencryptedCharArray;


public Crypt(String password, int key){
this.unencrypted = password;
this.key = key;
this.length = this.unencrypted.length();
rnd = new Random();
unencryptedCharArray = this.unencrypted.toCharArray(); //(String in char array umzuwandeln)
this.encrypted=crypt(unencryptedCharArray);
}

public Crypt(String password){
this.unencrypted = password;
this.length=this.unencrypted.length();
rnd = new Random();
this.key = createKey();
unencryptedCharArray = this.unencrypted.toCharArray(); //(String in char array umzuwandeln)
this.encrypted=crypt(unencryptedCharArray);
}


private int createKey(){
int tempKey = rnd.nextInt(10);
for(int i=0; i<this.length-1; i++){
tempKey*=10;
tempKey+=rnd.nextInt(10);
System.out.println (tempKey);
}
return tempKey;
}

private int[] intToDigit(int key){
int key2 = key;
keyArray = new int[length];//Neues Array mit Länge des Strings
for (int i=length-1; i>0-1; i--){
keyArray=key2%10;
key2=key2/10;//key in Ziffern aufteilen
}
return keyArray;
}

private String crypt(char[] unencryptedCharArray){
for (int i=0; i<this.length; i++){
unencryptedCharArray+=this.keyArray;
}
String encrypted = new String(unencryptedCharArray);
StringBuilder encrypted2 = new StringBuilder(encrypted);
int maxChars = 16;
int charsToAdd = maxChars - length;
for (int i=0; i<charsToAdd; i++){
encrypted2.append(unencryptedCharArray[rnd.nextInt(length)]);
}
String encrypted3 = encrypted2.toString();
return encrypted3;
//Verschlüsselung anhand des Keys
}



}[/CODE]
 
Hag2bard hat gesagt.:
Ich bekomme eine NullPointerException und weiß nicht wie ich die Fehlermeldung interpretieren soll, gerade in Bezug auf die ZeilenNummern.

Der Code wird noch bereinigt
[CODE lang="java" title="Main Klasse"]package com.crypt;

public class m {

public static void main(String[] args) {
Crypt c = new Crypt("Test");
}
}
[/CODE]

[CODE lang="java" title="Klasse Crypt"]package com.crypt;

import java.util.Random;


public class Crypt {
private String unencrypted;
private String encrypted;
private final int key;
private final int length;
private int createdKey;
private Random rnd;
private int [] keyArray;
private char[] unencryptedCharArray;


public Crypt(String password, int key){
this.unencrypted = password;
this.key = key;
this.length = this.unencrypted.length();
rnd = new Random();
unencryptedCharArray = this.unencrypted.toCharArray(); //(String in char array umzuwandeln)
this.encrypted=crypt(unencryptedCharArray);
}

public Crypt(String password){
this.unencrypted = password;
this.length=this.unencrypted.length();
rnd = new Random();
this.key = createKey();
unencryptedCharArray = this.unencrypted.toCharArray(); //(String in char array umzuwandeln)
this.encrypted=crypt(unencryptedCharArray);
}


private int createKey(){
int tempKey = rnd.nextInt(10);
for(int i=0; i<this.length-1; i++){
tempKey*=10;
tempKey+=rnd.nextInt(10);
System.out.println (tempKey);
}
return tempKey;
}

private int[] intToDigit(int key){
int key2 = key;
keyArray = new int[length];//Neues Array mit Länge des Strings
for (int i=length-1; i>0-1; i--){
keyArray=key2%10;
key2=key2/10;//key in Ziffern aufteilen
}
return keyArray;
}

private String crypt(char[] unencryptedCharArray){
for (int i=0; i<this.length; i++){
unencryptedCharArray+=this.keyArray;
}
String encrypted = new String(unencryptedCharArray);
StringBuilder encrypted2 = new StringBuilder(encrypted);
int maxChars = 16;
int charsToAdd = maxChars - length;
for (int i=0; i<charsToAdd; i++){
encrypted2.append(unencryptedCharArray[rnd.nextInt(length)]);
}
String encrypted3 = encrypted2.toString();
return encrypted3;
//Verschlüsselung anhand des Keys
}



}[/CODE]
Zum Vergrößern anklicken....

kannst du die NPE rein kopieren da steht im Regelfall die Stelle des Fehlers drinnen
 
[CODE lang="java" title="Exception"]72
723
7238
java.lang.NullPointerException: Attempt to read from null array
at com.crypt.Crypt.crypt(Crypt.java:58)
at com.crypt.Crypt.<init>(Crypt.java:32)
at com.crypt.m.main(m.java:6)
at java.lang.reflect.Method.invoke(Native Method)
at com.duy.android.compiler.java.Java.run(Java.java:115)
at com.duy.ide.javaide.run.activities.ExecuteActivity.executeDex(ExecuteActivity.java:147)
at com.duy.ide.javaide.run.activities.ExecuteActivity.exec(ExecuteActivity.java:124)
at com.duy.ide.javaide.run.activities.ExecuteActivity.access$100(ExecuteActivity.java:45)
at com.duy.ide.javaide.run.activities.ExecuteActivity$1.run(ExecuteActivity.java:88)
at java.lang.Thread.run(Thread.java:764)
[/CODE]
 
Java: 
java.lang.NullPointerException: Attempt to read from null array
das ist die Zeile die dich interessiert "Versuch von einem null array zu lesen" dh du hast ein Array noch nicht gesetzt

jetzt ist es dein Ziel zu finden welches array null ist
und warum es ab diesen Zeitpunkt über haupt noch null ist

du hast drüber deine 72 723 7238 .. ja Noch geschafft ab dann greifst du irgendwo auf ein Array zu => dh der Fehler muss nach dem berechnen der 3 Zahlen passiert sein .. das schränkt deine Fehler Zone ziemlich ein
 
Java: 
Exception in thread "main" java.lang.NullPointerException: Cannot load from int array because "this.keyArray" is null
    at finalGame1/application.Main.crypt(Main.java:70)
    at finalGame1/application.Main.<init>(Main.java:44)
    at finalGame1/application.Main.main(Main.java:27)
ich habe es schnell in Eclipse zusammen gebaut ... ka was du bneutzt aber bei mir kommt da schon was genaueres raus WIESO auch immer..

this.keyArray is null.. warum und weshalb ist dein Job 😀

PS: dass es main heist ist unwichtig da meine Klasse nicht Crypt sondern main heist
 
Welche Methode setzt dir denn das keyArray.... und noch eine Frage... wann rufst du die Methode auf...(bei mir steht da "never used") 😉



Wenn du das gefunden hast:
in dieser "methode" hast du ein return drin das dir das key array zurück liefert obwohl du es im Objekt eh schon gesetzt hast in der methode....
 
jetzt hast du noch ein weiteres Problem ...

Du verschlüsselst einmal was was .. soweit ja noch in Produktion ist ergo OK

was noch nicht passt ist -> du hast keine Methode wo du das Objekt von aussen benutzen kannst dh

für jede Verschlüsselung brauchst du ein Neues Crypt Objekt ... es würde aber reichen
-> Neuen String setzen zum verschlüsseln
(-> neuen Key generieren lassen .. nicht unbedingt )
-> verschlüsseln starten

das musst du noch richtig verpacken... jedoch überschneidet sich das mit deinen Finals ( es ist schön dass du finals benutzt)
dein length ist final -> und ist die Länge deines Übergebenen Strings -> soweit OK
dein String Wort ist nicht Final -> dh im nachhinein veränderbar = es passt nicht mehr mit der Final Länge zusammen


dass dein key 1 Mal ausgewürfelt wird und dann final ist kann man als ok betrachten... kommt von der Intention her wie man es möchte



dir ist das Problem wahrscheinlich noch nicht aufgefallen weil du noch nicht so weit warst aber da wirst du noch in das Problem laufen sobald du diese Situation hast

array aus Strings die Verschlüsselt werden möchten

1 Verschlüsselungs Objekt das durch alle durch geht und alle vershclüsselt

so wie es im Moment ist müsstest du bei 1000 Wörtern 1000 Vershclüsselungs Objekte erzeugen die nur den String unterschiedlich haben -> nicht gerade nicer dicer
 
Zuletzt bearbeitet von einem Moderator:
Java: 
    public Main(String password, int key){
    this(password);
    this.key = key;
    }

    public Main(String password){
    this.unencrypted = password;
    this.length=this.unencrypted.length();
    rnd = new Random();
 
    this.key = createKey();
    unencryptedCharArray = this.unencrypted.toCharArray(); //(String in char array umzuwandeln)
    System.out.println(" Hi"+this.keyArray );
    this.encrypted=crypt(unencryptedCharArray);
    }
Noch eine Anekdote... DIE MAN NICHT MACHEN MUSS

dein Konstruktor password key unterscheidet sich nur darin dass ein Key gesetzt wird
mit this(Argumente) rufst du den Konstruktor im Objekt auf der zu den Argumenten passt ... jedoch überschneidet sich das mit deinem final Key....


Da wurden halt in deinem Code mehrere verschiedene Wege eingeschlagen die alle Richtig sind aber ganz zusammen passen um 1 Ziel zu verfolgen... das ist noch nicht ganz da 😀
 
Zuletzt bearbeitet von einem Moderator:
Mart hat gesagt.:
dein Konstruktor password key unterscheidet sich nur darin dass ein Key gesetzt wird
mit this(Argumente) rufst du den Konstruktor im Objekt auf der zu den Argumenten passt ... jedoch überschneidet sich das mit deinem final Key....
Zum Vergrößern anklicken....
Ich persönlich halte den umgekehrten Weg für schöner:
Java: 
public Crypt(String password) {
    this(password, createKey()); // ruft den zweiten Konstruktor mit den gewünschten Werten auf
}

public Crypt(String password, int key) {
    unencrypted = password;
    this.key = key;
    length = this.unencrypted.length();
    rnd = new Random();
    unencryptedCharArray = this.unencrypted.toCharArray(); //(String in char array umzuwandeln)
    encrypted=crypt(unencryptedCharArray);
}
 
temi hat gesagt.:
Ich persönlich halte den umgekehrten Weg für schöner:
Java: 
public Crypt(String password) {
    this(password, createKey()); // ruft den zweiten Konstruktor mit den gewünschten Werten auf
}

public Crypt(String password, int key) {
    unencrypted = password;
    this.key = key;
    length = this.unencrypted.length();
    rnd = new Random();
    unencryptedCharArray = this.unencrypted.toCharArray(); //(String in char array umzuwandeln)
    encrypted=crypt(unencryptedCharArray);
}
Zum Vergrößern anklicken....
ich war da nicht mehr in so einer Nüchternen Lage das gebakcen zu kriegen... dein weg ist schon besser .. vorallem weil es nicht gegen seinen Final Key(den der TE haben möchte) verstößt und meins schon
 
Ich hab das jetzt alles ein wenig abgeändert, mein Konstruktor ist fast leer.
Die decrypt Methode ist noch unsauber und unleserlich. Beim ermitteln der Länge des Keys würde ich gerne in einen String casten und dann mit getLength die Länge ermitteln aber das soll ja unperformant sein.

[CODE lang="java" title="Crypt Klasse"]package com.crypt;

import java.util.Random;
public class Crypt2 {


private String unencrypted;//Passwort nicht verschlüsselt
private String encrypted;
//private String decrypted;
private int key;
private int length;
private Random rnd;
private int [] keyArray;
private char[] unencryptedCharArray;
private char[] decryptedCharArray;
private String decryptedPassword;

public Crypt2(){
rnd = new Random();
}

public String encrypt(String password, int key){
this.unencrypted = password;
this.key = key;
intToDigit(this.key);
this.length = this.unencrypted.length();
unencryptedCharArray = this.unencrypted.toCharArray(); //(String in char array umzuwandeln)
this.encrypted=crypt(unencryptedCharArray);
return this.encrypted;

}

public String encrypt(String password){
this.unencrypted = password;
this.length=this.unencrypted.length();
this.key = createKey();
intToDigit(this.key);
unencryptedCharArray = this.unencrypted.toCharArray(); //(String in char array umzuwandeln)
this.encrypted=crypt(unencryptedCharArray);
System.out.println (this.key);
return this.encrypted;
}


private int createKey(){
int tempKey = rnd.nextInt(10);
for(int i=0; i<this.length-1; i++){
tempKey*=10;
tempKey+=rnd.nextInt(10);
System.out.println (tempKey);
}
return tempKey;
}

private void intToDigit(int key){
int key2 = key;
keyArray = new int[length];//Neues Array mit Länge des Strings
for (int i=length-1; i>0-1; i--){
keyArray=key2%10;
key2=key2/10;//key in Ziffern aufteilen
}

}

private String crypt(char[] unencryptedCharArray){
for (int i=0; i<this.length; i++){
unencryptedCharArray+=this.keyArray;
}
String encrypted = new String(unencryptedCharArray);
StringBuilder encrypted2 = new StringBuilder(encrypted);
int maxChars = 16;
int charsToAdd = maxChars - length;
for (int i=0; i<charsToAdd; i++){
encrypted2.append(unencryptedCharArray[rnd.nextInt(length)]);
}
String encrypted3 = encrypted2.toString();
return encrypted3;
//Verschlüsselung anhand des Keys
}
public String getEncrypted(){
return this.encrypted;
}

public String decrypt(String decrypted, int key){
this.decryptedPassword = decrypted;
this.key = key;

this.length = getIntLength(key);
intToDigit(this.key);
String passwordDecrypted = this.decryptedPassword.substring(0, this.length);
// string kürzen
decryptedCharArray = passwordDecrypted.toCharArray(); //(String in char array umzuwandeln)
for (int i=0; i<this.length; i++){
decryptedCharArray-=keyArray;
}



String decryptedPassword = String.valueOf(decryptedCharArray);
return decryptedPassword;

}


private int getIntLength(int number) {

if (number < 100000) {
if (number < 100) {
if (number < 10) {
return 1;
} else {
return 2;
}
} else {
if (number < 1000) {
return 3;
} else {
if (number < 10000) {
return 4;
} else {
return 5;
}
}
}
} else {
if (number < 10000000) {
if (number < 1000000) {
return 6;
} else {
return 7;
}
} else {
if (number < 100000000) {
return 8;
} else {
if (number < 1000000000) {
return 9;
} else {
return 10;
}
}
}
}



}
}

[/CODE]
 
Java: 
package com.crypt;

import java.util.Random;
public class Crypt2 {


private String unencrypted;//Passwort nicht verschlüsselt
private String encrypted;
//private String decrypted;
private int key;
private int length;
private Random rnd = new Random(); // Kannst du sofort erstellen.. muss nicht im Konstruktor erfolgen erzeugt nur 1 Zeile mehr an Code
private int [] keyArray;
private char[] unencryptedCharArray;
private char[] decryptedCharArray;
private String decryptedPassword;

public Crypt2(){
this(createKey);
}
public Crypt2(int key){
this.key = key;
}



////////////////////////////////////////////////////////////////////////////////////////////////////
//// hier hast du schon wieder doppelten Code -> verkürzbar
//// der einzige Unterschied ist dass beim einen der Key übergeben werden kann und beim anderen nicht
//// jedoch sollte während der Verschlüsselung der Key geändert werden?? -> Nein ansonsten kann man nicht mehr Entschlüsseln
//// eig brauchst du lediglich die public String encrypt(String password){ ... }
public String encrypt(String password, int key){
this.unencrypted = password;
this.key = key;
intToDigit(this.key);
this.length = this.unencrypted.length();
unencryptedCharArray = this.unencrypted.toCharArray(); //(String in char array umzuwandeln)
this.encrypted=crypt(unencryptedCharArray);
return this.encrypted;

}

public String encrypt(String password){
this.unencrypted = password;
this.length=this.unencrypted.length();
this.key = createKey();
intToDigit(this.key);
unencryptedCharArray = this.unencrypted.toCharArray(); //(String in char array umzuwandeln)
this.encrypted=crypt(unencryptedCharArray);
System.out.println (this.key);
return this.encrypted;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

private int createKey(){
  int tempKey = rnd.nextInt(10);
  for(int i=0; i<this.length-1; i++){
  tempKey*=10;
  tempKey+=rnd.nextInt(10);
  System.out.println (tempKey);
  }
  return tempKey;
}

private void intToDigit(int key){
///// "key2 = key;" ist komplett nichts sagend ... ja schön dass man jetzt zwei hat :D
  int key2 = key;
  keyArray = new int[length];//Neues Array mit Länge des Strings
 for (int i=length-1; i>0-1; i--){
   keyArray[i]=key2%10;
   key2=key2/10;//key in Ziffern aufteilen
   }
 
}

private String crypt(char[] unencryptedCharArray){
  for (int i=0; i<this.length; i++){
    unencryptedCharArray[i]+=this.keyArray[i];
    }
    String encrypted = new String(unencryptedCharArray);
    StringBuilder encrypted2 = new StringBuilder(encrypted);
    int maxChars = 16;
    int charsToAdd = maxChars - length;
    for (int i=0; i<charsToAdd; i++){
     encrypted2.append(unencryptedCharArray[rnd.nextInt(length)]);
  }
  String encrypted3 = encrypted2.toString();
  return encrypted3;
  //Verschlüsselung anhand des Keys
}
public String getEncrypted(){
  return this.encrypted;
}

public String decrypt(String decrypted, int key){
this.decryptedPassword = decrypted;
this.key = key;

this.length = getIntLength(key);
intToDigit(this.key);
String passwordDecrypted = this.decryptedPassword.substring(0, this.length);
// string kürzen
decryptedCharArray = passwordDecrypted.toCharArray(); //(String in char array umzuwandeln)
for (int i=0; i<this.length; i++){
    decryptedCharArray[i]-=keyArray[i];
  }
 
 
 
  String decryptedPassword = String.valueOf(decryptedCharArray);
return decryptedPassword;

}

////// hä ?
private int getIntLength(int number) {
               
if (number < 100000) {
    if (number < 100) {
        if (number < 10) {
            return 1;
        } else {
            return 2;
        }
    } else {
        if (number < 1000) {
            return 3;
        } else {
            if (number < 10000) {
                return 4;
            } else {
                return 5;
            }
        }
    }
} else {
    if (number < 10000000) {
        if (number < 1000000) {
            return 6;
        } else {
            return 7;
        }
    } else {
        if (number < 100000000) {
            return 8;
        } else {
            if (number < 1000000000) {
                return 9;
            } else {
                return 10;
            }
        }
    }
}



}
}

habe versucht ein Paar Anmerkungen zu machen
 
Also erstmal zur Methode getIntLength:
Beim Verschlüsseln hängt er noch ein paar Zeichen an den verschlüsselten String, damit man nicht weiß wie lang das eigentliche Passwort ist. Wenn ich einen Key und dieses verschlüsselte Passwort habe, weiß er anhand der Länge des Keys, wie viele Zeichen das Passwort ursprünglich hatte.

Wenn ich z.b. ein Passwort habe mit 3 Zeichen, z.b. "tst" und man das anhand des verschlüsselten Strings sehen könnte, könnte man durch Bruteforcing sehr schnell Erfolg haben.

So war zumindest mein Gedankengang.
Ich versuche jetzt noch die ganzen Anmerkungen umzusetzen, danke dafür.
Man könnte mit einem eigenen Schlüssel encrypten, deshalb habe ich die Methode überladen.

Mein nächster Schritt wäre, da hab ich mir noch keine Gedanken gemacht, es hinzubekommen, dass man nicht nur verschlüsselen und entschlüsseln kann sondern auch eine Art Passwortabfrage zu erstellen.
Im Zeitalter von PayPal, Online Banking und den vielen empfindlichen Daten im Internet, wird meine Lösung wahrscheinlich lachhaft, aber mir geht es darum etwas zu lernen in kleinen Schritten.
 
Hag2bard hat gesagt.:
Man könnte mit einem eigenen Schlüssel encrypten, deshalb habe ich die Methode überladen
Zum Vergrößern anklicken....
aber wenn du per Zufall einen Schlüssel erstellst ... was soll dann ein Mensch eingeben 1234? 😀
ICH würde es nicht zulassen wenn es die Nette Methode Create Key eh schon gibt

was halt gegeben sein muss .. meines Erachtens...
wenn man alles hat -> muss es schnell gehen
wenn man nicht alles hat -> muss man so viel Ausprobieren bis es die Sinnvolle Zeit überschreitet

Du kannst niemals ein Perfektes Passwort zusammenbauen...
Es macht jedoch einen Unterschied ob ein hacker 1 mio Jahre braucht oder 2 jahre um einen Schlüssel zu knacken

sobald es die Menschliche Lebenszeit übersteigt es zu knacken -> relativ sicher
 
Ich geh einfach mal von dem Szenario aus, dass ich Nachrichten verschlüsseln möchte, sagen wir mal mit einem festen Schlüssel pro Tag.
Dieser soll 7 Zeichen haben, damit er nicht so unendlich lang wird. Dieser wird dann für eine Nachricht mit 280 Zeichen verwendet. Alle 7 Zeichen wiederholt sich der Schlüssel, das wäre bei 280 Zeichen 40 mal.
Ich gebe also meinem Kollegen den Schlüssel persönlich jeden Morgen durch und so können wir uns Nachrichten hin und her schicken die mehr oder weniger verschlüsselt sind.
Das wäre z.b. eine Idee für eine Methode die keinen eigenen Key generiert.
Ich denke zumindest dass ich mich somit rechtfertigen kann. 😀


Hier noch mein optimierter Code, wenn ich Tipps ignoriert habe, dann ausversehen .

[CODE lang="java" title="Crypt2" highlight="82"]package com.crypt;

import java.util.Random;
public class Crypt2 {


private String unencrypted;//Passwort nicht verschlüsselt
private String encrypted;
private int key;
private int length;
private Random rnd = new Random();
private int [] keyArray;
private char[] unencryptedCharArray;
private char[] decryptedCharArray;
private String decryptedPassword;

public String encrypt(String password, int key){
this.unencrypted = password;
this.key = key;
intToDigit(this.key);
this.length = this.unencrypted.length();
unencryptedCharArray = this.unencrypted.toCharArray(); //(String in char array umzuwandeln)
this.encrypted=crypt(unencryptedCharArray);
return this.encrypted;
}

public String encrypt(String password){
this.length = password.length();
return encrypt(password, createKey());
}

private int createKey(){
int tempKey = rnd.nextInt(10);
for(int i=0; i<this.length-1; i++){
tempKey*=10;
tempKey+=rnd.nextInt(10);
System.out.println (tempKey);
}
return tempKey;
}

private void intToDigit(int key){
keyArray = new int[length];//Neues Array mit Länge des Strings
for (int i=length-1; i>0-1; i--){
keyArray=key%10;
key=key/10;//key in Ziffern aufteilen
}
}

private String crypt(char[] unencryptedCharArray){
for (int i=0; i<this.length; i++){
unencryptedCharArray+=this.keyArray;
}
String encrypted = new String(unencryptedCharArray);
StringBuilder encrypted2 = new StringBuilder(encrypted);
int maxChars = 16;
int charsToAdd = maxChars - length;
for (int i=0; i<charsToAdd; i++){
encrypted2.append(unencryptedCharArray[rnd.nextInt(length)]);
}
return encrypted2.toString();
}
public String getEncrypted(){
return this.encrypted;
}

public String decrypt(String decrypted, int key){
this.decryptedPassword = decrypted;
this.key = key;
this.length = getIntLength(key);
intToDigit(this.key);
String passwordDecrypted = this.decryptedPassword.substring(0, this.length);
// string kürzen
decryptedCharArray = passwordDecrypted.toCharArray(); //(String in char array umzuwandeln)
for (int i=0; i<this.length; i++){
decryptedCharArray-=keyArray;
}
String decryptedPassword = String.valueOf(decryptedCharArray);
return decryptedPassword;
}

private int getIntLength(int number) {
if (number < 100000) {
if (number < 100) {
if (number < 10) {
return 1;
} else {
return 2;
}
} else {
if (number < 1000) {
return 3;
} else {
if (number < 10000) {
return 4;
} else {
return 5;
}
}
}
} else {
if (number < 10000000) {
if (number < 1000000) {
return 6;
} else {
return 7;
}
} else {
if (number < 100000000) {
return 8;
} else {
if (number < 1000000000) {
return 9;
} else {
return 10;
}
}
}
}



}
}

[/CODE]

Soll ich die Länge eines int lieber anders ermitteln?
 
Zuletzt bearbeitet:
Hag2bard hat gesagt.:
Soll ich die Länge eines int lieber anders ermitteln?
Zum Vergrößern anklicken....
Ja, da das letzte Quentchen Performanz hier keine Rolle spielt, würde ich das entweder über die String-Länge oder über den Logarithmus lösen:
Java: 
public int digitsByString(int value) {
    return Integer.toString(value).length();
}
public int digitsByLog(int value) {
    return (int) Math.log10(value) + 1;
}
digitsByLog setzt voraus, dass value > 0 gilt. Ist das nicht sichergestellt, kannst Du die Methode natürlich um entsprechende Prüfungen erweitern.

Kryptisch an Deiner Verschlüsselung ist allerdings vor allem Dein Code 🙂 Was willst Du mit diesen ganzen Instanzvariablen? Was haben die mit einem Passwort zu tun? Du verschlüsselst doch einen beliebigen Text, der halt zufällig auch ein Passwort sein kann. Warum verwendest Du einen int als Schlüssel? Wieso gibt der Schlüssel vor, wie lang der zu verschlüsselnde Text sein darf/kann? Warum ist maxChars eine Variable und warum heißt die nicht minChars oder vielleicht minLength (bzw. als Konstante MIN_LENGTH)?
 
Hag2bard hat gesagt.:
Ich geh einfach mal von dem Szenario aus, dass ich Nachrichten verschlüsseln möchte, sagen wir mal mit einem festen Schlüssel pro Tag.
Zum Vergrößern anklicken....
Ich kann mich @mihe7 nur anschließen. Die Klasse und die Menge an Instanzvariablen erscheinen mir auch etwas durcheinander.

Im ersten Schritt solltest du dir überlegen, wie ein Benutzer deiner Klasse diese verwenden möchte und dir über eine saubere und einheitliche Schnittstelle Gedanken machen. Schnittstelle meint dabei die öffentlichen Methoden, die zur Verfügung stehen. Dafür sollte man viel Sorgfalt walten lassen, denn die Schnittstelle lässt sich i. d. R. später nicht mehr ändern, ohne Brüche zu erzeugen. Stell dir vor, viele Programmiere nutzen deine Klasse und dann kommst du auf die Idee in einer neuen Version, die Schnittstelle zu ändern. Alle bis dahin geschriebenen Programme wären dann nicht mehr ohne weiteres mit der neuen Version verwendbar.

Ich finde es schon etwas seltsam, dass die Methoden crypt() und decrypt() unterschiedliche Parametertypen haben. Das ist nicht sehr benutzerfreundlich. Zudem gibt es dann noch die Methoden encrypt(), die vom Namen suggerieren, dasselbe zu tun wie crypt(). Das ist nicht intuitiv.

Eine einfache Schnittstelle könnte folgendermaßen aussehen:
Java: 
public class Crypt {
 
    public String encrypt(String unencrypted, String key) {
        // todo
    }
 
    public String decrypt(String encrypted, String key) {
        // todo
    }
 
    // optional Schlüsselerzeugung mit fest vorgegebener Schlüssellänge
    public String getRandomKey() {
        // todo
    }
 
    // optional Schlüsselerzeugung mit wählbarer Schlüssellänge
    public String getRandomKey(int length) {
        // todo
    }
}


// Verwendung

Crypt crypt = new Crypt();

String key = crypt.getRandomKey(); // zu faul, sich selbst einen Schlüssel auszudenken
String secret = crypt.encrypt("Mein zu verschlüsselnder Text", key);

Das kann man noch ergänzen um einen Konstruktor (oder Setter), um das Verschlüsselungsverfahren einzustellen, das Schlüsselalphabet festzulegen, u. v. m.

Wenn du noch etwas für dich tun möchtest, dann kann ich dir das Buch "Effective Java" von Bloch empfehlen. Da sind viele Tipps mit ausführlichen Erklärungen aufgeführt, welche die Qualität von Software verbessern. Die Beschäftigung mit SOLID halte ich auch für sinnvoll, auch wenn das vielleicht noch etwas zu früh für dich ist. Andererseits ist es gut, sich von Anfang an guten Stil zu gewöhnen, dann muss man sich schlechten Stil erst gar nicht wieder abgewöhnen. 😉
 
Zuletzt bearbeitet:
Super danke für den Tipp.
Ich bin gerade dran das Programm nochmal in Ruhe neu zu schreiben.
Nebenbei schau ich mal Effective Java rein.
 
es macht sc
temi hat gesagt.:
Ich kann mich @mihe7 nur anschließen. Die Klasse und die Menge an Instanzvariablen erscheinen mir auch etwas durcheinander.

Im ersten Schritt solltest du dir überlegen, wie ein Benutzer deiner Klasse diese verwenden möchte und dir über eine saubere und einheitliche Schnittstelle Gedanken machen. Schnittstelle meint dabei die öffentlichen Methoden, die zur Verfügung stehen. Dafür sollte man viel Sorgfalt walten lassen, denn die Schnittstelle lässt sich i. d. R. später nicht mehr ändern, ohne Brüche zu erzeugen. Stell dir vor, viele Programmiere nutzen deine Klasse und dann kommst du auf die Idee in einer neuen Version, die Schnittstelle zu ändern. Alle bis dahin geschriebenen Programme wären dann nicht mehr ohne weiteres mit der neuen Version verwendbar.

Ich finde es schon etwas seltsam, dass die Methoden crypt() und decrypt() unterschiedliche Parametertypen haben. Das ist nicht sehr benutzerfreundlich. Zudem gibt es dann noch die Methoden encrypt(), die vom Namen suggerieren, dasselbe zu tun wie crypt(). Das ist nicht intuitiv.

Eine einfache Schnittstelle könnte folgendermaßen aussehen:
Java: 
public class Crypt {
 
    public String encrypt(String unencrypted, String key) {
        // todo
    }
 
    public String decrypt(String encrypted, String key) {
        // todo
    }
 
    // optional Schlüsselerzeugung mit fest vorgegebener Schlüssellänge
    public String getRandomKey() {
        // todo
    }
 
    // optional Schlüsselerzeugung mit wählbarer Schlüssellänge
    public String getRandomKey(int length) {
        // todo
    }
}


// Verwendung

Crypt crypt = new Crypt();

String key = crypt.getRandomKey(); // zu faul, sich selbst einen Schlüssel auszudenken
String secret = crypt.encrypt("Mein zu verschlüsselnder Text", key);

Das kann man noch ergänzen um einen Konstruktor (oder Setter), um das Verschlüsselungsverfahren einzustellen, das Schlüsselalphabet festzulegen, u. v. m.

Wenn du noch etwas für dich tun möchtest, dann kann ich dir das Buch "Effective Java" von Bloch empfehlen. Da sind viele Tipps mit ausführlichen Erklärungen aufgeführt, welche die Qualität von Software verbessern. Die Beschäftigung mit SOLID halte ich auch für sinnvoll, auch wenn das vielleicht noch etwas zu früh für dich ist. Andererseits ist es gut, sich von Anfang an guten Stil zu gewöhnen, dann muss man sich schlechten Stil erst gar nicht wieder abgewöhnen. 😉
Zum Vergrößern anklicken....
In einer Gewissen Sicht habt ihr Recht nur @Hag2bard lernt erst noch und da zu fordern
performanten Code
Schönen Code
gleichzeitig zu schreiben ist zu viel verlangt...

erst sollte es funktionieren und dann Ausbessern um es ZU LERNEN ...

Es geht bei dem verschlüsseln um den Mehr wert... und der ist meines Erachtens dann groß wenn man Code schreibt und die Logik versteht und im Nachhinein den Code verbessert.. dann geht "ein Lichtlein auf" ... nur das Parallel mit der Logik gebacken zu kriegen ist einfach zu viel verlangt
 
Mart hat gesagt.:
nur @Hag2bard lernt erst noch und da zu fordern
Zum Vergrößern anklicken....
Naja, wir "fordern" ja nichts.

Er hatte in einem anderen Thema geschrieben, dass er sich seit einiger Zeit mit Java beschäftigt und sich jetzt, vor seiner Ausbildung, noch weiter vorbereiten möchte.

Gerade ein so übersichtliches Projekt, welches nur aus einer einzigen Klasse besteht, kann man doch hervorragend dazu hernehmen, um Clean Code und guten Programmierstil erst mal nur auf Klassenebene zu erläutern und zu üben. Die Anmerkungen waren ja auch nicht böse gemeint. Und wie schon oben geschrieben: Was man gleich richtig lernt, muss man sich später nicht mehr abgewöhnen.

Auch wenn er vielleicht auf Anhieb nicht alles versteht, was in Effective Java steht oder die SOLID-Prinzipien im einzelnen bedeuten, so hat er dann zumindest schon mal davon gehört. Und mit der Zeit kommt Verständnis und Erkenntnis.
 
Danke nochmals für alle Antworten. Ich bin gerade dabei den Code neu zu entwerfen und verstehe auch wieso ein String für den Key besser geeignet ist. Dazu wurde mir ja geraten.
Jetzt ist meine Frage.
Ich habe ein StringBuilder Objekt mit dem generieren Key. Welchen Weg gehe ich am besten um ihn zu einzelnen Ziffern zu konvertieren ?
Soll ich ihn in einen String casten und davon dann mit einer Schleife die einzelnen Zeichen in ein char Array umwandeln und dieses dann in ein Int Array umzuwandeln oder welchen Weg geht man da?
 
Ich hätte da nochmal eine Frage zum Programmierstil.
Ich habe eine Methode die mir einen StringBuilder-Objekt aus Zahlen zusammensetzt.
Diese Methode ist wieder verwendbar, deshalb hat sie einen StringBuilder als Rückgabe Wert.
Ich habe den StringBuilder aber bereits als Klassenvariable instanziiert, weshalb es hier in diesem Fall eigentlich überflüssig wäre einen StringBuilder zu returnen.

Java: 
package com.crypt;

import java.util.Random;


public class Crypt3 {
private String unencrypted;
private int length;
private StringBuilder randomKey;
private Random rnd = new Random();

public String encrypt(String unencrypted){
  this.unencrypted = unencrypted;
  this.length = unencrypted.length();
  getRandomKey(this.length);
  char[] unencryptedAsCharArray = this.unencrypted.toCharArray();
  for (int i=0; i<this.length; i++){
     unencryptedAsCharArray[i]+=randomKey.charAt(i);
  }
  return String.valueOf(unencryptedAsCharArray);
}

public StringBuilder getRandomKey(int length){
randomKey = new StringBuilder(this.length);
for (int i=0; i<length; i++){
  randomKey.append(rnd.nextInt(10));
  }
  return randomKey;
}
//decrypt


}

Soll ich in der Methode encrypt aus Stil-Gründen den Rückgabewert der getRandomKey Methode tatsächlich verwenden und die Instanzvariable raus hauen?
Sprich, Ich erstelle ein StringBuilder Objekt in der getRandomKey Methode. Dieser wird an die encrypt Methode zurückgegeben.
Diese erstellt ein StringBuilder Objekt und weißt ihr den Rückgabe Wert von der getRandomKey Methode zu?

2. Frage: Soll ich in der getRandomKey Methode den StringBuilder zum String umwandeln und diesen zurückgeben?
 
Zuletzt bearbeitet:
Java: 
package crypto;

import java.util.Random;

public class Crypt {
    private static final Random randomNumberGenerator = new Random();
  
    private String unencrypted;
    private StringBuilder randomKey;
    private int unecryptedLength;
  
    public Crypt() {
    }
  
    public Crypt(String unencrypted) {
        this.unencrypted = unencrypted;
    }
    public String autoEncrypt() {
         this.setUnecryptedLength();
         this.generateRandomKey();
         return encryptPassword();
    }
  
    private String encryptPassword(){
      char[] unencryptedAsCharArray = this.unencrypted.toCharArray();
  
      for (int i=0; i<unecryptedLength; i++) {
          unencryptedAsCharArray[i]+=randomKey.charAt(i);
      }
  
      return String.valueOf(unencryptedAsCharArray);
    }
  
    private void generateRandomKey() {
        this.randomKey = new StringBuilder(this.unecryptedLength);
        for (int i=0; i<this.unecryptedLength; i++) {
            randomKey.append(randomNumberGenerator.nextInt(10));
        }
    }
  
    //decrypt
  
  
    public void setUnencrypted(String unencrypted) {
        this.unencrypted = unencrypted;
    }
    private void setUnecryptedLength() {
        this.unecryptedLength = unencrypted.length();
    }
}
Ich habe versucht paar Sachen zu ändern ... es wirft mir auch das aus ¢¤£ als Zeichen also anscheinend funktioniert es auch ... ich hoffe ich hab nix wichtiges gelöscht oder etwas von deinem Code durcheinander gebracht


auch wenn immer noch nicht alles optimal ist... ich möchte nicht komplett bei deinem Code dazwischen funken ... es sollte ja nach der Verbeserung immer noch dein Code sein im Ganzen

wenn du fragen hast warum ich was gemacht hab kannst du sie ja stellen udn copy paste ist nicht angebracht sondern drüber lesen und überlegen warum und weshalb
 
Zuletzt bearbeitet von einem Moderator:
Im Grunde genommen habe ich keine Fragen zu deinem Code. Ich finde das weitere Aufteilen in Methoden gut , dass muss ich unbedingt verinnerlichen.
Dann hätte ich aber eine Frage:

Wieso hat der Scanner ein private als Zugriffsmodifkator, wenn er static ist?
 
Hag2bard hat gesagt.:
Im Grunde genommen habe ich keine Fragen zu deinem Code. Ich finde das weitere Aufteilen in Methoden gut , dass muss ich unbedingt verinnerlichen.
Dann hätte ich aber eine Frage:

Wieso hat der Scanner ein private als Zugriffsmodifkator, wenn er static ist?
Zum Vergrößern anklicken....
weil die Random Konstante niemanden ausserhalb angeht static heist ja nur dass es beim kompilieren erzeugt wird und jedes neue objekt auf den Gleichen generator zugreift
 
Mart hat gesagt.:
static heist ja nur dass es beim kompilieren erzeugt wird
Zum Vergrößern anklicken....
Das ist so natürlich falsch. Static bedeutet, daß die Variable zur Klasse gehört und nicht zu einer Instanz. Und die Initialisierung wird durchgeführt, wenn die Klasse geladen wird (Die Class Instanz für die Klasse erzeugt wird).
 
was überhaupt noch nicht betrachtet wurde ist vererbung... also aus private protected machen wo es nötig ist bzw gebraucht wird
bzw wenn vererbung nicht möglich sein darf die klasse final machen usw.. das musst du aber komplett selber etnscheiden was du da haben möchtest das kann dir keiner vor schreiben... ausser ein Interface 😀
 
Hag2bard hat gesagt.:
Klassenvariable
Zum Vergrößern anklicken....
Instanzvariable, Klassenvariablen sind static.

Hag2bard hat gesagt.:
Soll ich in der Methode encrypt aus Stil-Gründen
Zum Vergrößern anklicken....
Das hat weniger was mit Stil zu tun. Die Frage ist, welche Attribute ein Objekt hat bzw. haben muss. Der Rest sind Helferlein. Das ist nicht immer eindeutig abgrenzbar, da man ja sehr viele Freiheiten hat.

Hier hilft es ggf., an physische Objekte zu denken. Wenn du eine Chiffriermaschine baust, dann ist im einfachsten Fall der "Schlüssel" eingebaut. In dem Fall wird beim Erstellen der Maschine der einzubauende Schlüssel benötigt. Die Maschine ist dann fertig und kann beliebige Texte verschlüsseln, die das Teil von außen erhält.

So betrachtet könnte man eine Klasse Chiffriermaschine modellieren, die den Schlüssel als Instanzvariable hält und eine Methode besitzt, die den Klartext bekommt und den verschlüsselten String zurückgibt (wenn wir mal von Strings ausgehen).

Zum Thema Freiheiten: genauso gut könnte man auch eine Funktion betrachten, die Klartext und Schlüssel auf einen verschlüsselten Text abbildet. Dann hätte man ggf. überhaupt keine Instanzvariablen.
 
Falls es sich nicht um eine Copy & Paste Fehler handelt, dann würde ich dir zuallererst empfehlen deinen Code anständig zu formatieren:
Java: 
package com.crypt;

import java.util.Random;

public class Crypt3 {
    private String unencrypted;
    private int length;
    private StringBuilder randomKey;
    private Random rnd = new Random();

    public String encrypt(String unencrypted) {
          this.unencrypted = unencrypted; // Instanzvariable wird zugewiesen, aber nie verwendet
          this.length = unencrypted.length(); // m.m.N. braucht man dies Instanzvariable nicht
          getRandomKey(this.length);
    
          char[] unencryptedAsCharArray = this.unencrypted.toCharArray();
          for (int i=0; i<this.length; i++) {
             unencryptedAsCharArray[i]+=randomKey.charAt(i);
          }
  
          return String.valueOf(unencryptedAsCharArray);
    }

    public StringBuilder getRandomKey(int length) {
        randomKey = new StringBuilder(this.length);
        for (int i=0; i<length; i++) {
            randomKey.append(rnd.nextInt(10));
        }
  
        return randomKey;
    }
}

Ich persönlich halte einige der Instanzvariablen für unnötig, aber es ist natürlich deine Entscheidung, was den Objektzustand ausmacht. Das hängt auch von der vorgesehenen Verwendung ab, z. B.:
Java: 
Crypt crypt = new Crypt("secretKey"); // Schlüssel wird bei der Instantiierung übergeben

String text1 = crypt.encrypt("Geheimer Text 1"); // wird mit dem gespeicherten Schlüssel verschlüsselt
String text2 = crypt.encrypt("Geheimer Text 2"); // wird mit dem gespeicherten Schlüssel verschlüsselt

// versus

Crypt crypt = new Crypt();

String text1 = crypt.encrypt("Geheimer Text 1", "secretKey1"); // wird mit dem übergebenen Schlüssel verschlüsselt
String text2 = crypt.encrypt("Geheimer Text 2", "secretKey2"); // wird mit dem übergebenen Schlüssel verschlüsselt

Im ersten Fall ist es sinnvoll den Schlüssel als Instanzvariable zu speichern, im zweiten Fall nicht.

Warum man den unverschlüsselten Text als Zustand des Objektes speichern sollte erschließt sich mir nicht.

Warum die Methode getRandomKey sowohl einen Parameter length als auch die Instanzvariable length benötigt, auch nicht, weil die Werte identisch sind. Da sie explizit mit getRandomKey() benannt wurde ist es für mich nicht intuitiv, dass sie eine Instanzvariable ändert und der Rückgabewert gar nicht verwendet werden muss. In dem Fall würde ich sie wenigsten createRandomKey() o. ä. nennen. Ich persönlich würde sie so lassen wie sie ist, den Zugriff auf die Instanzvariable innerhalb der Methode entfernen, um keine unnötige interne Abhängigkeit zu erzeugen und falls die Instanzvariable wirklich benötigt wird lieber eine Zuweisung außerhalb machen.
Java: 
public String encrypt(String unencrypted) {
    randomKey = getRandomKey(unencrypted.length());
    // ...
Den StringBuilder würde ich zwar intern verwenden, aber einen String zurückgeben. Die Methode encrypt() kann damit genauso arbeiten. Soll es der StringBuilder als Rückgabewert unbedingt sein, dann würde ich die Methode nicht öffentlich sondern private machen. Warum sollte jemand, der einen Schlüssel benötigt einen StringBuilder erwarten?

Dir ist klar, dass es bei einem automatisch erstellten Schlüssel, für die Gegenseite schwierig wird, wenn sie diesen Schlüssel nicht kennt?

Darum würde ich es den Benutzer überlassen, wie er den Schlüssel erzeugt und entweder mit der encrypt() Methode als Parameter übergeben oder bei der Erzeugung der Instanz im Konstruktor übergeben:
Java: 
String key = Crypt.getRandomKey(); // Aufruf der statischen Hilfsmethode von Crypt
Crypt = new Crypt(key);

// oder

Crypt = new Crypt("mySecretKey");
In dem Beispiel wäre getRandomKey() eine statische Methode.

Allerdings gibt es viele Wege zur Realisation und viele haben eine Berechtigung. Ich wollte damit auch weniger Kritik üben als ein paar Vorschläge machen. Und noch einmal der Hinweis: Überlege dir gut, was die Klasse machen und wie ein Benutzer der Klasse damit umgehen soll. Entsprechend entwirf sorgfältig die Schnittstelle der Klasse (= öffentliche Methoden), so dass sie die Anforderungen abdeckt.
 
Zuletzt bearbeitet:
temi hat gesagt.:
Falls es sich nicht um eine Copy & Paste Fehler handelt, dann würde ich dir zuallererst empfehlen deinen Code anständig zu formatieren:
Zum Vergrößern anklicken....
deswegen hatte ich meinen Tab als 4 Leerzeichen eingestellt dass es überall gleich aussieht und nicht als tab zeichen... in eclipse kann man das einfach umstellen und würde ich auch empfehlen
 
Mart hat gesagt.:
deswegen hatte ich meinen Tab als 4 Leerzeichen eingestellt dass es überall gleich aussieht und nicht als tab zeichen... in eclipse kann man das einfach umstellen und würde ich auch empfehlen
Zum Vergrößern anklicken....
Ja guter Hinweis. In den meisten IDEs kann man einstellen, ob die Einrückungen mit Tabulator oder mit Leerzeichen erzeugt werden sollen. Leerzeichen sind da die bessere Wahl. Außerdem bieten die meisten IDEs auch eine Funktion zum automatischen Formatieren an.
 
Ohje hier hagelt es Kritik, nahezu Shitstorm. Tut mir leid dass ich ein Anfänger bin. Ich benutze eine IDE auf meinem Handy. Die Formatierung ist natürlich absolut für die Katz.
Ich verstehe schon was final bedeutet und was ein Zugriffsmodifikator ist. Ich dachte nur dass static Methoden/Variablen dafür da sind, dass ich von jeder anderen Klasse aus, ohne eine Instanz von der Klasse mit den Statics erzeugen zu müssen auf diese zugreifen kann.
Das hat sich meiner Meinung nach widersprochen wenn man sie dann private macht.
Ich habe Dank der vielen Tipps hier schon einiges gelernt. Ich bin mittlerweile bei diesem Code hier angekommen.
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Eigener Webserver + Eigener Webbrowser
Antworten: 7
String mit Hilfe von Array verschlüsseln
Antworten: 19
String über GUI verschlüsseln
Antworten: 8
String verschlüsseln - Applet - ohne BASE64
Antworten: 7
In Java String sicher verschlüsseln
Antworten: 6

Zurück
Oben