Information

0
Story Points

Technologies

Decompiled Java File
package iaik.pkcs.pkcs7;

import iaik.asn1.ASN;
import iaik.asn1.ASN1Object;
import iaik.asn1.ASN1Type;
import iaik.asn1.CON_SPEC;
import iaik.asn1.CodingException;
import iaik.asn1.DerCoder;
import iaik.asn1.EncodeListener;
import iaik.asn1.INTEGER;
import iaik.asn1.OCTET_STRING;
import iaik.asn1.ObjectID;
import iaik.asn1.SEQUENCE;
import iaik.asn1.structures.AlgorithmID;
import iaik.asn1.structures.Attribute;
import iaik.pkcs.pkcs7.Content;
import iaik.pkcs.pkcs7.DigestInfo;
import iaik.pkcs.pkcs7.IssuerAndSerialNumber;
import iaik.pkcs.pkcs7.SignedAndEnvelopedData;
import iaik.pkcs.pkcs7.SignedAndEnvelopedDataStream;
import iaik.pkcs.pkcs7.d;
import iaik.utils.Util;
import java.math.BigInteger;
import java.security.GeneralSecurityException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.SignatureException;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;

public class SignerInfo implements EncodeListener, ASN1Type {
   // $FF: synthetic field
   static Class j;
   PrivateKey c;
   Attribute[] b;
   byte[] e;
   AlgorithmID g;
   Attribute[] i;
   AlgorithmID h;
   IssuerAndSerialNumber d;
   int a = 1;
   d f;

   static Class a(String var0) {
      try {
         return Class.forName(var0);
      } catch (ClassNotFoundException var2) {
         throw new NoClassDefFoundError(var2.getMessage());
      }
   }

   public String toString(boolean var1) {
      StringBuffer var2 = new StringBuffer();
      var2.append("Version: " + this.a + "\n");
      var2.append(this.d);
      var2.append("digest_algorithm: " + this.h + "\n");
      var2.append("digest_encryption_algorithm: " + this.g + "\n");
      if(this.e != null) {
         var2.append("encrypted_digest: " + this.e.length + " Bytes [" + Util.toString(this.e, 0, 5) + "...]\n");
      } else {
         var2.append("encrypted_digest: yet not set\n");
      }

      int var3;
      if(this.i != null) {
         var2.append("authenticated_attributes:\n");

         for(var3 = 0; var3 < this.i.length; ++var3) {
            var2.append(this.i[var3].toString());
         }
      }

      if(this.b != null) {
         var2.append("unauthenticated_attributes:\n");

         for(var3 = 0; var3 < this.b.length; ++var3) {
            var2.append(this.b[var3].toString());
         }
      }

      return var2.toString();
   }

   public String toString() {
      return this.toString(false);
   }

   public ASN1Object toASN1Object() throws CodingException {
      SEQUENCE var1 = new SEQUENCE();

      try {
         var1.addComponent(new INTEGER(this.a));
         var1.addComponent(this.d.toASN1Object());
         var1.addComponent(this.h.toASN1Object());
         OCTET_STRING var2;
         if(this.i != null && this.i.length > 0) {
            var2 = new OCTET_STRING();
            int var3 = this.i.length;
            boolean var4 = false;

            for(int var5 = 0; var5 < var3; ++var5) {
               if(this.i[var5].getType().equals(ObjectID.messageDigest)) {
                  var4 = true;
                  break;
               }
            }

            if(!var4) {
               if(this.f instanceof Content) {
                  this.encodeCalled(var2, 1);
               } else {
                  var2.addEncodeListener(this, 1);
               }

               this.i = (Attribute[])Util.resizeArray(this.i, var3 + 1);
               this.i[var3] = new Attribute(ObjectID.messageDigest, new ASN1Object[]{var2});
            }

            ASN1Object var6;
            if(this.a == 2) {
               var6 = ASN.createSequenceOf(this.i);
               var1.addComponent(new CON_SPEC(2, var6, false));
            } else {
               var6 = ASN.createSetOf(this.i, true);
               var1.addComponent(new CON_SPEC(0, var6, true));
            }
         }

         var1.addComponent(this.g.toASN1Object());
         var2 = new OCTET_STRING();
         if(this.f instanceof Content) {
            this.encodeCalled(var2, 2);
         } else {
            var2.addEncodeListener(this, 2);
         }

         var1.addComponent(var2);
         if(this.b != null) {
            ASN1Object var8;
            if(this.a == 2) {
               var8 = ASN.createSequenceOf(this.b);
               var1.addComponent(new CON_SPEC(3, var8, true));
            } else {
               var8 = ASN.createSetOf(this.b);
               var1.addComponent(new CON_SPEC(1, var8, true));
            }
         }

         return var1;
      } catch (Exception var7) {
         throw new CodingException(var7.toString());
      }
   }

