Zermelo

//PBKDF2 Beta 1.1.cpp : Defines the entry point for the console application.
//PBKDF2 Beta 1.1 using the HMAC-SHA-1 as the Pseduo-Random Function

#include "stdafx.h"
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
unsigned long Rol(unsigned long x, int y);
unsigned long Ror(unsigned long x, int y);
unsigned long f(unsigned long B,unsigned long C,unsigned long D, int t);

unsigned long H[5];
unsigned long T[512]={0};
void HMAC(string text, string key);
void SHA1(string s);
void PBKDF2(string P,string S, int c, int dkLen);

int main()

{
    char P[8192];
    char S[8192];
    int dkLen,c;
    c = 4096;
    dkLen = 32;

    cout << "Enter Password: ";
    cin.getline(P, 8192, '\n');
    cout << "Enter Salt: ";
    cin.getline(S, 8192, '\n');;
    cout << "Enter Number of Iterations c: ";
    cin >> c;
    cout << "Enter intended length in bytes of the derived key: ";
    cin >> dkLen;

    cout << "Derived Key: " << endl;
    PBKDF2(P,S,c,dkLen);

    for(int i=0; i<(dkLen/4); i++)
    {
        cout << hex << T[i];
    }
    cout << endl << "Press Enter to End" << endl;
    cin >> c;
    return 0;
}

void PBKDF2(string P, string S,int c,int dkLen)
{
    string U;
    unsigned long L[5]={0,0,0,0,0};
    int hlen,l,r;
    char t;

    hlen = 20;
    //requires new version of Ceiling Function: l = ceil(dkLen/hlen)
    l = (dkLen/hlen)+1;
    r = dkLen -(l-1)*hlen;

    for(int i=1; i<=l; i++)
    {
        t = 0;
        U = S + t + t + t;
        t = i;
        U = U + t;
        L[0] = L[1] = L[2] = L[3] = L[4] = 0;
        for(int j=1; j<=c; j++)
        {
            HMAC(U,P);
            L[0] = L[0]^H[0];
            L[1] = L[1]^H[1];
            L[2] = L[2]^H[2];
            L[3] = L[3]^H[3];
            L[4] = L[4]^H[4];
            U = "";
            for(int x=0; x<5; x++)
            {
                for(int y=0; y<4; y++)
                {
                    t = ((H[x] >> 8*(3-y)) % 256);
                    U = U + t;
                }
            }
        }

        T[5*(i-1)] = L[0];
        T[5*(i-1)+1] = L[1];
        T[5*(i-1)+2] = L[2];
        T[5*(i-1)+3] = L[3];
        T[5*(i-1)+4] = L[4];
    }
}

// HMAC function
void HMAC(string text, string key)
{
    char c;
    string s;
    unsigned long Key[16] = {0};
    unsigned long X[16] = {0};
    unsigned long Y[16] = {0};
    unsigned long ipad = 0x36363636;
    unsigned long opad = 0x5c5c5c5c;
    int k;
    s = "";

    //Process string key into sub-key
    //Hash key in case it is less than 64 bytes
    if (key.length() > 64)
    {
        SHA1(key);
        Key[0] = H[0];
        Key[1] = H[1];
        Key[2] = H[2];
        Key[3] = H[3];
        Key[4] = H[4];
    }
    else
    {
        for(int i=0; i<16; i++)
        {
            for(int j=0; j<4; j++)
            {
                if (4*i+j <= key.length())
                {
                    k = key[4*i+j];
                }
                else
                {
                    k = 0;
                }
                if (k<0)
                {
                    k = k + 256;
                }
                Key[i]= Key[i] + k*pow(256,(double)3-j);
            }
        }
    }

    for(int i=0; i<16; i++)
    {
        X[i] = Key[i]^ipad;
        Y[i] = Key[i]^opad;
    }

    //Turn X-Array into a String
    for(int i=0; i<16; i++)
    {
        for(int j=0; j<4; j++)
        {
            c = ((X[i] >> 8*(3-j)) % 256);
            s = s + c;
        }
    }

    //Append text to string
    s = s + text;

    //Hash X-Array
    SHA1(s);

    s = "";

    //Turn Y-Array into a String
    for(int i=0; i<16; i++)
    {
        for(int j=0; j<4; j++)
        {
            c = ((Y[i] >> 8*(3-j)) % 256);
            s = s + c;
        }
    }

    //Append Hashed X-Array to Y-Array in string
    for(int i=0; i<5; i++)
    {
        for(int j=0; j<4; j++)
        {
            c = ((H[i] >> 8*(3-j)) % 256);
            s = s + c;
        }
    }

    //Hash final concatenated string
    SHA1(s);
}

