protected override void OnEVH() { switch (step) { case 1: if (!ReferenceEquals(code, null)) { TransformEncType(program.GetValue(code.operand1)); } else { Run(); } break; case 2: if (!ReferenceEquals(code, null)) { if (encVal[0].GetEncType() == EncryptionType.None) { encType = EncryptionType.None; var re = new Numeric((BigInteger.One << (Config.ScaleBits + encVal[0].GetScaleBits())) / encVal[0].GetUnsignedBigInteger(), Config.ScaleBits); eInva = new NumericArray(re); // jump to round 13 step = 12; Run(); break; } } parallism = encVal.Length; length = Config.NumericBits; new IndexMSBOnEVH(party, line, this, encVal, ePow2msb, length).Run(); break; case 3: var eRevPow = Inverse.ReverseBits(ePow2msb, length); // encKpRevPow is in {1, 2, 4, ..., 2^(Config.NumericBitLength - 1)} new XORToAddModOnEVH(party, line, this, eRevPow, encKpRevPow).Run(); break; case 4: var MulOperands = new NumericArray(2 * parallism); for (int p = 0; p < parallism; ++p) { MulOperands[2 * p] = encVal[p]; MulOperands[2 * p + 1] = encKpRevPow[p]; } // a' is in [ 2 ^ (NumericBitLength - 1), 2 ^ (NumericBitLength) ) new MultiplicationOnEVH(party, line, this, MulOperands, encKppap).Run(); break; case 5: et = new Numeric[parallism][]; et1 = new NumericArray(parallism); for (int p = 0; p < parallism; ++p) { System.Diagnostics.Debug.Assert(encKppap[p].GetScaleBits() == 0); //EncKppap[p].ResetScaleBits(); et[p] = new Numeric[Inverse.nt + 1]; et[p][0] = new Numeric(1, 0); // a' - at > 0 et1[p] = encKppap[p] - Inverse.at; } // AddModToAdd makes sure (a' + k" - at) > 0 and k" > 0 new AddModToAddOnEVH(party, line, this, et1, et1).Run(); break; // case 6~8 computes the (a' - at) ^ 2, (a' - at) ^ 3, ... , (a' - at) ^ 7 case 6: var mulOperand2 = new NumericArray(2 * parallism); for (int p = 0; p < parallism; ++p) { et[p][1] = et1[p] >> Inverse.reductionBits; mulOperand2[2 * p] = et[p][1]; mulOperand2[2 * p + 1] = et[p][1]; } new MultiplicationOnEVH(party, line, this, mulOperand2, et2).Run(); break; case 7: var mulOperand34 = new NumericArray(parallism * 4); for (int p = 0; p < parallism; ++p) { et[p][2] = et2[p]; mulOperand34[4 * p] = et[p][1]; mulOperand34[4 * p + 1] = et[p][2]; mulOperand34[4 * p + 2] = et[p][2]; mulOperand34[4 * p + 3] = et[p][2]; } new MultiplicationOnEVH(party, line, this, mulOperand34, et3et4).Run(); break; case 8: var mulOperand567 = new NumericArray(parallism * 6); for (int p = 0; p < parallism; ++p) { et[p][3] = et3et4[2 * p]; et[p][4] = et3et4[2 * p + 1]; mulOperand567[6 * p] = et[p][1]; mulOperand567[6 * p + 1] = et[p][4]; mulOperand567[6 * p + 2] = et[p][2]; mulOperand567[6 * p + 3] = et[p][4]; mulOperand567[6 * p + 4] = et[p][3]; mulOperand567[6 * p + 5] = et[p][4]; } new MultiplicationOnEVH(party, line, this, mulOperand567, et5et6et7).Run(); break; case 9: for (int p = 0; p < parallism; ++p) { et[p][5] = et5et6et7[3 * p]; et[p][6] = et5et6et7[3 * p + 1]; et[p][7] = et5et6et7[3 * p + 2]; } et2ToEt7 = new NumericArray(parallism * 6); for (int p = 0; p < parallism; ++p) { int offset = p * 6; for (int i = 0; i < 6; ++i) { et2ToEt7[offset + i] = et[p][i + 2]; } } // convert encrption for (a' - at) ^ 2, (a' - at) ^ 3, ... , (a' - at) ^ 7 from AddMod to Addition, // such that when computing taylor sum, module will affect the result new AddModToAddOnEVH(party, line, this, et2ToEt7, et2ToEt7).Run(); break; // compute taylor sum case 10: for (int p = 0; p < parallism; ++p) { int offset = p * 6; for (int i = 0; i < 6; ++i) { et[p][i + 2] = et2ToEt7[offset + i]; } } eInva = new NumericArray(parallism); var MulOperandsScale = new NumericArray(2 * parallism); // since 1/a' is too small(even after mutilpied by scaling factor), it will always be 0 if converted to fixed pointer integer // such that we need to magnify it with a factor. Here we choose 2 ^ (Config.NumericBitLength - 1) BigInteger magnificationFactor = BigInteger.One << (Config.NumericBits - 1); for (int p = 0; p < parallism; ++p) { BigInteger taylorSum = Inverse.scaleFactor * magnificationFactor / Inverse.dReciprocal[0], redFactor = Inverse.reductionFactor; for (int i = 1; i <= Inverse.nt; ++i) { taylorSum += redFactor * Inverse.scaleFactor * magnificationFactor / Inverse.dReciprocal[i]; redFactor *= Inverse.reductionFactor; // taylorSum += Inverse.d[i] * et[p][i].GetVal(); } eInva[p] = new Numeric(taylorSum, 0); //System.Diagnostics.Debug.WriteLine("e: taylorSum * magnificationFactor: " + taylorSum); //System.Diagnostics.Debug.WriteLine("e: val: " + taylorSum * Math.Pow(2, Config.NumericBitLength - 1)); //System.Diagnostics.Debug.WriteLine("e: eInva befor: " + eInva[0]); MulOperandsScale[2 * p] = eInva[p]; MulOperandsScale[2 * p + 1] = encKpRevPow[p]; } // 1 / a' * encKpRevPow is the result new MultiplicationOnEVH(party, line, this, MulOperandsScale, eInva).Run(); break; case 11: new AddModToAddOnEVH(party, line, this, eInva, eInva).Run(); break; case 12: for (int p = 0; p < parallism; ++p) { // scale down the result by the factor 2 ^ (Config.NumericBitLength - 1) eInva[p] >>= (Config.NumericBits - 1); eInva[p].SetScaleBits(Config.ScaleBits); } //System.Diagnostics.Debug.WriteLine("e: eInva: " + eInva[0]); Run(); break; case 13: SetResult(encType, eInva.GetArray()); break; case 14: InvokeCaller(); break; default: throw new Exception(); } }
protected override void OnEVH() { switch (step) { case 1: parallelism = encVal.Length; encType = resultEncType; if (!ReferenceEquals(code, null)) { Numeric enckaa = program.GetValue(code.operand1); encVal = new NumericArray(enckaa); length = Config.NumericBits; if (encVal[0].GetEncType() == EncryptionType.None) { encType = EncryptionType.None; if (encVal[0].GetUnsignedBigInteger() == 0) { encH = new NumericArray(new Numeric(1, 0)); } else { encH = new NumericArray(new Numeric(0, 0)); } // jump to round 4 step = 3; Run(); break; } } new HammingDistanceOnEVH(party, line, this, encVal, encH, length).Run(); break; case 2: new FastEqualZeroOnEVH(party, line, this, encH, encH, (int)Math.Ceiling(Math.Log(length + 1, 2))).Run(); break; case 3: // as subfunction, the result should be 0 if secret == 0 // however the result from FastEqualZero if 1 if secret == 0 if (ReferenceEquals(code, null)) { for (int p = 0; p < parallelism; p++) { encH[p] ^= new Numeric(1, 0); } } Run(); break; case 4: SetResult(encType, encH.GetArray()); break; case 5: InvokeCaller(); break; default: throw new Exception(); ////System.Diagnostics.Debug.Assert(le >= 2 || le == 0); //if (le > 2) //{ // le = (int)Math.Ceiling(Math.Log(le + 1, 2)); // new HammingDistanceOnEVH(party, line, this, encH, encH, le).Run(); //} //else if (le == 2) //{ // var OROperand = new Numeric[2 * parallelism]; // for (int p = 0; p < parallelism; ++p) // { // OROperand[2 * p] = encH[p] >> 1; // OROperand[2 * p + 1] = encH[p].ModPow(1); // } // le = 0; // new OROnEVH(party, line, this, new NumericArray(OROperand), encH).Run(); //} //else //{ // Numeric[] enckf = new Numeric[parallelism]; // for (int p = 0; p < parallelism; ++p) // { // enckf[p] = encH[p].ModPow(1); // //enckf[p].SetEncType(EncryptionType.XOR); // } // if(!ReferenceEquals(code, null)) // { // // not as a subfunction // enckf[0] ^= new Numeric(1, 0); // } // SetResult(enckf); //} //break; } }
protected override void OnEVH() { switch (step) { case 1: if (!ReferenceEquals(code, null)) { Numeric enckaa = program.GetValue(code.operand1); TransformEncType(enckaa); } else { Run(); } break; case 2: encType = resultEncType; // input value is not encrypted if (!ReferenceEquals(code, null) && encVal[0].GetEncType() == EncryptionType.None) { encType = EncryptionType.None; enckf = new NumericArray(1); if (encVal[0].GetUnsignedBigInteger() < 0) { enckf[0] = new Numeric(1, 0); } else { enckf[0] = new Numeric(0, 0); } // jump to round 6 step = 5; Run(); break; } parallelism = encVal.Length; KInversePlusKip = new NumericArray(); party.receiver.ReceiveFrom(PartyType.KH, line, this, KInversePlusKip); break; case 3: var Enckipa = new NumericArray(parallelism * ne); for (int p = 0; p < parallelism; ++p) { int offset = p * ne; for (int i = 0; i < ne; i++) { Enckipa[offset + i] = encVal[p] + KInversePlusKip[offset + i]; } } elei = new NumericArray(); new LessZeroOnEVH(party, line, this, Enckipa, elei, length).Run(); break; case 4: new XORToAddModOnEVH(party, line, this, elei, elei).Run(); break; case 5: var sele = new NumericArray(parallelism); for (int p = 0; p < parallelism; ++p) { sele[p] = new Numeric(ne / 2, 0); int offset = p * ne; for (int i = 0; i < ne; i++) { sele[p] -= elei[offset + i]; } //System.Diagnostics.Debug.WriteLine("EVH SUM: " + sele[p].ToUnsignedBigInteger()); } enckf = new NumericArray(); new LessZeroOnEVH(party, line, this, sele, enckf, length).Run(); break; case 6: SetResult(encType, enckf.GetArray()); break; case 7: InvokeCaller(); break; default: throw new Exception(); } }
protected override void OnKH() { switch (step) { case 1: encType = resultEncType; if (!ReferenceEquals(code, null)) { Numeric ka = program.GetValue(code.operand1); key = new NumericArray(ka); length = Config.NumericBits; if (key[0].GetEncType() == EncryptionType.None) { encType = EncryptionType.None; if (key[0].GetEncType() == EncryptionType.None) { encType = EncryptionType.None; if (key[0].GetUnsignedBigInteger() == 0) { keyH = new NumericArray(new Numeric(1, 0)); } else { keyH = new NumericArray(new Numeric(0, 0)); } // jump to round 3 step = 2; Run(); break; } } } parallelism = key.Length; //Console.WriteLine("KH: " + key[0]); new HammingDistanceOnKH(party, line, this, key, keyH, length).Run(); break; case 2: new FastEqualZeroOnKH(party, line, this, keyH, keyH, (int)Math.Ceiling(Math.Log(length + 1, 2))).Run(); break; case 3: SetResult(encType, keyH.GetArray()); break; case 4: InvokeCaller(); break; default: throw new Exception(); ////System.Diagnostics.Debug.Assert(le >= 2 || le == 0); //if (le > 2) //{ // le = (int)Math.Ceiling(Math.Log(le + 1, 2)); // new HammingDistanceOnKH(party, line, this, keyH, keyH, le).Run(); //} //else if (le == 2) //{ // var OROperand = new Numeric[2 * parallelism]; // for (int p = 0; p < parallelism; ++p) // { // OROperand[2 * p] = keyH[p] >> 1; // OROperand[2 * p + 1] = keyH[p].ModPow(1); // } // le = 0; // new OROnKH(party, line, this, new NumericArray(OROperand), keyH).Run(); //} //else //{ // Numeric[] kf = new Numeric[parallelism]; // for (int p = 0; p < parallelism; ++p) // { // kf[p] = keyH[p].ModPow(1); // //kf[p].SetEncType(EncryptionType.XOR); // } // SetResult(kf); //} //break; } }
protected override void OnKH() { switch (step) { case 1: if (!ReferenceEquals(code, null)) { Numeric ka = program.GetValue(code.operand1); TransformEncType(ka); } else { Run(); } break; case 2: encType = resultEncType; // input value is not encrypted if (!ReferenceEquals(code, null) && key[0].GetEncType() == EncryptionType.None) { encType = EncryptionType.None; kf = new NumericArray(1); if (key[0].GetUnsignedBigInteger() < 0) { kf[0] = new Numeric(1, 0); } else { kf[0] = new Numeric(0, 0); } // jump to round 5 step = 4; Run(); break; } parallelism = key.Length; var Kip = new NumericArray(parallelism * ne); var KInversePlusKip = new Numeric[parallelism * ne]; for (int p = 0; p < parallelism; ++p) { int offset = p * ne; for (int i = 0; i < ne; ++i) { Kip[offset + i] = Utility.NextUnsignedNumeric(key[p].GetScaleBits()); KInversePlusKip[offset + i] = Kip[offset + i] - key[p]; } } var toEVH = Message.AssembleMessage(line, opType, false, KInversePlusKip); party.sender.SendTo(PartyType.EVH, toEVH); klei = new NumericArray(); new LessZeroOnKH(party, line, this, Kip, klei, length).Run(); break; case 3: new XORToAddModOnKH(party, line, this, klei, klei).Run(); break; case 4: var skle = new NumericArray(parallelism); for (int p = 0; p < parallelism; ++p) { skle[p] = new Numeric(0, 0); int offset = p * ne; for (int i = 0; i < ne; i++) { skle[p] -= klei[offset + i]; } //System.Diagnostics.Debug.WriteLine("KH SUM: " + skle[p].ToUnsignedBigInteger()); } kf = new NumericArray(); new LessZeroOnKH(party, line, this, skle, kf, length).Run(); break; case 5: SetResult(encType, kf.GetArray()); break; case 6: InvokeCaller(); break; default: throw new Exception(); } }