Spermatid v6.1.8版本的 MD5 值为：a375ce51a42d528ba6e2583c10478296

以下内容为反编译后的 Sign.java 源代码，内容仅作参考

package cn.hutool.crypto.asymmetric;

import a1.d;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.crypto.CryptoException;
import h1.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;

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 i10) {
        return j.e(sign(inputStream, i10));
    }

    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");
            }
        }
        this.publicKey = certificate.getPublicKey();
        return this;
    }

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

    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) {
        this.lock.lock();
        try {
            try {
                this.signature.initVerify(this.publicKey);
                this.signature.update(bArr);
                return this.signature.verify(bArr2);
            } catch (Exception e10) {
                throw new CryptoException(e10);
            }
        } finally {
            this.lock.unlock();
        }
    }

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

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

    public byte[] sign(String str) {
        return sign(str, cn.hutool.core.util.c.f4171c);
    }

    public String signHex(String str) {
        return signHex(str, cn.hutool.core.util.c.f4171c);
    }

    public Sign(SignAlgorithm signAlgorithm, String str, String str2) {
        this(signAlgorithm.getValue(), o1.b.e(str), o1.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 i10) {
        if (i10 < 1) {
            i10 = 8192;
        }
        byte[] bArr = new byte[i10];
        this.lock.lock();
        try {
            try {
                this.signature.initSign(this.privateKey);
                try {
                    int read = inputStream.read(bArr, 0, i10);
                    while (read > -1) {
                        this.signature.update(bArr, 0, read);
                        read = inputStream.read(bArr, 0, i10);
                    }
                    return this.signature.sign();
                } catch (Exception e10) {
                    throw new CryptoException(e10);
                }
            } catch (Exception e11) {
                throw new CryptoException(e11);
            }
        } finally {
            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, s.c.a(str2), s.c.a(str3));
    }

    public Sign(String str, byte[] bArr, byte[] bArr2) {
        this(str, o1.b.i(str, bArr), o1.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);
    }
}