web-dev-qa-db-fra.com

Cryptage simple en Java sans clé ni mot de passe

Disons que j'ai une adresse IP, 192.168.1.1

Je souhaite que mon programme crée une chaîne aléatoire d'un mot en fonction de cette adresse IP, qui peut être facilement décryptée sans clé ni mot de passe, ni sécurité supplémentaire.

par exemple. 

J'entre 192.168.1.1

Le programme le convertit en AzlQrEHCSD ou en une autre chaîne aléatoire

J'entre cette chaine dans le programme

Il est reconverti en 192.168.1.1

Existe-t-il un algorithme simple permettant de le faire sans générer des éléments tels que des clés ou des mots de passe supplémentaires? Je comprends que les clés et les mots de passe sont indispensables pour le cryptage et le décryptage, mais mon scénario ne l’impose pas.

javastringalgorithmencryptionrandom
7
Mayukh Nair

Je sais que c'est exagéré, mais j'utiliserais jasypt library car il est vraiment facile à utiliser. Tout ce dont vous avez besoin est une graine aléatoire à chiffrer ou à décomposer.

Voici le code source pour chiffrer les données:

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

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

Et pour le décryptage des données:

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

String decrypted = encryptor.decrypt(encrypted);

Ou vous pouvez simplement encoder ou décoder votre chaîne en base64. L’exemple suivant est présenté ici: Base64 Java encoder et décoder une chaîne

8
Kiki

Presque identique aux solutions higuaro mais avec beaucoup de corrections pour le faire fonctionner, le code suivant a été testé et fonctionne depuis higuaro ne fonctionne pas bien comme les caractères sont entrés dans les nombres et lorsque vous inversez son numéro unique et tout endommagé:

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();
}

Pour décrypter les procédures en arrière:

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));
}

J'espère que c'est utile.

5
Al-Mothafar

Vous pouvez coder l'ip String en base64, inverser la chaîne, puis utiliser un chiffrement Caesar :

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();
}

Pour déchiffrer la procédure en arrière:

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);
}
4
higuaro

C'est le code le plus simple, mais ce n'est pas sécurisé.

     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);

Pour cela, vous devez import org.Apache.commons.codec.binary.Base64;

vous pouvez Téléchargez org-Apache-commons-codec.jar fichier à partir de Lien

2
utkal patel

Si la chaîne générée était "aléatoire", votre application devrait alors garder une trace de toute chaîne générée pour toujours. Probablement pas un bon design.

Un "cryptage" rapide et pauvre serait ROT47 ( http://rot47.net/ )

1
GhostCat

Voici un cryptage aléatoire simple:

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));
    }  

}

j'espère que cela t'aides.

0
bitsnaps