I'm looking 4 some encryption algorithms, not very strong (complex) but fairly secure<br>
The Ghost
ghost@crazygrandpa.com

How good do you need? Some of the good encryption algorithms involve matrices and their identities, where to move forward and backwards through the message you would have to multiply by the identity matrix. I can't remember all the details of this algorithm, but if you want it, I can look it up later and send it to you. You would have to know something about matrices to use, though.

There are two methods in software design. One is to make the program so simple that there are obviously no flaws, the other is to make the program so complicated that there are no obvious flaws.

something for a part of an app. not VERY stupid and obvious but not Rijndle (is that how u write it ?!)

The Ghost
ghost@crazygrandpa.com

OK, how's this for an algorithm? It's not complicated at all, but it would not be obvious how to crack it, since even you won't know the actual key. You create a string that contains all the letters and characters that you want to use, in any order. Make a copy of the string. In a loop that goes until the copy is empty, remove a random character from the string and put it in a new string. You will now have three strings: 1 with an ordered sequence of characters, 1 empty, and 1 with a randomly ordered collection of the same characters.
You then take your message and parse it letter by letter, and replace each character with the character at the same location in teh third string. (If the first string is "ABCDE" and the second is "" and the third is "DBEAC" then all A's become D's and all B's stay the same, all C's become E's, etc..). Then when you want to decrypt it, you have to pass the string to be decrypted along with the two strings containing the list of characters that have been exchanged. Note that you do not need to change every character used, but all the A's must be changed (just an example). You can also run the string through multiple times, where it would become a little more encrypted, and would take the same number of runs backwards to decrypt it.

Hope this helps.


There are two methods in software design. One is to make the program so simple that there are obviously no flaws, the other is to make the program so complicated that there are no obvious flaws.

: OK, how's this for an algorithm? It's not complicated at all

Here's one that's even simpler, and turns the message into complete white noise - random garbage. It requires an integer key, which is used to encrypt and decrypt the message.

Encrypt:
1) seed random number generator with key
2) add random number to each byte in the data

Decrypt:
1) seed random number generator with key
2) subtract random number from each byte in the data

That's it. Yes, it's crackable, especially if you use the stock random number generator of a popular compiler, or if the number generator repeats itself before the end of the message (would require a giant message, or a lousy random number generator). However, it would require a pretty knowledgeable cracker.

#include <stdio.h>
#include <stdlib.h>

void encrypt (unsigned int key, unsigned char* data, size_t len) {
  srand(key);
  const unsigned char* end = data + len;
  while (data < end)
    *data++ += rand();
}

void decrypt (unsigned int key, unsigned char* data, size_t len) {
  srand(key);
  const unsigned char* end = data + len;
  while (data < end)
    *data++ -= rand();
}

int main()
{
  unsigned char data[] = "This is a test of the encryption algorithm.";

  size_t len = sizeof(data) - 1;

  int key = 777;

  encrypt (key, data, len);
  puts (data);

  decrypt (key, data, len);
  puts (data);

  return 0;
}

Cheers,
Eric

A variation on this algorithm uses a password.

This algorithm uses three strings: a message string, a password string, and an encrypted message string.
You simply perform a mathematical expression taking the letters from the message and the password to encrypt a new string. The most simple being an ASCII-addition, example:

Message: Encryption algorithm
Password: code

- Take the first letter of the message and the password, and add them:

E (ASCII 69) + c(ASCII 99) = (ASCII 168)

- then the second, third etc. until you reach the end of the password.
- Now you have a problem, since you cannot add any more letters to the message letters. Solution: start over with the password.

In this case: the fifth letter (y) is encrypted with the C of the password.
The encrypted message looks like this: __+?F?
Which is utter garbage.

P.S. Here is the Delphi code, which produced this message:

var
  msg:string = 'Encryption algorithm';
  pw:string = 'code';
  emsg:string;
  pwindex,msgindex:integer;
begin
  pwindex:=1;
  for msgindex:=1 to length(msg) do begin
    emsg:=emsg+char(byte(msg[msgindex])+byte(pw[pwindex]))+' ';
    inc(pwindex);
    if pwindex>length(pw) then
      pwindex:=1;
  end;
end;

: A variation on this algorithm uses a password.

The algorithm I showed uses a password, too.

: This algorithm uses three strings: a message string, a password string, and an encrypted message string.
: You simply perform a mathematical expression taking the letters from the message and the password to encrypt a new string. The most simple being an ASCII-addition, example:
:
: Message: Encryption algorithm
: Password: code
:
: - Take the first letter of the message and the password, and add them:
:
: E (ASCII 69) + c(ASCII 99) = (ASCII 168)
:
: - then the second, third etc. until you reach the end of the password.
: - Now you have a problem, since you cannot add any more letters to the message letters. Solution: start over with the password.
:
: In this case: the fifth letter (y) is encrypted with the C of the password.
: The encrypted message looks like this: __+?F?
: Which is utter garbage.

Not really utter garbage. In your example, the alteration of the message repeats every 4 characters! The kind of thing easy for a computer to spot. Actually, this one's easy enough for a human to spot. Imagine some blank space in the message, like:

  original  = '                   '
  encrypted = ''

If we look at the value of each byte:

131 143 132 133 131 143 132 133 131 143 132 133 131 143 132 133 131 143 132

It doesn't take a master hacker to see that it repeats. Here's the same blank space encrypted with the algorithm I posted.

  original  = '                        '
  encrypted = '-Sn' a-l?z-q     ' (mostly non-printable chars)

186 196 83 252 145 247 39 247 0 97 45 108 169 160 14 122 45 113 199

Utter garbage. ;)

Cheers,
Eric

: : A variation on this algorithm uses a password.
:
: The algorithm I showed uses a password, too.
:
: : This algorithm uses three strings: a message string, a password string, and an encrypted message string.
: : You simply perform a mathematical expression taking the letters from the message and the password to encrypt a new string. The most simple being an ASCII-addition, example:
: :
: : Message: Encryption algorithm
: : Password: code
: :
: : - Take the first letter of the message and the password, and add them:
: :
: : E (ASCII 69) + c(ASCII 99) = (ASCII 168)
: :
: : - then the second, third etc. until you reach the end of the password.
: : - Now you have a problem, since you cannot add any more letters to the message letters. Solution: start over with the password.
: :
: : In this case: the fifth letter (y) is encrypted with the C of the password.
: : The encrypted message looks like this: __+?F?
: : Which is utter garbage.
:
: Not really utter garbage. In your example, the alteration of the message repeats every 4 characters! The kind of thing easy for a computer to spot. Actually, this one's easy enough for a human to spot. Imagine some blank space in the message, like:
:

:   original  = '                   '
:   encrypted = ''
: 

: If we look at the value of each byte:
:
: 131 143 132 133 131 143 132 133 131 143 132 133 131 143 132 133 131 143 132
:
: It doesn't take a master hacker to see that it repeats. Here's the same blank space encrypted with the algorithm I posted.
:

:   original  = '                        '
:   encrypted = '-Sn˜'˜ a-l?z-q     ' (mostly non-printable chars)
: 
: 

:
: 186 196 83 252 145 247 39 247 0 97 45 108 169 160 14 122 45 113 199
:
: Utter garbage. ;)
:
: Cheers,
: Eric
:
:
:
:
:
That is correct, but this was merely a simple example. Normally I use much more complicated formulas, and combine it with completely other encryption algorithms, such as a transformation matrix or a simple compression.