Java Permutation类代码示例

import org.bouncycastle.pqc.math.linearalgebra.Permutation; //导入依赖的package包/类
/**
 * Constructor (used by the {@link McElieceKeyFactory}).
 *
 * @param oid
 * @param n            the length of the code
 * @param k            the dimension of the code
 * @param encField     the encoded field polynomial defining the finite field
 *                     <tt>GF(2<sup>m</sup>)</tt>
 * @param encGoppaPoly the encoded irreducible Goppa polynomial
 * @param encSInv      the encoded matrix <tt>S<sup>-1</sup></tt>
 * @param encP1        the encoded permutation used to generate the systematic
 *                     check matrix
 * @param encP2        the encoded permutation used to compute the public
 *                     generator matrix
 * @param encH         the encoded canonical check matrix
 * @param encQInv      the encoded matrix used to compute square roots in
 *                     <tt>(GF(2<sup>m</sup>))<sup>t</sup></tt>
 * @param params       McElieceParameters
 */
public McEliecePrivateKeyParameters(String oid, int n, int k, byte[] encField,
                                    byte[] encGoppaPoly, byte[] encSInv, byte[] encP1, byte[] encP2,
                                    byte[] encH, byte[][] encQInv, McElieceParameters params)
{
    super(true, params);
    this.oid = oid;
    this.n = n;
    this.k = k;
    field = new GF2mField(encField);
    goppaPoly = new PolynomialGF2mSmallM(field, encGoppaPoly);
    sInv = new GF2Matrix(encSInv);
    p1 = new Permutation(encP1);
    p2 = new Permutation(encP2);
    h = new GF2Matrix(encH);
    qInv = new PolynomialGF2mSmallM[encQInv.length];
    for (int i = 0; i < encQInv.length; i++)
    {
        qInv[i] = new PolynomialGF2mSmallM(field, encQInv[i]);
    }
}
 

import org.bouncycastle.pqc.math.linearalgebra.Permutation; //导入依赖的package包/类
/**
 * Constructor used by the {@link McElieceKeyFactory}.
 *
 * @param n            the length of the code
 * @param k            the dimension of the code
 * @param encFieldPoly the encoded field polynomial defining the finite field
 *                     <tt>GF(2<sup>m</sup>)</tt>
 * @param encGoppaPoly the encoded irreducible Goppa polynomial
 * @param encP         the encoded permutation
 * @param encH         the encoded canonical check matrix
 * @param encQInv      the encoded matrix used to compute square roots in
 *                     <tt>(GF(2^m))^t</tt>
 * @param params       McElieceCCA2Parameters
 */
public McElieceCCA2PrivateKeyParameters(String oid, int n, int k, byte[] encFieldPoly,
                                        byte[] encGoppaPoly, byte[] encP, byte[] encH, byte[][] encQInv, McElieceCCA2Parameters params)
{
    super(true, params);
    this.oid = oid;
    this.n = n;
    this.k = k;
    field = new GF2mField(encFieldPoly);
    goppaPoly = new PolynomialGF2mSmallM(field, encGoppaPoly);
    p = new Permutation(encP);
    h = new GF2Matrix(encH);
    qInv = new PolynomialGF2mSmallM[encQInv.length];
    for (int i = 0; i < encQInv.length; i++)
    {
        qInv[i] = new PolynomialGF2mSmallM(field, encQInv[i]);
    }
}
 

import org.bouncycastle.pqc.math.linearalgebra.Permutation; //导入依赖的package包/类
public McElieceCCA2PrivateKey(ASN1ObjectIdentifier oid, int n, int k, GF2mField field, PolynomialGF2mSmallM goppaPoly, Permutation p, GF2Matrix h, PolynomialGF2mSmallM[] qInv)
{
    this.oid = oid;
    this.n = n;
    this.k = k;
    this.encField = field.getEncoded();
    this.encGp = goppaPoly.getEncoded();
    this.encP = p.getEncoded();
    this.encH = h.getEncoded();
    this.encqInv = new byte[qInv.length][];

    for (int i = 0; i != qInv.length; i++)
    {
        encqInv[i] = qInv[i].getEncoded();
    }
}
 

