Spermatid Pro v6.4.3 - Sign.java 源代码

package cn.hutool.crypto.asymmetric;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.c;
import cn.hutool.crypto.CryptoException;
import e1.j;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.security.InvalidAlgorithmParameterException;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.cert.Certificate;
import java.security.cert.X509Certificate;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Set;
import l1.b;
import x0.d;

public class Sign extends BaseAsymmetric<Sign> {
    private static final long serialVersionUID = 1;
    public Signature signature;

    public Sign(SignAlgorithm signAlgorithm) {
        this(signAlgorithm, (byte[]) null, (byte[]) null);
    }

    public String digestHex(InputStream inputStream, int i3) {
        return j.e(sign(inputStream, i3));
    }

    public Signature getSignature() {
        return this.signature;
    }

    public Sign setCertificate(Certificate certificate) {
        boolean[] keyUsage;
        if (certificate instanceof X509Certificate) {
            X509Certificate x509Certificate = (X509Certificate) certificate;
            Set<String> criticalExtensionOIDs = x509Certificate.getCriticalExtensionOIDs();
            if (CollUtil.m(criticalExtensionOIDs) && criticalExtensionOIDs.contains("2.5.29.15") && (keyUsage = x509Certificate.getKeyUsage()) != null && !keyUsage[0]) {
                throw new CryptoException("Wrong key usage");
            }
        }
        ((BaseAsymmetric) this).publicKey = certificate.getPublicKey();
        return this;
    }

    public Sign setParameter(AlgorithmParameterSpec algorithmParameterSpec) {
        try {
            this.signature.setParameter(algorithmParameterSpec);
            return this;
        } catch (InvalidAlgorithmParameterException e) {
            throw new CryptoException(e);
        }
    }

    public Sign setSignature(Signature signature) {
        this.signature = signature;
        return this;
    }

    public byte[] sign(String str, Charset charset) {
        return sign(d.h(str, charset));
    }

    public String signHex(String str, Charset charset) {
        return j.e(sign(str, charset));
    }

    public boolean verify(byte[] bArr, byte[] bArr2) {
        ((BaseAsymmetric) this).lock.lock();
        try {
            try {
                this.signature.initVerify(((BaseAsymmetric) this).publicKey);
                this.signature.update(bArr);
                return this.signature.verify(bArr2);
            } catch (Exception e) {
                throw new CryptoException(e);
            }
        } finally {
            ((BaseAsymmetric) this).lock.unlock();
        }
    }

    public Sign(String str) {
        this(str, (byte[]) null, (byte[]) null);
    }

    public Sign init(String str, PrivateKey privateKey, PublicKey publicKey) {
        this.signature = b.d(str);
        super.init(str, privateKey, publicKey);
        return this;
    }

    public byte[] sign(String str) {
        return sign(str, c.c);
    }

    public String signHex(String str) {
        return signHex(str, c.c);
    }

    public Sign(SignAlgorithm signAlgorithm, String str, String str2) {
        this(signAlgorithm.getValue(), b.e(str), b.e(str2));
    }

    public byte[] sign(byte[] bArr) {
        return sign(new ByteArrayInputStream(bArr), -1);
    }

    public String signHex(byte[] bArr) {
        return j.e(sign(bArr));
    }

    public Sign(SignAlgorithm signAlgorithm, byte[] bArr, byte[] bArr2) {
        this(signAlgorithm.getValue(), bArr, bArr2);
    }

    public byte[] sign(InputStream inputStream) {
        return sign(inputStream, 8192);
    }

    public String signHex(InputStream inputStream) {
        return j.e(sign(inputStream));
    }

    public Sign(SignAlgorithm signAlgorithm, KeyPair keyPair) {
        this(signAlgorithm.getValue(), keyPair);
    }

    public byte[] sign(InputStream inputStream, int i3) {
        if (i3 < 1) {
            i3 = 8192;
        }
        byte[] bArr = new byte[i3];
        ((BaseAsymmetric) this).lock.lock();
        try {
            try {
                this.signature.initSign(((BaseAsymmetric) this).privateKey);
                try {
                    int read = inputStream.read(bArr, 0, i3);
                    while (read > -1) {
                        this.signature.update(bArr, 0, read);
                        read = inputStream.read(bArr, 0, i3);
                    }
                    return this.signature.sign();
                } catch (Exception e) {
                    throw new CryptoException(e);
                }
            } catch (Exception e4) {
                throw new CryptoException(e4);
            }
        } finally {
            ((BaseAsymmetric) this).lock.unlock();
        }
    }

    public Sign(SignAlgorithm signAlgorithm, PrivateKey privateKey, PublicKey publicKey) {
        this(signAlgorithm.getValue(), privateKey, publicKey);
    }

    public Sign(String str, String str2, String str3) {
        this(str, q.c.a(str2), q.c.a(str3));
    }

    public Sign(String str, byte[] bArr, byte[] bArr2) {
        this(str, b.i(str, bArr), b.k(str, bArr2));
    }

    public Sign(String str, KeyPair keyPair) {
        this(str, keyPair.getPrivate(), keyPair.getPublic());
    }

    public Sign(String str, PrivateKey privateKey, PublicKey publicKey) {
        super(str, privateKey, publicKey);
    }
}