   public void setUnauthenticatedAttributes(Attribute[] var1) {
      this.b = var1;
   }

   public void setEncryptedDigest(byte[] var1) {
      this.e = var1;
   }

   public void setAuthenticatedAttributes(Attribute[] var1) {
      this.i = var1;
   }

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

   public Attribute[] getUnauthenticatedAttributes() {
      return this.b;
   }

   public Attribute getUnauthenticatedAttribute(ObjectID var1) {
      if(this.b == null) {
         return null;
      } else {
         for(int var2 = 0; var2 < this.b.length; ++var2) {
            if(this.b[var2].getType().equals(var1)) {
               return this.b[var2];
            }
         }

         return null;
      }
   }

   public IssuerAndSerialNumber getIssuerAndSerialNumber() {
      return this.d;
   }

   public byte[] getEncryptedDigest() {
      return this.e;
   }

   public AlgorithmID getDigestEncryptionAlgorithm() {
      return this.g;
   }

   public AlgorithmID getDigestAlgorithm() {
      return this.h;
   }

   public byte[] getDigest(PublicKey var1) throws InvalidKeyException, SignatureException {
      try {
         Cipher var2 = Cipher.getInstance("RSA/ECB/PKCS1Padding");
         var2.init(2, var1);
         DigestInfo var3 = new DigestInfo(DerCoder.decode(var2.doFinal(this.e)));
         if(!this.h.equals(var3.getDigestAlgorithm())) {
            throw new SignatureException("Digest algorithm mismatch!");
         } else {
            return var3.getDigest();
         }
      } catch (NoSuchAlgorithmException var4) {
         throw new SignatureException(var4.toString());
      } catch (GeneralSecurityException var5) {
         throw new SignatureException(var5.toString());
      } catch (CodingException var6) {
         throw new SignatureException(var6.toString());
      }
   }

   public Attribute[] getAuthenticatedAttributes() {
      return this.i;
   }

   public Attribute getAuthenticatedAttribute(ObjectID var1) {
      if(this.i == null) {
         return null;
      } else {
         for(int var2 = 0; var2 < this.i.length; ++var2) {
            if(this.i[var2].getType().equals(var1)) {
               return this.i[var2];
            }
         }

         return null;
      }
   }

