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?
