Example usage for org.bouncycastle.pkcs PKCS10CertificationRequest getSubjectPublicKeyInfo

Introduction

In this page you can find the example usage for org.bouncycastle.pkcs PKCS10CertificationRequest getSubjectPublicKeyInfo.

Prototype

public SubjectPublicKeyInfo getSubjectPublicKeyInfo() 

Source Link

Document

Return the SubjectPublicKeyInfo describing the public key this request is carrying.

Usage

From source file:net.jmhertlein.mcanalytics.api.auth.SSLUtil.java

License:Open Source License

/**
 * Given a certificate signing request, produce a signed certificate.
 *
 * @param caKey//from w  ww .  j  a va2s.  c  o m
 * @param caCert
 * @param r
 * @param makeAuthority
 * @return
 */
public static X509Certificate fulfillCertRequest(PrivateKey caKey, X509Certificate caCert,
        PKCS10CertificationRequest r, boolean makeAuthority) {
    X509v3CertificateBuilder b = new JcaX509v3CertificateBuilder(new X500Name(caCert.getSubjectDN().getName()), // the order of O,OU,CN returned is very important
            BigInteger.probablePrime(128, new SecureRandom()), Date.from(Instant.now().minusSeconds(1)),
            Date.from(LocalDateTime.now().plusYears(3).toInstant(ZoneOffset.UTC)), r.getSubject(),
            getPublicKeyFromInfo(r.getSubjectPublicKeyInfo()));

    try {
        b.addExtension(Extension.basicConstraints, true, new BasicConstraints(makeAuthority));
    } catch (CertIOException ex) {
        Logger.getLogger(SSLUtil.class.getName()).log(Level.SEVERE, null, ex);
    }

    try {
        ContentSigner signer = new JcaContentSignerBuilder(SIGNING_ALGORITHM).setProvider("BC").build(caKey);
        X509CertificateHolder build = b.build(signer);
        return new JcaX509CertificateConverter().setProvider("BC").getCertificate(build);
    } catch (OperatorCreationException | CertificateException ex) {
        Logger.getLogger(SSLUtil.class.getName()).log(Level.SEVERE, null, ex);
        return null;
    }
}

---

From source file:net.sf.portecle.crypto.X509CertUtil.java

License:Open Source License

/**
 * Load a CSR from the specified URL.//w  w w  .  j  av a 2 s .c  om
 * 
 * @param url The URL to load CSR from
 * @return The CSR
 * @throws CryptoException Problem encountered while loading the CSR
 * @throws FileNotFoundException If the CSR file does not exist, is a directory rather than a regular
 *             file, or for some other reason cannot be opened for reading
 * @throws IOException An I/O error occurred
 */
public static PKCS10CertificationRequest loadCSR(URL url) throws CryptoException, IOException {
    // TODO: handle DER encoded requests too?
    try (PEMParser pr = new PEMParser(new InputStreamReader(NetUtil.openGetStream(url)))) {
        PKCS10CertificationRequest csr = (PKCS10CertificationRequest) pr.readObject();
        ContentVerifierProvider prov = new JcaContentVerifierProviderBuilder()
                .build(csr.getSubjectPublicKeyInfo());

        if (!csr.isSignatureValid(prov)) {
            throw new CryptoException(RB.getString("NoVerifyCsr.exception.message"));
        }

        return csr;
    } catch (ClassCastException | OperatorCreationException | PKCSException ex) {
        throw new CryptoException(RB.getString("NoLoadCsr.exception.message"), ex);
    }
}

---

From source file:net.solarnetwork.node.setup.test.PKITestUtils.java

License:Open Source License

public static X509Certificate sign(PKCS10CertificationRequest csr, X509Certificate issuer,
        PrivateKey issuerPrivateKey)
        throws InvalidKeyException, NoSuchAlgorithmException, NoSuchProviderException, SignatureException,
        IOException, OperatorCreationException, CertificateException, java.security.cert.CertificateException {

    final BigInteger serial = getNextSerialNumber();
    final Date notBefore = new Date();
    final Date notAfter = new Date(System.currentTimeMillis() + 24L * 60L * 60L * 1000L);

    X500Name issuerName = JcaX500NameUtil.getSubject(issuer);
    X509v3CertificateBuilder myCertificateGenerator = new X509v3CertificateBuilder(issuerName, serial,
            notBefore, notAfter, csr.getSubject(), csr.getSubjectPublicKeyInfo());

    JcaContentSignerBuilder signerBuilder = new JcaContentSignerBuilder("SHA256WithRSA");
    ContentSigner signer = signerBuilder.build(issuerPrivateKey);
    X509CertificateHolder holder = myCertificateGenerator.build(signer);

    JcaX509CertificateConverter converter = new JcaX509CertificateConverter();
    return converter.getCertificate(holder);
}

