import org.bouncycastle.pqc.crypto.gmss.GMSSParameters; //导入依赖的package包/类
public GMSSPrivateKey(int[] index, byte[][] currentSeed,
                      byte[][] nextNextSeed, byte[][][] currentAuthPath,
                      byte[][][] nextAuthPath, Treehash[][] currentTreehash,
                      Treehash[][] nextTreehash, Vector[] currentStack,
                      Vector[] nextStack, Vector[][] currentRetain,
                      Vector[][] nextRetain, byte[][][] keep, GMSSLeaf[] nextNextLeaf,
                      GMSSLeaf[] upperLeaf, GMSSLeaf[] upperTreehashLeaf,
                      int[] minTreehash, byte[][] nextRoot, GMSSRootCalc[] nextNextRoot,
                      byte[][] currentRootSig, GMSSRootSig[] nextRootSig,
                      GMSSParameters gmssParameterset, AlgorithmIdentifier digestAlg)
{
    AlgorithmIdentifier[] names = new AlgorithmIdentifier[] { digestAlg };
    this.primitive = encode(index, currentSeed, nextNextSeed, currentAuthPath, nextAuthPath, keep, currentTreehash, nextTreehash, currentStack, nextStack, currentRetain, nextRetain, nextNextLeaf, upperLeaf, upperTreehashLeaf, minTreehash, nextRoot, nextNextRoot, currentRootSig, nextRootSig, gmssParameterset, names);
}
 

import org.bouncycastle.pqc.crypto.gmss.GMSSParameters; //导入依赖的package包/类
/**
 * @param index             tree indices
 * @param currentSeed       seed for the generation of private OTS keys for the
 *                          current subtrees (TREE)
 * @param nextNextSeed      seed for the generation of private OTS keys for the
 *                          subtrees after next (TREE++)
 * @param currentAuthPath   array of current authentication paths (AUTHPATH)
 * @param nextAuthPath      array of next authentication paths (AUTHPATH+)
 * @param keep              keep array for the authPath algorithm
 * @param currentTreehash   treehash for authPath algorithm of current tree
 * @param nextTreehash      treehash for authPath algorithm of next tree (TREE+)
 * @param currentStack      shared stack for authPath algorithm of current tree
 * @param nextStack         shared stack for authPath algorithm of next tree (TREE+)
 * @param currentRetain     retain stack for authPath algorithm of current tree
 * @param nextRetain        retain stack for authPath algorithm of next tree (TREE+)
 * @param nextNextLeaf      array of upcoming leafs of the tree after next (LEAF++) of
 *                          each layer
 * @param upperLeaf         needed for precomputation of upper nodes
 * @param upperTreehashLeaf needed for precomputation of upper treehash nodes
 * @param minTreehash       index of next treehash instance to receive an update
 * @param nextRoot          the roots of the next trees (ROOT+)
 * @param nextNextRoot      the roots of the tree after next (ROOT++)
 * @param currentRootSig    array of signatures of the roots of the current subtrees
 *                          (SIG)
 * @param nextRootSig       array of signatures of the roots of the next subtree
 *                          (SIG+)
 * @param gmssParameterset  the GMSS Parameterset
 */
public GMSSPrivateKeySpec(int[] index, byte[][] currentSeed,
                          byte[][] nextNextSeed, byte[][][] currentAuthPath,
                          byte[][][] nextAuthPath, Treehash[][] currentTreehash,
                          Treehash[][] nextTreehash, Vector[] currentStack,
                          Vector[] nextStack, Vector[][] currentRetain,
                          Vector[][] nextRetain, byte[][][] keep, GMSSLeaf[] nextNextLeaf,
                          GMSSLeaf[] upperLeaf, GMSSLeaf[] upperTreehashLeaf,
                          int[] minTreehash, byte[][] nextRoot, GMSSRootCalc[] nextNextRoot,
                          byte[][] currentRootSig, GMSSRootSig[] nextRootSig,
                          GMSSParameters gmssParameterset)
{
    this.index = index;
    this.currentSeed = currentSeed;
    this.nextNextSeed = nextNextSeed;
    this.currentAuthPath = currentAuthPath;
    this.nextAuthPath = nextAuthPath;
    this.currentTreehash = currentTreehash;
    this.nextTreehash = nextTreehash;
    this.currentStack = currentStack;
    this.nextStack = nextStack;
    this.currentRetain = currentRetain;
    this.nextRetain = nextRetain;
    this.keep = keep;
    this.nextNextLeaf = nextNextLeaf;
    this.upperLeaf = upperLeaf;
    this.upperTreehashLeaf = upperTreehashLeaf;
    this.minTreehash = minTreehash;
    this.nextRoot = nextRoot;
    this.nextNextRoot = nextNextRoot;
    this.currentRootSig = currentRootSig;
    this.nextRootSig = nextRootSig;
    this.gmssPS = gmssParameterset;
}
 

