PKM Encryption

#include <stdio.h>

#include <stdlib.h>

#include <iostream>

#include <fstream>

using namespace std;

unsigned int seed;

void setseed(unsigned int newSeed){

    seed = newSeed;

}

unsigned int srand(){

    seed = ((0x41c64e6d * seed + 0x6073)) & 4294967295L;

    return seed >> 16;

}



unsigned int toUInt32(unsigned char* input, int offset){

    union{

        unsigned int num;

        unsigned char bytes[4];

    } obj;

    for(int i = offset; i < offset + 4; i++)

        obj.bytes[i - offset] = input[i];

    return obj.num;

}



unsigned short toUInt16 (unsigned char* input, int offset){

    union{

        unsigned short num;

        unsigned char bytes[2];

    } obj;

    for(int i = offset; i < offset + 2; i++)

        obj.bytes[i - offset] = input[i];

    return obj.num;

}



unsigned char* encrypt(unsigned char* pks2)

{

    unsigned int pid = 0;

    unsigned short checksum = 0;

    pid = toUInt32(pks2, 0);

    checksum = toUInt16(pks2, 6);

    int order = (pid >> (13) & 31) % 24;

    char firstblock, secondblock, thirdblock, fourthblock;



    switch (order) {

        case 0:

            firstblock = 'A';

            secondblock = 'B';

            thirdblock = 'C';

            fourthblock = 'D';

            break;

        case 1:

            firstblock = 'A';

            secondblock = 'B';

            thirdblock = 'D';

            fourthblock = 'C';

            break;

        case 2:

            firstblock = 'A';

            secondblock = 'C';

            thirdblock = 'B';

            fourthblock = 'D';

            break;

        case 3:

            firstblock = 'A';

            secondblock = 'C';

            thirdblock = 'D';

            fourthblock = 'B';

            break;

        case 4:

            firstblock = 'A';

            secondblock = 'D';

            thirdblock = 'B';

            fourthblock = 'C';

            break;

        case 5:

            firstblock = 'A';

            secondblock = 'D';

            thirdblock = 'C';

            fourthblock = 'B';

            break;

        case 6:

            firstblock = 'B';

            secondblock = 'A';

            thirdblock = 'C';

            fourthblock = 'D';

            break;

        case 7:

            firstblock = 'B';

            secondblock = 'A';

            thirdblock = 'D';

            fourthblock = 'C';

            break;

        case 8:

            firstblock = 'B';

            secondblock = 'C';

            thirdblock = 'A';

            fourthblock = 'D';

            break;

        case 9:

            firstblock = 'B';

            secondblock = 'C';

            thirdblock = 'D';

            fourthblock = 'A';

            break;

        case 10:

            firstblock = 'B';

            secondblock = 'D';

            thirdblock = 'A';

            fourthblock = 'C';

            break;

        case 11:

            firstblock = 'B';

            secondblock = 'D';

            thirdblock = 'C';

            fourthblock = 'A';

            break;

        case 12:

            firstblock = 'C';

            secondblock = 'A';

            thirdblock = 'B';

            fourthblock = 'D';

            break;

        case 13:

            firstblock = 'C';

            secondblock = 'A';

            thirdblock = 'D';

            fourthblock = 'B';

            break;

        case 14:

            firstblock = 'C';

            secondblock = 'B';

            thirdblock = 'A';

            fourthblock = 'D';

            break;

        case 15:

            firstblock = 'C';

            secondblock = 'B';

            thirdblock = 'D';

            fourthblock = 'A';

            break;

        case 16:

            firstblock = 'C';

            secondblock = 'D';

            thirdblock = 'A';

            fourthblock = 'B';

            break;

        case 17:

            firstblock = 'C';

            secondblock = 'D';

            thirdblock = 'B';

            fourthblock = 'A';

            break;

        case 18:

            firstblock = 'D';

            secondblock = 'A';

            thirdblock = 'B';

            fourthblock = 'C';

            break;

        case 19:

            firstblock = 'D';

            secondblock = 'A';

            thirdblock = 'C';

            fourthblock = 'B';

            break;

        case 20:

            firstblock = 'D';

            secondblock = 'B';

            thirdblock = 'A';

            fourthblock = 'C';

            break;

        case 21:

            firstblock = 'D';

            secondblock = 'B';

            thirdblock = 'C';

            fourthblock = 'A';

            break;

        case 22:

            firstblock = 'D';

            secondblock = 'C';

            thirdblock = 'A';

            fourthblock = 'B';

            break;

        case 23:

            firstblock = 'D';

            secondblock = 'C';

            thirdblock = 'B';

            fourthblock = 'A';

            break;

    }



    // BLOCK A

    int z = 0;

    int v = 8;

    unsigned short* blocka = new unsigned short[17];

    while (z < 16) {

        blocka[z] = toUInt16(pks2, v);

        z = z + 1;

        v = v + 2;

    }



    // BLOCK B

    z = 0;

    v = 40;

    unsigned short* blockb = new unsigned short[17];

    while (z < 16) {

        blockb[z] = toUInt16(pks2, v);

        z = z + 1;

        v = v + 2;

    }



    // BLOCK C

    z = 0;

    v = 72;

    unsigned short* blockc = new unsigned short[17];

    while (z < 16) {

        blockc[z] = toUInt16(pks2, v);

        z = z + 1;

        v = v + 2;

    }



    // BLOCK D

    z = 0;

    unsigned short* blockd = new unsigned short[17];

    v = 104;

    while (z < 16) {

        blockd[z] = toUInt16(pks2, v);

        z = z + 1;

        v = v + 2;

    }



    setseed(checksum);



    // BYTER (FIRSTBLOCK)

    unsigned short* byter = new unsigned short[17];

    z = 0;

    v = 8;

    switch (firstblock) {

        case 'A':

            while (z < 16) {

                byter[z] = blocka[z] ^ srand();

                z = z + 1;

            }

            break;

        case 'B':

            while (z < 16) {

                byter[z] = blockb[z] ^ srand();

                z = z + 1;

            }

            break;

        case 'C':

            while (z < 16) {

                byter[z] = blockc[z] ^ srand();

                z = z + 1;

            }

            break;

        case 'D':

            while (z < 16) {

                byter[z] = blockd[z] ^ srand();

                z = z + 1;

            }

            break;

    }

    z = 0;

    v = 8;

    while (z < 16) {

        pks2[v] = byter[z] & 255;

        pks2[v + 1] = byter[z] >> 8;

        z = z + 1;

        v = v + 2;

    }



    // SECONDBLOCK

    z = 0;

    v = 40;

    switch (secondblock) {

        case 'A':

            while (z < 16) {

                byter[z] = blocka[z] ^ srand();

                z = z + 1;

            }

            break;

        case 'B':

            while (z < 16) {

                byter[z] = blockb[z] ^ srand();

                z = z + 1;

            }

            break;

        case 'C':

            while (z < 16) {

                byter[z] = blockc[z] ^ srand();

                z = z + 1;

            }

            break;

        case 'D':

            while (z < 16) {

                byter[z] = blockd[z] ^ srand();

                z = z + 1;

            }

            break;

    }

    z = 0;

    while (z < 16) {

        pks2[v] = byter[z] & 255;

        pks2[v + 1] = byter[z] >> 8;

        z = z + 1;

        v = v + 2;

    }



    // THIRDBLOCK

    z = 0;

    v = 72;

    switch (thirdblock) {

        case 'A':

            while (z < 16) {

                byter[z] = blocka[z] ^ srand();

                z = z + 1;

            }

            break;

        case 'B':

            while (z < 16) {

                byter[z] = blockb[z] ^ srand();

                z = z + 1;

            }

            break;

        case 'C':

            while (z < 16) {

                byter[z] = blockc[z] ^ srand();

                z = z + 1;

            }

            break;

        case 'D':

            while (z < 16) {

                byter[z] = blockd[z] ^ srand();

                z = z + 1;

            }

            break;

    }

    z = 0;

    while (z < 16) {

        pks2[v] = byter[z] & 255;

        pks2[v + 1] = byter[z] >> 8;

        z = z + 1;

        v = v + 2;

    }



    // FOURTHBLOCK

    z = 0;

    v = 104;

    switch (fourthblock) {

        case 'A':

            while (z < 16) {

                byter[z] = blocka[z] ^ srand();

                z = z + 1;

            }

            break;

        case 'B':

            while (z < 16) {

                byter[z] = blockb[z] ^ srand();

                z = z + 1;

            }

            break;

        case 'C':

            while (z < 16) {

                byter[z] = blockc[z] ^ srand();

                z = z + 1;

            }

            break;

        case 'D':

            while (z < 16) {

                byter[z] = blockd[z] ^ srand();

                z = z + 1;

            }

            break;

    }

    z = 0;

    while (z < 16) {

        pks2[v] = byter[z] & 255;

        pks2[v + 1] = byter[z] >> 8;

        z = z + 1;

        v = v + 2;

    }



    return pks2;

}

int main(int argc, char* argv[])

{

    if(sizeof(int) != 4){

        printf("The algorithm is incompatible with the system.");

        exit(-1);

    }

    ifstream file (argv[1]);

    unsigned char* input = new unsigned char[136];

    file.read((char*)input, 136);

    unsigned char* output = encrypt(input);

    /*for(int i = 0; i < 136; i++){

        printf("%c", output[i]);

    }*/

    ofstream file2 (argv[2], ios::out | ios::binary);

    file2.write((char*)output, 136);

    file2.close();

    return 0;

}