---

From source file:net.solarnetwork.pki.bc.BCCertificateService.java

License:Open Source License

@Override
public X509Certificate signCertificate(String csrPEM, X509Certificate caCert, PrivateKey privateKey)
        throws CertificateException {
    if (!csrPEM.matches("(?is)^\\s*-----BEGIN.*")) {
        // let's throw in the guards
        csrPEM = "-----BEGIN CERTIFICATE REQUEST-----\n" + csrPEM + "\n-----END CERTIFICATE REQUEST-----\n";
    }//  ww w .j a v  a2  s  . c om
    PemReader reader = null;
    try {
        reader = new PemReader(new StringReader(csrPEM));
        PemObject pemObj = reader.readPemObject();
        log.debug("Parsed PEM type {}", pemObj.getType());
        PKCS10CertificationRequest csr = new PKCS10CertificationRequest(pemObj.getContent());

        Date now = new Date();
        Date expire = new Date(now.getTime() + (1000L * 60L * 60L * 24L * certificateExpireDays));
        X509v3CertificateBuilder builder = new X509v3CertificateBuilder(JcaX500NameUtil.getIssuer(caCert),
                new BigInteger(String.valueOf(counter.incrementAndGet())), now, expire, csr.getSubject(),
                csr.getSubjectPublicKeyInfo());

        JcaContentSignerBuilder signerBuilder = new JcaContentSignerBuilder(signatureAlgorithm);
        ContentSigner signer;
        DefaultDigestAlgorithmIdentifierFinder digestAlgFinder = new DefaultDigestAlgorithmIdentifierFinder();
        try {
            DigestCalculatorProvider digestCalcProvider = new JcaDigestCalculatorProviderBuilder()
                    .setProvider(new BouncyCastleProvider()).build();
            JcaX509ExtensionUtils extUtils = new JcaX509ExtensionUtils(
                    digestCalcProvider.get(digestAlgFinder.find("SHA-256")));
            builder.addExtension(X509Extension.basicConstraints, false, new BasicConstraints(false));
            builder.addExtension(X509Extension.subjectKeyIdentifier, false,
                    extUtils.createSubjectKeyIdentifier(csr.getSubjectPublicKeyInfo()));
            builder.addExtension(X509Extension.authorityKeyIdentifier, false,
                    extUtils.createAuthorityKeyIdentifier(caCert));

            signer = signerBuilder.build(privateKey);
        } catch (OperatorException e) {
            log.error("Error signing CSR {}", csr.getSubject(), e);
            throw new CertificateException("Error signing CSR" + csr.getSubject() + ": " + e.getMessage());
        } catch (CertificateEncodingException e) {
            log.error("Error signing CSR {}", csr.getSubject().toString(), e);
            throw new CertificateException("Error signing CSR" + csr.getSubject() + ": " + e.getMessage());
        }

        X509CertificateHolder holder = builder.build(signer);
        JcaX509CertificateConverter converter = new JcaX509CertificateConverter();
        try {
            return converter.getCertificate(holder);
        } catch (java.security.cert.CertificateException e) {
            throw new CertificateException("Error creating certificate", e);
        }
    } catch (IOException e) {
        throw new CertificateException("Error signing CSR", e);
    } finally {
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e2) {
                log.warn("IOException closing PemReader", e2);
            }
        }
    }
}

---

From source file:org.signserver.server.cryptotokens.CryptoTokenTestBase.java

License:Open Source License