import org.bouncycastle.pqc.math.linearalgebra.Permutation; //导入依赖的package包/类
public McEliecePrivateKey(ASN1ObjectIdentifier oid, int n, int k, GF2mField field, PolynomialGF2mSmallM goppaPoly, GF2Matrix sInv, Permutation p1, Permutation p2, GF2Matrix h, PolynomialGF2mSmallM[] qInv)
{
    this.oid = oid;
    this.n = n;
    this.k = k;
    this.encField = field.getEncoded();
    this.encGp = goppaPoly.getEncoded();
    this.encSInv = sInv.getEncoded();
    this.encP1 = p1.getEncoded();
    this.encP2 = p2.getEncoded();
    this.encH = h.getEncoded();
    this.encqInv = new byte[qInv.length][];

    for (int i = 0; i != qInv.length; i++)
    {
        encqInv[i] = qInv[i].getEncoded();
    }
}
 

import org.bouncycastle.pqc.math.linearalgebra.Permutation; //导入依赖的package包/类
/**
 * Constructor used by the {@link McElieceKeyFactory}.
 *
 * @param n            the length of the code
 * @param k            the dimension of the code
 * @param encFieldPoly the encoded field polynomial defining the finite field
 *                     <tt>GF(2<sup>m</sup>)</tt>
 * @param encGoppaPoly the encoded irreducible Goppa polynomial
 * @param encP         the encoded permutation
 * @param encH         the encoded canonical check matrix
 * @param encQInv      the encoded matrix used to compute square roots in
 *                     <tt>(GF(2^m))^t</tt>
 */
public McElieceCCA2PrivateKeySpec(String oid, int n, int k, byte[] encFieldPoly,
                                  byte[] encGoppaPoly, byte[] encP, byte[] encH, byte[][] encQInv)
{
    this.oid = oid;
    this.n = n;
    this.k = k;
    field = new GF2mField(encFieldPoly);
    goppaPoly = new PolynomialGF2mSmallM(field, encGoppaPoly);
    p = new Permutation(encP);
    h = new GF2Matrix(encH);
    qInv = new PolynomialGF2mSmallM[encQInv.length];
    for (int i = 0; i < encQInv.length; i++)
    {
        qInv[i] = new PolynomialGF2mSmallM(field, encQInv[i]);
    }
}
 

import org.bouncycastle.pqc.math.linearalgebra.Permutation; //导入依赖的package包/类
/**
 * Constructor (used by the {@link McElieceKeyFactory}).
 *
 * @param oid
 * @param n            the length of the code
 * @param k            the dimension of the code
 * @param encField     the encoded field polynomial defining the finite field
 *                     <tt>GF(2<sup>m</sup>)</tt>
 * @param encGoppaPoly the encoded irreducible Goppa polynomial
 * @param encSInv      the encoded matrix <tt>S<sup>-1</sup></tt>
 * @param encP1        the encoded permutation used to generate the systematic
 *                     check matrix
 * @param encP2        the encoded permutation used to compute the public
 *                     generator matrix
 * @param encH         the encoded canonical check matrix
 * @param encQInv      the encoded matrix used to compute square roots in
 *                     <tt>(GF(2<sup>m</sup>))<sup>t</sup></tt>
 */
public McEliecePrivateKeySpec(String oid, int n, int k, byte[] encField,
                              byte[] encGoppaPoly, byte[] encSInv, byte[] encP1, byte[] encP2,
                              byte[] encH, byte[][] encQInv)
{
    this.oid = oid;
    this.n = n;
    this.k = k;
    field = new GF2mField(encField);
    goppaPoly = new PolynomialGF2mSmallM(field, encGoppaPoly);
    sInv = new GF2Matrix(encSInv);
    p1 = new Permutation(encP1);
    p2 = new Permutation(encP2);
    h = new GF2Matrix(encH);
    qInv = new PolynomialGF2mSmallM[encQInv.length];
    for (int i = 0; i < encQInv.length; i++)
    {
        qInv[i] = new PolynomialGF2mSmallM(field, encQInv[i]);
    }
}
 

