Einfache Verschlüsselung in Java-no Schlüsseln/Passwort

Question

Sagen, ich habe eine IP-Adresse, 192.168.1.1

ich mein Programm will eine gelegentliche-Wortfolge basierend auf dieser IP-Adresse zu erstellen, die leicht ohne entschlüsselt werden können Schlüssel oder Passwort oder zusätzliche Sicherheit.

z.

I 192.168.1.1 eingeben

Programm wandelt es in AzlQrEHCSD oder eine andere zufällige Zeichenfolge

ich diese Zeichenfolge in das Programm eingeben

Es zurück zu 192.168.1.1 umgewandelt wird

Gibt es einen einfachen Algorithmus, der das tun kann, ohne Schlüssel wie Schlüssel oder zusätzliche Passwörter zu erzeugen? Ich verstehe, dass Schlüssel und Passwörter sind ein Muss für die Verschlüsselung und Entschlüsselung, aber mein Szenario erfordert es nicht.

Answer 1

Ich kenne seine Overkill aber ich würde jasypt Bibliothek seit seinem wirklich einfach bedienen zu verwenden. Alles, was Sie brauchen, ist zufälliger Seed zum Verschlüsseln oder Entschlüsseln.

Hier ist der Quellcode für die Verschlüsselung von Daten:

String seed = "ipNumber"; 
String myIpValue = "192.168.0.1"; 

StandardPBEStringEncryptor encryptor = new StandardPBEStringEncryptor(); 
encryptor.setPassword(seed); 
String encrypted= encryptor.encrypt(myIpValue); 

Und zur Datenentschlüsselung:

StandardPBEStringEncryptor encryptor = new StandardPBEStringEncryptor(); 
encryptor.setPassword(seed); 

String decrypted = encryptor.decrypt(encrypted); 

Oder Sie könnten nur Ihren String base64 Beispiel zeigt hier kodieren oder entschlüsseln: Base64 Java encode and decode a string

Answer 2

Wenn die generierte Zeichenfolge "zufällig" wäre, müsste Ihre Anwendung die generierte Zeichenfolge für alle Zeit verfolgen. Wahrscheinlich kein gutes Design.

Eine schnelle Armer „Verschlüsselung“ wäre ROT47 (http://rot47.net/)

Answer 3

Sie können die IP String zu base64 codieren, die Zeichenfolge umkehren und dann eine 0 verwenden:

public String easeyEncrypt(String ip) { 
    String b64encoded = Base64.encode(ip); 

    // Reverse the string 
    String reverse = new StringBuffer(b64encoded).reverse().toString(); 

    StringBuilder tmp = new StringBuilder(); 
    final int OFFSET = 4; 
    for (int i = 0; i < reverse.length(); i++) { 
     tmp.append(reverse.chartAt(i) + OFFSET); 
    } 
    return tmp.toString(); 
} 

PROCEDE So entschlüsseln rückwärts:

public String easeyDecrypt(String secret) { 
    StringBuilder tmp = new StringBuilder(); 
    final int OFFSET = 4; 
    for (int i = 0; i < secret.length(); i++) { 
     tmp.append(secret.chartAt(i) - OFFSET); 
    } 

    String reversed = new StringBuffer(tmp.toString()).reverse().toString(); 
    return Base64.encode(reversed); 
} 

Answer 4

Das ist einfachste Verschlüsselung/Entschlüsselung Code, aber es ist nicht sicher.

 String strip = "192.168.1.11";   
    byte[] encryptArray = Base64.encodeBase64(strip.getBytes());   
    String encstr = new String(encryptArray,"UTF-8"); 
    System.out.println("Enc >> "+ encstr); 


    String strDec = "MTkyLjE2OC4xLjEx"; 
    byte[] dectryptArray = strDec.getBytes(); 
    byte[] decarray = Base64.decodeBase64(dectryptArray); 
    String decstr = new String(decarray,"UTF-8"); 
    System.out.println("Dec >>> "+ decstr); 

Dazu müssen Sie import org.apache.commons.codec.binary.Base64;

Sie können herunterladen org-Apache-Commons-Codec.jar Datei von Link

Answer 5

Fast die gleiche wie higuaro Lösungen, aber mit viel fixiert den folgenden Code getestet und funktioniert es Arbeit zu machen, da higuaro nicht gut funktioniert wie Zeichen in Zahlen ging, und wenn Sie umkehren seine erhalten einzelne Zahl und beschädigen alles:

public String caesarCipherEncrypt(String plain) { 
    String b64encoded = Base64.getEncoder().encodeToString(plain.getBytes()); 

    // Reverse the string 
    String reverse = new StringBuffer(b64encoded).reverse().toString(); 

    StringBuilder tmp = new StringBuilder(); 
    final int OFFSET = 4; 
    for (int i = 0; i < reverse.length(); i++) { 
     tmp.append((char)(reverse.charAt(i) + OFFSET)); 
    } 
    return tmp.toString(); 
} 

de-Krypta PROCEDE rückwärts:

public String caesarCipherDecrypte(String secret) { 
    StringBuilder tmp = new StringBuilder(); 
    final int OFFSET = 4; 
    for (int i = 0; i < secret.length(); i++) { 
     tmp.append((char)(secret.charAt(i) - OFFSET)); 
    } 

    String reversed = new StringBuffer(tmp.toString()).reverse().toString(); 
    return new String(Base64.getDecoder().decode(reversed)); 
} 

ich hoffe, seine hilfreich.