Information

0
Story Points

Technologies

Decompiled Java File
package iaik.pkcs.pkcs7;

import iaik.asn1.ASN;
import iaik.asn1.ASN1Object;
import iaik.asn1.CodingException;
import iaik.asn1.DerCoder;
import iaik.asn1.DerInputStream;
import iaik.asn1.INTEGER;
import iaik.asn1.ObjectID;
import iaik.asn1.SEQUENCE;
import iaik.asn1.structures.AlgorithmID;
import iaik.pkcs.PKCSException;
import iaik.pkcs.PKCSParsingException;
import iaik.pkcs.pkcs7.Content;
import iaik.pkcs.pkcs7.EncryptedContentInfo;
import iaik.pkcs.pkcs7.EnvelopedDataStream;
import iaik.pkcs.pkcs7.RecipientInfo;
import iaik.utils.Util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.util.Enumeration;
import javax.crypto.SecretKey;

public class EnvelopedData extends EnvelopedDataStream implements Content {
   // $FF: synthetic field
   static Class b;
   private EncryptedContentInfo a;

   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: " + super.version + "\n");
      if(var1) {
         for(int var3 = 0; var3 < super.recipient_infos.size(); ++var3) {
            var2.append("\nRecipientInfo " + (var3 + 1) + ":{\n");
            var2.append(((RecipientInfo)super.recipient_infos.elementAt(var3)).toString());
            var2.append("\n}");
         }
      } else {
         var2.append("RecipientInfos: " + super.recipient_infos.size() + "\n");
      }

      var2.append("\nEncryptedContentInfo: {\n");
      var2.append(this.a.toString() + "}");
      return var2.toString();
   }

   protected ASN1Object toASN1Object(int var1) throws PKCSException {
      if(var1 <= 0) {
         var1 = super.block_size;
      }

      if(super.recipient_infos == null) {
         throw new PKCSException("No recipients specified.");
      } else {
         if(super.symmetric_key != null) {
            Enumeration var2 = super.recipient_infos.elements();

            while(var2.hasMoreElements()) {
               ((RecipientInfo)var2.nextElement()).encryptKey(super.symmetric_key);
            }
         }

         this.a.setBlockSize(var1);
         SEQUENCE var5 = new SEQUENCE(var1 > 0);

         try {
            var5.addComponent(new INTEGER(super.version));
            if(super.version == 1) {
               var5.addComponent(ASN.createSequenceOf(super.recipient_infos));
            } else {
               var5.addComponent(ASN.createSetOf(super.recipient_infos));
            }

            var5.addComponent(this.a.toASN1Object());
            return var5;
         } catch (CodingException var4) {
            throw new PKCSException(var4.toString());
         }
      }
   }

   public void setupCipher(PrivateKey var1, int var2) throws InvalidKeyException, NoSuchAlgorithmException, PKCSException {
      SecretKey var3 = ((RecipientInfo)super.recipient_infos.elementAt(var2)).decryptKey(var1);
      this.a.setupCipher(var3);
   }

   public void setupCipher(Key var1) throws InvalidKeyException, NoSuchAlgorithmException, PKCSException {
      this.a.setupCipher(var1);
   }

   public InputStream getInputStream() {
      return this.a.getInputStream();
   }

   public Object getEncryptedContentInfo() {
      return this.a;
   }

   public byte[] getEncoded() throws PKCSException {
      try {
         ByteArrayOutputStream var1 = new ByteArrayOutputStream();
         DerCoder.encodeTo(this.toASN1Object(), var1);
         return var1.toByteArray();
      } catch (IOException var2) {
         throw new PKCSException(var2.getMessage());
      }
   }

   public byte[] getContent() {
      return this.a.getContent();
   }

   public void decode(InputStream var1) throws PKCSParsingException, IOException {
      if(!(var1 instanceof DerInputStream)) {
         var1 = new DerInputStream((InputStream)var1);
      }

      DerInputStream var2 = ((DerInputStream)var1).readSequence();
      super.version = var2.readInteger().intValue();

      try {
         super.recipient_infos = Util.getVector((RecipientInfo[])ASN.parseSequenceOf(DerCoder.decode(var2), b != null?b:(b = a("iaik.pkcs.pkcs7.RecipientInfo"))));
      } catch (CodingException var3) {
         throw new PKCSParsingException("Error parsing recipient infos!");
      }

      this.a = new EncryptedContentInfo();
      this.a.c = super.version;
      this.a.decode(var2);
   }

   public void decode(ASN1Object var1) throws PKCSParsingException {
      try {
         this.decode((InputStream)(new ByteArrayInputStream(DerCoder.encode(var1))));
      } catch (IOException var3) {
         throw new PKCSParsingException(var3.getMessage());
      }
   }

   public EnvelopedData(RecipientInfo[] var1, EncryptedContentInfo var2, int var3) {
      super.recipient_infos = Util.getVector(var1);
      this.a = var2;
      if(var3 == 1) {
         super.version = 1;
         this.a.c = 1;
      } else if(var3 != 0) {
         throw new IllegalArgumentException("Invalid version number: " + var3);
      }
   }

   public EnvelopedData(RecipientInfo[] var1, EncryptedContentInfo var2) {
      super.recipient_infos = Util.getVector(var1);
      this.a = var2;
   }

   public EnvelopedData(byte[] var1, AlgorithmID var2, int var3, int var4) throws NoSuchAlgorithmException {
      this.a = new EncryptedContentInfo(ObjectID.pkcs7_data, var1);
      if(var4 == 1) {
         super.version = 1;
         this.a.c = 1;
      } else if(var4 != 0) {
         throw new IllegalArgumentException("Invalid version number: " + var4);
      }

      super.symmetric_key = this.a.setupCipher(var2, var3);
   }

   public EnvelopedData(byte[] var1, AlgorithmID var2, int var3) throws NoSuchAlgorithmException {
      this.a = new EncryptedContentInfo(ObjectID.pkcs7_data, var1);
      super.symmetric_key = this.a.setupCipher(var2, var3);
   }

   public EnvelopedData(byte[] var1, AlgorithmID var2) throws NoSuchAlgorithmException {
      this.a = new EncryptedContentInfo(ObjectID.pkcs7_data, var1);
      super.symmetric_key = this.a.setupCipher(var2);
   }

   public EnvelopedData(InputStream var1) throws IOException, PKCSParsingException {
      this.decode(var1);
   }

   public EnvelopedData(ASN1Object var1) throws PKCSParsingException {
      this.decode(var1);
   }

   protected EnvelopedData() {
   }
}
Page generated: Oct 19, 2017 2:35:19 PM