import org.bouncycastle.pqc.crypto.rainbow.util.GF2Field; //导入依赖的package包/类
/**
 * initial operations before solving the Linear equation system.
 *
 * @param layer the current layer for which a LES is to be solved.
 * @param msg   the message that should be signed.
 * @return Y_ the modified document needed for solving LES, (Y_ =
 *         A1^{-1}*(Y-b1)) linear map L1 = A1 x + b1.
 */
private short[] initSign(Layer[] layer, short[] msg)
{

    /* preparation: Modifies the document with the inverse of L1 */
    // tmp = Y - b1:
    short[] tmpVec = new short[msg.length];

    tmpVec = cf.addVect(((RainbowPrivateKeyParameters)this.key).getB1(), msg);

    // Y_ = A1^{-1} * (Y - b1) :
    short[] Y_ = cf.multiplyMatrix(((RainbowPrivateKeyParameters)this.key).getInvA1(), tmpVec);

    /* generates the vinegar vars of the first layer at random */
    for (int i = 0; i < layer[0].getVi(); i++)
    {
        x[i] = (short)random.nextInt();
        x[i] = (short)(x[i] & GF2Field.MASK);
    }

    return Y_;
}
 

import org.bouncycastle.pqc.crypto.rainbow.util.GF2Field; //导入依赖的package包/类
/**
 * Signature verification using public key
 *
 * @param signature vector of dimension n
 * @return document hash of length n - v1
 */
private short[] verifySignatureIntern(short[] signature)
{

    short[][] coeff_quadratic = ((RainbowPublicKeyParameters)this.key).getCoeffQuadratic();
    short[][] coeff_singular = ((RainbowPublicKeyParameters)this.key).getCoeffSingular();
    short[] coeff_scalar = ((RainbowPublicKeyParameters)this.key).getCoeffScalar();

    short[] rslt = new short[coeff_quadratic.length];// n - v1
    int n = coeff_singular[0].length;
    int offset = 0; // array position
    short tmp = 0; // for scalar

    for (int p = 0; p < coeff_quadratic.length; p++)
    { // no of polynomials
        offset = 0;
        for (int x = 0; x < n; x++)
        {
            // calculate quadratic terms
            for (int y = x; y < n; y++)
            {
                tmp = GF2Field.multElem(coeff_quadratic[p][offset],
                    GF2Field.multElem(signature[x], signature[y]));
                rslt[p] = GF2Field.addElem(rslt[p], tmp);
                offset++;
            }
            // calculate singular terms
            tmp = GF2Field.multElem(coeff_singular[p][x], signature[x]);
            rslt[p] = GF2Field.addElem(rslt[p], tmp);
        }
        // add scalar
        rslt[p] = GF2Field.addElem(rslt[p], coeff_scalar[p]);
    }

    return rslt;
}
 

import org.bouncycastle.pqc.crypto.rainbow.util.GF2Field; //导入依赖的package包/类
/**
 * This function generates the invertible affine linear map L1 = A1*x + b1
 * <p/>
 * The translation part b1, is stored in a separate array. The inverse of
 * the matrix-part of L1 A1inv is also computed here.
 * <p/>
 * This linear map hides the output of the map F. It is on k^(n-v1).
 */
private void generateL1()
{

    // dimension = n-v1 = vi[last] - vi[first]
    int dim = vi[vi.length - 1] - vi[0];
    this.A1 = new short[dim][dim];
    this.A1inv = null;
    ComputeInField c = new ComputeInField();

    /* generation of A1 at random */
    while (A1inv == null)
    {
        for (int i = 0; i < dim; i++)
        {
            for (int j = 0; j < dim; j++)
            {
                A1[i][j] = (short)(sr.nextInt() & GF2Field.MASK);
            }
        }
        A1inv = c.inverse(A1);
    }

    /* generation of the translation vector at random */
    b1 = new short[dim];
    for (int i = 0; i < dim; i++)
    {
        b1[i] = (short)(sr.nextInt() & GF2Field.MASK);
    }
}
 

import org.bouncycastle.pqc.crypto.rainbow.util.GF2Field; //导入依赖的package包/类
/**
 * This function generates the invertible affine linear map L2 = A2*x + b2
 * <p/>
 * The translation part b2, is stored in a separate array. The inverse of
 * the matrix-part of L2 A2inv is also computed here.
 * <p/>
 * This linear map hides the output of the map F. It is on k^(n).
 */
private void generateL2()
{

    // dimension = n = vi[last]
    int dim = vi[vi.length - 1];
    this.A2 = new short[dim][dim];
    this.A2inv = null;
    ComputeInField c = new ComputeInField();

    /* generation of A2 at random */
    while (this.A2inv == null)
    {
        for (int i = 0; i < dim; i++)
        {
            for (int j = 0; j < dim; j++)
            { // one col extra for b
                A2[i][j] = (short)(sr.nextInt() & GF2Field.MASK);
            }
        }
        this.A2inv = c.inverse(A2);
    }
    /* generation of the translation vector at random */
    b2 = new short[dim];
    for (int i = 0; i < dim; i++)
    {
        b2[i] = (short)(sr.nextInt() & GF2Field.MASK);
    }

}
 

import org.bouncycastle.pqc.crypto.rainbow.util.GF2Field; //导入依赖的package包/类
/**
 * The quadratic (or mixed) terms of the public key are compacted from a n x
 * n matrix per polynomial to an upper diagonal matrix stored in one integer
 * array of n (n + 1) / 2 elements per polynomial. The ordering of elements
 * is lexicographic and the result is updating <tt>this.pub_quadratic</tt>,
 * which stores the quadratic elements of the public key.
 *
 * @param coeff_quadratic_to_compact 3-dimensional array containing a n x n Matrix for each of the
 *                                   n - v1 polynomials
 */