import org.bouncycastle.pqc.math.linearalgebra.Permutation; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param oid
 * @param n            the length of the code
 * @param k            the dimension of the code
 * @param encField     the encoded field polynomial defining the finite field
 *                     <tt>GF(2<sup>m</sup>)</tt>
 * @param encGoppaPoly the encoded irreducible Goppa polynomial
 * @param encSInv      the encoded matrix <tt>S<sup>-1</sup></tt>
 * @param encP1        the encoded permutation used to generate the systematic
 *                     check matrix
 * @param encP2        the encoded permutation used to compute the public
 *                     generator matrix
 * @param encH         the encoded canonical check matrix
 * @param encQInv      the encoded matrix used to compute square roots in
 *                     <tt>(GF(2<sup>m</sup>))<sup>t</sup></tt>
 * @param params       McElieceParameters
 */
public McEliecePrivateKeyParameters(String oid, int n, int k, byte[] encField,
                                    byte[] encGoppaPoly, byte[] encSInv, byte[] encP1, byte[] encP2,
                                    byte[] encH, byte[][] encQInv, McElieceParameters params)
{
    super(true, params);
    this.oid = oid;
    this.n = n;
    this.k = k;
    field = new GF2mField(encField);
    goppaPoly = new PolynomialGF2mSmallM(field, encGoppaPoly);
    sInv = new GF2Matrix(encSInv);
    p1 = new Permutation(encP1);
    p2 = new Permutation(encP2);
    h = new GF2Matrix(encH);
    qInv = new PolynomialGF2mSmallM[encQInv.length];
    for (int i = 0; i < encQInv.length; i++)
    {
        qInv[i] = new PolynomialGF2mSmallM(field, encQInv[i]);
    }
}
 

import org.bouncycastle.pqc.math.linearalgebra.Permutation; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param n            the length of the code
 * @param k            the dimension of the code
 * @param encFieldPoly the encoded field polynomial defining the finite field
 *                     <tt>GF(2<sup>m</sup>)</tt>
 * @param encGoppaPoly the encoded irreducible Goppa polynomial
 * @param encP         the encoded permutation
 * @param encH         the encoded canonical check matrix
 * @param encQInv      the encoded matrix used to compute square roots in
 *                     <tt>(GF(2^m))^t</tt>
 * @param params       McElieceCCA2Parameters
 */
public McElieceCCA2PrivateKeyParameters(String oid, int n, int k, byte[] encFieldPoly,
                                        byte[] encGoppaPoly, byte[] encP, byte[] encH, byte[][] encQInv, McElieceCCA2Parameters params)
{
    super(true, params);
    this.oid = oid;
    this.n = n;
    this.k = k;
    field = new GF2mField(encFieldPoly);
    goppaPoly = new PolynomialGF2mSmallM(field, encGoppaPoly);
    p = new Permutation(encP);
    h = new GF2Matrix(encH);
    qInv = new PolynomialGF2mSmallM[encQInv.length];
    for (int i = 0; i < encQInv.length; i++)
    {
        qInv[i] = new PolynomialGF2mSmallM(field, encQInv[i]);
    }
}
 

import org.bouncycastle.pqc.math.linearalgebra.Permutation; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param n            the length of the code
 * @param k            the dimension of the code
 * @param encFieldPoly the encoded field polynomial defining the finite field
 *                     <tt>GF(2<sup>m</sup>)</tt>
 * @param encGoppaPoly the encoded irreducible Goppa polynomial
 * @param encP         the encoded permutation
 * @param encH         the encoded canonical check matrix
 * @param encQInv      the encoded matrix used to compute square roots in
 *                     <tt>(GF(2^m))^t</tt>
 */
public McElieceCCA2PrivateKeySpec(String oid, int n, int k, byte[] encFieldPoly,
                                  byte[] encGoppaPoly, byte[] encP, byte[] encH, byte[][] encQInv)
{
    this.oid = oid;
    this.n = n;
    this.k = k;
    field = new GF2mField(encFieldPoly);
    goppaPoly = new PolynomialGF2mSmallM(field, encGoppaPoly);
    p = new Permutation(encP);
    h = new GF2Matrix(encH);
    qInv = new PolynomialGF2mSmallM[encQInv.length];
    for (int i = 0; i < encQInv.length; i++)
    {
        qInv[i] = new PolynomialGF2mSmallM(field, encQInv[i]);
    }
}
 

