7. Configuration avancée du Serveur WAPT

Le fichier de configuration du Serveur WAPT sur les systèmes GNU/ Linux et macOS se trouve dans /opt/wapt/conf/waptserver.ini ou dans /opt/wapt/waptserver/waptserver.ini.

Le fichier de configuration du Serveur WAPT sous Windows se trouve dans C:waptconfwaptserver.ini.

Attention

La modification de ces fichiers est réservée aux utilisateurs avancés !

7.1. Configurations par défaut du fichier waptserver et de nginx

7.1.1. Modifier la section [options] du fichier waptserver.ini

Plusieurs options peuvent être définies dans la section [options] .

[options]

Paramètres disponibles pour la section [options] du fichier waptserver.ini

Options (Valeur par défaut)	description	Exemple
agents_folder (défaut watpagent in wapt repository)	Définit où les Agents WAPT sont stockés sur le Serveur WAPT.	agents_folder = /var/www/wapt/waptagent
allow_unauthenticated_connect (défaut None)	Définit si les connexions websocket doivent être authentifiées. Si :code:use_kerberos = True, alors allow_unauthenticated_connect DOIT être mis à False car cette valeur sera prioritaire.	allow_unauthenticated_connect = True
allow_unauthenticated_registration (défaut False)	Permet l’enregistrement initial de l’Agent WAPT en utilisant un login et un mot de passe.	allow_unauthenticated_registration = True
allow_unsigned_status_data (défaut False)	Débogage uniquement - Permet à l’Agent d’envoyer des données d’état non signées.	allow_unsigned_status_data = True
application_root (défaut None)	Définit un chemin racine personnalisé pour le Serveur WAPT.	application_root = wapt
authentication_logs (défaut True)	Active les journaux d’authentification.	authentication_logs = False
auto_create_waptagent_from_config (défaut False)	Utilise le fichier de configuration automatique lorsque waptsetup est installé.	auto_create_waptagent_from_config = True
client_certificate_lifetime (défaut 3650)	Définit la durée de vie du certificat de la machine (en jours).	client_certificate_lifetime = 500
cleanup_kbs (défaut True)	Définit si les KB Windows non utilisés :ref:` doivent être automatiquement supprimés <auto_kb_clean>` du Serveur WAPT.	cleanup_kbs = False
clients_read_timeout (défaut 5)	Définit le délai d’attente du client websocket (en secondes).	clients_read_timeout = 10
clients_signing_certificate (défaut None)	Définit le certificat de signature de la machine.	clients_signing_certificate = C:\private\org-coder.crt
clients_signing_crl_days (défaut 30)	Définit la périodicité de la signature du certificat de la CRL de la machine (en jours).	clients_signing_crl_days = 15
clients_signing_crl (défaut None)	Définit le chemin de la CRL du certificat de signature machine.	clients_signing_crl = C:\private\org-coder.crt
clients_signing_crl_url (défaut None)	Définit l’URL de la CRL du certificat de signature machine.	clients_signing_crl_url = https://srvwapt.mydomain.lan/crl
clients_signing_key (défaut None)	Définit le chemin de la clé de signature du certificat de la machine.	clients_signing_key = C:\private\org-coder.crt
client_tasks_timeout (défaut 5)	Définit le délai maximum autorisé avant que l’Agent WAPT bascule en time-out (en secondes).	client_tasks_timeout = 5
copy_winpe_x64_in_tftp_folder (défaut False)	Si x64, permet de copier tous les WinPE à partir de wads_folder lorsque les WinPE sont téléchargés.	copy_winpe_x64_in_tftp_folder = True
db_connect_timeout (défaut 3)	Définit le délai maximum autorisé avant que les requêtes PostgreSQL n’expirent (en secondes).	db_connect_timeout = 10
db_host (défaut None)	Définit l’url du serveur PostgreSQL (par défaut WAPT utilise une socket Unix locale).	db_host = https://wapt.mydomain.lan
db_max_connections (défaut 90)	Définit le nombre maximum de connexions simultanées à la base de données PostgreSQL.	db_max_connections = 100
db_name (défaut wapt)	Définit la base de données PostgreSQL à laquelle le Serveur WAPT se connecte.	db_name = wapt
db_password (défaut None)	Définit le mot de passe pour authentifier l’utilisateur sur la base de données PostgreSQL (par défaut WAPT utilise une socket UNIX locale).	db_password = WAPT_DB_PASSWORD
db_port (défaut 5432)	Définit le port du serveur PostgreSQL.	db_port = 5432
db_stale_timeout (défaut 300)	Définit le délai d’expiration de la requête à la base de données (en secondes).	db_stale_timeout = 500
db_user (défaut wapt)	Définit l’utilisateur PostgreSQL qui se connecte à la base de données.	db_user = wapt
default_ldap_users_acls (défaut view)	Définit l’acl par défaut pour un nouvel utilisateur qui ouvre la Console WAPT.	default_ldap_users_acls = admin
download_wsusscn2 (défaut False)	Télécharge automatiquement le fichier :wsusscn2.cab.	download_wsusscn2 = False
enable_store (défaut False)	Active le store WAPT web (Déprécié).	enable_store = False
encrypt_host_packages (défaut False)	Chiffre le paquet hôte avec le certificat du client.	encrypt_host_packages = True
htpasswd_path (défaut None)	Ajoute l’authentification de base au Serveur WAPT.	htpasswd_path = True
http_proxy (défaut None)	Définit le serveur proxy pour permettre au Serveur WAPT de récupérer sa CRL.	http_proxy = http://srvproxy.mydomain.lan:3128
known_certificates_folder (défaut répertoire /ssl/)	Ajoute une CA supplémentaire connue pour vérifier les certificats.	known_certificates_folder = /opt/wapt/ssl/
ldap_account_service_login (défaut None)	Définit l’utilisateur UPN Active Directory pour le SSO et/ou le mode waptserver-ldap pour le self-service.	ldap_account_service_login = wapt-ldap@ad.tranquil.it
ldap_account_service_password (défaut None)	Définit le mot de passe de l’utilisateur pour le SSO et/ou le mode waptserver-ldap pour le self-service.	ldap_account_service_password = PASSWORD
ldap_auth_base_dn (défaut None)	Définit le DN de base de l’authentification LDAP.	ldap_auth_base_dn = dc=mydomain,dc=lan
ldap_auth_server (défaut None)	Définit le serveur d’authentification LDAP.	ldap_auth_server = srvads.mydomain.lan
ldap_auth_ssl_enabled (défaut True)	Définit l’authentification SSL sur les connexions LDAP.	ldap_auth_ssl_enabled = False
ldap_nesting_group_support (défaut True)	Permet la recherche de groupes imbriqués dans Active Directory.	ldap_nesting_group_support = False
ldap_primary_group_ad_support (défaut True)	Active la recherche sur les utilisateurs du groupe primaire d’Active Directory.	ldap_primary_group_ad_support = False
list_subnet_skip_login_wads (défaut [])	Liste les sous-réseaux sans exigence d’authentification.	list_subnet_skip_login_wads = 192.168.0.0/24,192.168.1.0/24
login_on_wads (défaut False)	Active l’authentification pour utiliser WADS (le format est user:password).	login_on_wads = True
loglevel (défaut warning)	Définit le niveau du journal d’historisation. Les valeurs possibles sont : debug, info, warning, critical.	loglevel = debug
max_clients (défaut 4096)	Définit le nombre maximum de connexions simultanées de clients WAPT.	max_clients = 2048
min_password_length (défaut 10)	Définit la longueur minimale du mot de passe du SuperAdmin.	min_password_length = 15
nginx_http (défaut 80)	Définit le port HTTP du serveur web Nginx (Windows uniquement).	nginx_http = 8080
nginx_https (défaut 443)	Définit le port HTTPS du serveur web Nginx (Windows uniquement).	nginx_https = 44380
optimized_authentication_logs (défaut True)	Si une de ces options est renseignée, le journal d’historisation ne l’enregistrera pas : waptagent_version, host_tasks_status, get_ad_groups, get_ad_sites, get_ad_ou_split, host_data, get_hosts , audit_data, wsus.windows_updates, wsus.windows_products, wsus.windows_updates_classifications, packages_for_hosts, enterprise.reporting_exec, known_packages, repositories.get_all_agentrepos, repositories.get_sync_version, repositories.get_all_rules, get_all_users_acls, known_signers_certificates, enterprise.reporting_list, usage_statistics, repositories.get_createupdatefilesync, repositories.get_sync_changelog, licences	optimized_authentication_logs = False
remote_repo_update_delay (default True)	Définit la périodicité à laquelle le Serveur WAPT vérifie l’état de synchronisation des dépôts distants (en minutes).	remote_repo_update_delay = 5
remote_repo_websockets (défaut True)	Permet la communication websocket avec les Agents WAPT configurés en tant que dépôts distants.	remote_repo_websockets = False
secret_key (défaut None)	Définit la chaîne aléatoire pour initialiser le serveur d’application Python Flask. La chaîne est générée lors de la première installation du Serveur WAPT et est unique pour chaque Serveur WAPT.	secret_key = FKjfzjfkF687fjrkeznfkj7678jknk78687
server_uuid (défaut None)	Définit l”UUID du Serveur WAPT (cet identifiant anonyme est utilisé pour les statistiques WAPT).	server_uuid = 76efezfa6-b309-1fez5-92cd-8ea48fc122dc
session_lifetime (défaut 126060)	Définit le temps maximum autorisé pour l’ouverture de la session (en secondes).	session_lifetime = 352120
signature_clockskew (défaut 300)	Définit la différence de temps maximale autorisée pour les websockets (en secondes).	signature_clockskew = 72000
token_lifetime (défaut 43200)	Définit la durée de vie du jeton d’authentification (en secondes).	token_lifetime = 43200
trusted_signers_certificates_folder (défaut None)	Définit le chemin d’accès au répertoire des certificats des signataires de confiance.	trusted_signers_certificates_folder = C:\private\org-coder.crt
trusted_users_certificates_folder (défaut None)	Définit le chemin d’accès au répertoire des certificats CA des utilisateurs de confiance.	trusted_users_certificates_folder = C:\private\org-coder.crt
use_kerberos (par défaut False)	Permet à un Agent WAPT de s’enregistrer en utilisant son compte kerberos. Si :code:use_kerberos = True, alors allow_unauthenticated_connect DOIT être mis à False, sinon ce paramètre sera prioritaire.	use_kerberos = True
use_ssl_client_auth (défaut False)	Active l’authentification par certificat client.	use_ssl_client_auth = True
verify_cert_ldap (défaut True)	Vérifie si le certificat SSL / TLS d’Active Directory est valide pour les connexions LDAP.	verify_cert_ldap = False
wads_enable (défaut False)	Active la fonctionnalité WADS et active wapttftpserver.	wads_enable = True
wads_folder (défaut répertoire wads dans le dépôt WAPT)	Définit le répertoire sur le Serveur WAPT qui stocke les fichiers liés à WADS.	wads_folder = /var/www/waptwads
wapt_admin_group_dn (défaut None)	Définit le DN LDAP du groupe d’utilisateurs Active Directory autorisé à se connecter à la Console WAPT.	wapt_admin_group_dn = CN=waptadmins,OU=groups,DC=ad,DC=mydomain,DC=lan
wapt_admin_group (défaut None)	Définit le(s) groupe(s) d’utilisateurs Active Directory sAMAccountName autorisé(s) à se connecter à la Console WAPT. La valeur peut être plusieurs groupes, séparés par des virgules.	wapt_admin_group = waptadmins, wapttechs
wapt_folder (défaut /var/www/wapt ou /var/www/html/wapt ou root_dir/waptserver/repository/wapt)	Définit le chemin vers le dépôt principal de WAPT.	wapt_folder = /var/www/wapt
wapt_huey_db (défaut None)	Définit le chemin vers la base de données qui stocke l’état des tâches en cours.	wapt_huey_db = C:\Program Files(x86)\wapt\db\waptservertasks.sqlite
wapt_password (défaut None)	Définit le mot de passe du SuperAdmin pour la connexion à la Console WAPT.	wapt_password = 46642dd2b1dfezfezgfezgadf0ezgeezgezf53d
waptserver_port (défaut 8080)	Définit le port du service python du Serveur WAPT.	waptserver_port = 1313
wapt_user (défaut admin)	Définit le nom d’utilisateur du SuperAdmin dans la Console WAPT.	wapt_user = wapt_admin
waptwua_folder (défaut wapt_folder + “wua”)	Définit l’emplacement du dossier WAPT WUA.	waptwua_folder = /var/www/waptwua
wol_port (défaut 7,9)	Définit la liste des ports UDP auxquels envoyer des paquets magiques WakeOnLAN.	wol_port = 9, 123, 4000
wapt_bind_interface (défaut 127.0.0.1)	Définit comment écouter le service du Serveur WAPT.	wapt_bind_interface = 127.0.0.1
ipxe_script_jinja_path (défaut /opt/wapt/waptserver/templates/ipxe-default.j2)	Définit l’emplacement du modèle jinja utilisé pour le script ipxe dans WADS.	ipxe_script_jinja_path = /opt/wapt/waptserver/templates/ipxe-autoregister.j2

