GCrypt/main.cpp

#include <iostream>
#include <sstream>
#include <array>
#include <bitset>

#define BLOCK_SIZE 128
#define HALFBLOCK_SIZE (BLOCK_SIZE / 2)
#define N_ROUNDS 128

typedef std::bitset<BLOCK_SIZE> Block;
typedef std::bitset<HALFBLOCK_SIZE> Halfblock;
typedef std::array<Block, N_ROUNDS> Keyset;

// Will convert a string to a data block
Block StringToBits(const std::string& s);

// Will convert a data block to a string
std::string BitsToString(const Block& bits);

// Split a data block into two half blocks (into L and R)
std::pair<Halfblock, Halfblock> FeistelSplit(const Block& block);

// Combine two half blocks (L and R) into a regular data block
Block FeistelCombine(const Halfblock& l, const Halfblock& r);

// Creates a key of size key-size from a password of arbitrary length.
Block PasswordToKey(const std::string& in);

// Will generate a keyset from a seed-key
Keyset GenerateRoundkeys(const Block& seedKey);

// Feistel-cipher
Block Feistel(const Block& data, const Keyset& keys, bool reverseKeyOrder = false);

// Will expand a halfblock to a fullblock
Block ExpansionFunction(const Halfblock& block);

// Will compress a fullblock to a halfblock
Halfblock CompressionFunction(const Block& block);

// Substitutes four bits by static random others
std::string SBox(const std::string& in);

// Arbitrary cipher function
Halfblock F(Halfblock m, const Block& key);

template<std::size_t T>
std::bitset<T> Shiftl(const std::bitset<T>& bits, std::size_t amount);

template<std::size_t T>
std::bitset<T> Shiftr(const std::bitset<T>& bits, std::size_t amount);

std::string DiffusionCheck(const std::string& asciiMessage);

int Mod(int numerator, int denominator)
{
    return (denominator + (numerator % denominator)) % denominator;
}


int main()
{
    const std::string cipher1 = DiffusionCheck("Hello, World :3");
    
    std::cout << std::endl;

    const std::string cipher2 = DiffusionCheck("Hello, world :3");

    std::size_t numDiff = 0;
    for (std::size_t i = 0; i < cipher1.size(); i++)
        if (cipher1[i] != cipher2[i])
            numDiff++;
    std::cout << std::endl;
    std::cout << "Total difference between C1 and C2: " << numDiff << std::endl;

    return 0;
}

std::string DiffusionCheck(const std::string& asciiMessage)
{
    Block message = StringToBits(asciiMessage);

    const Block seedKey = PasswordToKey("Ich bin ein PASSWORT-SCHLÜSSEL!");
    Keyset roundkeys = GenerateRoundkeys(seedKey);

    //std::cout << "Keys: " << std::endl;
    //for (std::size_t i = 0; i < roundkeys.size(); i++)
    //    std::cout << roundkeys[i] << std::endl;
    //std::cout << "---" << std::endl;
    //exit(0);


    std::cout << "Message ascii:   " << asciiMessage << std::endl;

    std::cout << "Message:         " << message << std::endl;

    Block ciphertext = Feistel(message, roundkeys);
    std::cout << "Ciphertext:      " << ciphertext << std::endl;

    Block decrypted = Feistel(ciphertext, roundkeys, true);
    std::cout << "Decrypted:       " << decrypted << std::endl;

    const std::string asciiDecrypted = BitsToString(decrypted);
    std::cout << "Decrypted ascii: " << asciiDecrypted << std::endl;

    return ciphertext.to_string();
}

Block Feistel(const Block& data, const Keyset& keys, bool reverseKeyOrder)
{
    const auto splitData = FeistelSplit(data);
    Halfblock l = splitData.first;
    Halfblock r = splitData.second;

    Halfblock tmp;

    for (std::size_t i = 0; i < N_ROUNDS; i++)
    {
        // Calculate key index
        std::size_t keyIndex;
        if (reverseKeyOrder)
            keyIndex = N_ROUNDS - i - 1;
        else
            keyIndex = i;

        // Do a feistel round
        tmp = r;
        r = l ^ F(r, keys[keyIndex]);
        l = tmp;
    }

    return FeistelCombine(r, l);
}

Halfblock F(Halfblock m, const Block& key)
{
    // Made-up F function

    // Expand to full bitwidht
    Block m_expanded = ExpansionFunction(m);

    // Shift to left by 1
    m_expanded = Shiftl(m_expanded, 1);

    // Xor with key
    m_expanded ^= key;

    // Non-linearly apply subsitution boxes
    std::stringstream ss;
    const std::string m_str = m_expanded.to_string();

    for (std::size_t i = 0; i < m_str.size(); i += 4)
    {
        ss << SBox(m_str.substr(i, 4));
    }

    m_expanded = Block(ss.str());

    // Return the compressed version
    return CompressionFunction(m_expanded);
}

