If the configuration does not include passwords, you can provide them as as java properties (<tt>jetty.ssl.password</tt> and <tt>jetty.ssl.keypassword</tt>), else the system prompts for them. Remember that putting your password on the command line is a security risk. You can also set them as properties within the config file, but this risks accidental discovery by developers.

If the configuration does not include passwords, you can provide them as as java properties (<tt>jetty.ssl.password</tt> and <tt>jetty.ssl.keypassword</tt>), else the system prompts for them. Remember that putting your password on the command line is a security risk. You can also set them as properties within the config file, but this risks accidental discovery by developers.

−

If jetty is given a password that begins with "OBF:" it is treated as an obfuscated password. You can obfuscated passwords by running [http://download.eclipse.org/jetty/stable-7/apidocs/index.html?org/eclipse/jetty/http/security/Password.html org.eclipse.jetty.http.security.Password] as a main class. This can protect passwords from casual observation.

+

If jetty is given a password that begins with "OBF:" it is treated as an obfuscated password. You can obfuscated passwords by running [http://download.eclipse.org/jetty/stable-8/apidocs/index.html?org/eclipse/jetty/util/security/Password.html org.eclipse.jetty.http.util.Password] as a main class. This can protect passwords from casual observation.

+

+

See [[Jetty/Howto/Secure Passwords|Secure Passwords]] for more details.

Introduction

This is an overview of how to configure SSL for Jetty, which uses Sun's reference implementation for the Java Secure Sockets Extension (JSSE).

Understanding Certificates and Keys

Configuring SSL can be a confusing experience of keys, certificates, protocols and formats, thus it helps to have a reasonable understanding of the basics. The following links provide some good starting points:

Configuring Jetty for SSL

OpenSSL Versus Keytool

For testing, keytool probably provides the simplest way to generate the key and certificate you need. However, IBM's keyman is also pretty good, and provides a GUI rather than a command line.

You can also use the OpenSSL tools to generate keys and certificates, or to convert those that you have used with Apache or other servers. Since Apache and other servers commonly use the OpenSSL tool suite to generate and manipulate keys and certificates, you might already have some keys and certificates created by OpenSSL. Also, OpenSSL might be more trusted than keytool or some certificate authorities. You might also prefer the formats OpenSSL produces.

If you want the option of using the same certificate with Jetty or a web server such as Apache not written in Java, you might prefer to generate your private key and certificate with OpenSSL. The Java keytool does not provide options for exporting private keys, and Apache needs the private key. If you create the key and certificate with OpenSSL, your non-Java web server has ready access to it.

Generating Key Pairs and Certificates

The simplest way to generate keys and certificates is to use the keytool application that comes with the JDK, as it generates keys and certificates directly into the keystore. See Generating a Certificate with JDK keytool.

If you already have keys and certificates, see Loading Keys and Certificates to load them into a JSSE key store. This section also applies if you have a renewal certificate to replace one that is expiring.

The examples below generate only basic keys and certificates. You should read the full manuals of the tools you are using if you want to specify:

Key size.

Certificate expiry.

Alternate security providers.

Generating Keys and Certificates with JDK keytool

The following command generates a key pair and certificate directly into a keystore:

keytool -keystore keystore -alias jetty -genkey-keyalg RSA

The DSA key algorithm certificate produces an error after loading several pages. In a browser, it displays a message "Could not establish an encrypted connection because certificate presented by localhost has an invalid signature." The solution is to use RSA for the key algorithm.

This command prompts for information about the certificate and for passwords to protect both the keystore and the keys within it. The only mandatory response is to provide the fully qualified host name of the server at the "first and last name" prompt. For example:

keytool -keystore keystore -alias jetty -genkey-keyalg RSA
Enter keystore password: password
What is your first and last name?
[Unknown]: jetty.eclipse.org
What is the name of your organizational unit?
[Unknown]: Jetty
What is the name of your organization?
[Unknown]: Mort Bay Consulting Pty. Ltd.
What is the name of your City or Locality?
[Unknown]:
What is the name of your State or Province?
[Unknown]:
What is the two-letter country code for this unit?
[Unknown]:
Is CN=jetty.eclipse.org, OU=Jetty, O=Mort Bay Consulting Pty. Ltd.,
L=Unknown, ST=Unknown, C=Unknown correct?
[no]: yes
Enter key password for<jetty>(RETURN if same as keystore password): password

You now have the minimal requirements to run an SSL connection and could proceed directly to Configuring Jetty to configure an SSL connector. However the browser will not trust the certificate you have generated, and will prompt the user to this effect. While what you have at this point is often sufficient for testing, most public sites need to request a trusted certificate, as shown in the section, Obtaining a CSR from keytool.

Generating Keys and Certificates with OpenSSL

The following command generates a key pair in the file jetty.key:

openssl genrsa -des3-out jetty.key

You might also want to use the -rand file argument to provide an arbitrary file that helps seed the random number generator.

The following command generates a certificate for the key into the file jetty.crt:

openssl req -new-x509-key jetty.key -out jetty.crt

The next command prompts for information about the certificate and for passwords to protect both the keystore and the keys within it. The only mandatory response is to provide the fully qualified host name of the server at the Common Name prompt. For example:

openssl genrsa -des3-out jetty.key
Generating RSA private key, 512 bit long modulus
...........................++++++++++++
..++++++++++++
e is 65537(0x10001)
Enter pass phrase for jetty.key:
Verifying - Enter pass phrase for jetty.key:
# openssl req -new -x509 -key jetty.key -out jetty.crt
Enter pass phrase for jetty.key:
You are about to be asked to enter information to be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there is a default value,
If you enter '.', the field is left blank.
-----
Country Name (2 letter code)[AU]:.
State or Province Name (full name)[Some-State]:.
Locality Name (eg, city)[]:.
Organization Name (eg, company)[Internet Widgets Pty Ltd]:Mort Bay Consulting Pty. Ltd.
Organizational Unit Name (eg, section)[]:Jetty
Common Name (eg, YOUR name)[]:jetty.eclipse.org
Email Address []:
#

You now have the minimal requirements to run an SSL connection and could proceed directly to Loading Keys and Certificates to load these keys and certificates into a JSSE keystore. However the browser will not trust the certificate you have generated, and will prompt the user to this effect. While what you have at this point is often sufficient for testing, most public sites need to request a trusted certificate, as shown in the section, Generating a CSR from OpenSSL to obtain a certificate.

Using Keys and Certificates from Other Sources

Requesting a Trusted Certificate

The keys and certificates generated with the JDK keytool and OpenSSL are sufficient to run an SSL connector. However the browser will not trust the certificate you have generated, and it will prompt the user to this effect.

To obtain a certificate that most common browsers will trust, you need to request a well-known certificate authority (CA) to sign your key/certificate. Such trusted CAs include: AddTrust, Entrust, GeoTrust, RSA Data Security, Thawte, VISA, ValiCert, Verisign, and beTRUSTed, among others.

Each CA has its own instructions (look for JSSE or OpenSSL sections), but all involve a step that generates a certificate signing request (CSR).

Generating a CSR from keytool

The following command generates the file jetty.csr using keytool for a key/cert already in the keystore:

keytool -certreq-alias jetty -keystore keystore -file jetty.csr

Generating a CSR from OpenSSL

The following command generates the file jetty.csr using OpenSSL for a key in the file jetty.key:

openssl req -new-key jetty.key -out jetty.csr

Notice that this command uses only the existing key from jetty.key file, and not a certificate in jetty.crt as generated with OpenSSL. You need to enter the details for the certificate again.

Loading Keys and Certificates

Once a CA has sent you a certificate, or if you generated your own certificate without keytool, you need to load it into a JSSE keystore.

Combined Private Key and Certificate

You need both the private key and the certificate in the keystore. You should load the certificate into the keystore used to generate the CSR with keytool. If your key pair is not in a keystore (generated with OpenSSL), you need to use the PKCS12 format to load both key and certificate (see Loading Keys and Certificates via PKCS12.

Loading Certificates with keytool

You can use keytool to load a certificate in PEM form directly into a keystore. The PEM format is a text encoding of certificates; it is produced by OpenSSL, and is returned by some CAs. An example PEM file is:

Depending on the situation, you might not require the -trustcacerts option. Try the operation without it if you like. If the certificate you receive from the CA is not in a format that keytool understands, you can use the openssl command to convert formats:

openssl x509 -in jetty.der -inform DER -outform PEM -out jetty.crt

Loading Keys and Certificates via PKCS12

If you have a key and certificate in separate files, you need to combine them into a PKCS12 format file to load into a new keystore. The certificate can be one you generated yourself or one returned from a CA in response to your CSR.

The following OpenSSL command combines the keys in jetty.key and the certificate in the jetty.crt file into the jetty.pkcs12 file:

The order of certificates must be from server to rootCA, as per RFC2246 section 7.4.2.

OpenSSL asks for an export password. A non-empty password seems to be required to make the next step work. Then load the resulting PKCS12 file into a JSSE keystore with the following jetty utility class:

This asks for two passphrases. Give the password from the last step as the input passphrase and you are set. The "output passphrase" must appear in your jetty.xml config file as both the Password and KeyPassword of the SunJsseListener that uses the certificate.

You can also use keytool (starting form jdk1.6) to import a PKCS12 file with the following command:

Configuring Jetty

Beginning with Jetty 7.3.1, the preferred way to configure SSL parameters for the connector is by configuring the SslContextFactory object and passing it to the connector's constructor.

Jetty has two SSL connectors–the SslSocketConnector and the SslSelectChannelConnector. The SslSocketConnector is built on top of the Jetty SocketConnector which is Jetty's implementation of a blocking connector. It uses Java's SslSocket to add the security layer. The SslSelectChannelConnector is an extension of Jetty's SelectChannelConnector which uses non-blocking IO. For its security layer, it uses java nio SslEngine. You can configure these two connectors similarly; the difference is in the implementation.

The following is an example of an SslSelectChannelConnector configuration. You can configure an SslSocketConnector the same way–just change the value of the class to org.eclipse.jetty.server.ssl.SslSocketConnector.

maxCertPathLengh–Maximum allowed number of intermediate certificates, default is -1 (unlimited).

If there is no value for the truststore, the system uses the keystore value. You can obfuscate passwords by using the Jetty password utility.

Choosing a Directory for the keystore

The keystore file in the example above is given relative to the jetty home directory. For production, choose a private directory with restricted access to keep your keystore in. Even though it has a password on it, the password may be configured into the runtime environment so is vulnerable to theft. You can now start Jetty the normal way (make sure that jcert.jar, jnet.jar and jsse.jar are on your classpath) and SSL can be used with a URL like:

https://localhost:8443/

Setting the Port for https

Remember that the default port for https is 443 not 80, so change 8443 to 443 if you want to be able to use URLs without explicit port numbers. For a production site it normally makes sense to have an HttpListener on port 80 and a SunJsseListener on port 443. Because these are privileged ports, you might want to use a redirection mechanism to map port 80 to, for example, 8080 and 443 to, for example, 8443. For details on this, see Accessing Port 80 as a non-Root User.

The most common mistake at this point is to try to access port 8443 with http rather than https.

Redirecting http requests to https

To redirect http to https, the webapp should indicate it needs CONFIDENTIAL or INTEGRAL connections from users. This is
done in web.xml:

<web-app>
...
<security-constraint><web-resource-collection><web-resource-name>Everything in the webapp</web-resource-name><url-pattern>/*</url-pattern></web-resource-collection><user-data-constraint><transport-guarantee>CONFIDENTIAL</transport-guarantee></user-data-constraint></security-constraint></web-app>

Then you need to tell the plain http connector if the users try to access that webapp using plain http, they
should be redirected to the port of your ssl connector (the "confidential port"):

That's it. If the webapp doesn't indicate it needs CONFIDENTIAL or INTEGRAL connections (as it may be considered
a deployment issue), you can set this requirement in the context (so you must deploy the webapp as a WebAppContext
instead of just a war file):

Configuring SSL for Earlier Versions of Jetty

Password Issues

If the configuration does not include passwords, you can provide them as as java properties (jetty.ssl.password and jetty.ssl.keypassword), else the system prompts for them. Remember that putting your password on the command line is a security risk. You can also set them as properties within the config file, but this risks accidental discovery by developers.

If jetty is given a password that begins with "OBF:" it is treated as an obfuscated password. You can obfuscated passwords by running org.eclipse.jetty.http.util.Password as a main class. This can protect passwords from casual observation.

Renewing Certificates

If you are updating your configuration to use a newer certificate, as when the old one is expiring, just load the newer certificate as described in the section, Loading Keys and Certificates. If you imported the key and certificate originally using the PKCS12 method, use an alias of "1" rather than "jetty", because that is the alias the PKCS12 process enters into the keystore.