7.1.2. Configuration de Nginx

La configuration par défaut de Nginx est la suivante :

# uwsgi upstream  server
upstream waptserver {
  server unix:///run/waptserver/uwsgi.sock;
}




log_format combined_ssl '$remote_addr $ssl_client_s_dn $ssl_client_verify $remote_user [$time_local] '
                    '"$request" $status $body_bytes_sent '
                    '"$http_referer" "$http_user_agent"';

server {

    listen                      80;

    listen                      [::]:80;


    listen                      443 ssl;

    listen                      [::]:443 ssl;




    server_name                 srvwapt.mydomain.lan;

    server_name                 192.168.100.12;




    access_log "/var/log/nginx/access.log" combined_ssl;


    ssl_certificate             "/opt/wapt/waptserver/ssl/cert.pem";
    ssl_certificate_key         "/opt/wapt/waptserver/ssl/key.pem";
    ssl_protocols               TLSv1.2;

    ssl_dhparam                 "/etc/ssl/certs/dhparam.pem";


    ssl_prefer_server_ciphers   on;
    ssl_ciphers                 'EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH';
    ssl_stapling                on;
    ssl_stapling_verify         on;
    ssl_session_cache           none;
    ssl_session_tickets         off;

    # HSTS (ngx_http_headers_module is required) (63072000 seconds)
    add_header Strict-Transport-Security "max-age=63072000" always;


    ssl_client_certificate "/opt/wapt/conf/ca-srvwapt.mydomain.lan.crt";

    ssl_crl "/opt/wapt/conf/ca-check-clients.crl";

    ssl_verify_client optional;


    gzip_min_length     1000;
    gzip_buffers        4 8k;
    gzip_http_version   1.0;
    gzip_disable        "msie6";
    gzip_types          text/plain text/css application/json;
    gzip_vary           on;

    index index.html;

  server_tokens off;

    client_max_body_size 12288m;
    client_body_timeout 1800;

    large_client_header_buffers 4 16k;
    proxy_headers_hash_max_size 1024;
    proxy_headers_hash_bucket_size 128;

    proxy_request_buffering off;

    location ^~ /.well-known/acme-challenge/ {
      default_type "text/plain";
      root         /var/www/html;
    }

    # sub instances
    include "/opt/wapt/conf/wapt.d/*.conf";

    location /static {
            alias "/opt/wapt/waptserver/static";
    }


    location /ssl {
            alias "/var/www/ssl";
    }


    # not protected URL
    location ~ ^/(wapt/waptsetup.*\.exe|wapt/ping|wapt/waptagent/.*|wapt/waptagent\.exe|wapt/waptdeploy\.exe|wapt/conf\.d/.*\.json)$ {
        add_header Cache-Control "store, no-cache, must-revalidate, post-check=0, pre-check=0";
        add_header Pragma "no-cache";
        root "/var/www";
    }

    location ~ ^/api/v3/(wads_register_host|set_host_wads_status|baseipxe|get_host_ipxe|get_wads_exe.*|get_wads_config)$ {

            proxy_http_version 1.1;
            proxy_request_buffering off;

            include "/opt/wapt/conf/forward_ssl_auth.conf";

            rewrite /(.*) /$1 break;

            proxy_pass http://127.0.0.1:8080;



    }


    # not protected URL
    location /wads {

      alias "/var/www/wads";

    }


    location = / {
      include "/opt/wapt/conf/forward_ssl_auth.conf";
      proxy_pass http://127.0.0.1:8080;
    }



    # SSL protected URL
    location /waptwua {
        add_header Cache-Control "store, no-cache, must-revalidate, post-check=0, pre-check=0";
        add_header Pragma "no-cache";


        include "/opt/wapt/conf/forward_ssl_auth.conf";

        include "/opt/wapt/conf/require_ssl_auth.conf";

        alias "/var/www/waptwua";


    }

    # SSL protected URL
    location ~ ^/(wapt/.*|wapt-diff-repos/.*|licences\.json|sync\.json)$ {
        add_header Cache-Control "store, no-cache, must-revalidate, post-check=0, pre-check=0";
        add_header Pragma "no-cache";

        include "/opt/wapt/conf/forward_ssl_auth.conf";

        include "/opt/wapt/conf/require_ssl_auth.conf";


        root "/var/www";
    }


    location /rules.json {
        add_header Cache-Control "store, no-cache, must-revalidate, post-check=0, pre-check=0";
        add_header Pragma "no-cache";

        include "/opt/wapt/conf/forward_ssl_auth.conf";

        root "/var/www";
    }


    # we don't want to expose our list of computers in case someone scan this folder.
    location /wapt-host/Packages {
        return 403;
    }

    location ~ ^/(wapt-host/.*)$ {
        log_not_found off;
        add_header Cache-Control "store, no-cache, must-revalidate, post-check=0, pre-check=0";
        add_header Pragma "no-cache";

        include "/opt/wapt/conf/forward_ssl_auth.conf";

        include "/opt/wapt/conf/require_ssl_auth.conf";


        root "/var/www";
    }


    location ~ ^/.*_kerberos$ {

        proxy_http_version 1.1;
        proxy_request_buffering off;

        include "/opt/wapt/conf/forward_ssl_auth.conf";

        auth_gss on;
        auth_gss_format_full on;
        auth_gss_keytab  /etc/nginx/http-krb5.keytab;
        proxy_pass http://127.0.0.1:8080;

    }

    # we need socketio for these actions.
    # they are enabled only locally on the loopback
    location ~ ^/api/v3/(update_hosts_sid_table|hosts_sid)$ {
        proxy_http_version 1.1;
        proxy_request_buffering off;

        include "/opt/wapt/conf/forward_ssl_auth.conf";

        rewrite /(.*) /$1 break;
        proxy_pass http://127.0.0.1:8080;
        allow 127.0.0.1;
        deny all;
    }

    # we need socketio for these actions
    location ~ ^/api/v3/(update_hosts_sid_table|trigger_host_action|reset_hosts_sid|host_tasks_status|trigger_cancel_task|hosts_delete|launch_sync_on_remotes_repos|broadcast_sync_on_remotes_repo)$ {
        proxy_http_version 1.1;
        proxy_request_buffering off;

        include "/opt/wapt/conf/forward_ssl_auth.conf";

        include "/opt/wapt/conf/require_ssl_auth.conf";


        rewrite /(.*) /$1 break;
        proxy_pass http://127.0.0.1:8080;
    }

    location /get_websocket_auth_token {
        return 404;
    }

    # these actions are not protected by SSL client side certificate, as we perhaps don't have one at this stage.
    # in case uwsgi is enabled, we wat this to still be handled by eventlet waptserver as these endpoints are not cpu intensive but often called
    location ~ ^/(ping)$ {
        proxy_http_version 1.1;
        proxy_request_buffering off;

        include "/opt/wapt/conf/forward_ssl_auth.conf";

        rewrite /(.*) /$1 break;
        proxy_pass http://127.0.0.1:8080;
    }

    # these actions are not protected by SSL client side certificate, as we perhaps don't have one at this stage.
    location ~ ^/(login|api/v3/login|api/v3/logout|api/v3/get_hash_json_content|api/v3/waptagent_version|add_host|api/v3/add_host|api/v3/get_waptagent_exe/.*/waptagent.exe)$ {
        proxy_http_version 1.1;
        proxy_request_buffering off;

        include "/opt/wapt/conf/forward_ssl_auth.conf";

        rewrite /(.*) /$1 break;

        include    /opt/wapt/conf/uwsgi_params;
        uwsgi_pass  waptserver;

    }

    location / {
        proxy_http_version 1.1;
        proxy_request_buffering off;

        include "/opt/wapt/conf/forward_ssl_auth.conf";

        include "/opt/wapt/conf/require_ssl_auth.conf";



        include     /opt/wapt/conf/uwsgi_params;
        uwsgi_pass  waptserver;

    }

    location /socket.io {
        proxy_http_version 1.1;
        proxy_request_buffering off;

        include "/opt/wapt/conf/forward_ssl_auth.conf";

        include "/opt/wapt/conf/require_ssl_auth.conf";


        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "Upgrade";
        proxy_pass http://127.0.0.1:8080/socket.io;
    }
}

