13,143,693 members (28,062 online)
alternative version

#### Stats

22K views
7 bookmarked
Posted 29 Aug 2010

# Experimental Crypt

, 30 Aug 2010
 Rate this:
Experimental crypt

## Introduction

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

2. Compute hash from it
3. xor plaintext with that hash (one byte at a time, up to 4 bytes)
4. 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

```// base (the only one) class
class Perfect_Crypt{
public:
bool Crypt(BYTE *src, int srclength, BYTE *&dest,
TCryptParam param);
};```

### The Core

```      // core functions - macros
#define neg(I) ( ~I)            // negation
#define rot(I) ( (I << 3) ^ (I >> (32-3)))      // bit rotation by 3
// hash, from an article by Bob Jenkins
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;
}
// crypt
addr = (BYTE *)&HASH;   // get the address of BYTE of our HASH number
while(srcptr != stop){
HASH^=srcChr;            // pseudo cipher block chaining
HashChr = *(addr+four);  // take particular byte from HASH into HashChr
srcChr = (*srcptr);      // copy plaintext char into srcChr
(*destptr) = srcChr ^ HashChr;   // output ciphertext byte as xored
// srcChr and HashChr
four++;          // used when taking bytes from hash number
if (four == 4){                  // if all bytes from hash were
// used 4 for 32 bit integers
HASH = Hash((BYTE*)&HASH, 4);     // make new hash
HASH = neg(HASH);         // negate hash bits
HASH = rot(HASH);         // rotate hash bits
four = 0;             // reset "4 bytes" counter
}
destptr++            // move forward;
srcptr++;
}
```

### Usage

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

```bool Texcrypt::Crypt(BYTE *src, int srclength, BYTE *&dest,
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.

1. Rijndael, at Wiki http://en.wikipedia.org/wiki/Rijndael
2. RSA, at Wiki http://en.wikipedia.org/wiki/Rsa
3. 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??

## Share

 Software Developer (Junior) SOMI Systems Slovakia
Got 1st and 2nd degree from computer science in 2011 on university of Matej Bel, city of Banska Bystrica. Currently work for computer-oriented company SOMI Systems in Slovakia.
Working for SOMI Systems a.s., http://somi.sk/

## You may also be interested in...

 First Prev Next
 Hash, Symmetric, Asymmetric [modified] Tomice29-Aug-10 21:16 Tomice 29-Aug-10 21:16
 Re: Hash, Symmetric, Asymmetric Jan Mojzis30-Aug-10 4:58 Jan Mojzis 30-Aug-10 4:58
 Known data [modified] waykohler29-Aug-10 18:05 waykohler 29-Aug-10 18:05
 If you know a bit about the data you can quite easily decode the whole crypt. Lets say you encrypt a jpeg, the first 4 bytes in that file is a magic number identifying the file as a jpeg. If you xor the first 4 bytes of the file with that number you have the first key and you can decode the whole file. The same would be true for word docs, html pages, pdf's and so on. modified on Monday, August 30, 2010 12:31 AM
 My vote of 1 Shawn Poulson29-Aug-10 16:29 Shawn Poulson 29-Aug-10 16:29
 My vote of 1 Bething229-Aug-10 11:47 Bething2 29-Aug-10 11:47
 Perfect? imagiro29-Aug-10 6:12 imagiro 29-Aug-10 6:12
 Re: Perfect? Jan Mojzis29-Aug-10 9:06 Jan Mojzis 29-Aug-10 9:06
 Re: Perfect? Green Fuze29-Aug-10 9:55 Green Fuze 29-Aug-10 9:55
 Re: Perfect? Jan Mojzis29-Aug-10 10:22 Jan Mojzis 29-Aug-10 10:22
 You're missing the point Shawn Poulson29-Aug-10 16:28 Shawn Poulson 29-Aug-10 16:28
 Re: You're missing the point waykohler29-Aug-10 19:30 waykohler 29-Aug-10 19:30
 Re: You're missing the point Jan Mojzis30-Aug-10 5:03 Jan Mojzis 30-Aug-10 5:03
 Re: You're missing the point Shawn Poulson30-Aug-10 7:51 Shawn Poulson 30-Aug-10 7:51
 Re: You're missing the point Jan Mojzis30-Aug-10 9:04 Jan Mojzis 30-Aug-10 9:04
 Last Visit: 31-Dec-99 18:00     Last Update: 21-Sep-17 15:05 Refresh 1