Examples with Certificate org.shredzone.acme4j.Certificate used on opensource projects

Example 1 with Certificate

use of org.shredzone.acme4j.Certificate in project stdlib by petergeneric.

the class LetsEncryptService method generateOrRenewCertificate.

public LetsEncryptCertificateEntity generateOrRenewCertificate(final String domains) {
    LetsEncryptCertificateEntity entity = getCertificate(domains);
    // If we already have a keypair for these domains we shouldn't regenerate it, only regenerate the cert
    final KeyPair domainKeyPair;
    final boolean isNew;
    try {
        if (entity != null) {
            final ByteArrayInputStream bis = new ByteArrayInputStream(entity.getKeypair());
            final InputStreamReader isr = new InputStreamReader(bis, StandardCharsets.UTF_8);
            domainKeyPair = KeyPairUtils.readKeyPair(isr);
            isNew = false;
        } else {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            OutputStreamWriter osr = new OutputStreamWriter(bos, StandardCharsets.UTF_8);
            domainKeyPair = KeyPairUtils.createKeyPair(DOMAIN_KEY_SIZE);
            KeyPairUtils.writeKeyPair(domainKeyPair, osr);
            entity = new LetsEncryptCertificateEntity();
            entity.setId(domains);
            entity.setKeypair(bos.toByteArray());
            isNew = true;
        }
    } catch (IOException e) {
        throw new RuntimeException("Error serialising/deserialising keypair for domains " + domains, e);
    }
    final Registration registration = getRegistration();
    // Generate a CSR for the domains
    CSRBuilder csrb = new CSRBuilder();
    for (String domain : domains.split(",")) csrb.addDomain(domain);
    try {
        csrb.sign(domainKeyPair);
    } catch (IOException e) {
        throw new RuntimeException("Error signing CSR for " + domains + " with domains keypair!", e);
    }
    // Request a signed certificate
    final Certificate certificate;
    try {
        certificate = registration.requestCertificate(csrb.getEncoded());
        log.info("Success! The certificate for domains " + domains + " has been generated!");
        log.info("Certificate URI: " + certificate.getLocation());
    } catch (IOException e) {
        throw new RuntimeException("Failed to encode CSR request for " + domains, e);
    } catch (AcmeException e) {
        throw new RuntimeException("Failed to request certificate from Let's Encrypt for " + domains, e);
    }
    // Download the certificate
    final X509Certificate cert;
    final X509Certificate[] chain;
    try {
        cert = certificate.download();
        chain = certificate.downloadChain();
    } catch (AcmeException e) {
        throw new RuntimeException("Error downloading certificate information for " + domains + " " + certificate.getLocation(), e);
    }
    // Write certificate only
    final byte[] certBytes;
    try {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        OutputStreamWriter osr = new OutputStreamWriter(bos, StandardCharsets.UTF_8);
        CertificateUtils.writeX509Certificate(cert, osr);
        certBytes = bos.toByteArray();
    } catch (IOException e) {
        throw new RuntimeException("Error serialising Cert for " + domains, e);
    }
    // Write chain only
    byte[] chainBytes;
    try {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        OutputStreamWriter osr = new OutputStreamWriter(bos, StandardCharsets.UTF_8);
        CertificateUtils.writeX509CertificateChain(chain, osr);
        chainBytes = bos.toByteArray();
    } catch (IOException e) {
        throw new RuntimeException("Error serialising Cert for " + domains, e);
    }
    entity.setCert(certBytes);
    entity.setChain(chainBytes);
    entity.setExpires(new DateTime(cert.getNotAfter()));
    // Make sure a management token is assigned
    if (entity.getManagementToken() == null)
        entity.setManagementToken(SimpleId.alphanumeric(32));
    if (isNew) {
        certificateDao.save(entity);
    } else {
        certificateDao.update(entity);
    }
    return entity;
}

Example 2 with Certificate

use of org.shredzone.acme4j.Certificate in project webpieces by deanhiller.

the class AcmeClientProxy method finalizeOrder.

private XFuture<CertAndSigningRequest> finalizeOrder(ProxyOrder proxyOrder, String domain, String organization, KeyPair accountKeyPair) {
    try (StringWriter writer = new StringWriter()) {
        Order order = proxyOrder.getOrder();
        CSRBuilder csrb = new CSRBuilder();
        csrb.addDomain(domain);
        csrb.setOrganization(organization);
        csrb.sign(accountKeyPair);
        byte[] csr = csrb.getEncoded();
        // NEED to store the csr as base64 into the DB!!!
        order.execute(csr);
        while (order.getStatus() != Status.VALID) {
            Thread.sleep(3000L);
            order.update();
        }
        csrb.write(writer);
        Certificate cert = order.getCertificate();
        return XFuture.completedFuture(new CertAndSigningRequest(writer.toString(), cert.getCertificateChain()));
    } catch (AcmeException | IOException | InterruptedException e) {
        throw SneakyThrow.sneak(e);
    }
}

Example 3 with Certificate

use of org.shredzone.acme4j.Certificate in project meecrowave by apache.

the class LetsEncryptReloadLifecycle method run.

@Override
public synchronized void run() {
    final KeyPair userKeyPair = loadOrCreateKeyPair(config.getUserKeySize(), config.getUserKeyLocation());
    final KeyPair domainKeyPair = loadOrCreateKeyPair(config.getDomainKeySize(), config.getDomainKey());
    final Session session = new Session(config.getEndpoint());
    try {
        final Account account = new AccountBuilder().agreeToTermsOfService().useKeyPair(userKeyPair).create(session);
        final Order order = account.newOrder().domains(config.getDomains().trim().split(",")).create();
        final boolean updated = order.getAuthorizations().stream().map(authorization -> {
            try {
                return authorize(authorization);
            } catch (final AcmeException e) {
                getLogger().error(e.getMessage(), e);
                return false;
            }
        }).reduce(false, (previous, val) -> previous || val);
        if (!updated) {
            return;
        }
        final CSRBuilder csrBuilder = new CSRBuilder();
        csrBuilder.addDomains(config.getDomains());
        csrBuilder.sign(domainKeyPair);
        try (final Writer writer = new BufferedWriter(new FileWriter(config.getDomainCertificate()))) {
            csrBuilder.write(writer);
        }
        order.execute(csrBuilder.getEncoded());
        try {
            int attempts = config.getRetryCount();
            while (order.getStatus() != Status.VALID && attempts-- > 0) {
                if (order.getStatus() == Status.INVALID) {
                    throw new AcmeException("Order failed... Giving up.");
                }
                Thread.sleep(config.getRetryTimeoutMs());
                order.update();
            }
        } catch (final InterruptedException ex) {
            getLogger().error(ex.getMessage());
            Thread.currentThread().interrupt();
            return;
        }
        final Certificate certificate = order.getCertificate();
        getLogger().info("Got new certificate " + certificate.getLocation() + " for domain(s) " + config.getDomains());
        try (final Writer writer = new BufferedWriter(new FileWriter(config.getDomainChain()))) {
            certificate.writeCertificate(writer);
        }
        protocol.reloadSslHostConfigs();
    } catch (final AcmeException | IOException ex) {
        getLogger().error(ex.getMessage(), ex);
    }
}