7.2. Configuration du Serveur WAPT pour les grands déploiements

Les paramètres par défaut du système d’exploitation, de Nginx et de Postgresql sont adaptés pour environ 400 Agents WAPT. Si vous avez plus de 400 clients, il est nécessaire de modifier quelques paramètres au niveau du système ainsi que la base de données PostgreSQL, le serveur web Nginx et le Serveur python WAPT.

Dans le futur, le script postconf.sh pourra prendre en charge cette configuration en fonction du nombre d’ordinateurs clients attendus.

Avec les paramètres suivants, un Serveur WAPT devrait pouvoir fonctionner avec environ 5000 clients actifs simultanés. Vous pouvez avoir plus de clients dans la base de données s’ils ne fonctionnent pas tous en même temps. Si vous avez plus de 5000 clients, il est recommandé d’avoir plus d’un Serveur WAPT.

La limite du nombre de clients finaux est due à un goulot d’étranglement dans le code python et le backend PostgreSQL. Les performances de WAPT s’améliorent avec le temps et, à l’avenir, le Serveur WAPT pourrait supporter une large base sur un seul serveur. Cependant, la partie Nginx s’adapte très bien et peut tirer pleinement parti d’une connexion 10Gbps pour les déploiements de paquets à forte charge.

Note

Les paramètres à modifier ci-dessous sont liés entre eux et doivent être modifiés globalement et non individuellement.

7.2.1. Configuration de Nginx

nginx.conf emplacement du fichier de configuration

Type d’OS	Localisation des fichiers
Debian et dérivées	/etc/nginx/nginx.conf
RedHat et dérivées	/etc/nginx/nginx.conf
Windows	C:\wapt\waptserver\nginx\conf\nginx.conf

Dans le fichier nginx.conf, modifiez le paramètre worker_connections. La valeur doit être d’environ 2,5 fois le nombre de clients WAPT (n connexions pour les websockets et n connexions pour les téléchargements de packages et le téléchargement d’inventaire + une certaine marge).

events {
  worker_connections 4096;
}

Mettez ensuite à jour le nombre de filedescriptors dans le fichier /etc/nginx/nginx.conf pour linux ou pour Windows C:\wapt\waptserver\nginx\conf\nginx.conf :

worker_rlimit_nofile 32768;

En fonction du partitionnement de votre Serveur WAPT, vous devrez peut-être faire attention au répertoire de téléchargement de fichiers temporaires de Nginx. Nginx agit comme un proxy inverse pour le moteur Python du Serveur WAPT et fait une mise en cache des paquets téléchargés lors du téléchargement d’un nouveau paquet depuis la console.

Les paquets sont stockés dans le répertoire /var/lib/nginx/proxy. Vous devez vous assurer que la partition qui héberge ce répertoire est suffisamment grande. Vous pouvez modifier l’emplacement de ce répertoire en utilisant le paramètre de configuration suivant de Nginx.

$client_body_temp_path

7.2.2. Configuration du système Linux

Augmenter le nombre de filedescriptors. Le fichier d’unité du système demande une augmentation du nombre autorisé de filedescriptors (LimitNOFILE=32768). Nous devrions avoir la même chose pour Nginx. Il y a quelques limites à modifier.

Tout d’abord, nous modifions au niveau du système le nombre de filedescriptors autorisés pour Nginx et WAPT.

