Home | History | Annotate | Download | only in x509
      1 package org.bouncycastle.asn1.x509;
      2 
      3 import org.bouncycastle.asn1.ASN1Encodable;
      4 import org.bouncycastle.asn1.ASN1EncodableVector;
      5 import org.bouncycastle.asn1.ASN1Sequence;
      6 import org.bouncycastle.asn1.ASN1TaggedObject;
      7 import org.bouncycastle.asn1.DERBoolean;
      8 import org.bouncycastle.asn1.DERObject;
      9 import org.bouncycastle.asn1.DERSequence;
     10 import org.bouncycastle.asn1.DERTaggedObject;
     11 
     12 /**
     13  * <pre>
     14  * IssuingDistributionPoint ::= SEQUENCE {
     15  *   distributionPoint          [0] DistributionPointName OPTIONAL,
     16  *   onlyContainsUserCerts      [1] BOOLEAN DEFAULT FALSE,
     17  *   onlyContainsCACerts        [2] BOOLEAN DEFAULT FALSE,
     18  *   onlySomeReasons            [3] ReasonFlags OPTIONAL,
     19  *   indirectCRL                [4] BOOLEAN DEFAULT FALSE,
     20  *   onlyContainsAttributeCerts [5] BOOLEAN DEFAULT FALSE }
     21  * </pre>
     22  */
     23 public class IssuingDistributionPoint
     24     extends ASN1Encodable
     25 {
     26     private DistributionPointName distributionPoint;
     27 
     28     private boolean onlyContainsUserCerts;
     29 
     30     private boolean onlyContainsCACerts;
     31 
     32     private ReasonFlags onlySomeReasons;
     33 
     34     private boolean indirectCRL;
     35 
     36     private boolean onlyContainsAttributeCerts;
     37 
     38     private ASN1Sequence seq;
     39 
     40     public static IssuingDistributionPoint getInstance(
     41         ASN1TaggedObject obj,
     42         boolean explicit)
     43     {
     44         return getInstance(ASN1Sequence.getInstance(obj, explicit));
     45     }
     46 
     47     public static IssuingDistributionPoint getInstance(
     48         Object obj)
     49     {
     50         if (obj == null || obj instanceof IssuingDistributionPoint)
     51         {
     52             return (IssuingDistributionPoint)obj;
     53         }
     54         else if (obj instanceof ASN1Sequence)
     55         {
     56             return new IssuingDistributionPoint((ASN1Sequence)obj);
     57         }
     58 
     59         throw new IllegalArgumentException("unknown object in factory: " + obj.getClass().getName());
     60     }
     61 
     62     /**
     63      * Constructor from given details.
     64      *
     65      * @param distributionPoint
     66      *            May contain an URI as pointer to most current CRL.
     67      * @param onlyContainsUserCerts Covers revocation information for end certificates.
     68      * @param onlyContainsCACerts Covers revocation information for CA certificates.
     69      *
     70      * @param onlySomeReasons
     71      *            Which revocation reasons does this point cover.
     72      * @param indirectCRL
     73      *            If <code>true</code> then the CRL contains revocation
     74      *            information about certificates ssued by other CAs.
     75      * @param onlyContainsAttributeCerts Covers revocation information for attribute certificates.
     76      */
     77     public IssuingDistributionPoint(
     78         DistributionPointName distributionPoint,
     79         boolean onlyContainsUserCerts,
     80         boolean onlyContainsCACerts,
     81         ReasonFlags onlySomeReasons,
     82         boolean indirectCRL,
     83         boolean onlyContainsAttributeCerts)
     84     {
     85         this.distributionPoint = distributionPoint;
     86         this.indirectCRL = indirectCRL;
     87         this.onlyContainsAttributeCerts = onlyContainsAttributeCerts;
     88         this.onlyContainsCACerts = onlyContainsCACerts;
     89         this.onlyContainsUserCerts = onlyContainsUserCerts;
     90         this.onlySomeReasons = onlySomeReasons;
     91 
     92         ASN1EncodableVector vec = new ASN1EncodableVector();
     93         if (distributionPoint != null)
     94         {                                    // CHOICE item so explicitly tagged
     95             vec.add(new DERTaggedObject(true, 0, distributionPoint));
     96         }
     97         if (onlyContainsUserCerts)
     98         {
     99             // BEGIN android-changed
    100             vec.add(new DERTaggedObject(false, 1, DERBoolean.TRUE));
    101             // END android-changed
    102         }
    103         if (onlyContainsCACerts)
    104         {
    105             // BEGIN android-changed
    106             vec.add(new DERTaggedObject(false, 2, DERBoolean.TRUE));
    107             // END android-changed
    108         }
    109         if (onlySomeReasons != null)
    110         {
    111             vec.add(new DERTaggedObject(false, 3, onlySomeReasons));
    112         }
    113         if (indirectCRL)
    114         {
    115             // BEGIN android-changed
    116             vec.add(new DERTaggedObject(false, 4, DERBoolean.TRUE));
    117             // END android-changed
    118         }
    119         if (onlyContainsAttributeCerts)
    120         {
    121             // BEGIN android-changed
    122             vec.add(new DERTaggedObject(false, 5, DERBoolean.TRUE));
    123             // END android-changed
    124         }
    125 
    126         seq = new DERSequence(vec);
    127     }
    128 
    129     /**
    130      * Constructor from ASN1Sequence
    131      */
    132     public IssuingDistributionPoint(
    133         ASN1Sequence seq)
    134     {
    135         this.seq = seq;
    136 
    137         for (int i = 0; i != seq.size(); i++)
    138         {
    139             ASN1TaggedObject o = ASN1TaggedObject.getInstance(seq.getObjectAt(i));
    140 
    141             switch (o.getTagNo())
    142             {
    143             case 0:
    144                                                     // CHOICE so explicit
    145                 distributionPoint = DistributionPointName.getInstance(o, true);
    146                 break;
    147             case 1:
    148                 onlyContainsUserCerts = DERBoolean.getInstance(o, false).isTrue();
    149                 break;
    150             case 2:
    151                 onlyContainsCACerts = DERBoolean.getInstance(o, false).isTrue();
    152                 break;
    153             case 3:
    154                 onlySomeReasons = new ReasonFlags(ReasonFlags.getInstance(o, false));
    155                 break;
    156             case 4:
    157                 indirectCRL = DERBoolean.getInstance(o, false).isTrue();
    158                 break;
    159             case 5:
    160                 onlyContainsAttributeCerts = DERBoolean.getInstance(o, false).isTrue();
    161                 break;
    162             default:
    163                 throw new IllegalArgumentException(
    164                         "unknown tag in IssuingDistributionPoint");
    165             }
    166         }
    167     }
    168 
    169     public boolean onlyContainsUserCerts()
    170     {
    171         return onlyContainsUserCerts;
    172     }
    173 
    174     public boolean onlyContainsCACerts()
    175     {
    176         return onlyContainsCACerts;
    177     }
    178 
    179     public boolean isIndirectCRL()
    180     {
    181         return indirectCRL;
    182     }
    183 
    184     public boolean onlyContainsAttributeCerts()
    185     {
    186         return onlyContainsAttributeCerts;
    187     }
    188 
    189     /**
    190      * @return Returns the distributionPoint.
    191      */
    192     public DistributionPointName getDistributionPoint()
    193     {
    194         return distributionPoint;
    195     }
    196 
    197     /**
    198      * @return Returns the onlySomeReasons.
    199      */
    200     public ReasonFlags getOnlySomeReasons()
    201     {
    202         return onlySomeReasons;
    203     }
    204 
    205     public DERObject toASN1Object()
    206     {
    207         return seq;
    208     }
    209 
    210     public String toString()
    211     {
    212         String       sep = System.getProperty("line.separator");
    213         StringBuffer buf = new StringBuffer();
    214 
    215         buf.append("IssuingDistributionPoint: [");
    216         buf.append(sep);
    217         if (distributionPoint != null)
    218         {
    219             appendObject(buf, sep, "distributionPoint", distributionPoint.toString());
    220         }
    221         if (onlyContainsUserCerts)
    222         {
    223             appendObject(buf, sep, "onlyContainsUserCerts", booleanToString(onlyContainsUserCerts));
    224         }
    225         if (onlyContainsCACerts)
    226         {
    227             appendObject(buf, sep, "onlyContainsCACerts", booleanToString(onlyContainsCACerts));
    228         }
    229         if (onlySomeReasons != null)
    230         {
    231             appendObject(buf, sep, "onlySomeReasons", onlySomeReasons.toString());
    232         }
    233         if (onlyContainsAttributeCerts)
    234         {
    235             appendObject(buf, sep, "onlyContainsAttributeCerts", booleanToString(onlyContainsAttributeCerts));
    236         }
    237         if (indirectCRL)
    238         {
    239             appendObject(buf, sep, "indirectCRL", booleanToString(indirectCRL));
    240         }
    241         buf.append("]");
    242         buf.append(sep);
    243         return buf.toString();
    244     }
    245 
    246     private void appendObject(StringBuffer buf, String sep, String name, String value)
    247     {
    248         String       indent = "    ";
    249 
    250         buf.append(indent);
    251         buf.append(name);
    252         buf.append(":");
    253         buf.append(sep);
    254         buf.append(indent);
    255         buf.append(indent);
    256         buf.append(value);
    257         buf.append(sep);
    258     }
    259 
    260     private String booleanToString(boolean value)
    261     {
    262         return value ? "true" : "false";
    263     }
    264 }
    265