import org.bouncycastle.pqc.math.linearalgebra.Permutation; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param oid          string representation of the object identifier the algorithm for this key.
 * @param n            the length of the code
 * @param k            the dimension of the code
 * @param encField     the encoded field polynomial defining the finite field
 *                     <tt>GF(2<sup>m</sup>)</tt>
 * @param encGoppaPoly the encoded irreducible Goppa polynomial
 * @param encSInv      the encoded matrix <tt>S<sup>-1</sup></tt>
 * @param encP1        the encoded permutation used to generate the systematic
 *                     check matrix
 * @param encP2        the encoded permutation used to compute the public
 *                     generator matrix
 * @param encH         the encoded canonical check matrix
 * @param encQInv      the encoded matrix used to compute square roots in
 *                     <tt>(GF(2<sup>m</sup>))<sup>t</sup></tt>
 */
public McEliecePrivateKeySpec(String oid, int n, int k, byte[] encField,
                              byte[] encGoppaPoly, byte[] encSInv, byte[] encP1, byte[] encP2,
                              byte[] encH, byte[][] encQInv)
{
    this.oid = oid;
    this.n = n;
    this.k = k;
    field = new GF2mField(encField);
    goppaPoly = new PolynomialGF2mSmallM(field, encGoppaPoly);
    sInv = new GF2Matrix(encSInv);
    p1 = new Permutation(encP1);
    p2 = new Permutation(encP2);
    h = new GF2Matrix(encH);
    qInv = new PolynomialGF2mSmallM[encQInv.length];
    for (int i = 0; i < encQInv.length; i++)
    {
        qInv[i] = new PolynomialGF2mSmallM(field, encQInv[i]);
    }
}
 

import org.bouncycastle.pqc.math.linearalgebra.Permutation; //导入依赖的package包/类
/**
 * Create an nxn random regular matrix.
 *
 * @param n  number of rows (and columns)
 * @param sr source of randomness
 */
public void assignRandomRegularMatrix(int n, SecureRandom sr)
{
    numRows = n;
    numColumns = n;
    length = (n + (INTSIZE-1)) >>> BLOCKEXP;
    matrix = new int[numRows][length];
    GF2MatrixEx lm = new GF2MatrixEx(n, Matrix.MATRIX_TYPE_RANDOM_LT, sr);
    GF2MatrixEx um = new GF2MatrixEx(n, Matrix.MATRIX_TYPE_RANDOM_UT, sr);
    GF2MatrixEx rm = (GF2MatrixEx)lm.rightMultiply(um);
    Permutation perm = new Permutation(n, sr);
    int[] p = perm.getVector();
    for (int i = 0; i < n; i++)
    {
        System.arraycopy(rm.getIntArray()[i], 0, matrix[p[i]], 0, length);
    }
}
 

import org.bouncycastle.pqc.math.linearalgebra.Permutation; //导入依赖的package包/类
/**
 * Compute the product of a permutation matrix (which is generated from an
 * n-permutation) and this matrix.
 *
 * @param p the permutation
 * @return {@link GF2MatrixEx} <tt>P*this</tt>
 */
public Matrix leftMultiply(Permutation p)
{
    int[] pVec = p.getVector();
    if (pVec.length != numRows)
    {
        throw new ArithmeticException("length mismatch");
    }

    int[][] result = new int[numRows][];

    for (int i = numRows - 1; i >= 0; i--)
    {
        result[i] = IntUtils.clone(matrix[pVec[i]]);
    }

    return new GF2MatrixEx(numRows, result);
}
 

import org.bouncycastle.pqc.math.linearalgebra.Permutation; //导入依赖的package包/类
/**
 * Compute the product of this matrix and a permutation matrix which is
 * generated from an n-permutation.
 *
 * @param p the permutation
 * @return {@link GF2MatrixEx} <tt>this*P</tt>
 */
public Matrix rightMultiply(Permutation p)
{

    int[] pVec = p.getVector();
    if (pVec.length != numColumns)
    {
        throw new ArithmeticException("length mismatch");
    }

    GF2MatrixEx result = new GF2MatrixEx(numRows, numColumns);

    for (int i = numColumns - 1; i >= 0; i--)
    {
        int q = i >>> BLOCKEXP;
        int r = i & 0x1f;
        int pq = pVec[i] >>> BLOCKEXP;
        int pr = pVec[i] & 0x1f;
        for (int j = numRows - 1; j >= 0; j--)
        {
            result.matrix[j][q] |= ((matrix[j][pq] >>> pr) & 1) << r;
        }
    }

    return result;
}