How to Enable Https In Spring Boot?

16 minutes read

To enable HTTPS in a Spring Boot application, you need to perform the following steps:

  1. Generate or obtain an SSL certificate: You can either generate a self-signed certificate or obtain one from a trusted certificate authority (CA).
  2. Include the certificate in the application's keystore: Spring Boot uses a keystore file to store certificates. You need to include the SSL certificate in this keystore.
  3. Configure the application.properties file: Add the following properties to the application.properties file: server.port=8443 server.ssl.enabled=true server.ssl.key-store-type=PKCS12 server.ssl.key-store=classpath:keystore.p12 server.ssl.key-store-password=your-password server.ssl.key-password=your-password Replace your-password with the password for your keystore.
  4. Set up a redirect from HTTP to HTTPS (optional): If you want to redirect HTTP requests to HTTPS, add the following property: server.port=8080 server.ssl.redirect.enabled=true
  5. Run the Spring Boot application: Once you have made the necessary configuration changes, start the Spring Boot application. It will now listen for HTTPS requests on port 8443.


These steps enable HTTPS in a Spring Boot application. You can then access your application using the https:// protocol with the appropriate port.

Best Spring Boot Books to Read in May 2024

1
Full Stack Development with Spring Boot and React: Build modern and scalable web applications using the power of Java and React, 3rd Edition

Rating is 5 out of 5

Full Stack Development with Spring Boot and React: Build modern and scalable web applications using the power of Java and React, 3rd Edition

2
Spring Boot Persistence Best Practices: Optimize Java Persistence Performance in Spring Boot Applications

Rating is 4.9 out of 5

Spring Boot Persistence Best Practices: Optimize Java Persistence Performance in Spring Boot Applications

3
Spring Boot in Action

Rating is 4.8 out of 5

Spring Boot in Action

4
Spring Boot: Up and Running: Building Cloud Native Java and Kotlin Applications

Rating is 4.7 out of 5

Spring Boot: Up and Running: Building Cloud Native Java and Kotlin Applications

5
Learning Spring Boot 3.0: Simplify the development of production-grade applications using Java and Spring, 3rd Edition

Rating is 4.6 out of 5

Learning Spring Boot 3.0: Simplify the development of production-grade applications using Java and Spring, 3rd Edition

6
Spring in Action, Sixth Edition

Rating is 4.5 out of 5

Spring in Action, Sixth Edition

7
Modern API Development with Spring and Spring Boot: Design highly scalable and maintainable APIs with REST, gRPC, GraphQL, and the reactive paradigm

Rating is 4.4 out of 5

Modern API Development with Spring and Spring Boot: Design highly scalable and maintainable APIs with REST, gRPC, GraphQL, and the reactive paradigm

8
Spring Boot and Angular: Hands-on full stack web development with Java, Spring, and Angular

Rating is 4.3 out of 5

Spring Boot and Angular: Hands-on full stack web development with Java, Spring, and Angular


How does Spring Boot handle HTTPS?

Spring Boot can handle HTTPS (Hypertext Transfer Protocol Secure) by configuring an SSL certificate for the embedded servlet container. To enable HTTPS support, the following steps need to be followed:

  1. Obtain an SSL certificate: Purchase an SSL certificate from a trusted Certificate Authority (CA) or generate a self-signed certificate for development/testing purposes.
  2. Update application.properties: Add the following properties in the application.properties file:
1
2
3
4
5
server.port=8443
server.ssl.key-store-type=PKCS12
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=YourPassword
server.ssl.key-alias=your-alias


Here, server.port specifies the port for HTTPS, server.ssl.key-store-type defines the type of keystore, server.ssl.key-store specifies the path to the keystore file, server.ssl.key-store-password specifies the password for the keystore, and server.ssl.key-alias defines the alias for the certificate in the keystore.

  1. Place the keystore file: Place the keystore file (e.g., keystore.p12) in the classpath (src/main/resources folder) or provide an absolute path.
  2. Run the Spring Boot application: Run the application, and it will start an embedded servlet container with HTTPS configured on the specified port. Now, the application can be accessed using https://localhost:8443.


Note that in production environments, it is recommended to obtain a valid SSL certificate from a trusted CA instead of using a self-signed certificate.


How to renew an SSL certificate in Spring Boot?