// SHA-1 Algorithm
void SHA1(string s)
{
    unsigned long K[80];
    unsigned long A,B,C,D,E,TEMP;
    int r,k,ln;
    H[0]=0x67452301;
    H[1]=0xefcdab89;
    H[2]=0x98badcfe;
    H[3]=0x10325476;
    H[4]=0xc3d2e1f0;

    ln=s.length();
    r = int((ln+1)/64);

    if (((ln+1) % 64) > 56)
        {
        r=r+1;
        }

    // initialize Constants
    for(int t=0; t<80; t++)
        {
            if (t<20)
                {
                    K[t] = 0x5a827999;
                }

            if ((t>19)&(t<40))
                {
                    K[t] = 0x6ED9EBA1;
                }
            if ((t>39)&(t<60))
                {
                    K[t] = 0x8F1BBCDC;
                }
            if (t>59)
                {
                    K[t] = 0xca62c1d6;
                }
        }

    for(int l=0; l <= r; l++)
    {
        unsigned long W[80]={0};
        //Initialize Text
        for (int i=0; i<16; i++)
            {
            for(int j=0; j<4; j++)
                {
                    if (4*i+j <= ln)
                    {
                        k = s[64*l+4*i+j];
                    }
                    else
                    {
                        k =0;
                    }

                    if (k<0)
                    {
                        k = k +256;
                    }

                    if (4*i+j == ln)
                        {
                            k = 0x80;
                        }

                    W[i]= W[i] + k*pow(256,(double)3-j);
                }
            }
        if ((W[14]==0)&(W[15]==0))
        {
            W[15]=8*s.length();
        }

    // Hash Cycle

        for (int t = 16; t <80; t++)
            {
                W[t] = Rol(W[t-3]^W[t-8]^W[t-14]^W[t-16],1);
            }

        A = H[0];
        B = H[1];
        C = H[2];
        D = H[3];
        E = H[4];

        for(int t = 0; t < 80; t++)
        {
            TEMP = Rol(A,5) + f(B,C,D,t) + E + W[t] + K[t];
            E = D;
            D = C;
            C = Rol(B,30);
            B = A;
            A = TEMP;
        }

        H[0] = H[0] + A;
        H[1] = H[1] + B;
        H[2] = H[2] + C;
        H[3] = H[3] + D;
        H[4] = H[4] + E;

        ln = ln - 64;
    }

}

unsigned long f(unsigned long B,unsigned long C,unsigned long D, int t)
{
    if (t < 20)
        {
            return ((B & C)^((~B) & D));
        }
    if ((t > 19) & (t < 40))
        {
            return (B ^ C ^ D);
        }
    if ((t > 39) & (t < 60))
        {
            return ((B & C)^(B & D)^(C & D));
        }
    if (t > 59)
        {
            return (B ^ C ^ D);
        }
}


unsigned long Rol(unsigned long x, int y)
{
    if (y % 32 == 0) {return x;}
    else {return ((x << y)^(x >> -y));}
}

unsigned long Ror(unsigned long x, int y)
{
    if (y % 32 == 0) {return x;}
    else {return ((x >> y)^(x << -y));}
}