private void compactPublicKey(short[][][] coeff_quadratic_to_compact)
{
    int polynomials = coeff_quadratic_to_compact.length;
    int n = coeff_quadratic_to_compact[0].length;
    int entries = n * (n + 1) / 2;// the small gauss
    this.pub_quadratic = new short[polynomials][entries];
    int offset = 0;

    for (int p = 0; p < polynomials; p++)
    {
        offset = 0;
        for (int x = 0; x < n; x++)
        {
            for (int y = x; y < n; y++)
            {
                if (y == x)
                {
                    this.pub_quadratic[p][offset] = coeff_quadratic_to_compact[p][x][y];
                }
                else
                {
                    this.pub_quadratic[p][offset] = GF2Field.addElem(
                        coeff_quadratic_to_compact[p][x][y],
                        coeff_quadratic_to_compact[p][y][x]);
                }
                offset++;
            }
        }
    }
}
 

import org.bouncycastle.pqc.crypto.rainbow.util.GF2Field; //导入依赖的package包/类
/**
 * This function generates the invertible affine linear map L1 = A1*x + b1
 * <p>
 * The translation part b1, is stored in a separate array. The inverse of
 * the matrix-part of L1 A1inv is also computed here.
 * </p><p>
 * This linear map hides the output of the map F. It is on k^(n-v1).
 * </p>
 */
private void generateL1()
{

    // dimension = n-v1 = vi[last] - vi[first]
    int dim = vi[vi.length - 1] - vi[0];
    this.A1 = new short[dim][dim];
    this.A1inv = null;
    ComputeInField c = new ComputeInField();

    /* generation of A1 at random */
    while (A1inv == null)
    {
        for (int i = 0; i < dim; i++)
        {
            for (int j = 0; j < dim; j++)
            {
                A1[i][j] = (short)(sr.nextInt() & GF2Field.MASK);
            }
        }
        A1inv = c.inverse(A1);
    }

    /* generation of the translation vector at random */
    b1 = new short[dim];
    for (int i = 0; i < dim; i++)
    {
        b1[i] = (short)(sr.nextInt() & GF2Field.MASK);
    }
}
 

import org.bouncycastle.pqc.crypto.rainbow.util.GF2Field; //导入依赖的package包/类
/**
 * This function generates the invertible affine linear map L2 = A2*x + b2
 * <p>
 * The translation part b2, is stored in a separate array. The inverse of
 * the matrix-part of L2 A2inv is also computed here.
 * </p><p>
 * This linear map hides the output of the map F. It is on k^(n).
 * </p>
 */
private void generateL2()
{

    // dimension = n = vi[last]
    int dim = vi[vi.length - 1];
    this.A2 = new short[dim][dim];
    this.A2inv = null;
    ComputeInField c = new ComputeInField();

    /* generation of A2 at random */
    while (this.A2inv == null)
    {
        for (int i = 0; i < dim; i++)
        {
            for (int j = 0; j < dim; j++)
            { // one col extra for b
                A2[i][j] = (short)(sr.nextInt() & GF2Field.MASK);
            }
        }
        this.A2inv = c.inverse(A2);
    }
    /* generation of the translation vector at random */
    b2 = new short[dim];
    for (int i = 0; i < dim; i++)
    {
        b2[i] = (short)(sr.nextInt() & GF2Field.MASK);
    }

}
 

import org.bouncycastle.pqc.crypto.rainbow.util.GF2Field; //导入依赖的package包/类
/**
 * This function generates the coefficients of all polynomials in this layer
 * at random using random generator.
 *
 * @param sr the random generator which is to be used
 */
public Layer(int vi, int viNext, SecureRandom sr)
{
    this.vi = vi;
    this.viNext = viNext;
    this.oi = viNext - vi;

    // the coefficients of all polynomials in this layer
    this.coeff_alpha = new short[this.oi][this.oi][this.vi];
    this.coeff_beta = new short[this.oi][this.vi][this.vi];
    this.coeff_gamma = new short[this.oi][this.viNext];
    this.coeff_eta = new short[this.oi];

    int numOfPoly = this.oi; // number of polynomials per layer

    // Alpha coeffs
    for (int k = 0; k < numOfPoly; k++)
    {
        for (int i = 0; i < this.oi; i++)
        {
            for (int j = 0; j < this.vi; j++)
            {
                coeff_alpha[k][i][j] = (short)(sr.nextInt() & GF2Field.MASK);
            }
        }
    }
    // Beta coeffs
    for (int k = 0; k < numOfPoly; k++)
    {
        for (int i = 0; i < this.vi; i++)
        {
            for (int j = 0; j < this.vi; j++)
            {
                coeff_beta[k][i][j] = (short)(sr.nextInt() & GF2Field.MASK);
            }
        }
    }
    // Gamma coeffs
    for (int k = 0; k < numOfPoly; k++)
    {
        for (int i = 0; i < this.viNext; i++)
        {
            coeff_gamma[k][i] = (short)(sr.nextInt() & GF2Field.MASK);
        }
    }
    // Eta
    for (int k = 0; k < numOfPoly; k++)
    {
        coeff_eta[k] = (short)(sr.nextInt() & GF2Field.MASK);
    }
}