Information

1
Story Points

Technologies

Decompiled Java File
package iaik.x509.extensions;

import iaik.asn1.ASN;
import iaik.asn1.ASN1Object;
import iaik.asn1.ASN1Type;
import iaik.asn1.BIT_STRING;
import iaik.asn1.BOOLEAN;
import iaik.asn1.CON_SPEC;
import iaik.asn1.CodingException;
import iaik.asn1.ObjectID;
import iaik.asn1.SEQUENCE;
import iaik.asn1.structures.GeneralNames;
import iaik.asn1.structures.RDN;
import iaik.utils.InternalErrorException;
import iaik.x509.V3Extension;
import iaik.x509.X509ExtensionException;

public class IssuingDistributionPoint extends V3Extension {
   private boolean f = false;
   private boolean e = false;
   private int a = -1;
   private boolean c = false;
   private boolean b = false;
   private ASN1Type d;
   public static final ObjectID oid = new ObjectID("2.5.29.28", "IssuingDistributionPoint");

   public String toString() {
      StringBuffer var1 = new StringBuffer();
      if(this.d != null) {
         var1.append("DistributionPoint: ");
         var1.append(this.d.toString() + "\n");
      }

      var1.append("onlyContainsUserCerts: " + this.b + "\n");
      var1.append("onlyContainsCaCerts: " + this.c + "\n");
      if(this.a > 0) {
         var1.append("reasonFlags: ");
         if((this.a & 1) > 0) {
            var1.append("unused | ");
         }

         if((this.a & 2) > 0) {
            var1.append("keyCompromise | ");
         }

         if((this.a & 4) > 0) {
            var1.append("cACompromise | ");
         }

         if((this.a & 8) > 0) {
            var1.append("affiliationChanged|");
         }

         if((this.a & 16) > 0) {
            var1.append("superseded | ");
         }

         if((this.a & 32) > 0) {
            var1.append("cessationOfOperation | ");
         }

         if((this.a & 64) > 0) {
            var1.append("certificateHold | ");
         }

         var1.setLength(var1.length() - 3);
         var1.append("\n");
      }

      var1.append("indirectCRL: " + this.e + "\n");
      var1.append("onlyContainsAttributeCerts: " + this.f + "\n");
      var1.setLength(var1.length() - 1);
      return var1.toString();
   }

   public ASN1Object toASN1Object() throws X509ExtensionException {
      if(this.b && this.c) {
         throw new X509ExtensionException("OnlyContainsUserCerts and OnlyContainsCaCerts are not allowed both to be true!");
      } else {
         boolean var1 = true;
         SEQUENCE var2 = new SEQUENCE();

         try {
            if(this.d != null) {
               boolean var3 = true;
               byte var6;
               if(this.d instanceof GeneralNames) {
                  var6 = 0;
               } else {
                  if(!(this.d instanceof RDN)) {
                     throw new InternalErrorException("DistributionPointName: Unknown type [create]!");
                  }

                  var6 = 1;
               }

               CON_SPEC var4 = new CON_SPEC(var6, this.d.toASN1Object(), var1);
               var2.addComponent(new CON_SPEC(0, var4));
            }

            if(this.b) {
               var2.addComponent(new CON_SPEC(1, new BOOLEAN(this.b), var1));
            }

            if(this.c) {
               var2.addComponent(new CON_SPEC(2, new BOOLEAN(this.c), var1));
            }

            if(this.a != -1) {
               StringBuffer var7 = new StringBuffer(Integer.toBinaryString(this.a));
               var7.reverse();
               var2.addComponent(new CON_SPEC(3, new BIT_STRING(var7.toString()), var1));
            }

            if(this.e) {
               var2.addComponent(new CON_SPEC(4, new BOOLEAN(this.e), var1));
            }

            if(this.f) {
               var2.addComponent(new CON_SPEC(5, new BOOLEAN(this.f), var1));
            }

            return var2;
         } catch (CodingException var5) {
            throw new X509ExtensionException(var5.getMessage());
         }
      }
   }

   public void setReasonFlags(int var1) {
      this.a = var1;
   }