• Créer /etc/security/limits.d/wapt.conf.

cat > /etc/security/limits.d/wapt.conf <<EOF
wapt         hard    nofile      32768
wapt         soft    nofile      32768
www-data     hard    nofile      32768
www-data     soft    nofile      32768
EOF

Nginx sert de proxy inverse et établit un grand nombre de connexions. Chaque client WAPT maintient une connexion websocket en permanence afin de répondre aux actions du Serveur WAPT.

Le noyau Linux a une protection contre le fait d’avoir trop de connexions TCP ouvertes en même temps et on peut obtenir le message SYN flooding on port dans le journal de Nginx. Afin d’éviter ces messages, il est nécessaire de modifier les deux paramètres suivants. Il doit être environ 1,5 fois le nombre de clients WAPT.

cat > /etc/sysctl.d/wapt.conf <<EOF
net.ipv4.tcp_max_syn_backlog=4096
net.core.somaxconn=4096
EOF

sysctl --system

7.2.3. Configuration de la base de données PostgreSQL

postgresql.conf emplacement du fichier de configuration

Type d’OS	Localisation des fichiers
Debian et dérivées	/etc/postgresql/{version}/main/postgresql.conf
RedHat et dérivées	/var/lib/pgsql/{version}/data/postgresql.conf
Windows	C:\wapt\waptserver\pgsql{version}_data\postgresql.conf

Un plus grand nombre de clients nécessite un plus grand nombre de connexions à la base de données PostgreSQL. Dans le fichier postgresql.conf vous devez augmenter le paramètre suivant pour atteindre approximativement 1/4 du nombre d’Agents WAPT actifs.

max_connections = 1000

