dz2_raw

#include <iostream>
#include <vector>
#include <string>
#include <iomanip>
#include <bitset>

typedef unsigned __int16 Block;

static int SHIFT = 1;
static int ENCRYPT_WAY = 1;

struct CircularData
{
    Block data = 0;
};

CircularData createCircularData(Block data)
{
    return CircularData({ data });
}

CircularData operator>>(CircularData l, int n)
{
    Block mask = 0x0;
    for (int i = 0; i < n; i++) {
        mask <<= 1;
        mask |= 1;
    }
    Block cycle = (l.data & mask) << (16 - n);

    return CircularData({
        static_cast<Block>((l.data >> n) | cycle)
    });
}

CircularData operator<<(CircularData l, int n)
{
    Block mask = 0x0;
    for (int i = 0; i < n; i++) {
        mask <<= 1;
        mask |= 1;
    }
    Block cycle = (l.data >> (16 - n)) & mask;

    return CircularData({
        static_cast<Block>((l.data << n) | cycle)
    });
}

CircularData operator^(CircularData l, Block r)
{
    return CircularData({
        static_cast<Block>(l.data ^ r)
    });
}

bool operator==(CircularData l, CircularData r)
{
    return l.data == r.data;
}

void encrypt(CircularData *data, Block salt)
{
    if (ENCRYPT_WAY == 0) {
        (*data) = (*data ^ salt) << SHIFT;
    } else {
        (*data) = (*data ^ salt) >> SHIFT;
    }
}

// (var ^ v) ^ v == var
void decrypt(CircularData *data, Block salt)
{
    if (ENCRYPT_WAY == 0) {
        (*data) = (*data >> SHIFT) ^ salt;
    } else {
        (*data) = (*data << SHIFT) ^ salt;
    }
}

int main(int argc, char *argv[])
{
    if (argc >= 3) {
        ENCRYPT_WAY = atoi(argv[1]);
        SHIFT = atoi(argv[2]);
    }
    std::cout << "Way  : " << (ENCRYPT_WAY == 0 ? "<<" : ">>") << std::endl;
    std::cout << "Shift: " << SHIFT << std::endl;

    std::string input;
    std::getline(std::cin, input);
    std::vector<CircularData> data;
    for (auto &c : input) {
        static size_t index = 0;
        static Block block = 0;
        if (index % 2 == 0) {
            block = c << 8;
        } else {
            block |= c;
        }

        data.emplace_back(
            std::move(createCircularData(block))
        );
        index++;
    }

    std::string key;
    std::getline(std::cin, key);

    unsigned int srandKey = 0;
    srandKey |= 0x90000000 ^ (key[0] << 24);        // 1001 at the end
    for (size_t i = 1; i < 4; i++) {
        char current = key.size() > i ? key[i] : 0;
        srandKey |= current << 8 * (3 - i);
    }
    srand(srandKey);
    Block salt = rand();

    std::vector<CircularData> dataCopy(data);
    for (auto &d : dataCopy)
        encrypt(&d, salt);
    for (auto &d : dataCopy)
        decrypt(&d, salt);

    std::cout << (dataCopy == data) << std::endl;

    return 0;
}