destination[destinationOffset + j] = barrett( temporary + destination[destinationOffset + j + numberOfProblem], Parameter.Q_III_P, Parameter.BARRETT_MULTIPLICATION_III_P, Parameter.BARRETT_DIVISION_III_P ); destination[destinationOffset + j + numberOfProblem] = barrett( montgomeryP( omega * (temporary + (2L * Parameter.Q_III_P - destination[destinationOffset + j + numberOfProblem])), Parameter.Q_III_P, Parameter.Q_INVERSE_III_P
numberTheoreticTransform(multiplierNumberTheoreticTransform, zeta, n, q, qInverse); componentWisePolynomialMultiplication(product, multiplicand, multiplierNumberTheoreticTransform, n, q, qInverse); inverseNumberTheoreticTransformI(product, PolynomialHeuristic.ZETA_INVERSE_I); inverseNumberTheoreticTransform( inverseNumberTheoreticTransform(
/*************************************************************************************************************************************************************************************************** * Description: Polynomial Multiplication for Provably-Secure qTESLA Security Category-1 and Category-3 * * @param product Product = Multiplicand * Multiplier * @param productOffset Starting Point of the Product Array * @param multiplicand Multiplicand Array * @param multiplicandOffset Starting Point of the Multiplicand Array * @param multiplier Multiplier Array * @param multiplierOffset Starting Point of the Multiplier Array * @param n Polynomial Degree * @param q Modulus * @param qInverse * * @return none ***************************************************************************************************************************************************************************************************/ public static void polynomialMultiplication(long[] product, int productOffset, long[] multiplicand, int multiplicandOffset, long[] multiplier, int multiplierOffset, int n, int q, long qInverse) { componentWisePolynomialMultiplication(product, productOffset, multiplicand, multiplicandOffset, multiplier, multiplierOffset, n, q, qInverse); if (q == Parameter.Q_I_P) { inverseNumberTheoreticTransformIP(product, productOffset, PolynomialProvablySecure.ZETA_INVERSE_I_P, 0); } if (q == Parameter.Q_III_P) { inverseNumberTheoreticTransformIIIP(product, productOffset, PolynomialProvablySecure.ZETA_INVERSE_III_P, 0); } }
/*********************************************************************************************************************************************** * Description: Polynomial Number Theoretic Transform for Provably-Secure qTESLA Security Category-1 and Category-3 * * @param arrayNumberTheoreticTransform Transformed Array * @param array Array to be Transformed * @param n Polynomial Degree * * @return none ***********************************************************************************************************************************************/ public static void polynomialNumberTheoreticTransform(long[] arrayNumberTheoreticTransform, long[] array, int n) { for (int i = 0; i < n; i++) { arrayNumberTheoreticTransform[i] = array[i]; } if (n == Parameter.N_I_P) { numberTheoreticTransformIP(arrayNumberTheoreticTransform, PolynomialProvablySecure.ZETA_I_P); } if (n == Parameter.N_III_P) { numberTheoreticTransformIIIP(arrayNumberTheoreticTransform, PolynomialProvablySecure.ZETA_III_P); } }
destination[j] = barrett(temporary + destination[j + numberOfProblem], q, barrettMultiplication, barrettDivision); destination[j + numberOfProblem] = montgomery(omega * (temporary - destination[j + numberOfProblem]), q, qInverse); destination[i] = montgomery((long)r * destination[i], q, qInverse);
/**************************************************************************************************************************************************** * Description: Component Wise Polynomial Multiplication for Heuristic qTESLA Security Category-1 and Security Category-3 (Option for Size and Speed) * * @param product Product = Multiplicand (*) Multiplier * @param multiplicand Multiplicand Array * @param multiplier Multiplier Array * @param n Polynomial Degree * @param q Modulus * @param qInverse * * @return none ****************************************************************************************************************************************************/ private static void componentWisePolynomialMultiplication(int[] product, int[] multiplicand, int[] multiplier, int n, int q, long qInverse) { for (int i = 0; i < n; i++) { product[i] = montgomery((long)multiplicand[i] * multiplier[i], q, qInverse); } }
/****************************************************************************************************************************************************************************************************************** * Description: Component Wise Polynomial Multiplication for Provably-Secure qTESLA Security Category-1 and Security Category-3 * * @param product Product = Multiplicand (*) Multiplier * @param productOffset Starting Point of the Product Array * @param multiplicand Multiplicand Array * @param multiplicandOffset Starting Point of the Multiplicand Array * @param multiplier Multiplier Array * @param multiplierOffset Starting Point of the Multiplier Array * @param n Polynomial Degree * @param q Modulus * @param qInverse * * @return none ******************************************************************************************************************************************************************************************************************/ private static void componentWisePolynomialMultiplication(long[] product, int productOffset, long[] multiplicand, int multiplicandOffset, long[] multiplier, int multiplierOffset, int n, int q, long qInverse) { for (int i = 0; i < n; i++) { product[productOffset + i] = montgomeryP(multiplicand[multiplicandOffset + i] * multiplier[multiplierOffset + i], q, qInverse); } }
/****************************************************************************************************************************************************************************************************************************** * Description: Polynomial Subtraction for Provably-Secure qTESLA Security Category-1 and Security Category-3 * * @param difference Difference = Minuend (-) Subtrahend * @param differenceOffset Starting Point of the Difference Array * @param minuend Minuend Array * @param minuendOffset Starting Point of the Minuend Array * @param subtrahend Subtrahend Array * @param subtrahendOffset Starting Point of the Subtrahend Array * @param n Polynomial Degree * @param q Modulus * @param barrettMultiplication * @param barrettDivision * * @return none ******************************************************************************************************************************************************************************************************************************/ public static void polynomialSubtraction(long[] difference, int differenceOffset, long[] minuend, int minuendOffset, long[] subtrahend, int subtrahendOffset, int n, int q, int barrettMultiplication, int barrettDivision) { for (int i = 0; i < n; i++) { difference[differenceOffset + i] = barrett(minuend[minuendOffset + i] - subtrahend[subtrahendOffset + i], q, barrettMultiplication, barrettDivision); } }
/******************************************************************************************************************************************* * Description: Polynomial Subtraction with Montgomery Reduction for Heuristic qTESLA Security Category-1 and Security Category-3 * (Option for Size or Speed) * * @param difference Difference = Minuend (-) Subtrahend * @param minuend Minuend Array * @param subtrahend Subtrahend Array * @param n Polynomial Degree * @param q Modulus * @param qInverse * @param r * * @return none *******************************************************************************************************************************************/ public static void polynomialSubtractionMontgomery(int[] difference, int[] minuend, int[] subtrahend, int n, int q, long qInverse, int r) { for (int i = 0; i < n; i++) { difference[i] = montgomery((long)r * (minuend[i] - subtrahend[i]), q, qInverse); } }
long temporary = montgomeryP( omega * destination[j + numberOfProblem], Parameter.Q_I_P, Parameter.Q_INVERSE_I_P
product[productOffset + i] = barrett(product[productOffset + i], q, barrettMultiplication, barrettDivision);
long temporary = barrett( montgomeryP( omega * destination[j + numberOfProblem], Parameter.Q_III_P, ); destination[j + numberOfProblem] = barrett( destination[j] + (2L * Parameter.Q_III_P - temporary), Parameter.Q_III_P, ); destination[j] = barrett( destination[j] + temporary, Parameter.Q_III_P,
int temporary = montgomery(omega * destination[j + numberOfProblem], q, qInverse);
A[i++] = montgomeryP((long)value1 * inverseNumberTheoreticTransform, q, qInverse); A[i++] = montgomeryP((long)value2 * inverseNumberTheoreticTransform, q, qInverse); A[i++] = montgomeryP((long)value3 * inverseNumberTheoreticTransform, q, qInverse); A[i++] = montgomeryP((long)value4 * inverseNumberTheoreticTransform, q, qInverse);
destination[destinationOffset + j + numberOfProblem] = montgomeryP( omega * (temporary + (2L * Parameter.Q_I_P - destination[destinationOffset + j + numberOfProblem])), Parameter.Q_I_P, Parameter.Q_INVERSE_I_P destination[destinationOffset + j] = barrett( temporary + destination[destinationOffset + j + numberOfProblem], Parameter.Q_I_P, Parameter.BARRETT_MULTIPLICATION_I_P, Parameter.BARRETT_DIVISION_I_P ); destination[destinationOffset + j + numberOfProblem] = montgomeryP( omega * (temporary + (2L * Parameter.Q_I_P - destination[destinationOffset + j + numberOfProblem])), Parameter.Q_I_P, Parameter.Q_INVERSE_I_P
destination[j + numberOfProblem] = montgomery( omega * (temporary - destination[j + numberOfProblem]), Parameter.Q_I, Parameter.Q_INVERSE_I destination[i] = montgomery((long)Parameter.R_I * destination[i], Parameter.Q_I, Parameter.Q_INVERSE_I);
A[i++] = montgomery((long)value1 * inverseNumberTheoreticTransform, q, qInverse); A[i++] = montgomery((long)value2 * inverseNumberTheoreticTransform, q, qInverse); A[i++] = montgomery((long)value3 * inverseNumberTheoreticTransform, q, qInverse); A[i++] = montgomery((long)value4 * inverseNumberTheoreticTransform, q, qInverse);