protected void importCertificateChainHelper(final String existingKey) throws NoSuchAlgorithmException,
        NoSuchProviderException, OperatorCreationException, IOException, CertificateException,
        CryptoTokenOfflineException, IllegalArgumentException, CertificateEncodingException,
        OperationUnsupportedException, InvalidWorkerIdException, SignServerException {
    final String additionalAlias = "additionalKey";

    try {//from   w  w  w .  j  av  a  2 s.  c  o  m
        final ISignerCertReqInfo req = new PKCS10CertReqInfo("SHA1WithRSA", "CN=imported", null);
        Base64SignerCertReqData reqData = (Base64SignerCertReqData) genCertificateRequest(req, false,
                existingKey);

        // Issue certificate
        PKCS10CertificationRequest csr = new PKCS10CertificationRequest(
                Base64.decode(reqData.getBase64CertReq()));
        KeyPair issuerKeyPair = CryptoUtils.generateRSA(512);
        final X509CertificateHolder cert = new X509v3CertificateBuilder(new X500Name("CN=Test Issuer"),
                BigInteger.ONE, new Date(), new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(365)),
                csr.getSubject(), csr.getSubjectPublicKeyInfo())
                        .build(new JcaContentSignerBuilder("SHA256WithRSA").setProvider("BC")
                                .build(issuerKeyPair.getPrivate()));

        // import certficate chain
        importCertificateChain(Arrays.asList(CertTools.getCertfromByteArray(cert.getEncoded())), existingKey);

        List<Certificate> chain = getCertificateChain(existingKey);

        assertEquals("Number of certs", 1, chain.size());

        Certificate foundCert = chain.get(0);

        assertTrue("Imported cert", Arrays.equals(foundCert.getEncoded(), cert.getEncoded()));

        generateKey("RSA", "1024", additionalAlias);

        // Isse additional certificate
        reqData = (Base64SignerCertReqData) genCertificateRequest(req, false, additionalAlias);

        csr = new PKCS10CertificationRequest(Base64.decode(reqData.getBase64CertReq()));
        issuerKeyPair = CryptoUtils.generateRSA(512);
        final X509CertificateHolder newCert = new X509v3CertificateBuilder(new X500Name("CN=Test Issuer2"),
                BigInteger.ONE, new Date(), new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(365)),
                csr.getSubject(), csr.getSubjectPublicKeyInfo())
                        .build(new JcaContentSignerBuilder("SHA256WithRSA").setProvider("BC")
                                .build(issuerKeyPair.getPrivate()));

        // import certficate chain
        importCertificateChain(Arrays.asList(CertTools.getCertfromByteArray(newCert.getEncoded())),
                additionalAlias);

        // check that previously imported cert chain is un-affected
        chain = getCertificateChain(existingKey);

        assertEquals("Number of certs", 1, chain.size());

        foundCert = chain.get(0);

        assertTrue("Imported cert", Arrays.equals(foundCert.getEncoded(), cert.getEncoded()));

        // Test that it is not allowed to import a certificate for
        // an other key
        try {
            final List<Certificate> chainForExistingKey = chain;
            final String aliasForAnOtherKey = additionalAlias;
            importCertificateChain(chainForExistingKey, aliasForAnOtherKey);
            fail("Should have thrown exception about the key not matching");
        } catch (CryptoTokenOfflineException expected) {
            assertTrue("ex: " + expected.getMessage(), expected.getMessage().contains("does not match"));
        }

    } finally {
        try {
            destroyKey(additionalAlias);
        } catch (KeyStoreException ex) {
            LOG.error("Failed to remove additional key");
        }
    }
}

---

From source file:org.signserver.server.cryptotokens.CryptoTokenTestBase.java

License:Open Source License

/**
 * Tests export of certificate chain. First imports a generate certificate
 * chain and then checks that it can be read back. Then imports an other
 * chain and checks again.//from w ww  .  jav a  2 s .c  o m
 * @param existingKey entry to use
 */