Block ExpansionFunction(const Halfblock& block)
{
    std::stringstream ss;
    const std::string bits = block.to_string();

    // We have to double the bits!
    for (std::size_t i = 0; i < bits.size(); i += 2)
    {
        const std::string sub = bits.substr(i, 2);

             if (sub == "00")     ss << "1101";
        else if (sub == "01")     ss << "1000";
        else if (sub == "10")     ss << "0010";
        else /*if (sub == "11")*/ ss << "0111";

    }

    return Block(ss.str());
}

Halfblock CompressionFunction(const Block& block)
{
    std::stringstream ss;
    const std::string bits = block.to_string();

    // We have to double the bits!
    for (std::size_t i = 0; i < bits.size(); i += 4)
    {
        const std::string sub = bits.substr(i, 4);

             if (sub == "0000")     ss << "10";
        else if (sub == "0001")     ss << "01";
        else if (sub == "0010")     ss << "10";
        else if (sub == "0011")     ss << "10";
        else if (sub == "0100")     ss << "11";
        else if (sub == "0101")     ss << "01";
        else if (sub == "0110")     ss << "00";
        else if (sub == "0111")     ss << "11";
        else if (sub == "1000")     ss << "01";
        else if (sub == "1001")     ss << "00";
        else if (sub == "1010")     ss << "11";
        else if (sub == "1011")     ss << "00";
        else if (sub == "1100")     ss << "11";
        else if (sub == "1101")     ss << "10";
        else if (sub == "1110")     ss << "00";
        else /*if (sub == "1111")*/ ss << "01";
    }

    return Halfblock(ss.str());
}

std::string SBox(const std::string& in)
{
         if (in == "0000")     return "1100";
    else if (in == "0001")     return "1000";
    else if (in == "0010")     return "0001";
    else if (in == "0011")     return "0111";
    else if (in == "0100")     return "1011";
    else if (in == "0101")     return "0011";
    else if (in == "0110")     return "1101";
    else if (in == "0111")     return "1111";
    else if (in == "1000")     return "0000";
    else if (in == "1001")     return "1010";
    else if (in == "1010")     return "0100";
    else if (in == "1011")     return "1001";
    else if (in == "1100")     return "0010";
    else if (in == "1101")     return "1110";
    else if (in == "1110")     return "0101";
    else /*if (in == "1111")*/ return "0110";
}

Block StringToBits(const std::string& s)
{
    std::stringstream ss;

    for (std::size_t i = 0; i < s.size(); i++)
        ss << std::bitset<8>(s[i]);

    // Pad rest with zeores
    for (std::size_t i = s.size() * 8; i < BLOCK_SIZE; i++)
        ss << '0';

    return Block(ss.str());
}

std::string BitsToString(const Block& bits)
{
    std::stringstream ss;

    const std::string bitstring = bits.to_string();

    for (std::size_t i = 0; i < BLOCK_SIZE; i += 8)
    {
        ss << (char)std::bitset<8>(bitstring.substr(i, 8)).to_ulong();
    }

    return ss.str();
}

std::pair<Halfblock, Halfblock> FeistelSplit(const Block& block)
{
    const std::string bits = block.to_string();

    Halfblock l(bits.substr(0, bits.size() / 2));
    Halfblock r(bits.substr(bits.size() / 2));

    return std::make_pair(l, r);
}

Block FeistelCombine(const Halfblock& l, const Halfblock& r)
{
    return Block(l.to_string() + r.to_string());
}

Keyset GenerateRoundkeys(const Block& seedKey)
{
    Keyset keys;

    keys[0] = seedKey;
    keys[1] = (Shiftl(seedKey, 32) ^ keys[0]);

    for (std::size_t i = 2; i < keys.size(); i++)
    {
        keys[i] = Shiftl(keys[i-1], i + 32) ^ keys[i-2];
    }

    return keys;
}

template <std::size_t T>
std::bitset<T> Shiftl(const std::bitset<T>& bits, std::size_t amount)
{
    std::stringstream ss;
    const std::string bitss = bits.to_string();

    for (std::size_t i = 0; i < bitss.size(); i++)
        ss << bitss[Mod((i + amount), bitss.size())];

    return std::bitset<T>(ss.str());
}

template <std::size_t T>
std::bitset<T> Shiftr(const std::bitset<T>& bits, std::size_t amount)
{
    std::stringstream ss;
    const std::string bitss = bits.to_string();

    for (std::size_t i = 0; i < bitss.size(); i++)
        ss << bitss[Mod((i - amount), bitss.size())];

    return std::bitset<T>(ss.str());
}

Block PasswordToKey(const std::string& in)
{
    Block b;

    // Segment the password in segments of key-size, and xor them together.
    for (std::size_t i = 0; i < in.size(); i += BLOCK_SIZE / 8)
        b ^= StringToBits(in.substr(i, BLOCK_SIZE / 8));

    return b;
}