Information

0
Story Points

Technologies

Decompiled Java File
package iaik.security.dh;

import java.math.BigInteger;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactorySpi;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;
import javax.crypto.spec.DHPrivateKeySpec;
import javax.crypto.spec.DHPublicKeySpec;

public final class DHKeyFactory extends KeyFactorySpi {
   // $FF: synthetic field
   static Class d;
   // $FF: synthetic field
   static Class b;
   // $FF: synthetic field
   static Class c;
   // $FF: synthetic field
   static Class a;

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

   protected Key engineTranslateKey(Key var1) throws InvalidKeyException {
      BigInteger var2;
      DHParameterSpec var3;
      if(var1 instanceof DHPublicKey) {
         var2 = ((DHPublicKey)var1).getY();
         var3 = ((DHPublicKey)var1).getParams();
         return new iaik.security.dh.DHPublicKey(var2, var3);
      } else if(var1 instanceof DHPrivateKey) {
         var2 = ((DHPrivateKey)var1).getX();
         var3 = ((DHPrivateKey)var1).getParams();
         return new iaik.security.dh.DHPrivateKey(var2, var3);
      } else {
         throw new InvalidKeyException("Only keys of type DHPublicKey and DHPrivateKey can be translated.");
      }
   }

   protected KeySpec engineGetKeySpec(Key var1, Class var2) throws InvalidKeySpecException {
      DHParameterSpec var4;
      if(var1 instanceof iaik.security.dh.DHPublicKey) {
         if((a != null?a:(a = a("javax.crypto.spec.DHPublicKeySpec"))).isAssignableFrom(var2)) {
            iaik.security.dh.DHPublicKey var5 = (iaik.security.dh.DHPublicKey)var1;
            var4 = var5.getParams();
            return new DHPublicKeySpec(var5.getY(), var4.getP(), var4.getG());
         } else if((c != null?c:(c = a("java.security.spec.X509EncodedKeySpec"))).isAssignableFrom(var2)) {
            return new X509EncodedKeySpec(var1.getEncoded());
         } else {
            throw new InvalidKeySpecException("Can\'t convert key to KeySpec.");
         }
      } else if(var1 instanceof iaik.security.dh.DHPrivateKey) {
         iaik.security.dh.DHPrivateKey var3 = (iaik.security.dh.DHPrivateKey)var1;
         if((b != null?b:(b = a("javax.crypto.spec.DHPrivateKeySpec"))).isAssignableFrom(var2)) {
            var4 = var3.getParams();
            return new DHPrivateKeySpec(var3.getX(), var4.getP(), var4.getG());
         } else if((d != null?d:(d = a("java.security.spec.PKCS8EncodedKeySpec"))).isAssignableFrom(var2)) {
            return new PKCS8EncodedKeySpec(var3.getEncoded());
         } else {
            throw new InvalidKeySpecException("Can\'t convert key to KeySpec.");
         }
      } else {
         throw new InvalidKeySpecException("Can only convert DH keys.");
      }
   }

   protected PublicKey engineGeneratePublic(KeySpec var1) throws InvalidKeySpecException {
      try {
         if(var1 instanceof DHPublicKeySpec) {
            return new iaik.security.dh.DHPublicKey((DHPublicKeySpec)var1);
         } else if(var1 instanceof X509EncodedKeySpec) {
            return new iaik.security.dh.DHPublicKey(((X509EncodedKeySpec)var1).getEncoded());
         } else {
            throw new InvalidKeySpecException("Only DH key specs allowed.");
         }
      } catch (InvalidKeyException var2) {
         throw new InvalidKeySpecException("Invalid KeySpec.");
      }
   }

   protected PrivateKey engineGeneratePrivate(KeySpec var1) throws InvalidKeySpecException {
      try {
         if(var1 instanceof DHPrivateKeySpec) {
            return new iaik.security.dh.DHPrivateKey((DHPrivateKeySpec)var1);
         } else if(var1 instanceof PKCS8EncodedKeySpec) {
            return new iaik.security.dh.DHPrivateKey(((PKCS8EncodedKeySpec)var1).getEncoded());
         } else {
            throw new InvalidKeySpecException("Only DH key specs allowed.");
         }
      } catch (InvalidKeyException var2) {
         throw new InvalidKeySpecException("Invalid KeySpec.");
      }
   }
}
Page generated: Oct 19, 2017 2:35:08 PM