Introduction
Cette application permet de gérer le cycle de vie des cartes NFC de votre établissement, de la demande à sa désactivation en passant par son impression, encodage et activation dans votre système d'information.
...
Une Machine Virtuelle est à votre disposition pour pouvoir manipuler ESUP-SGC et ainsi avoir à diposition disposition un exemple complet d'installation : VM ESUP-SGC.
...
Sommaire |
---|
Concepts
Afin de mettre en œuvre le système de gestion de carte ESUP-SGC, vous devez installer ESUP-SGC mais également ESUP-NFC-TAG.
...
Gère le cycle de vie de vos cartes (workflow allant de la demande à désactivatino désactivation de la carte)
- Authentifie les utilisateurs via une authentification Shibboleth
Récupère les informations (nom, prénom, email, date de naissance, etc.) des utilisateurs depuis l'identifiaction l’identification shibboleth ou/et un annuaire LDAP ou/et une base de données relationnelle
Synchronise les informations utilisateurs et de cartes avec l'API du CNOUS (CROUS, IZLY) en temps réel.
- Synchronise les informations utilisateurs étudiants et de cartes avec l'API ESC - European Student Card : http://europeanstudentcard.eu
Synchronisation avec différentes solutions de contrôles d’accès (P2S, TIL, Synchronic)
- Reversement des informations de cartes (csn, 'identifiant desfire', photo) dans un annuaie annuaire LDAP
- Permet l’impression des cartes (en mode PS/PCL)
...
ESUP-NFC-TAG ( https://www.esup-portail.org/wiki/display/ESUPNFC ) se décompose d'une partie serveur (implémentatnt implémentant toute la logique métier, la gestion des périphériques et applications clientes ainsi que les algorithmes de chiffrement Mifare Desfire) nommé ESUP-NFC-TAG-SERVER qui :
...
Pour lire ou encoder une carte, un "client lourd" est nécessaire ; aussi les applications clientes suivantes sont disponibles :
esup-nfc-tag-desktop desktop : application java qui permet d’utiliser un encodeur PC/SC USB depuis une machine linux/windows/mac disposant de Java
esup-nfc-tag-droid droid : application Android qui utilise le lecteur NFC du smartphone
- esup-nfc-tag-keyboard : application java qui permet d’émuler des frappes clavier permettant ainsi de saisir l'identifiant du porteur de carte par exemple
ESUP-SGC-CLIENT
ESUP-SGC inclut également son propre client pour l’encodage des cartes (esup-sgc-client) qui est en fait également client d'esup-nfc-tag-server.
L’encodage via esup-sgc-client se passe de cette manière :
- Edition en 2 temps :
lecture du QR code présent sur la carte (identifiant l’individu à encoder) ; la carte ayant été imprimée depuis l'interface web d'esup-sgc via un navigateur web
association de la carte avec l’individu dans le SGC
encodage des différentes applications DESFIRE telles que décrites dans le fichier de configuration d'ESUP-NFC-TAG-SERVER
... et optionnellement (on recommande plutôt d'acheter des cartes
pré-encodés IZLY) encodage de l’application IZLY (CROUS) via ESUP-NFC-TAG-SERVER en utilisant la clé SAM du CNOUS et des DLL Windows
- Edition en 1 temps :
Schéma d’architecture de la solution
Liens
https://github.com/EsupPortail/esup-sgc
https://github.com/EsupPortail/esup-sgc-client
https://github.com/EsupPortail/esup-nfc-tag-server
https://github.com/EsupPortail/esup-nfc-tag-desktop
https://github.com/EsupPortail/esup-nfc-tag-droid
Pre-requis
Logiciels
- sélection de la carte à imprimer et encoder depuis l'interface web d'esup-sgc via un navigateur web
impression de la carte
association de la carte avec l’individu dans le SGC et encodage des différentes applications DESFIRE telles que décrites dans le fichier de configuration d'ESUP-NFC-TAG-SERVER
... et optionnellement (on recommande plutôt d'acheter des cartes pré-encodés IZLY) encodage de l’application IZLY (CROUS) via ESUP-NFC-TAG-SERVER en utilisant la clé SAM du CNOUS et des DLL Windows
Schéma d’architecture de la solution
Pre-requis
Logiciels
Java : nous recommandons l'usage d'openjdk
pour la partie serveur les versions 8 ou 11 ou 17 (généralement présentes dans les distributions) conviennent,
pour la partie cliente vous pouvez utiliser openjdk et openjfx en version 17.
Maven (dernière version 3.0.x) : le mieux est de l'installer via le système de paquets de votre linux - http://maven.apache.org/download.cgi
Postgresql : le mieux est de l'installer via le système de paquets de votre linux.
Tomcat 8 : .5 ou 9 (Tomcat 10 n'est pas supporté) : https://tomcat.apache.org/download-8090.cgi
Apache + libapache2-mod-shib2
Git
...
Serveur : 2 CPU, RAM > 2 Go, Disque > 20 Go
Cartes Mifare Desfire EV1 ou EV2
- Edition 2 temps :
Un lecteur RFID USB Compatible PC/SC pour encodage
- Une webcam
- Une imprimante à carte.
- Edition 1 temps : Cartes Mifare Desfire EV1 ou EV2
- Une imprimante à carte
- evolis (primacy) / zebra (zc300) avec lecteur NFC
A cela, un Smartphone Android > 5 avec lecteur NFC peut également s'avérer utile par exemple.
Installation des pré-requis
Note:
Les utilisateurs, chemins d'installation, ports utilisés ci-dessous ne sont qu'une suggestion.
Les exemples de configuration système sont basés sur Debian.
Les deux services seront installés sur le même serveur, l'un répondant avec le nom esup-sgc.univ-ville.fr et l'autre avec le nom esup-nfc-tag.univ-ville.fr.
Ces VirtualHosts seront configurés sous Apache.
Installer les paquets nécessaires
Bloc de code | ||||
---|---|---|---|---|
| ||||
apt-get install wget maven apache2 libapache2-mod-shib2shib git apt-get install postgresql postgresql-contrib |
Il est également nécessaire d'avoir un JDK d'installé (Oracle Java ou bien OpenJDK).
Installation des instances Tomcat
OpenJDK [installation par paquet]).
De même il vous faudra maven, que vous pouvez soit installer par paquet (apt-get install maven), soit manuellement depuis http://maven.apache.org/download.cgi
Installation des instances Tomcat
Création de lCréation de l'utilisateur esup:
Bloc de code | ||||
---|---|---|---|---|
| ||||
groupadd esup useradd -g esup -m esup |
Installer les deux instances de Tomcat. L'une sera utilisée pour ESUP-SGC, l'autre pour ESUP-NFC-TAG.
Bloc de code | ||||
---|---|---|---|---|
| ||||
cd /opt/ wget httphttps://dlcdn.apache.crihan.frorg/dist/tomcat/tomcat-89/v8v9.50.2458/bin/apache-tomcat-89.50.2458.tar.gz tar xzvf apache-tomcat-89.50.2458.tar.gz mv apache-tomcat-89.50.2458 apache-tomcat-89.50.2458-esup-nfc-tag tar xzvf apache-tomcat-89.50.2458.tar.gz mv apache-tomcat-89.50.2458 apache-tomcat-89.50.2458-esup-sgc ln -s apache-tomcat-89.50.2458-esup-nfc-tag tomcat-esup-nfc-tag ln -s apache-tomcat-89.50.2458-esup-sgc tomcat-esup-sgc rm -Rf /opt/tomcat-esup-sgc/webapps/* mkdir /opt/tomcat-esup-sgc/webapps/ROOT/ rm -Rf /opt/tomcat-esup-nfc-tag/webapps/* mkdir /opt/tomcat-esup-nfc-tag/webapps/ROOT/ chown -R esup:esup /opt/apache-tomcat-89.50.2458-esup-sgc/ chown -R esup:esup /opt/apache-tomcat-89.50.2458-esup-nfc-tag/ |
Note : Le contenu du dossier webapps est impérativement à supprimer, si vous ne le faites pas l'interface d'administration d'esup-sgc ne s'affichera pas. l'URL /manager rentrera en conflit avec la webapp manager de tomcat livrée par défaut lors du déploiement du serveur tomcat.
Les options Java étant les mêmes pour les deux instances, on peut Les options Java étant les mêmes pour les deux instances, on peut créer un fichier commun qui sera lu lors du démarrage des tomcat.
Bloc de code | ||||
---|---|---|---|---|
| ||||
cat > /opt/esup-env <<EOF #!/bin/sh ANT_HOME=/usr/share/ant JAVA_HOME=/opt/jdk #GRADLE_HOME=/usr/local/gradle-2.14.1 #ANDROID_HOME=/usr/local/android-sdk JAVA_OPTS="-Xms256m -Xmx512m -Djavax.net.ssl.trustStore=/opt/esup.univ-ville.jks -Djavax.net.ssl.trustStorePassword=esupesup" EOF |
Note: il faudra penser à créer le keystore indiqué et y intégrer les certificats utilisés par les VirtualHosts Apache.
...
"
EOF |
Note: si vous devez utiliser des certificats dont les autorités de certifications ne sont pas reconnus par le trustore par défaut de votre JVM (certificats autosignés par exemple), vous pouvez à ce niveau préciser dans JAVA_OPTS un trustore spécifique (que vous créez vous même) intégrant les autorités de certificats utilisés par les VirtualHosts Apache (ou encore serveurs ldaps).
Bloc de code | ||
---|---|---|
| ||
JAVA_OPTS="-Xms256m -Xmx512m -Djavax.net.ssl.trustStore=/opt/esup.univ-ville.jks -Djavax.net.ssl.trustStorePassword=esupesup" |
Ces deux instances seront démarrées via Systemd. On peut donc créer et activer ces deux services:
Pour Esup-SGC:
Bloc de code | ||||
---|---|---|---|---|
| ||||
cat > /etc/systemd/system/tomcat- |
Pour Esup-SGC:
Bloc de code | ||
---|---|---|
| ||
cat > /etc/systemd/system/tomcat-esup-sgc.service <<EOF
# Systemd unit file for tomcat
[Unit]
Description=Apache Tomcat Web Application Container
After=syslog.target network.target
[Service]
Type=forking
EnvironmentFile=/opt/esup-env
Environment=CATALINA_PID=/opt/tomcat-esup-sgc/temp/tomcat.pid
Environment=CATALINA_HOME=/opt/tomcat-esup-sgc
ExecStart=/opt/tomcat-esup-sgc/bin/startup.sh
ExecStop=/bin/kill -15 $MAINPID
User=esup
Group=esup
[Install]
WantedBy=multi-user.target
EOF
systemctl enable tomcat-esup-sgc.service |
Pour Esup-NFC-TAG:
Bloc de code | ||||
---|---|---|---|---|
| ||||
cat > /etc/systemd/system/tomcat-esup-nfc-tag.service <<EOF # Systemd unit file for tomcat [Unit] Description=Apache Tomcat Web Application Container After=syslog.target network.target [Service] Type=forking EnvironmentFile=/opt/esup-env Environment=CATALINA_PID=/opt/tomcat-esup-nfc-tag/temp/tomcat.pid Environment=CATALINA_HOME=/opt/tomcat-esup-nfc-tag ExecStart=/opt/tomcat-esup-nfc-tag/bin/startup.sh ExecStop=/bin/kill -15 $MAINPID User=esup Group=esup [Install] WantedBy=multi-user.target EOF systemctl enable tomcat-esup-nfc-tag.service |
...
Configuration des Tomcat
Pour l'instance d'Esup-SGC, éditer /opt/tomcat-esup-sgc/conf/server.xml
afin de configurer le port 8205 et un connecteur AJP sur le port 8209.
Les connecteurs HTTP et HTTPS (ports 8080 et 8443 par défaut) doivent être commentés (ou être configurés sur un autre port pour éviter les conflits avec la seconde instance Tomcat)
Bloc de code | ||||
---|---|---|---|---|
| ||||
<Server port="8205" shutdown="SHUTDOWN"> <!-- (...) --> <Connector port="8209" protocol="AJP/1.3" redirectPort="8443" asyncTimeout="1200000" tomcatAuthentication="false" scheme="https" secure="true" URIEncoding="UTF-8" secretRequired="false"/> |
Idem pour l'instance d'Esup-NFC-TAG qui utilisera les ports 8305 et 8309.
Bloc de code | ||||
---|---|---|---|---|
| ||||
<Server port="8305" shutdown="SHUTDOWN"> <!-- (...) --> <Connector port="8309" protocol="AJP/1.3" redirectPort="8443" asyncTimeout="1200000" tomcatAuthentication="false" /> |
Installation
Éléments requis
Pour avoir un système de gestion de cartes fonctionnel, l'installation minimale consiste à installer :
- un serveur tomcat avec l'application web esup-nfc-tag-server - documentation d'installation ici :
https://github.com/EsupPortail/esup-nfc-tag-server/blob/master/README.md - un serveur tomcat avec l'application web esup-sgc - documentation d'installation ici :
https://github.com/EsupPortail/esup-sgc/blob/master/README.md
A noter que esup-sgc embarque de fait le client esup-sgc-client sous la forme d'un jar servi via Java Web Start (JavaWS) / Java Network Launch Protocol (JNLP).
Ce client est signé par l'Université de Rouen Normandie - vous pouvez aussi le reconstruire et le resigner vous même depuis les sources : https://github.com/EsupPortail/esup-sgc-client
Éléments optionnels
Vous pouvez également mettre en place les applications Esup-nfc-tag-desktop et Esup-nfc-tag-droid :
- Esup-nfc-tag-desktop :https://github.com/EsupPortail/esup-nfc-tag-desktop/blob/master/README.md
- Esup-nfc-tag-droid : https://github.com/EsupPortail/esup-nfc-tag-droid/blob/master/README.md
Alliées à ESUP-SGC, ces applications pourront vous permettre
- de rechercher une carte en la badgeant
- de marquer une carte comme "livrée" en la badgeant
Configurations
Esup-nfc-tag-server
La configuration se fait par les fichiers suivants :
src/main/resources/META-INF/spring/applicationContext-custom.xml
src/main/resources/META-INF/spring/applicationContext-desfire.xml (voir configuration avancée)
src/main/resources/META-INF/spring/applicationContext-security.xml
applicationContext-custom.xml
Le fichier applicationContext-custom.xml permet de configurer les différentes applications avec lesquelles esup-nfc-tag va communiquer.
Dans le cadre du SGC il faudra à minima configurer la connexion avec esup-sgc à l’aide de la configuration suivante :
Bloc de code | ||
---|---|---|
| ||
<bean id="csnAuthConfig" class="org.esupportail.nfctag.service.api.impl.CsnAuthConfig">
<property name="description" value="Authentification CSN"/>
</bean>
<bean id="esupSgcWriteExtApi" class="org.esupportail.nfctag.service.api.impl.AppliExtRestWs">
<property name="isTagableUrl" value="https://esup-sgc-test.univ-ville.fr/wsrest/nfc/isTagable"/>
<property name="validateTagUrl" value="https://esup-sgc-test.univ-ville.fr/wsrest/nfc/validateTag"/>
<property name="getLocationsUrl" value="https://esup-sgc-test.univ-ville.fr/wsrest/nfc/locations"/>
<property name="description" value="Web Service Write Esup SGC"/>
</bean>
<bean id="tagIdCheckApiEsupSgc" class="org.esupportail.nfctag.service.api.impl.TagIdCheckRestWs">
<property name="tagIdCheckUrl" value="https://esup-sgc-test.univ-ville.fr/wsrest/nfc/tagIdCheck"/>
<property name="idFromEppnInitUrl" value="https://esup-sgc-test.univ-ville.fr/wsrest/nfc/idFromEppnInit"/>
<property name="description" value="via Esup SGC"/>
</bean> |
en remplacant les liens par ceux pointant vers votre instance d’esup-sgc
applicationContext-desfire.xml
Dans le ficher applicationContext-desfire.xml on trouve la structure et les données qui seront écrites sur la carte lors de l’encodage. Par défaut la configuration de Desfire est vide, aucune application ne sera écrite sur la carte.
Bloc de code | ||
---|---|---|
| ||
<bean id="tagName" class="org.esupportail.nfctag.beans.DesfireTag" p:formatBeforeWrite="false" p:key="0000000000000000" p:keyType="DES" p:keyVersion="00">
</bean>
<bean id="desfireAuthConfigComueWriteEsupSgc" class="org.esupportail.nfctag.service.api.impl.DesfireWriteConfig">
<property name="desfireTag" ref="tagName" />
<property name="description" value="Ecriture ESUP SGC"/>
</bean>
|
Voir la documentation avancée pour l'ajout d'application Desfire sur la carte.
applicationContext-security.xml
Dans le fichier applicationContext-security.xml il faut modifier le mapping des groupes pour l’attribution des rôles Admin et Supervisor en precisant le cn des groupes concernés :
Bloc de code | ||
---|---|---|
| ||
<beans:bean id="authUserDetailsService" class="org.esupportail.nfctag.security.ShibAuthenticatedUserDetailsService">
<beans:property name="mappingGroupesRoles">
<beans:map>
<beans:entry key="cn=for.esup-nfc-tag.admin,ou=groups,dc=univ-ville,dc=fr" value="ROLE_ADMIN" />
<beans:entry key="cn=for.esup-nfc-tag.supervisor,ou=groups,dc=univ-ville,dc=fr" value="ROLE_SUPERVISOR" />
</beans:map>
</beans:property>
</beans:bean> |
Configuration de l'application dans l'IHM
ESUP-NFC-TAG est multi-service. Il faut donc déclarer les applications, auxquelles il peut s’adresser, au niveau de l’IHM.
Dans la section « Application » → « +Ajouter une application »
On retrouve les éléments configurés dans applicationContext-custom.xml. Pour l’encodage des cartes par le SGC, nous allons créer une application nommée "Ecriture SGC" avec les paramètres suivants:
Nom : « Ecriture SGC »
Configuration NFC : « Ecriture ESUP SGC » (spécifié dans applicationContext-desfire.xml)
Application externe : « Web Service Write Esup SGC »
Contrôle du tagId : « via Esup SGC »
Valeur par défaut pour la validation sans confirmation : true
Esup-sgc
La configuration se fait via les fichiers suivants :
src/main/resources/META-INF/spring/applicationContext-services.xml
src/main/resources/META-INF/spring/applicationContext-crous.xml
src/main/resources/META-INF/spring/applicationContext-paybox.xml
src/main/resources/META-INF/spring/applicationContext-access-control.xml
src/main/resources/META-INF/spring/applicationContext-security.xml
applicationContext-services.xml
UserInfo :
La première partie du fichier comporte les « UserInfoService » ainsi que les « SpelUserInfoService » . Ces deux entités ont pour but de peupler les informations des demandeurs de carte à l’aide des différentes sources de données présentent dans le SI. Trois methodes sont implémentées dans le SGC :
ShibUserInfoService (recupération des données via le context Shibboleth)
LdapUserInfoService
SqlUserInfoService
Les spelUserInfoService sont des règles qui s’appliquent ensuite pour calculer certains attributs de l’utilisateur.
La recherche dans les différentes sources ainsi que le calcul des règles se fait de manière séquentielle dans l’ordre défini par la propriété « p:order ». A chaque étape, quand une donnée est trouvée, elle remplace celle trouvée par l’étape précédente.
ComueNuCardIdService :
Permet de configurer le début de la plage d’identifiants, dans le cas present l’identifiant COMUE (ouverture de portes) et l’identifiant CROUS.
Bloc de code | ||
---|---|---|
| ||
<bean id="cardIdService" class="org.esupportail.sgc.services.cardid.ComueNuCardIdService">
<property name="cardNfcIdCounterBegin" value="107000000100000"/>
<property name="cardCrousIdCounterBegin" value="66900000"/>
<property name="crousEncodeEnabled" value="true"/>
</bean> |
crousEncodeEnabled permet de spécifier si l’application CROUS doit être écrite lors de l’encodage des cartes.
EsupNfcTagService :
Pour spécifier l’adresse du serveur esup-nfc-tag. Le SGC déclare et contrôle ses périphériques d’encodage (esup-scg-client) avec esup-nfc-tag (applicationName correspond à l'application créée dans esup-nfc-tag)
" scheme="https" secure="true" URIEncoding="UTF-8" secretRequired="false"/> |
Info |
---|
|
Configuration d'Apache
Activer les modules suivants:
Bloc de code | ||||
---|---|---|---|---|
| ||||
a2enmod rewrite
a2enmod ssl
a2enmod proxy_ajp
a2enmod proxy_http
a2enmod shib
|
Créer un fichier de configuration pour le VirtualHost esup-sgc.univ-ville.fr /etc/apache2/sites-available/esup-sgc.univ-ville.fr.conf
Bloc de code | ||||
---|---|---|---|---|
| ||||
<VirtualHost *:80>
ServerName esup-sgc.univ-ville.fr
ServerAdmin webmaster@univ-ville.fr
DocumentRoot /var/www/html
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
RewriteEngine On
RewriteCond %{REQUEST_METHOD} ^(TRACE|TRACK)
RewriteRule .* - [F]
RewriteRule ^/(.*)$ https://esup-sgc.univ-ville.fr/$1 [L,R]
</VirtualHost>
<VirtualHost *:443>
ServerName esup-sgc.univ-ville.fr
ServerAdmin webmaster@univ-ville.fr
DocumentRoot /var/www/html
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
SSLEngine on
SSLCertificateFile /etc/letsencrypt/live/esup-sgc.univ-ville.fr/cert.pem
SSLCertificateKeyFile /etc/letsencrypt/live/esup-sgc.univ-ville.fr/privkey.pem
SSLCertificateChainFile /etc/letsencrypt/live/esup-sgc.univ-ville.fr/chain.pem
ProxyPass /Shibboleth.sso !
ProxyPass /secure !
ScriptAlias /secure /var/www/printenv.pl
ShibCompatValidUser Off
<Location /Shibboleth.sso>
SetHandler shib
AuthType None
Require all granted
</Location>
<Location /shibboleth-sp>
AuthType None
Require all granted
</Location>
Alias /shibboleth-sp/main.css /usr/share/shibboleth/main.css
<Location /secure>
AuthType shibboleth
ShibRequestSetting requireSession 1
require shib-session
ShibUseHeaders On
ShibRequestSetting applicationId default
</Location>
<Location />
AuthType shibboleth
ShibRequestSetting requireSession 1
require shib-session
ShibUseHeaders On
ShibRequestSetting applicationId default
</Location>
<Location "/resources">
Require all granted
ShibRequireSession Off
</Location>
<Location "/wsrest">
Require all granted
ShibRequireSession Off
</Location>
<Location "/payboxcallback">
Require all granted
ShibRequireSession Off
</Location>
ProxyPass / ajp://localhost:8209/ ttl=10 timeout=3600 retry=1
AddOutputFilterByType DEFLATE text/plain text/html text/css text/javascript application/x-javascript application/javascript application/json image/svg+xml
</VirtualHost> |
Idem pour le VirtualHost esup-nfc-tag.univ-ville.fr dans /etc/apache2/sites-available/esup-nfc-tag.univ-ville.fr.conf
Bloc de code | ||||
---|---|---|---|---|
| ||||
<VirtualHost *:80>
ServerName esup-nfc-tag.univ-ville.fr
ServerAdmin webmaster@univ-ville.fr
DocumentRoot /var/www/html
ErrorLog ${APACHE_LOG_DIR}/error_esup-nfc-tag.log
CustomLog ${APACHE_LOG_DIR}/access_esup-nfc-tag.log combined
RewriteEngine On
RewriteCond %{REQUEST_METHOD} ^(TRACE|TRACK)
RewriteRule .* - [F]
RewriteRule ^/(.*)$ https://esup-nfc-tag.univ-ville.fr/$1 [L,R]
</VirtualHost>
<VirtualHost *:443>
ServerName esup-nfc-tag.univ-ville.fr
ServerAdmin webmaster@univ-ville.fr
DocumentRoot /var/www/html
ErrorLog ${APACHE_LOG_DIR}/error_esup-nfc-tag.log
CustomLog ${APACHE_LOG_DIR}/access_esup-nfc-tag.log combined
SSLEngine on
SSLCertificateFile /etc/letsencrypt/live/esup-nfc-tag.univ-ville.fr/cert.pem
SSLCertificateKeyFile /etc/letsencrypt/live/esup-nfc-tag.univ-ville.fr/privkey.pem
SSLCertificateChainFile /etc/letsencrypt/live | ||||
Bloc de code | ||||
| ||||
<bean id="esupNfcTagService" class="org.esupportail.sgc.services.EsupNfcTagService"> <property name="restTemplate" ref="restTemplate"/> <property name="webUrl" value="http://esup-nfc-tag.univ-ville.fr"/>chain.pem <property name="applicationName" value="Ecriture SGC"/> <property name="location" value="Encodage ESUP SGC"/> </bean> |
LdapValidateService
Le SGC peut transmettre des données au LDAP lorsque la carte est activée. Dans le bean ldapValidateService il est possible de paramétrer deux types de clés : Simple ou multivaluée (ldapCardIdsMappingValue, ldapCardIdsMappingMultiValues)
Les valeurs transmissibles sont : %csn%, %reverse_csn% (le csn retourné par paires), %access-control% (ex : identifiant contrôle d'accès), %photo%.
Bloc de code | ||
---|---|---|
| ||
<bean id="ldapValidateService" class="org.esupportail.sgc.services.ldap.LdapValidateService"> <property name="ldapTemplate" ref="ldapTestTemplate"/> <property name="peopleSearchFilter" value="(eduPersonPrincipalName={0})"/> <property name="ldapCardIdsMappingMultiValues"> <map> <!-- Exemple clé multi-valuée --> <entry key="supannRefId"> <list> <value>{ISO15693}%csn%</value> <value>{LEOCARTE:ACCESS-CONTROL}%access-control%</value> </list> </entry> <!-- Exemple clé multi-valuée --> <entry key="autreExemple"> <list> <value>%reverse_csn%@ISO15693</value> ProxyPass /Shibboleth.sso ! ProxyPass /secure ! ScriptAlias /secure /var/www/printenv.pl ShibCompatValidUser Off <Location /Shibboleth.sso> SetHandler shib AuthType None Require all granted </Location> <Location /shibboleth-sp> AuthType None Require all granted </list>Location> </entry> Alias </map> </property> <property name="ldapCardIdsMappingValue"> <map> <!-- Exemple clé simple -->/shibboleth-sp/main.css /usr/share/shibboleth/main.css <Location /secure> AuthType shibboleth ShibRequestSetting requireSession 1 <entry key="jpegPhoto" value="%photo%"/> require shib-session </map> </property> </bean> |
applicationContext-crous.xml
ApiCrousService :
Permet d’activer l’envoi de données au CROUS via l’api
Bloc de code | ||
---|---|---|
| ||
<bean id="apiCrousService" class="org.esupportail.sgc.services.crous.ApiCrousService">
<property name="enable" value="false"/>
<property name="webUrl" value="https://api-pp.nuonet.fr/v1" />
<property name="login" value="truc@univ-ville.fr" />
<property name="password" value="xxxxxxxxxxxxxxx" />
<property name="restTemplate" ref="restTemplate" />
</bean> |
EsistCrousService :
Fait référence au fichier XML de calcul des tarifs CROUS
ApiEscrService :
Permet de configurer l’envoi des données à l’api ESC (Eropean Student Card) voir : http://europeanstudentcard.eu/
Bloc de code | ||
---|---|---|
| ||
<bean id="europeanStudentCardService" class="org.esupportail.sgc.services.esc.ApiEscrService">
<property name="enable" value="false"/>
<property name="webUrl" value="http://api-sandbox.europeanstudentcard.eu/v1" />
<property name="key" value="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" />
<property name="restTemplate" ref="restTemplate" />
<property name="countryCode" value="FR"/>
<property name="picInstitutionCode" value="000000000"/>
<!--
Type of cards. Possibles values are :
1 - passive card, with no electronic
2 - Smartcard without European common data zone
3 - Smartcard with European common data zone
4 - Smartcard on which application may be installed by service providers
-->
<property name="cardType" value="3"/>
</bean> |
applicationContext-paybox.xml
Permet le paramétrage du module paybox dans le cas d’un renouvellement de carte payant.
applicationContext-access-control.xml
Permet de paramétrer le chemin d'export des informations pour le controle d'accès. Formats disponibles:
- P2S
- TIL
- SYNCHRONIC
applicationContext-security.xml
Comme pour la configuration esup-nfc-tag, il s’agit de mapper les groups sur les rôles proposés par le SGC :
ADMIN
MANAGER
LIVREUR
UPDATER
CONSULT
USER (Liste des utilisateurs pouvant faire une demande de carte)
USER_NO_EDITABLE (Liste des utilisateurs dont les critères ne permettent pas l’edition de la carte, ex: dossier administratif incomplet)
USER_RENEWAL_PAYED (Liste des utilisateurs pouvant renouveler leur carte gratuitement)
ShibUseHeaders On
ShibRequestSetting applicationId esup-nfc-tag
</Location>
<Location /manager>
AuthType shibboleth
ShibRequestSetting requireSession 1
require shib-session
ShibUseHeaders On
ShibRequestSetting applicationId esup-nfc-tag
</Location>
<Location /admin>
AuthType shibboleth
ShibRequestSetting requireSession 1
require shib-session
ShibUseHeaders On
ShibRequestSetting applicationId esup-nfc-tag
</Location>
<Location /nfc>
AuthType shibboleth
ShibRequestSetting requireSession 1
require shib-session
ShibUseHeaders On
ShibRequestSetting applicationId esup-nfc-tag
</Location>
ProxyPass / ajp://localhost:8309/ ttl=10 timeout=3600 retry=1
AddOutputFilterByType DEFLATE text/plain text/html text/css text/javascript application/x-javascript application/javascript application/json image/svg+xml
</VirtualHost> |
A noter que l'applicationId
du ShibRequestSetting
diffère selon les VirtualHosts.
De plus, dans cet exemple, chaque VirtualHost dispose de son propre certificat. Il est tout à fait possible d'utiliser le même sous-réserve que les noms des deux VirtualHosts y soient indiqués (SAN).
En présentant la chaîne correctement et avec des certificats tels que proposés par Renater/Sectigo (les chemins ci-dessus correspondent à des exemples de chemins de certificats récupérés via le protocole ACME par certbot ... depuis Sectigo) le keystore par défaut de votre JVM suffira et vous n'avez pas besoin alors d'importer unitairement vos certificats dans le keystore java.
Si jamais vous avez un certificat issu d'une autorité de certification non reconnue par votre JVM (à proscrire) vous pouvez, en dernier recours, intégrer ce certificat au keystore ainsi par exemple:
Bloc de code | ||||
---|---|---|---|---|
| ||||
# on copie le cacerts initial pour conserver la confiance dans les autorités de certification racines par défaut
cp /etc/ssl/certs/java/cacerts /opt/esup.univ-ville.jks
# par défaut le password est changeit,on le modifie
keytool -storepasswd -keystore cacerts
# utile si on doit supprimer un ancien certificat expiré pour en mettre un nouveau
keytool -delete -alias mon_cert -keystore /opt/esup.univ-ville.jks
# on importe le certificat
keytool -import -file /etc/apache2/certs/esup-sgc.crt -alias sgc -trustcacerts -keystore /opt/esup.univ-ville.jks |
À nouveau, normalement, avec un certificat valide et bien présenté, vous n'avez pas besoin de réaliser cette opération sur le keystore java et vous n'avez pas besoin de fait d'avoir ce fichier keystore /opt/esup.univ-ville.jks
Activer les sites:
Bloc de code | ||||
---|---|---|---|---|
| ||||
a2dissite 000-default.conf
a2ensite esup-sgc.univ-ville.fr
a2ensite esup-nfc-tag.univ-ville.fr |
Installation du SP Shibboleth
Générer une nouvelle clé:
Bloc de code | ||||
---|---|---|---|---|
| ||||
shib-keygen |
Cette commande permet de générer les fichiers sp-key.pem
et sp-cert.pem
dans /etc/shibboleth/
Editer /etc/shibboleth/shibboleth2.xml
Avant la balise ApplicationDefaults, ajouter un RequestMap avec le nom des deux virtualhost:
Bloc de code | ||||
---|---|---|---|---|
| ||||
<RequestMapper type="Native">
<RequestMap applicationId="default">
<Host name="esup-nfc-tag.univ-ville.fr" applicationId="esup-nfc-tag" authType="shibboleth" requireSession="false"/>
<Host name="esup-sgc.univ-ville.fr" applicationId="esup-sgc" authType="shibboleth" requireSession="false"/>
</RequestMap>
</RequestMapper> |
Configurer la balise SSO pour utiliser le WAYF de Renater (ou un Idp par défaut sinon, cf variante en commentaires) :
Bloc de code | ||||
---|---|---|---|---|
| ||||
<ApplicationDefaults entityID="https://esup-sgc.univ-ville.fr" ...>
<Sessions ...>
<!--
<SSO entityID="https://idp.univ-ville.fr/idp/shibboleth">
SAML2 SAML1
</SSO>
-->
<SSO location="/"
discoveryProtocol="SAMLDS" discoveryURL="https://discovery.renater.fr/renater">
SAML2 SAML1
</SSO> |
Penser à modifier le contact du support:
Bloc de code | ||||
---|---|---|---|---|
| ||||
<Errors supportContact="sysadmin@univ-ville.fr" |
Votre fournisseur de Metadata Renater (ou directement l'IDP - variante donnée en commentaires ; si vous n'utilisez pas la fédération Renater ...) - notez ici l'usage du "Whitelist" sur la fédération Renater :
Attention si vous avez un sp en version 3, uri="https://xx" est ignoré et il faut mettre url= !!! L'erreur étant peu évidente à comprendre, c'est 1/2 journée perdue
Bloc de code | ||||
---|---|---|---|---|
| ||||
<!--
<MetadataProvider type="XML" validate="true"
url="https://idp.univ-ville.fr/idp/shibboleth"
backingFilePath="idp.univ-ville.fr-metadata.xml">
</MetadataProvider>
-->
<MetadataProvider type="XML" url="https://metadata.federation.renater.fr/renater/main/main-idps-renater-metadata.xml" backingFilePath="/etc/shibboleth/metadatas/main-idps-renater-metadata.xml" reloadInterval="7200">
<MetadataFilter type="RequireValidUntil" maxValidityInterval="2419200"/>
<MetadataFilter type="Signature" certificate="renater-metadata-signing-cert-2016.pem"/>
<MetadataFilter type="Whitelist">
<Include>urn:mace:cru.fr:federation:univ-rouen.fr</Include>
<Include>https://shibboleth.insa-rouen.fr/idp/shibboleth</Include>
</MetadataFilter>
</MetadataProvider>
|
Et enfin, avant la fermeture de la balise ApplicationDefaults, rajoutez un ApplicationOverride. Dans notre cas, le VirtualHost esup-sgc.univ-ville.fr utilisera le default, on utilisera un id spécifique pour esup-nfc-tag:
Bloc de code | ||||
---|---|---|---|---|
| ||||
<ApplicationOverride id="esup-nfc-tag" entityID="https://esup-nfc-tag.univ-ville.fr/shibboleth"/> |
Les Metadata doivent à présent être téléchargeables à ces adresses:
https://esup-sgc.univ-ville.fr/Shibboleth.sso/Metadata
https://esup-nfc-tag.univ-ville.fr/Shibboleth.sso/Metadata
Il reste donc à les intégrer à l'IDP, soit directement, soit en passant par la fédération d'identité.
Rotation des logs
Il est possible de mettre en place une rotation journalière des logs. La plupart des distributions fournissent logrotate. Il est donc possible de créer un fichier de config /etc/logrotate.d/esup-sgc
avec, par exemple, le contenu suivant:
Bloc de code | ||
---|---|---|
| ||
/opt/tomcat-esup-sgc/logs/catalina.out {
copytruncate
daily
missingok
rotate 30
compress
delaycompress
}
/opt/tomcat-esup-nfc-tag/logs/catalina.out {
copytruncate
daily
missingok
rotate 30
compress
delaycompress
} |
Sous Debian, il est également possible d'éditer le fichier /var/lib/logrotate/status
pour déterminer plus précisément la date de rotation (ceci est utile dans le cas d'une utilisation de lvm2 par exemple).
Installation
Éléments requis
Pour avoir un système de gestion de cartes fonctionnel, l'installation minimale consiste à installer :
- un serveur tomcat avec l'application web esup-sgc : Installation ESUP-SGC - Configurations ESUP-SGC et ESUP-NFC-TAG-SERVER
- un serveur tomcat avec l'application web esup-nfc-tag-server : ESUP-NFC-TAG-SERVER
L'ordre d'installation n'a pas d'importance. Toutefois, les deux applications étant dépendentes, la documentation d'installation d'ESUP-SGC comporte des configurations d'ESUP-NFC-TAG-SERVER
Pour enrôler et éventuellement encoder vos cartes vous avez également besoin d'un client esup-sgc-client : voir la documentation [archivé]
Installation materielle
Dans l'application esup-sgc-client, pour l'édition en 2 temps, l'encodage des cartes s'effectue à l'aide de la webcam et du lecteur de carte NFC. La webcam est disposée au dessus du lecteur de cartes de manière à le filmer. Lorsque qu'une carte est placée sur le lecteur la webcam lit le qrcode puis lance l'encodage.
Pour automatiser l'encodage des cartes il est possible d'utiliser une imprimante Zebra ZXP3. voir : Tuto robot encodeur basé sur une Zebra ZXP3
Pour plus d'informations sur les différentes possibilités d'édition, voir la page ESUP-SGC-Client et édition des cartes
Éléments optionnels
Vous pouvez également mettre en place les applications Esup-nfc-tag-desktop et Esup-nfc-tag-droid :
- Esup-nfc-tag-desktop : ESUP-NFC-TAG-DESKTOP
- Esup-nfc-tag-droid : ESUP-NFC-TAG-DROID
Alliées à ESUP-SGC, ces applications pourront vous permettre
- de rechercher une carte en la badgeant
- de marquer une carte comme "livrée" en la badgeant
...