Dans le fichier /opt/wapt/conf/waptserver.ini (pour Windows C:\wapt\conf\waptserver.ini, db_max_connections` doit être égal au max_connections` de PostgreSQL moins 10 (PostgreSQL a besoin de garder quelques connexions pour son ménage). Le paramètre max_clients devrait être fixé à environ 1,2 fois le nombre d’Agents WAPT :

[options]
...
max_clients = 4096
db_max_connections = 990

7.3. Utiliser des lignes de commande pour la gestion des dépôts

7.3.1. wapt-get upload-package

La commande wapt-get upload-package <chemin vers le paquet> télécharge un paquet sur le dépôt principal de WAPT.

La commande wapt-get upload-package C:\waptdev\tis-tightvnc.wapt renvoie :

Using config file: C:\Users\documentation\AppData\Local\waptconsole\waptconsole.ini
Uploading packages to https://srvwapt.mydomain.lan
Please get login for https://srvwapt.mydomain.lan/api/v3/upload_xxx:admin
Password:
c:\waptdev\tis-tightvnc.wapt[================================] 54316019/54316019 - 00:00:17
OK : 1 Packages uploaded, 0 errors

7.3.2. wapt-get sign-package

Indication

Cette commande s’applique aux dépôts Windows ** UNIQUEMENT**.

La commande wapt-get scan-packages <répertoire> reconstruit un fichier Packages pour un dépôt de paquets WAPT.

La commande wapt-get scan-packages C:waptwaptserverrepositorywapt renvoie :

Using config file: C:\Program Files (x86)\wapt\wapt-get.ini
Packages filename: C:\wapt\waptserver\repository\wapt
Processed packages:
  C:\wapt\waptserver\repository\wapt\tis-firefox.wapt
  C:\wapt\waptserver\repository\wapt\tis-tightvnc.wapt
  C:\wapt\waptserver\repository\wapt\tis-7zip.wapt
Skipped packages:

7.3.3. wapt-get sign-package

Indication

Cette commande s’applique aux dépôts Linux ** UNIQUEMENT**.

La commande wapt-scanpackages <répertoire> reconstruit un fichier Packages pour un dépôt de paquets WAPT.

La commande wapt-scanpackages /var/www/wapt/ ne renvoie rien.

7.3.4. Re-signer des paquets sur le Serveur WAPT en utilisant une ligne de commande

Utilisez cette méthode si la re-signature à partir de la méthode de la Console WAPT n’aboutit pas. Ces commandes sont UNIQUEMENT disponibles pour les Serveurs WAPT fonctionnant sous Linux.

Avertissement

Avant d’utiliser cette méthode, assurez-vous que votre Serveur WAPT est sûr et n’est pas sous le contrôle d’une entité tierce non autorisée.

• Copiez vos .crt et .pem dans /tmp/ sur le Serveur WAPT en utilisant Winscp ou un outil équivalent.

• Il est alors possible de re-signer tous les paquets en une seule fois sur le Serveur WAPT avec les commandes suivantes.

wapt-signpackages -d /var/www/wapt-host -c /tmp/wapt_pub_key.crt -k /tmp/wapt_priv_key.pem -s
wapt-signpackages -d /var/www/wapt -c /tmp/wapt_pub_key.crt -k /tmp/wapt_priv_key.pem -s
wapt-scanpackages /var/www/wapt/

Si l’erreur Access violation apparaît, la raison en est que le paquet WAPT est trop volumineux.

Modifier le paquet et vérifier cette procédure pour transférer un paquet volumineux.

Danger

Supprimer les fichiers .crt et .pem de /tmp/ sur le Serveur WAPT ou le serveur deviendra un bien sensible.

Pour plus d’options disponibles, veuillez consulter la section ligne de commande.

8. Renforcer la sécurité de votre installation WAPT - Côté Serveur

Par défaut, tous les paquets WAPT sont signés avec votre clé privée, ce qui offre déjà un haut niveau de sécurité. Cependant, vous pouvez améliorer davantage la sécurité de WAPT.

Pour sécuriser complètement votre installation WAPT, vous devez procéder comme suit :

• Activez l’enregistrement authentifié pour filtrer les personnes autorisées à enregistrer le périphérique auprès du Serveur WAPT.

• Activez la vérification du certificat https sur les Agents et la Console WAPT pour vous assurer que les Agents WAPT et la Console WAPT se connectent au bon Serveur WAPT.

• Configurez l’authentification Active Directory pour permettre l’accès à la Console WAPT uniquement aux administrateurs WAPT autorisés.

• Activez l’authentification par certificat côté client pour n’autoriser que les appareils authentifiés à accéder au Serveur WAPT (Remarque : c’est particulièrement important si vous voulez exposer votre Serveur WAPT à l’extérieur dans une DMZ).

• Si vous utilisez la version Enterprise de WAPT et que vous exploitez une grande flotte avec plusieurs administrateurs, vous serez peut-être intéressé de savoir comment configurer et appliquer correctement les ACLs.

8.1. Configuration du pare-feu sur le Serveur WAPT

La configuration du pare-feu du Serveur WAPT est essentielle et devrait être la première étape pour obtenir une meilleure sécurité dans WAPT.

Comme WAPT vise à être sécurisé dès la conception, seul un ensemble minimal de ports ouverts est nécessaire sur le Serveur WAPT par rapport aux autres solutions.

Vous trouverez dans la documentation suivante des conseils autour des configurations de pare-feu pour renforcer la sécurité du Serveur WAPT.

8.1.1. Configuration du pare-feu pour le serveur WAPT sur Debian et dérivées

Par défaut sur Debian Linux, aucune règle de pare-feu ne s’applique.

• Désactivez ufw et installez firewalld à la place.

ufw disable
apt update
apt -y install firewalld

• Il suffit d’appliquer cette configuration firewalld.

systemctl start firewalld
systemctl enable firewalld
firewall-cmd --zone=public --add-port=80/tcp --permanent
firewall-cmd --zone=public --add-port=443/tcp --permanent
systemctl restart firewalld

8.1.2. Configuration du pare-feu pour le Serveur WAPT sur RedHat et dérivées

• Il suffit d’appliquer cette configuration firewalld.

systemctl start firewalld
systemctl enable firewalld
firewall-cmd --zone=public --add-port=80/tcp --permanent
firewall-cmd --zone=public --add-port=443/tcp --permanent
systemctl restart firewalld

8.2. Configuration de l’authentification kerberos

Note

• Sans l’authentification kerberos, vous devez soit faire confiance à l’enregistrement initial, soit saisir un mot de passe pour chaque poste de travail lors de l’enregistrement initial.

• Pour plus d’informations, consultez la documentation sur l’enregistrement d’une machine auprès du Serveur WAPT et la signature des mises à jour d’inventaire.

• L’authentification kerberos sera utilisée uniquement lors de l’enregistrement de la machine.

8.2.1. Installation des composants kerberos et configuration du fichier krb5.conf

Debian and derivativesRedHat and derivatives

apt install krb5-user msktutil libnginx-mod-http-auth-spnego

Note

L’enregistrement avec kerberos n’est pas disponible avec un Serveur WAPT fonctionnant sous Windows.

Modifiez le fichier /etc/krb5.conf et remplacez tout le contenu par les 4 lignes suivantes en remplaçant MYDOMAIN.LAN par votre nom de domaine Active Directory (i.e. <MYDOMAIN.LAN>).

Attention

La valeur default_realm doit être écrit en MAJUSCULES ! ! !

[libdefaults]
  default_realm = MYDOMAIN.LAN
  dns_lookup_kdc = true
  dns_lookup_realm=false

Récupérer un keytab de service. Utiliser les commandes kinit et klist. Vous pouvez utiliser un compte Administrateur ou tout autre compte ayant le droit délégué de joindre un ordinateur au domaine dans le conteneur de destination approprié (par défaut CN=Computers).

Dans la transcription shell ci-dessous, les commandes sont en noir et le texte renvoyé est commenté en gris clair :

sudo kinit administrator
## Password for administrator@MYDOMAIN.LAN:
## Warning: Your password will expire in 277 days on Mon. 17 sept. 2018 10:51:21 CEST
sudo klist
## Ticket cache: FILE:/tmp/krb5cc_0
## Default principal: administrator@MYDOMAIN.LAN
##
## Valid starting       Expires              Service principal
## 01/12/2017 16:49:31  02/12/2017 02:49:31  krbtgt/MYDOMAIN.LAN@MYDOMAIN.LAN
## renew until 02/12/2017 16:49:27

Si la demande d’authentification est réussie, vous pouvez alors créer votre Keytab HTTP avec la commande msktutil.

Veillez à modifier la chaîne <DOMAIN_CONTROLER> avec le nom de votre contrôleur de domaine (par exemple : srvads.mydomain.lan).

sudo msktutil --server DOMAIN_CONTROLER --precreate --host $(hostname) -b cn=computers --service HTTP --description "host account for wapt server" --enctypes 24 -N
sudo msktutil --server DOMAIN_CONTROLER --auto-update --keytab /etc/nginx/http-krb5.keytab --host $(hostname) -N

Attention

Assurez-vous d’avoir correctement configuré votre nom d’hôte de Serveur WAPT avant d’exécuter ces commandes ;

Afin de vérifier votre nom d’hôte, vous pouvez exécuter echo $(hostname) et il DOIT renvoyer le nom qui sera utilisé par l’Agent WAPT exécuté sur les postes de travail clients. Si votre Serveur WAPT est disponible sur Internet, vous devez ajouter un autre servicePrincipalName (SPN) pour qu’il corresponde à l’URL publique WAPT. Pour pouvoir mettre à jour le fichier keytab, vous devez lancer une seconde fois la commande msktutil à chaque fois que vous allez ajouter un nouveau SPN.

You can add an auto-update task in crontab. It will frequently change the machine account password in Active Directory so you can pass security audits. Crontab content:

32 23 3 * * root msktutil --auto-update --keytab /etc/nginx/http-krb5.keytab

• Appliquez les droits d’accès appropriés au fichier http-krb5.keytab. Si vous avez un système d’exploitation basé sur Redhat avec selinux, veuillez fixer les droits avec restorecon.

Debian and derivativesRedHat and derivatives

sudo chmod 640 /etc/nginx/http-krb5.keytab
sudo chown root:www-data /etc/nginx/http-krb5.keytab

8.2.2. Post-configuration de kerberos pour le Serveur WAPT

Vous pouvez maintenant utiliser le script de post-configuration pour configurer le Serveur WAPT afin d’utiliser kerberos.

Le script de post-configuration va configurer Nginx et le Serveur WAPT pour utiliser l’authentification kerberos.

Indication

Ce script de post-configuration DOIT être exécuté en tant que root.

/opt/wapt/waptserver/scripts/postconf.sh --force-https

L’authentification Kerberos sera maintenant configurée.

8.2.3. Cas particuliers d’utilisation

8.2.3.1. Mon Serveur WAPT n’a pas accès à un Active Directory en écriture

• Connectez-vous à votre Active Directory (pas un RODC).

• Créez un compte d’ordinateur srvwapt.

• Ajouter un SPN sur le compte srvwapt$.

setspn -A HTTP/srvwapt.mydomain.lan srvwapt

• Créer un keytab pour ce Serveur WAPT.

ktpass -out C:\http-krb5.keytab -princ HTTP/srvwapt.mydomain.lan@MYDOMAIN.LAN rndpass -minpass 64 -crypto all -pType KRB5_NT_PRINCIPAL /mapuser srvwapt$@MYDOMAIN.LAN
Reset SRVWAPT$'s password [y/n]? y

Note

Si l’adresse de votre Serveur WAPT est différente de celle de votre domaine Active Directory, remplacez HTTP/srvwapt.mydomain.lan@MYDOMAIN.LAN par HTTP/srvwapt.othername.com@MYDOMAIN.LAN.

• Transférez ce fichier dans /etc/nginx/ (avec winscp par exemple).

• Appliquez les droits d’accès appropriés au fichier http-krb5.keytab. Si vous avez un système d’exploitation basé sur Redhat avec selinux, veuillez fixer les droits avec restorecon.

Debian and derivativesRedHat and derivatives

sudo chmod 640 /etc/nginx/http-krb5.keytab
sudo chown root:www-data /etc/nginx/http-krb5.keytab

8.2.3.2. L’Agent WAPT n’a accès qu’à un contrôleur de domaine RODC

• Pour RODC, ajoutez le compte srvwapt au groupe de mots de passe autorisés pour la réplication.

• N’oubliez pas de précharger le mot de passe du Serveur WAPT avec les différents serveurs RODC.

8.2.3.3. Vous avez plusieurs domaines Active Directory, avec ou sans relations

Si vous avez plusieurs domaines Active Directory, vous devez créer un keytab par domaine en suivant la procédure ci-dessus, ex :

• http-krb5-domain1.local.keytab ;

• http-krb5-domain2.local.keytab ;

• http-krb5-domain3.local.keytab.

Vous devrez ensuite fusionner tous ces keytabs en un unique keytab :

ktutil
read_kt http-krb5-domain1.local.keytab
read_kt http-krb5-domain2.local.keytab
read_kt http-krb5-domain3.local.keytab
write_kt http-krb5.keytab

8.2.4. Débugger les problèmes avec les kerberos

Attention

• L’adresse du Serveur WAPT ne peut pas être une IP, Kerberos ne fonctionne bien qu’avec le DNS.

• Dans votre test, l’url utilisée doit être exactement la même adresse que celle indiquée dans C:\Program Files (x86)\waptwapt-get.ini.

8.2.4.1. Avez-vous redémarré nginx correctement ?

systemctl restart nginx

8.2.4.2. Vérifier les permissions du fichier http-krb5.keytab

[root@srvwapt.mydomain.lan]# ls -l /etc/nginx/http-krb5.keytab
-rw-r----- 1 root www-data 921 janv. 4 16:20 /etc/nginx/http-krb5.keytab

8.2.4.3. Le mode kerberos est-il actif sur mon Agent WAPT ?

Sur la machine Windows :

• Vérifiez dans votre C:\Program Files (x86)\wapt\wapt-get.ini que la valeur use_kerberos est True.

[global]
use_kerberos=True

• Si vous modifiez cette valeur, n’oubliez pas de redémarrer le service WAPT.

net stop waptservice
net start waptservice

8.2.4.4. Le mode Kerberos est-il actif sur mon Serveur WAPT ?

Sur la machine linux :

• Vérifiez dans votre /opt/wapt/conf/waptserver.ini que la valeur use_kerberos est True.

[options]
use_kerberos=True

• Vérifiez dans votre /etc/nginx/sites-enabled/wapt.conf que cette configuration est présente.

location ~ ^/.*_kerberos$ {

      proxy_http_version 1.1;
      proxy_request_buffering off;

      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

      # be sure these headers are not forwarded
      proxy_set_header X-Ssl-Client-Dn "";
      proxy_set_header X-Ssl-Authenticated "";

      auth_gss on;
      auth_gss_keytab /etc/nginx/http-krb5.keytab;
      proxy_pass http://127.0.0.1:8080;

  }

• Si l’une des deux configurations n’est pas présente, redémarrez la post-configuration et activez kerberos.

8.2.4.5. Vérification que le fichier keytab contient l’url correcte

[root@srvwapt.mydomaine.lan]# KRB5_KTNAME=/etc/nginx/http-krb5.keytab klist -k
Keytab name: FILE:/etc/nginx/http-krb5.keytab
KVNO Principal
---- --------------------------------------------------------------------------
   ...
   3 HTTP/srvwapt.ad.mydomain.lan@AD.MYDOMAIN.LAN
   ...

8.2.4.6. Essayer d’enregistrer l’hôte en utilisant un compte système

Pour passer à un compte système, vous DEVEZ utiliser l’outil psexe de Microsoft : psexe.

• Dans cmd en tant qu’administrateur.

C:\Users\\xxxxxx\\Downloads\\PSTools\\psexec.exe -accepteula -s -i cmd

• Dans la nouvelle fenêtre cmd, vérifiez que vous êtes identifié comme System.

C:\WINDOWS\\system32>whoami

NT AUTHORITY\System

• Exécutez la commande register.

wapt-get register

8.2.4.7. Tenter une authentification avec le keytab de votre Serveur WAPT

• Sur la machine linux.

[root@srvwapt.ad.tranq ~]# ktutil
ktutil: read_kt /etc/nginx/http-krb5.keytab
ktutil: list
slot KVNO Principal
---- ---- ---------------------------------------------------------------------
  1    3                  srvwapt$@AD.TRANQUIL.IT
  2    3                  srvwapt$@AD.TRANQUIL.IT
  3    3                  srvwapt$@AD.TRANQUIL.IT
  4    3                  SRVWAPT$@AD.TRANQUIL.IT
  5    3                  SRVWAPT$@AD.TRANQUIL.IT
  6    3                  SRVWAPT$@AD.TRANQUIL.IT
  7    3              host/srvwapt@AD.TRANQUIL.IT
  8    3              host/srvwapt@AD.TRANQUIL.IT
  9    3              host/srvwapt@AD.TRANQUIL.IT
 10    3 HTTP/srvwapt.ad.tranquil.it@AD.TRANQUIL.IT
 11    3 HTTP/srvwapt.ad.tranquil.it@AD.TRANQUIL.IT
 12    3 HTTP/srvwapt.ad.tranquil.it@AD.TRANQUIL.IT
ktutil: quit
[root@srvwapt.ad.tranq ~]# kinit -k -t /etc/nginx/http-krb5.keytab srvwapt\$@AD.TRANQUIL.IT
[root@srvwapt.ad.tranq ~]# klist
Ticket cache: FILE:/tmp/krb5cc_0
Default principal: srvwapt$@AD.TRANQUIL.IT

Valid starting       Expires              Service principal
05/02/2021 19:06:05  06/02/2021 05:06:05  krbtgt/AD.TRANQUIL.IT@AD.TRANQUIL.IT
  renew until 06/02/2021 19:06:05

8.2.4.8. Vérification de la réussite de l’obtention d’un ticket Kerberos

Attention

Exécutez toujours les commandes dans le compte système (voir le point précédent) !

klist purge
klist get http/srvwapt.ad.mydomain.lan

Vous devez obtenir (dans votre langue) :

C:\Windows\System32>klist get http/srvwapt.ad.mydomain.lan

LogonId est 0:0x13794d
Un ticket pour http/srvwapt.ad.mydomain.lan a été récupéré.

Tickets mis en cache : (2)

#0> Client : sfonteneau @ AD.MYDOMAIN.LAN
  Serveur : krbtgt/AD.MYDOMAIN.LAN @ AD.MYDOMAIN.LAN
  Type de chiffrement KerbTicket : AES-256-CTS-HMAC-SHA1-96
  Indicateurs de tickets 0x40e00000 -> forwardable renewable initial pre_authent
  Heure de démarrage : 2/4/2021 15:51:07 (Local)
  Heure de fin :   2/5/2021 1:51:07 (Local)
  Heure de renouvellement : 2/11/2021 15:51:07 (Local)
  Type de clé de session : AES-256-CTS-HMAC-SHA1-96
  Indicateurs de cache : 0x1 -> PRIMARY
  KDC appelé : srvads.AD.MYDOMAIN.LAN

#1> Client : sfonteneau @ AD.MYDOMAIN.LAN
  Serveur : http/srvwapt.AD.MYDOMAIN.LAN @ AD.MYDOMAIN.LAN
  Type de chiffrement KerbTicket : AES-256-CTS-HMAC-SHA1-96
  Indicateurs de tickets 0x40a80000 -> forwardable renewable pre_authent 0x80000
  Heure de démarrage : 2/4/2021 15:51:07 (Local)
  Heure de fin : 2/5/2021 1:51:07 (Local)
  Heure de renouvellement : 2/11/2021 15:51:07 (Local)
  Type de clé de session : AES-256-CTS-HMAC-SHA1-96
  Indicateurs de cache : 0
  KDC appelé : srvads.AD.MYDOMAIN.LAN

Si cela ne fonctionne pas, vérifier dans votre Active Directory que l’attribut serviceprincipalname sur le compte de l’ordinateur du Serveur WAPT a cette valeur : HTTP/srvwapt.mydomain.lan.

8.2.4.9. Vérifiez qu’il fonctionne avec Firefox

Note

Vous devez d’abord configurer Firefox pour l’authentification kerberos.

• Tapez about:config dans la barre d’URL de votre Firefox.

• Editez network.negotiate-auth.trusted-uris, et ajoutez l’url du serveur wapt : srvwapt.mydomain.lan.

• Vous pouvez maintenant visiter l’url : https://srvwapt.mydomain.lan/add_host_kerberos.

• Si l’authentification ne fonctionne pas, le Serveur WAPT renvoie un message d’erreur 403.

8.2.4.10. En cas d’erreur lors d’un des contrôles précédents

• Supprimez le compte de la machine de l’Active Directory.

• Supprimez le fichier /etc/nginx/http-krb5.keytab.

• Redémarrez la machine avec laquelle vous effectuez le test et exécutez à nouveau le processus de création de la keytab.

Note

• Il est important de redémarrer la machine pour purger les tickets kerberos précédemment obtenus par la machine.

• Pour éviter le redémarrage, vous pouvez également exécuter la commande « klist purge » en tant que SYSTEM.

8.3. Activation de la vérification du certificat SSL / TLS

Lors de l’exécution du script de post-configuration du Serveur WAPT, le script générera un certificat auto-signé afin d’activer les communications HTTPS.

L’Agent WAPT vérifie le certificat du serveur HTTPS en fonction de la valeur verify_cert de la section [global] dans C:\Program Files (x86)\wapt\wapt-get.ini.

Options pour verify_cert

Options pour verify_cert	Fonctionnement de l’Agent WAPT
verify_cert = 0	l’Agent WAPT ne vérifiera pas le certificat HTTPS du Serveur WAPT.
verify_cert = 1	l’Agent WAPT vérifiera le certificat HTTPS du Serveur WAPT à l’aide du paquet de certificats C:\Program Files (x86)\wapt\lib\site-packages\certifi\cacert.pem
verify_cert = C:\Program Files (x86)\wapt\ssl\srvwapt.mydomain.lan.crt	l’Agent WAPT vérifiera le certificat HTTPS du Serveur WAPT avec le groupe de certificats C:\Program Files (x86)\wapt\ssl\srvwapt.mydomain.lan.crt

Indication

Pour activer rapidement et facilement la vérification du certificat HTTPS, vous pouvez utiliser la méthode Pinning.

8.3.1. Épingler le certificat

L”épinglage de certificat consiste à vérifier le certificat SSL/ TLS à l’aide de la définition d’un paquet bien défini et restrictif.

Indication

Cette méthode est la plus simple lorsqu’on utilise un certificat auto-signé.

Pour cela, vous devez lancer les commandes suivantes dans le shell Windows cmd.exe (avec des privilèges élevés si UAC est actif).

Si vous avez déjà un shell Windows cmd.exe ouvert, fermez-le et ouvrez un nouveau shell afin de prendre en compte les variables d’environnement mises à jour :

wapt-get enable-check-certificate
wapt-get restart-waptservice

Validez le certificat avec wapt-get update

Lorsque vous avez exécuté la commande update, assurez-vous que tout s’est bien passé, et en cas de doute, vérifiez Problème lors du enable-check-certificate.

Attention

Si wapt-get enable-check-certificate renvoie une erreur, supprimez le .crt de même nom sur C:\Program Files (x86)\wapt\ssl\server

Note

• La commande enable-check-certificate télécharge le certificat srvwapt.mydomain.lan.crt dans le dossier C:\Program Files (x86)\WAPT\ssl\server.

• Il modifie ensuite le fichier wapt-get.ini pour spécifier la valeur verify_cert = C:\Program Files (x86)\wapt\ssl\server\srvwapt.mydomain.lan.crt.

• L’Agent WAPT va maintenant vérifier les certificats en utilisant le certificat épinglé.

Attention

Si vous utilisez la méthode d”épinglage de certificat, n’oubliez pas de SAUVEGARDER le dossier /opt/wapt/waptserver/ssl sur votre Serveur WAPT.

Le fichier devra être restauré sur votre Serveur WAPT si vous migrez ou mettez à niveau votre Serveur WAPT, si vous voulez que les Agents WAPT puissent continuer à établir des connexions HTTPS de confiance.

8.3.2. Comment utiliser un certificat commercial ou des certificats fournis par votre organisation ?

Si la méthode d’épinglage ne vous convient pas, vous pouvez remplacer le certificat auto-signé généré lors de l’installation de WAPT.

Remplacez l’ancien certificat par le nouveau dans le dossier /opt/wapt/waptserver/ssl/ (linux) ou c:\wapt\waptserver\ssl\ (windows).

La nouvelle paire de clés doit être au format PEM encodé en Base64.

Note

Cas particulier où votre certificat a été signé par une Autorité de Certification interne

Les certificats émis par une Autorité de certification interne doivent avoir la chaîne de certificats complète de l” Autorité de certification.

Vous pouvez ajouter manuellement la chaîne de certificats de l’autorité de certification au certificat qui sera utilisé par Nginx.

Exemple : echo srvwapt.mydomain.lan.crt ca.crt > cert.pem

• Pour les serveurs Linux, il est également nécessaire de réinitialiser les ACLs, si vous êtes avec un OS basé sur Redhat avec selinux, veuillez fixer les droits avec restorecon :

Debian and derivativesRedHat and derivatives

chown root:www-data /opt/wapt/waptserver/ssl/*.pem

• Redémarrez Nginx pour prendre en compte les nouveaux certificats.

LinuxWindows:

systemctl restart nginx

8.3.2.1. Configuration de l’Agent WAPT

Pour un certificat commercial, vous pouvez définir verify_cert = 1 dans wapt-get.ini.

Pour un certificat émis par une autorité de certification interne, vous devez placer le certificat dans le dossier C:\Program Files (x86)\wapt\ssl\server\ca.crt et spécifier le chemin du certificat avec verify_cert dans le fichier :wapt-get.ini de l’Agent WAPT.

Pour appliquer la nouvelle configuration à l’ensemble de votre flotte :

• Régénérer un Agent WAPT avec les paramètres appropriés.

• Utilisation du paquet WAPT pour modifier wapt-get.ini et pousser le certificat.

8.3.3. Vérification du certificat dans la Console WAPT

Lorsque la Console WAPT démarre pour la première fois, elle lit le contenu du fichier C:\Program Files (x86)WAPT\wapt-get.ini et elle construit son fichier de configuration C:\Usersadmin\AppData\Local\waptconsole\waptconsole.ini.

Ceci définit correctement l’attribut verify_cert pour la communication HTTPS entre la Console WAPT et le Serveur WAPT.

8.4. Configuration de l’authentification des utilisateurs par rapport à l’Active Directory

Par défaut, le Serveur WAPT est configuré avec un seul compte SuperAdmin dont le mot de passe est défini lors de la post-configuration initiale.

Sur les réseaux étendus et sécurisés, ce compte SuperAdmin ne doit pas être utilisé car il ne peut pas fournir la traçabilité nécessaire aux actions administratives effectuées sur le réseau.

Il est donc nécessaire de configurer l’authentification par rapport à l’Active Directory pour les utilisateurs de la Console WAPT ; cela permettra d’utiliser des comptes nommés pour les tâches.

Note

• L’authentification Active Directory est utilisée pour authentifier l’accès à l’inventaire via la Console WAPT.

• Cependant, toutes les actions sur les appareils distants équipés du WAPT sont basées sur des signatures X.509, donc un Administrateur aura besoin à la fois d’une connexion Active Directory ET d’une clé privée dont le certificat est reconnu par les appareils distants pour gérer sa base installée d’appareils utilisant WAPT.

• Seul le compte SuperAdmin et les membres du groupe de sécurité Active Directory waptadmins seront autorisés à télécharger des paquets sur le dépôt principal (mode d’authentification par login et mot de passe).

8.4.1. Activation de l’authentification Active Directory

• Pour activer l’authentification du Serveur WAPT sur Active Directory, configurez le fichier waptserver.ini comme suit.

Note

Le fichier de configuration du Serveur WAPT sur les systèmes GNU/ Linux et macOS se trouve dans /opt/wapt/conf/waptserver.ini ou dans /opt/wapt/waptserver/waptserver.ini.

Le fichier de configuration du Serveur WAPT sur les systèmes Windows se trouve dans C:\wapt\conf\waptserver.ini.

#waptserver.ini

wapt_admin_group=waptadmins
ldap_auth_server=srvads.mydomain.lan
ldap_auth_base_dn=DC=mydomain,DC=lan
ldap_auth_ssl_enabled=False

Options d’authentification disponibles

Options (Valeur par défaut)	description	Exemple
wapt_admin_group_dn = (défaut [])	DN LDAP du groupe d’utilisateurs Active Directory autorisé à se connecter à la Console WAPT.	wapt_admin_group_dn = CN=waptadmins,OU=groups,DC=ad,DC=mydomain,DC=lan
wapt_admin_group (défaut [])	Définit le sAMAccountName du groupe d’utilisateurs Active Directory autorisé à se connecter à la Console WAPT, c’est une liste qui peut contenir plusieurs groupes. Vous pouvez utiliser cette option plutôt que wapt_admin_group_dn, mais NE PAS UTILISER les deux attributs en même temps.	wapt_admin_group = waptadmins, wapttech
ldap_auth_server (défaut None)	Définit le serveur d’authentification LDAP.	ldap_auth_server = srvads.mydomain.lan
ldap_auth_base_dn (défaut None)	Définit le DN de base de l’authentification LDAP.	ldap_auth_base_dn = dc=domain,dc=lan
ldap_auth_ssl_enabled (défaut True)	Définit l’authentification SSL sur les connexions LDAP.	ldap_auth_ssl_enabled = False
verify_cert_ldap (défaut True)	Vérifie le certificat SSL pour les connexions LDAP, à moins que ldap_auth_ssl_enabled soit à False (sinon il ne fera rien).	verify_cert_ldap = False

• Redémarrer le service waptserver.

Avertissement

Pour Microsoft Active Directory, Microsoft a annoncé que l’authentification SimpleBind sur MS-AD sans SSL/TLS sera bloquée par défaut à partir d’avril 2020. Si vous n’avez pas de certificat installé, vous devrez modifier une clé de registre pour que l’authentification fonctionne.

Note

Par défaut Samba-AD ne permet pas l’authentification SimpleBind sans SSL/TLS. Si vous ne disposez pas d’un certificat valide, vous devrez modifier le paramètre ldap server require strong auth dans /etc/samba/smb.conf. Pour plus d’informations, vous pouvez consulter la documentation de Tranquil IT sur https://dev.tranquil.it/samba/en/index.html.

8.4.2. Activer le Single Sign On (SSO) pour la Console WAPT et le selfservice

Avertissement

Cette configuration n’est disponible que pour les serveurs sous Linux : CentOS, Debian ou Ubuntu.

Vous pouvez utiliser Kerberos pour vous authentifier sur la waptconsole et le selfservice. De cette manière, les utilisateurs n’ont pas besoin d’entrer leur mot de passe.

Il n’est pas nécessaire d’enregistrer l’Agent WAPT en utilisant kerberos pour utiliser le SSO kerberos avec la Console WAPT et avec le Self-Service.

8.4.2.1. Préparer le Serveur WAPT pour Kerberos Single Sign On

Attention

Pour activer Kerberos sur le Serveur WAPT avec l’option use_kerberos = True, lancez le script WAPT Server postconf.

/opt/wapt/waptserver/scripts/postconf.sh

Veuillez consulter la documentation sur la configuration de kerberos pour l’authentification au préalable.

Si vous ne souhaitez pas utiliser Kerberos pour l’enregistrement des clients, mettre l’option allow_unauthenticated_registration` à True`.

Enfin, redémarrez les services waptserver et wapttasks.

systemctl restart waptserver wapttasks

Il existe 3 méthodes pour configurer votre Serveur WAPT avec Kerberos et l’authentification LDAP.

Pour chacun d’entre eux, vous devrez modifier le fichier waptserver.ini.

1. La première méthode est la moins sécurisée .

Cette méthode ne vérifie pas le certificat LDAP et n’utilise pas de port sécurisé pour contacter le Serveur WAPT.

ldap_auth_ssl_enabled = False
verify_cert_ldap = False

En effet, ldap_auth_ssl_enabled=False n’essaiera pas de requête l’Active Directory avec le protocole LDAPS.

L’option verify_cert_ldap=False est définie si vous n’utilisez pas SSL/TLS support.

Indication

Si votre serveur Active Directory est un Samba-AD et que vous avez cette option dans le waptserver.ini, alors le serveur Samba-AD refusera la connexion.

ldap_auth_ssl_enabled = False

Par défaut Samba-AD ne permet pas l’authentification SimpleBind sans SSL/TLS.

Si vous n’avez pas de certificat valide, vous devrez modifier le paramètre ldap server require strong auth dans /etc/samba/smb.conf.

Pour plus d’informations, vous pouvez consulter la documentation de Tranquil IT sur https://dev.tranquil.it/samba/fr/index.html.

2. La deuxième façon plus sûre mais pas parfaite.

Cette méthode permet l’authentification SSL sans vérifier le certificat.

ldap_auth_ssl_enabled = True
verify_cert_ldap = False

Le Serveur WAPT essaiera d’utiliser le protocole LDAPS mais sans vérification de certificat pour contacter Active Directory.

3. La méthode recommandée est la plus sûre.

ldap_auth_ssl_enabled = True
verify_cert_ldap = True

• Mais pour faire fonctionner cela, vous aller devoir activer le support SSL/TLS.

• Ensuite, vous devrez ajouter ces options dans le fichier waptserver.ini :

  ldap_account_service_login = wapt-ldap@ad.tranquil.it
  ldap_account_service_password = PASSWORD
  ldap_auth_server = srvads.mydomain.lan
  ldap_auth_base_dn = dc=mydomain,dc=lan
  use_kerberos = True
  

  Les options ldap_account_service_login et ldap_account_service_password nécessitent un compte utilisateur dans votre Active Directory.

  Il n’est pas nécessaire que le compte de service ait des droits élevés, juste assez de droits pour lire les groupes et les membres des groupes. En d’autres termes, le Serveur WAPT DOIT avoir des droits de lecture sur l’attribut memberof dans l’Active Directory.

• Puis redémarrez les services sur le Serveur WAPT :

  systemctl restart waptserver wapttasks
  

8.4.2.2. Configuration de l’Agent WAPT

Du côté du client, vous allez devoir vous assurer que ces 2 options sont définies dans wapt-get.ini de l’Agent WAPT :

service_auth_type = waptserver-ldap
use_kerberos = True

Il est possible de faire des changements dans wapt-get.ini manuellement ou en déployant un paquet WAPT avec les nouveaux paramètres de configuration.

Un paquet d’exemple est disponible dans le dépôt Tranquil IT.

Avec cette configuration, vous pouvez lancer votre Console WAPT ou votre selfservice sans demander de mot de passe.

Pour que cette fonctionnalité fonctionne, l’Active Directory doit être disponible.

Note

La Console WAPT continuera à vous demander un login/mot de passe : c’est tout à fait normal, de cette façon vous pouvez utiliser un autre utilisateur que votre utilisateur actuel dans votre session Windows.

Sinon, il vous suffit de mettre votre login et de cliquer sur OK.

8.4.3. Activez le support SSL/ TLS pour les connexions LDAP dans le Contrôleur de Domaine Active Directory

Par défaut, l’authentification sur Active Directory repose sur LDAP SSL (port 636 par défaut).

SSL/ TLS n’est pas activé par défaut sur Microsoft Active Directory tant qu’un certificat SSL n’a pas été configuré pour le contrôleur de domaine.

Note

Le Serveur WAPT utilise les paquets d’autorité de certification du système d’exploitation (CentOS) pour valider la connexion SSL/ TLS à Active Directory.

Si le certificat Active Directory est auto-signé ou a été signé par une autorité de certification interne, vous devrez ajouter ces certificats au magasin de certificats.

Ajouter un Autorité de Certification dans le dossier /etc/pki/ca-trust/source/anchors/ et mettez à jour le magasin des CA.

Debian and derivativesRedHat and derivativesWindows

cp cainterne.crt /usr/local/share/ca-certificates/cainterne.crt
update-ca-certificates

• Une fois que vous avez configuré LDAP SSL/ TLS sur votre Active Directory (veuillez vous référer à la documentation de Microsoft pour cela), vous pouvez activer le support de la sécurité SSL/TLS pour AD dans waptserver.ini.

ldap_auth_ssl_enabled = True

• Redémarrer le service waptserver.

8.5. Configuration de l’authentification par certificat côté client

Si votre entreprise a besoin d’un Serveur WAPT ouvert sur Internet, il peut être sécurisé grâce à l’authentification par certificat côté client.

Cette configuration restreint la visibilité du Serveur WAPT aux seuls clients enregistrés. Cela se fait en s’appuyant sur la clé privée de l’Agent WAPT générée lors de l’enregistrement. Elle fonctionne comme suit :

• L’Agent WAPT envoie un CSR au Serveur WAPT qui le signe et le renvoie à l’Agent WAPT.

• Grâce au certificat signé, l’Agent peut accéder aux parties protégées du serveur Web Nginx.

Note

Nous recommandons fortement d’activer l’enregistrement Kerberos ou par login/mot de passe dans la post-configuration du Serveur WAPT.

Avertissement

Toutes les actions sont à mener sur le Serveur WAPT

8.5.1. Activation de l’authentification des certificats côté client sur le Serveur WAPT

Avertissement

Pour Linux, vérifiez si le lien symbolique dans sites-enabled existe :

cd /etc/nginx/sites-enabled/
find . -maxdepth 1 -type l -ls

Le résultat escompté devrait être :

269091      0 lrwxrwxrwx   1 root     root           36 juil. 22 15:51 ./wapt.conf -> /etc/nginx/sites-available/wapt.conf

Sinon, utilisez la commande suivante :

ln -s /etc/nginx/sites-available/wapt.conf ./wapt.conf

Pour activer l’authentification, vous devez ajouter ces paramètres dans le fichier de configuration du Serveur WAPT dans la section option :

use_ssl_client_auth = True

Relancez le script de post-configuration.

Attention

Attention, à la date du 2024-10-28, WAPT ne supporte pas les CRL, ce qui signifie que lorsque vous supprimez une machine dans la Console WAPT, la machine aura toujours accès au dépôt WAPT.

WAPTDeploy ne peut pas utiliser le https pour récupérer l’Agent WAPT, vous devrez ajouter cette section dans le fichier :

server {
  listen                      80;
  listen                      [::]:80;
  server_name                 _;

  location ~ ^/(wapt/waptsetup-tis.exe|wapt/waptagent.exe|wapt/waptdeploy.exe)$ {
      add_header Cache-Control "store, no-cache, must-revalidate, post-check=0, pre-check=0";
      add_header Pragma "no-cache";
      root "/var/www";
  }

  return 301                  https://$host$request_uri;
}