protected void exportCertificatesHelper(final String existingKey)
        throws CryptoTokenOfflineException, KeyStoreException, InvalidWorkerIdException, SignServerException,
        IllegalArgumentException, CertificateException, CertificateEncodingException,
        OperationUnsupportedException, NoSuchAlgorithmException, NoSuchProviderException,
        OperatorCreationException, IOException, QueryException, OperationUnsupportedException,
        AuthorizationDeniedException, InvalidAlgorithmParameterException, UnsupportedCryptoTokenParameter {

    final ISignerCertReqInfo req = new PKCS10CertReqInfo("SHA1WithRSA", "CN=imported", null);
    final Base64SignerCertReqData reqData = (Base64SignerCertReqData) genCertificateRequest(req, false,
            existingKey);

    // Generate a certificate chain that we will try to import and later export
    KeyPair issuerKeyPair = CryptoUtils.generateRSA(512);
    final X509CertificateHolder issuerCert = new JcaX509v3CertificateBuilder(
            new X500Name("CN=Test Import/Export CA"), BigInteger.ONE, new Date(),
            new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(3650)),
            new X500Name("CN=Test Import/Export CA"), issuerKeyPair.getPublic())
                    .build(new JcaContentSignerBuilder("SHA256WithRSA").setProvider("BC")
                            .build(issuerKeyPair.getPrivate()));
    PKCS10CertificationRequest csr = new PKCS10CertificationRequest(Base64.decode(reqData.getBase64CertReq()));
    final X509CertificateHolder subjectCert1 = new X509v3CertificateBuilder(
            new X500Name("CN=Test Import/Export CA"), BigInteger.ONE, new Date(),
            new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(365)),
            new X500Name("CN=Test Import/Export 1"), csr.getSubjectPublicKeyInfo())
                    .build(new JcaContentSignerBuilder("SHA256WithRSA").setProvider("BC")
                            .build(issuerKeyPair.getPrivate()));
    final X509CertificateHolder subjectCert2 = new X509v3CertificateBuilder(
            new X500Name("CN=Test Import/Export CA"), BigInteger.ONE, new Date(),
            new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(365)),
            new X500Name("CN=Test Import/Export 2"), csr.getSubjectPublicKeyInfo())
                    .build(new JcaContentSignerBuilder("SHA256WithRSA").setProvider("BC")
                            .build(issuerKeyPair.getPrivate()));

    // Import certficate chain 1
    importCertificateChain(Arrays.asList(CertTools.getCertfromByteArray(subjectCert1.getEncoded()),
            CertTools.getCertfromByteArray(issuerCert.getEncoded())), existingKey);

    // Find the entry
    TokenSearchResults searchResults = searchTokenEntries(0, Integer.MAX_VALUE, QueryCriteria.create()
            .add(new Term(RelationalOperator.EQ, CryptoTokenHelper.TokenEntryFields.alias.name(), existingKey)),
            true);
    LinkedList<String> aliases = new LinkedList<String>();
    for (TokenEntry entry : searchResults.getEntries()) {
        aliases.add(entry.getAlias());
    }
    assertArrayEquals(new String[] { existingKey }, aliases.toArray());
    TokenEntry entry = searchResults.getEntries().iterator().next();
    Certificate[] parsedChain = entry.getParsedChain();

    assertEquals("right subject",
            new JcaX509CertificateConverter().getCertificate(subjectCert1).getSubjectX500Principal().getName(),
            ((X509Certificate) parsedChain[0]).getSubjectX500Principal().getName());
    assertEquals("right issuer",
            new JcaX509CertificateConverter().getCertificate(issuerCert).getSubjectX500Principal().getName(),
            ((X509Certificate) parsedChain[1]).getSubjectX500Principal().getName());

    // Import certificate chain 2
    importCertificateChain(Arrays.asList(CertTools.getCertfromByteArray(subjectCert2.getEncoded()),
            CertTools.getCertfromByteArray(issuerCert.getEncoded())), existingKey);

    // Find the entry
    searchResults = searchTokenEntries(0, Integer.MAX_VALUE, QueryCriteria.create()
            .add(new Term(RelationalOperator.EQ, CryptoTokenHelper.TokenEntryFields.alias.name(), existingKey)),
            true);
    entry = searchResults.getEntries().iterator().next();
    parsedChain = entry.getParsedChain();

    assertEquals("right subject",
            new JcaX509CertificateConverter().getCertificate(subjectCert2).getSubjectX500Principal().getName(),
            ((X509Certificate) parsedChain[0]).getSubjectX500Principal().getName());
    assertEquals("right issuer",
            new JcaX509CertificateConverter().getCertificate(issuerCert).getSubjectX500Principal().getName(),
            ((X509Certificate) parsedChain[1]).getSubjectX500Principal().getName());
}

---

From source file:org.signserver.server.cryptotokens.KeystoreCryptoTokenTestBase.java

License:Open Source License

