Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.bouncycastle.pqc.crypto.mceliece;
  
  
This class implements key pair generation of the McEliece Public Key Cryptosystem (McEliecePKC).
 
 {
 
 
     public McElieceKeyPairGenerator()
     {
 
     }


    
The OID of the algorithm.
 
     private static final String OID = "1.3.6.1.4.1.8301.3.1.3.4.1";
 
 
     // the extension degree of the finite field GF(2^m)
     private int m;
 
     // the length of the code
     private int n;
 
     // the error correction capability
     private int t;
 
     // the field polynomial
     private int fieldPoly;
 
     // the source of randomness
     private SecureRandom random;
 
     // flag indicating whether the key pair generator has been initialized
     private boolean initialized = false;


    
Default initialization of the key pair generator.
 
     private void initializeDefault()
     {
         initialize(mcParams);
     }
 
     private void initialize(
         KeyGenerationParameters param)
     {
         this. = (McElieceKeyGenerationParameters)param;
 
         // set source of randomness
         this. = new SecureRandom();
 
         this. = this..getParameters().getM();
         this. = this..getParameters().getN();
         this. = this..getParameters().getT();
         this. = this..getParameters().getFieldPoly();
         this. = true;
     }
 
 
     {
 
         if (!)
         {
             initializeDefault();
         }
 
         // finite field GF(2^m)
         GF2mField field = new GF2mField();
 
         // irreducible Goppa polynomial
         PolynomialGF2mSmallM gp = new PolynomialGF2mSmallM(field,
         PolynomialRingGF2m ring = new PolynomialRingGF2m(fieldgp);
 
         // matrix used to compute square roots in (GF(2^m))^t
        PolynomialGF2mSmallM[] sqRootMatrix = ring.getSquareRootMatrix();
        // generate canonical check matrix
        GF2Matrix h = GoppaCode.createCanonicalCheckMatrix(fieldgp);
        // compute short systematic form of check matrix
        MaMaPe mmp = GoppaCode.computeSystematicForm(h);
        GF2Matrix shortH = mmp.getSecondMatrix();
        Permutation p1 = mmp.getPermutation();
        // compute short systematic form of generator matrix
        GF2Matrix shortG = (GF2Matrix)shortH.computeTranspose();
        // extend to full systematic form
        GF2Matrix gPrime = shortG.extendLeftCompactForm();
        // obtain number of rows of G (= dimension of the code)
        int k = shortG.getNumRows();
        // generate random invertible (k x k)-matrix S and its inverse S^-1
        GF2Matrix[] matrixSandInverse = GF2Matrix
            .createRandomRegularMatrixAndItsInverse(k);
        // generate random permutation P2
        Permutation p2 = new Permutation();
        // compute public matrix G=S*G'*P2
        GF2Matrix g = (GF2Matrix)matrixSandInverse[0].rightMultiply(gPrime);
        g = (GF2Matrix)g.rightMultiply(p2);
        // generate keys
        McEliecePrivateKeyParameters privKey = new McEliecePrivateKeyParameters(k,
            fieldgpmatrixSandInverse[1], p1p2hsqRootMatrix.getParameters());
        // return key pair
        return new AsymmetricCipherKeyPair(pubKeyprivKey);
    }
    public void init(KeyGenerationParameters param)
    {
        this.initialize(param);
    }
    {
        return genKeyPair();
    }
New to GrepCode? Check out our FAQ X