Qu'est-ce que Tomcat

Tomcat est un conteneur web de servlets et JSP. Il a son propre serveur web. Il est paramétrable par des fichiers XML et des propriétés, et inclut des outils pour la configuration et la gestion.

Il compile les JSP pour en faire des servlets. On peut notamment déployer des servlets à l'aide de fichiers .war.

Qu'est-ce qu'un servlet ?

Un servlet est une classe Java qui permet de créer dynamiquement des données dans un serveur HTTP, généralement du html mais potentiellement n'importe quel format utilisé par les navigateurs web. Le servlet est exécuté dynamiquement sur le serveur et permet l'extension de ses fonctions.

Qu'est que JSP ?

JSP signifie Java Server Page. Il s'agit d'une technologie de génération de pages dynamiques. La technologie JSP permet de séparer la présentation sous forme de code HTML et les traitements écrits en Java sous la forme de JavaBeans ou de servlets. Ceci est d'autant plus facile que les JSP définissent une syntaxe particulière permettant d'appeler un bean et d'insérer le résultat de son traitement dans la page HTML dynamiquement. Javabeans : "des composants logiciels reséutilisables manipulables visuellement dans un outil de conception".

Qu'est-ce qu'un .war ?

Web Application Archive. C'est un fichier JAR utilisé pour contenir un ensemble de JSP, servlets, classes java, fichier XML, et des pages statiques, le tout constituant une application web. Ce genre de fichier est utilisé pour déployer des application web sur des serveur applicatifs comme Tomcat.

Mise en pratique de Tomcat

https://www.vogella.com/tutorials/ApacheTomcat/article.html https://journaldunadminlinux.fr/tutoriel-installation-et-configuration-de-tomcat-9/

Je teste ici sur une Debian 10; Tomcat est actuellmeent proposé en version 9. La machine qui reçoit Tomcat a pour IP 10.0.0.10.

Installation

apt install tomcat9 tomcat9-admin tomcat9-docs tomcat9-examples openjdk*

Configuration

Tomcat a tendance à foutre des fichiers un peu partout. Il compte notamment des fichiers dans /etc/tomcat9, mais aussi ses servlets dans /usr/share/tomcat-[quelque chose].

<source lang="bash"> systemctl enable tomcat9 systemctl start tomcat9 </source>

J'ai ensuite droit à une page à l'adresse http://10.0.0.10:8080:

Console Web

Tomcat propose une console web, à l'adresse http://10.0.0.10:8080/manager/html. Par défaut elle n'est pas accessible, mais ses messages d'erreurs sont très explicites pour comprendre le souci.

On commence par donner les droits à un utilisateur dans /etc/tomcat9/tomcat-users.xml. Il me suffit de rajouter un petit bloc dans la section <tomcat-users>:

Par défaut, Tomcat n'autorise à partir de la version 9 l'accès à la console que depuis un browser située sur la même machine. On va changer ça dans le fichier de contexte du manager. Il s'agit d'un fichier qui définit le comportement du servlet de management et qui est situé dans:

/usr/share/tomcat9-admin/manager/META-INF/context.xml (sic...)

Il suffit de commenter le bloc Valve qui limite les accès:

 <Manager sessionAttributeValueClassNameFilter="java\.lang\.(?:Boolean|Integer|Long|Number|String)|org\.apache\.catalina\.filters\.CsrfPreventionFilter\$LruCache(?:\$1)?|java\.util\.(?:Linked)?HashMap"/>

</Context> </source>

Le tout, suivi d'un restart de tomcat :

systemctl restart tomcat

Je peux enfin accéder à l'interface:

On peut notamment voir que l'interface permet d'uploader et déployer des fichiers .war.

Keystores

https://www.sslshopper.com/article-most-common-java-keytool-keystore-commands.html?jn9ed3e997=3

Java utilise des keystores, des fichiers .jks protégés par un mot de passe qui contiennent clef, certificat, chaine... Et sont gérés par la commande "keytool".

Création d'un keystore

Création d'un keystore à partir d'un certificat .pem

Conversion en pkcs12

openssl pkcs12 -export -in newcert.pem -inkey newkey.pem -out server.p12 -name test_server -caname root_ca -chain -CAfile cacert.pem

Création du keytool par import du pkcs12

keytool -importkeystore -deststorepass mypass -destkeypass mypass -destkeystore keystore.jks -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass p12pass -srcalias test_server -destalias test_server

Exemple :

openssl pkcs12 -export -in cert-27052-ecandidat.u-pec.fr.pem -inkey ecandidat.u-pec.fr.key -out server.p12 -name ecandidat -caname root_ca -chain -CAfile chain-27052-ecandidat.u-pec.fr.pem

keytool -importkeystore -deststorepass changeit -destkeypass changeit -destkeystore ecandidat.keystore -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass changeit -srcalias ecandidat -destalias ecandidat

Mise à jour d'un certif dans un jks

https://gist.github.com/Austinb/1134768246e8d8f56f1c06f17fbacde2

Si besoin du mot de passe, il doit normalement se trouver dans le server.xml du tomcat.

Le guide suivant issu de la source a été testé et approuvé.

Fast guide for replacing a certificate in a JAVA key store using keytool and openssl. Useful if you do not want to generate a new csr. This also has commands for extracting the private key in case you lost it or do not have access to it.

This guide is probably incomplete but you have to start somewhere...

First backup your existing keystore file. If you break it you have a copy you can fallback on.

cp /path/to/keystore ~/keystore

All the commands will prompt for passwords. Passwords are usually required when dealing with keytool so it is best to set a password when prompted instead of just entering an empty password.

Extract the private key from your keystore file. You can skip the next two steps if you already have the private key file in PEM format. Change the paths and the alias to match what you need. I recommend using the same alias as the one you are replacing in the keystore.

keytool -importkeystore -srckeystore /path/to/keystore -srcalias your_alias -destalias your_alias -destkeystore /path/to/export.p12 -deststoretype PKCS12

Export the P12 key into PEM format

openssl pkcs12 -in /path/to/export.p12 -nodes -nocerts -out /path/to/export.pem

Convert your crt into a P12 file that we can import into the keystore

openssl pkcs12 -export -in /path/to/cert.crt -inkey /path/to/export.pem -certfile /path/to/bundle.crt -out /path/to/newkeystore.p12 -name your_alias

Note when creating the new P12 file above you will need to make sure the value of -name matches the alias in the keystore you will be importing this P12 file into. If it does not the import will fail with an error like keytool error: java.lang.Exception: Alias <your_hub> does not exist You can verify the alias matches by listing the entries in the P12 file keytool -list -keystore /path/to/newkeystore.p12

Import your P12 into your main keystore file which will prompt you to overwrite your existing alias

keytool -importkeystore -srckeystore /path/to/newkeystore.p12 -srcstoretype PKCS12 -alias your_alias -destkeystore /path/to/keystore

Now you can check your keystore and see that the alias has been updated with the imported P12 file.

keytool -list -keystore /path/to/keystore

Apache Tomcat

Sommaire