protected void cmsSigner(final int workerId, final boolean expectActive) throws Exception {
    // Generate CSR
    PKCS10CertReqInfo certReqInfo = new PKCS10CertReqInfo("SHA1WithRSA", "CN=Worker" + workerId, null);
    Base64SignerCertReqData reqData = (Base64SignerCertReqData) getWorkerSession()
            .getCertificateRequest(workerId, certReqInfo, false);

    // Issue certificate
    PKCS10CertificationRequest csr = new PKCS10CertificationRequest(Base64.decode(reqData.getBase64CertReq()));
    KeyPair issuerKeyPair = CryptoUtils.generateRSA(512);
    X509CertificateHolder cert = new X509v3CertificateBuilder(new X500Name("CN=TestP11 Issuer"), BigInteger.ONE,
            new Date(), new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(365)), csr.getSubject(),
            csr.getSubjectPublicKeyInfo())
                    .build(new JcaContentSignerBuilder("SHA256WithRSA").setProvider("BC")
                            .build(issuerKeyPair.getPrivate()));

    // Install certificate and chain
    workerSession.uploadSignerCertificate(workerId, cert.getEncoded(), GlobalConfiguration.SCOPE_GLOBAL);
    workerSession.uploadSignerCertificateChain(workerId, Arrays.asList(cert.getEncoded()),
            GlobalConfiguration.SCOPE_GLOBAL);
    workerSession.reloadConfiguration(workerId);

    if (expectActive) {
        // Test active
        List<String> errors = workerSession.getStatus(workerId).getFatalErrors();
        assertEquals("errors: " + errors, 0, errors.size());
    }/*from  w  w  w .  j  ava  2s.  co  m*/

    // Test signing
    signGenericDocument(workerId, "Sample data".getBytes());
}

---

From source file:org.signserver.server.cryptotokens.P11SignTest.java

License:Open Source License

private void pdfSignerTest() throws Exception {
    // Generate CSR
    PKCS10CertReqInfo certReqInfo = new PKCS10CertReqInfo("SHA1WithRSA", "CN=Worker" + WORKER_PDF, null);
    Base64SignerCertReqData reqData = (Base64SignerCertReqData) getWorkerSession()
            .getCertificateRequest(WORKER_PDF, certReqInfo, false);

    // Issue certificate
    PKCS10CertificationRequest csr = new PKCS10CertificationRequest(Base64.decode(reqData.getBase64CertReq()));
    KeyPair issuerKeyPair = CryptoUtils.generateRSA(512);
    X509CertificateHolder cert = new X509v3CertificateBuilder(new X500Name("CN=TestP11 Issuer"), BigInteger.ONE,
            new Date(), new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(365)), csr.getSubject(),
            csr.getSubjectPublicKeyInfo())
                    .build(new JcaContentSignerBuilder("SHA256WithRSA").setProvider("BC")
                            .build(issuerKeyPair.getPrivate()));

    // Install certificate and chain
    workerSession.uploadSignerCertificate(WORKER_PDF, cert.getEncoded(), GlobalConfiguration.SCOPE_GLOBAL);
    workerSession.uploadSignerCertificateChain(WORKER_PDF, Arrays.asList(cert.getEncoded()),
            GlobalConfiguration.SCOPE_GLOBAL);
    workerSession.reloadConfiguration(WORKER_PDF);

    // Test active
    List<String> errors = workerSession.getStatus(WORKER_PDF).getFatalErrors();
    assertEquals("errors: " + errors, 0, errors.size());

    // Test signing
    signGenericDocument(WORKER_PDF, readFile(pdfSampleFile));
}

---

From source file:org.signserver.server.cryptotokens.P11SignTest.java

License:Open Source License