   public void setOnlyContainsUserCerts(boolean var1) {
      this.b = var1;
   }

   public void setOnlyContainsCaCerts(boolean var1) {
      this.c = var1;
   }

   public void setOnlyContainsAttributeCerts(boolean var1) {
      this.f = var1;
   }

   public void setIndirectCRL(boolean var1) {
      this.e = var1;
   }

   public void setDistributionPointName(ASN1Type var1) throws IllegalArgumentException {
      if(!(var1 instanceof GeneralNames) && !(var1 instanceof RDN)) {
         throw new IllegalArgumentException("Only instances of GeneralNames or RDN are accepted!");
      } else {
         this.d = var1;
      }
   }

   public void init(ASN1Object var1) throws X509ExtensionException {
      if(!var1.isA(ASN.SEQUENCE)) {
         throw new X509ExtensionException("No DistributionPoint!");
      } else {
         try {
            for(int var2 = 0; var2 < var1.countComponents(); ++var2) {
               CON_SPEC var3 = (CON_SPEC)var1.getComponentAt(var2);
               int var4 = var3.getAsnType().getTag();
               switch(var4) {
               case 0:
                  CON_SPEC var5 = (CON_SPEC)var3.getValue();
                  int var6 = var5.getAsnType().getTag();
                  if(var6 == 0) {
                     var5.forceImplicitlyTagged(ASN.SEQUENCE);
                     this.d = new GeneralNames((ASN1Object)var5.getValue());
                  } else {
                     if(var6 != 1) {
                        throw new CodingException("DistributionPointName: Unknown type [parse]!");
                     }

                     var5.forceImplicitlyTagged(ASN.SET);
                     this.d = new RDN((ASN1Object)var5.getValue());
                  }
                  break;
               case 1:
                  var3.forceImplicitlyTagged(ASN.BOOLEAN);
                  BOOLEAN var7 = (BOOLEAN)var3.getValue();
                  this.b = ((Boolean)var7.getValue()).booleanValue();
                  break;
               case 2:
                  var3.forceImplicitlyTagged(ASN.BOOLEAN);
                  BOOLEAN var8 = (BOOLEAN)var3.getValue();
                  this.c = ((Boolean)var8.getValue()).booleanValue();
                  break;
               case 3:
                  var3.forceImplicitlyTagged(ASN.BIT_STRING);
                  BIT_STRING var9 = (BIT_STRING)var3.getValue();
                  StringBuffer var10 = (new StringBuffer(var9.getBinaryString())).reverse();
                  this.a = Integer.parseInt(var10.toString(), 2);
                  break;
               case 4:
                  var3.forceImplicitlyTagged(ASN.BOOLEAN);
                  BOOLEAN var11 = (BOOLEAN)var3.getValue();
                  this.e = ((Boolean)var11.getValue()).booleanValue();
                  break;
               case 5:
                  var3.forceImplicitlyTagged(ASN.BOOLEAN);
                  BOOLEAN var12 = (BOOLEAN)var3.getValue();
                  this.f = ((Boolean)var12.getValue()).booleanValue();
                  break;
               default:
                  throw new CodingException("Invalid issuingDistributionPoint: unsupported tag number: " + var4);
               }
            }

            if(this.b && this.c) {
               throw new X509ExtensionException("OnlyContainsUserCerts and OnlyContainsCaCerts are not allowed both to be true!");
            }
         } catch (Exception var13) {
            throw new X509ExtensionException(var13.getMessage());
         }
      }
   }

   public int hashCode() {
      return oid.hashCode();
   }

   public int getReasonFlags() {
      return this.a;
   }

   public boolean getOnlyContainsUserCerts() {
      return this.b;
   }

   public boolean getOnlyContainsCaCerts() {
      return this.c;
   }

   public boolean getOnlyContainsAttributeCerts() {
      return this.f;
   }

   public ObjectID getObjectID() {
      return oid;
   }

   public boolean getIndirectCRL() {
      return this.e;
   }

   public ASN1Type getDistributionPointName() {
      return this.d;
   }
}
Page generated: Oct 19, 2017 2:34:25 PM