package com.l7tech.security.keys;

import com.l7tech.security.prov.JceProvider;
import com.l7tech.util.ExceptionUtils;
import com.l7tech.util.SyspropUtil;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.StringReader;
import java.io.StringWriter;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.PublicKey;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
import org.bouncycastle.cert.X509CertificateHolder;
import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;
import org.bouncycastle.openssl.PEMDecryptorProvider;
import org.bouncycastle.openssl.PEMEncryptedKeyPair;
import org.bouncycastle.openssl.PEMKeyPair;
import org.bouncycastle.openssl.PEMParser;
import org.bouncycastle.openssl.PKCS8Generator;
import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;
import org.bouncycastle.openssl.jcajce.JcaPEMWriter;
import org.bouncycastle.openssl.jcajce.JceOpenSSLPKCS8DecryptorProviderBuilder;
import org.bouncycastle.openssl.jcajce.JceOpenSSLPKCS8EncryptorBuilder;
import org.bouncycastle.openssl.jcajce.JcePEMDecryptorProviderBuilder;
import org.bouncycastle.operator.InputDecryptorProvider;
import org.bouncycastle.operator.OperatorCreationException;
import org.bouncycastle.pkcs.PKCS8EncryptedPrivateKeyInfo;
import org.bouncycastle.pkcs.PKCSException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class PemUtils {
   private static final Logger a;
   private static final String b;
   private static final String c;
   private static final String d;
   private static final String[] e;

   @Nullable
   public static String getPemPrivateKeyAlgorithm(String var0) {
      try {
         if (var0.contains(e[0])) {
            return e[2];
         }
      } catch (IllegalStateException var2) {
         throw a(var2);
      }

      try {
         return var0.contains(e[7]) ? e[12] : null;
      } catch (IllegalStateException var1) {
         throw a(var1);
      }
   }

   @NotNull
   public static KeyPair doReadKeyPair(String var0) throws IOException {
      StringReader var1 = new StringReader(var0);
      PEMParser var2 = new PEMParser(var1);

      KeyPair var4;
      try {
         Object var3 = var2.readObject();

         try {
            if (!(var3 instanceof PEMKeyPair)) {
               throw new IOException(e[15]);
            }
         } catch (Throwable var7) {
            throw a(var7);
         }

         var4 = new JcaPEMKeyConverter().getKeyPair((PEMKeyPair)var3);
      } catch (Throwable var8) {
         try {
            var2.close();
         } catch (Throwable var5) {
            var8.addSuppressed(var5);
         }

         throw var8;
      }

      try {
         var2.close();
         if (var4 == null) {
            a(0);
         }

         return var4;
      } catch (Throwable var6) {
         throw a(var6);
      }
   }

   @NotNull
   public static KeyPair doReadKeyPair(String var0, String var1) throws IOException {
      StringReader var2 = new StringReader(var0);
      PEMParser var3 = new PEMParser(var2);

      KeyPair var7;
      label85: {
         KeyPair var16;
         label84: {
            KeyPair var6;
            label83: {
               try {
                  Object var4 = var3.readObject();
                  if (var4 instanceof PKCS8EncryptedPrivateKeyInfo) {
                     try {
                        InputDecryptorProvider var17 = new JceOpenSSLPKCS8DecryptorProviderBuilder().build(var1.toCharArray());
                        PrivateKeyInfo var18 = ((PKCS8EncryptedPrivateKeyInfo)var4).decryptPrivateKeyInfo(var17);
                        var7 = new KeyPair(null, new JcaPEMKeyConverter().getPrivateKey(var18));
                        break label85;
                     } catch (OperatorCreationException | PKCSException var10) {
                        throw new IOException(var10);
                     }
                  }

                  if (var4 instanceof PrivateKeyInfo) {
                     var16 = new KeyPair(null, new JcaPEMKeyConverter().getPrivateKey((PrivateKeyInfo)var4));
                     break label84;
                  }

                  if (var4 instanceof PEMEncryptedKeyPair) {
                     PEMDecryptorProvider var15 = new JcePEMDecryptorProviderBuilder().build(var1.toCharArray());
                     var6 = new JcaPEMKeyConverter().getKeyPair(((PEMEncryptedKeyPair)var4).decryptKeyPair(var15));
                     break label83;
                  }

                  if (!(var4 instanceof PEMKeyPair)) {
                     throw new IOException(e[8]);
                  }

                  var16 = new JcaPEMKeyConverter().getKeyPair((PEMKeyPair)var4);
               } catch (Throwable var14) {
                  try {
                     var3.close();
                  } catch (Throwable var8) {
                     var14.addSuppressed(var8);
                  }

                  throw var14;
               }

               try {
                  var3.close();
                  if (var16 == null) {
                     a(4);
                  }

                  return var16;
               } catch (OperatorCreationException var13) {
                  throw a(var13);
               }
            }

            try {
               var3.close();
               if (var6 == null) {
                  a(3);
               }

               return var6;
            } catch (OperatorCreationException var12) {
               throw a(var12);
            }
         }

         try {
            var3.close();
            if (var16 == null) {
               a(2);
            }

            return var16;
         } catch (OperatorCreationException var11) {
            throw a(var11);
         }
      }

      try {
         var3.close();
         if (var7 == null) {
            a(1);
         }

         return var7;
      } catch (OperatorCreationException var9) {
         throw a(var9);
      }
   }

   @NotNull
   public static X509Certificate doReadCertificate(String var0) throws CertificateException, IOException {
      StringReader var1 = new StringReader(var0);
      PEMParser var2 = new PEMParser(var1);

      X509Certificate var4;
      try {
         Object var3 = var2.readObject();

         try {
            if (!(var3 instanceof X509CertificateHolder)) {
               throw new CertificateException(e[9]);
            }
         } catch (Throwable var7) {
            throw a(var7);
         }

         var4 = new JcaX509CertificateConverter().getCertificate((X509CertificateHolder)var3);
      } catch (Throwable var8) {
         try {
            var2.close();
         } catch (Throwable var5) {
            var8.addSuppressed(var5);
         }

         throw var8;
      }

      try {
         var2.close();
         if (var4 == null) {
            a(5);
         }

         return var4;
      } catch (Throwable var6) {
         throw a(var6);
      }
   }

   @NotNull
   public static String doWriteKeyPair(PrivateKey var0) throws IOException {
      StringWriter var1 = new StringWriter();
      JcaPEMWriter var2 = new JcaPEMWriter(var1);

      try {
         var2.writeObject(var0);
      } catch (Throwable var7) {
         try {
            var2.close();
         } catch (Throwable var5) {
            var7.addSuppressed(var5);
         }

         throw var7;
      }

      var2.close();

      try {
         String var10000 = var1.toString();
         if (var10000 == null) {
            a(6);
         }

         return var10000;
      } catch (Throwable var6) {
         throw a(var6);
      }
   }

   @NotNull
   public static String doWriteKeyPair(PrivateKey var0, String var1) throws IOException {
      StringWriter var2 = new StringWriter();

      try {
         JcaPEMWriter var3 = new JcaPEMWriter(var2);

         try {
            PKCS8Generator var4 = new PKCS8Generator(
               PrivateKeyInfo.getInstance(var0.getEncoded()),
               new JceOpenSSLPKCS8EncryptorBuilder(PKCS8Generator.PBE_SHA1_RC2_128).setPasssword(var1.toCharArray()).build()
            );
            var3.writeObject(var4.generate());
         } catch (Throwable var8) {
            try {
               var3.close();
            } catch (Throwable var6) {
               var8.addSuppressed(var6);
            }

            throw var8;
         }

         var3.close();
      } catch (OperatorCreationException var9) {
         throw new IOException(var9);
      }

      try {
         String var10000 = var2.toString();
         if (var10000 == null) {
            a(7);
         }

         return var10000;
      } catch (Throwable var7) {
         throw a(var7);
      }
   }

   @Nullable
   public static String writeKey(PublicKey var0, boolean var1) {
      ByteArrayOutputStream var2 = new ByteArrayOutputStream();

      try {
         JcaPEMWriter var3 = new JcaPEMWriter(new OutputStreamWriter(var2));

         String var5;
         try {
            var3.writeObject(var0);
            var3.flush();
            String var4 = var2.toString();
            if (!var1) {
               String[] var6 = e;
               var4 = var4.replace(SyspropUtil.getProperty(var6[4]), "");
            }

            var5 = var4;
         } catch (Throwable var8) {
            try {
               var3.close();
            } catch (Throwable var7) {
               var8.addSuppressed(var7);
            }

            throw var8;
         }

         var3.close();
         return var5;
      } catch (IOException var9) {
         a.log(Level.INFO, e[5] + ExceptionUtils.getMessage(var9), ExceptionUtils.getDebugException(var9));
         return null;
      }
   }

   @Nullable
   public static String writeKey(PublicKey var0) {
      return writeKey(var0, false);
   }

   @Nullable
   public static String getProviderNameForService(String var0) {
      Provider var1 = JceProvider.getInstance().getPreferredProvider(var0);

      try {
         if (var1 == null) {
            return null;
         }
      } catch (IllegalStateException var2) {
         throw a(var2);
      }

      return var1.getName();
   }

   static {
      String[] var5 = new String[17];
      int var3 = 0;
      String var2 = "Y\u001b;3h\u001c63\u007fX>\u0017\r2\u000e\u0010YAl,*\u0016?SoN$7\u0001\u0003&eW\u0011\u0010YD{$:0\u0011Dbw#7\u0010\u0015Bs\u000e\u0018_x{k-\u0016\u0004Wd\u007f11\u0001\u0015!Xw|);S\u0000Y6i77\u0007\u0011\u0016}{<dS\u00030eW\u000eY\u001b;3h\u001c63\u007fX>\u0001\r2\u001f5\u0016`\u007f)7\u0017T]sge.\u0012\u001dD6i$-S\u001aYb>#1\u0006\u001aR8\"5\u0016`\u007f)7\u0017TUsl17\u0015\u001dUwj ~\u0004\u0015E6p**S\u0012Ycp!p\r\u0010YD{$:8\u0011OF\u007f,,\u0003&eW\u00030eW!\u0017Y{1)i\u0007\u0011U~16;\u0010\u0001D\u007fj<q\u0018\u0011Oe1\u0015;\u001e!B\u007fr6\u000bY\u001b;3h\u001c63\u007fX>";
      int var4 = "Y\u001b;3h\u001c63\u007fX>\u0017\r2\u000e\u0010YAl,*\u0016?SoN$7\u0001\u0003&eW\u0011\u0010YD{$:0\u0011Dbw#7\u0010\u0015Bs\u000e\u0018_x{k-\u0016\u0004Wd\u007f11\u0001\u0015!Xw|);S\u0000Y6i77\u0007\u0011\u0016}{<dS\u00030eW\u000eY\u001b;3h\u001c63\u007fX>\u0001\r2\u001f5\u0016`\u007f)7\u0017T]sge.\u0012\u001dD6i$-S\u001aYb>#1\u0006\u001aR8\"5\u0016`\u007f)7\u0017TUsl17\u0015\u001dUwj ~\u0004\u0015E6p**S\u0012Ycp!p\r\u0010YD{$:8\u0011OF\u007f,,\u0003&eW\u00030eW!\u0017Y{1)i\u0007\u0011U~16;\u0010\u0001D\u007fj<q\u0018\u0011Oe1\u0015;\u001e!B\u007fr6\u000bY\u001b;3h\u001c63\u007fX>"
         .length();
      char var1 = 14;
      int var7 = -1;

      label24:
      while (true) {
         byte var10000 = 90;
         String var10001 = var2.substring(++var7, var7 + var1);
         byte var10002 = -1;

         while (true) {
            String var8 = a(var10000, a(var10001));
            switch (var10002) {
               case 0:
                  var5[var3++] = var8;
                  if ((var7 += var1) >= var4) {
                     e = var5;
                     String[] var9 = e;
                     b = e[6];
                     c = var9[11];
                     d = var9[14];
                     a = Logger.getLogger(PemUtils.class.getName());
                     return;
                  }

                  var1 = var2.charAt(var7);
                  break;
               default:
                  var5[var3++] = var8;
                  if ((var7 += var1) < var4) {
                     var1 = var2.charAt(var7);
                     continue label24;
                  }

                  var2 = "\u00156@_\t\u00177t}SGE\u000e2=d\u0016I\u0004\rs:yB\u001e\u0003\u0011&:r\u0018*\u0014XYJ+\u000b?86[[\u0011\u0016<06\u0013MK[ t{CM\u0011^=;b\u0016L\u0000\n&&x\u0016P\u0010\u0012?";
                  var4 = "\u00156@_\t\u00177t}SGE\u000e2=d\u0016I\u0004\rs:yB\u001e\u0003\u0011&:r\u0018*\u0014XYJ+\u000b?86[[\u0011\u0016<06\u0013MK[ t{CM\u0011^=;b\u0016L\u0000\n&&x\u0016P\u0010\u0012?"
                     .length();
                  var1 = 31;
                  var7 = -1;
            }

            var10000 = 122;
            var10001 = var2.substring(++var7, var7 + var1);
            var10002 = 0;
         }
      }
   }

   private static Throwable a(Throwable var0) {
      return var0;
   }

   private static char[] a(String var0) {
      char[] var10000 = var0.toCharArray();
      if (var10000.length < 2) {
         var10000[0] = (char)(var10000[0] ^ 41);
      }

      return var10000;
   }

   private static String a(int var0, char[] var1) {
      int var10003 = var1.length;
      int var10002 = var0;
      char[] var10001 = var1;
      int var10000 = var10003;

      for (int var2 = 0; var10000 > var2; var2++) {
         var10001[var2] = (char)(var10001[var2] ^ var10002 ^ switch (var2 % 7) {
            case 0 -> 46;
            case 1 -> 108;
            case 2 -> 76;
            case 3 -> 68;
            case 4 -> 31;
            case 5 -> 4;
            default -> 41;
         });
      }

      return new String(var10001).intern();
   }
}