// Copyright (c) The University of Cincinnati. All rights reserved.
// UC MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
// THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
// TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
// PARTICULAR PURPOSE, OR NON-INFRINGEMENT.  UC SHALL NOT BE LIABLE
// FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING,
// RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
// DERIVATIVES.
// By using or copying this Software, Licensee agrees to abide by the
// intellectual property laws, and all other applicable laws of the
// U.S., and the terms of this license.

// Author : Antarpreet Singh
//

#include <iostream>
#include <vector>
#include <math.h>
#include <string>

using namespace std;

typedef vector <double> double_vector;  
typedef vector <bool> bool_vector;

void CPA_HD(vector<double_vector>&, vector<bool_vector>&, vector<double>&, int, vector<bool>&);
void TEST1(vector <bool>*, vector <bool>*, vector <bool>*);

bool DPA_HD_CPA(int no_of_output_bits, int max_key_comb, int vectors, vector <bool_vector> &ptext, vector <double_vector> &current_data, vector <double_vector> &diffwf, int *final_key, vector <bool_vector> &kg, double *max, int clock_posedge_time_min, int clock_posedge_time_max, int correct_key, ofstream &fplog, string testname, string algorithm) { 

  vector <bool_vector> ctext;
  vector <bool> ctext_temp;
  
  vector <double> diffwf_temp;

  int i,j,k;
  double absmax;
  bool done;

  int keyvalue;
  int ctext_size;

  vector <bool> prev_ctext(no_of_output_bits,0);

    for(j=0;j<max_key_comb;j++) {

      //Peform DES
      for(i=0;i<ptext.size()-1;i++) {
	      if (algorithm == "DES10") {
        	DES10(&ptext[i],&kg[j],&ctext_temp);
	      } 
	      else if (algorithm == "TEST1") {
        	TEST1(&ptext[i],&kg[j],&ctext_temp);
	      }
        ctext.push_back(ctext_temp);
        ctext_temp.clear();
      }

      ctext_size = ctext.size();      
      if(vectors > ctext_size) {
        cout<<" All the vectors are exhausted. Unable to find key"<<"\n";
        fplog<<" All the vectors are exhausted. Unable to find key"<<"\n";
        exit(1);
      }
      //Perform DPA
      CPA_HD(current_data,ctext,diffwf_temp,vectors,prev_ctext);
      diffwf.push_back(diffwf_temp);
      diffwf_temp.clear();
      ctext.clear();
    }

    for(j=0;j<max_key_comb;j++) {
      *(max+j) = diffwf[j][0];  
      for(i=clock_posedge_time_min;i<clock_posedge_time_max;i++) {
        if( diffwf[j][i] > max[j]) {
          *(max+j) = diffwf[j][i];
        }
      }
    }

    absmax = *max;
    keyvalue = 0;

    for(j=1;j<max_key_comb;j++) {
      if( *(max+j) > absmax) {
        absmax = *(max+j);
        keyvalue = j;
      }
    }
    
    cout<<"Key Guess is : "<<keyvalue<<"\n";
    fplog<<"Key Guess is : "<<keyvalue<<"\n";

    cout<<"Correlation For Key Guess : "<<max[keyvalue]<<"\n";
    fplog<<"Correlation For Key Guess : "<<max[keyvalue]<<"\n";

    *final_key = keyvalue;
    if ((*final_key) == correct_key) {
      done = 1;
    } else if (vectors > ctext_size) {
      cout<<"Found Incorrect key\n";
      fplog<<"Found Incorrect key\n";
      exit(2);
    }
    else { 
      cout<<"Correlation For Correct key : "<<max[correct_key]<<"\n";
      fplog<<"Correlation For Correct key : "<<max[correct_key]<<"\n";
      done = 0;
    }
  return(done);
}

/******************************************************************/

void CPA_HD(vector<double_vector> &current_data, vector<bool_vector> &ctext, vector<double> &corr, int vectors, vector<bool> &prev_ctext) {

  double hwt,prod,sum_hw,sum_curr,sq_hw,sq_curr;
  int i,j;
  double cofficient;
 
  //Power Model for DPA
  int no_of_samples_x = current_data[0].size();
 
  for (j=0; j < no_of_samples_x ; j++) {

    hwt=0;prod=0;sum_hw=0;sum_curr=0;sq_hw=0;sq_curr=0;
 
    for(i=0; i < vectors; i++) {
      hwt = HD(ctext[i],prev_ctext);
      prod += (hwt)*(current_data[i][j]);
      sum_hw +=  hwt;
      sum_curr += current_data[i][j];
      sq_hw += (hwt*hwt);
      sq_curr += (current_data[i][j])*(current_data[i][j]);
    }
    cofficient = ((vectors*prod) - (sum_hw*sum_curr))/(sqrt((vectors*sq_curr)-(sum_curr*sum_curr))*sqrt((vectors*sq_hw)-(sum_hw*sum_hw)));
    corr.push_back(cofficient);
  } 
}

/******************************************************************/