001package org.apache.commons.ssl.org.bouncycastle.asn1.icao;
002
003import java.util.Enumeration;
004
005import org.apache.commons.ssl.org.bouncycastle.asn1.ASN1EncodableVector;
006import org.apache.commons.ssl.org.bouncycastle.asn1.ASN1Integer;
007import org.apache.commons.ssl.org.bouncycastle.asn1.ASN1Object;
008import org.apache.commons.ssl.org.bouncycastle.asn1.ASN1Primitive;
009import org.apache.commons.ssl.org.bouncycastle.asn1.ASN1Sequence;
010import org.apache.commons.ssl.org.bouncycastle.asn1.DERSequence;
011import org.apache.commons.ssl.org.bouncycastle.asn1.x509.AlgorithmIdentifier;
012
013/**
014 * The LDSSecurityObject object (V1.8).
015 * <pre>
016 * LDSSecurityObject ::= SEQUENCE {
017 *   version                LDSSecurityObjectVersion,
018 *   hashAlgorithm          DigestAlgorithmIdentifier,
019 *   dataGroupHashValues    SEQUENCE SIZE (2..ub-DataGroups) OF DataHashGroup,
020 *   ldsVersionInfo         LDSVersionInfo OPTIONAL
021 *   -- if present, version MUST be v1 }
022 *   
023 * DigestAlgorithmIdentifier ::= AlgorithmIdentifier,
024 * 
025 * LDSSecurityObjectVersion :: INTEGER {V0(0)}
026 * </pre>
027 */
028
029public class LDSSecurityObject 
030    extends ASN1Object
031    implements ICAOObjectIdentifiers    
032{
033    public static final int ub_DataGroups = 16;
034    
035    private ASN1Integer version = new ASN1Integer(0);
036    private AlgorithmIdentifier digestAlgorithmIdentifier;
037    private DataGroupHash[] datagroupHash;
038    private LDSVersionInfo versionInfo;
039
040    public static LDSSecurityObject getInstance(
041        Object obj)
042    {
043        if (obj instanceof LDSSecurityObject)
044        {
045            return (LDSSecurityObject)obj;
046        }
047        else if (obj != null)
048        {
049            return new LDSSecurityObject(ASN1Sequence.getInstance(obj));            
050        }
051        
052        return null;
053    }    
054    
055    private LDSSecurityObject(
056        ASN1Sequence seq)
057    {
058        if (seq == null || seq.size() == 0)
059        {
060            throw new IllegalArgumentException("null or empty sequence passed.");
061        }
062        
063        Enumeration e = seq.getObjects();
064
065        // version
066        version = ASN1Integer.getInstance(e.nextElement());
067        // digestAlgorithmIdentifier
068        digestAlgorithmIdentifier = AlgorithmIdentifier.getInstance(e.nextElement());
069      
070        ASN1Sequence datagroupHashSeq = ASN1Sequence.getInstance(e.nextElement());
071
072        if (version.getValue().intValue() == 1)
073        {
074            versionInfo = LDSVersionInfo.getInstance(e.nextElement());
075        }
076
077        checkDatagroupHashSeqSize(datagroupHashSeq.size());        
078        
079        datagroupHash = new DataGroupHash[datagroupHashSeq.size()];
080        for (int i= 0; i< datagroupHashSeq.size();i++)
081        {
082            datagroupHash[i] = DataGroupHash.getInstance(datagroupHashSeq.getObjectAt(i));
083        }
084    }
085
086    public LDSSecurityObject(
087        AlgorithmIdentifier digestAlgorithmIdentifier, 
088        DataGroupHash[]       datagroupHash)
089    {
090        this.version = new ASN1Integer(0);
091        this.digestAlgorithmIdentifier = digestAlgorithmIdentifier;
092        this.datagroupHash = datagroupHash;
093        
094        checkDatagroupHashSeqSize(datagroupHash.length);                      
095    }    
096
097    public LDSSecurityObject(
098        AlgorithmIdentifier digestAlgorithmIdentifier,
099        DataGroupHash[]     datagroupHash,
100        LDSVersionInfo      versionInfo)
101    {
102        this.version = new ASN1Integer(1);
103        this.digestAlgorithmIdentifier = digestAlgorithmIdentifier;
104        this.datagroupHash = datagroupHash;
105        this.versionInfo = versionInfo;
106
107        checkDatagroupHashSeqSize(datagroupHash.length);
108    }
109
110    private void checkDatagroupHashSeqSize(int size)
111    {
112        if ((size < 2) || (size > ub_DataGroups))
113        {
114               throw new IllegalArgumentException("wrong size in DataGroupHashValues : not in (2.."+ ub_DataGroups +")");
115        }
116    }  
117
118    public int getVersion()
119    {
120        return version.getValue().intValue();
121    }
122
123    public AlgorithmIdentifier getDigestAlgorithmIdentifier()
124    {
125        return digestAlgorithmIdentifier;
126    }
127    
128    public DataGroupHash[] getDatagroupHash()
129    {
130        return datagroupHash;
131    }
132
133    public LDSVersionInfo getVersionInfo()
134    {
135        return versionInfo;
136    }
137
138    public ASN1Primitive toASN1Primitive()
139    {
140        ASN1EncodableVector seq = new ASN1EncodableVector();
141        
142        seq.add(version);
143        seq.add(digestAlgorithmIdentifier);
144                
145        ASN1EncodableVector seqname = new ASN1EncodableVector();
146        for (int i = 0; i < datagroupHash.length; i++) 
147        {
148            seqname.add(datagroupHash[i]);
149        }            
150        seq.add(new DERSequence(seqname));                   
151
152        if (versionInfo != null)
153        {
154            seq.add(versionInfo);
155        }
156
157        return new DERSequence(seq);
158    }
159}