Simple encryption in java-no key/password

Question

Say I have an IP address, 192.168.1.1

I want my program to create a random one-word string based on this IP address which can be easily decrypted without a key or password or additional security.

eg.

I enter 192.168.1.1

Program converts it to AzlQrEHCSD or some other random string

I enter this string in the program

It gets converted back to 192.168.1.1

Is there any simple algorithm that can do this without generating stuff like keys or additional passwords? I understand that keys and passwords are a must for encryption and decryption, but my scenario does not require it.

It will be not encryption at all, just encoding. Convert your ip to bytes and apply base64 conversion — Alex Salauyou, Mar 24 '15 at 07:14

score 17 · Accepted Answer · edited May 23 '17 at 12:17

I know its overkill but i would use jasypt library since its realy easy to use. All you need is random seed to encrypt or decrpyt.

Here is the source code for encrypting data:

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

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

And for data decryption:

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

String decrypted = encryptor.decrypt(encrypted);

Or you could just encode or decode your string to base64 example is show here: Base64 Java encode and decode a string

Al-Mothafar · Answer 2 · 2017-06-29T06:31:45.913

Almost the same as higuaro solutions but with a lot of fixes to make it work, the following code tested and working since higuaro not working well like characters went into numbers and when you reverse its get single number and damage everything:

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

To de-crypt procede backwards:

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

I hope its helpful.

There is no variable ``key`` in here: ``key.charAt(i)``, didn't you mean ``secret.charAt(i)`` ? — Jagoda Gorus, Jun 29 '17 at 05:49
What's more, I also changed: ``Base64.getDecoder()`` to ``Base64.getMimeDecoder()``, due to ``Base64: java.lang.IllegalArgumentException: Illegal character`` error and included your functions in my small university project :) — Jagoda Gorus, Jun 29 '17 at 06:35

score 4 · Answer 3 · edited May 04 '19 at 14:23

You can encode the ip String to base64, reverse the string, and then use a Caesar cipher:

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

To decrypt procede backwards:

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

From the wikipedia link: As with all single-alphabet substitution ciphers, the Caesar cipher is easily broken and in modern practice offers essentially no communication security — Hristo Stoyanov, May 07 '18 at 04:26

score 2 · Answer 4 · answered Apr 27 '16 at 06:35

This is simplest encrypt/decrypt code but it is not secure.

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

For this you have to import org.apache.commons.codec.binary.Base64;

you can Download org-apache-commons-codec.jar file from Link

since java 8, you can use the Base64 that is part of the JDK. `java.util.Base64.getEncoder().encode(string.getBytes());` — lance.dolan, Jan 31 '20 at 16:48

GhostCat · Answer 5 · 2015-03-24T07:22:47.327

1

If the generated string would be "random", then your application would have to keep track of any generated string for all time. Probably not a good design.

A fast poor man "encryption" would be ROT47 ( http://rot47.net/ )

edited Mar 24 '15 at 07:22

answered Mar 24 '15 at 07:14

GhostCat

137,827
25
176
248

It's for letters, not for decimals – Alex Salauyou Mar 24 '15 at 07:18
Yes, you are correct. I actually thought of ROT47; but confused myself. ROT47 will work for numbers, too. – GhostCat Mar 24 '15 at 07:23

score 0 · Answer 6 · answered Sep 04 '18 at 10:24

Here is a simple random encryption:

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

}

hope this helps.

Simple encryption in java-no key/password

6 Answers6