import org.bouncycastle.operator.SignatureAlgorithmIdentifierFinder; //导入依赖的package包/类
/**
 * return the collection of signers that are associated with the
 * signatures for the message.
 */
public SignerInformationStore getSignerInfos()
{
    if (signerInfoStore == null)
    {
        ASN1Set         s = signedData.getSignerInfos();
        List            signerInfos = new ArrayList();
        SignatureAlgorithmIdentifierFinder sigAlgFinder = new DefaultSignatureAlgorithmIdentifierFinder();

        for (int i = 0; i != s.size(); i++)
        {
            SignerInfo info = SignerInfo.getInstance(s.getObjectAt(i));
            ASN1ObjectIdentifier contentType = signedData.getEncapContentInfo().getContentType();

            if (hashes == null)
            {
                signerInfos.add(new SignerInformation(info, contentType, signedContent, null));
            }
            else
            {
                Object obj = hashes.keySet().iterator().next();
                byte[] hash = (obj instanceof String) ? (byte[])hashes.get(info.getDigestAlgorithm().getAlgorithm().getId()) : (byte[])hashes.get(info.getDigestAlgorithm().getAlgorithm());

                signerInfos.add(new SignerInformation(info, contentType, null, hash));
            }
        }

        signerInfoStore = new SignerInformationStore(signerInfos);
    }

    return signerInfoStore;
}
 

import org.bouncycastle.operator.SignatureAlgorithmIdentifierFinder; //导入依赖的package包/类
public BcRSASignerInfoVerifierBuilder(CMSSignatureAlgorithmNameGenerator sigAlgNameGen, SignatureAlgorithmIdentifierFinder sigAlgIdFinder, DigestAlgorithmIdentifierFinder digestAlgorithmFinder, DigestCalculatorProvider digestCalculatorProvider)
{
    this.sigAlgNameGen = sigAlgNameGen;
    this.sigAlgIdFinder = sigAlgIdFinder;
    this.contentVerifierProviderBuilder = new BcRSAContentVerifierProviderBuilder(digestAlgorithmFinder);
    this.digestCalculatorProvider = digestCalculatorProvider;
}
 

import org.bouncycastle.operator.SignatureAlgorithmIdentifierFinder; //导入依赖的package包/类
public SignerInformationVerifier(CMSSignatureAlgorithmNameGenerator sigNameGenerator, SignatureAlgorithmIdentifierFinder sigAlgorithmFinder, ContentVerifierProvider verifierProvider, DigestCalculatorProvider digestProvider)
{
    this.sigNameGenerator = sigNameGenerator;
    this.sigAlgorithmFinder = sigAlgorithmFinder;
    this.verifierProvider = verifierProvider;
    this.digestProvider = digestProvider;
}
 

import org.bouncycastle.operator.SignatureAlgorithmIdentifierFinder; //导入依赖的package包/类
public JcaSignerInfoVerifierBuilder setSignatureAlgorithmFinder(SignatureAlgorithmIdentifierFinder sigAlgIDFinder)
{
    this.sigAlgIDFinder = sigAlgIDFinder;

    return this;
}
 

import org.bouncycastle.operator.SignatureAlgorithmIdentifierFinder; //导入依赖的package包/类
/**
 * Read the pkcs#10 CSR pem text and create a BC CSR object for subsequent
 * verifying and manipulation. This test uses bcprov-jdk15on-1.50.jar and
 * bcpkix-jdk15on-1.50.jar
 *
 * @throws Exception
 */
