#define DBG_OUT(msg) fprintf(stderr, "MSG %s:%d:%s: %s\n", __FILE__, __LINE__, __FUNCTION__, msg);

#define DBG_OUT_E(msg) fprintf(stderr, "MSG %s:%d:%s: %s : 0x%X\n", __FILE__, __LINE__, __FUNCTION__, msg, GetLastError());


void printN(char *descr, unsigned char *dat, size_t amount){
    printf("%s:\n", descr);
    int i;
    for(i =0; i < amount; i++){
        printf("%02X ", *(dat + i));
    }

    printf("\n");
}

HCRYPTPROV hProv;

HCRYPTKEY gen_fake_session_key(){

    HCRYPTKEY sess_key = 0;

    HCRYPTHASH sess_hash = 0;
    const unsigned char *sess_secret = "session fake-secret data.";

    if (!CryptCreateHash(hProv, CALG_GR3411, 0, 0, &sess_hash))
    {
        DBG_OUT_E("Can't create CALG_GR3411 hash!");
        return 0;
    }

    if (!CryptHashData(sess_hash, sess_secret, strlen(sess_secret), 0)) {
        CryptDestroyHash(sess_hash);
        DBG_OUT_E("Can't hash sess data");
        return 0;
    }

    if (!CryptDeriveKey(hProv, CALG_G28147, sess_hash, CRYPT_EXPORTABLE, &sess_key)) {
        CryptDestroyHash(sess_hash);
        DBG_OUT_E("Can't derive sess key from hash.");
        return 0;
    }

    CryptDestroyHash(sess_hash);

    return sess_key;
}

static int make_imito(HCRYPTPROV hProv)
{

    unsigned char IV[ SEANCE_VECTOR_LEN ] = {1, 2, 3, 4, 5, 6, 7, 8};
    unsigned char data[ G28147_KEYLEN ];
    
    memset(data, 0, G28147_KEYLEN);


    HCRYPTKEY imito_key = gen_fake_session_key();

/*
    DWORD dparam = ZERO_PADDING;

    if (!CryptSetKeyParam(imito_key, KP_PADDING, (BYTE*)&dparam, 0))
    {
        DBG_OUT_E("Can't set ZERO_PADDING for generated KEK.");
        return 0;
    }
*/

    if (!CryptSetKeyParam(imito_key, KP_IV, IV, 0)) {
        DBG_OUT_E("Can't set IV for IMITO");
        return 0;
    }

    HCRYPTHASH im = 0;
    if(!CryptCreateHash(hProv, CALG_G28147_IMIT, imito_key, 0, &im))
    {
      DBG_OUT_E("Can't create IMITO hash");
      return 0;
    }

    if(!CryptHashData(im, data, G28147_KEYLEN, 0))
    {
        DBG_OUT_E("Can't hash");
        return 0;
    }

    unsigned char calc_imito [ EXPORT_IMIT_SIZE ];
    DWORD imitLen = EXPORT_IMIT_SIZE;

    if(!CryptGetHashParam(im,
                         HP_HASHVAL,
                         calc_imito, 
                         &imitLen, 0))
    {
        DBG_OUT_E("Can't get CEK hash data");
        return 0;
    }

    CryptDestroyHash(im);
    CryptDestroyKey(imito_key);

    printN(" Calc IMIT: ", calc_imito, 4);

    return 1;
}


int main(int argc, char** argv) {

    hProv = 0;
   
    if (CryptAcquireContext(&hProv, NULL, NULL, PROV_GOST_2001_DH, CRYPT_VERIFYCONTEXT))
    {
        DBG_OUT("Container used");
    }
    else
    {
        DBG_OUT("Can't obtain context");
        exit(3);
    }

    make_imito(hProv);

    return (EXIT_SUCCESS);
}