Information

0
Story Points

Technologies

Decompiled Java File
package iaik.pkcs.pkcs12;

import iaik.asn1.ASN1Object;
import iaik.asn1.ASN1Type;
import iaik.asn1.CodingException;
import iaik.asn1.DerCoder;
import iaik.asn1.ObjectID;
import iaik.asn1.structures.AlgorithmID;
import iaik.pkcs.PKCSException;
import iaik.pkcs.PKCSParsingException;
import iaik.pkcs.pkcs12.PKCS8ShroudedKeyBag;
import iaik.pkcs.pkcs12.SafeBag;
import iaik.pkcs.pkcs7.ContentInfo;
import iaik.pkcs.pkcs7.Data;
import iaik.pkcs.pkcs7.EncryptedContentInfo;
import iaik.pkcs.pkcs7.EncryptedData;
import iaik.security.cipher.PBEKeyBMP;
import iaik.utils.InternalErrorException;
import java.security.AlgorithmParameters;
import java.security.GeneralSecurityException;
import java.security.InvalidAlgorithmParameterException;
import java.security.KeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.AlgorithmParameterSpec;

public class AuthenticatedSafe implements ASN1Type {
   // $FF: synthetic field
   static Class g;
   private static final int h = 1024;
   SafeBag[] a;
   private int b;
   private ContentInfo d;
   EncryptedContentInfo c;
   public static final int PUBLIC_KEY_ENCRYPTED = 3;
   public static final int PASSWORD_ENCRYPTED = 2;
   public static final int UNENCRYPTED = 1;
   private static final boolean e = false;
   private static final boolean f = false;

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

   public String toString() {
      StringBuffer var1 = new StringBuffer();
      var1.append("mode: ");
      switch(this.b) {
      case 1:
         var1.append("UNENCRYPTED\n");
         break;
      case 2:
         var1.append("PASSWORD_ENCRYPTED\n");
         var1.append("Content encrypted with: " + this.c.getContentEncryptionAlgorithm().getName() + "\n");
         break;
      case 3:
         var1.append("PUBLIC_KEY_ENCRYPTED\n");
      }

      if(this.a == null) {
         var1.append("No SafeBags or not decrypted yet.\n");
      } else {
         for(int var2 = 0; var2 < this.a.length; ++var2) {
            var1.append("\nSafeBag: " + var2 + "\n");
            var1.append(this.a[var2].toString());
         }
      }

      return var1.toString();
   }

   public ASN1Object toASN1Object() throws CodingException {
      try {
         return this.d.toASN1Object();
      } catch (PKCSException var2) {
         throw new CodingException(var2.toString());
      }
   }

   public SafeBag[] getSafeBags() {
      return this.a;
   }

   public void encrypt(char[] var1, AlgorithmID var2) throws PKCSException, NoSuchAlgorithmException {
      switch(this.b) {
      case 1:
         return;
      case 2:
         AlgorithmParameterSpec var3 = null;
         if(!var2.equals(AlgorithmID.pbeWithSHAAnd40BitRC2_CBC) && !var2.equals(AlgorithmID.pbeWithSHAAnd3_KeyTripleDES_CBC)) {
            throw new NoSuchAlgorithmException(var2.getName() + " not allowed!");
         } else {
            try {
               AlgorithmParameters var4 = var2.getAlgorithmParameters("PBE");
               var3 = var4.getParameterSpec(g != null?g:(g = a("javax.crypto.spec.PBEParameterSpec")));
            } catch (Exception var7) {
               throw new InternalErrorException(var7);
            }

            try {
               this.c.setupCipher(var2, new PBEKeyBMP(var1), var3);
            } catch (KeyException var5) {
               throw new PKCSException(var5.toString());
            } catch (InvalidAlgorithmParameterException var6) {
               throw new PKCSException(var6.toString());
            }

            EncryptedData var8 = new EncryptedData(this.c);
            var8.setBlockSize(1024);
            this.d = new ContentInfo(var8);
            return;
         }
      case 3:
         throw new RuntimeException("PUBLIC_KEY_ENCRYPTED not implemented");
      default:
         throw new PKCSException("Unknown mode!");
      }
   }

   public void decrypt(char[] var1) throws NoSuchAlgorithmException, PKCSException {
      switch(this.b) {
      case 1:
         break;
      case 2:
         try {
            AlgorithmID var2 = this.c.getContentEncryptionAlgorithm();
            AlgorithmParameters var3 = var2.getAlgorithmParameters("PBE");
            AlgorithmParameterSpec var4 = var3.getParameterSpec(g != null?g:(g = a("javax.crypto.spec.PBEParameterSpec")));
            this.c.setupCipher(new PBEKeyBMP(var1), var4);
            byte[] var5 = this.c.getContent();
            ASN1Object var6 = DerCoder.decode(var5);
            this.a = SafeBag.parseSafeContents(DerCoder.encode(var6));
            break;
         } catch (Exception var8) {
            throw new PKCSException(var8.toString());
         }
      case 3:
         throw new PKCSException("privacy mode PUBLIC_KEY_ENCRYPTED not implemented.");
      default:
         throw new PKCSException("Unknown authenticated safes mode.");
      }

      if(this.a != null) {
         for(int var9 = 0; var9 < this.a.length; ++var9) {
            if(this.a[var9] instanceof PKCS8ShroudedKeyBag) {
               try {
                  ((PKCS8ShroudedKeyBag)this.a[var9]).decrypt(var1);
               } catch (GeneralSecurityException var7) {
                  throw new PKCSException("Unable to decrypt PrivateKey!");
               }
            }
         }
      }

   }

   public void decode(ASN1Object var1) throws CodingException {
      try {
         this.d = new ContentInfo(var1);
      } catch (PKCSParsingException var3) {
         throw new CodingException(var3.toString());
      }

      if(this.d.getContentType().equals(ObjectID.pkcs7_encryptedData)) {
         this.b = 2;
         EncryptedData var4 = (EncryptedData)this.d.getContent();
         this.c = (EncryptedContentInfo)var4.getEncryptedContentInfo();
      } else if(this.d.getContentType().equals(ObjectID.pkcs7_envelopedData)) {
         this.b = 3;
         throw new CodingException("public-key encrypted not implemented.");
      } else if(this.d.getContentType().equals(ObjectID.pkcs7_data)) {
         this.b = 1;
         byte[] var2 = ((Data)this.d.getContent()).getData();
         this.a = SafeBag.parseSafeContents(var2);
      } else {
         throw new CodingException("Unknown content type in AuthenticatedSafes.");
      }
   }

   public AuthenticatedSafe(ASN1Object var1) throws PKCSParsingException {
      try {
         this.decode(var1);
      } catch (CodingException var3) {
         throw new PKCSParsingException(var3.toString());
      }
   }

   public AuthenticatedSafe(int var1, SafeBag[] var2) throws PKCSException {
      this.b = var1;
      this.a = var2;

      try {
         byte[] var3 = SafeBag.encodeSafeContents(this.a);
         if(var1 == 2) {
            this.c = new EncryptedContentInfo(ObjectID.pkcs7_data, var3);
            this.c.setBlockSize(1024);
         } else if(var1 == 3) {
            throw new RuntimeException("PUBLIC_KEY_ENCRYPTED not implemented");
         } else if(var1 == 1) {
            Data var4 = new Data(var3);
            var4.setBlockSize(1024);
            this.d = new ContentInfo(var4);
         } else {
            throw new PKCSException("Unknown mode!");
         }
      } catch (CodingException var5) {
         throw new PKCSException("Unknown mode!");
      }
   }
}
Page generated: Oct 19, 2017 2:35:08 PM