Is this home-grown algorithm safe for encryption?

Question

Jasoos (Cryptography Algorithm)

I am working on encrypting and decrypt web application. I have built an algorithm that uses 24-byte key to encrypt/decrypt the message.

Review this algorithm and please suggest anything important and fault in this algorithm that can make it perform better. Your contribution can help us to improve our algorithm.

Code is provided on my GitHub

Algorithm:-

1] 24 digit entered/generated key will be converted into ASCII code of 24 digit code.

public void setKey(char[] arr){
 for(int i=0;i<24;i++){
   key[i] = (int)arr[i];
 } 
}

2] Entered String will be changed into a character array.

Every character will be then incremented first with the key’s value and changed into 10-bit binary code.

 public void Encryption(String text){
 char[] msg = text.toCharArray();
 int flag = 0;
 int l = msg.length;
 for(int i=0;i<l;i++){
  int a = (int)msg[i];
 // System.out.print(msg[i]+" "+a+"-> ");

 if(flag>23)
     flag=0;
 int b=a+key[flag];
 flag++;
 //System.out.print(b+" | ");
 String z = binary(b);
 sb.append(lookUpTool(z));
 //Character.toString((char)b);
 }
 //sb.append(sumBinary);
 sb = comp1(sb);
}

3] lookUp(): - It will take a 10-bit string as input and a matrix, and divide that string into two 5 bit binary code.

We will then calculate decimal value of each 5-bit binary code.

Example: 0011101101 -> 00111 = 7 and 01101 = 13

We have a matrix of 32 X 32 dimensions which has unique random values from 0 to 1023 and will not be shared publicly.

For 0011101101 we will look for 7th row and 13th column value. That value will be changed into 10 bits binary code.

public String lookUp(String bits, int[][] mat){

int mid = Math.round((float) bits.length() / 2);
String part1 = bits.substring(0, mid);
String part2 = bits.substring(mid, bits.length());
int row=binaryValue(part1);
int col=binaryValue(part2);;


//System.out.print("row: "+row);
// System.out.println("|| col: "+col);
int a = mat[row][col];
return binary(a);

}

4] We will perform this steps ten times with ten different private matrices by lookUpTool method.

  public String lookUpTool(String s){

   String s1 = lookUp(s,matrix1);
   String s2 = lookUp(s1,matrix2);
   String s3 = lookUp(s2,matrix3);
   String s4 = lookUp(s3,matrix4);
   String s5 = lookUp(s4,matrix5);
   String s6 = lookUp(s5,matrix6);
   String s7 = lookUp(s6,matrix7);
   String s8 = lookUp(s7,matrix8);
   String s9 = lookUp(s8,matrix9);
   String s10 = lookUp(s9,matrix10);

   return s10;

}

Similarly, we will do this for each character in the text/string and encrypt it.

Example:-

Key: c|H@yLzd3PkRte0H,u16zt8N

Message: abcd ef$

After Encryption: 11001111000001101010000010000101101000001110100000101010111001110000011000001000

Answer 1

Your algorithm is completely worthless by any reasonable standard. The most obvious problem is this:

You just gave us a key, plaintext, and corresponding encoded message. This leaks out numerous entries from your super-secret matrix that you weren't supposed to share publicly. (Each ten-bit chunk of the encrypted message is an entry from that array, and with the key and plaintext, I can figure out which one it is.)

Imagine if an adversary had a collection of messages that were already encrypted by your algorithm and then you posted this challenge. He can now decrypt a significant fraction of those messages, just from what you leaked in this challenge. And if there are obvious missing bits, say he has "trans_ormer", he can work out another entry in your formerly super-secret array.

But please read the links in the comments. Trying to design your own encryption algorithm for actual use and reliance in this way is absolutely foolish. A new algorithm cannot even be considered for actual use before it has been reviewed thoroughly by experts in each type of known cryptanalysis.

Another algorithmic flaw is immediately obvious. An attacker will know that the key repeats every 24 characters. With a long enough message, say in English, the attacker can do a frequency analysis for each set of every 24th character. It's even worse if the attacker knows the message format and that format has an even more unequal frequency distribution.