Einfache Verschlüsselung in java-kein Schlüssel/Passwort

Sagen, ich habe eine IP-Adresse, die 192.168.1.1

Möchte ich mein Programm erstellen Sie eine zufällige ein-Wort-string basierend auf dieser IP-Adresse können einfach entschlüsselt werden, ohne einen Schlüssel oder ein Kennwort oder eine zusätzliche Sicherheit.

zB.

Ich geben Sie 192.168.1.1

Programm wandelt es um AzlQrEHCSD oder einige andere zufällige Zeichenfolge

Ich geben Sie diese Zeichenfolge in das Programm

Wird es umgewandelt zurück zu 192.168.1.1

Ist es einfacher Algorithmus, der dies tun kann, ohne dass Sachen wie Schlüssel oder zusätzliche Kennwörter? Ich verstehe, dass Schlüssel und Passwörter sind ein muss für die Verschlüsselung und Entschlüsselung, aber mein Szenario nicht.

  • Wie wäre Base64-Codierung?
  • Es wird keine Verschlüsselung überhaupt, sondern nur eine Codierung. Konvertieren Sie Ihre ip in bytes und gelten base64-Konvertierung
  • xor-Verschlüsselung ist schnell und einfach zu implementieren.
InformationsquelleAutor Mayukh Nair | 2015-03-24
  1. 8

    Ich weiß, das ist übertrieben, aber ich würde jasypt Bibliothek, da seine wirklich einfach zu bedienen. Alles, was Sie brauchen, ist random seed zu verschlüsseln oder decrpyt.

    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 für Entschlüsselung von Daten:

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

String decrypted = encryptor.decrypt(encrypted);

    Oder Sie könnten einfach codieren oder decodieren Sie Ihre string zu base64 Beispiel ist hier gezeigt:
    Base64 Java codieren und decodieren einer Zeichenfolge

    • Es funktioniert aber sehr sehr langsam...
    InformationsquelleAutor Kiki
  2. 6

    Fast das gleiche wie higuaro Lösungen, aber mit einer Menge fixes, damit es funktioniert, die folgenden code getestet und arbeiten seit higuaro funktioniert nicht gut, wie Zeichen, ging in die zahlen und wenn Sie stornieren Ihre einzelne Zahl und Schäden 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-crypt 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 hilfreich.

    • Es gibt keine variable key hier: key.charAt(i), hast du nicht meine secret.charAt(i) ?
    • ja, ty
    • Was mehr ist, habe ich auch geändert: Base64.getDecoder() zu Base64.getMimeDecoder() aufgrund Base64: java.lang.IllegalArgumentException: Illegal character Fehler und Ihre Funktionen in mein kleines Uni-Projekt 🙂
    InformationsquelleAutor Al-Mothafar
  3. 4

    Kodieren Sie die ip - String zu base64 ist, umkehren Sie die Zeichenfolge, und verwenden Sie dann eine Caesar-Chiffre:

    public String easeyEncrypt(String ip) {
   String b64encoded = Base64.getEncoder().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.charAt(i) + OFFSET);
   }
   return tmp.toString();
}

    Entschlüsseln procede 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.charAt(i) - OFFSET);
   }

   String reversed = new StringBuffer(tmp.toString()).reverse().toString();
   return Base64.encode(reversed);
}
    • Up stimmten für den Einsatz von offset
    • Aus dem wikipedia-link: Wie bei allen single-alphabet substitution ciphers, die Caesar-Chiffre ist leicht gebrochen und in der modernen Praxis bietet im Grunde keine Kommunikation Sicherheit
    • downvoted, da es keine funktionierenden code.
    InformationsquelleAutor higuaro
  4. 2

    Dies ist am einfachsten verschlüsseln/entschlüsseln von 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);

    Dafür musst du import org.apache.commons.codec.binary.Base64;

    können Sie Download org-apache-commons-codec.jar Datei aus Link

    • Simple und einfach.. vielen Dank!!
    InformationsquelleAutor utkal patel
  5. 1

    Wenn die generierte Zeichenfolge wäre "zufällig", dann wird Ihre Anwendung haben würde, um zu verfolgen alle generierten string für alle Zeit. Wahrscheinlich nicht ein gutes design.

    Einen schnellen armer Mann "Verschlüsselung" wäre ROT47 ( http://rot47.net/ )

    • Es ist für Briefe, nicht für Dezimalzahlen
    • Ja, Sie sind richtig. Ich dachte eigentlich, der ROT47; aber verwirrt mich. ROT47 wird für die Arbeit zahlen, zu.
    InformationsquelleAutor GhostCat
  6. 0

    Hier ist ein einfaches random-Verschlüsselung:

    class SimpleStringEncryption {

  public static String encrypt(String str){
    int code;
    String result = "";
    for (int i = 0; i < str.length(); i++) {
      code = Math.round((float) Math.random()*8+1);
      result += code + Integer.toHexString( ((int) str.charAt(i) ) ^ code )+"-";
    }
    return result.substring(0, result.lastIndexOf("-"));
  }

  public static String decrypt(String str){
    str = str.replace("-", "");
    String result = "";
    for (int i = 0; i < str.length(); i+=3) {
      String hex =  str.substring(i+1, i+3);
      result += (char) (Integer.parseInt(hex, 16) ^ (Integer.parseInt(String.valueOf(str.charAt(i)))));
    }
    return result;
  }

    public static void main (String[] args) {
        String e = "some text to encrypt";
        String encrypted = encrypt(e);
        System.out.println(encrypted);
        System.out.println(decrypt(encrypted));
    }  

}

    hoffe, das hilft.

    InformationsquelleAutor bitsnaps
Schreibe einen Kommentar