SpeedCash v6.5.1482 - AdvancedTlsX509KeyManager.java 源代码

package io.grpc.util;

import com.google.common.base.Preconditions;
import io.grpc.ExperimentalApi;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.Socket;
import java.security.GeneralSecurityException;
import java.security.Principal;
import java.security.PrivateKey;
import java.security.cert.X509Certificate;
import java.util.Arrays;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.X509ExtendedKeyManager;

@ExperimentalApi("https://github.com/grpc/grpc-java/issues/8024")
public final class AdvancedTlsX509KeyManager extends X509ExtendedKeyManager {
    public static final Logger b = Logger.getLogger(AdvancedTlsX509KeyManager.class.getName());
    public volatile b a;

    public interface Closeable extends java.io.Closeable {
        @Override
        void close();
    }

    public class a implements Closeable {
        public final ScheduledFuture a;

        public a(ScheduledFuture scheduledFuture) {
            this.a = scheduledFuture;
        }

        @Override
        public void close() {
            this.a.cancel(false);
        }
    }

    public static class b {
        public final PrivateKey a;
        public final X509Certificate[] b;

        public b(PrivateKey privateKey, X509Certificate[] x509CertificateArr) {
            this.a = privateKey;
            this.b = x509CertificateArr;
        }
    }

    public class c implements Runnable {
        public File a;
        public File b;
        public long c = 0;
        public long d = 0;

        public c(File file, File file2) {
            this.a = file;
            this.b = file2;
        }

        @Override
        public void run() {
            try {
                d c = AdvancedTlsX509KeyManager.this.c(this.a, this.b, this.c, this.d);
                if (c.a) {
                    this.c = c.b;
                    this.d = c.c;
                }
            } catch (IOException | GeneralSecurityException e) {
                AdvancedTlsX509KeyManager.b.log(Level.SEVERE, "Failed refreshing private key and certificate chain from files. Using previous ones", e);
            }
        }
    }

    public static class d {
        public boolean a;
        public long b;
        public long c;

        public d(boolean z, long j, long j2) {
            this.a = z;
            this.b = j;
            this.c = j2;
        }
    }

    public final d c(File file, File file2, long j, long j2) throws IOException, GeneralSecurityException {
        long lastModified = file.lastModified();
        long lastModified2 = file2.lastModified();
        if (lastModified == j || lastModified2 == j2) {
            return new d(false, j, j2);
        }
        FileInputStream fileInputStream = new FileInputStream(file);
        try {
            try {
                PrivateKey privateKey = CertificateUtils.getPrivateKey(fileInputStream);
                FileInputStream fileInputStream2 = new FileInputStream(file2);
                try {
                    try {
                        updateIdentityCredentials(privateKey, CertificateUtils.getX509Certificates(fileInputStream2));
                        d dVar = new d(true, lastModified, lastModified2);
                        fileInputStream2.close();
                        fileInputStream.close();
                        return dVar;
                    } catch (Throwable th) {
                        th = th;
                        fileInputStream2.close();
                        throw th;
                    }
                } catch (Throwable th2) {
                    th = th2;
                }
            } catch (Throwable th3) {
                th = th3;
                fileInputStream.close();
                throw th;
            }
        } catch (Throwable th4) {
            th = th4;
            fileInputStream.close();
            throw th;
        }
    }

    @Override
    public String chooseClientAlias(String[] strArr, Principal[] principalArr, Socket socket) {
        return "default";
    }

    @Override
    public String chooseEngineClientAlias(String[] strArr, Principal[] principalArr, SSLEngine sSLEngine) {
        return "default";
    }

    @Override
    public String chooseEngineServerAlias(String str, Principal[] principalArr, SSLEngine sSLEngine) {
        return "default";
    }

    @Override
    public String chooseServerAlias(String str, Principal[] principalArr, Socket socket) {
        return "default";
    }

    @Override
    public X509Certificate[] getCertificateChain(String str) {
        if (str.equals("default")) {
            return (X509Certificate[]) Arrays.copyOf(this.a.b, this.a.b.length);
        }
        return null;
    }

    @Override
    public String[] getClientAliases(String str, Principal[] principalArr) {
        return new String[]{"default"};
    }

    @Override
    public PrivateKey getPrivateKey(String str) {
        if (str.equals("default")) {
            return this.a.a;
        }
        return null;
    }

    @Override
    public String[] getServerAliases(String str, Principal[] principalArr) {
        return new String[]{"default"};
    }

    public void updateIdentityCredentials(PrivateKey privateKey, X509Certificate[] x509CertificateArr) {
        this.a = new b((PrivateKey) Preconditions.checkNotNull(privateKey, "key"), (X509Certificate[]) Preconditions.checkNotNull(x509CertificateArr, "certs"));
    }

    public Closeable updateIdentityCredentialsFromFile(File file, File file2, long j, TimeUnit timeUnit, ScheduledExecutorService scheduledExecutorService) throws IOException, GeneralSecurityException {
        if (c(file, file2, 0L, 0L).a) {
            return new a(scheduledExecutorService.scheduleWithFixedDelay(new c(file, file2), j, j, timeUnit));
        }
        throw new GeneralSecurityException("Files were unmodified before their initial update. Probably a bug.");
    }

    public void updateIdentityCredentialsFromFile(File file, File file2) throws IOException, GeneralSecurityException {
        if (!c(file, file2, 0L, 0L).a) {
            throw new GeneralSecurityException("Files were unmodified before their initial update. Probably a bug.");
        }
    }
}