Rabbit

#ifndef RABBIT_H
#define RABBIT_H

#include <cstdint>
class rabbit
{
    public:
        rabbit();
        rabbit(uint16_t key[8]);
        virtual ~rabbit();
        void setKey(uint16_t sKey[8]);
        void encrypt(uint16_t *in, uint16_t *out);
        void decrypt(uint16_t *in, uint16_t *out);
    private:
        uint32_t mState[8];
        uint32_t mCounter[8];
        uint8_t mCounterCarryBit;
        uint16_t mKeystream[8];

        uint32_t bwr(uint8_t steps, uint32_t in);
        void nextState();
        void incrementCounter();
        void getKeystream();
        uint8_t getCCB(uint8_t number);
};

#endif // RABBIT_H

/*--------------------------------------------
Ab hier die Rabbit.cpp
--------------------------------------------*/

#include "rabbit.h"
#define MODULO 4294967295 //2^32

const uint32_t a[8] = {0x4D34D34D, 0xD34D34D3, 0x34D34D34, 0x4D34D34D, 0xD34D34D3, 0x34D34D34, 0x4D34D34D, 0xD34D34D3};

rabbit::rabbit(){mCounterCarryBit = 0;}

rabbit::rabbit(uint16_t key[8]){
    setKey(key);
    mCounterCarryBit = 0;
}

rabbit::~rabbit(){}

//Bit wise rotation (<<<)
uint32_t rabbit::bwr(uint8_t steps, uint32_t in){
    uint32_t tmp;
    tmp = in >> (32-steps);
    return (in << steps) + tmp;
}

void rabbit::setKey(uint16_t sKey[8]){
    //Set state variable (state 0-7)
    for(uint_fast8_t j = 0; j < 8; j++){
        //For j even, state (j) = key(j+1 mod 8) (concatenated with) key (j)
        if((j%2) == 0){
            mState[j] = sKey[(j+1)%8];
            mState[j] = (mState[j] << 16) + sKey[j];
        //For j odd, state(j) = key (j+5 mod 8) (concatenated with) key (j+4 mod 8)
        }else{
            mState[j] = sKey[(j+5) %8];
            mState[j] = (mState[j] << 16) + sKey[(j+4)%8];
        }
    }

    //Set counter variable (counter 0-7)
    for(uint_fast8_t j = 0; j < 8; j++){
        //For j even, counter (j) = key(j+4 mod 8) (concatenated with) key (j+5 mod8)
        if(j%2 == 0){
            mCounter[j] = sKey[(j+4)%8];
            mCounter[j] = (mCounter[j] << 16) + sKey[(j+5)%8];
        //For j odd, counter(j) = key (j+1 mod 8) (concatenated with) key (j)
        }else{
            mCounter[j] = sKey[(j+1) %8];
            mCounter[j] = (mCounter[j] << 16) + sKey[j];
        }
    }
    //To diminish correlations between bits in the key and bits in the internal state variables it iterates 4 times
    for(uint_fast8_t i = 0; i < 4; i++)
        nextState();
    //re-initialized to prevent key recoverty
    for(uint_fast8_t j = 0; j < 8; j++){
        mCounter[j] = mCounter[j] ^ mState[(j+4)%8];
    }
}

//Get the counter carry bit
uint8_t rabbit::getCCB(uint8_t number){
    static uint8_t lastCCB;
    if(number == 0){
        lastCCB = mCounterCarryBit;
        //If counter(0) + a (j)0 + carry (old 7) >= 2^32 AND j = 0 set carry 1 else 0
        if(mCounter[0]+a[0]+lastCCB >= MODULO){
            lastCCB = 1;
        }else{
            lastCCB = 0;
        }
        return lastCCB;
    }else{
        //If counter (j) + a(j) + carry (new j-1) >= 2^32 AND j > 0 set carry 1 else 0
        if(mCounter[number]+a[number]+lastCCB >= MODULO){
            lastCCB = 1;
        }else{
            lastCCB = 0;
        }
    }
    return lastCCB;
}

void rabbit::incrementCounter(){
    //Set incremented counter variables
    //counter (new 0) = counter (old 0) +a(0) + old carry bit (7) mod 2^32
    mCounter[0] = (mCounter[0] + a[0] + mCounterCarryBit)%MODULO;
    //for counter (j>0): counter(new j) = counter (old j) + a(j) + new carry bit (j-1) mod 2^32
    for(uint_fast8_t j = 1; j< 8;j++){
        mCounter[j] = (mCounter[j] + a[j] + getCCB(j-1))%MODULO;
    }
    mCounterCarryBit = getCCB(7);
}

void rabbit::nextState(){
    incrementCounter();

    uint32_t temp[8];
    //temp(j) = (state(j) + counter(j))^2 XOR ((state(j) + counter(j))^2 >> 32) mod 2^32
    for(uint_fast8_t j = 0; j < 8; j++){
        uint64_t a = (mState[j] + mCounter[j]);
        a = a*a;
        uint64_t b = (mState[j] + mCounter[j]);
        b = (b * b )>>32;
        temp[j] = a ^ b % MODULO;
    }

    //Set state variables
    mState[0] = (temp[0] + bwr(16, temp[7]) + bwr(16, temp[6])) % MODULO;
    mState[1] = (temp[1] + bwr(8, temp[0]) + temp[7]) % MODULO;
    mState[2] = (temp[2] + bwr(16, temp[1]) + bwr(16, temp[0])) % MODULO;
    mState[3] = (temp[3] + bwr(8, temp[2]) + temp[1]) % MODULO;
    mState[4] = (temp[4] + bwr(16, temp[3]) + bwr(16, temp[2])) % MODULO;
    mState[5] = (temp[5] + bwr(8, temp[4]) + temp[3]) % MODULO;
    mState[6] = (temp[6] + bwr(16, temp[5]) + bwr(16, temp[4])) % MODULO;
    mState[7] = (temp[7] + bwr(8, temp[6]) + temp[5]) % MODULO;
}

void rabbit::getKeystream(){
    mKeystream[0] = static_cast<uint16_t>((mState[0]) ^ (mState[5]>>16));
    mKeystream[1] = static_cast<uint16_t>((mState[0]>>16) ^ mState[3]);
    mKeystream[2] = static_cast<uint16_t>(mState[2] ^ (mState[7]>>16));
    mKeystream[3] = static_cast<uint16_t>((mState[2]>>16) ^ mState[5]);
    mKeystream[4] = static_cast<uint16_t>(mState[4] ^ (mState[1]>>16));
    mKeystream[5] = static_cast<uint16_t>((mState[4]>>16) ^ mState[7]);
    mKeystream[6] = static_cast<uint16_t>(mState[6] ^ (mState[3]>>16));
    mKeystream[7] = static_cast<uint16_t>((mState[6]>>16) ^ mState[1]);
}

void rabbit::encrypt(uint16_t *in, uint16_t *out){
    getKeystream();
    for(uint_fast8_t i = 0; i < 8; i++){
        *out = *in ^ mKeystream[i];
        out++;
        in++;
    }
    nextState();
}

void rabbit::decrypt(uint16_t *in, uint16_t *out){
    getKeystream();
    for(uint_fast8_t i = 0; i < 8; i++){
        *out = *in ^ mKeystream[i];
        out++;
        in++;
    }
    nextState();
}