To renew an SSL certificate in Spring Boot, you need to follow these steps:

  1. Obtain a new SSL certificate: Contact your SSL certificate provider or renew the certificate using the same process you followed initially.
  2. Replace the existing SSL certificate files: Once you have the new certificate, replace the following files in your Spring Boot project:
  • The new certificate file (usually with a .crt extension)
  • The new private key file (usually with a .key extension)
  1. Update the SSL configuration in Spring Boot: Open the application.properties or application.yml file in your project and update the following properties based on the new certificate files:
  • server.ssl.key-store: Path to the new certificate file.
  • server.ssl.key-store-password: Password for the certificate file.
  • server.ssl.key-store-type: Type of the keystore file (e.g., PKCS12, JKS).
  • server.ssl.key-alias: Alias for the certificate in keystore.
  1. Restart the Spring Boot application: Rebuild and redeploy your Spring Boot application for the SSL changes to take effect.


Note: It is recommended to back up your existing SSL certificate files before making any changes and verify the SSL configuration using a SSL certificate checker tool or browser.


What is a keystore?

A keystore, also known as a keychain, is a secure storage container that holds cryptographic keys, certificates, and other sensitive credentials. It is commonly used in computer systems to securely store and manage cryptographic information for various purposes such as encryption, digital signatures, and authentication.


A keystore acts as a repository for private keys, public keys, and digital certificates. Private keys are used for encryption, decryption, and digital signing, while public keys are used for encryption and verification. Digital certificates, issued by trusted certificate authorities, help establish the authenticity and integrity of communication between parties.


Keystores provide a secure and centralized location for managing cryptographic keys and certificates, ensuring their protection from unauthorized access. They are utilized in various applications like web servers, email clients, operating systems, and software development frameworks to secure sensitive information and facilitate secure communication.

Best Cloud Providers to Host Java Spring Boot in 2024

1
AWS

Rating is 5 out of 5

AWS

2
DigitalOcean

Rating is 4.9 out of 5

DigitalOcean

3
Vultr

Rating is 4.8 out of 5

Vultr

4
Cloudways

Rating is 4.7 out of 5

Cloudways


How do I create a self-signed SSL certificate?

To create a self-signed SSL certificate, you can follow these general steps:

  1. Open a terminal or command prompt and navigate to a directory where you want to generate the certificate.
  2. Generate a private key by running the following command: openssl genpkey -algorithm RSA -out private.key -pkeyopt rsa_keygen_bits:2048
  3. Generate a certificate signing request (CSR) by running the following command and providing required details (e.g., Common Name, Organization, etc.): openssl req -new -key private.key -out certificate.csr
  4. Generate a self-signed certificate using the private key and CSR by running the following command: openssl x509 -req -days 365 -in certificate.csr -signkey private.key -out certificate.crt This will create a self-signed certificate named certificate.crt valid for 365 days.
  5. You will have two files: private.key (your private key) and certificate.crt (your self-signed certificate). These files can be used for SSL/TLS configuration in your server or application.


It's important to note that self-signed certificates are not trusted by default by most web browsers and operating systems. They are primarily intended for testing or local development purposes. For production use, it's recommended to obtain a trusted certificate from a recognized Certificate Authority (CA).


How can I disable HTTPS in Spring Boot?

To disable HTTPS in Spring Boot, you can follow these steps:

  1. Open the application.properties file in your Spring Boot application.
  2. Remove or comment out the following line: server.ssl.enabled=true
  3. Save the changes and start/restart your application.


By removing or commenting out the server.ssl.enabled=true property, you are effectively disabling the HTTPS protocol in your Spring Boot application.


How to specify the SSL/TLS protocol version in Spring Boot?

To specify the SSL/TLS protocol version in Spring Boot, you can configure the protocol version through the application.properties or application.yml file.

  1. In the application.properties file, add the following line to specify the SSL/TLS protocol version: server.ssl.protocol=Replace with the desired protocol version, such as TLSv1.2 or TLSv1.3.
  2. Or, in the application.yml file, add the following lines to specify the SSL/TLS protocol version: server: ssl: protocol: Again, replace with the desired protocol version.


After specifying the SSL/TLS protocol version, restart your Spring Boot application for the changes to take effect.


How do I configure HTTPS programmatically in Spring Boot?

To configure HTTPS programmatically in a Spring Boot application, you can follow these steps:

  1. Enable HTTPS in your Spring Boot project by adding the spring-boot-starter-security and spring-boot-starter-web dependencies to your Maven or Gradle configuration.
  2. Create a WebServerFactoryCustomizer bean to customize the server configuration. In this example, we will configure the embedded Tomcat server:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Configuration
public class HttpsConfig {

    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory> customizeTomcatConnector() {
        return (factory) -> {
            factory.addConnectorCustomizers((connector) -> {
                connector.setScheme("https");
                connector.setSecure(true);
                connector.setPort(8443); // HTTPS port

                // Configure the SSL/TLS certificate
                HttpsURLConnection.setDefaultHostnameVerifier((hostname, sslSession) -> true); // Disables hostname verification
                SSLContext sslContext = SSLContext.getInstance("TLS");
                sslContext.init(null, null, null);
                connector.setAttribute("sslContext", sslContext);

                // Redirect HTTP to HTTPS
                Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();
                protocol.setSSLEnabled(true);
                protocol.setRedirectPort(8443); // HTTPS port
            });
        };
    }
}


  1. Generate a keystore file and certificate for your server. You can use the Java keytool to create a self-signed certificate or obtain a valid certificate from a trusted Certificate Authority.
  2. Configure the keystore properties in your application.properties or application.yml file:
1
2
3
4
server.ssl.key-store-type=PKCS12
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=yourPassword
server.ssl.key-password=yourKeyPassword


Make sure to replace keystore.p12 with the actual path to your keystore file, and replace yourPassword and yourKeyPassword with the actual passwords.

  1. Run your Spring Boot application, and it should now serve content over HTTPS on the configured port (8443 in the example above).


Note: In a production environment, it is recommended to use a keystore with a valid certificate signed by a trusted Certificate Authority. Self-signed certificates should only be used for development and testing purposes.


How to use a custom SSL certificate in Spring Boot?

To use a custom SSL certificate in Spring Boot, you need to follow these steps:

  1. Generate a custom SSL certificate using a tool like OpenSSL. You can generate a self-signed certificate for testing purposes or obtain a signed certificate from a trusted certificate authority (CA) for production.
  2. Once you have the certificate, store it in a location accessible by your Spring Boot application. You can store it in a directory within your application's project or in a separate directory on your server.
  3. In your Spring Boot application, configure the SSL properties in the application.properties or application.yml file. You need to specify the path to the certificate files and provide any additional configuration such as the private key password.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# application.properties
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=changeit
server.ssl.key-store-type=PKCS12

# application.yml
server:
  ssl:
    key-store: classpath:keystore.p12
    key-store-password: changeit
    key-store-type: PKCS12


  1. If you're using a self-signed certificate, you may need to import the certificate into the truststore of the Java runtime environment that runs your Spring Boot application. This is necessary to trust the certificate. You can use the keytool command to import the certificate into the truststore:
1
keytool -import -trustcacerts -keystore $JAVA_HOME/jre/lib/security/cacerts -storepass changeit -noprompt -alias mycertificate -file /path/to/certificate.crt


  1. Start your Spring Boot application, and it should now use your custom SSL certificate for secure communication.


Note: Make sure your Spring Boot application is capable of handling HTTPS requests. This may involve configuring your application to listen on the appropriate secure port (default is 8443) and securing any sensitive endpoints with appropriate security configurations.


How to customize the cipher suites in Spring Boot?

To customize the cipher suites in Spring Boot, you can follow these steps:

  1. Create a new Java class that implements the WebServerFactoryCustomizer interface. This interface allows you to customize the configuration of the embedded web server.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
import org.springframework.boot.web.server.Ssl;
import org.springframework.boot.web.server.SslStoreProvider;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
import org.springframework.stereotype.Component;

@Component
public class CustomWebServerFactoryCustomizer
        implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {

    @Override
    public void customize(ConfigurableServletWebServerFactory factory) {
        Ssl ssl = new Ssl();
        ssl.setCiphers("TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384");
        ssl.setEnabledProtocols("TLSv1.2");
        // Set other SSL properties if required

        factory.setSsl(ssl);
    }
}


  1. In the above code, you can set the desired cipher suites using the ssl.setCiphers() method. You can also set other SSL properties like protocols using the setEnabledProtocols() method.
  2. Add the @Component annotation to register the customizer as a Spring bean.
  3. Restart your Spring Boot application. The embedded web server will now use the customized cipher suites.


Note: The above example is for configuring cipher suites for an embedded Tomcat server. If you are using a different embedded web server like Jetty or Undertow, you may need to adjust the code accordingly.


Additionally, you may also need to modify your application.properties or application.yml file to enable HTTPS and specify the SSL certificate and key file paths.


References:

  • Spring Boot Documentation: Servlet Container Customization
  • Spring Boot Source Code: ConfigurableServletWebServerFactory
Facebook Twitter LinkedIn Telegram Whatsapp Pocket

Related Posts:

To integrate Spring Boot with Angular, the following steps can be followed:Create a new Spring Boot project: Start by setting up a new Spring Boot project using your preferred IDE or Spring Initializer. Include the necessary dependencies for web and data. Set ...
To connect Spring Boot to MySQL, you need to follow these steps:First, make sure you have MySQL installed and running on your system. In your Spring Boot project, open the application.properties file. Add the following properties to the file: spring.datasourc...
To stop a Spring Boot application from the command line, you need to perform the following steps:Identify the process ID (PID) of the running Spring Boot application. You can do this by using the jps command. Open the command prompt and type jps -l. Look for t...