import org.bouncycastle.pqc.math.ntru.polynomial.ProductFormPolynomial; //导入依赖的package包/类
/**
 * Reads a polynomial <code>f</code> from an input stream and constructs a new private key
 *
 * @param is     an input stream
 * @param params the NtruEncrypt parameters to use
 * @see #writeTo(OutputStream)
 */
public NTRUEncryptionPrivateKeyParameters(InputStream is, NTRUEncryptionParameters params)
    throws IOException
{
    super(true, params);

    if (params.polyType == NTRUParameters.TERNARY_POLYNOMIAL_TYPE_PRODUCT)
    {
        int N = params.N;
        int df1 = params.df1;
        int df2 = params.df2;
        int df3Ones = params.df3;
        int df3NegOnes = params.fastFp ? params.df3 : params.df3 - 1;
        h = IntegerPolynomial.fromBinary(is, params.N, params.q);
        t = ProductFormPolynomial.fromBinary(is, N, df1, df2, df3Ones, df3NegOnes);
    }
    else
    {
        h = IntegerPolynomial.fromBinary(is, params.N, params.q);
        IntegerPolynomial fInt = IntegerPolynomial.fromBinary3Tight(is, params.N);
        t = params.sparse ? new SparseTernaryPolynomial(fInt) : new DenseTernaryPolynomial(fInt);
    }

    init();
}
 

import org.bouncycastle.pqc.math.ntru.polynomial.ProductFormPolynomial; //导入依赖的package包/类
/**
 * Converts the key to a byte array
 *
 * @return the encoded key
 * @see #NTRUEncryptionPrivateKeyParameters(byte[], NTRUEncryptionParameters)
 */
public byte[] getEncoded()
{
    byte[] hBytes = h.toBinary(params.q);
    byte[] tBytes;

    if (t instanceof ProductFormPolynomial)
    {
        tBytes = ((ProductFormPolynomial)t).toBinary();
    }
    else
    {
        tBytes = t.toIntegerPolynomial().toBinary3Tight();
    }

    byte[] res = new byte[hBytes.length + tBytes.length];

    System.arraycopy(hBytes, 0, res, 0, hBytes.length);
    System.arraycopy(tBytes, 0, res, hBytes.length, tBytes.length);

    return res;
}
 

import org.bouncycastle.pqc.math.ntru.polynomial.ProductFormPolynomial; //导入依赖的package包/类
private byte[] getEncoded(Polynomial p)
{
    if (p instanceof ProductFormPolynomial)
    {
        return ((ProductFormPolynomial)p).toBinary();
    }
    else
    {
        return p.toIntegerPolynomial().toBinary3Tight();
    }
}
 

import org.bouncycastle.pqc.math.ntru.polynomial.ProductFormPolynomial; //导入依赖的package包/类
/**
 * Deterministically generates a blinding polynomial from a seed and a message representative.
 *
 * @param seed
 * @param M    message representative
 * @return a blinding polynomial
 */
private Polynomial generateBlindingPoly(byte[] seed, byte[] M)
{
    IndexGenerator ig = new IndexGenerator(seed, params);

    if (params.polyType == NTRUParameters.TERNARY_POLYNOMIAL_TYPE_PRODUCT)
    {
        SparseTernaryPolynomial r1 = new SparseTernaryPolynomial(generateBlindingCoeffs(ig, params.dr1));
        SparseTernaryPolynomial r2 = new SparseTernaryPolynomial(generateBlindingCoeffs(ig, params.dr2));
        SparseTernaryPolynomial r3 = new SparseTernaryPolynomial(generateBlindingCoeffs(ig, params.dr3));
        return new ProductFormPolynomial(r1, r2, r3);
    }
    else
    {
        int dr = params.dr;
        boolean sparse = params.sparse;
        int[] r = generateBlindingCoeffs(ig, dr);
        if (sparse)
        {
            return new SparseTernaryPolynomial(r);
        }
        else
        {
            return new DenseTernaryPolynomial(r);
        }
    }
}
 

import org.bouncycastle.pqc.math.ntru.polynomial.ProductFormPolynomial; //导入依赖的package包/类
public void testFromToBinary()
    throws Exception
{
    ProductFormPolynomial p1 = ProductFormPolynomial.generateRandom(N, df1, df2, df3, df3 - 1, new SecureRandom());
    byte[] bin1 = p1.toBinary();
    ProductFormPolynomial p2 = ProductFormPolynomial.fromBinary(bin1, N, df1, df2, df3, df3 - 1);
    assertEquals(p1, p2);
}
 

import org.bouncycastle.pqc.math.ntru.polynomial.ProductFormPolynomial; //导入依赖的package包/类
public void testMult()
{
    ProductFormPolynomial p1 = ProductFormPolynomial.generateRandom(N, df1, df2, df3, df3 - 1, new SecureRandom());
    IntegerPolynomial p2 = PolynomialGenerator.generateRandom(N, q);
    IntegerPolynomial p3 = p1.mult(p2);
    IntegerPolynomial p4 = p1.toIntegerPolynomial().mult(p2);
    assertEquals(p3, p4);
}
 

import org.bouncycastle.pqc.math.ntru.polynomial.ProductFormPolynomial; //导入依赖的package包/类
/**
 * Reads a basis from an input stream and constructs a new basis.
 *
 * @param is        an input stream
 * @param params    NtruSign parameters
 * @param include_h whether to read the polynomial <code>h</code> (<code>true</code>) or only <code>f</code> and <code>f'</code> (<code>false</code>)
 */
Basis(InputStream is, NTRUSigningKeyGenerationParameters params, boolean include_h)
    throws IOException
{
    int N = params.N;
    int q = params.q;
    int d1 = params.d1;
    int d2 = params.d2;
    int d3 = params.d3;
    boolean sparse = params.sparse;
    this.params = params;

    if (params.polyType == NTRUParameters.TERNARY_POLYNOMIAL_TYPE_PRODUCT)
    {
        f = ProductFormPolynomial.fromBinary(is, N, d1, d2, d3 + 1, d3);
    }
    else
    {
        IntegerPolynomial fInt = IntegerPolynomial.fromBinary3Tight(is, N);
        f = sparse ? new SparseTernaryPolynomial(fInt) : new DenseTernaryPolynomial(fInt);
    }

    if (params.basisType == NTRUSigningKeyGenerationParameters.BASIS_TYPE_STANDARD)
    {
        IntegerPolynomial fPrimeInt = IntegerPolynomial.fromBinary(is, N, q);
        for (int i = 0; i < fPrimeInt.coeffs.length; i++)
        {
            fPrimeInt.coeffs[i] -= q / 2;
        }
        fPrime = fPrimeInt;
    }
    else if (params.polyType == NTRUParameters.TERNARY_POLYNOMIAL_TYPE_PRODUCT)
    {
        fPrime = ProductFormPolynomial.fromBinary(is, N, d1, d2, d3 + 1, d3);
    }
    else
    {
        fPrime = IntegerPolynomial.fromBinary3Tight(is, N);
    }

    if (include_h)
    {
        h = IntegerPolynomial.fromBinary(is, N, q);
    }
}