| package org.bouncycastle.pqc.asn1; |
| |
| import java.math.BigInteger; |
| import java.util.Vector; |
| |
| import org.bouncycastle.asn1.ASN1Encodable; |
| import org.bouncycastle.asn1.ASN1EncodableVector; |
| import org.bouncycastle.asn1.ASN1Integer; |
| import org.bouncycastle.asn1.ASN1Object; |
| import org.bouncycastle.asn1.ASN1Primitive; |
| import org.bouncycastle.asn1.ASN1Sequence; |
| import org.bouncycastle.asn1.DEROctetString; |
| import org.bouncycastle.asn1.DERSequence; |
| import org.bouncycastle.asn1.x509.AlgorithmIdentifier; |
| import org.bouncycastle.pqc.crypto.gmss.GMSSLeaf; |
| import org.bouncycastle.pqc.crypto.gmss.GMSSParameters; |
| import org.bouncycastle.pqc.crypto.gmss.GMSSRootCalc; |
| import org.bouncycastle.pqc.crypto.gmss.GMSSRootSig; |
| import org.bouncycastle.pqc.crypto.gmss.Treehash; |
| |
| public class GMSSPrivateKey |
| extends ASN1Object |
| { |
| private ASN1Primitive primitive; |
| |
| private GMSSPrivateKey(ASN1Sequence mtsPrivateKey) |
| { |
| // --- Decode <index>. |
| ASN1Sequence indexPart = (ASN1Sequence)mtsPrivateKey.getObjectAt(0); |
| int[] index = new int[indexPart.size()]; |
| for (int i = 0; i < indexPart.size(); i++) |
| { |
| index[i] = checkBigIntegerInIntRange(indexPart.getObjectAt(i)); |
| } |
| |
| // --- Decode <curSeeds>. |
| ASN1Sequence curSeedsPart = (ASN1Sequence)mtsPrivateKey.getObjectAt(1); |
| byte[][] curSeeds = new byte[curSeedsPart.size()][]; |
| for (int i = 0; i < curSeeds.length; i++) |
| { |
| curSeeds[i] = ((DEROctetString)curSeedsPart.getObjectAt(i)).getOctets(); |
| } |
| |
| // --- Decode <nextNextSeeds>. |
| ASN1Sequence nextNextSeedsPart = (ASN1Sequence)mtsPrivateKey.getObjectAt(2); |
| byte[][] nextNextSeeds = new byte[nextNextSeedsPart.size()][]; |
| for (int i = 0; i < nextNextSeeds.length; i++) |
| { |
| nextNextSeeds[i] = ((DEROctetString)nextNextSeedsPart.getObjectAt(i)).getOctets(); |
| } |
| |
| // --- Decode <curAuth>. |
| ASN1Sequence curAuthPart0 = (ASN1Sequence)mtsPrivateKey.getObjectAt(3); |
| ASN1Sequence curAuthPart1; |
| |
| byte[][][] curAuth = new byte[curAuthPart0.size()][][]; |
| for (int i = 0; i < curAuth.length; i++) |
| { |
| curAuthPart1 = (ASN1Sequence)curAuthPart0.getObjectAt(i); |
| curAuth[i] = new byte[curAuthPart1.size()][]; |
| for (int j = 0; j < curAuth[i].length; j++) |
| { |
| curAuth[i][j] = ((DEROctetString)curAuthPart1.getObjectAt(j)).getOctets(); |
| } |
| } |
| |
| // --- Decode <nextAuth>. |
| ASN1Sequence nextAuthPart0 = (ASN1Sequence)mtsPrivateKey.getObjectAt(4); |
| ASN1Sequence nextAuthPart1; |
| |
| byte[][][] nextAuth = new byte[nextAuthPart0.size()][][]; |
| for (int i = 0; i < nextAuth.length; i++) |
| { |
| nextAuthPart1 = (ASN1Sequence)nextAuthPart0.getObjectAt(i); |
| nextAuth[i] = new byte[nextAuthPart1.size()][]; |
| for (int j = 0; j < nextAuth[i].length; j++) |
| { |
| nextAuth[i][j] = ((DEROctetString)nextAuthPart1.getObjectAt(j)).getOctets(); |
| } |
| } |
| |
| // --- Decode <curTreehash>. |
| ASN1Sequence seqOfcurTreehash0 = (ASN1Sequence)mtsPrivateKey.getObjectAt(5); |
| ASN1Sequence seqOfcurTreehash1; |
| ASN1Sequence seqOfcurTreehashStat; |
| ASN1Sequence seqOfcurTreehashBytes; |
| ASN1Sequence seqOfcurTreehashInts; |
| ASN1Sequence seqOfcurTreehashString; |
| |
| Treehash[][] curTreehash = new Treehash[seqOfcurTreehash0.size()][]; |
| /* |
| for (int i = 0; i < curTreehash.length; i++) |
| { |
| seqOfcurTreehash1 = (ASN1Sequence)seqOfcurTreehash0.getObjectAt(i); |
| curTreehash[i] = new Treehash[seqOfcurTreehash1.size()]; |
| for (int j = 0; j < curTreehash[i].length; j++) |
| { |
| seqOfcurTreehashStat = (ASN1Sequence)seqOfcurTreehash1.getObjectAt(j); |
| seqOfcurTreehashString = (ASN1Sequence)seqOfcurTreehashStat |
| .getObjectAt(0); |
| seqOfcurTreehashBytes = (ASN1Sequence)seqOfcurTreehashStat |
| .getObjectAt(1); |
| seqOfcurTreehashInts = (ASN1Sequence)seqOfcurTreehashStat |
| .getObjectAt(2); |
| |
| String[] name = new String[2]; |
| name[0] = ((DERIA5String)seqOfcurTreehashString.getObjectAt(0)).getString(); |
| name[1] = ((DERIA5String)seqOfcurTreehashString.getObjectAt(1)).getString(); |
| |
| int tailLength = checkBigIntegerInIntRange(seqOfcurTreehashInts.getObjectAt(1)); |
| byte[][] statByte = new byte[3 + tailLength][]; |
| statByte[0] = ((DEROctetString)seqOfcurTreehashBytes.getObjectAt(0)).getOctets(); |
| |
| if (statByte[0].length == 0) |
| { // if null was encoded |
| statByte[0] = null; |
| } |
| |
| statByte[1] = ((DEROctetString)seqOfcurTreehashBytes.getObjectAt(1)).getOctets(); |
| statByte[2] = ((DEROctetString)seqOfcurTreehashBytes.getObjectAt(2)).getOctets(); |
| for (int k = 0; k < tailLength; k++) |
| { |
| statByte[3 + k] = ((DEROctetString)seqOfcurTreehashBytes |
| .getObjectAt(3 + k)).getOctets(); |
| } |
| int[] statInt = new int[6 + tailLength]; |
| statInt[0] = checkBigIntegerInIntRange(seqOfcurTreehashInts.getObjectAt(0)); |
| statInt[1] = tailLength; |
| statInt[2] = checkBigIntegerInIntRange(seqOfcurTreehashInts.getObjectAt(2)); |
| statInt[3] = checkBigIntegerInIntRange(seqOfcurTreehashInts.getObjectAt(3)); |
| statInt[4] = checkBigIntegerInIntRange(seqOfcurTreehashInts.getObjectAt(4)); |
| statInt[5] = checkBigIntegerInIntRange(seqOfcurTreehashInts.getObjectAt(5)); |
| for (int k = 0; k < tailLength; k++) |
| { |
| statInt[6 + k] = checkBigIntegerInIntRange(seqOfcurTreehashInts.getObjectAt(6 + k)); |
| } |
| |
| // TODO: Check if we can do better than throwing away name[1] !!! |
| curTreehash[i][j] = new Treehash(DigestFactory.getDigest(name[0]).getClass(), statByte, statInt); |
| } |
| } |
| |
| |
| // --- Decode <nextTreehash>. |
| ASN1Sequence seqOfNextTreehash0 = (ASN1Sequence)mtsPrivateKey.getObjectAt(6); |
| ASN1Sequence seqOfNextTreehash1; |
| ASN1Sequence seqOfNextTreehashStat; |
| ASN1Sequence seqOfNextTreehashBytes; |
| ASN1Sequence seqOfNextTreehashInts; |
| ASN1Sequence seqOfNextTreehashString; |
| |
| Treehash[][] nextTreehash = new Treehash[seqOfNextTreehash0.size()][]; |
| |
| for (int i = 0; i < nextTreehash.length; i++) |
| { |
| seqOfNextTreehash1 = (ASN1Sequence)seqOfNextTreehash0.getObjectAt(i); |
| nextTreehash[i] = new Treehash[seqOfNextTreehash1.size()]; |
| for (int j = 0; j < nextTreehash[i].length; j++) |
| { |
| seqOfNextTreehashStat = (ASN1Sequence)seqOfNextTreehash1 |
| .getObjectAt(j); |
| seqOfNextTreehashString = (ASN1Sequence)seqOfNextTreehashStat |
| .getObjectAt(0); |
| seqOfNextTreehashBytes = (ASN1Sequence)seqOfNextTreehashStat |
| .getObjectAt(1); |
| seqOfNextTreehashInts = (ASN1Sequence)seqOfNextTreehashStat |
| .getObjectAt(2); |
| |
| String[] name = new String[2]; |
| name[0] = ((DERIA5String)seqOfNextTreehashString.getObjectAt(0)) |
| .getString(); |
| name[1] = ((DERIA5String)seqOfNextTreehashString.getObjectAt(1)) |
| .getString(); |
| |
| int tailLength = checkBigIntegerInIntRange(seqOfNextTreehashInts.getObjectAt(1)); |
| |
| byte[][] statByte = new byte[3 + tailLength][]; |
| statByte[0] = ((DEROctetString)seqOfNextTreehashBytes.getObjectAt(0)).getOctets(); |
| if (statByte[0].length == 0) |
| { // if null was encoded |
| statByte[0] = null; |
| } |
| |
| statByte[1] = ((DEROctetString)seqOfNextTreehashBytes.getObjectAt(1)).getOctets(); |
| statByte[2] = ((DEROctetString)seqOfNextTreehashBytes.getObjectAt(2)).getOctets(); |
| for (int k = 0; k < tailLength; k++) |
| { |
| statByte[3 + k] = ((DEROctetString)seqOfNextTreehashBytes |
| .getObjectAt(3 + k)).getOctets(); |
| } |
| int[] statInt = new int[6 + tailLength]; |
| statInt[0] = checkBigIntegerInIntRange(seqOfNextTreehashInts.getObjectAt(0)); |
| |
| statInt[1] = tailLength; |
| statInt[2] = checkBigIntegerInIntRange(seqOfNextTreehashInts.getObjectAt(2)); |
| |
| statInt[3] = checkBigIntegerInIntRange(seqOfNextTreehashInts.getObjectAt(3)); |
| |
| statInt[4] = checkBigIntegerInIntRange(seqOfNextTreehashInts.getObjectAt(4)); |
| |
| statInt[5] = checkBigIntegerInIntRange(seqOfNextTreehashInts.getObjectAt(5)); |
| |
| for (int k = 0; k < tailLength; k++) |
| { |
| statInt[6 + k] = checkBigIntegerInIntRange(seqOfNextTreehashInts.getObjectAt(6 + k)); |
| |
| } |
| nextTreehash[i][j] = new Treehash(DigestFactory.getDigest(name[0]).getClass(), statByte, statInt); |
| } |
| } |
| |
| |
| // --- Decode <keep>. |
| ASN1Sequence keepPart0 = (ASN1Sequence)mtsPrivateKey.getObjectAt(7); |
| ASN1Sequence keepPart1; |
| |
| byte[][][] keep = new byte[keepPart0.size()][][]; |
| for (int i = 0; i < keep.length; i++) |
| { |
| keepPart1 = (ASN1Sequence)keepPart0.getObjectAt(i); |
| keep[i] = new byte[keepPart1.size()][]; |
| for (int j = 0; j < keep[i].length; j++) |
| { |
| keep[i][j] = ((DEROctetString)keepPart1.getObjectAt(j)).getOctets(); |
| } |
| } |
| |
| // --- Decode <curStack>. |
| ASN1Sequence curStackPart0 = (ASN1Sequence)mtsPrivateKey.getObjectAt(8); |
| ASN1Sequence curStackPart1; |
| |
| Vector[] curStack = new Vector[curStackPart0.size()]; |
| for (int i = 0; i < curStack.length; i++) |
| { |
| curStackPart1 = (ASN1Sequence)curStackPart0.getObjectAt(i); |
| curStack[i] = new Vector(); |
| for (int j = 0; j < curStackPart1.size(); j++) |
| { |
| curStack[i].addElement(((DEROctetString)curStackPart1.getObjectAt(j)).getOctets()); |
| } |
| } |
| |
| // --- Decode <nextStack>. |
| ASN1Sequence nextStackPart0 = (ASN1Sequence)mtsPrivateKey.getObjectAt(9); |
| ASN1Sequence nextStackPart1; |
| |
| Vector[] nextStack = new Vector[nextStackPart0.size()]; |
| for (int i = 0; i < nextStack.length; i++) |
| { |
| nextStackPart1 = (ASN1Sequence)nextStackPart0.getObjectAt(i); |
| nextStack[i] = new Vector(); |
| for (int j = 0; j < nextStackPart1.size(); j++) |
| { |
| nextStack[i].addElement(((DEROctetString)nextStackPart1 |
| .getObjectAt(j)).getOctets()); |
| } |
| } |
| |
| // --- Decode <curRetain>. |
| ASN1Sequence curRetainPart0 = (ASN1Sequence)mtsPrivateKey.getObjectAt(10); |
| ASN1Sequence curRetainPart1; |
| ASN1Sequence curRetainPart2; |
| |
| Vector[][] curRetain = new Vector[curRetainPart0.size()][]; |
| for (int i = 0; i < curRetain.length; i++) |
| { |
| curRetainPart1 = (ASN1Sequence)curRetainPart0.getObjectAt(i); |
| curRetain[i] = new Vector[curRetainPart1.size()]; |
| for (int j = 0; j < curRetain[i].length; j++) |
| { |
| curRetainPart2 = (ASN1Sequence)curRetainPart1.getObjectAt(j); |
| curRetain[i][j] = new Vector(); |
| for (int k = 0; k < curRetainPart2.size(); k++) |
| { |
| curRetain[i][j] |
| .addElement(((DEROctetString)curRetainPart2 |
| .getObjectAt(k)).getOctets()); |
| } |
| } |
| } |
| |
| // --- Decode <nextRetain>. |
| ASN1Sequence nextRetainPart0 = (ASN1Sequence)mtsPrivateKey.getObjectAt(11); |
| ASN1Sequence nextRetainPart1; |
| ASN1Sequence nextRetainPart2; |
| |
| Vector[][] nextRetain = new Vector[nextRetainPart0.size()][]; |
| for (int i = 0; i < nextRetain.length; i++) |
| { |
| nextRetainPart1 = (ASN1Sequence)nextRetainPart0.getObjectAt(i); |
| nextRetain[i] = new Vector[nextRetainPart1.size()]; |
| for (int j = 0; j < nextRetain[i].length; j++) |
| { |
| nextRetainPart2 = (ASN1Sequence)nextRetainPart1.getObjectAt(j); |
| nextRetain[i][j] = new Vector(); |
| for (int k = 0; k < nextRetainPart2.size(); k++) |
| { |
| nextRetain[i][j] |
| .addElement(((DEROctetString)nextRetainPart2 |
| .getObjectAt(k)).getOctets()); |
| } |
| } |
| } |
| |
| // --- Decode <nextNextLeaf>. |
| ASN1Sequence seqOfLeafs = (ASN1Sequence)mtsPrivateKey.getObjectAt(12); |
| ASN1Sequence seqOfLeafStat; |
| ASN1Sequence seqOfLeafBytes; |
| ASN1Sequence seqOfLeafInts; |
| ASN1Sequence seqOfLeafString; |
| |
| GMSSLeaf[] nextNextLeaf = new GMSSLeaf[seqOfLeafs.size()]; |
| |
| for (int i = 0; i < nextNextLeaf.length; i++) |
| { |
| seqOfLeafStat = (ASN1Sequence)seqOfLeafs.getObjectAt(i); |
| // nextNextAuth[i]= new byte[nextNextAuthPart1.size()][]; |
| seqOfLeafString = (ASN1Sequence)seqOfLeafStat.getObjectAt(0); |
| seqOfLeafBytes = (ASN1Sequence)seqOfLeafStat.getObjectAt(1); |
| seqOfLeafInts = (ASN1Sequence)seqOfLeafStat.getObjectAt(2); |
| |
| String[] name = new String[2]; |
| name[0] = ((DERIA5String)seqOfLeafString.getObjectAt(0)).getString(); |
| name[1] = ((DERIA5String)seqOfLeafString.getObjectAt(1)).getString(); |
| byte[][] statByte = new byte[4][]; |
| statByte[0] = ((DEROctetString)seqOfLeafBytes.getObjectAt(0)) |
| .getOctets(); |
| statByte[1] = ((DEROctetString)seqOfLeafBytes.getObjectAt(1)) |
| .getOctets(); |
| statByte[2] = ((DEROctetString)seqOfLeafBytes.getObjectAt(2)) |
| .getOctets(); |
| statByte[3] = ((DEROctetString)seqOfLeafBytes.getObjectAt(3)) |
| .getOctets(); |
| int[] statInt = new int[4]; |
| statInt[0] = checkBigIntegerInIntRange(seqOfLeafInts.getObjectAt(0)); |
| statInt[1] = checkBigIntegerInIntRange(seqOfLeafInts.getObjectAt(1)); |
| statInt[2] = checkBigIntegerInIntRange(seqOfLeafInts.getObjectAt(2)); |
| statInt[3] = checkBigIntegerInIntRange(seqOfLeafInts.getObjectAt(3)); |
| nextNextLeaf[i] = new GMSSLeaf(DigestFactory.getDigest(name[0]).getClass(), statByte, statInt); |
| } |
| |
| // --- Decode <upperLeaf>. |
| ASN1Sequence seqOfUpperLeafs = (ASN1Sequence)mtsPrivateKey.getObjectAt(13); |
| ASN1Sequence seqOfUpperLeafStat; |
| ASN1Sequence seqOfUpperLeafBytes; |
| ASN1Sequence seqOfUpperLeafInts; |
| ASN1Sequence seqOfUpperLeafString; |
| |
| GMSSLeaf[] upperLeaf = new GMSSLeaf[seqOfUpperLeafs.size()]; |
| |
| for (int i = 0; i < upperLeaf.length; i++) |
| { |
| seqOfUpperLeafStat = (ASN1Sequence)seqOfUpperLeafs.getObjectAt(i); |
| seqOfUpperLeafString = (ASN1Sequence)seqOfUpperLeafStat.getObjectAt(0); |
| seqOfUpperLeafBytes = (ASN1Sequence)seqOfUpperLeafStat.getObjectAt(1); |
| seqOfUpperLeafInts = (ASN1Sequence)seqOfUpperLeafStat.getObjectAt(2); |
| |
| String[] name = new String[2]; |
| name[0] = ((DERIA5String)seqOfUpperLeafString.getObjectAt(0)).getString(); |
| name[1] = ((DERIA5String)seqOfUpperLeafString.getObjectAt(1)).getString(); |
| byte[][] statByte = new byte[4][]; |
| statByte[0] = ((DEROctetString)seqOfUpperLeafBytes.getObjectAt(0)) |
| .getOctets(); |
| statByte[1] = ((DEROctetString)seqOfUpperLeafBytes.getObjectAt(1)) |
| .getOctets(); |
| statByte[2] = ((DEROctetString)seqOfUpperLeafBytes.getObjectAt(2)) |
| .getOctets(); |
| statByte[3] = ((DEROctetString)seqOfUpperLeafBytes.getObjectAt(3)) |
| .getOctets(); |
| int[] statInt = new int[4]; |
| statInt[0] = checkBigIntegerInIntRange(seqOfUpperLeafInts.getObjectAt(0)); |
| statInt[1] = checkBigIntegerInIntRange(seqOfUpperLeafInts.getObjectAt(1)); |
| statInt[2] = checkBigIntegerInIntRange(seqOfUpperLeafInts.getObjectAt(2)); |
| statInt[3] = checkBigIntegerInIntRange(seqOfUpperLeafInts.getObjectAt(3)); |
| upperLeaf[i] = new GMSSLeaf(DigestFactory.getDigest(name[0]).getClass(), statByte, statInt); |
| } |
| |
| // --- Decode <upperTreehashLeaf>. |
| ASN1Sequence seqOfUpperTHLeafs = (ASN1Sequence)mtsPrivateKey.getObjectAt(14); |
| ASN1Sequence seqOfUpperTHLeafStat; |
| ASN1Sequence seqOfUpperTHLeafBytes; |
| ASN1Sequence seqOfUpperTHLeafInts; |
| ASN1Sequence seqOfUpperTHLeafString; |
| |
| GMSSLeaf[] upperTHLeaf = new GMSSLeaf[seqOfUpperTHLeafs.size()]; |
| |
| for (int i = 0; i < upperTHLeaf.length; i++) |
| { |
| seqOfUpperTHLeafStat = (ASN1Sequence)seqOfUpperTHLeafs.getObjectAt(i); |
| seqOfUpperTHLeafString = (ASN1Sequence)seqOfUpperTHLeafStat.getObjectAt(0); |
| seqOfUpperTHLeafBytes = (ASN1Sequence)seqOfUpperTHLeafStat.getObjectAt(1); |
| seqOfUpperTHLeafInts = (ASN1Sequence)seqOfUpperTHLeafStat.getObjectAt(2); |
| |
| String[] name = new String[2]; |
| name[0] = ((DERIA5String)seqOfUpperTHLeafString.getObjectAt(0)) |
| .getString(); |
| name[1] = ((DERIA5String)seqOfUpperTHLeafString.getObjectAt(1)) |
| .getString(); |
| byte[][] statByte = new byte[4][]; |
| statByte[0] = ((DEROctetString)seqOfUpperTHLeafBytes.getObjectAt(0)) |
| .getOctets(); |
| statByte[1] = ((DEROctetString)seqOfUpperTHLeafBytes.getObjectAt(1)) |
| .getOctets(); |
| statByte[2] = ((DEROctetString)seqOfUpperTHLeafBytes.getObjectAt(2)) |
| .getOctets(); |
| statByte[3] = ((DEROctetString)seqOfUpperTHLeafBytes.getObjectAt(3)) |
| .getOctets(); |
| int[] statInt = new int[4]; |
| statInt[0] = checkBigIntegerInIntRange(seqOfUpperTHLeafInts.getObjectAt(0)); |
| statInt[1] = checkBigIntegerInIntRange(seqOfUpperTHLeafInts.getObjectAt(1)); |
| statInt[2] = checkBigIntegerInIntRange(seqOfUpperTHLeafInts.getObjectAt(2)); |
| statInt[3] = checkBigIntegerInIntRange(seqOfUpperTHLeafInts.getObjectAt(3)); |
| upperTHLeaf[i] = new GMSSLeaf(DigestFactory.getDigest(name[0]).getClass(), statByte, statInt); |
| } |
| |
| // --- Decode <minTreehash>. |
| ASN1Sequence minTreehashPart = (ASN1Sequence)mtsPrivateKey.getObjectAt(15); |
| int[] minTreehash = new int[minTreehashPart.size()]; |
| for (int i = 0; i < minTreehashPart.size(); i++) |
| { |
| minTreehash[i] = checkBigIntegerInIntRange(minTreehashPart.getObjectAt(i)); |
| } |
| |
| // --- Decode <nextRoot>. |
| ASN1Sequence seqOfnextRoots = (ASN1Sequence)mtsPrivateKey.getObjectAt(16); |
| byte[][] nextRoot = new byte[seqOfnextRoots.size()][]; |
| for (int i = 0; i < nextRoot.length; i++) |
| { |
| nextRoot[i] = ((DEROctetString)seqOfnextRoots.getObjectAt(i)) |
| .getOctets(); |
| } |
| |
| // --- Decode <nextNextRoot>. |
| ASN1Sequence seqOfnextNextRoot = (ASN1Sequence)mtsPrivateKey.getObjectAt(17); |
| ASN1Sequence seqOfnextNextRootStat; |
| ASN1Sequence seqOfnextNextRootBytes; |
| ASN1Sequence seqOfnextNextRootInts; |
| ASN1Sequence seqOfnextNextRootString; |
| ASN1Sequence seqOfnextNextRootTreeH; |
| ASN1Sequence seqOfnextNextRootRetain; |
| |
| GMSSRootCalc[] nextNextRoot = new GMSSRootCalc[seqOfnextNextRoot.size()]; |
| |
| for (int i = 0; i < nextNextRoot.length; i++) |
| { |
| seqOfnextNextRootStat = (ASN1Sequence)seqOfnextNextRoot.getObjectAt(i); |
| seqOfnextNextRootString = (ASN1Sequence)seqOfnextNextRootStat |
| .getObjectAt(0); |
| seqOfnextNextRootBytes = (ASN1Sequence)seqOfnextNextRootStat |
| .getObjectAt(1); |
| seqOfnextNextRootInts = (ASN1Sequence)seqOfnextNextRootStat.getObjectAt(2); |
| seqOfnextNextRootTreeH = (ASN1Sequence)seqOfnextNextRootStat |
| .getObjectAt(3); |
| seqOfnextNextRootRetain = (ASN1Sequence)seqOfnextNextRootStat |
| .getObjectAt(4); |
| |
| // decode treehash of nextNextRoot |
| // --------------------------------- |
| ASN1Sequence seqOfnextNextRootTreeHStat; |
| ASN1Sequence seqOfnextNextRootTreeHBytes; |
| ASN1Sequence seqOfnextNextRootTreeHInts; |
| ASN1Sequence seqOfnextNextRootTreeHString; |
| |
| Treehash[] nnRTreehash = new Treehash[seqOfnextNextRootTreeH.size()]; |
| |
| for (int k = 0; k < nnRTreehash.length; k++) |
| { |
| seqOfnextNextRootTreeHStat = (ASN1Sequence)seqOfnextNextRootTreeH |
| .getObjectAt(k); |
| seqOfnextNextRootTreeHString = (ASN1Sequence)seqOfnextNextRootTreeHStat |
| .getObjectAt(0); |
| seqOfnextNextRootTreeHBytes = (ASN1Sequence)seqOfnextNextRootTreeHStat |
| .getObjectAt(1); |
| seqOfnextNextRootTreeHInts = (ASN1Sequence)seqOfnextNextRootTreeHStat |
| .getObjectAt(2); |
| |
| String[] name = new String[2]; |
| name[0] = ((DERIA5String)seqOfnextNextRootTreeHString.getObjectAt(0)) |
| .getString(); |
| name[1] = ((DERIA5String)seqOfnextNextRootTreeHString.getObjectAt(1)) |
| .getString(); |
| |
| int tailLength = checkBigIntegerInIntRange(seqOfnextNextRootTreeHInts.getObjectAt(1)); |
| |
| byte[][] statByte = new byte[3 + tailLength][]; |
| statByte[0] = ((DEROctetString)seqOfnextNextRootTreeHBytes |
| .getObjectAt(0)).getOctets(); |
| if (statByte[0].length == 0) |
| { // if null was encoded |
| statByte[0] = null; |
| } |
| |
| statByte[1] = ((DEROctetString)seqOfnextNextRootTreeHBytes |
| .getObjectAt(1)).getOctets(); |
| statByte[2] = ((DEROctetString)seqOfnextNextRootTreeHBytes |
| .getObjectAt(2)).getOctets(); |
| for (int j = 0; j < tailLength; j++) |
| { |
| statByte[3 + j] = ((DEROctetString)seqOfnextNextRootTreeHBytes |
| .getObjectAt(3 + j)).getOctets(); |
| } |
| int[] statInt = new int[6 + tailLength]; |
| statInt[0] = checkBigIntegerInIntRange(seqOfnextNextRootTreeHInts.getObjectAt(0)); |
| |
| statInt[1] = tailLength; |
| statInt[2] = checkBigIntegerInIntRange(seqOfnextNextRootTreeHInts.getObjectAt(2)); |
| |
| statInt[3] = checkBigIntegerInIntRange(seqOfnextNextRootTreeHInts.getObjectAt(3)); |
| |
| statInt[4] = checkBigIntegerInIntRange(seqOfnextNextRootTreeHInts.getObjectAt(4)); |
| |
| statInt[5] = checkBigIntegerInIntRange(seqOfnextNextRootTreeHInts.getObjectAt(5)); |
| |
| for (int j = 0; j < tailLength; j++) |
| { |
| statInt[6 + j] = checkBigIntegerInIntRange(seqOfnextNextRootTreeHInts |
| .getObjectAt(6 + j)); |
| } |
| nnRTreehash[k] = new Treehash(DigestFactory.getDigest(name[0]).getClass(), statByte, statInt); |
| } |
| // --------------------------------- |
| |
| // decode retain of nextNextRoot |
| // --------------------------------- |
| // ASN1Sequence seqOfnextNextRootRetainPart0 = |
| // (ASN1Sequence)seqOfnextNextRootRetain.get(0); |
| ASN1Sequence seqOfnextNextRootRetainPart1; |
| |
| Vector[] nnRRetain = new Vector[seqOfnextNextRootRetain.size()]; |
| for (int j = 0; j < nnRRetain.length; j++) |
| { |
| seqOfnextNextRootRetainPart1 = (ASN1Sequence)seqOfnextNextRootRetain |
| .getObjectAt(j); |
| nnRRetain[j] = new Vector(); |
| for (int k = 0; k < seqOfnextNextRootRetainPart1.size(); k++) |
| { |
| nnRRetain[j] |
| .addElement(((DEROctetString)seqOfnextNextRootRetainPart1 |
| .getObjectAt(k)).getOctets()); |
| } |
| } |
| // --------------------------------- |
| |
| String[] name = new String[2]; |
| name[0] = ((DERIA5String)seqOfnextNextRootString.getObjectAt(0)) |
| .getString(); |
| name[1] = ((DERIA5String)seqOfnextNextRootString.getObjectAt(1)) |
| .getString(); |
| |
| int heightOfTree = checkBigIntegerInIntRange(seqOfnextNextRootInts.getObjectAt(0)); |
| int tailLength = checkBigIntegerInIntRange(seqOfnextNextRootInts.getObjectAt(7)); |
| byte[][] statByte = new byte[1 + heightOfTree + tailLength][]; |
| statByte[0] = ((DEROctetString)seqOfnextNextRootBytes.getObjectAt(0)) |
| .getOctets(); |
| for (int j = 0; j < heightOfTree; j++) |
| { |
| statByte[1 + j] = ((DEROctetString)seqOfnextNextRootBytes |
| .getObjectAt(1 + j)).getOctets(); |
| } |
| for (int j = 0; j < tailLength; j++) |
| { |
| statByte[1 + heightOfTree + j] = ((DEROctetString)seqOfnextNextRootBytes |
| .getObjectAt(1 + heightOfTree + j)).getOctets(); |
| } |
| int[] statInt = new int[8 + heightOfTree + tailLength]; |
| statInt[0] = heightOfTree; |
| statInt[1] = checkBigIntegerInIntRange(seqOfnextNextRootInts.getObjectAt(1)); |
| statInt[2] = checkBigIntegerInIntRange(seqOfnextNextRootInts.getObjectAt(2)); |
| statInt[3] = checkBigIntegerInIntRange(seqOfnextNextRootInts.getObjectAt(3)); |
| statInt[4] = checkBigIntegerInIntRange(seqOfnextNextRootInts.getObjectAt(4)); |
| statInt[5] = checkBigIntegerInIntRange(seqOfnextNextRootInts.getObjectAt(5)); |
| statInt[6] = checkBigIntegerInIntRange(seqOfnextNextRootInts.getObjectAt(6)); |
| statInt[7] = tailLength; |
| for (int j = 0; j < heightOfTree; j++) |
| { |
| statInt[8 + j] = checkBigIntegerInIntRange(seqOfnextNextRootInts.getObjectAt(8 + j)); |
| } |
| for (int j = 0; j < tailLength; j++) |
| { |
| statInt[8 + heightOfTree + j] = checkBigIntegerInIntRange(seqOfnextNextRootInts.getObjectAt(8 |
| + heightOfTree + j)); |
| } |
| nextNextRoot[i] = new GMSSRootCalc(DigestFactory.getDigest(name[0]).getClass(), statByte, statInt, |
| nnRTreehash, nnRRetain); |
| } |
| |
| // --- Decode <curRootSig>. |
| ASN1Sequence seqOfcurRootSig = (ASN1Sequence)mtsPrivateKey.getObjectAt(18); |
| byte[][] curRootSig = new byte[seqOfcurRootSig.size()][]; |
| for (int i = 0; i < curRootSig.length; i++) |
| { |
| curRootSig[i] = ((DEROctetString)seqOfcurRootSig.getObjectAt(i)) |
| .getOctets(); |
| } |
| |
| // --- Decode <nextRootSig>. |
| ASN1Sequence seqOfnextRootSigs = (ASN1Sequence)mtsPrivateKey.getObjectAt(19); |
| ASN1Sequence seqOfnRSStats; |
| ASN1Sequence seqOfnRSStrings; |
| ASN1Sequence seqOfnRSInts; |
| ASN1Sequence seqOfnRSBytes; |
| |
| GMSSRootSig[] nextRootSig = new GMSSRootSig[seqOfnextRootSigs.size()]; |
| |
| for (int i = 0; i < nextRootSig.length; i++) |
| { |
| seqOfnRSStats = (ASN1Sequence)seqOfnextRootSigs.getObjectAt(i); |
| // nextNextAuth[i]= new byte[nextNextAuthPart1.size()][]; |
| seqOfnRSStrings = (ASN1Sequence)seqOfnRSStats.getObjectAt(0); |
| seqOfnRSBytes = (ASN1Sequence)seqOfnRSStats.getObjectAt(1); |
| seqOfnRSInts = (ASN1Sequence)seqOfnRSStats.getObjectAt(2); |
| |
| String[] name = new String[2]; |
| name[0] = ((DERIA5String)seqOfnRSStrings.getObjectAt(0)).getString(); |
| name[1] = ((DERIA5String)seqOfnRSStrings.getObjectAt(1)).getString(); |
| byte[][] statByte = new byte[5][]; |
| statByte[0] = ((DEROctetString)seqOfnRSBytes.getObjectAt(0)) |
| .getOctets(); |
| statByte[1] = ((DEROctetString)seqOfnRSBytes.getObjectAt(1)) |
| .getOctets(); |
| statByte[2] = ((DEROctetString)seqOfnRSBytes.getObjectAt(2)) |
| .getOctets(); |
| statByte[3] = ((DEROctetString)seqOfnRSBytes.getObjectAt(3)) |
| .getOctets(); |
| statByte[4] = ((DEROctetString)seqOfnRSBytes.getObjectAt(4)) |
| .getOctets(); |
| int[] statInt = new int[9]; |
| statInt[0] = checkBigIntegerInIntRange(seqOfnRSInts.getObjectAt(0)); |
| statInt[1] = checkBigIntegerInIntRange(seqOfnRSInts.getObjectAt(1)); |
| statInt[2] = checkBigIntegerInIntRange(seqOfnRSInts.getObjectAt(2)); |
| statInt[3] = checkBigIntegerInIntRange(seqOfnRSInts.getObjectAt(3)); |
| statInt[4] = checkBigIntegerInIntRange(seqOfnRSInts.getObjectAt(4)); |
| statInt[5] = checkBigIntegerInIntRange(seqOfnRSInts.getObjectAt(5)); |
| statInt[6] = checkBigIntegerInIntRange(seqOfnRSInts.getObjectAt(6)); |
| statInt[7] = checkBigIntegerInIntRange(seqOfnRSInts.getObjectAt(7)); |
| statInt[8] = checkBigIntegerInIntRange(seqOfnRSInts.getObjectAt(8)); |
| nextRootSig[i] = new GMSSRootSig(DigestFactory.getDigest(name[0]).getClass(), statByte, statInt); |
| } |
| |
| // --- Decode <name>. |
| |
| // TODO: Really check, why there are multiple algorithms, we only |
| // use the first one!!! |
| ASN1Sequence namePart = (ASN1Sequence)mtsPrivateKey.getObjectAt(20); |
| String[] name = new String[namePart.size()]; |
| for (int i = 0; i < name.length; i++) |
| { |
| name[i] = ((DERIA5String)namePart.getObjectAt(i)).getString(); |
| } |
| */ |
| } |
| |
| 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); |
| } |
| |
| |
| // TODO: change method signature to something more integrated into BouncyCastle |
| |
| /** |
| * @param index tree indices |
| * @param currentSeeds seed for the generation of private OTS keys for the |
| * current subtrees (TREE) |
| * @param nextNextSeeds seed for the generation of private OTS keys for the |
| * subtrees after next (TREE++) |
| * @param currentAuthPaths array of current authentication paths (AUTHPATH) |
| * @param nextAuthPaths 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 |
| * @param algorithms An array of algorithm identifiers, containing the hash function details |
| */ |
| private ASN1Primitive encode(int[] index, byte[][] currentSeeds, |
| byte[][] nextNextSeeds, byte[][][] currentAuthPaths, |
| byte[][][] nextAuthPaths, byte[][][] keep, |
| Treehash[][] currentTreehash, Treehash[][] nextTreehash, |
| Vector[] currentStack, Vector[] nextStack, |
| Vector[][] currentRetain, Vector[][] nextRetain, |
| GMSSLeaf[] nextNextLeaf, GMSSLeaf[] upperLeaf, |
| GMSSLeaf[] upperTreehashLeaf, int[] minTreehash, byte[][] nextRoot, |
| GMSSRootCalc[] nextNextRoot, byte[][] currentRootSig, |
| GMSSRootSig[] nextRootSig, GMSSParameters gmssParameterset, |
| AlgorithmIdentifier[] algorithms) |
| { |
| |
| ASN1EncodableVector result = new ASN1EncodableVector(); |
| |
| // --- Encode <index>. |
| ASN1EncodableVector indexPart = new ASN1EncodableVector(); |
| for (int i = 0; i < index.length; i++) |
| { |
| indexPart.add(new ASN1Integer(index[i])); |
| } |
| result.add(new DERSequence(indexPart)); |
| |
| // --- Encode <curSeeds>. |
| ASN1EncodableVector curSeedsPart = new ASN1EncodableVector(); |
| for (int i = 0; i < currentSeeds.length; i++) |
| { |
| curSeedsPart.add(new DEROctetString(currentSeeds[i])); |
| } |
| result.add(new DERSequence(curSeedsPart)); |
| |
| // --- Encode <nextNextSeeds>. |
| ASN1EncodableVector nextNextSeedsPart = new ASN1EncodableVector(); |
| for (int i = 0; i < nextNextSeeds.length; i++) |
| { |
| nextNextSeedsPart.add(new DEROctetString(nextNextSeeds[i])); |
| } |
| result.add(new DERSequence(nextNextSeedsPart)); |
| |
| // --- Encode <curAuth>. |
| ASN1EncodableVector curAuthPart0 = new ASN1EncodableVector(); |
| ASN1EncodableVector curAuthPart1 = new ASN1EncodableVector(); |
| for (int i = 0; i < currentAuthPaths.length; i++) |
| { |
| for (int j = 0; j < currentAuthPaths[i].length; j++) |
| { |
| curAuthPart0.add(new DEROctetString(currentAuthPaths[i][j])); |
| } |
| curAuthPart1.add(new DERSequence(curAuthPart0)); |
| curAuthPart0 = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(curAuthPart1)); |
| |
| // --- Encode <nextAuth>. |
| ASN1EncodableVector nextAuthPart0 = new ASN1EncodableVector(); |
| ASN1EncodableVector nextAuthPart1 = new ASN1EncodableVector(); |
| for (int i = 0; i < nextAuthPaths.length; i++) |
| { |
| for (int j = 0; j < nextAuthPaths[i].length; j++) |
| { |
| nextAuthPart0.add(new DEROctetString(nextAuthPaths[i][j])); |
| } |
| nextAuthPart1.add(new DERSequence(nextAuthPart0)); |
| nextAuthPart0 = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(nextAuthPart1)); |
| |
| // --- Encode <curTreehash>. |
| ASN1EncodableVector seqOfTreehash0 = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfTreehash1 = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfStat = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfByte = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfInt = new ASN1EncodableVector(); |
| |
| for (int i = 0; i < currentTreehash.length; i++) |
| { |
| for (int j = 0; j < currentTreehash[i].length; j++) |
| { |
| seqOfStat.add(new DERSequence(algorithms[0])); |
| |
| int tailLength = currentTreehash[i][j].getStatInt()[1]; |
| |
| seqOfByte.add(new DEROctetString(currentTreehash[i][j] |
| .getStatByte()[0])); |
| seqOfByte.add(new DEROctetString(currentTreehash[i][j] |
| .getStatByte()[1])); |
| seqOfByte.add(new DEROctetString(currentTreehash[i][j] |
| .getStatByte()[2])); |
| for (int k = 0; k < tailLength; k++) |
| { |
| seqOfByte.add(new DEROctetString(currentTreehash[i][j] |
| .getStatByte()[3 + k])); |
| } |
| seqOfStat.add(new DERSequence(seqOfByte)); |
| seqOfByte = new ASN1EncodableVector(); |
| |
| seqOfInt.add(new ASN1Integer( |
| currentTreehash[i][j].getStatInt()[0])); |
| seqOfInt.add(new ASN1Integer(tailLength)); |
| seqOfInt.add(new ASN1Integer( |
| currentTreehash[i][j].getStatInt()[2])); |
| seqOfInt.add(new ASN1Integer( |
| currentTreehash[i][j].getStatInt()[3])); |
| seqOfInt.add(new ASN1Integer( |
| currentTreehash[i][j].getStatInt()[4])); |
| seqOfInt.add(new ASN1Integer( |
| currentTreehash[i][j].getStatInt()[5])); |
| for (int k = 0; k < tailLength; k++) |
| { |
| seqOfInt.add(new ASN1Integer(currentTreehash[i][j] |
| .getStatInt()[6 + k])); |
| } |
| seqOfStat.add(new DERSequence(seqOfInt)); |
| seqOfInt = new ASN1EncodableVector(); |
| |
| seqOfTreehash1.add(new DERSequence(seqOfStat)); |
| seqOfStat = new ASN1EncodableVector(); |
| } |
| seqOfTreehash0.add(new DERSequence(seqOfTreehash1)); |
| seqOfTreehash1 = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(seqOfTreehash0)); |
| |
| // --- Encode <nextTreehash>. |
| seqOfTreehash0 = new ASN1EncodableVector(); |
| seqOfTreehash1 = new ASN1EncodableVector(); |
| seqOfStat = new ASN1EncodableVector(); |
| seqOfByte = new ASN1EncodableVector(); |
| seqOfInt = new ASN1EncodableVector(); |
| |
| for (int i = 0; i < nextTreehash.length; i++) |
| { |
| for (int j = 0; j < nextTreehash[i].length; j++) |
| { |
| seqOfStat.add(new DERSequence(algorithms[0])); |
| |
| int tailLength = nextTreehash[i][j].getStatInt()[1]; |
| |
| seqOfByte.add(new DEROctetString(nextTreehash[i][j] |
| .getStatByte()[0])); |
| seqOfByte.add(new DEROctetString(nextTreehash[i][j] |
| .getStatByte()[1])); |
| seqOfByte.add(new DEROctetString(nextTreehash[i][j] |
| .getStatByte()[2])); |
| for (int k = 0; k < tailLength; k++) |
| { |
| seqOfByte.add(new DEROctetString(nextTreehash[i][j] |
| .getStatByte()[3 + k])); |
| } |
| seqOfStat.add(new DERSequence(seqOfByte)); |
| seqOfByte = new ASN1EncodableVector(); |
| |
| seqOfInt |
| .add(new ASN1Integer(nextTreehash[i][j].getStatInt()[0])); |
| seqOfInt.add(new ASN1Integer(tailLength)); |
| seqOfInt |
| .add(new ASN1Integer(nextTreehash[i][j].getStatInt()[2])); |
| seqOfInt |
| .add(new ASN1Integer(nextTreehash[i][j].getStatInt()[3])); |
| seqOfInt |
| .add(new ASN1Integer(nextTreehash[i][j].getStatInt()[4])); |
| seqOfInt |
| .add(new ASN1Integer(nextTreehash[i][j].getStatInt()[5])); |
| for (int k = 0; k < tailLength; k++) |
| { |
| seqOfInt.add(new ASN1Integer(nextTreehash[i][j] |
| .getStatInt()[6 + k])); |
| } |
| seqOfStat.add(new DERSequence(seqOfInt)); |
| seqOfInt = new ASN1EncodableVector(); |
| |
| seqOfTreehash1.add(new DERSequence(seqOfStat)); |
| seqOfStat = new ASN1EncodableVector(); |
| } |
| seqOfTreehash0.add(new DERSequence(new DERSequence(seqOfTreehash1))); |
| seqOfTreehash1 = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(seqOfTreehash0)); |
| |
| // --- Encode <keep>. |
| ASN1EncodableVector keepPart0 = new ASN1EncodableVector(); |
| ASN1EncodableVector keepPart1 = new ASN1EncodableVector(); |
| for (int i = 0; i < keep.length; i++) |
| { |
| for (int j = 0; j < keep[i].length; j++) |
| { |
| keepPart0.add(new DEROctetString(keep[i][j])); |
| } |
| keepPart1.add(new DERSequence(keepPart0)); |
| keepPart0 = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(keepPart1)); |
| |
| // --- Encode <curStack>. |
| ASN1EncodableVector curStackPart0 = new ASN1EncodableVector(); |
| ASN1EncodableVector curStackPart1 = new ASN1EncodableVector(); |
| for (int i = 0; i < currentStack.length; i++) |
| { |
| for (int j = 0; j < currentStack[i].size(); j++) |
| { |
| curStackPart0.add(new DEROctetString((byte[])currentStack[i] |
| .elementAt(j))); |
| } |
| curStackPart1.add(new DERSequence(curStackPart0)); |
| curStackPart0 = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(curStackPart1)); |
| |
| // --- Encode <nextStack>. |
| ASN1EncodableVector nextStackPart0 = new ASN1EncodableVector(); |
| ASN1EncodableVector nextStackPart1 = new ASN1EncodableVector(); |
| for (int i = 0; i < nextStack.length; i++) |
| { |
| for (int j = 0; j < nextStack[i].size(); j++) |
| { |
| nextStackPart0.add(new DEROctetString((byte[])nextStack[i] |
| .elementAt(j))); |
| } |
| nextStackPart1.add(new DERSequence(nextStackPart0)); |
| nextStackPart0 = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(nextStackPart1)); |
| |
| // --- Encode <curRetain>. |
| ASN1EncodableVector currentRetainPart0 = new ASN1EncodableVector(); |
| ASN1EncodableVector currentRetainPart1 = new ASN1EncodableVector(); |
| ASN1EncodableVector currentRetainPart2 = new ASN1EncodableVector(); |
| for (int i = 0; i < currentRetain.length; i++) |
| { |
| for (int j = 0; j < currentRetain[i].length; j++) |
| { |
| for (int k = 0; k < currentRetain[i][j].size(); k++) |
| { |
| currentRetainPart0.add(new DEROctetString( |
| (byte[])currentRetain[i][j].elementAt(k))); |
| } |
| currentRetainPart1.add(new DERSequence(currentRetainPart0)); |
| currentRetainPart0 = new ASN1EncodableVector(); |
| } |
| currentRetainPart2.add(new DERSequence(currentRetainPart1)); |
| currentRetainPart1 = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(currentRetainPart2)); |
| |
| // --- Encode <nextRetain>. |
| ASN1EncodableVector nextRetainPart0 = new ASN1EncodableVector(); |
| ASN1EncodableVector nextRetainPart1 = new ASN1EncodableVector(); |
| ASN1EncodableVector nextRetainPart2 = new ASN1EncodableVector(); |
| for (int i = 0; i < nextRetain.length; i++) |
| { |
| for (int j = 0; j < nextRetain[i].length; j++) |
| { |
| for (int k = 0; k < nextRetain[i][j].size(); k++) |
| { |
| nextRetainPart0.add(new DEROctetString( |
| (byte[])nextRetain[i][j].elementAt(k))); |
| } |
| nextRetainPart1.add(new DERSequence(nextRetainPart0)); |
| nextRetainPart0 = new ASN1EncodableVector(); |
| } |
| nextRetainPart2.add(new DERSequence(nextRetainPart1)); |
| nextRetainPart1 = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(nextRetainPart2)); |
| |
| // --- Encode <nextNextLeaf>. |
| ASN1EncodableVector seqOfLeaf = new ASN1EncodableVector(); |
| seqOfStat = new ASN1EncodableVector(); |
| seqOfByte = new ASN1EncodableVector(); |
| seqOfInt = new ASN1EncodableVector(); |
| |
| for (int i = 0; i < nextNextLeaf.length; i++) |
| { |
| seqOfStat.add(new DERSequence(algorithms[0])); |
| |
| byte[][] tempByte = nextNextLeaf[i].getStatByte(); |
| seqOfByte.add(new DEROctetString(tempByte[0])); |
| seqOfByte.add(new DEROctetString(tempByte[1])); |
| seqOfByte.add(new DEROctetString(tempByte[2])); |
| seqOfByte.add(new DEROctetString(tempByte[3])); |
| seqOfStat.add(new DERSequence(seqOfByte)); |
| seqOfByte = new ASN1EncodableVector(); |
| |
| int[] tempInt = nextNextLeaf[i].getStatInt(); |
| seqOfInt.add(new ASN1Integer(tempInt[0])); |
| seqOfInt.add(new ASN1Integer(tempInt[1])); |
| seqOfInt.add(new ASN1Integer(tempInt[2])); |
| seqOfInt.add(new ASN1Integer(tempInt[3])); |
| seqOfStat.add(new DERSequence(seqOfInt)); |
| seqOfInt = new ASN1EncodableVector(); |
| |
| seqOfLeaf.add(new DERSequence(seqOfStat)); |
| seqOfStat = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(seqOfLeaf)); |
| |
| // --- Encode <upperLEAF>. |
| ASN1EncodableVector seqOfUpperLeaf = new ASN1EncodableVector(); |
| seqOfStat = new ASN1EncodableVector(); |
| seqOfByte = new ASN1EncodableVector(); |
| seqOfInt = new ASN1EncodableVector(); |
| |
| for (int i = 0; i < upperLeaf.length; i++) |
| { |
| seqOfStat.add(new DERSequence(algorithms[0])); |
| |
| byte[][] tempByte = upperLeaf[i].getStatByte(); |
| seqOfByte.add(new DEROctetString(tempByte[0])); |
| seqOfByte.add(new DEROctetString(tempByte[1])); |
| seqOfByte.add(new DEROctetString(tempByte[2])); |
| seqOfByte.add(new DEROctetString(tempByte[3])); |
| seqOfStat.add(new DERSequence(seqOfByte)); |
| seqOfByte = new ASN1EncodableVector(); |
| |
| int[] tempInt = upperLeaf[i].getStatInt(); |
| seqOfInt.add(new ASN1Integer(tempInt[0])); |
| seqOfInt.add(new ASN1Integer(tempInt[1])); |
| seqOfInt.add(new ASN1Integer(tempInt[2])); |
| seqOfInt.add(new ASN1Integer(tempInt[3])); |
| seqOfStat.add(new DERSequence(seqOfInt)); |
| seqOfInt = new ASN1EncodableVector(); |
| |
| seqOfUpperLeaf.add(new DERSequence(seqOfStat)); |
| seqOfStat = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(seqOfUpperLeaf)); |
| |
| // encode <upperTreehashLeaf> |
| ASN1EncodableVector seqOfUpperTreehashLeaf = new ASN1EncodableVector(); |
| seqOfStat = new ASN1EncodableVector(); |
| seqOfByte = new ASN1EncodableVector(); |
| seqOfInt = new ASN1EncodableVector(); |
| |
| for (int i = 0; i < upperTreehashLeaf.length; i++) |
| { |
| seqOfStat.add(new DERSequence(algorithms[0])); |
| |
| byte[][] tempByte = upperTreehashLeaf[i].getStatByte(); |
| seqOfByte.add(new DEROctetString(tempByte[0])); |
| seqOfByte.add(new DEROctetString(tempByte[1])); |
| seqOfByte.add(new DEROctetString(tempByte[2])); |
| seqOfByte.add(new DEROctetString(tempByte[3])); |
| seqOfStat.add(new DERSequence(seqOfByte)); |
| seqOfByte = new ASN1EncodableVector(); |
| |
| int[] tempInt = upperTreehashLeaf[i].getStatInt(); |
| seqOfInt.add(new ASN1Integer(tempInt[0])); |
| seqOfInt.add(new ASN1Integer(tempInt[1])); |
| seqOfInt.add(new ASN1Integer(tempInt[2])); |
| seqOfInt.add(new ASN1Integer(tempInt[3])); |
| seqOfStat.add(new DERSequence(seqOfInt)); |
| seqOfInt = new ASN1EncodableVector(); |
| |
| seqOfUpperTreehashLeaf.add(new DERSequence(seqOfStat)); |
| seqOfStat = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(seqOfUpperTreehashLeaf)); |
| |
| // --- Encode <minTreehash>. |
| ASN1EncodableVector minTreehashPart = new ASN1EncodableVector(); |
| for (int i = 0; i < minTreehash.length; i++) |
| { |
| minTreehashPart.add(new ASN1Integer(minTreehash[i])); |
| } |
| result.add(new DERSequence(minTreehashPart)); |
| |
| // --- Encode <nextRoot>. |
| ASN1EncodableVector nextRootPart = new ASN1EncodableVector(); |
| for (int i = 0; i < nextRoot.length; i++) |
| { |
| nextRootPart.add(new DEROctetString(nextRoot[i])); |
| } |
| result.add(new DERSequence(nextRootPart)); |
| |
| // --- Encode <nextNextRoot>. |
| ASN1EncodableVector seqOfnextNextRoot = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfnnRStats = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfnnRStrings = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfnnRBytes = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfnnRInts = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfnnRTreehash = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfnnRRetain = new ASN1EncodableVector(); |
| |
| for (int i = 0; i < nextNextRoot.length; i++) |
| { |
| seqOfnnRStats.add(new DERSequence(algorithms[0])); |
| seqOfnnRStrings = new ASN1EncodableVector(); |
| |
| int heightOfTree = nextNextRoot[i].getStatInt()[0]; |
| int tailLength = nextNextRoot[i].getStatInt()[7]; |
| |
| seqOfnnRBytes.add(new DEROctetString( |
| nextNextRoot[i].getStatByte()[0])); |
| for (int j = 0; j < heightOfTree; j++) |
| { |
| seqOfnnRBytes.add(new DEROctetString(nextNextRoot[i] |
| .getStatByte()[1 + j])); |
| } |
| for (int j = 0; j < tailLength; j++) |
| { |
| seqOfnnRBytes.add(new DEROctetString(nextNextRoot[i] |
| .getStatByte()[1 + heightOfTree + j])); |
| } |
| |
| seqOfnnRStats.add(new DERSequence(seqOfnnRBytes)); |
| seqOfnnRBytes = new ASN1EncodableVector(); |
| |
| seqOfnnRInts.add(new ASN1Integer(heightOfTree)); |
| seqOfnnRInts.add(new ASN1Integer(nextNextRoot[i].getStatInt()[1])); |
| seqOfnnRInts.add(new ASN1Integer(nextNextRoot[i].getStatInt()[2])); |
| seqOfnnRInts.add(new ASN1Integer(nextNextRoot[i].getStatInt()[3])); |
| seqOfnnRInts.add(new ASN1Integer(nextNextRoot[i].getStatInt()[4])); |
| seqOfnnRInts.add(new ASN1Integer(nextNextRoot[i].getStatInt()[5])); |
| seqOfnnRInts.add(new ASN1Integer(nextNextRoot[i].getStatInt()[6])); |
| seqOfnnRInts.add(new ASN1Integer(tailLength)); |
| for (int j = 0; j < heightOfTree; j++) |
| { |
| seqOfnnRInts.add(new ASN1Integer( |
| nextNextRoot[i].getStatInt()[8 + j])); |
| } |
| for (int j = 0; j < tailLength; j++) |
| { |
| seqOfnnRInts.add(new ASN1Integer(nextNextRoot[i].getStatInt()[8 |
| + heightOfTree + j])); |
| } |
| |
| seqOfnnRStats.add(new DERSequence(seqOfnnRInts)); |
| seqOfnnRInts = new ASN1EncodableVector(); |
| |
| // add treehash of nextNextRoot object |
| // ---------------------------- |
| seqOfStat = new ASN1EncodableVector(); |
| seqOfByte = new ASN1EncodableVector(); |
| seqOfInt = new ASN1EncodableVector(); |
| |
| if (nextNextRoot[i].getTreehash() != null) |
| { |
| for (int j = 0; j < nextNextRoot[i].getTreehash().length; j++) |
| { |
| seqOfStat.add(new DERSequence(algorithms[0])); |
| |
| tailLength = nextNextRoot[i].getTreehash()[j].getStatInt()[1]; |
| |
| seqOfByte.add(new DEROctetString(nextNextRoot[i] |
| .getTreehash()[j].getStatByte()[0])); |
| seqOfByte.add(new DEROctetString(nextNextRoot[i] |
| .getTreehash()[j].getStatByte()[1])); |
| seqOfByte.add(new DEROctetString(nextNextRoot[i] |
| .getTreehash()[j].getStatByte()[2])); |
| for (int k = 0; k < tailLength; k++) |
| { |
| seqOfByte.add(new DEROctetString(nextNextRoot[i] |
| .getTreehash()[j].getStatByte()[3 + k])); |
| } |
| seqOfStat.add(new DERSequence(seqOfByte)); |
| seqOfByte = new ASN1EncodableVector(); |
| |
| seqOfInt.add(new ASN1Integer( |
| nextNextRoot[i].getTreehash()[j].getStatInt()[0])); |
| seqOfInt.add(new ASN1Integer(tailLength)); |
| seqOfInt.add(new ASN1Integer( |
| nextNextRoot[i].getTreehash()[j].getStatInt()[2])); |
| seqOfInt.add(new ASN1Integer( |
| nextNextRoot[i].getTreehash()[j].getStatInt()[3])); |
| seqOfInt.add(new ASN1Integer( |
| nextNextRoot[i].getTreehash()[j].getStatInt()[4])); |
| seqOfInt.add(new ASN1Integer( |
| nextNextRoot[i].getTreehash()[j].getStatInt()[5])); |
| for (int k = 0; k < tailLength; k++) |
| { |
| seqOfInt.add(new ASN1Integer(nextNextRoot[i] |
| .getTreehash()[j].getStatInt()[6 + k])); |
| } |
| seqOfStat.add(new DERSequence(seqOfInt)); |
| seqOfInt = new ASN1EncodableVector(); |
| |
| seqOfnnRTreehash.add(new DERSequence(seqOfStat)); |
| seqOfStat = new ASN1EncodableVector(); |
| } |
| } |
| // ---------------------------- |
| seqOfnnRStats.add(new DERSequence(seqOfnnRTreehash)); |
| seqOfnnRTreehash = new ASN1EncodableVector(); |
| |
| // encode retain of nextNextRoot |
| // ---------------------------- |
| // --- Encode <curRetain>. |
| currentRetainPart0 = new ASN1EncodableVector(); |
| if (nextNextRoot[i].getRetain() != null) |
| { |
| for (int j = 0; j < nextNextRoot[i].getRetain().length; j++) |
| { |
| for (int k = 0; k < nextNextRoot[i].getRetain()[j].size(); k++) |
| { |
| currentRetainPart0.add(new DEROctetString( |
| (byte[])nextNextRoot[i].getRetain()[j] |
| .elementAt(k))); |
| } |
| seqOfnnRRetain.add(new DERSequence(currentRetainPart0)); |
| currentRetainPart0 = new ASN1EncodableVector(); |
| } |
| } |
| // ---------------------------- |
| seqOfnnRStats.add(new DERSequence(seqOfnnRRetain)); |
| seqOfnnRRetain = new ASN1EncodableVector(); |
| |
| seqOfnextNextRoot.add(new DERSequence(seqOfnnRStats)); |
| seqOfnnRStats = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(seqOfnextNextRoot)); |
| |
| // --- Encode <curRootSig>. |
| ASN1EncodableVector curRootSigPart = new ASN1EncodableVector(); |
| for (int i = 0; i < currentRootSig.length; i++) |
| { |
| curRootSigPart.add(new DEROctetString(currentRootSig[i])); |
| } |
| result.add(new DERSequence(curRootSigPart)); |
| |
| // --- Encode <nextRootSig>. |
| ASN1EncodableVector seqOfnextRootSigs = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfnRSStats = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfnRSStrings = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfnRSBytes = new ASN1EncodableVector(); |
| ASN1EncodableVector seqOfnRSInts = new ASN1EncodableVector(); |
| |
| for (int i = 0; i < nextRootSig.length; i++) |
| { |
| seqOfnRSStats.add(new DERSequence(algorithms[0])); |
| seqOfnRSStrings = new ASN1EncodableVector(); |
| |
| seqOfnRSBytes.add(new DEROctetString( |
| nextRootSig[i].getStatByte()[0])); |
| seqOfnRSBytes.add(new DEROctetString( |
| nextRootSig[i].getStatByte()[1])); |
| seqOfnRSBytes.add(new DEROctetString( |
| nextRootSig[i].getStatByte()[2])); |
| seqOfnRSBytes.add(new DEROctetString( |
| nextRootSig[i].getStatByte()[3])); |
| seqOfnRSBytes.add(new DEROctetString( |
| nextRootSig[i].getStatByte()[4])); |
| |
| seqOfnRSStats.add(new DERSequence(seqOfnRSBytes)); |
| seqOfnRSBytes = new ASN1EncodableVector(); |
| |
| seqOfnRSInts.add(new ASN1Integer(nextRootSig[i].getStatInt()[0])); |
| seqOfnRSInts.add(new ASN1Integer(nextRootSig[i].getStatInt()[1])); |
| seqOfnRSInts.add(new ASN1Integer(nextRootSig[i].getStatInt()[2])); |
| seqOfnRSInts.add(new ASN1Integer(nextRootSig[i].getStatInt()[3])); |
| seqOfnRSInts.add(new ASN1Integer(nextRootSig[i].getStatInt()[4])); |
| seqOfnRSInts.add(new ASN1Integer(nextRootSig[i].getStatInt()[5])); |
| seqOfnRSInts.add(new ASN1Integer(nextRootSig[i].getStatInt()[6])); |
| seqOfnRSInts.add(new ASN1Integer(nextRootSig[i].getStatInt()[7])); |
| seqOfnRSInts.add(new ASN1Integer(nextRootSig[i].getStatInt()[8])); |
| |
| seqOfnRSStats.add(new DERSequence(seqOfnRSInts)); |
| seqOfnRSInts = new ASN1EncodableVector(); |
| |
| seqOfnextRootSigs.add(new DERSequence(seqOfnRSStats)); |
| seqOfnRSStats = new ASN1EncodableVector(); |
| } |
| result.add(new DERSequence(seqOfnextRootSigs)); |
| |
| // --- Encode <parameterset>. |
| ASN1EncodableVector parSetPart0 = new ASN1EncodableVector(); |
| ASN1EncodableVector parSetPart1 = new ASN1EncodableVector(); |
| ASN1EncodableVector parSetPart2 = new ASN1EncodableVector(); |
| ASN1EncodableVector parSetPart3 = new ASN1EncodableVector(); |
| |
| for (int i = 0; i < gmssParameterset.getHeightOfTrees().length; i++) |
| { |
| parSetPart1.add(new ASN1Integer( |
| gmssParameterset.getHeightOfTrees()[i])); |
| parSetPart2.add(new ASN1Integer(gmssParameterset |
| .getWinternitzParameter()[i])); |
| parSetPart3.add(new ASN1Integer(gmssParameterset.getK()[i])); |
| } |
| parSetPart0.add(new ASN1Integer(gmssParameterset.getNumOfLayers())); |
| parSetPart0.add(new DERSequence(parSetPart1)); |
| parSetPart0.add(new DERSequence(parSetPart2)); |
| parSetPart0.add(new DERSequence(parSetPart3)); |
| result.add(new DERSequence(parSetPart0)); |
| |
| // --- Encode <names>. |
| ASN1EncodableVector namesPart = new ASN1EncodableVector(); |
| |
| for (int i = 0; i < algorithms.length; i++) |
| { |
| namesPart.add(algorithms[i]); |
| } |
| |
| result.add(new DERSequence(namesPart)); |
| return new DERSequence(result); |
| |
| } |
| |
| private static int checkBigIntegerInIntRange(ASN1Encodable a) |
| { |
| BigInteger b = ((ASN1Integer)a).getValue(); |
| if ((b.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0) || |
| (b.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) < 0)) |
| { |
| throw new IllegalArgumentException("BigInteger not in Range: " + b.toString()); |
| } |
| return b.intValue(); |
| } |
| |
| |
| public ASN1Primitive toASN1Primitive() |
| { |
| return this.primitive; |
| } |
| } |