@Test
public void testCreateCsrFromPemV2_bcprov_jdk15on_1_50() throws Exception {
    SignatureAlgorithmIdentifierFinder algFinder = new DefaultSignatureAlgorithmIdentifierFinder();
    String csrPemStr = this.getCsrIrregularOrderDN();

    PemReader pemReader = new PemReader(new StringReader(csrPemStr));
    PemObject obj = pemReader.readPemObject();
    pemReader.close();
    byte[] pembytes = obj.getContent();
    PKCS10CertificationRequest req = new PKCS10CertificationRequest(pembytes);

    assertEquals("CN=some body,C=UK,L=DL,O=eScience,OU=CLRC", req.getSubject().toString());
    //System.out.println(req.getSubject().toString());
    SubjectPublicKeyInfo pkInfo = req.getSubjectPublicKeyInfo();

    // get the algorithm of the pubkey RSA  
    AlgorithmIdentifier pubKeyAlgId = pkInfo.getAlgorithm();
    //System.out.println(pubKeyAlgId.getAlgorithm().getId());   // 1.2.840.113549.1.1.1
    //System.out.println(pubKeyAlgId.getAlgorithm().toString());// 1.2.840.113549.1.1.1
    assertEquals("1.2.840.113549.1.1.1", pubKeyAlgId.getAlgorithm().getId());

    // get the algorithm of the request (we expect SHA1 with RSA)  
    AlgorithmIdentifier reqSigAlgId = req.getSignatureAlgorithm();
    AlgorithmIdentifier algIdExpected = algFinder.find("SHA1WITHRSAENCRYPTION"); // or "SHA1withRSA", "SHA1withRSAEncryption" 
    assertEquals(reqSigAlgId.getAlgorithm().getId(), algIdExpected.getAlgorithm().getId());
    assertEquals("1.2.840.113549.1.1.5", algIdExpected.getAlgorithm().getId());

    // Get java.security.PublicKey so we can validate and get the DB formatted pub key  
    // Looks like we can get the public key in two ways: 
    //
    // 1) 
    //http://stackoverflow.com/questions/11028932/how-to-get-publickey-from-pkcs10certificationrequest-using-new-bouncy-castle-lib
    RSAKeyParameters rsa = (RSAKeyParameters) PublicKeyFactory.createKey(pkInfo);
    assertEquals(2048, rsa.getModulus().bitLength());
    RSAPublicKeySpec rsaSpec = new RSAPublicKeySpec(rsa.getModulus(), rsa.getExponent());
    KeyFactory kf = KeyFactory.getInstance("RSA");
    PublicKey pubKey1 = kf.generatePublic(rsaSpec);
    String pubkey1DBFormat = getDBFormattedRSAPublicKey(pubKey1);
    boolean valid = req.isSignatureValid((new JcaContentVerifierProviderBuilder()).build(pubKey1));
    assertTrue(valid);
    //
    // 2) 
    JcaPKCS10CertificationRequest jcaReq = new JcaPKCS10CertificationRequest(req);
    PublicKey pubKey2 = jcaReq.getPublicKey();
    RSAPublicKey rsa2 = (RSAPublicKey) pubKey2;
    assertEquals(2048, rsa2.getModulus().bitLength());

    String pubkey2DBFormat = getDBFormattedRSAPublicKey(pubKey2);
    assertTrue(jcaReq.isSignatureValid((new JcaContentVerifierProviderBuilder()).build(pubKey2)));

    // Test that the two DB formated pubkeys are the same 
    assertEquals(pubkey1DBFormat, pubkey2DBFormat);

}
 

import org.bouncycastle.operator.SignatureAlgorithmIdentifierFinder; //导入依赖的package包/类
@Test
public void testPythonSigned() throws Exception {
    final InputStream pythonIs = Thread.currentThread().getContextClassLoader().getResourceAsStream("python_signed.txt");

  /*
  Message message = new Message(pythonIs);
  Multipart multipart = (Multipart)message.getBody();
  System.out.println("count: " + multipart.getCount());
  */

    ByteArrayDataSource ds = new ByteArrayDataSource(pythonIs, "multipart/signed");
    MimeMultipart mm = new MimeMultipart(ds);

    System.out.println(mm.getContentType());

    System.out.println("Multipart.count(): " + mm.getCount());

    MimeBodyPart mbp = (MimeBodyPart) mm.getBodyPart(0);

    output(mbp);

    SMIMESigned signed = new SMIMESigned(mm);

    SignerInformationStore signers = signed.getSignerInfos();
    Assert.assertEquals(1, signers.size());
    SignerInformation signer = (SignerInformation) signers.getSigners().iterator().next();


    final CMSSignatureAlgorithmNameGenerator cmsSignatureAlgorithmNameGenerator = new DefaultCMSSignatureAlgorithmNameGenerator();
    final SignatureAlgorithmIdentifierFinder signatureAlgorithmIdentifierFinder = new DefaultSignatureAlgorithmIdentifierFinder();
    final JcaContentVerifierProviderBuilder jcaContentVerifierProviderBuilder = new JcaContentVerifierProviderBuilder();
    final ContentVerifierProvider contentVerifierProvider = jcaContentVerifierProviderBuilder.build(cert.getPublicKey());
    final DigestCalculatorProvider digestCalculatorProvider = new BcDigestCalculatorProvider();

    SignerInformationVerifier verifier = new SignerInformationVerifier(
            cmsSignatureAlgorithmNameGenerator,
            signatureAlgorithmIdentifierFinder,
            contentVerifierProvider,
            digestCalculatorProvider);

    Assert.assertTrue(signer.verify(verifier));
}