generate() — netty Function Reference

Architecture documentation for the generate() function in KeytoolSelfSignedCertGenerator.java from the netty codebase.

Function java Buffer Allocators

Entity Profile

Buffer→ Allocators→ generate() — netty Function Reference

Dependency Diagram

graph TD
  1736d790_bdb1_a678_100c_8a59bd8956c1["generate()"]
  7d93c1db_41b2_7d8c_513d_ce103edd9897["KeytoolSelfSignedCertGenerator"]
  1736d790_bdb1_a678_100c_8a59bd8956c1 -->|defined in| 7d93c1db_41b2_7d8c_513d_ce103edd9897
  style 1736d790_bdb1_a678_100c_8a59bd8956c1 fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

handler/src/main/java/io/netty/handler/ssl/util/KeytoolSelfSignedCertGenerator.java lines 74–141

    static void generate(SelfSignedCertificate.Builder builder) throws IOException, GeneralSecurityException {
        // Change all asterisk to 'x' for file name safety.
        String dirFqdn = builder.fqdn.replaceAll("[^\\w.-]", "x");

        Path directory = Files.createTempDirectory("keytool_" + dirFqdn);
        Path keyStore = directory.resolve("keystore.jks");
        try {
            Process process = new ProcessBuilder()
                    .command(
                            KEYTOOL.toAbsolutePath().toString(),
                            "-genkeypair",
                            "-keyalg", builder.algorithm,
                            "-keysize", String.valueOf(builder.bits),
                            "-startdate", DATE_FORMAT.format(
                                    builder.notBefore.toInstant().atZone(ZoneId.systemDefault())),
                            "-validity", String.valueOf(builder.notBefore.toInstant().until(
                                    builder.notAfter.toInstant(), ChronoUnit.DAYS)),
                            "-keystore", keyStore.toString(),
                            "-alias", ALIAS,
                            "-keypass", PASSWORD,
                            "-storepass", PASSWORD,
                            "-dname", "CN=" + builder.fqdn,
                            "-storetype", KEY_STORE_TYPE
                    )
                    .redirectErrorStream(true)
                    .start();
            try {
                if (!process.waitFor(60, TimeUnit.SECONDS)) {
                    process.destroyForcibly();
                    throw new IOException("keytool timeout");
                }
            } catch (InterruptedException e) {
                process.destroyForcibly();
                Thread.currentThread().interrupt();
                throw new InterruptedIOException();
            }

            if (process.exitValue() != 0) {
                ByteBuf buffer = Unpooled.buffer();
                try {
                    try (InputStream stream = process.getInputStream()) {
                        while (true) {
                            if (buffer.writeBytes(stream, 4096) == -1) {
                                break;
                            }
                        }
                    }
                    String log = buffer.toString(StandardCharsets.UTF_8);
                    throw new IOException("Keytool exited with status " + process.exitValue() + ": " + log);
                } finally {
                    buffer.release();
                }
            }

            KeyStore ks = KeyStore.getInstance(KEY_STORE_TYPE);
            try (InputStream is = Files.newInputStream(keyStore)) {
                ks.load(is, PASSWORD.toCharArray());
            }
            KeyStore.PrivateKeyEntry entry = (KeyStore.PrivateKeyEntry) ks.getEntry(
                    ALIAS, new KeyStore.PasswordProtection(PASSWORD.toCharArray()));
            builder.paths = SelfSignedCertificate.newSelfSignedCertificate(
                    builder.fqdn, entry.getPrivateKey(), (X509Certificate) entry.getCertificate());
            builder.privateKey = entry.getPrivateKey();
        } finally {
            Files.deleteIfExists(keyStore);
            Files.delete(directory);
        }
    }