   public void encodeCalled(ASN1Object var1, int var2) throws CodingException {
      try {
         switch(var2) {
         case 1:
            var1.setValue(this.f.getMessageDigest(this.h));
            return;
         case 2:
            if(this.e == null) {
               byte[] var3;
               if(this.i == null) {
                  var3 = this.f.getMessageDigest(this.h);
               } else {
                  MessageDigest var4 = MessageDigest.getInstance(this.h.getName());
                  if(this.a == 2) {
                     var3 = var4.digest(DerCoder.encode(ASN.createSequenceOf(this.i)));
                  } else {
                     var3 = var4.digest(DerCoder.encode(ASN.createSetOf(this.i, true)));
                  }
               }

               DigestInfo var11 = new DigestInfo(this.h, var3);
               Cipher var5 = Cipher.getInstance("RSA/ECB/PKCS1Padding");
               var5.init(1, this.c);
               this.e = var5.doFinal(var11.toByteArray());
               if(this.f instanceof SignedAndEnvelopedData || this.f instanceof SignedAndEnvelopedDataStream) {
                  AlgorithmID var6 = null;
                  IvParameterSpec var8;
                  Cipher var9;
                  if(this.f instanceof SignedAndEnvelopedData) {
                     SignedAndEnvelopedData var7 = (SignedAndEnvelopedData)this.f;
                     var6 = var7.c.getContentEncryptionAlgorithm();
                     var8 = new IvParameterSpec((byte[])var6.getParameter().getValue());
                     var9 = var6.getCipherInstance();
                     var9.init(1, var7.a, var8, (SecureRandom)null);
                     this.e = var9.doFinal(this.e);
                  } else {
                     SignedAndEnvelopedDataStream var12 = (SignedAndEnvelopedDataStream)this.f;
                     var6 = var12.c.getContentEncryptionAlgorithm();
                     var8 = new IvParameterSpec((byte[])var6.getParameter().getValue());
                     var9 = var6.getCipherInstance();
                     var9.init(1, var12.a, var8, (SecureRandom)null);
                     this.e = var9.doFinal(this.e);
                  }
               }
            }

            var1.setValue(this.e);
            return;
         default:
         }
      } catch (Exception var10) {
         throw new CodingException("Unable to encrypt digest: " + var10.getMessage());
      }
   }

   public void decode(ASN1Object var1) throws CodingException {
      try {
         ASN1Object var2 = null;
         int var3 = 0;
         this.a = ((BigInteger)var1.getComponentAt(0).getValue()).intValue();
         this.d = new IssuerAndSerialNumber(var1.getComponentAt(1));
         this.h = new AlgorithmID(var1.getComponentAt(2));
         var2 = var1.getComponentAt(3);
         if(var2.isA(ASN.CON_SPEC)) {
            if(this.a != 2) {
               ((CON_SPEC)var2).forceImplicitlyTagged(ASN.SEQUENCE);
            }

            this.i = (Attribute[])ASN.parseSequenceOf((ASN1Object)var2.getValue(), j != null?j:(j = a("iaik.asn1.structures.Attribute")));
            ++var3;
         }

         this.g = new AlgorithmID(var1.getComponentAt(3 + var3));
         this.e = (byte[])var1.getComponentAt(4 + var3).getValue();
         if(5 + var3 < var1.countComponents()) {
            CON_SPEC var4 = (CON_SPEC)var1.getComponentAt(5 + var3);
            var4.forceImplicitlyTagged(ASN.SEQUENCE);
            this.b = (Attribute[])ASN.parseSequenceOf((ASN1Object)var4.getValue(), j != null?j:(j = a("iaik.asn1.structures.Attribute")));
         }
      } catch (Exception var5) {
         throw new CodingException(var5.toString());
      }
   }

   public SignerInfo(IssuerAndSerialNumber var1, AlgorithmID var2, PrivateKey var3) {
      this.h = AlgorithmID.sha;
      this.g = AlgorithmID.rsaEncryption;
      this.d = var1;
      this.h = var2;
      this.c = var3;
   }

   public SignerInfo(IssuerAndSerialNumber var1, AlgorithmID var2, AlgorithmID var3, PrivateKey var4) {
      this.h = AlgorithmID.sha;
      this.g = AlgorithmID.rsaEncryption;
      if(!var3.equals(AlgorithmID.rsaEncryption)) {
         throw new IllegalArgumentException("Algorithm " + var3.getName() + " not supported for digest encryption!");
      } else {
         this.d = var1;
         this.h = var2;
         this.g = var3;
         this.c = var4;
      }
   }

   public SignerInfo(ASN1Object var1) throws CodingException {
      this.h = AlgorithmID.sha;
      this.g = AlgorithmID.rsaEncryption;
      this.decode(var1);
   }

   public SignerInfo() {
      this.h = AlgorithmID.sha;
      this.g = AlgorithmID.rsaEncryption;
   }
}
Page generated: Oct 19, 2017 2:34:48 PM