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.

The WAPT Server configuration file on Windows is found in C:\wapt\conf\waptserver.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_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
`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¶

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

yum install krb5-workstation msktutil nginx-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.

Vous pouvez ajouter une tâche de mise à jour automatique dans la crontab. Elle modifiera fréquemment le mot de passe du compte machine dans Active Directory afin que vous puissiez passer les audits de sécurité. Contenu de la crontab :

32 23 * * * 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.

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

sudo chown root:nginx /etc/nginx/http-krb5.keytab
sudo chmod 640 /etc/nginx/http-krb5.keytab
restorecon -v -R /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.

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

sudo chown root:nginx /etc/nginx/http-krb5.keytab
sudo chmod 640 /etc/nginx/http-krb5.keytab
restorecon -v -R /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.

Précharger le mot de passe du compte srvwapt

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. Attempting an authentication with curl¶

Sur la machine linux.

[root@srvwapt.ad.tranq ~]# kdestroy
[root@srvwapt.ad.tranq ~]# kinit sfonteneau
Password for sfonteneau@AD.TRANQUIL.IT:
[root@srvwapt.ad.tranq ~]# klist
Ticket cache: FILE:/tmp/krb5cc_0
Default principal: sfonteneau@AD.TRANQUIL.IT

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

root@srvwapt.ad.tranq ~]# curl -v --negotiate -u : https://srvwapt.ad.tranquil.it/api/v3/add_host_kerberos -k
* Expire in 0 ms for 6 (transfer 0x563dece09f90)
* Uses proxy env variable no_proxy == 'localhost,127.0.01/8,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,ad.tranquil.it'
* Expire in 1 ms for 1 (transfer 0x563dece09f90)
...
{"success":true,"msg":"Authentication OK","result":{"auth_result":{"auth_method":"kerb","user":"sfonteneau","auth_date":"2024-11-04T16:53:03.817821","with2fa":false},"server_uuid":"7j54647e-1b54-11ea-bcbe-cae466b691e5","version":"2.6.0","server_domain":"ad.tranquil.it","edition":"enterprise","user_acls":{},"token":null},"request_time":0.006450653076171875}

8.2.4.9. 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.10. 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.11. 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 :

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

chown root:nginx /opt/wapt/waptserver/ssl/*.pem
restorecon -v -R /opt/wapt/waptserver/ssl/

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

systemctl restart nginx

net stop waptnginx
net start waptnginx

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
ad_domain_name=mydomain.lan

Options d’authentification disponibles¶
Options (Valeur par défaut)	Description	Exemple
`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`)	Defines the LDAP authentication server. If not specified, a cldap query will be used with the ad_domain_name option to find the best domain controller based on the site and Active Directory service.	ldap_auth_server = srvads.mydomain.lan
`ldap_auth_base_dn` (défaut `None`)	Defines the LDAP authentication base DN. If not specified, The root will be used	ldap_auth_base_dn = dc=domain,dc=lan
`ad_domain_name` (default `None`)	Defines the domain name.	ad_domain_name = mydomain.lan

Redémarrer le service waptserver.

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 : Red Hat and its derivatives, Debian and its derivatives 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

You will need to modify the waptserver.ini.

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.

It is not necessary that the service account had elevated right, just enough rights to read groups and group members.
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 (Red Hat and its derivatives) 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.

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

cp cainterne.crt /etc/pki/ca-trust/source/anchors/cainterne.crt
update-ca-trust

certutil -addstore -f "ROOT" cainterne.crt

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-11-20, 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;
}