## Introduction

Warning: This article is not about conventional ciphers.

Cryptography is among my interests - from simple substitute ciphers up to public key ciphers and one-way functions, such as modulo. This experimental cipher is very simple, symmetric key using and relies heavily on hash algorithm implementation.

## The Reliability

The cipher is far poorly designed, and will serve in non-security based projects, where security is not a challenge. If you want a really world-wide used cipher, perhaps you should look for Rijndael as current AES symmetric private key cipher, or RSA and PGP, if you want really "Pretty Good Privacy".

## Basic Idea

- Take password
- Compute hash from it
- xor plaintext with that hash (one byte at a time, up to 4 bytes)
- When all four bytes of hash were used, then compute new hash as:
HASH = Hash(HASH)

So we should get another hash, made from the previous one. Although primitive in core, perhaps a bit controversial, but interesting.

More interesting is my CBC (although not real one, just pseudo CBC) that can be created by putting:

HASH = HASH XOR source_plaintext_byte

for crypting to the beginning of the loop and...

HASH = HASH XOR destination_plaintext_byte

...in decryption loop to the end.

There are two other, minor functions (macros) that are here for experimental purposes. They should've not been taken responsible for failing / securing a ciphertext. Their only purpose is to hide (possible) artefacts from ciphertext. But basic core is hash function itself:

unsigned int Hash(BYTE *key, int length){
unsigned int hash = 0;
int i;
for (i = 0; i < length; i++){
hash += key[i];
hash += (hash << 10);
hash ^= (hash >> 6);
}
hash += (hash << 3);
hash ^= (hash >> 11);
hash += (hash << 15);
return hash;
}

`unsigned int `

is 32 bit long number, `unsigned long long `

would extend our simple poor hash to 64 bits, but that does not solve our problem as well. The hash number is way too short to guarantee anything even similar to "safety". 128 or 256 bit hash would be ideal, but if I am able to code any hash, then I can code any hash, with extended bit length.

I do not remember where I came across this hash, but could be "Jenkins One-at-a-time hash", from Bob Jenkins' article here. But for implementation, see this link.

I think that usage of better hash could produce a better chance that the first key-hash would not be broken. That has to be proven.

## Background

You can learn about CBC, ciphers, private and public keys, patterns, etc. on Wiki pages:

## The Code

This is pure C code with C++ class usage. The algorithm is widely portable, wherever the C is available.

### Base Class

class Perfect_Crypt{
public:
bool Crypt(BYTE *src, int srclength, BYTE *&dest,
int &destlength,BYTE *password, int passwordlength,
TCryptParam param);
};

### The Core

#define neg(I) ( ~I) // negation
#define rot(I) ( (I << 3) ^ (I >> (32-3))) // bit rotation by 3
unsigned int Hash(BYTE *key, int length){
unsigned int hash = 0;
int i;
for (i = 0; i < length; i++){
hash += key[i];
hash += (hash << 10);
hash ^= (hash >> 6);
}
hash += (hash << 3);
hash ^= (hash >> 11);
hash += (hash << 15);
return hash;
}
addr = (BYTE *)&HASH;
while(srcptr != stop){
HASH^=srcChr;
HashChr = *(addr+four);
srcChr = (*srcptr);
(*destptr) = srcChr ^ HashChr;
four++;
if (four == 4){
HASH = Hash((BYTE*)&HASH, 4);
HASH = neg(HASH);
HASH = rot(HASH);
four = 0;
}
destptr++
srcptr++;
}

### Usage

If you want to use and experiment with this cipher, you can call:

bool Texcrypt::Crypt(BYTE *src, int srclength, BYTE *&dest,
int &destlength, BYTE *password, int passwordlength,
TCryptParam param)

## Points of Interest

The algorithm is mainly based on hash algorithm, so should there be any weakness in hash algorithm, it will have a direct impact on crypt reliability. The weakness here is collision production and not complete bits "overwhelming", when we need each bit to be hashed with each one (other).

Surprisingly simple algorithm, suspecting weakness, although, it is no conventional cipher anymore.

One more thing is that the cipher algorithm computes verification code, the summation of 1 in each byte. This is not CRC32, just pseudo CRC, to improve security.

It also includes pseudo cipher block chaining. Basically, CBC is designed to chain each cipherblock with the previous plaintext, so any small change in plaintext (such as error in decryption) would make all next blocks unreadable and "garbage" like in appearance.

Perhaps one will find such a concept useful.

## Additional Information

- Rijndael, at Wiki http://en.wikipedia.org/wiki/Rijndael
- RSA, at Wiki http://en.wikipedia.org/wiki/Rsa
- PGP, at Wiki http://en.wikipedia.org/wiki/Pretty_Good_Privacy

## History

- Update 30.8.2010 - Added a few references and warning about reliability of the cipher
- Update 30.8.2010 - Renamed to Excrypt, that stands for experimental crypt
- Update 29.8.2010 - Added cipher block chaining (two lines of code) and few comments to make few things more clear
- Update 29.8.2010 - Removed one extra
`rot()`

, why was it there??
- Update 29.8.2010 - Comments