private void tsSigner() throws Exception {
    // Generate CSR
    PKCS10CertReqInfo certReqInfo = new PKCS10CertReqInfo("SHA1WithRSA", "CN=Worker" + WORKER_TSA, null);
    Base64SignerCertReqData reqData = (Base64SignerCertReqData) getWorkerSession()
            .getCertificateRequest(WORKER_TSA, certReqInfo, false);

    // Issue certificate
    PKCS10CertificationRequest csr = new PKCS10CertificationRequest(Base64.decode(reqData.getBase64CertReq()));
    KeyPair issuerKeyPair = CryptoUtils.generateRSA(512);
    X509CertificateHolder cert = new X509v3CertificateBuilder(new X500Name("CN=TestP11 Issuer"), BigInteger.ONE,
            new Date(), new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(365)), csr.getSubject(),
            csr.getSubjectPublicKeyInfo())
                    .addExtension(org.bouncycastle.asn1.x509.X509Extension.extendedKeyUsage, true,
                            new ExtendedKeyUsage(KeyPurposeId.id_kp_timeStamping))
                    .build(new JcaContentSignerBuilder("SHA256WithRSA").setProvider("BC")
                            .build(issuerKeyPair.getPrivate()));

    // Install certificate and chain
    workerSession.uploadSignerCertificate(WORKER_TSA, cert.getEncoded(), GlobalConfiguration.SCOPE_GLOBAL);
    workerSession.uploadSignerCertificateChain(WORKER_TSA, Arrays.asList(cert.getEncoded()),
            GlobalConfiguration.SCOPE_GLOBAL);
    workerSession.reloadConfiguration(WORKER_TSA);

    // Test active
    List<String> errors = workerSession.getStatus(WORKER_TSA).getFatalErrors();
    assertEquals("errors: " + errors, 0, errors.size());

    // Test signing
    TimeStampRequestGenerator timeStampRequestGenerator = new TimeStampRequestGenerator();
    TimeStampRequest timeStampRequest = timeStampRequestGenerator.generate(TSPAlgorithms.SHA1, new byte[20],
            BigInteger.valueOf(100));
    byte[] requestBytes = timeStampRequest.getEncoded();
    GenericSignRequest signRequest = new GenericSignRequest(567, requestBytes);
    final GenericSignResponse res = (GenericSignResponse) workerSession.process(WORKER_TSA, signRequest,
            new RequestContext());
    Certificate signercert = res.getSignerCertificate();
    assertNotNull(signercert);/* w ww .  j  ava2  s  . co  m*/
    final TimeStampResponse timeStampResponse = new TimeStampResponse((byte[]) res.getProcessedData());
    timeStampResponse.validate(timeStampRequest);

    assertEquals("Token granted", PKIStatus.GRANTED, timeStampResponse.getStatus());
    assertNotNull("Got timestamp token", timeStampResponse.getTimeStampToken());
}

---

From source file:org.signserver.server.cryptotokens.P11SignTest.java

License:Open Source License

private void mrtdsodSigner(final int workerId) throws Exception {
    // Generate CSR
    PKCS10CertReqInfo certReqInfo = new PKCS10CertReqInfo("SHA1WithRSA", "CN=Worker" + workerId, null);
    Base64SignerCertReqData reqData = (Base64SignerCertReqData) getWorkerSession()
            .getCertificateRequest(workerId, certReqInfo, false);

    // Issue certificate
    PKCS10CertificationRequest csr = new PKCS10CertificationRequest(Base64.decode(reqData.getBase64CertReq()));
    KeyPair issuerKeyPair = CryptoUtils.generateRSA(512);
    X509CertificateHolder issuerCert = new JcaX509v3CertificateBuilder(new X500Name("CN=TestP11 Issuer"),
            BigInteger.ONE, new Date(), new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(365)),
            new X500Name("CN=TestP11 Issuer"), issuerKeyPair.getPublic())
                    .build(new JcaContentSignerBuilder("SHA256WithRSA").setProvider("BC")
                            .build(issuerKeyPair.getPrivate()));
    X509CertificateHolder cert = new X509v3CertificateBuilder(new X500Name("CN=TestP11 Issuer"), BigInteger.ONE,
            new Date(), new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(365)), csr.getSubject(),
            csr.getSubjectPublicKeyInfo())
                    .build(new JcaContentSignerBuilder("SHA256WithRSA").setProvider("BC")
                            .build(issuerKeyPair.getPrivate()));

    // Install certificate and chain
    workerSession.uploadSignerCertificate(workerId, cert.getEncoded(), GlobalConfiguration.SCOPE_GLOBAL);
    workerSession.uploadSignerCertificateChain(workerId,
            Arrays.asList(cert.getEncoded(), issuerCert.getEncoded()), GlobalConfiguration.SCOPE_GLOBAL);
    workerSession.reloadConfiguration(workerId);

    // Test active
    List<String> errors = workerSession.getStatus(workerId).getFatalErrors();
    assertEquals("errors: " + errors, 0, errors.size());

    // Test signing
    HashMap<Integer, byte[]> dgs = new HashMap<Integer, byte[]>();
    dgs.put(1, "Yy==".getBytes());
    dgs.put(2, "Yy==".getBytes());
    dgs.put(3, "Yy==".getBytes());
    final SODSignRequest signRequest = new SODSignRequest(233, dgs);
    final SODSignResponse res = (SODSignResponse) workerSession.process(workerId, signRequest,
            new RequestContext());
    Certificate signercert = res.getSignerCertificate();
    assertNotNull(signercert);/*from w ww. j  a v a  2  s. c om*/
}

---

• «
• 1
• 2
• 3
• 4
• »