public Boolean ContainsAPUF(ArbiterPUF aPUFModel) { Boolean containsPUFInstance = false; if (NoisyAPUFList.Contains(aPUFModel) == true) { containsPUFInstance = true; } return(containsPUFInstance); }
public object Clone() { ArbiterPUF aPUFCopy = new ArbiterPUF(Weight); //Automatically clones the weights in the constructor //Other variables must be set manually aPUFCopy.BitNumber = BitNumber; aPUFCopy.WeightMean = WeightMean; aPUFCopy.WeightVariance = WeightVariance; aPUFCopy.NoiseMean = NoiseMean; aPUFCopy.NoiseVariance = NoiseVariance; aPUFCopy.MajorityVoteCount = MajorityVoteCount; return(aPUFCopy); }
//Default constructor public XORArbiterPUF(int numPUFIN, int bitNum, double aPUFMean, double aPUFVar) { //set the input variables BitNumber = bitNum; NumPUF = numPUFIN; MeanForAPUF = aPUFMean; VarianceForAPUF = aPUFVar; ArbiterPUFArray = new ArbiterPUF[NumPUF]; //Initialize the arbiter PUF array for (int i = 0; i < NumPUF; i++) { ArbiterPUFArray[i] = new ArbiterPUF(bitNumber, MeanForAPUF, VarianceForAPUF); } }
//Copy constructor public XORArbiterPUF(int numPUFIN, int bitNum, double[][] weightsIN, double aPUFMean, double aPUFVar, double noiseMeanAPUFIN, double noiseVarianceAPUFIN) { //set the input variables BitNumber = bitNum; NumPUF = numPUFIN; MeanForAPUF = aPUFMean; VarianceForAPUF = aPUFVar; NoiseMeanForAPUF = noiseMeanAPUFIN; NoiseVarianceForAPUF = noiseVarianceAPUFIN; ArbiterPUFArray = new ArbiterPUF[NumPUF]; //Initialize the arbiter PUF array for (int i = 0; i < NumPUF; i++) { ArbiterPUFArray[i] = new ArbiterPUF(weightsIN[i], NoiseMeanForAPUF, NoiseVarianceForAPUF); } }
//Takes in weights, phi challenges and target response bits, gives average error of APUF model public double ObjFunValueOfInverseModel(double[] weightVector, double[][] phiChallenges, double[][] targets) { int sampleNumber = phiChallenges.Length; //Number of challenge-response pairs (number of training samples) ArbiterPUF aPUFModel = new ArbiterPUF(weightVector); double error = 0; for (int currentSample = 0; currentSample < sampleNumber; currentSample++) { double currentTarget = targets[currentSample][0]; double modelOutput = aPUFModel.ComputeResponse(phiChallenges[currentSample]); if (modelOutput == currentTarget) { error++; } } error = error / (double)sampleNumber; //Give the average error return(error); }
//Constructor that only takes a 1D double public XORArbiterPUF(int bitNum, double[] allAPUFWeights) { //set the input variables BitNumber = bitNum; NumPUF = (int)Math.Floor((double)allAPUFWeights.Length / ((double)bitNumber + 1)); //find the number of APUFs ArbiterPUFArray = new ArbiterPUF[NumPUF]; //Fill in the APUF array for (int i = 0; i < NumPUF; i++) { //Extract the weights from the double array double[] currentAPUFWeights = new double[BitNumber + 1]; int indexer = i * (bitNumber + 1); for (int j = 0; j < currentAPUFWeights.Length; j++) { currentAPUFWeights[j] = allAPUFWeights[indexer]; indexer++; } ArbiterPUFArray[i] = new ArbiterPUF(currentAPUFWeights); } }
public IPUF(int xNumPUFIN, int yNumPUFIN, int bitNum, double aPUFMean, double aPUFVar) { //set the input variables BitNumber = bitNum; NumPUFX = xNumPUFIN; NumPUFY = yNumPUFIN; MeanForAPUF = aPUFMean; VarianceForAPUF = aPUFVar; ArbiterPUFArrayX = new ArbiterPUF[xNumPUFIN]; ArbiterPUFArrayY = new ArbiterPUF[yNumPUFIN]; //Initialize the X arbiter PUF array for (int i = 0; i < NumPUFX; i++) { ArbiterPUFArrayX[i] = new ArbiterPUF(bitNumber, MeanForAPUF, VarianceForAPUF); } //Initialize the Y arbiter PUF array for (int i = 0; i < NumPUFY; i++) { ArbiterPUFArrayY[i] = new ArbiterPUF(bitNumber + 1, MeanForAPUF, VarianceForAPUF); //note this has one more bit than the X PUFs } }
//Add a noisy APUF to the contributing list public void AddNoisyAPUF(ArbiterPUF aPUFIN) { NoisyAPUFList.Add(aPUFIN); }
//This is a version to match Ha's noise, not sure if right public static void GenerateReliabilityTrainingDataHaWay(XORArbiterPUF xPUF, int numberOfMeasurements, double[][] trainingData, double[][] trainingReliability, Random randomGenerator) { int trainingSize = trainingData.Length; int bitNum = xPUF.BitNumber; //pregenerate training data inputs double[] noisyAPUFWeight1 = new double[bitNum + 1]; double[] noisyAPUFWeight2 = new double[bitNum + 1]; double[] sumOfResponses = new double[trainingSize]; for (int i = 0; i < trainingSize; i++) { trainingData[i] = GenerateRandomPhiVector(bitNum, randomGenerator); } for (int m = 0; m < numberOfMeasurements; m++) //Ha's way is flipped { double[] noiseAPUF1 = new double[bitNum + 1]; double[] noiseAPUF2 = new double[bitNum + 1]; for (int i = 0; i < noiseAPUF1.Length; i++) { noiseAPUF1[i] = GenerateRandomNormalVariable(0, 0.1, randomGenerator); noiseAPUF2[i] = GenerateRandomNormalVariable(0, 0.1, randomGenerator); } double[] originalAPUFWeight1 = xPUF.GetAllGroundTruthWeights()[0]; double[] originalAPUFWeight2 = xPUF.GetAllGroundTruthWeights()[1]; //Combine the noisy and original weights for (int i = 0; i < noisyAPUFWeight1.Length; i++) { noisyAPUFWeight1[i] = originalAPUFWeight1[i] + noiseAPUF1[i]; noisyAPUFWeight2[i] = originalAPUFWeight2[i] + noiseAPUF2[i]; } ArbiterPUF aNoisy1 = new ArbiterPUF(noisyAPUFWeight1); ArbiterPUF aNoisy2 = new ArbiterPUF(noisyAPUFWeight2); //Compute for each sample for (int i = 0; i < trainingSize; i++) { int cc = aNoisy1.ComputeResponse(trainingData[i]); int ccc = aNoisy2.ComputeResponse(trainingData[i]); int result = aNoisy1.ComputeResponse(trainingData[i]) ^ aNoisy2.ComputeResponse(trainingData[i]); sumOfResponses[i] = sumOfResponses[i] + result; } } //Last compute the reliability for (int i = 0; i < trainingSize; i++) { trainingReliability[i] = new double[1]; //trainingReliability[i][0]= Math.Abs(numberOfMeasurements / 2.0 - (sumOfResponses[i] / (double)numberOfMeasurements)); trainingReliability[i][0] = Math.Abs(numberOfMeasurements / 2.0 - (sumOfResponses[i])); } //for (int i = 0; i < trainingSize; i++) //{ // double sumOfResponses = 0; // //trainingData[i] = GenerateRandomPhiVector(bitNum); // trainingData[i] = GenerateRandomPhiVector(bitNum, randomGenerator); // for (int m = 0; m < numberOfMeasurements; m++) // { // double randomNoise // sumOfResponses = sumOfResponses + aPUF.ComputeNoisyResponse(trainingData[i]); //sum the measurements // } // trainingReliability[i] = new double[1]; // //trainingReliability[i][0] = sumOfResponses / (double)numberOfMeasurements; // trainingReliability[i][0] = Math.Abs(numberOfMeasurements / 2.0 - (sumOfResponses / (double)numberOfMeasurements)); //} }
//Use Ha's method to attack XOR APUF with the absolute objective function public static void AttackXORAPUFwithAbsoluteMethod() { //Generate a noisy PUF int bitNum = 64; int pufNum = 2; int numberOfMeasurements = 5; //I am guessing this, no clue double aPUFMean = 0.0; double aPUFVar = 1.0; double aPUFMeanNoise = 0.0; double aPUFNoiseVar = aPUFVar / 10.0; //Create the XOR APUF XORArbiterPUF xPUF = new XORArbiterPUF(pufNum, bitNum, aPUFMean, aPUFVar, aPUFMeanNoise, aPUFNoiseVar); //Generate training data (reliability information) int trainingSize = 30000; //fix back int testingSize = 10000; int attackRepeatNum = 15; ParallelOptions options = new ParallelOptions { MaxDegreeOfParallelism = 10 }; //make independent copies in memory XORArbiterPUF[] xArray = new XORArbiterPUF[attackRepeatNum]; for (int i = 0; i < xArray.Length; i++) { xArray[i] = (XORArbiterPUF)xPUF.Clone(); } double[][] solutionList = new double[attackRepeatNum][]; //Two different objective functions, one for CMA-ES, the other to test the final model accuracy ObjectiveFunctionResponse rObj = new ObjectiveFunctionResponse(); //ObjectiveFunctionReliabilityStandard[] sObjArray = new ObjectiveFunctionReliabilityStandard[attackRepeatNum]; ObjectiveFunctionReliabilityAbsolute[] sObjArray = new ObjectiveFunctionReliabilityAbsolute[attackRepeatNum]; for (int i = 0; i < sObjArray.Length; i++) { sObjArray[i] = new ObjectiveFunctionReliabilityAbsolute(); } Parallel.For(0, attackRepeatNum, a => { //for (int a = 0; a < attackRepeatNum; a++) //{ Random randomGenerator = new Random((int)DateTime.Now.Ticks); //remove the dependences for parallelization int dimensionNumber = bitNum + 1; double[][] trainingData = new double[trainingSize][]; //these will be phi vectors double[][] trainingReliability = new double[trainingSize][]; //DataGeneration.GenerateReliabilityTrainingDataHaWay(xArray[a], numberOfMeasurements, trainingData, trainingReliability, randomGenerator); DataGeneration.GenerateReliabilityTrainingData(xArray[a], numberOfMeasurements, trainingData, trainingReliability, randomGenerator); //Generate the first solution randomly for CMA-ES double[] firstSolution = new double[bitNum + 1]; for (int i = 0; i < firstSolution.Length; i++) { //firstSolution[i] = AppConstants.rx.NextDouble(); firstSolution[i] = randomGenerator.NextDouble(); } Console.Out.WriteLine("Data generation for core " + a.ToString() + " complete. Beginning CMA-ES"); CMAESCandidate solutionCMAES = CMAESMethods.ComputeCMAES(dimensionNumber, sObjArray[a], trainingData, trainingReliability, firstSolution, randomGenerator); double[] solution = solutionCMAES.GetWeightVector(); solutionList[a] = solution; //store the solution in independent memory // } }); //Just see if we can recover the 0th APUF //ArbiterPUF aPUF = xPUF.GetAPUFAtIndex(0); //Testing data can be in form of response because we don't care about the reliability double[][] accMeasures = new double[solutionList.Length][]; for (int i = 0; i < solutionList.Length; i++) { accMeasures[i] = new double[pufNum]; } Random randomGenerator2 = new Random((int)DateTime.Now.Ticks); for (int j = 0; j < pufNum; j++) { ArbiterPUF aPUF = xPUF.GetAPUFAtIndex(j); double[][] testingData = new double[testingSize][]; //these will be phi vectors double[][] testingResponse = new double[testingSize][]; DataGeneration.GenerateTrainingData(aPUF, testingData, testingResponse, randomGenerator2); for (int i = 0; i < solutionList.Length; i++) { accMeasures[i][j] = 1.0 - rObj.ObjFunValue(solutionList[i], testingData, testingResponse); Console.Out.WriteLine("The accuracy for PUF " + j.ToString() + " " + accMeasures[i][j].ToString()); } //Ground truth sanity check double gca = 1.0 - rObj.ObjFunValue(aPUF.GetGroundTruthWeight(), testingData, testingResponse); Console.Out.WriteLine("The ground truth accuracy for PUF " + j.ToString() + " " + gca.ToString()); } int k = 0; }