import org.bouncycastle.pqc.crypto.gmss.GMSSParameters; //导入依赖的package包/类
/**
 * The constructor.
 *
 * @param key              a raw GMSS public key
 * @param gmssParameterSet an instance of GMSSParameterSet
 */
public GMSSPublicKeySpec(byte[] key, GMSSParameters gmssParameterSet)
{
    super(gmssParameterSet);

    this.gmssPublicKey = key;
}
 

import org.bouncycastle.pqc.crypto.gmss.GMSSParameters; //导入依赖的package包/类
public GMSSParameters getGmssPS()
{
    return gmssPS;
}
 

import org.bouncycastle.pqc.crypto.gmss.GMSSParameters; //导入依赖的package包/类
protected GMSSKeySpec(GMSSParameters gmssParameterSet)
{
    this.gmssParameterSet = gmssParameterSet;
}
 

import org.bouncycastle.pqc.crypto.gmss.GMSSParameters; //导入依赖的package包/类
/**
 * @return The GMSS Parameterset
 */
public GMSSParameters getParameterSet()
{
    return gmssParameterSet;
}
 

import org.bouncycastle.pqc.crypto.gmss.GMSSParameters; //导入依赖的package包/类
public void performTest()
    throws Exception
{

    GMSSParameters params = new GMSSParameters(3,
        new int[]{15, 15, 10}, new int[]{5, 5, 4}, new int[]{3, 3, 2});

    GMSSDigestProvider digProvider = new GMSSDigestProvider()
    {
        public Digest get()
        {
            return new SHA224Digest();
        }
    };

    GMSSKeyPairGenerator gmssKeyGen = new GMSSKeyPairGenerator(digProvider);

    GMSSKeyGenerationParameters genParam = new GMSSKeyGenerationParameters(keyRandom, params);

    gmssKeyGen.init(genParam);

    AsymmetricCipherKeyPair pair = gmssKeyGen.generateKeyPair();

    ParametersWithRandom param = new ParametersWithRandom(pair.getPrivate(), keyRandom);

    // TODO
    Signer gmssSigner = new DigestingMessageSigner(new GMSSSigner(digProvider), new SHA224Digest());
    gmssSigner.init(true, param);

    byte[] message = BigIntegers.asUnsignedByteArray(new BigInteger("968236873715988614170569073515315707566766479517"));
    gmssSigner.update(message, 0, message.length);
    byte[] sig = gmssSigner.generateSignature();


    gmssSigner.init(false, pair.getPublic());
    gmssSigner.update(message, 0, message.length);
    if (!gmssSigner.verifySignature(sig))
    {
        fail("verification fails");
    }

    if (!((GMSSPrivateKeyParameters)pair.getPrivate()).isUsed())
    {
        fail("private key not marked as used");
    }
}
 

import org.bouncycastle.pqc.crypto.gmss.GMSSParameters; //导入依赖的package包/类
/**
 * Returns the GMSS parameter set
 *
 * @return The GMSS parameter set
 */
public GMSSParameters getParameters()
{
    return gmssParameterSet;
}
 

import org.bouncycastle.pqc.crypto.gmss.GMSSParameters; //导入依赖的package包/类
/**
 * The constructor
 *
 * @param pub              a raw GMSS public key
 * @param gmssParameterSet an instance of GMSS Parameterset
 * @see org.bouncycastle.pqc.crypto.gmss.GMSSKeyPairGenerator
 */
public BCGMSSPublicKey(byte[] pub, GMSSParameters gmssParameterSet)
{
    this.gmssParameterSet = gmssParameterSet;
    this.publicKeyBytes = pub;
}