import org.bouncycastle.operator.RuntimeOperatorException; //导入依赖的package包/类
public boolean verify(byte[] expected)
{
    try
    {
        return stream.verify(expected);
    }
    catch (SignatureException e)
    {
        throw new RuntimeOperatorException("exception obtaining signature: " + e.getMessage(), e);
    }
}
 

import org.bouncycastle.operator.RuntimeOperatorException; //导入依赖的package包/类
@Override
public OutputStream getOutputStream() {
    try {
        signer.initSign(key);
    } catch (InvalidKeyException ex) {
        throw new RuntimeOperatorException("could not initSign", ex);
    }
    return stream;
}
 

import org.bouncycastle.operator.RuntimeOperatorException; //导入依赖的package包/类
@Override
public byte[] getSignature() {
    try {
        return stream.getSignature();
    } catch (SignatureException ex) {
        throw new RuntimeOperatorException("exception obtaining signature: " + ex.getMessage(),
                ex);
    }
}
 

import org.bouncycastle.operator.RuntimeOperatorException; //导入依赖的package包/类
public static byte[] hash(HashAlgoType hashAlgoType, byte[] data) {
    ParamUtil.requireNonNull("hashAlgoType", hashAlgoType);
    ParamUtil.requireNonNull("data", data);
    if (!MDS_MAP.containsKey(hashAlgoType)) {
        throw new IllegalArgumentException("unknown hash algo " + hashAlgoType);
    }

    ConcurrentBag<ConcurrentBagEntry<Digest>> mds = MDS_MAP.get(hashAlgoType);

    ConcurrentBagEntry<Digest> md0 = null;
    for (int i = 0; i < 3; i++) {
        try {
            md0 = mds.borrow(10, TimeUnit.SECONDS);
            break;
        } catch (InterruptedException ex) { // CHECKSTYLE:SKIP
        }
    }

    if (md0 == null) {
        throw new RuntimeOperatorException("could not get idle MessageDigest");
    }

    try {
        Digest md = md0.value();
        md.reset();
        md.update(data, 0, data.length);
        byte[] bytes = new byte[md.getDigestSize()];
        md.doFinal(bytes, 0);
        return bytes;
    } finally {
        mds.requite(md0);
    }
}
 

import org.bouncycastle.operator.RuntimeOperatorException; //导入依赖的package包/类
/**
 * Hash the data and returns the first 8 bytes of the hash value.
 * @param data data over which the hash value is calculated.
 * @return long represented of the first 8 bytes
 */
public static long hash(byte[] data) {
    ParamUtil.requireNonNull("data", data);

    ConcurrentBagEntry<Digest> md0 = null;
    for (int i = 0; i < 3; i++) {
        try {
            md0 = MDS.borrow(10, TimeUnit.SECONDS);
            break;
        } catch (InterruptedException ex) { // CHECKSTYLE:SKIP
        }
    }

    if (md0 == null) {
        throw new RuntimeOperatorException("could not get idle MessageDigest");
    }

    try {
        Digest md = md0.value();
        md.reset();
        md.update(data, 0, data.length);
        byte[] bytes = new byte[md.getDigestSize()];
        md.doFinal(bytes, 0);

        return bytesToLong(bytes);
    } finally {
        MDS.requite(md0);
    }
}
 

import org.bouncycastle.operator.RuntimeOperatorException; //导入依赖的package包/类
private MacCalculator genCalculator(final PBMParameter params, char[] password)
    throws CRMFException
{
    // From RFC 4211
    //
    //   1.  Generate a random salt value S
    //
    //   2.  Append the salt to the pw.  K = pw || salt.
    //
    //   3.  Hash the value of K.  K = HASH(K)
    //
    //   4.  Iter = Iter - 1.  If Iter is greater than zero.  Goto step 3.
    //
    //   5.  Compute an HMAC as documented in [HMAC].
    //
    //       MAC = HASH( K XOR opad, HASH( K XOR ipad, data) )
    //
    //       Where opad and ipad are defined in [HMAC].
    byte[] pw = Strings.toUTF8ByteArray(password);
    byte[] salt = params.getSalt().getOctets();
    byte[] K = new byte[pw.length + salt.length];

    System.arraycopy(pw, 0, K, 0, pw.length);
    System.arraycopy(salt, 0, K, pw.length, salt.length);

    calculator.setup(params.getOwf(), params.getMac());

    int iter = params.getIterationCount().getValue().intValue();
    do
    {
        K = calculator.calculateDigest(K);
    }
    while (--iter > 0);

    final byte[] key = K;

    return new MacCalculator()
    {
        ByteArrayOutputStream bOut = new ByteArrayOutputStream();

        public AlgorithmIdentifier getAlgorithmIdentifier()
        {
            return new AlgorithmIdentifier(CMPObjectIdentifiers.passwordBasedMac, params);
        }

        public GenericKey getKey()
        {
            return new GenericKey(getAlgorithmIdentifier(), key);
        }

        public OutputStream getOutputStream()
        {
            return bOut;
        }

        public byte[] getMac()
        {
            try
            {
                return calculator.calculateMac(key, bOut.toByteArray());
            }
            catch (CRMFException e)
            {
                throw new RuntimeOperatorException("exception calculating mac: " + e.getMessage(), e);
            }
        }
    };
}
 

import org.bouncycastle.operator.RuntimeOperatorException; //导入依赖的package包/类
public ContentSigner build(AsymmetricKeyParameter privateKey)
    throws OperatorCreationException
{
    final Signer sig = createSigner(sigAlgId, digAlgId);

    if (random != null)
    {
        sig.init(true, new ParametersWithRandom(privateKey, random));
    }
    else
    {
        sig.init(true, privateKey);
    }

    return new ContentSigner()
    {
        private BcSignerOutputStream stream = new BcSignerOutputStream(sig);

        public AlgorithmIdentifier getAlgorithmIdentifier()
        {
            return sigAlgId;
        }

        public OutputStream getOutputStream()
        {
            return stream;
        }

        public byte[] getSignature()
        {
            try
            {
                return stream.getSignature();
            }
            catch (CryptoException e)
            {
                throw new RuntimeOperatorException("exception obtaining signature: " + e.getMessage(), e);
            }
        }
    };
}