Cryptography : is it me ???

[fullmetalcoder]

If the message was long enough, that wouldn't have helped much. Knowing the pattern of masking bits or shifting one could still be able to find collisions, i.e. if you shift, you'll eventually get the original key again and it can happer faster when you use weak keys. For example if you rotated the key one bit to the right in each iteration, a weak key could be 1111 0000 1111 0000 - it repeats every half of its length (0101 0101 0101 0101 is even weaker).

When I mentioned predefined extension of the key to make it virtually as long as the message I had no precise idea but I'm now thinking about this concept : "the message is the key". My first approach is to keep the XOR block encryption but to avoid repeating the key by using the message as a key. The first block is encrypted with the key and then used as key to encrypt the next block and so on... This is not of course unbreakable but the first block can't be decrypted in any other way than brute-force search which makes the algorithm much stronger than the first one I proposed.

void encrypt(QByteArray& data, QByteArray& pass)
{
    int i = 0, e = data.size(), x = 0, m = pass.count();
    char c, *d = data.data(), *p = pass.data(), *b = new char [m];
 
    while ( i < e )
    {
        b[x] = d[i];
        d[i] ^= p[x];
 
        if ( !(x = (++i % m)) )
            qSwap(p, b);
    }
}
 
void decrypt(QByteArray& data, QByteArray& pass)
{
    int i = 0, e = data.size(), x = 0, m = pass.count();
    char c, *d = data.data(), *p = pass.data(), *b = new char [m];
 
    while ( i < e )
    {
        d[i] ^= p[x];
        b[x] = d[i];
 
        if ( !(x = (++i % m)) )
            qSwap(p, b);
    }
}

void encrypt(QByteArray& data, QByteArray& pass)
{
    int i = 0, e = data.size(), x = 0, m = pass.count();
    char c, *d = data.data(), *p = pass.data(), *b = new char [m];
    
    while ( i < e )
    {
        b[x] = d[i];
        d[i] ^= p[x];
        
        if ( !(x = (++i % m)) )
            qSwap(p, b);
    }
}

void decrypt(QByteArray& data, QByteArray& pass)
{
    int i = 0, e = data.size(), x = 0, m = pass.count();
    char c, *d = data.data(), *p = pass.data(), *b = new char [m];
    
    while ( i < e )
    {
        d[i] ^= p[x];
        b[x] = d[i];
        
        if ( !(x = (++i % m)) )
            qSwap(p, b);
    }
}

To copy to clipboard, switch view to plain text mode 

Further enhancement of this code could be :

• Compressing the data on-the-fly to reduce redundancy without increasing complexity (a simple RLE would be enough I think)
• Using tricks to make encryption a little more random. For instance XOR'ing with 0xff (one's complement) on some special occasions (data byte is even, or odd, or multiple of 3 or whatever...)