(Modifié le 03/11/2019)

ASRock QC5000M Quad-Core APU

ASRock QC5000M (pdf)

ASRock QC5000M

  • Platform
    • Micro ATX Form Factor
    • Solid Capacitor design
    • High Density Glass Fabric PCB
  • CPU
    • AMD FT3 Kabini A4-5050/5000 Quad-Core APU
  • Memory
    • 2 x DDR3 DIMM Slots
    • Supports DDR3 1600/1333/1066 non-ECC, un-buffered memory
    • Max. capacity of system memory: 32GB (see CAUTION1)
  • Expansion Slot
    • 1 x PCI Express 2.0 x16 Slot (PCIE2: x4 mode)
    • 2 x PCI Express 2.0 x1 Slot
  • Graphics
    • Integrated AMD RadeonTM HD 8330 Graphics
    • DirectX 11.1, Pixel Shader 5.0
    • Max. shared memory 2GB
    • Dual graphics output: support D-Sub and HDMI ports by independent display controllers (see CAUTION2)
    • Supports HDMI with max. resolution up to 4K × 2K (4096x2160) @ 24Hz or 4K × 2K (3840x2160) @ 30Hz
    • Supports D-Sub with max. resolution up to 2048x1536 @ 60Hz
    • Supports Auto Lip Sync, Deep Color (12bpc), xvYCC and HBR (High Bit Rate Audio) with HDMI Port (Compliant HDMI monitor is required)
    • Supports HDCP with HDMI Port
    • Supports Full HD 1080p Blu-ray (BD) playback with HDMI Port
  • Audio
    • 7.1 CH HD Audio (Realtek ALC887 Audio Codec) * To configure 7.1 CH HD Audio, it is required to use an HD front panel audio module and enable the multi-channel audio feature through the audio driver.
    • Supports Surge Protection (ASRock Full Spike Protection)
    • ELNA Audio Caps
  • LAN
    • PCIE x1 Gigabit LAN 10/100/1000 Mb/s
    • Rea ltek RTL 8111GR
    • S u p p o r t s Wa k e - O n -WA N
    • Suppor t s Wa ke- On-L A N
    • Supports Lightning/ESD Protection (ASRock Full Spike Protection)
    • Supports LAN Cable Detection
    • Supports Energy Efficient Ethernet 802.3az
    • Supports PXE
  • Rear Panel I/O
    • 1 x PS/2 Mouse/Keyboard Port
    • 1 x Serial Port: COM1
    • 1 x D-Sub Port
    • 1 x HDMI Port
    • 4 x USB 2.0 Ports (Supports ESD Protection (ASRock Full Spike Protection))
    • 2 x USB 3.0 Ports (Supports ESD Protection (ASRock Full Spike Protection))
    • 1 x RJ-45 LAN Port with LED (ACT/LINK LED and SPEED LED)
    • HD Audio Jacks: Line in / Front Speaker / Microphone
  • Storage
    • 2 x SATA3 6.0 Gb/s Connectors, support NCQ, AHCI and Hot Plug
  • Connector
    • 1 x TPM Header
    • 1 x CPU Fan Connector (3-pin)
    • 2 x Chassis Fan Connectors (1 x 4-pin, 1 x 3-pin)
    • 1 x 24 pin ATX Power Connector
    • 1 x Front Panel Audio Connector
    • 2 x USB 2.0 Headers (Support 4 USB 2.0 ports) (Supports ESD Protection (ASRock Full Spike Protection))
  • BIOS Feature
    • 32Mb AMI UEFI Legal BIOS with multilingual GUI support
    • Supports “Plug and Play”
    • ACPI 1.1 compliance wake up events
    • SMBIOS 2.3.1 support
    • DRAM Voltage multi-adjustment
  • HardwareMonitor
    • CPU/Chassis temperature sensing
    • CPU/Chassis Fan Tachometer
    • CPU/Chassis Quiet Fan
    • CPU/Chassis Fan multi-speed control
    • Voltage monitoring: +12V, +5V, +3.3V, Vcore
  • OS
    • Microsoft® Windows® 10 64-bit / 8.1 32-bit / 8.1 64-bit / 8 32-bit / 8 64-bit / 7 32-bit / 7 64-bit / XP 32-bit / XP 64-bit*
    • USB 3.0 is not supported by Windows® XP* For the updated Windows® 10 driver, please visit ASRock’s website for details: http://www.asrock.com
  • Certifica-tions
    • FCC, CE, WHQL
    • ErP/EuP ready (ErP/EuP ready power supply is required)

Debian Buster

Partitionnement du disque

  • 2MB, type EF02 (BIOS partition). Utilisé par GRUB2/BIOS-GPT. (/dev/sda1)
  • 512MB, type 8300 (Linux). Pour le boot linux /boot (/dev/sda2)
  • 4GB, type 8200 (swap). Partition swap (en dehors de lvm). (/dev/sda3)
  • Espace restant, type 8E00 (LVM). Pour le root / et /home. (/dev/sda4).

Partitionnement du reste du disque SSD 120G GPT + LVM

gdisk /dev/sda

On passe en mode expert : x
On efface tout : z
On relance gdisk

gdisk /dev/sda
GPT fdisk (gdisk) version 0.8.6
 
Partition table scan:
  MBR: not present
  BSD: not present
  APM: not present
  GPT: not present
 
Creating new GPT entries.
 
Command (? for help): o
This option deletes all partitions and creates a new protective MBR.
Proceed? (Y/N): y

Command (? for help): n
Partition number (1-128, default 1): 1
First sector (34-31457246, default = 2048) or {+-}size{KMGTP}: 
Last sector (2048-31457246, default = 31457246) or {+-}size{KMGTP}: +2M
Current type is 'Linux filesystem'
Hex code or GUID (L to show codes, Enter = 8300): ef02
Changed type of partition to 'BIOS boot partition'

Command (? for help): n
Partition number (2-128, default 2): 2
First sector (34-31457246, default = 6144) or {+-}size{KMGTP}: 
Last sector (6144-31457246, default = 31457246) or {+-}size{KMGTP}: +512M
Current type is 'Linux filesystem'
Hex code or GUID (L to show codes, Enter = 8300): 8300
Changed type of partition to 'Linux filesystem'

Command (? for help): n
Partition number (3-128, default 3): 3
First sector (34-31457246, default = 210944) or {+-}size{KMGTP}: 
Last sector (210944-31457246, default = 31457246) or {+-}size{KMGTP}: +4G
Current type is 'Linux filesystem'
Hex code or GUID (L to show codes, Enter = 8300): 8200
Changed type of partition to 'Linux swap'

Command (? for help): n
Partition number (4-128, default 4): 
First sector (34-31457246, default = 4405248) or {+-}size{KMGTP}: 
Last sector (4405248-31457246, default = 31457246) or {+-}size{KMGTP}: 
Current type is 'Linux filesystem'
Hex code or GUID (L to show codes, Enter = 8300): 8e00
Changed type of partition to 'Linux LVM'
 
Command (? for help): w

Final checks complete. About to write GPT data. THIS WILL OVERWRITE EXISTING
PARTITIONS!!
 
Do you want to proceed? (Y/N): y
OK; writing new GUID partition table (GPT) to /dev/sda.
The operation has completed successfully.

Installation debian 10

  • Installation effectuée à partir d’une clé USB bootable , fichier ISO : debian-10.0.0-amd64-netinst.iso
  • Choix “partitionnement manuel”

Debian 10

  • Serveur virtuel 64 bits VirtualBox : Debian Buster
  • machine : srvbust
  • domaine :
  • root : ytreu49
  • Utilisateur : admbust
  • Mot de passe : admbust49
  • Adresse IP : 192.168.0.45
  • Accès
    • SSH : ssh bust@192.168.0.45
    • SSH + clé : **ssh -i ~/.ssh/vbox-vmbust-ed25519 bust@192.168.0.49** (facultatif)
    • Transfert de fichier : **scp -P 55022 -i ~/.ssh/vbox-vmbust-ed25519 fichiera fichierb bust@192.168.0.49:/home/bust** (facultatif)

Partitionnement
Disque SCSI1(0,0,0)(sda) 120.0 GB

Partition Taille _ Type Commentaire _
n°1 2.1 MB K biosgrub Bios boot pa  
n°2 536.9 MB   ext2 Linux filesys /boot
n°3 4.3 GB F swap Linux swap swap
n°4 115.2 GB K lvm Linux lvm  

Groupe de volumes LVM ssd-vg

Partition Taille _ Type Commentaire _
n°1 42.9 GB F ext4   /home
n°2 21.5 GB F ext4   /

Sélection des logiciels

  • serveur SSH
  • utilitaires usuels du système

Oter la clé après installation

Connexion SSH

ssh bust@192.168.0.45

Passer en root

su 

Mise à jour

apt update && apt upgrade -y

Installer les outils et sudo

apt install rsync curl tmux jq figlet git

Installer sudo

apt install sudo

Visudo pour les accès root via utilisateur bust

echo "admbust     ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers

Eviter l’erreur “Possible missing firmware” sous Debian

type de message

W: Possible missing firmware /lib/firmware/rtl_nic/rtl8168f-2.fw for module r8169
W: Possible missing firmware /lib/firmware/rtl_nic/rtl8168f-1.fw for module r8169
W: Possible missing firmware /lib/firmware/rtl_nic/rtl8105e-1.fw for module r8169

Résolution du problème

Certains pilotes de matériels sont fournis par leurs constructeurs respectifs mais sont “non open-source”, il reste la propriété de leurs constructeurs. Donc pour corriger ce problème, il faut installer le paquet firmware-linux-nonfree.

En premier lieu, on ajoute à sources.list le dépôt non-free. En ligne de commande :

sudo -s
sed -i "s/main/main\ non-free/g" /etc/apt/sources.list  

Ensuite, reste plus qu’à rafraîchir les dépôts avec la commande :

apt update

Puis on installe les paquets firmware-linux-non-free et firmware-realtek avec la commande suivante :

apt install firmware-linux-nonfree firmware-realtek

Historique de la ligne de commande

Ajoutez la recherche d’historique de la ligne de commande au terminal. Tapez un début de commande précédent, puis utilisez shift + up (flèche haut) pour rechercher l’historique filtré avec le début de la commande.

# Global, tout utilisateur
echo '"\e[1;2A": history-search-backward' | sudo tee -a /etc/inputrc
echo '"\e[1;2B": history-search-forward' | sudo tee -a /etc/inputrc

OpenSSH, clé et script

OpenSSH

connexion avec clé
sur l'ordinateur de bureau Générer une paire de clé curve25519-sha256 (ECDH avec Curve25519 et SHA2) nommé vbox-srvbust-ed25519 pour une liaison SSH avec le serveur KVM.

ssh-keygen -t ed25519 -o -a 100 -f ~/.ssh/vbox-srvbust-ed25519

Envoyer la clé publique sur le serveur KVM

scp ~/.ssh/vbox-srvbust-ed25519.pub admbust@192.168.0.45:/home/admbust/

sur le serveur KVM On se connecte

ssh admbust@192.168.0.45

Copier le contenu de la clé publique dans /home/$USER/.ssh/authorized_keys

cd ~

Sur le KVM ,créer un dossier .ssh

mkdir .ssh
cat $HOME/vbox-srvbust-ed25519.pub >> $HOME/.ssh/authorized_keys

et donner les droits

chmod 600 $HOME/.ssh/authorized_keys

effacer le fichier de la clé

rm $HOME/vbox-srvbust-ed25519.pub

Modifier la configuration serveur SSH

Port = 55035 # changement numéro port , facultatif
PermitRootLogin no # Connexion par root NON autorisée
PasswordAuthentication no # Utilise la clé comme authentification

Exécuter les commande ci-dessous

sudo sed -i 's/#Port 22/Port 55035/g' /etc/ssh/sshd_config
sudo sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin no/g' /etc/ssh/sshd_config
sudo sed -i 's/#PasswordAuthentication yes/PasswordAuthentication no/g' /etc/ssh/sshd_config

Modifier

session SSH ne se termine pas correctement lors d'un "reboot" à distance
Si vous tentez de redémarrer/éteindre une machine distance par ssh, vous pourriez constater que votre session ne se termine pas correctement, vous laissant avec un terminal inactif jusqu’à l’expiration d’un long délai d’inactivité. Il existe un bogue 751636 à ce sujet. Pour l’instant, la solution de contournement à ce problème est d’installer :

sudo apt-get install libpam-systemd  # Installé par défaut sur debian buster

cela terminera la session ssh avant que le réseau ne tombe.
Veuillez noter qu’il est nécessaire que PAM soit activé dans sshd.

Relancer openSSH

sudo systemctl restart sshd

Accès depuis le poste distant avec la clé privée

ssh -p 55035 -i ~/.ssh/vbox-srvbust-ed25519 admbust@192.168.0.45

ATTENTION!!! Les scripts sur connexion peuvent poser des problèmes pour des appels externes autres que ssh

Adressage ipv6

ipv6

Adresse IP : 192.168.0.45
Mac Adress : 70:85:c2:53:cb:80

ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: enp3s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 70:85:c2:53:cb:80 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.45/24 brd 192.168.0.255 scope global dynamic enp3s0
       valid_lft 41814sec preferred_lft 41814sec
    inet6 2a01:e34:eebf:df0:7285:c2ff:fe53:cb80/64 scope global dynamic mngtmpaddr 
       valid_lft 86318sec preferred_lft 86318sec
    inet6 fe80::7285:c2ff:fe53:cb80/64 scope link 
       valid_lft forever preferred_lft forever

La carte n’est joignable de l’internet que par son adresse IPV6
NextHop Freebox permet d’attribuer une adresse IPV6

Prefixe : 2a01:e34:eebf:df5:://64
Next Hop: fe80::7285:c2ff:fe53:cb80
Passerelle IPV6 Box : fe80::224:d4ff:fea6:aa20

Modifier interface réseau debian

sudo nano /etc/network/interfaces

REMPLACER

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
allow-hotplug enp3s0
iface enp3s0 inet dhcp
# This is an autoconfigured IPv6 interface
iface enp3s0 inet6 auto

PAR

# Configuration static ipv4/ipv6
source /etc/network/interfaces.d/*

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
allow-hotplug enp3s0
iface enp3s0 inet static
 address 192.168.0.45
 netmask 255.255.255.0
 network 192.168.0.0
 broadcast 192.168.0.255
 gateway 192.168.0.254
	
# This is an autoconfigured IPv6 interface

iface enp3s0 inet6 static
  address 2abb:e70:ffef:cd3::1
  netmask 64
  post-up ip -6 route add default via fe80::224:d4ff:fea6:aa20 dev enp3s0

Redémarrer la machine

sudo systemctl reboot

Après reboot, connexion SSH
Vérifier adresses IP V4 et V6

ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: enp3s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 70:85:c2:53:cb:80 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.45/24 brd 192.168.0.255 scope global enp3s0
       valid_lft forever preferred_lft forever
    inet6 2abb:e70:ffef:cd3::1/64 scope global 
       valid_lft forever preferred_lft forever
    inet6 fe80::7285:c2ff:fe53:cb80/64 scope link 
       valid_lft forever preferred_lft forever

Vérifier avec un autre poste sur le même réseau local

ping -6 -c5 2abb:e70:ffef:cd3::1
PING 2abb:e70:ffef:cd3::1(2abb:e70:ffef:cd3::1) 56 data bytes
64 bytes from 2abb:e70:ffef:cd3::1: icmp_seq=1 ttl=56 time=55.6 ms
64 bytes from 2abb:e70:ffef:cd3::1: icmp_seq=2 ttl=56 time=54.4 ms
64 bytes from 2abb:e70:ffef:cd3::1: icmp_seq=3 ttl=56 time=54.2 ms
64 bytes from 2abb:e70:ffef:cd3::1: icmp_seq=4 ttl=56 time=54.7 ms
64 bytes from 2abb:e70:ffef:cd3::1: icmp_seq=5 ttl=56 time=54.7 ms

--- 2abb:e70:ffef:cd3::1 ping statistics ---
5 packets transmitted, 5 received, 0% packet loss, time 9ms
rtt min/avg/max/mdev = 54.239/54.719/55.574/0.544 ms

DMZ et Next Hop Freebox

Activer la dmz sur la “freebox” pour rediriger tout le traffic entrant sur l’adresse ip 192.168.0.45

Next Hop

DNS OVH

dns OVH

Modification domaine xoyize.xyz pour un accès IPV4/IPV6.

$TTL 3600
@	IN SOA dns106.ovh.net. tech.ovh.net. (2019100803 86400 3600 3600000 300)
    3600 IN NS     dns106.ovh.net.
    3600 IN NS     ns106.ovh.net.
    3600 IN A      78.235.240.223
    3600 IN AAAA   2a01:e34:eebf:df3::1
    3600 IN CAA    0 issue "letsencrypt.org"
*   3600 IN CNAME  xoyize.xyz.

Modification domaine ouestline.net pour un accès IPV4/IPV6.

$TTL 3600
@	IN SOA dns111.ovh.net. tech.ovh.net. (2019100900 86400 3600 3600000 300)
    3600 IN NS     ns111.ovh.net.
    3600 IN NS     dns111.ovh.net.
    3600 IN MX     10 ouestline.net.
     3600 IN A      78.235.240.223
    3600 IN AAAA   2a01:e34:eebf:df3::1
*   3600 IN CNAME  ouestline.net.

Hostname

Vérifier le nom

# sudo hostnamectl set-hostname xoyize.xyz # Pour un changement de nom
hostnamectl status
   Static hostname: xoyize.xyz
         Icon name: computer-desktop
           Chassis: desktop
        Machine ID: 943d75b5cd2b44f4a2e4552ce881ca30
           Boot ID: f720b189b0ee4d99a41f14e14fa0c336
  Operating System: Debian GNU/Linux 10 (buster)
            Kernel: Linux 4.19.0-5-amd64
      Architecture: x86-64

Il faut modifier le fichier /etc/hosts , ajout domaine xoyize.xyz

sudo nano /etc/hosts
127.0.0.1	localhost
127.0.1.1	xoyize.xyz	srvxo

# The following lines are desirable for IPv6 capable hosts
::1     localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

Après modification

hostname --fqdn

xoyize.xyz

Journalctl

Ajout utilisateur courant au groupe systemd-journal et adm

sudo gpasswd -a $USER systemd-journal
sudo gpasswd -a $USER adm

Lignes non tronquées ,ajouter au fichier ~/.bashrc

echo "export SYSTEMD_LESS=FRXMK journalctl" >> /home/$USER/.bashrc

Prise en compte après déconnexion/reconnexion

Volumes disques et partitions

Les disques

fdisk -l
Disque /dev/sda : 111,8 GiB, 120034123776 octets, 234441648 secteurs
Modèle de disque : SSD2SC120G3SA754
Unités : secteur de 1 × 512 = 512 octets
Taille de secteur (logique / physique) : 512 octets / 512 octets
taille d'E/S (minimale / optimale) : 512 octets / 512 octets
Type d'étiquette de disque : gpt
Identifiant de disque : E404411D-4E3E-4957-A853-D095508F4024

Périphérique   Début       Fin  Secteurs Taille Type
/dev/sda1       2048      6143      4096     2M Amorçage BIOS
/dev/sda2       6144   1054719   1048576   512M Système de fichiers Linux
/dev/sda3    1054720   9443327   8388608     4G Partition d'échange Linux
/dev/sda4    9443328 234441614 224998287 107,3G LVM Linux


Disque /dev/sdb : 447,1 GiB, 480103981056 octets, 937703088 secteurs
Modèle de disque : Crucial_CT480M50
Unités : secteur de 1 × 512 = 512 octets
Taille de secteur (logique / physique) : 512 octets / 4096 octets
taille d'E/S (minimale / optimale) : 4096 octets / 4096 octets
Type d'étiquette de disque : dos
Identifiant de disque : 0xc4bcac58

Périphérique Amorçage    Début       Fin  Secteurs Taille Id Type
/dev/sdb1    *            2048  41945087  41943040    20G 83 Linux
/dev/sdb2             41945088 937703087 895758000 427,1G 8e LVM Linux

Volumes LVM

root@srvxo:/home/admbust# pvs
  PV         VG       Fmt  Attr PSize    PFree  
  /dev/sda4  ssd-vg   lvm2 a--  <107,29g <47,29g
  /dev/sdb2  ssd-m500 lvm2 a--  <427,13g      0 
root@srvxo:/home/admbust# vgs
  VG       #PV #LV #SN Attr   VSize    VFree  
  ssd-m500   1   1   0 wz--n- <427,13g      0 
  ssd-vg     1   2   0 wz--n- <107,29g <47,29g
root@srvxo:/home/admbust# lvs
  LV    VG       Attr       LSize    Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert
  lv500 ssd-m500 -wi-ao---- <427,13g                                                    
  home  ssd-vg   -wi-ao----   40,00g                                                    
  root  ssd-vg   -wi-ao----   20,00g               

Création des points de montage

sudo mkdir -p /srv/{data,musique}

Modification /etc/fstab pour ajout volume “data”

/dev/mapper/ssd--m500-lv500   /srv/data    ext4    defaults        0       2

Tester le montage

sudo mount -a

Structure
df -h

Sys. de fichiers            Taille Utilisé Dispo Uti% Monté sur
udev                          3,7G       0  3,7G   0% /dev
tmpfs                         741M    8,6M  733M   2% /run
/dev/mapper/ssd--vg-root       20G    1,1G   18G   6% /
tmpfs                         3,7G       0  3,7G   0% /dev/shm
tmpfs                         5,0M       0  5,0M   0% /run/lock
tmpfs                         3,7G       0  3,7G   0% /sys/fs/cgroup
/dev/sda2                     504M     47M  432M  10% /boot
/dev/mapper/ssd--vg-home       40G     49M   38G   1% /home
tmpfs                         741M       0  741M   0% /run/user/1000
/dev/mapper/ssd--m500-lv500   420G    153G  246G  39% /srv/data

Script analyse - ~/ssh_rc_bash_only

Le batch

nano ~/ssh_rc_bash_only
#!/bin/bash

get_infos() {
    seconds="$(< /proc/uptime)"
    seconds="${seconds/.*}"
    days="$((seconds / 60 / 60 / 24)) jour(s)"
    hours="$((seconds / 60 / 60 % 24)) heure(s)"
    mins="$((seconds / 60 % 60)) minute(s)"
    
    # Remove plural if < 2.
    ((${days/ *} == 1))  && days="${days/s}"
    ((${hours/ *} == 1)) && hours="${hours/s}"
    ((${mins/ *} == 1))  && mins="${mins/s}"
    
    # Hide empty fields.
    ((${days/ *} == 0))  && unset days
    ((${hours/ *} == 0)) && unset hours
    ((${mins/ *} == 0))  && unset mins
    
    uptime="${days:+$days, }${hours:+$hours, }${mins}"
    uptime="${uptime%', '}"
    uptime="${uptime:-${seconds} seconds}"

   if [[ -f "/sys/devices/virtual/dmi/id/board_vendor" ||
                    -f "/sys/devices/virtual/dmi/id/board_name" ]]; then
	model="$(< /sys/devices/virtual/dmi/id/board_vendor)"
	model+=" $(< /sys/devices/virtual/dmi/id/board_name)"
   fi

   if [[ -f "/sys/devices/virtual/dmi/id/bios_vendor" ||
                    -f "/sys/devices/virtual/dmi/id/bios_version" ]]; then
        bios="$(< /sys/devices/virtual/dmi/id/bios_vendor)"
        bios+=" $(< /sys/devices/virtual/dmi/id/bios_version)"
        bios+=" $(< /sys/devices/virtual/dmi/id/bios_date)"
   fi
}

#clear
PROCCOUNT=`ps -Afl | wc -l`  		# nombre de lignes
PROCCOUNT=`expr $PROCCOUNT - 5`		# on ote les non concernées
GROUPZ=`users`
ipinfo=$(curl -s ipinfo.io) 		# info localisation format json
#ipinfo=$(curl -s iplocality.com) 		# info localisation format json
publicip=$(echo $ipinfo | jq -r '.ip')  # extraction des données , installer préalablement "jq"
ville=$(echo $ipinfo | jq -r '.city')
pays=$(echo $ipinfo | jq -r '.country')
cpuname=`cat /proc/cpuinfo |grep 'model name' | cut -d: -f2 | sed -n 1p`
iplink=`ip link show |grep -m 1 "2:" | awk '{print $2}' | cut -d: -f1`

if [[ $GROUPZ == *irc* ]]; then
ENDSESSION=`cat /etc/security/limits.conf | grep "@irc" | grep maxlogins | awk {'print $4'}`
PRIVLAGED="IRC Account"
else
ENDSESSION="Unlimited"
PRIVLAGED="Regular User"
fi
get_infos
logo=$(figlet "`hostname --fqdn`")
meteo=$(curl fr.wttr.in/$ville?0)
lvm_entet="Sys. de fichiers                      Taille Utilisé Dispo Uti% Monté sur"
lvm=$(df -h |grep mapper)
lvm+='\n'$(df -h |grep sda)
distri=$(lsb_release -sd)
distri+=" $(uname -m)"

echo -e "
\e[1;31m$logo
\e[1;35m   \e[1;37mHostname \e[1;35m= \e[1;32m`hostname`
\e[1;35m \e[1;37mWired IpV4 \e[1;35m= \e[1;32m`ip addr show $iplink | grep 'inet\b' | awk '{print $2}' | cut -d/ -f1`
\e[1;35m \e[1;37mWired IpV6 \e[1;35m= \e[1;32m`ip addr show $iplink | grep -E 'inet6' |grep -E 'scope link' | awk '{print $2}' | cut -d/ -f1`
\e[1;35m     \e[1;37mKernel \e[1;35m= \e[1;32m`uname -r`
\e[1;35m    \e[1;37mDistrib \e[1;35m= \e[1;32m$distri
\e[1;35m     \e[1;37mUptime \e[1;35m= \e[1;32m`echo $uptime`
\e[1;35m       \e[1;37mBios \e[1;35m= \e[1;32m`echo $bios`
\e[1;35m      \e[1;37mBoard \e[1;35m= \e[1;32m`echo $model`
\e[1;35m        \e[1;37mCPU \e[1;35m= \e[1;32m`echo $cpuname`
\e[1;35m \e[1;37mMemory Use \e[1;35m= \e[1;32m`free -m | awk 'NR==2{printf "%s/%sMB (%.2f%%)\n", $3,$2,$3*100/$2 }'`
\e[1;35m   \e[1;37mUsername \e[1;35m= \e[1;32m`whoami`
\e[1;35m   \e[1;37mSessions \e[1;35m= \e[1;32m`who | grep $USER | wc -l`
\e[1;35m\e[1;37mPublic IpV4 \e[1;35m= \e[1;32m`echo $publicip`
\e[1;35m\e[1;37mPublic IpV6 \e[1;35m= \e[1;32m`ip addr show $iplink | grep -m 1 'inet6\b'  | awk '{print $2}' | cut -d/ -f1`
\e[1;35m\e[1;96m$lvm_entet\e[1;35m\e[1;49m
\e[1;35m\e[1;33m$lvm
\e[1;35m\e[1;32m$meteo
\e[1;0m
"

Les droits en exécution

chmod +x ~/ssh_rc_bash_only

Effacer motd

sudo rm /etc/motd

Exécution

./ssh_rc_bash_only

Texte alternatif

Certificats letsencrypt - domaine *.xyz

letsencrypt

Installation gestionnaire des certificats Let’s Encrypt

cd ~
sudo apt install socat # prérequis
git clone https://github.com/Neilpang/acme.sh.git
cd acme.sh
./acme.sh --install 

Résultat de l’installation

[lundi 26 août 2019, 13:00:48 (UTC+0200)] Installing to /home/admbust/.acme.sh
[lundi 26 août 2019, 13:00:48 (UTC+0200)] Installed to /home/admbust/.acme.sh/acme.sh
[lundi 26 août 2019, 13:00:48 (UTC+0200)] Installing alias to '/home/admbust/.bashrc'
[lundi 26 août 2019, 13:00:48 (UTC+0200)] OK, Close and reopen your terminal to start using acme.sh
[lundi 26 août 2019, 13:00:48 (UTC+0200)] Installing cron job
no crontab for admbust
no crontab for admbust
[lundi 26 août 2019, 13:00:48 (UTC+0200)] Good, bash is found, so change the shebang to use bash as preferred.
[lundi 26 août 2019, 13:00:49 (UTC+0200)] OK

Se déconnecter puis se reconnecter pou la prise en compte

Se connecter sur l’api OVH pour les paramètres (clé et secret)

export OVH_AK="votre application key"
export OVH_AS="votre application secret"

Premier lancement pour la génération des certificats

acme.sh --dns dns_ovh --issue --ocsp --keylength ec-384 -d xoyize.xyz -d *.xoyize.xyz
[...]
[lundi 26 août 2019, 13:04:15 (UTC+0200)] Please open this link to do authentication: https://eu.api.ovh.com/auth/?credentialToken=ls7bXtEJZSv67jKAd9M1YNQQvpAd8W7Uohg2GSiCUXvVnEgtJ2OaiZE6EwPbi0lY
[...]

Connecter l’url ci-dessus, s’authentifier puis sélectionner “unlimited” et valider.Le message suivant dit s’afficher.

OVH authentication Success ! 

Lancer une seconde fois la génération des certificats et patienter quelques minutes…

acme.sh --dns dns_ovh --issue --ocsp --keylength ec-384 -d xoyize.xyz -d *.xoyize.xyz

Les certificats sont disponibles

[lundi 26 août 2019, 13:06:53 (UTC+0200)] Your cert is in  /home/admbust/.acme.sh/xoyize.xyz_ecc/xoyize.xyz.cer 
[lundi 26 août 2019, 13:06:53 (UTC+0200)] Your cert key is in  /home/admbust/.acme.sh/xoyize.xyz_ecc/xoyize.xyz.key 
[lundi 26 août 2019, 13:06:53 (UTC+0200)] The intermediate CA cert is in  /home/admbust/.acme.sh/xoyize.xyz_ecc/ca.cer 
[lundi 26 août 2019, 13:06:53 (UTC+0200)] And the full chain certs is there:  /home/admbust/.acme.sh/xoyize.xyz_ecc/fullchain.cer 

Idem pour ouestline.net

[mardi 15 octobre 2019, 14:58:36 (UTC+0200)] Your cert is in  /home/admbust/.acme.sh/ouestline.net_ecc/ouestline.net.cer 
[mardi 15 octobre 2019, 14:58:36 (UTC+0200)] Your cert key is in  /home/admbust/.acme.sh/ouestline.net_ecc/ouestline.net.key 
[mardi 15 octobre 2019, 14:58:36 (UTC+0200)] The intermediate CA cert is in  /home/admbust/.acme.sh/ouestline.net_ecc/ca.cer 
[mardi 15 octobre 2019, 14:58:36 (UTC+0200)] And the full chain certs is there:  /home/admbust/.acme.sh/ouestline.net_ecc/fullchain.cer 

Les liens pour les certificats

SSL

# domaine xoyize.xyz
sudo ln -s /home/admbust//.acme.sh/xoyize.xyz_ecc/fullchain.cer /etc/ssl/private/xoyize.xyz-fullchain.pem   # full chain certs
sudo ln -s /home/admbust//.acme.sh/xoyize.xyz_ecc/xoyize.xyz.key /etc/ssl/private/xoyize.xyz-key.pem     # cert key
sudo ln -s /home/admbust//.acme.sh/xoyize.xyz_ecc/xoyize.xyz.cer /etc/ssl/private/xoyize.xyz-chain.pem   # cert domain
sudo ln -s /home/admbust//.acme.sh/xoyize.xyz_ecc/ca.cer /etc/ssl/private/xoyize.xyz-ca.pem                 # intermediate CA cert

# domaine ouestline.net
sudo ln -s /home/admbust/.acme.sh/ouestline.net_ecc/ouestline.net.cer /etc/ssl/private/ouestline.net-chain.pem   # cert domain
sudo ln -s /home/admbust/.acme.sh/ouestline.net_ecc/ouestline.net.key /etc/ssl/private/ouestline.net-key.pem     # cert key 
sudo ln -s /home/admbust/.acme.sh/ouestline.net_ecc/ca.cer /etc/ssl/private/ouestline.net-ca.pem                 # intermediate CA cert
sudo ln -s /home/admbust/.acme.sh/ouestline.net_ecc/fullchain.cer /etc/ssl/private/ouestline.net-fullchain.pem   # full chain certs

Pour un lancement manuel (ajout domaine, sous-domaine ou regénération des certificats)

acme.sh --dns dns_ovh --issue --keylength ec-384 -d xoyize.xyz -d *.xoyize.xyz

Un certificat Wildcard Let’s Encrypt qui se renouvelle automatiquement

crontab -l
48 0 * * * "/home/admbust/.acme.sh"/acme.sh --cron --home "/home/admbust/.acme.sh" > /dev/null

NFS serveur


NFS (pour Network File System, système de fichiers en réseau) est un protocole qui permet à un ordinateur d’accéder à des fichiers via un réseau.

Installation NFS

on passe en mode su

sudo -s

Installation

apt install nfs-kernel-server

Vérification serveur

rpcinfo -p | grep nfs
    100003    3   tcp   2049  nfs
    100003    4   tcp   2049  nfs
    100003    3   udp   2049  nfs

Vérifier que le système supporte effectivement NFS

cat /proc/filesystems | grep nfs
nodev	nfsd

Si la commande précédente ne renvoie rien, il se peut que le module NFS ne soit pas chargé, auquel cas, il faut le charger modprobe nfs
Enfin, vérifions que portmap attend les instructions sur le port 111

rpcinfo -p | grep portmap
    100000    4   tcp    111  portmapper
    100000    3   tcp    111  portmapper
    100000    2   tcp    111  portmapper
    100000    4   udp    111  portmapper
    100000    3   udp    111  portmapper
    100000    2   udp    111  portmapper

Configuration du partage

Passage en su

sudo -s

indiquer au serveur les répertoires qui seront partagés, les machines qui y auront accès et les conditions de ce partage.

nano /etc/exports

Ajouter en fin de fichier /etc/exports

# Premier disque
/srv/data      192.168.0.0/24(rw,sync,no_subtree_check,no_root_squash)

Exporter

exportfs -ar

Sécurisation NFS

Passage en su

sudo -s

Le protocole RPC n’a pas la réputation d’être bien sécurisé, mais la version 4 de NFS entend corriger ce problème, elle est donc à privilégier. Il est déconseillé d’effectuer un partage NFS via internet, ou bien dans ce cas, opter pour un tunnel crypté.

  • S’assurer que les partages sont réservés à certaines IP dans /etc/exports
  • S’appuyer sur rpcbind (/etc/hosts.deny et /etc/hosts.allow) pour sécuriser l’accès au serveur NFS
  • Configurer convenablement iptables

hosts.deny , hosts.allow
Tout le monde est interdit, puis le LAN est autorisé:

echo "rpcbind mountd nfsd statd lockd rquotad : ALL" >> /etc/hosts.deny
echo "rpcbind mountd nfsd statd lockd rquotad: 192.168.0." >> /etc/hosts.allow

iptables (NFS)
Par défaut, les différents services NFS (lockd, statd, mountd, etc.) demandent des assignations de ports aléatoires à partir du portmapper (portmap/rpcbind), ce qui signifie que la plupart des administrateurs doivent ouvrir une gamme de ports dans leur base de règles de pare-feu pour que NFS fonctionne.

Il va donc falloir fixer les ports de ces services afin de créer les règles iptables.

echo 'STATDOPTS="--port 32765 --outgoing-port 32766"' >> /etc/default/nfs-common
echo 'RPCMOUNTDOPTS="-p 32767"' >> /etc/default/nfs-kernel-server
echo 'RPCRQUOTADOPTS="-p 32769"' >> /etc/default/quota

Relance sysctl

sysctl --system
* Applying /etc/sysctl.d/99-sysctl.conf ...
* Applying /etc/sysctl.d/protect-links.conf ...
fs.protected_hardlinks = 1
fs.protected_symlinks = 1
* Applying /etc/sysctl.conf ...

Relancer le service

systemctl restart nfs-kernel-server

Voici les règles à fixer dans le parefeu

iptables -A INPUT -s 192.168.0.0/24 -p tcp -m multiport --ports 111,2049,32764:32769 -j ACCEPT -m comment --comment "NFS Server"
iptables -A INPUT -s 192.168.0.0/24 -p udp -m multiport --ports 111,2049,32764:32769 -j ACCEPT -m comment --comment "NFS Server"

Correction erreur NFS “nfsdcltrack failed to init database”

sudo -s
apt install sqlite  # installer sqlite
mkdir /var/lib/nfs/nfsdcltrack
nfsdcltrack init
ls -la /var/lib/nfs/nfsdcltrack/main.sqlite  # vérifier si présent
sqlite3 /var/lib/nfs/nfsdcltrack/main.sqlite # ouvrir la base sqlite

SQLite version 3.27.2 2019-02-25 16:06:06
Enter ".help" for usage hints.
sqlite> .tables
clients     parameters
sqlite> .schema
CREATE TABLE parameters (key TEXT PRIMARY KEY, value TEXT);
CREATE TABLE clients (id BLOB PRIMARY KEY, time INTEGER, has_session INTEGER);
sqlite> .schema parameters
CREATE TABLE parameters (key TEXT PRIMARY KEY, value TEXT);
sqlite> .quit

systemctl restart nfs-server  # redémarrer nfs-server
systemctl status nfs-server

● nfs-server.service - NFS server and services
   Loaded: loaded (/lib/systemd/system/nfs-server.service; enabled; vendor preset: enabled)
   Active: active (exited) since Thu 2019-08-29 11:04:47 CEST; 10s ago
  Process: 6042 ExecStartPre=/usr/sbin/exportfs -r (code=exited, status=0/SUCCESS)
  Process: 6043 ExecStart=/usr/sbin/rpc.nfsd $RPCNFSDARGS (code=exited, status=0/SUCCESS)
 Main PID: 6043 (code=exited, status=0/SUCCESS)

août 29 11:04:47 srvxo systemd[1]: Starting NFS server and services...
août 29 11:04:47 srvxo systemd[1]: Started NFS server and services.

Ajout partage groupe nommé ‘nfs’

Pour le partage multi utilisateurs
On utilise le reste du volume ssd-vg

lvcreate -n nfs -l 12105 ssd-vg  # création volume logique
lvcreate -n nfs -l 12105 ssd-vg  # format ext4
mkdir /srv/nfs  # point de montage
mount /dev/mapper/ssd--vg-nfs /srv/nfs # montage

Montage permanent , ajouter au fichier /etc/fstab

/dev/mapper/ssd--vg-nfs       /srv/nfs     ext4    defaults        0       2

Montage

mount -a

Ajouter au fichier /etc/exports

/srv/nfs	192.168.0.0/24(rw,sync,no_subtree_check,no_root_squash)

Recharger

exportfs -arv

Configurer le partage NFS avec SetGID

Maintenant que le serveur NFS est configuré avec le point de montage NFS de base /srv/nfs, nous devons configurer SetGID dans ce répertoire, comme indiqué ci-dessous.

chmod 2770 /srv/nfs

Cela a également défini les autorisations 770 sur le répertoire, de sorte que l’utilisateur racine et le groupe défini disposent d’autorisations complètes. Le 2 permet setgid.

Ensuite, nous créons un groupe appelé ‘partage’ et modifions le répertoire /srv/nfs afin que le propriétaire du groupe soit ce groupe ‘partage’.
Nous spécifions également manuellement le GID qui sera utilisé pour le groupe en tant que 9999; il doit s’agir d’un numéro libre sur votre client et votre serveur.

Exécuter groupadd sur le client et sur le serveur, et ajouter un utilisateur à ce groupe.

sudo groupadd -g 9999 partage      # sur client et serveur
sudo usermod -a -G partage $USER   # sur client et serveur
sudo chgrp partage /srv/nfs        # serveur uniquement

NE PAS OUBLIER DE SE DECONNECTER/CONNECTER

Nous pouvons confirmer que setgid est en place, comme indiqué ci-dessous, où le bit d’exécution pour les autorisations de groupe est une minuscule. Cela passera à une majuscule S si le groupe ne dispose pas de l’autorisation d’exécution et que seul setgid est en place.

ls -la /srv/nfs/

drwxrws— 2 root partage 4096 oct. 23 12:51

Désormais, tous les fichiers ou répertoires créés dans /srv/nfs se verront automatiquement attribuer le propriétaire du groupe ‘partage’, ce qui permettra essentiellement la collaboration de groupe, car tout utilisateur appartenant au groupe ‘partage’ pourra désormais accéder aux fichiers créés par d’autres utilisateurs du groupe. même groupe dans le répertoire /srv/nfs.

Parefeu (iptables)

/sbin/iptables-firewall.sh

On utilise un service systemd
Créer le fichier le script /sbin/iptables-firewall.sh

sudo nano /sbin/iptables-firewall.sh
#!/bin/bash
# Configure iptables firewall

# Limit PATH
PATH="/sbin:/usr/sbin:/bin:/usr/bin"

# iptables configuration
firewall_start() {
###################
#      IPv4       #
###################

# refuser input et forward par défaut, accepter output
iptables -t filter -P INPUT DROP
iptables -t filter -P FORWARD DROP
iptables -t filter -P OUTPUT ACCEPT

# interface lo (loop) accessible
iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT

# maintenir les connexions établies
iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -m state --state RELATED,ESTABLISHED -j ACCEPT

# accepter en entrée le ping (icmp), et les
# connexions sur les ports nécessaires.
iptables -A INPUT -p icmp --icmp-type echo-request -m conntrack --ctstate NEW -m limit --limit 1/s --limit-burst 1 -j ACCEPT
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp --dport 443 -j ACCEPT
iptables -A INPUT -p tcp --dport 55035 -j ACCEPT
iptables -A INPUT -p udp --dport 55035 -j ACCEPT

# accepter en sortie le ping, les requêtes HTTP(S), DNS,
# et les connexions sur les ports nécessaires.
iptables -A OUTPUT -p icmp --icmp-type echo-request -m conntrack --ctstate NEW -j ACCEPT
iptables -A OUTPUT -p tcp --dport 80 -j ACCEPT
iptables -A OUTPUT -p tcp --dport 443 -j ACCEPT
iptables -A OUTPUT -p udp --dport 53 -j ACCEPT
iptables -A OUTPUT -p tcp --dport 53 -j ACCEPT

# NFS
iptables -A INPUT -s 192.168.0.0/24 -p tcp -m multiport --ports 111,2049,32764:32769 -j ACCEPT -m comment --comment "NFS Server"
iptables -A INPUT -s 192.168.0.0/24 -p udp -m multiport --ports 111,2049,32764:32769 -j ACCEPT -m comment --comment "NFS Server"



###################
#      IPv6       #
###################

# refuser input et forward par défaut, accepter output
ip6tables -t filter -P INPUT DROP
ip6tables -t filter -P FORWARD DROP
ip6tables -t filter -P OUTPUT ACCEPT

# interface lo (loop) accessible
ip6tables -A INPUT -i lo -j ACCEPT
ip6tables -A OUTPUT -o lo -j ACCEPT

# maintenir les connexions établies
ip6tables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
ip6tables -A OUTPUT -m state --state RELATED,ESTABLISHED -j ACCEPT

# NDP pour toute interface de type broadcast
ip6tables -A INPUT -p icmpv6 --icmpv6-type neighbour-solicitation -m hl --hl-eq 255 -j ACCEPT
ip6tables -A INPUT -p icmpv6 --icmpv6-type neighbour-advertisement -m hl --hl-eq 255 -j ACCEPT
ip6tables -A INPUT -p icmpv6 --icmpv6-type router-advertisement -m hl --hl-eq 255 -j ACCEPT

ip6tables -A OUTPUT -p icmpv6 --icmpv6-type neighbour-solicitation -j ACCEPT
ip6tables -A OUTPUT -p icmpv6 --icmpv6-type neighbour-advertisement -j ACCEPT
ip6tables -A OUTPUT -p icmpv6 --icmpv6-type router-solicitation -j ACCEPT

# accepter en entrée le ping (icmpv6), les
# connexions entrantes déjà établies et les connexions sur les ports nécessaires.
ip6tables -A INPUT -p icmpv6 --icmpv6-type echo-request -m conntrack --ctstate NEW -m limit --limit 1/s --limit-burst 1 -j ACCEPT
ip6tables -A INPUT -p tcp --dport 80 -j ACCEPT
ip6tables -A INPUT -p tcp --dport 443 -j ACCEPT
ip6tables -A INPUT -p tcp --dport 55035 -j ACCEPT
ip6tables -A INPUT -p udp --dport 55035 -j ACCEPT

# accepter en sortie le ping, les requêtes HTTP(S), DNS,
# et les connexions sur les ports nécessaires.
ip6tables -t filter -A OUTPUT -p icmpv6 --icmpv6-type echo-request -j ACCEPT
ip6tables -A OUTPUT -p tcp --dport 80 -j ACCEPT
ip6tables -A OUTPUT -p tcp --dport 443 -j ACCEPT
ip6tables -A OUTPUT -p udp --dport 53 -j ACCEPT
ip6tables -A OUTPUT -p tcp --dport 53 -j ACCEPT
}

# clear iptables configuration
firewall_stop() {
  iptables -F
  iptables -X
  iptables -P INPUT   ACCEPT
  iptables -P FORWARD ACCEPT
  iptables -P OUTPUT  ACCEPT
  ip6tables -F
  ip6tables -X
  ip6tables -P INPUT   ACCEPT
  ip6tables -P FORWARD ACCEPT
  ip6tables -P OUTPUT  ACCEPT
}

# execute action
case "$1" in
  start|restart)
    echo "Starting firewall"
    firewall_stop
    firewall_start
    ;;
  stop)
    echo "Stopping firewall"
    firewall_stop
    ;;
esac

Les droits et exécutable

sudo chown root:root /sbin/iptables-firewall.sh
sudo chmod 750 /sbin/iptables-firewall.sh 

systemd - iptables-firewall.service

Créer le service systemd iptables-firewall.service

cat << EOF | sudo tee /etc/systemd/system/iptables-firewall.service
[Unit]
Description=iptables firewall service
After=network.target

[Service]
Type=oneshot
ExecStart=/sbin/iptables-firewall.sh start
RemainAfterExit=true
ExecStop=/sbin/iptables-firewall.sh stop
StandardOutput=journal

[Install]
WantedBy=multi-user.target
EOF

Recharger systemd manager

sudo systemctl daemon-reload

Lancer le service iptables et l’activer

sudo systemctl start iptables-firewall
sudo systemctl enable iptables-firewall

BorgBackup

Machine qui stocke les sauvegardes → xoyize.xyz - 192.168.0.45

Installation BorgBackup et ajout clé publique sur le serveur de sauvegarde xoyize.xyz
On se connecte sur la machine et on passe en mode su

sudo -s

Installer borgbackup

apt install borgbackup

Créer un utilisateur borg dédié aux sauvegardes par BorgBackup :

useradd borg --create-home --home-dir /srv/data/borg-backups/

Vérifier le propriétaire des dossiers “borg” , sinon modifier

chown borg.borg -R  /srv/data/borg-backups/

Cet utilisateur n’a pas de mot de passe, nous nous y connecterons uniquement avec une clef SSH ,ajout de la clé publique

mkdir -p /srv/data/borg-backups/.ssh
cat >> /srv/data/borg-backups/.ssh/authorized_keys

Copier/coller le contenu du fichier du fichier de clef publique (fichier /root/.ssh/yanspm_ed25519.pub de la machine à sauvegarder ) dans ce terminal, et presser [Ctrl]+[D] pour valider.

Autoriser utilisateur borg à exécuter /usr/bin/borg uniquement

echo "borg ALL=NOPASSWD: /usr/bin/borg" >> /etc/sudoers

Machines autorisés à effectuer leur backup

Le dossier de base pour les sauvegardes sur le serveur xoyize.xyz : /srv/data/borg-backups/
Pour info les machines autorisés à effectuer leur backup sur cette machine :
yannick-pc e6230

Rsync , transfert des sauvegardes borg xoyaz.xyz → xoyize.xyz

Pour les serveurs yanspm.com yanfi.net et cinay.xyz ,les sauvegardes sont effectuées en utilisant le logiciel borg ,vers le serveur de backup xoyaz.xyz et on utilise rsync pour les transférer localement

connexion avec clé
sur le serveur appelant srvxo (xoyize.xyz - 192.168.0.45) Générer une paire de clé curve25519-sha256 (ECDH avec Curve25519 et SHA2) nommé xoyaz_ed25519 pour une liaison SSH avec le serveur KVM.

ssh-keygen -t ed25519 -o -a 100 -f ~/.ssh/xoyaz_ed25519

Ajouter la clé publique au fichier ~/.ssh/authorized_keys du serveur de backup xoyaz.xyz

Test connexion

ssh -p 55036 -i /home/admbust/.ssh/xoyaz_ed25519 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null usernl@xoyaz.xyz

Créer la commande rsync avec son fichier d’exclusion

nano .ssh/exclude-list.txt
.bash_logout
.bashrc
.profile
.ssh

Lancer la commande rsync dans une fenêtre terminal tmux en mode su

tmux
sudo -s
rsync -avz --progress --stats --human-readable --exclude-from '/home/admbust/.ssh/exclude-list.txt' --rsync-path="sudo rsync" -e "ssh -p 55036 -i /home/admbust/.ssh/xoyaz_ed25519 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"  usernl@xoyaz.xyz:/srv/data/borg-backups/* /srv/data/borg-backups/

Paramétrer pour une exécution chaque jour à 2h30

sudo crontab -e
# Synchro Backup (contient les dossiers de sauvegardes borg) avec xoyize 
30 02 * * * rsync -avz --progress --stats --human-readable --exclude-from '/home/admbust/.ssh/exclude-list.txt' --rsync-path="sudo rsync" -e "ssh -p 55036 -i /home/admbust/.ssh/xoyaz_ed25519 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"  usernl@xoyaz.xyz:/srv/data/borg-backups/* /srv/data/borg-backups/ ; if [ $? -eq 0 ]; then echo "Rsync usernl@xoyaz.xyz:/srv/data/borg-backups/* /srv/data/borg-backups/ : Synchronisation OK" | systemd-cat -t rsyncborg -p info ; else echo "Rsync usernl@xoyaz.xyz:/srv/data/borg-backups/* /srv/data/borg-backups/ :Erreur Synchronisation" | systemd-cat -t rsyncborg -p emerg ; fi

On redirige le résultat de la commande ($?) vers le journal avec systemd-cat
if [ $? -eq 0 ]; then echo "Rsync usernl@xoyaz.xyz:/srv/data/borg-backups/* /srv/data/borg-backups/ : Synchronisation OK" | systemd-cat -t rsyncborg -p info ; else echo "Rsync usernl@xoyaz.xyz:/srv/data/borg-backups/* /srv/data/borg-backups/ :Erreur Synchronisation" | systemd-cat -t rsyncborg -p emerg ; fi

la ligne de commande décortiquée:

if [ $? -eq 0 ]
 then
  echo "Rsync usernl@xoyaz.xyz:/srv/data/borg-backups/* /srv/data/borg-backups/ : Synchronisation OK" | systemd-cat -t rsyncborg -p info
 else
  echo "Rsync usernl@xoyaz.xyz:/srv/data/borg-backups/* /srv/data/borg-backups/ :Erreur Synchronisation" | systemd-cat -t rsyncborg -p emerg
fi

On peut lire le journal avec l’identifiant rsyncborg

journalctl -t rsyncborg
-- Logs begin at Thu 2019-08-29 11:07:55 CEST, end at Tue 2019-09-17 17:50:32 CEST. --
sept. 17 17:50:32 srvxo rsyncborg[11728]: Rsync usernl@xoyaz.xyz:/srv/data/borg-backups/* /srv/data/borg-backups/ : Synchronisation OK

Sauvegarde dossiers Musique Calibre → xoyaz.xyz (backup)

Ajouter au lanceur de tâches programmées

sudo crontab -e
# Sauvegarde de dossiers /srv/data/{Musique,CalibreTechnique} sur serveur distant backup (nl) xoyaz.xyz
# Synchro Musique avec Backup
00 02 * * * rsync -avz --progress --stats --human-readable --exclude-from '/home/admbust/.ssh/exclude-list.txt' --rsync-path="sudo rsync" -e "ssh -p 55036 -i /home/admbust/.ssh/xoyaz_ed25519 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"  /srv/data/Musique/* usernl@xoyaz.xyz:/home/usernl/backup/musique/ 
# Synchro CalibreTechnique avec Backup
10 02 * * * rsync -avz --progress --stats --human-readable --exclude-from '/home/admbust/.ssh/exclude-list.txt' --rsync-path="sudo rsync" -e "ssh -p 55036 -i /home/admbust/.ssh/xoyaz_ed25519 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"  /srv/data/CalibreTechnique/* usernl@xoyaz.xyz:/home/usernl/backup/CalibreTechnique/

Nginx + PHP7.3 + MariaDB + SSL/TLS1.3

lemp

Ce script bash compile et installe nginx ,le service nginx (systemd) pour le démarrage, PHP7.3 et mariadb.
Exécuter les instructions suivantes pour lancer la compilation

sudo -s             # Passer en mode super utilisateur (su ou sudo)  
wget -O compil.sh "https://static.cinay.xyz/files/debian10-compilation-nginx-lua-tls1.3-php7.3-MariaDB.sh" # Télécharger le script
chmod +x compil.sh  # Rendre le script exécutable  
./compil.sh     # Exécuter le script
#******** Patienter **********

Patienter de 5 à 10 minutes…
Résultat

Versions Nginx OpenSSL MariaDB et PHP
nginx version: nginx/1.16.1
OpenSSL 1.1.1c  28 May 2019
mysql  Ver 15.1 Distrib 10.3.15-MariaDB, for debian-linux-gnu (x86_64) using readline 5.2
Mot de passe MySql/MariaDB : /etc/mysql/mdp
PHP 7.3.8-1+0~20190807.43+debian10~1.gbp7731bf (cli) (built: Aug  7 2019 19:47:21) ( NTS )
Copyright (c) 1997-2018 The PHP Group
Zend Engine v3.3.8, Copyright (c) 1998-2018 Zend Technologies
    with Zend OPcache v7.3.8-1+0~20190807.43+debian10~1.gbp7731bf, Copyright (c) 1999-2018, by Zend Technologies

Configuration nginx , ssl (tls1.2 tls1.3) , Diffie Hellman ,Headers et OCSP
Diffie-Hellman : openssl dhparam -out /etc/ssl/private/dh2048.pem -outform PEM -2 2048

Regroupement dans un fichier /etc/nginx/ssl_dh_headers_ocsp

    ssl_certificate /etc/ssl/private/xoyize.xyz-fullchain.pem;
    ssl_certificate_key /etc/ssl/private/xoyize.xyz-key.pem;
    ssl_session_timeout 5m;
    ssl_session_cache shared:SSL:50m;

    # As suggested by Mozilla : https://wiki.mozilla.org/Security/Server_Side_TLS and https://en.wikipedia.org/wiki/Curve25519
    ssl_ecdh_curve secp521r1:secp384r1:prime256v1;
    ssl_prefer_server_ciphers on;

    # Ciphers with modern compatibility
    ssl_protocols TLSv1.3 TLSv1.2;
    ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256';

    ssl_dhparam /etc/ssl/private/dh2048.pem;

    # Follows the Web Security Directives from the Mozilla Dev Lab and the Mozilla Obervatory + Partners
    # https://wiki.mozilla.org/Security/Guidelines/Web_Security
    # https://observatory.mozilla.org/ 
    more_set_headers "Strict-Transport-Security : max-age=63072000; includeSubDomains; preload"; 
    more_set_headers "Content-Security-Policy : upgrade-insecure-requests";
    more_set_headers "Content-Security-Policy-Report-Only : default-src https: data: 'unsafe-inline' 'unsafe-eval'";
    more_set_headers "X-Content-Type-Options : nosniff";
    more_set_headers "X-XSS-Protection : 1; mode=block";
    more_set_headers "X-Download-Options : noopen";
    more_set_headers "X-Permitted-Cross-Domain-Policies : none";
    more_set_headers "X-Frame-Options : SAMEORIGIN";

    
    # OCSP settings
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_trusted_certificate /etc/ssl/private/xoyize.xyz-ca.pem;
    resolver 127.0.0.1 127.0.1.1 valid=300s;
    resolver_timeout 5s;

On change le dossier racine

sudo mkdir -p /var/www/default-www
sudo mv /var/www/{index.html,info.php} /var/www/default-www/

Générer le fichier Diffie-Hellman

sudo -s
openssl dhparam -out /etc/ssl/private/dh2048.pem -outform PEM -2 2048

Configuration de base avec SSL et sécurité + letsencrypt (renouvellement)

sudo nano /etc/nginx/conf.d/xoyize.xyz.conf
server {
    listen 80;
    listen [::]:80;

    ## redirect http to https ##
    server_name xoyize.xyz;
    return  301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name xoyize.xyz;

    ####    Locations
    # On cache les fichiers statiques
    location ~* \.(html|css|js|png|jpg|jpeg|gif|ico|svg|eot|woff|ttf)$ { expires max; }
    # On interdit les dotfiles
    location ~ /\. { deny all; }

    include ssl_dh_headers_ocsp;

    root /var/www/default-www ;
    index index.php index.html index.htm;
        location ~ \.php$ {
           fastcgi_split_path_info ^(.+\.php)(/.+)$;
           fastcgi_pass unix:/run/php/php7.3-fpm.sock;   # PHP7.3
           fastcgi_index index.php;
           include fastcgi_params;
	   fastcgi_param SCRIPT_FILENAME $request_filename;
        }

    # if folder xoyize.xyz.d , uncomment the following directive
    #include conf.d/xoyize.xyz.d/*.conf;

    access_log /var/log/nginx/xoyize.xyz-access.log;
    error_log /var/log/nginx/xoyize.xyz-error.log;
}

Effacer ancien fichier de config

sudo rm /etc/nginx/conf.d/default.conf

Vérifier

sudo nginx -t
nginx: the configuration file /usr/local/openresty/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /usr/local/openresty/nginx/conf/nginx.conf test is successful

relancer nginx

sudo systemctl restart nginx

Vérifier le lien https://xoyize.xyz , le tls 1.3

Nginx et les modules

sudo nginx -V
built by gcc 8.3.0 (Debian 8.3.0-6) 
built with OpenSSL 1.1.1d  10 Sep 2019
TLS SNI support enabled
configure arguments:
 --with-cc-opt='-g -O2 -fdebug-prefix-map=/usr/src/nginx-custom/$stable_nginx=. -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2'
 --with-ld-opt='-Wl,-z,relro -Wl,-z,now,-rpath,/usr/local/lib'
 --prefix=/usr/share/nginx
 --conf-path=/etc/nginx/nginx.conf
 --http-log-path=/var/log/nginx/access.log
 --error-log-path=/var/log/nginx/error.log
 --lock-path=/var/lock/nginx.lock
 --pid-path=/run/nginx.pid
 --modules-path=/usr/lib/nginx/modules
 --http-client-body-temp-path=/var/lib/nginx/body
 --http-fastcgi-temp-path=/var/lib/nginx/fastcgi
 --http-proxy-temp-path=/var/lib/nginx/proxy
 --http-scgi-temp-path=/var/lib/nginx/scgi
 --http-uwsgi-temp-path=/var/lib/nginx/uwsgi
 --with-debug
 --with-pcre-jit
 --with-http_ssl_module
 --with-http_stub_status_module
 --with-http_realip_module
 --with-http_auth_request_module
 --with-http_v2_module
 --with-http_dav_module
 --with-http_slice_module
 --with-threads
 --with-http_addition_module
 --with-http_flv_module
 --with-http_geoip_module=dynamic
 --with-http_gunzip_module
 --with-http_gzip_static_module
 --with-http_image_filter_module=dynamic
 --with-http_mp4_module
 --with-http_perl_module=dynamic
 --with-http_random_index_module
 --with-http_secure_link_module
 --with-http_sub_module
 --with-http_xslt_module=dynamic
 --with-mail=dynamic
 --with-mail_ssl_module
 --with-stream
 --with-stream_ssl_module
 --with-stream_ssl_preread_module
 --with-http_ssl_module
 --add-dynamic-module=../modules/headers-more-nginx-module
 --add-dynamic-module=../modules/nginx-auth-pam
 --add-dynamic-module=../modules/ngx-fancyindex
 --add-dynamic-module=../modules/nginx-upload-progress
 --add-dynamic-module=../modules/nginx-upstream-fair
 --add-dynamic-module=../modules/nginx-cache-purge
 --add-dynamic-module=../modules/ngx_http_substitutions_filter_module

Les modules /usr/lib/nginx/modules/

ngx_http_auth_pam_module.so    ngx_http_headers_more_filter_module.so  ngx_http_subs_filter_module.so	  ngx_http_xslt_filter_module.so
ngx_http_fancyindex_module.so  ngx_http_image_filter_module.so	       ngx_http_uploadprogress_module.so  ngx_mail_module.so
ngx_http_geoip_module.so       ngx_http_perl_module.so		       ngx_http_upstream_fair_module.so

Les modules actifs /etc/nginx/modules-enabled/

50-mod-ngx_http_auth_pam_module.so-upload.conf		   50-mod-ngx_http_image_filter_module.so-upload.conf	 50-mod-ngx_http_upstream_fair_module.so-upload.conf
50-mod-ngx_http_fancyindex_module.so-upload.conf	   50-mod-ngx_http_perl_module.so-upload.conf		 50-mod-ngx_http_xslt_filter_module.so-upload.conf
50-mod-ngx_http_geoip_module.so-upload.conf		   50-mod-ngx_http_subs_filter_module.so-upload.conf	 50-mod-ngx_mail_module.so-upload.conf
50-mod-ngx_http_headers_more_filter_module.so-upload.conf  50-mod-ngx_http_uploadprogress_module.so-upload.conf

PHP Composer sur Debian

curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer
chmod +x /usr/local/bin/composer

Mise en place onduleur eaton

Gestion onduleur eaton (debian ups)

En suivant les liens ci-dessus , on installe la gestion d’un onduleur par nut et la possibilité d’exécuter des bash cgi sur nginx.

Pour accepter les fichiers autres de configuration nginx ,il faut modifier le fichier /etc/nginx/conf.d/xoyize.xyz.conf et ajouter la ligne suivante (avant access_log /var/log/nginx/xoyize.xyz-access.log;

include conf.d/xoyize.xyz.d/*.conf;

Le fichier de configuration nginx pour l’onduleur

/etc/nginx/conf.d/xoyize.xyz.d/eaton.conf 
location /cgi {
     alias /var/www/default-www/cgi;
        location ~ \.cgi$ {
            fastcgi_intercept_errors on;
            include fastcgi_params;
            #fastcgi_param DOCUMENT_ROOT \$document_root;
            #fastcgi_param SCRIPT_NAME   \$fastcgi_script_name;
            #fastcgi_param SCRIPT_FILENAME \$document_root\$fastcgi_script_name;
            fastcgi_param SCRIPT_FILENAME $request_filename;
            fastcgi_pass unix:/run/fcgiwrap.socket;
        }


}

Créer un dossier pour les bash cgi

sudo mkdir /var/www/default-www/cgi

Le script CGI /var/www/default-www/cgi/eaton.cgi

#!/bin/bash

echo "Content-type: text/html"
echo ""

echo "<html>"
echo "<head>"
echo "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">"
echo "<title>Onduleur</title>"
echo "</head>"
echo "<body>"
#echo "<p>TEST</p>"
#echo "<pre>"
#env
#upsc eaton@localhost 2>&1 | grep -v '^Init SSL' |grep 'device\|battery\|ups.status'
#echo "</pre>"
echo -e "<h2>Onduleur " 
upsc eaton@localhost 2>&1 | grep -v '^Init SSL' |grep 'device.mfr:' | awk -F'[:]' '{print $2}' |sed "s/^\ *//g"
echo -e " "
upsc eaton@localhost 2>&1 | grep -v '^Init SSL' |grep 'device.model:' | awk -F'[:]' '{print $2}' |sed "s/^\ *//g"
echo "</h2>"
echo -e "Charge batterie actuelle : "
upsc eaton@localhost 2>&1 | grep -v '^Init SSL' |grep 'battery.charge:' | awk -F'[:]' '{print $2}' |sed "s/^\ *//g"
echo " %"
echo "<br>"
echo -e "Charge minimun tolérée : "
upsc eaton@localhost 2>&1 | grep -v '^Init SSL' |grep 'battery.charge.low:' | awk -F'[:]' '{print $2}' |sed "s/^\ *//g"
echo " %"
echo "<br>"
ETAT=`upsc eaton@localhost 2>&1 | grep -v '^Init SSL' |grep 'ups.status:' | awk -F'[:]' '{print $2}' |sed "s/^\ *//g"`
case $ETAT in
     OL)
          echo "Onduleur en ligne sur le secteur"
          ;;
     OB)
          echo "Onduleur sur batterie (coupure courant)"
          ;;
     *)
          echo "Status onduleur inconnu !!!"
          ;;
esac

echo "<pre>"
#env
upsc eaton@localhost 2>&1 | grep -v '^Init SSL'
echo "</pre>"

echo "</body>"
echo "</html>"

exit 0

Accès par le lien https://xoyize.xyz/cgi/eaton.cgi

Development - devel.xoyize.xyz

 ____                 _                                  _   
|  _ \  _____   _____| | ___  _ __  _ __ ___   ___ _ __ | |_ 
| | | |/ _ \ \ / / _ \ |/ _ \| '_ \| '_ ` _ \ / _ \ '_ \| __|
| |_| |  __/\ V /  __/ | (_) | |_) | | | | | |  __/ | | | |_ 
|____/ \___| \_/ \___|_|\___/| .__/|_| |_| |_|\___|_| |_|\__|
                             |_|                             

Accès dossier “développement” /srv/data/devel/ouestline partagé avec PC1
Fichier de configuration nginx /etc/nginx/conf.d/devel.xoyize.xyz.conf

# /etc/nginx/conf.d/devel.xoyize.xyz.conf	
	##
	# Virtual Host devel.xoyize.xyz
	##

	server {
	    listen 80;
	    listen [::]:80;
	
	    ## redirect http to https ##
	    server_name devel.xoyize.xyz;
	    return  301 https://$server_name$request_uri;
	}
	
	server {
	    listen 443 ssl http2;
	    listen [::]:443 ssl http2;
	    server_name devel.xoyize.xyz;
	
	    ####    Locations
	    # On cache les fichiers statiques
	    location ~* \.(html|css|js|png|jpg|jpeg|gif|ico|svg|eot|woff|ttf)$ { expires max; }
	    # On interdit les dotfiles
	    location ~ /\. { deny all; }
	
	   include ssl_dh_headers_ocsp;
	
	   # autoindex on;
	   fancyindex on;              # Enable fancy indexes.
	   fancyindex_exact_size off;  # Output human-readable file sizes.
	
	    root /srv/data/devel/ouestline/ ;
	    index index.php index.html index.htm;
	        location ~ \.php$ {
	           fastcgi_split_path_info ^(.+\.php)(/.+)$;
	           fastcgi_pass unix:/run/php/php7.3-fpm.sock;   # PHP7.3
	           fastcgi_index index.php;
	           include fastcgi_params;
		   fastcgi_param SCRIPT_FILENAME $request_filename;
	        }
	
	    # if folder devel.xoyize.xyz.d , uncomment the following directive
	    #include conf.d/devel.xoyize.xyz.d/*.conf;
	
	    access_log /var/log/nginx/develop-access.log;
	    error_log /var/log/nginx/develop-error.log;
	}

Vérifier et relancer nginx

sudo nginx -t
sudo systemctl reload nginx

Problème de compilation du module --add-dynamic-module=../modules/lua-nginx-module
NGINX as an OpenID Connect RP with WSO2 Identity Server — Part 2

Pi-Hole - dns.xoyize.xyz

Pi-Hole
On va utiliser le serveur xoyize.xyz qui est connecté au réseau local avec une ip statique 192.168.0.45

Pi-Hole installation

Pi-Hole (bloqueur de pub) permet de filtrer les requêtes DNS grâce à des listes pré-établies de domaines bloqués

Il est préférable d’être root pour éviter les problèmes de droits lors de l’installation.

sudo -s

Une seule commande est à saisir pour lancer l’installation de Pi Hole :

curl -sSL https://install.pi-hole.net | bash

Le script d’installation se récupère depuis le site officiel du projet Pi Hole – les paquets manquants sur votre système seront automatiquement installés.
Une fois le script lancé, une première question vous sera posée : le serveur DNS qui servira de serveur primaire à contacter depuis votre Pi Hole. En effet, même si Pi Hole bloque les liens / adresses / redirections DNS inutiles, il faut toutefois rediriger sur un vrai serveur DNS les requêtes utiles







Une fois l’installation terminée, on peut changer le mot de passe :

sudo pihole -a -p

Pi-Hole nginx

Si le serveur lighttpd est installé , l’arrêter et le désactiver

systemctl stop lighttpd
systemctl disable lighttpd

Création de la configuration nginx /etc/nginx/conf.d/dns.xoyize.xyz.conf

# /etc/nginx/conf.d/dns.xoyize.xyz.conf	
	##
	# Virtual Host dns.xoyize.xyz (PiHole)
	##

	server {
	    listen 80;
	    listen [::]:80;
	
	    ## redirect http to https ##
	    server_name dns.xoyize.xyz;
	    return  301 https://$server_name$request_uri;
	}
	
	server {
	    listen 443 ssl http2;
	    listen [::]:443 ssl http2;
	
		include ssl_dh_headers_ocsp;
	
	        root /var/www/html;
	        server_name dns.xoyize.xyz;
	        autoindex off;
	
	        index pihole/index.php index.php index.html index.htm;
	
	        location / {
	                expires max;
	                try_files $uri $uri/ =404;
	        }
	
	        location ~ \.php$ {
	           fastcgi_split_path_info ^(.+\.php)(/.+)$;
	           fastcgi_pass unix:/run/php/php7.3-fpm.sock;   # PHP7.3
	           fastcgi_index index.php;
	           include fastcgi_params;
		   fastcgi_param SCRIPT_FILENAME $request_filename;
	                auth_basic "Restricted"; #For Basic Auth
	                auth_basic_user_file /etc/nginx/.htpasswd;  #For Basic Auth
	        }
	
	        location /*.js {
	                index pihole/index.js;
	                auth_basic "Restricted"; #For Basic Auth
	                auth_basic_user_file /etc/nginx/.htpasswd;  #For Basic Auth
	        }
	
	        location /admin {
	                root /var/www/html;
	                index index.php index.html index.htm;
	                auth_basic "Restricted"; #For Basic Auth
	                auth_basic_user_file /etc/nginx/.htpasswd;  #For Basic Auth
	        }
	
	        location ~ /\.ht {
	                deny all;
	        }
	}

Vérification et relance nginx

nginx -t
systemctl restart nginx

Paramétrage FreeBox

Dans l’interface de paramétrage de votre routeur/box internet, de déclarer l’IP 192.168.0.45 comme champ de serveur DNS. Il faut remplacer la première adresse dns par l’ip locale du serveur Pi-Hole (192.168.0.45).

Paramètres de la freebox → Mode avancé → DHCP
pi-hole-dns-freebox

Accès https://dns.xoyize.xyz/admin

En cas d’erreur pihole Unable to parse results from queryads.php: Unhandled error message ()
Modifier le fichier /var/www/html/pihole/index.php
Remplacer la ligne
$serverName = htmlspecialchars($_SERVER["HTTP_HOST"]);
par $serverName = htmlspecialchars($_SERVER["SERVER_ADDR"]);
Sauvegarder et recharger la page web.

Wiki.js - wiki.xoyize.xyz

wiki.js (Node.js + Yarn) sur Debian

fichier de configuration nginx /etc/nginx/conf.d/wiki.xoyize.xyz.conf

# /etc/nginx/conf.d/wiki.xoyize.xyz.conf
	##
	# Virtual Host wiki.xoyize.xyz (WikiJs)
	##

	server {
	    listen 80;
	    listen [::]:80;
	
	    ## redirect http to https ##
	    server_name wiki.xoyize.xyz;
	    return  301 https://$server_name$request_uri;
	}
	
	server {
	    listen 443 ssl http2;
	    listen [::]:443 ssl http2;
	    server_name wiki.xoyize.xyz;
	
	    charset utf-8;
	    client_max_body_size 50M;
	
	    include ssl_dh_headers_ocsp;
	
	    location / {
	        proxy_set_header Host $http_host;
	        proxy_set_header X-Real-IP $remote_addr;
	        proxy_pass http://127.0.0.1:3000;
	        proxy_http_version 1.1;
	        proxy_set_header Upgrade $http_upgrade;
	        proxy_set_header Connection "upgrade";
	        proxy_next_upstream error timeout http_502 http_503 http_504;
	    }
	    
	    access_log /var/log/nginx/wikijs-access.log;
	    error_log /var/log/nginx/wikijs-error.log;
	}

PhpLdapAdmin - lm.xoyize.xyz

OpenLDAP installation et configuration annuaire + PhpLdapAdmin

  • Host : ldap.xoyize.xyz
  • Port : 389
  • DN : dc=xoyize,dc=xyz (connexion anonyme)
  • DN : cn=admin,dc=xoyize,dc=xyz (connexion avec mot de passe)

Configuration nginx /etc/nginx/conf.d/lm.xoyize.xyz.conf

# /etc/nginx/conf.d/lm.xoyize.xyz.conf	
	##
	# Virtual Host lm.xoyize.xyz (PhpLdapAdmin)
	##

	server {
	    listen 80;
	    listen [::]:80;
	
	    ## redirect http to https ##
	    server_name lm.xoyize.xyz;
	    return  301 https://$server_name$request_uri;
	}
	
	server {
	    listen 443 ssl http2;
	    listen [::]:443 ssl http2;
	    server_name lm.xoyize.xyz;
	
	    include ssl_dh_headers_ocsp;
	
	    root /var/www/phpldapadmin;
	    index index.php;
	
	        location ~ \.php$ {
	           fastcgi_split_path_info ^(.+\.php)(/.+)$;
	           fastcgi_pass unix:/run/php/php7.3-fpm.sock;   # PHP7.3
	           fastcgi_index index.php;
	           include fastcgi_params;
	    	   fastcgi_param SCRIPT_FILENAME $request_filename;
	        }
	
	
	    access_log /var/log/nginx/lm-access.log;
	    error_log /var/log/nginx/lm-error.log;
	}

Nextcloud - nc.xoyize.xyz

nginx - nginx.conf

user www-data;
worker_processes auto;
pid /run/nginx.pid;
include /etc/nginx/modules-enabled/*.conf;

events {
	worker_connections 768;
}

http {
  server_names_hash_bucket_size 64;
		upstream php-handler {
	  		server unix:/run/php/php7.3-fpm.sock;
		}

	##
	# Basic Settings
	##

	sendfile on;
	tcp_nopush on;
	tcp_nodelay on;
	keepalive_timeout 65;
	types_hash_max_size 2048;
	# server_tokens off;

	include /etc/nginx/mime.types;
	default_type application/octet-stream;

	##
	# SSL Settings
	##

	#ssl_protocols TLSv1 TLSv1.1 TLSv1.2; # Dropping SSLv3, ref: POODLE
	ssl_protocols TLSv1.2 TLSv1.3;
	ssl_prefer_server_ciphers on;

	##
	# Logging Settings
	##

	access_log /var/log/nginx/access.log;
	error_log /var/log/nginx/error.log;

	##
	# Gzip Settings
	##

	gzip on;
	gzip_disable "msie6";

	##
	# Virtual Host Configs
	##

	include /etc/nginx/conf.d/*.conf;
	include /etc/nginx/sites-enabled/*;
}

PHP - configuration

Exécuter les instructions suivantes

cp /etc/php/7.3/fpm/pool.d/www.conf /etc/php/7.3/fpm/pool.d/www.conf.bak
cp /etc/php/7.3/cli/php.ini /etc/php/7.3/cli/php.ini.bak
cp /etc/php/7.3/fpm/php.ini /etc/php/7.3/fpm/php.ini.bak
cp /etc/php/7.3/fpm/php-fpm.conf /etc/php/7.3/fpm/php-fpm.conf.bak

sed -i "s/;env\[HOSTNAME\] = /env[HOSTNAME] = /" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s/;env\[TMP\] = /env[TMP] = /" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s/;env\[TMPDIR\] = /env[TMPDIR] = /" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s/;env\[TEMP\] = /env[TEMP] = /" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s/;env\[PATH\] = /env[PATH] = /" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s/pm.max_children = .*/pm.max_children = 240/" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s/pm.start_servers = .*/pm.start_servers = 20/" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s/pm.min_spare_servers = .*/pm.min_spare_servers = 10/" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s/pm.max_spare_servers = .*/pm.max_spare_servers = 20/" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s/;pm.max_requests = 500/pm.max_requests = 500/" /etc/php/7.3/fpm/pool.d/www.conf

sed -i "s/output_buffering =.*/output_buffering = 'Off'/" /etc/php/7.3/cli/php.ini
sed -i "s/max_execution_time =.*/max_execution_time = 1800/" /etc/php/7.3/cli/php.ini
sed -i "s/max_input_time =.*/max_input_time = 3600/" /etc/php/7.3/cli/php.ini
sed -i "s/post_max_size =.*/post_max_size = 10240M/" /etc/php/7.3/cli/php.ini
sed -i "s/upload_max_filesize =.*/upload_max_filesize = 10240M/" /etc/php/7.3/cli/php.ini
sed -i "s/max_file_uploads =.*/max_file_uploads = 100/" /etc/php/7.3/cli/php.ini
sed -i "s/;date.timezone.*/date.timezone = Europe\/\Berlin/" /etc/php/7.3/cli/php.ini
sed -i "s/;session.cookie_secure.*/session.cookie_secure = True/" /etc/php/7.3/cli/php.ini

sed -i "s/memory_limit = 128M/memory_limit = 512M/" /etc/php/7.3/fpm/php.ini
sed -i "s/output_buffering =.*/output_buffering = 'Off'/" /etc/php/7.3/fpm/php.ini
sed -i "s/max_execution_time =.*/max_execution_time = 1800/" /etc/php/7.3/fpm/php.ini
sed -i "s/max_input_time =.*/max_input_time = 3600/" /etc/php/7.3/fpm/php.ini
sed -i "s/post_max_size =.*/post_max_size = 10240M/" /etc/php/7.3/fpm/php.ini
sed -i "s/upload_max_filesize =.*/upload_max_filesize = 10240M/" /etc/php/7.3/fpm/php.ini
sed -i "s/max_file_uploads =.*/max_file_uploads = 100/" /etc/php/7.3/fpm/php.ini
sed -i "s/;date.timezone.*/date.timezone = Europe\/\Berlin/" /etc/php/7.3/fpm/php.ini
sed -i "s/;session.cookie_secure.*/session.cookie_secure = True/" /etc/php/7.3/fpm/php.ini
sed -i "s/;opcache.enable=.*/opcache.enable=1/" /etc/php/7.3/fpm/php.ini
sed -i "s/;opcache.enable_cli=.*/opcache.enable_cli=1/" /etc/php/7.3/fpm/php.ini
sed -i "s/;opcache.memory_consumption=.*/opcache.memory_consumption=128/" /etc/php/7.3/fpm/php.ini
sed -i "s/;opcache.interned_strings_buffer=.*/opcache.interned_strings_buffer=8/" /etc/php/7.3/fpm/php.ini
sed -i "s/;opcache.max_accelerated_files=.*/opcache.max_accelerated_files=10000/" /etc/php/7.3/fpm/php.ini
sed -i "s/;opcache.revalidate_freq=.*/opcache.revalidate_freq=1/" /etc/php/7.3/fpm/php.ini
sed -i "s/;opcache.save_comments=.*/opcache.save_comments=1/" /etc/php/7.3/fpm/php.ini

sed -i "s/;emergency_restart_threshold =.*/emergency_restart_threshold = 10/" /etc/php/7.3/fpm/php-fpm.conf
sed -i "s/;emergency_restart_interval =.*/emergency_restart_interval = 1m/" /etc/php/7.3/fpm/php-fpm.conf
sed -i "s/;process_control_timeout =.*/process_control_timeout = 10s/" /etc/php/7.3/fpm/php-fpm.conf

sed -i "s/09,39.*/# &/" /etc/cron.d/php
(crontab -l ; echo "09,39 * * * * /usr/lib/php/sessionclean 2>&1") | crontab -u root -

cp /etc/ImageMagick-6/policy.xml /etc/ImageMagick-6/policy.xml.bak
sed -i "s/rights\=\"none\" pattern\=\"PS\"/rights\=\"read\|write\" pattern\=\"PS\"/" /etc/ImageMagick-6/policy.xml
sed -i "s/rights\=\"none\" pattern\=\"EPI\"/rights\=\"read\|write\" pattern\=\"EPI\"/" /etc/ImageMagick-6/policy.xml
sed -i "s/rights\=\"none\" pattern\=\"PDF\"/rights\=\"read\|write\" pattern\=\"PDF\"/" /etc/ImageMagick-6/policy.xml
sed -i "s/rights\=\"none\" pattern\=\"XPS\"/rights\=\"read\|write\" pattern\=\"XPS\"/" /etc/ImageMagick-6/policy.xml

Redémarrez les deux, PHP et NGINX

service php7.3-fpm restart && service nginx restart

MariaDB - configuration

mariaDB installé, motde passe /etc/mysql/mdp
Vérifiez la version de votre serveur de base de données:

mysql --version

mysql Ver 15.1 Distrib 10.3.17-MariaDB, for debian-linux-gnu (x86_64) using readline 5.2 devrait apparaître.

Sécuriser MariaDB

mysql_secure_installation
    Switch to unix_socket authentication [Y/n] N
    Enter current password for root (enter for none): <ENTER> or type the password Set root password? [Y/n] Y

Mot de passe root défini lors de l’installation de MariaDB, il vous sera demandé si vous souhaitez le modifier ou le conserver.

Enter current password for root (enter for none): 
OK, successfully used password, moving on...
Change the root password? [Y/n] n
Remove anonymous users? [Y/n] Y
Disallow root login remotely? [Y/n] Y
Remove test database and access to it? [Y/n] Y
Reload privilege tables now? [Y/n] Y

Configurer “my.cnf” MariaDB

service mysql stop
mv /etc/mysql/my.cnf /etc/mysql/my.cnf.bak && nano /etc/mysql/my.cnf

Collez les lignes suivantes:

[client]
default-character-set = utf8mb4
port = 3306
socket = /var/run/mysqld/mysqld.sock

[mysqld_safe]
log_error=/var/log/mysql/mysql_error.log
nice = 0
socket = /var/run/mysqld/mysqld.sock

[mysqld]
basedir = /usr
bind-address = 127.0.0.1
binlog_format = ROW
bulk_insert_buffer_size = 16M
character-set-server = utf8mb4
collation-server = utf8mb4_general_ci
concurrent_insert = 2
connect_timeout = 5
datadir = /var/lib/mysql
default_storage_engine = InnoDB
expire_logs_days = 10
general_log_file = /var/log/mysql/mysql.log
general_log = 0
innodb_buffer_pool_size = 1024M
innodb_buffer_pool_instances = 1
innodb_flush_log_at_trx_commit = 2
innodb_log_buffer_size = 32M
innodb_max_dirty_pages_pct = 90
innodb_file_per_table = 1
innodb_open_files = 400
innodb_io_capacity = 4000
innodb_flush_method = O_DIRECT
key_buffer_size = 128M
lc_messages_dir = /usr/share/mysql
lc_messages = en_US
log_bin = /var/log/mysql/mariadb-bin
log_bin_index = /var/log/mysql/mariadb-bin.index
log_error=/var/log/mysql/mysql_error.log
log_slow_verbosity = query_plan
log_warnings = 2
long_query_time = 1
max_allowed_packet = 16M
max_binlog_size = 100M
max_connections = 200
max_heap_table_size = 64M
myisam_recover_options = BACKUP
myisam_sort_buffer_size = 512M
port = 3306
pid-file = /var/run/mysqld/mysqld.pid
query_cache_limit = 2M
query_cache_size = 64M
query_cache_type = 1
query_cache_min_res_unit = 2k
read_buffer_size = 2M
read_rnd_buffer_size = 1M
skip-external-locking
skip-name-resolve
slow_query_log_file = /var/log/mysql/mariadb-slow.log
slow-query-log = 1
socket = /var/run/mysqld/mysqld.sock
sort_buffer_size = 4M
table_open_cache = 400
thread_cache_size = 128
tmp_table_size = 64M
tmpdir = /tmp
transaction_isolation = READ-COMMITTED
user = mysql
wait_timeout = 600

[mysqldump]
max_allowed_packet = 16M
quick
quote-names

[isamchk]
key_buffer = 16M

Redémarrer MariaDB

service mysql restart 

MariaDB - création base nextcloud

Générer un mot de passe pour nextcloud

echo $(head -c 12 /dev/urandom | openssl enc -base64) > /etc/mysql/nextcloud

Connexion à MariaDB

mysql -uroot -p$(cat /etc/mysql/mdp)

Créer la base “nextcloud”

mysql -uroot -p$(cat /etc/mysql/mdp) -e "CREATE DATABASE nextcloud CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci; CREATE USER nextcloud@localhost identified by '$(cat /etc/mysql/nextcloud)'; GRANT ALL PRIVILEGES on nextcloud.* to nextcloud@localhost; FLUSH privileges; quit;"

Vérifiez que le niveau d’isolement de la transaction a été défini sur READ_Commit et que le classement a été défini sur UTF8MB4 correctement:

mysql -h localhost -uroot -p$(cat /etc/mysql/mdp) -e "SELECT @@TX_ISOLATION; SELECT SCHEMA_NAME 'database', default_character_set_name 'charset', DEFAULT_COLLATION_NAME 'collation' FROM information_schema.SCHEMATA WHERE SCHEMA_NAME='nextcloud'"
+----------------+
| @@TX_ISOLATION |
+----------------+
| READ-COMMITTED |
+----------------+
+-----------+---------+--------------------+
| database  | charset | collation          |
+-----------+---------+--------------------+
| nextcloud | utf8mb4 | utf8mb4_general_ci |
+-----------+---------+--------------------+

Si le résultat est “READ-COMMITTED” et “utf8mb4_general_ci” comme indiqué, poursuivez l’installation de redis.

Redis

Redis, qui signifie Remote Dictionary Server (Serveur de dictionnaire à distance), est un système de stockage de données clé-valeur en mémoire, open source et rapide, pour une utilisation en tant que base de données, de cache, de courtier de messages et de file d’attente. Le projet a démarré lorsque Salvatore Sanfilippo, le développeur initial de Redis, a essayé d’améliorer la scalabilité de sa startup italienne. Redis offre désormais des temps de réponse inférieurs à la milliseconde permettant des millions de demandes par seconde pour des applications en temps réel dans les domaines du jeu, de la technologie publicitaire, des services financiers, des soins de santé et de l’Internet des objets. Redis est un choix populaire pour la mise en cache, la gestion de session, les jeux, les classements, l’analyse en temps réel, le géospatial, l’appel de voiture avec chauffeur, le chat/la messagerie, le streaming multimédia et les applications pub/sub.

Installation

apt update && apt install redis-server php-redis -y

Changer la configuration et l’appartenance à un groupe

cp /etc/redis/redis.conf /etc/redis/redis.conf.bak
sed -i "s/port 6379/port 0/" /etc/redis/redis.conf
sed -i s/\#\ unixsocket/\unixsocket/g /etc/redis/redis.conf
sed -i "s/unixsocketperm 700/unixsocketperm 770/" /etc/redis/redis.conf
sed -i "s/# maxclients 10000/maxclients 512/" /etc/redis/redis.conf
sed -i "s/supervised no/supervised systemd/" /etc/redis/redis.conf
usermod -a -G redis www-data

cp /etc/sysctl.conf /etc/sysctl.conf.bak
sed -i '$avm.overcommit_memory = 1' /etc/sysctl.conf

Il est recommandé de redémarrer votre serveur une fois:

shutdown -r now 

Let’s Encrypt - certificats SSL

Si vous n’utilisez pas la création des certificats Let’s Encrypt par les DNS
Créer le fichier letsencrypt.conf

nano /etc/nginx/conf.d/letsencrypt.conf

Collez les lignes suivantes:

server {
server_name 127.0.0.1;
 listen 127.0.0.1:81 default_server;
 charset utf-8;
 location ^~ /.well-known/acme-challenge {
  default_type text/plain;
  root /var/www/letsencrypt;
 }
}

Nginx - ssl_params

Créer ou modifier le fichier ssl_params

nano /etc/nginx/ssl_params

Coller les lignes suivantes

    ssl_certificate /etc/ssl/private/xoyize.xyz-fullchain.pem;
    ssl_certificate_key /etc/ssl/private/xoyize.xyz-key.pem;
    ssl_session_timeout 5m;
    ssl_session_cache shared:SSL:50m;
    ssl_prefer_server_ciphers on;

    # Ciphers with modern compatibility
    # New protocol TLSv1.3
    ssl_protocols TLSv1.3 TLSv1.2;
    #ssl_ciphers 'TLS13-CHACHA20-POLY1305-SHA256:TLS13-AES-256-GCM-SHA384:TLS13-AES-128-GCM-SHA256:EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH';
    ssl_ciphers 'TLS-CHACHA20-POLY1305-SHA256:TLS-AES-256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384';
    ssl_ecdh_curve X448:secp521r1:secp384r1:prime256v1;
    ssl_stapling on;
    ssl_stapling_verify on;

Nginx - proxy_params

Créer le fichier proxy_params

nano /etc/nginx/proxy_params

Coller les lignes suivantes

proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-Host $host;
proxy_set_header X-Forwarded-Protocol $scheme;
proxy_set_header X-Forwarded-For $remote_addr;
proxy_set_header X-Forwarded-Port $server_port;
proxy_set_header X-Forwarded-Server $host;
proxy_connect_timeout 3600;
proxy_send_timeout 3600;
proxy_read_timeout 3600;
proxy_redirect off;

Nginx - header_params

Créer le fichier header_params

 nano /etc/nginx/header_params 

Coller les lignes suivantes

add_header Strict-Transport-Security "max-age=15768000; includeSubDomains; preload;";
add_header X-Robots-Tag none;
add_header X-Download-Options noopen;
add_header X-Permitted-Cross-Domain-Policies none;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header Referrer-Policy "no-referrer" always;
#add_header Feature-Policy "accelerometer 'none'; autoplay 'self'; geolocation 'none'; midi 'none'; sync-xhr 'self' ; microphone 'self'; camera 'self'; magnetometer 'none'; gyroscope 'none'; speaker 'self'; fullscreen 'self'; payment 'none'; usb 'none'";
add_header X-Frame-Options "SAMEORIGIN";

Nginx - optimization_params

Créer optimization_params

nano /etc/nginx/optimization_params 

Coller les lignes suivantes

fastcgi_hide_header X-Powered-By;
fastcgi_read_timeout 3600;
fastcgi_send_timeout 3600;
fastcgi_connect_timeout 3600;
fastcgi_buffers 64 64K;
fastcgi_buffer_size 256k;
fastcgi_busy_buffers_size 3840K;
fastcgi_cache_key $http_cookie$request_method$host$request_uri;
fastcgi_cache_use_stale error timeout invalid_header http_500;
fastcgi_ignore_headers Cache-Control Expires Set-Cookie;
gzip on;
gzip_vary on;
gzip_comp_level 4;
gzip_min_length 256;
gzip_proxied expired no-cache no-store private no_last_modified no_etag auth;
gzip_types application/atom+xml application/javascript application/json application/ld+json application/manifest+json application/rss+xml application/vnd.geo+json application/vnd.ms-fontobject application/x-font-ttf application/x-web-app-manifest+json application/xhtml+xml application/xml font/opentype image/bmp image/svg+xml image/x-icon text/cache-manifest text/css text/plain text/vcard text/vnd.rim.location.xloc text/vtt text/x-component text/x-cross-domain-policy;
gzip_disable "MSIE [1-6]\.";

Nginx - php_optimization_params

Créez le php_optimization_params

nano /etc/nginx/php_optimization_params 

Coller les lignes suivantes

fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_param modHeadersAvailable true;
fastcgi_param front_controller_active true;
fastcgi_intercept_errors on;
fastcgi_request_buffering off;
fastcgi_cache_valid 404 1m;
fastcgi_cache_valid any 1h;
fastcgi_cache_methods GET HEAD;

Améliorer la sécurité

openssl dhparam -out /etc/ssl/private/dh2048.pem 2048

S’il vous plaît soyez patient, cela prendra un certain temps en fonction de votre matériel.

Nginx - nc.xoyize.xyz.conf

Créez les fichiers de configuration /etc/nginx/conf.d/nc.xoyize.xyz.conf

nano /etc/nginx/conf.d/nc.xoyize.xyz.conf

ATTENTION remplacer nc.xoyize.xyz par votre domaine
Collez les lignes suivantes:

server {
	server_name nc.xoyize.xyz;
	listen 80 default_server;
	listen [::]:80 default_server;
	# Let's encrypt par http
	# location ^~ /.well-known/acme-challenge {
	#	proxy_pass http://127.0.0.1:81;
	#	proxy_set_header Host $host;
	# }
	location / {
	 return 301 https://$host$request_uri;
	}
}
server {
	server_name nc.xoyize.xyz;
	listen 443 ssl http2 default_server;
	listen [::]:443 ssl http2 default_server;

    include ssl_dh_headers_ocsp;
	add_header X-Robots-Tag none;
	add_header Referrer-Policy no-referrer;

	root /var/www/nextcloud/;
		location = /robots.txt {
			allow all;
			log_not_found off;
			access_log off;
		}
		location = /.well-known/carddav {
			return 301 $scheme://$host/remote.php/dav;
		}
		location = /.well-known/caldav {
			return 301 $scheme://$host/remote.php/dav;
		}
	#SOCIAL app enabled? Please uncomment the following row
	#rewrite ^/.well-known/webfinger /public.php?service=webfinger last;
	#WEBFINGER app enabled? Please uncomment the following two rows.
	#rewrite ^/.well-known/host-meta /public.php?service=host-meta last;
	#rewrite ^/.well-known/host-meta.json /public.php?service=host-meta-json last;
	client_max_body_size 10240M;
		location / {
			rewrite ^ /index.php$request_uri;
		}
		location ~ ^/(?:build|tests|config|lib|3rdparty|templates|data)/ {
			deny all;
		}
		location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) {
			deny all;
		}
		location ^~ /apps/rainloop/app/data {
			deny all;
		}
		location ~ \.(?:flv|mp4|mov|m4a)$ {
			mp4;
			mp4_buffer_size 100M;
			mp4_max_buffer_size 1024M;
			fastcgi_split_path_info ^(.+?.php)(\/.*|)$;
			include fastcgi_params;
			include php_optimization_params;
			fastcgi_pass php-handler;
			fastcgi_param HTTPS on;
		}
		location ~ ^\/(?:index|remote|public|cron|core\/ajax\/update|status|ocs\/v[12]|updater\/.+|oc[ms]-provider\/.+).php(?:$|\/) {
			fastcgi_split_path_info ^(.+?.php)(\/.*|)$;
			include fastcgi_params;
			include php_optimization_params;
			fastcgi_pass php-handler;
			fastcgi_param HTTPS on;
		}
		location ~ ^\/(?:updater|oc[ms]-provider)(?:$|\/) {
			try_files $uri/ =404;
			index index.php;
		}
		location ~ .(?:css|js|woff2?|svg|gif|map|png|html|ttf|ico|jpg|jpeg)$ {
			try_files $uri /index.php$request_uri;
			access_log off;
			expires 360d;
		}
}

Redémarrez NGINX

service nginx restart 

Créer des dossiers et appliquer des autorisations

mkdir -p /var/nc_data /var/www/letsencrypt
chown -R www-data:www-data /var/nc_data /var/www

Nextcloud - installation

cd /usr/local/src
wget https://download.nextcloud.com/server/releases/latest.tar.bz2
tar -xjf latest.tar.bz2 -C /var/www && chown -R www-data:www-data /var/www/ && rm -f latest.tar.bz2

Infos Nextcloud

  • –database-name “nextcloud”: comme défini ci-dessus lors de la création de la base de données
  • –database-user “nextcloud”: comme défini ci-dessus lors de la création de l’utilisateur de la base de données
  • –database-pass “xxxxxxxxx”: comme défini ci-dessus lors de la création du mot de passe nextcloud
  • –admin-pass “Mot_de_passe_ncadmin” : à définir

Installez Nextcloud en mode silencieux

su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ maintenance:install --database "mysql" --database-name "nextcloud" --database-user "nextcloud" --database-pass "nextcloud" --admin-user "ncadmin" --admin-pass "Mot_de_passe_ncadmin" --data-dir "/var/nc_data"'

Configuration domaine

su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ config:system:set trusted_domains 0 --value=nc.xoyize.xyz'
su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ config:system:set overwrite.cli.url --value=https://nc.xoyize.xyz'
cp /var/www/nextcloud/config/config.php /var/www/nextcloud/config/config.php.bak

Développez votre fichier Nextcloud config.php:

sed -i 's/^[ ]*//' /var/www/nextcloud/config/config.php
sed -i '/);/d' /var/www/nextcloud/config/config.php

cat <<EOF >>/var/www/nextcloud/config/config.php
'activity_expire_days' => 14,
'auth.bruteforce.protection.enabled' => true,
'blacklisted_files' => 
array (
0 => '.htaccess',
1 => 'Thumbs.db',
2 => 'thumbs.db',
),
'cron_log' => true,
'enable_previews' => true,
'enabledPreviewProviders' => 
array (
0 => 'OC\\Preview\\PNG',
1 => 'OC\\Preview\\JPEG',
2 => 'OC\\Preview\\GIF',
3 => 'OC\\Preview\\BMP',
4 => 'OC\\Preview\\XBitmap',
5 => 'OC\\Preview\\Movie',
6 => 'OC\\Preview\\PDF',
7 => 'OC\\Preview\\MP3',
8 => 'OC\\Preview\\TXT',
9 => 'OC\\Preview\\MarkDown',
),
'filesystem_check_changes' => 0,
'filelocking.enabled' => 'true',
'htaccess.RewriteBase' => '/',
'integrity.check.disabled' => false,
'knowledgebaseenabled' => false,
'logfile' => '/var/nc_data/nextcloud.log',
'loglevel' => 2,
'logtimezone' => 'Europe/Paris',
'log_rotate_size' => 104857600,
'maintenance' => false,
'memcache.local' => '\\OC\\Memcache\\APCu',
'memcache.locking' => '\\OC\\Memcache\\Redis',
'overwriteprotocol' => 'https',
'preview_max_x' => 1024,
'preview_max_y' => 768,
'preview_max_scale_factor' => 1,
'redis' => 
array (
'host' => '/var/run/redis/redis-server.sock',
'port' => 0,
'timeout' => 0.0,
),
'quota_include_external_storage' => false,
'share_folder' => '/Shares',
'skeletondirectory' => '',
'theme' => '',
'trashbin_retention_obligation' => 'auto, 7',
'updater.release.channel' => 'stable',
);
EOF

Nextcloud - /var/www/nextcloud/.user.ini

sudo -u www-data sed -i "s/output_buffering=.*/output_buffering='Off'/" /var/www/nextcloud/.user.ini
service php7.3-fpm restart && service redis-server restart && service nginx restart

Nextcloud - Ajuster les applications

su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ app:disable survey_client'
su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ app:disable firstrunwizard'
su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ app:enable admin_audit'
su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ app:enable files_pdfviewer'

Nextcloud - Optimisation avec deux scripts shell

1-mettre à jour votre environnement périodiquement

nano /root/upgrade.sh
# Debian 9.x 10.x
#!/bin/bash
/usr/sbin/service nginx stop
su - www-data -s /bin/bash -c 'php /var/www/nextcloud/updater/updater.phar'
su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ status'
su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ -V'
su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ db:add-missing-indices'
su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ db:convert-filecache-bigint'
sed -i "s/output_buffering=.*/output_buffering='Off'/" /var/www/nextcloud/.user.ini
chown -R www-data:www-data /var/www/nextcloud
su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ app:update --all'
/usr/sbin/service php7.3-fpm restart
/usr/sbin/service nginx restart
exit 0

(infos: BigInt , indices manquants )

2-optimisez périodiquement votre Nextcloud

nano /root/optimize.sh
####
# Optimize your Nextcloud instance
# create a daily cronjob, e.g.:
# crontab -e
# 5 1 * * *  /usr/local/src/install-nextcloud/optimize.sh 2>&1
####
#!/bin/bash
redis-cli -s /var/run/redis/redis.sock <<EOF
FLUSHALL
quit
EOF
su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ files:scan --all'
su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ files:scan-app-data'
exit 0

Sauvegarder les deux scripts et les marquer comme exécutables

chmod +x /root/*.sh 

Exécuter les deux scripts

/root/upgrade.sh && /root/optimize.sh
Nextcloud Updater - version: v16.0.3-3-ga0c2b25 dirty

Current version is 17.0.0.

No update available.

Nothing to do.
  - installed: true
  - version: 17.0.0.9
  - versionstring: 17.0.0
  - edition: 
Nextcloud 17.0.0
Check indices of the share table.
Check indices of the filecache table.
Check indices of the twofactor_providers table.
Check indices of the login_flow_v2 table.
Check indices of the whats_new table.
Check indices of the cards table.
Check indices of the cards_properties table.
Done.
All tables already up to date!
files_rightclick new version available: 0.15.1
files_rightclick updated
Could not connect to Redis at /var/run/redis/redis.sock: No such file or directory
Could not connect to Redis at /var/run/redis/redis.sock: No such file or directory
Starting scan for user 1 out of 1 (ncadmin)
+---------+-------+--------------+
| Folders | Files | Elapsed time |
+---------+-------+--------------+
| 4       | 10    | 00:00:00     |
+---------+-------+--------------+

Scanning AppData for files

+---------+-------+--------------+
| Folders | Files | Elapsed time |
+---------+-------+--------------+
| 2       | 1     | 00:00:00     |
+---------+-------+--------------+

Ajouter des tâches cron pour Nextcloud pour www-data et root

Pour www-data :

crontab -u www-data -e

Coller les lignes suivantes

*/5 * * * * php -f /var/www/nextcloud/cron.php > /dev/null 2>&1

Pour root :

crontab -e 

Collez les lignes suivantes:

5 1 * * * /root/optimize.sh 2>&1

Nextcloud - Bascule pour utiliser cron.php

su - www-data -s /bin/bash -c 'php /var/www/nextcloud/occ background:cron'

Set mode for background jobs to ‘cron’

Redémarrer tous les services

service mysql restart && service php7.3-fpm restart && service redis-server restart && service nginx restart

Nextcloud - Connexion nc.xoyize.xyz

Connexion en administrateur et vérification sécurité

Avertissements de sécurité & configuration

Il est important pour la sécurité et la performance de votre instance que celle-ci soit correctement configurée. Afin de vous aider, votre instance Nextcloud effectue des vérifications automatiques. Pour de plus amples informations, veuillez consulter la documentation liée.
Tous les tests ont réussi. 

Nextcloud - Installation et configuration fail2ban

Fail2Ban, en deux mots, c’est un petit utilitaire qui permet de configurer le parefeu iptables de Linux à la volée.

apt update && apt install fail2ban -y

Collez les lignes suivantes dans le filtre fail2ban pour Nextcloud

nano /etc/fail2ban/filter.d/nextcloud.conf 
[Definition]
failregex=^{"reqId":".*","remoteAddr":".*","app":"core","message":"Login failed: '.*' \(Remote IP: '<HOST>'\)","level":2,"time":".*"}$
            ^{"reqId":".*","level":2,"time":".*","remoteAddr":".*","app":"core".*","message":"Login failed: '.*' \(Remote IP: '<HOST>'\)".*}$
            ^.*\"remoteAddr\":\"<HOST>\".*Trusted domain error.*$

Collez les lignes suivantes dans la prison fail2ban pour Nextcloud:

nano /etc/fail2ban/jail.d/nextcloud.local
[nextcloud]
backend = auto
enabled = true
port = 80,443
protocol = tcp
filter = nextcloud
maxretry = 3
bantime = 36000
findtime = 36000
logpath = /var/nc_data/nextcloud.log

[nginx-http-auth]
enabled = true

Redémarrez le service fail2ban

service fail2ban restart
fail2ban-client status nextcloud
Status for the jail: nextcloud
|- Filter
|  |- Currently failed:	0
|  |- Total failed:	0
|  `- File list:	/var/nc_data/nextcloud.log
`- Actions
   |- Currently banned:	0
   |- Total banned:	0
   `- Banned IP list:	

Nextcloud - Application de stockage externe

Vous pouvez activer l’ application de stockage externe et bénéficier de nombreux avantages:

  • les fichiers peuvent être créés, édités et supprimés des deux côtés: à l’intérieur et à l’extérieur de Nextcloud
  • vous êtes autorisé à monter des services et des périphériques de stockage externes en tant que périphériques de stockage Nextcloud secondaires
  • les utilisateurs sont autorisés à monter leurs propres services de stockage externe

external-storage-nextcloud.png

Si vous souhaitez utiliser Samba, émettez la déclaration suivante

apt install php-smbclient smbclient -y

et redémarrez PHP

service php7.3-fpm restart 

Nextcloud - music

Activer l’application music
Chemin vers votre collection de musique: /drv/data/Musique

API Ampache
https://nc.xoyize.xyz/apps/music/ampache
Utilisez cette adresse pour naviguer dans votre collection musicale avec un client compatible Ampache. If this URL doesn’t work try to append ‘/server/xml.server.php’.
Mots de passe à utiliser avec l’API Ampache, parce qu’ils ne peuvent être stockés d’une manière sécurisée en raison de la conception de l’API d’Ampache.
Vous pouvez générer autant de mots de passe que vous voulez et vous pouvez les révoquer à tout instant.

Use the following credentials to connect to this Ampache instance.

Username: 967dd43e-7656-1039-8d83-79754dcb5ca2 Password: glq89ocahqyc

Streamer sa musique librement

Nextcloud - LDAP

Connexion sur nextcloud en administrateur
Activer l’application “Intégration LDAP/AD”
Ouvrir “paramètres”
nc
nc
nc
nc
nc

Nextcloud - Netdata (Surveillance système)

Démarrer le téléchargement netdata - le répertoire ‘netdata’ sera créé

apt install apache2-utils git gcc make autoconf automake pkg-config uuid-dev zlib1g-dev
cd /usr/local/src
git clone https://github.com/firehol/netdata.git --depth=1
cd netdata

Créez un fichier de mot de passe pour protéger netdata:

htpasswd -c /etc/nginx/netdata-access YanNetData

Exécuter le script netdata-installer.sh avec les privilèges root pour créer, installer et démarrer netdata.

./netdata-installer.sh

  ^
  |.-.   .-.   .-.   .-.   .-.   .  netdata                          .-.   .-
  |   '-'   '-'   '-'   '-'   '-'   is installed and running now!  -'   '-'  
  +----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+--->

  enjoy real-time performance and health monitoring...

Ajustements à la configuration de netdata:

nano /etc/netdata/netdata.conf 

Modifier la valeur pour «historique», par exemple, 14400 (4 heures de conservation des données de graphique, utilise environ 60 Mo de RAM) dans la section [global]:

history = 14400

Modifier la liaison dans la section [web] en localhost (127.0.0.1) uniquement:

bind to = 127.0.0.1

Enfin, nous améliorons les fichiers /etc/nginx/conf.d/nc.xoyize.xyz.conf et nginx.conf pour inclure la configuration du serveur Web Netdata:

nano /etc/nginx/conf.d/nextcloud.conf  # ATTENTION ce fichier peut être inclus dans /etc/nginx/nginx.conf

Collez les lignes comme indiqué ci-dessous dans le fichier /etc/nginx/conf.d/nc.xoyize.xyz.conf:

[...]
    location / {
        rewrite ^ /index.php$request_uri;
    }
    ### début insertion netdata
    location /netdata {
        return 301 /netdata/;
    }
    location ~ /netdata/(?<ndpath>.*) {
     auth_basic "Restricted Area";
     auth_basic_user_file /etc/nginx/netdata-access;
     proxy_http_version 1.1;
     proxy_pass_request_headers on;
     proxy_set_header Connection "keep-alive";
     proxy_store off;
     proxy_pass http://netdata/$ndpath$is_args$args;
     gzip on;
     gzip_proxied any;
     gzip_types *;
    }
    ### fin insertion netdata
 location ~ ^/(?:build|tests|config|lib|3rdparty|templates|data)/ {
 deny all;
[...]

Créez le nouveau fichier /etc/nginx/conf.d/stub_status.conf:

nano /etc/nginx/conf.d/stub_status.conf 

Collez toutes les lignes suivantes:

server {
  listen 127.0.0.1:80 default_server;
  server_name 127.0.0.1;
  location /stub_status {
   stub_status on;
   allow 127.0.0.1;
   deny all;
  }
}

Modifier le fichier /etc/nginx/nginx.conf:


Enregistrer et vérifier NGINX

nginx -t

Si aucune erreur n’apparaît, redémarrez netdata et nginx

service netdata restart && service nginx restart

et appelez netdata dans votre navigateur https://nc.xoyize.xyz/netdata
ou en tant que site externe dans votre Nextcloud.

Nextcloud - nginx (configuration finale)

# /etc/nginx/conf.d/nc.xoyize.xyz.conf
	## 
	# netdata
	##
	  upstream netdata {
	   server 127.0.0.1:19999;
	   keepalive 64;
	 }
	##
	# Virtual Host nc.xoyize.xyz (Nextcloud)
	##

	server {
		listen 80;
		listen [::]:80;
		# Let's encrypt par http
		# location ^~ /.well-known/acme-challenge {
		#	proxy_pass http://127.0.0.1:81;
		#	proxy_set_header Host $host;
		# }
		server_name nc.xoyize.xyz;
		location / {
		 return 301 https://$host$request_uri;
		}
	}
	server {
		listen 443 ssl http2;
		listen [::]:443 ssl http2;
		server_name nc.xoyize.xyz;
	
	        include ssl_dh_headers_ocsp;
		add_header X-Robots-Tag none;
		add_header Referrer-Policy no-referrer;
	
		root /var/www/nextcloud/;
			location = /robots.txt {
				allow all;
				log_not_found off;
				access_log off;
			}
			location = /.well-known/carddav {
				return 301 $scheme://$host/remote.php/dav;
			}
			location = /.well-known/caldav {
				return 301 $scheme://$host/remote.php/dav;
			}
		#SOCIAL app enabled? Please uncomment the following row
		#rewrite ^/.well-known/webfinger /public.php?service=webfinger last;
		#WEBFINGER app enabled? Please uncomment the following two rows.
		#rewrite ^/.well-known/host-meta /public.php?service=host-meta last;
		#rewrite ^/.well-known/host-meta.json /public.php?service=host-meta-json last;
		client_max_body_size 10240M;
			location / {
				rewrite ^ /index.php$request_uri;
			}
		    ### début insertion netdata
		    location /netdata {
		        return 301 /netdata/;
		    }
		    location ~ /netdata/(?<ndpath>.*) {
		     auth_basic "Restricted Area";
		     auth_basic_user_file /etc/nginx/netdata-access;
		     proxy_http_version 1.1;
		     proxy_pass_request_headers on;
		     proxy_set_header Connection "keep-alive";
		     proxy_store off;
		     proxy_pass http://netdata/$ndpath$is_args$args;
		     gzip on;
		     gzip_proxied any;
		     gzip_types *;
		    }
		    ### fin insertion netdata
			location ~ ^/(?:build|tests|config|lib|3rdparty|templates|data)/ {
				deny all;
			}
			location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) {
				deny all;
			}
			location ^~ /apps/rainloop/app/data {
				deny all;
			}
			location ~ \.(?:flv|mp4|mov|m4a)$ {
				mp4;
				mp4_buffer_size 100M;
				mp4_max_buffer_size 1024M;
				fastcgi_split_path_info ^(.+?.php)(\/.*|)$;
				include fastcgi_params;
				include php_optimization_params;
				fastcgi_pass php-handler;
				fastcgi_param HTTPS on;
			}
			location ~ ^\/(?:index|remote|public|cron|core\/ajax\/update|status|ocs\/v[12]|updater\/.+|oc[ms]-provider\/.+).php(?:$|\/) {
				fastcgi_split_path_info ^(.+?.php)(\/.*|)$;
				include fastcgi_params;
				include php_optimization_params;
				fastcgi_pass php-handler;
				fastcgi_param HTTPS on;
			}
			location ~ ^\/(?:updater|oc[ms]-provider)(?:$|\/) {
				try_files $uri/ =404;
				index index.php;
			}
			location ~ .(?:css|js|woff2?|svg|gif|map|png|html|ttf|ico|jpg|jpeg)$ {
				try_files $uri /index.php$request_uri;
				access_log off;
				expires 360d;
			}
	}

Serveurs de streaming Audio

Sonerezh - audio.xoyize.xyz

https://mondedie.fr/d/6471-tuto-installer-sonerezh

Nous devons créer l’utilisateur pour la BDD, ainsi que la BDD.

mysql -uroot -p$(cat /etc/mysql/mdp) -e "CREATE DATABASE sonerezh; GRANT ALL PRIVILEGES ON sonerezh.* TO 'sonerezh'@'localhost' IDENTIFIED BY 'password'; FLUSH PRIVILEGES; quit;"

Remplacer password par le mot de passe souhaité !

sudo -s # on passe en mode su

Une fois ceci fait, nous pouvons passer à l’installation de Sonerezh en lui même.
Rendons nous dans notre répertoire racine du serveur web:

cd /var/www

Pour obtenir Sonerezh (Nous utilisons ici la branche master ainsi d’éviter tous les bugs)

git clone --branch master https://github.com/Sonerezh/sonerezh.git

Afin, on attribue les bons droits:

chown -R www-data: sonerezh

Il faut désormais faire le serveur-block pour nginx /etc/nginx/conf.d/audio.xoyize.xyz.conf

nano /etc/nginx/conf.d/audio.xoyize.xyz.conf
# /etc/nginx/conf.d/audio.xoyize.xyz.conf	
	##
	# Virtual Host audio.xoyize.xyz (Sonerezh)
	##

	server {
	    listen 80;
	    listen [::]:80;
	
	    ## redirect http to https ##
	    server_name audio.xoyize.xyz;
	    return  301 https://$server_name$request_uri;
	}
	
	server {
	    listen 443 ssl http2;
	    listen [::]:443 ssl http2;
	    server_name audio.xoyize.xyz;
	
	    include ssl_dh_headers_ocsp;
	
	    root        /var/www/sonerezh/app/webroot;
	    index index.php;
	
	location / {
	    try_files $uri $uri/ /index.php?$args;
	}
	
	       location ~ \.php$ {
	           fastcgi_split_path_info ^(.+\.php)(/.+)$;
	           fastcgi_pass unix:/run/php/php7.3-fpm.sock;   # PHP7.3
	           fastcgi_index index.php;
	           include fastcgi_params;
		   fastcgi_param SCRIPT_FILENAME $request_filename;
	        }
	
	
	    access_log /var/log/nginx/sonerezh-access.log;
	    error_log /var/log/nginx/sonerezh-error.log;
	}

Vérifier et relancer nginx

sudo nginx -t 
sudo systemctl restart nginx

Lien https://audio.xoyize.xyz

Configuration

Texte alternatif

Erreurs

Notice (8): Undefined index: id [APP/Model/User.php, line 152]

Warning (2): Cannot modify header information - headers already sent by (output started at /var/www/sonerezh/app/Vendor/cakephp/cakephp/lib/Cake/Utility/Debugger.php:797) [APP/Vendor/cakephp/cakephp/lib/Cake/Network/CakeResponse.php, line 458]

https://www.sonerezh.bzh/user-guides/cli-tool.html

Importer dans la base en ligne de commande

sudo -s
cd /var/www/sonerezh/app/
Console/cake sonerezh import -r /srv/data/Musique

Subsonic - sub.xoyize.xyz

openjdk 8 - Alternative 1 Installer la version java openjdk 8
Ajouter deb http://ftp.us.debian.org/debian sid main au fichier /etc/apt/sources.list

sudo apt update
sudo apt install openjdk-8-jdk

RETIRER la ligne deb http://ftp.us.debian.org/debian sid main du fichier /etc/apt/sources.list

sudo apt update

Vérifier la version

java -version
openjdk version "1.8.0_232-ea"
OpenJDK Runtime Environment (build 1.8.0_232-ea-8u232-b07-2-b07)
OpenJDK 64-Bit Server VM (build 25.232-b07, mixed mode)

openjdk 8 - Alternative 2 (A privilégier)
Installer la version java openjdk 8

sudo -s
cd /usr/local
wget https://github.com/AdoptOpenJDK/openjdk8-binaries/releases/download/jdk8u222-b10/OpenJDK8U-jre_x64_linux_hotspot_8u222b10.tar.gz
tar -xvf OpenJDK8U-jre_x64_linux_hotspot_8u222b10.tar.gz
#export PATH=$PWD/jdk8u222-b10-jre/bin:$PATH

Vérifier la version java

/usr/local/jdk8u222-b10-jre/bin/java -version
openjdk version "1.8.0_222"
OpenJDK Runtime Environment (AdoptOpenJDK)(build 1.8.0_222-b10)
OpenJDK 64-Bit Server VM (AdoptOpenJDK)(build 25.222-b10, mixed mode)

Subsonic - installation (.deb)

wget https://s3-eu-west-1.amazonaws.com/subsonic-public/download/subsonic-6.1.5.deb
sudo dpkg -i subsonic-6.1.5.deb # installer subsonic
sudo useradd subsonic  # ajout utilisateur subsonic

Modifier la configuration

sudo nano  /etc/default/subsonic
SUBSONIC_ARGS="--max-memory=300"
SUBSONIC_USER=subsonic

Modifier le bash de lancement /usr/share/subsonic/subsonic.sh
Ajouter JAVA_HOME=/usr/local/jdk8u222-b10-jre en début de fichier

###################################################################################
# Shell script for starting Subsonic.  See http://subsonic.org.
#
# Author: Sindre Mehus
###################################################################################

# Note: default to environment variables, if set.

JAVA_HOME=/usr/local/jdk8u222-b10-jre
SUBSONIC_HOME=${SUBSONIC_HOME:-/var/subsonic}
SUBSONIC_HOST=${SUBSONIC_HOST:-0.0.0.0}
SUBSONIC_PORT=${SUBSONIC_PORT:-4040}
SUBSONIC_HTTPS_PORT=${SUBSONIC_HTTPS_PORT:-0}
SUBSONIC_CONTEXT_PATH=${SUBSONIC_CONTEXT_PATH:-/}
SUBSONIC_DB=${SUBSONIC_DB}
SUBSONIC_MAX_MEMORY=${SUBSONIC_MAX_MEMORY:-150}
SUBSONIC_PIDFILE=${SUBSONIC_PIDFILE}
SUBSONIC_DEFAULT_MUSIC_FOLDER=${SUBSONIC_DEFAULT_MUSIC_FOLDER:-/var/music}
SUBSONIC_DEFAULT_PODCAST_FOLDER=${SUBSONIC_DEFAULT_PODCAST_FOLDER:-/var/music/Podcast}
SUBSONIC_DEFAULT_PLAYLIST_FOLDER=${SUBSONIC_DEFAULT_PLAYLIST_FOLDER:-/var/playlists}

Redémarrer subsonic

sudo systemctl restart subsonic

Fichier de configuration nginx /etc/nginx/conf.d/sub.xoyize.xyz.conf

sudo nano /etc/nginx/conf.d/sub.xoyize.xyz.conf
# /etc/nginx/conf.d/sub.xoyize.xyz.conf	
	##
	# Virtual Host sub.xoyize.xyz (Subsonic)
	##

	server {
	    listen 80;
	    listen [::]:80;
	
	    ## redirect http to https ##
	    server_name sub.xoyize.xyz;
	    return  301 https://$server_name$request_uri;
	}
	
	server {
	    listen 443 ssl http2;
	    listen [::]:443 ssl http2;
	    server_name sub.xoyize.xyz;
	
	    include ssl_dh_headers_ocsp;
	
	    location / {
		proxy_pass http://192.168.0.45:4040;
	    }
	
	}

Redémarrer nginx , sudo systemctl restart nginx
Accès https://sub.xoyize.xyz ,admin/admin

  • Changer le mot de passe administrateur
  • Définir le répertoire media : /srv/data/Musique
  • Changer le thème (facultatif)
  • Valider l’option accès au dossier media par admin
  • Scanner le dossier media

Autoriser l’authentification LDAP
Paramètres → Avancé

API Subsonic
A partir de la version 1.13.0 de l’API, le schéma d’authentification recommandé est d’envoyer un jeton d’authentification, calculé comme un hachage à sens unique du mot de passe.

Cela se fait en deux étapes :

  1. Pour chaque appel REST, générez une chaîne aléatoire appelée sel. Envoyer ceci comme paramètre s.
    Utilisez une longueur de salt (sel) d’au moins six caractères.
    • Calculez le jeton d’authentification comme suit : token = md5(mot de passe + sel)
      La fonction md5() prend une chaîne de caractères et retourne la représentation hexadécimale ASCII de 32 octets du hachage MD5, en utilisant des caractères minuscules pour les valeurs hexadécimales. L’opérateur’+’ représente la concaténation des deux chaînes de caractères. Traiter les chaînes comme encodées en UTF-8 lors du calcul du hachage. Envoyer le résultat comme paramètre t.

Par exemple : si le mot de passe est sesame et le sel aléatoire est c19b2d :
token=$(echo -n sesamec19b2d | md5sum) → 26719a1196d2a940705a59634eb18eab
L’URL de requête correspondante devient alors :
http://your-server/rest/ping.view?u=joe&t=26719a1196d2a940705a59634eb18eab&s=c19b2d&v=1.16.1&c=myapp
Api version 1.16.1 (subsonic 6.1.4)

Générer un “salt” aléatoire de 12 caractères
salt=$(< /dev/urandom tr -dc _A-Z-a-z-0-9 | head -c${1:-12};echo;)

Exemples

mdp=sesame
salt=c19b2d
token=$(echo -n $mdp$salt | md5sum)
echo $token

26719a1196d2a940705a59634eb18eab -

#-------

mdp=sesame
#Générer un "salt" aléatoire de 12 caractères  
salt=$(< /dev/urandom tr -dc _A-Z-a-z-0-9 | head -c${1:-12};echo;)
echo $salt
#  XB6bN69KTQah
token=$(echo -n $mdp$salt | md5sum)
echo $token
# 1f329882f3e0553a2761bbb9d79353ff
# le lien :
# http://your-server/rest/ping.view?u=joe&t=1f329882f3e0553a2761bbb9d79353ff&s=XB6bN69KTQah&v=1.16.1&c=myapp

# curl
curl -d "u=joe&t=1f329882f3e0553a2761bbb9d79353ff&s=XB6bN69KTQah&v=1.16.1&c=myapp" -X POST http://your-server/rest/ping.view

PhpMyadmin - sql.xoyize.xyz

phpMyAdmin (PMA) est une application Web de gestion pour les systèmes de gestion de base de données MySQL réalisée principalement en PHP et distribuée sous licence GNU GPL.Wikipedia

Fichier de configuration nginx /etc/nginx/conf.d/sql.xoyize.xyz.conf

# /etc/nginx/conf.d/sql.xoyize.xyz.conf	

# limiter à certains utilisateurs
map $ssl_client_s_dn $ssl_access {
    default 0;
    "~CN=Yann" 1;
    "~CN=Jean Dupondt Stagiaire" 1; 
    # etc.
}

	##
	# Virtual Host sql.xoyize.xyz (PhpMyAdmin)
	##

	server {
	    listen 80;
	    listen [::]:80;
	
	    ## redirect http to https ##
	    server_name sql.xoyize.xyz;
	    return  301 https://$server_name$request_uri;
	}
	
	server {
	    listen 443 ssl http2;
	    listen [::]:443 ssl http2;
	    server_name sql.xoyize.xyz;
	
	    include ssl_dh_headers_ocsp;
	
	    root /var/www/default-www/rienavoir;
	    index index.php;

       include auth_certificat_client;
       # Test variable $ssl_access
       if ( $ssl_access = 0 ) {
           return 403; # => forbidden
       }
	
	        location ~ \.php$ {
	           fastcgi_split_path_info ^(.+\.php)(/.+)$;
	           fastcgi_pass unix:/run/php/php7.3-fpm.sock;   # PHP7.3
	           fastcgi_index index.php;
	           include fastcgi_params;
	    	   fastcgi_param SCRIPT_FILENAME $request_filename;
	        }
	
	
	    access_log /var/log/nginx/sql-access.log;
	    error_log /var/log/nginx/sql-error.log;
	}

Accès par https://sql.xoyize.xyz
Refuser l’accès par https://xoyize.xyz/phpmyadmin

sudo nano /etc/nginx/conf.d/xoyize.xyz.d/phpmyadmin.conf
location /phpmyadmin {
  return 403; # => forbidden
}

msmtp - mail serveur

Première installation msmtp

sudo -s 
apt update && apt upgrade -y && apt install msmtp msmtp-mta mailutils -y

Créez votre configuration: créez le fichier, puis collez et modifiez les lignes suivantes:

nano /etc/msmtprc
defaults
port 587
tls on
tls_starttls on
tls_trust_file /etc/ssl/certs/ca-certificates.crt
#Your Mail:
account yannick@cinay.xyz
#Your SMTP-Server:
host cinay.xyz
#Mails will be sent from:
from div@xoyize.xyz
auth on 
#Your Mailaccount:
user yannick@cinay.xyz
#Your Password:
passwordeval cat /etc/.msmtp
#Default Mailaccount:
account default: yannick@cinay.xyz
aliases /etc/aliases
# find out more about the configuration here: https://marlam.de/msmtp/msmtprc.txt
logfile /var/log/msmtp.log

Définir la permission appropriée

chmod 600 /etc/msmtprc

et testez votre configuration de serveur de courrier en émettant

echo "Sending test mail..." | mail -s "Subject" -r yannick@cinay.xyz yanfi.net
echo -e "Subject: Test Mail\r\n\r\nThis is a test mail" | msmtp --debug --from=yannick@cinay.xyz -t yannick@yanfi.net --file=/etc/msmtprc

ATTENTION il faut préciser qui est le serveur smtp avec l’option r , ici yannick@cinay.xyz

Modifier PHP pour utiliser msmtp dans PHP

nano /etc/php/7.3/fpm/php.ini

Définissez le sendmail_path comme suit

sendmail_path = "/usr/bin/msmtp -C /etc/msmtprc -f yannick@cinay.xyz -t"

et redémarrez php

service php7.3-fpm restart 

Définissez enfin vos alias de messagerie: ouvrez le fichier

nano /etc/aliases

coller et modifier les lignes suivantes:

root: yannick@cinay.xyz
default: yannick@cinay.xyz

A partir de maintenant votre système est préparé pour envoyer des mails.

Test

echo '<?php mail("yannick@yanfi.net","PHP Test mail", "Ceci est un test...", "From:yannick@cinay.xyz") ?>' > test.php
php test.php

Problème msmtp avec apparmor How to disable a particular AppArmor profile on Ubuntu
sudo apparmor_parser -R /etc/apparmor.d/usr.bin.msmtp → temporaire
sudo ln -s /etc/apparmor.d/usr.bin.msmtp /etc/apparmor.d/disable/
sudo service apparmor restart

Modifiez logrotate pour gérer correctement les logs msmtp
Créer et éditer le fichier

nano /etc/logrotate.d/msmtp

et collez toutes les lignes suivantes:

/var/log/msmtp/*.log {
rotate 12
monthly
compress
missingok
notifempty
}

(a) configurer les mails de notification du système fail2ban (NON UTILISE)

Nous substituons l’utilisateur root dans fail2ban-config pour recevoir les mails d’état de fail2ban à l’avenir. Ces e-mails contiendront à la fois le statut fail2ban (arrêté / démarré) et, en cas d’échec de la connexion, l’adresse IP bannie. Editez le fichier de configuration fail2ban

cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.conf.bak
nano /etc/fail2ban/jail.conf

et remplacez au moins les paramètres yannick@cinay.xyz, mail, action = %(action_mwl)s en fonction de votre système:

...
destemail = yannick@cinay.xyz
...
sender = yannick@cinay.xyz
...
mta = mail
...
# action = %(action_)s
action = %(action_mwl)s
...

Enregistrez et quittez (: wq!) La configuration fail2ban. Pour éviter (plusieurs) mails sur chaque redémarrage fail2ban, créez simplement un nouveau fichier et copiez-le comme indiqué ci-dessous:

nano /etc/fail2ban/action.d/mail-buffered.local

Coller les lignes suivantes

[Definition]
actionstart =
actionstop =

Copier le fichier

cp /etc/fail2ban/action.d/mail-buffered.local /etc/fail2ban/action.d/mail.local
cp /etc/fail2ban/action.d/mail-buffered.local /etc/fail2ban/action.d/mail-whois-lines.local
cp /etc/fail2ban/action.d/mail-buffered.local /etc/fail2ban/action.d/mail-whois.local
cp /etc/fail2ban/action.d/mail-buffered.local /etc/fail2ban/action.d/sendmail-buffered.local
cp /etc/fail2ban/action.d/mail-buffered.local /etc/fail2ban/action.d/sendmail-common.local

Redémarrez le service fail2ban et vous serez (seulement) informé si Fail2ban a bloqué de nouvelles adresses IP

service fail2ban restart

Récapitulatif configuration

Nginx - configuration

tree -L 3 /etc/nginx
/etc/nginx
├── conf.d
│   ├── audio.xoyize.xyz.conf
│   ├── devel.xoyize.xyz.conf
│   ├── dns.xoyize.xyz.conf
│   ├── lm.xoyize.xyz.conf
│   ├── mail.xoyize.xyz.conf
│   ├── nc.xoyize.xyz.conf
│   ├── spam.xoyize.xyz.conf
│   ├── sql.xoyize.xyz.conf
│   ├── stub_status.conf
│   ├── sub.xoyize.xyz.conf
│   ├── wiki.xoyize.xyz.conf
│   ├── xoyize.xyz.conf
│   └── xoyize.xyz.d
│       ├── eaton.conf
├── fastcgi.conf
├── fastcgi.conf.default
├── fastcgi_params
├── fastcgi_params.default
├── header_params
├── koi-utf
├── koi-win
├── mime.types
├── mime.types.default
├── modules-enabled
│   ├── 50-mod-ngx_http_auth_pam_module.so-upload.conf
│   ├── 50-mod-ngx_http_fancyindex_module.so-upload.conf
│   ├── 50-mod-ngx_http_geoip_module.so-upload.conf
│   ├── 50-mod-ngx_http_headers_more_filter_module.so-upload.conf
│   ├── 50-mod-ngx_http_image_filter_module.so-upload.conf
│   ├── 50-mod-ngx_http_perl_module.so-upload.conf
│   ├── 50-mod-ngx_http_subs_filter_module.so-upload.conf
│   ├── 50-mod-ngx_http_uploadprogress_module.so-upload.conf
│   ├── 50-mod-ngx_http_upstream_fair_module.so-upload.conf
│   ├── 50-mod-ngx_http_xslt_filter_module.so-upload.conf
│   └── 50-mod-ngx_mail_module.so-upload.conf
├── netdata-access
├── nginx.conf
├── nginx.conf.default
├── optimization_params
├── php_optimization_params
├── proxy_params
├── scgi_params
├── scgi_params.default
├── ssl_dh_headers_ocsp
├── ssl_dh_headers_ouestline_params
├── ssl_params
├── uwsgi_params
├── uwsgi_params.default
└── win-utf

configuration globale /etc/nginx/nginx.conf

user www-data;
worker_processes auto;
pid /run/nginx.pid;
include /etc/nginx/modules-enabled/*.conf;

events {
	worker_connections 768;
}

http {
  server_names_hash_bucket_size 64;
		upstream php-handler {
	  		server unix:/run/php/php7.3-fpm.sock;
		}

	
	##
	# Basic Settings
	##

	sendfile on;
	tcp_nopush on;
	tcp_nodelay on;
	keepalive_timeout 65;
	types_hash_max_size 2048;
	# server_tokens off;

	include /etc/nginx/mime.types;
	default_type application/octet-stream;

	##
	# SSL Settings
	##

	#ssl_protocols TLSv1 TLSv1.1 TLSv1.2; # Dropping SSLv3, ref: POODLE
	ssl_protocols TLSv1.2 TLSv1.3;
	ssl_prefer_server_ciphers on;

	##
	# Logging Settings
	##

	access_log /var/log/nginx/access.log;
	error_log /var/log/nginx/error.log;

	##
	# Gzip Settings
	##

	gzip on;
	gzip_disable "msie6";

	##
	# Virtual Host Configs
	##

	include /etc/nginx/conf.d/*.conf;
}

OpenSSL Autorité de certification - Certificats Clients

Création d’une autorité de certification

Cette autorité de certification est la base de la chaine de certification. Il s’agit, ni plus ni moins, que d’un certificat x509 (auto signé) et d’une arborescence de gestion des certificats. Le certificat racine doit être protégé par un mot de passe et disposer d’une durée de validité non nulle.

La procédure de création d’une autorité de certification avec OpenSSL est grandement simplifiée par les scripts perl et bash « CA.XX » fournit dans les pacquages d’OpenSSL. En fonction des distributions, vous les trouverez dans /usr/lib/ssl/misc/ (debian), dans « /usr/local/ssl/misc/ », dans « /etc/ssl/misc/ », ou dans « /etc/openssl/misc ». Ces scripts font la même choses, ils sont juste scriptés dans un langage différent.

tree /usr/lib/ssl/misc/
/usr/lib/ssl/misc
├── CA.pl
├── tsget -> tsget.pl
└── tsget.pl

Les paramètres de création de l’autorité de certification sont déclarées dans le script « CA.xx » et dans le fichier de configuration de /etc/ssl/openssl.cnf

Par défaut, l’arborescence de l’autorité de certification est créée sous « ./demoCA » mais cela peut être changé dans le fichier de configuration et dans le script de création de l’autorité.

Créer une autorité de certification basée sur un certificat ayant une durée de validité de 10 ans dont la racine est « /etc/ssl/CertificateAuthority » , modifier les variables » CADAYS » et « CATOP » dans le fichier du script « /usr/lib/ssl/misc/CA.pl » ou « CA.sh »

sudo nano /usr/lib/ssl/misc/CA.pl
my $CADAYS = "-days 3650";	# 10 years
my $CATOP = "/etc/ssl/CertificateAuthority";

ainsi que la valeur de « dir » dans /etc/ssl/openssl.cnf

sudo nano /etc/ssl/openssl.cnf
[ CA_default ]

dir		= /etc/ssl/CertificateAuthority		# Where everything is kept

avant de lancer « /chemin/vers/CA.xx -newca » :

/usr/lib/ssl/misc/CA.pl -newca
CA certificate filename (or enter to create)

Making CA certificate ...
====
openssl req  -new -keyout /etc/ssl/CertificateAuthority/private/cakey.pem -out /etc/ssl/CertificateAuthority/careq.pem 
Generating a RSA private key
............................+++++
.........................................................+++++
writing new private key to '/etc/ssl/CertificateAuthority/private/cakey.pem'
Enter PEM pass phrase:
Verifying - Enter PEM pass phrase:
-----
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:FR
State or Province Name (full name) [Some-State]:Pays-de-Loire
Locality Name (eg, city) []:SMM
Organization Name (eg, company) [Internet Widgits Pty Ltd]:
Organizational Unit Name (eg, section) []:
Common Name (e.g. server FQDN or YOUR name) []:xoyan
Email Address []:

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:
An optional company name []:
==> 0
====
====
openssl ca  -create_serial -out /etc/ssl/CertificateAuthority/cacert.pem -days 3650 -batch -keyfile /etc/ssl/CertificateAuthority/private/cakey.pem -selfsign -extensions v3_ca  -infiles /etc/ssl/CertificateAuthority/careq.pem
Using configuration from /usr/lib/ssl/openssl.cnf
Enter pass phrase for /etc/ssl/CertificateAuthority/private/cakey.pem:
Check that the request matches the signature
Signature ok
Certificate Details:
        Serial Number:
            66:30:e8:93:dd:e5:9e:f7:31:4a:76:c8:e9:bd:19:ba:2c:c3:f6:0f
        Validity
            Not Before: Oct 26 10:55:31 2019 GMT
            Not After : Oct 23 10:55:31 2029 GMT
        Subject:
            countryName               = FR
            stateOrProvinceName       = Pays-de-Loire
            organizationName          = Internet Widgits Pty Ltd
            commonName                = xoyan
        X509v3 extensions:
            X509v3 Subject Key Identifier: 
                00:72:5B:A1:B0:6A:F6:CC:E9:9C:3C:72:CC:3C:75:71:4C:CA:C5:6A
            X509v3 Authority Key Identifier: 
                keyid:00:72:5B:A1:B0:6A:F6:CC:E9:9C:3C:72:CC:3C:75:71:4C:CA:C5:6A

            X509v3 Basic Constraints: critical
                CA:TRUE
Certificate is to be certified until Oct 23 10:55:31 2029 GMT (3650 days)

Write out database with 1 new entries
Data Base Updated
==> 0
====
CA certificate is in /etc/ssl/CertificateAuthority/cacert.pem

Qui aura pour effet de créer l’arborescence suivante :

tree /etc/ssl/CertificateAuthority/
/etc/ssl/CertificateAuthority/
├── cacert.pem
├── careq.pem
├── certs
├── crl
├── crlnumber
├── index.txt
├── index.txt.attr
├── index.txt.old
├── newcerts
│   └── 6630E893DDE59EF7314A76C8E9BD19BA2CC3F60F.pem
├── private
│   └── cakey.pem
└── serial

Où :

  • cacert.pem est la clé publique de votre autorité de certification ;
  • private/cakey.pem est la clé privée ;
  • index.txt est le fichier d’index conservant l’association certificat/propriétaire ;
  • index.txt.attr est le fichier d’option des indexes ;
  • serial est le numéro du prochain certificat créé ;
  • certs est le répertoire des certificats signés et de leurs hash associé.

Note sur le répertoire « certs »
Afin de pouvoir vérifier une chaine de certification, on crée dans le répertoire « certs » un lien symbolique pointant vers les certificats signés par la chaine de certification. Ce lien à pour nom « hash.0 » où « hash » est le hachage du « DN » (Dir Name de la forme /C=FR/ST=Ile-De-France/L=Paris/O=Admin Linux/OU=Service Informatique/CN=Marc Dupond/emailAddress=marc.dupond@admin-linux.fr) du certificat.

Le « hash » du certificat est retourné par openssl x509 -hash -noout -in certif.{pem,crt}

openssl x509 -hash -noout -in /etc/ssl/CertificateAuthority/cacert.pem 
    ecd697ae

et créons donc le lien « /etc/ssl/CertificateAuthority/certs/ecd697ae.0 » pointant vers « /etc/ssl/CertificateAuthority/cacert.pem »

ln -s /etc/ssl/CertificateAuthority/cacert.pem /etc/ssl/CertificateAuthority/certs/ecd697ae.0

Note sur les informations des certificats
ATTENTION : Par défaut, la signature de plusieurs certificats créés avec EXACTEMENT LES MÊMES PARAMÈTRES de sujet (countryName, stateOrProvinceName, organizationName, organizationalUnitName, commonName, emailAddress) n’est pas autorisé !

Pour des certificats machine, il est d’usage que le « commonName » désigne le nom de la machine (souvent dans son entier nom.domaine) tandis que pour les utilisateurs ils désigne leurs « Prénom NOM ».

Création d’un certificat client

Ensuite, un certificat client sera créé. c’est à vous de décider comment vous souhaitez les gérer, mais souvenez-vous qu’il s’agit en réalité d’un mot de passe. Si vous souhaitez le «modifier», vous devez révoquer le certificat. Alors, réfléchissez à la manière dont vous souhaitez gérer votre authentification: par utilisateur, par périphérique?

Vous voudrez d’abord une clé client; ceci est généré de la même manière que la clé de certificat; vous pouvez même utiliser celui-là (mais pas). En règle générale, si vous avez plusieurs utilisateurs, les deux étapes suivantes sont celles que vous leur demandez de faire: créer une demande de signature de certificat pour vous signer.

Utilisateurs: créer une clé et une demande de signature de certificat

Créez une clé ECC, si vous n’en avez pas déjà une:

openssl ecparam -out yannick.key -name prime256v1 -genkey # ECC utilisateur yannick

Ensuite, créez une demande de signature de certificat (CSR)

openssl req -new -key yannick.key -out yannick.csr -sha256    # ECC utilisateur yannick

Un certain nombre de questions seront posées. répondez à chacune d’elles, y compris le nom usuel et l’adresse électronique. Le CSR créé sera envoyé à l’autorité de certification (un administrateur, mais dans ce cas probablement aussi vous-même) pour signature.

You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:FR
State or Province Name (full name) [Some-State]:
Locality Name (eg, city) []:
Organization Name (eg, company) [Internet Widgits Pty Ltd]:
Organizational Unit Name (eg, section) []:
Common Name (e.g. server FQDN or YOUR name) []:Yannick
Email Address []:yannick@cinay.xyz

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:
An optional company name []:

Signer un CSR

Un CSR doit maintenant être signé par le CA; c’est ce que dit le CA: “Je connais cette personne ou cet appareil: ils sont ce qu’ils prétendent être.”

Cas yannick
1-Préparation certificat avant signature

openssl req -x509 -in yannick.csr -key yannick.key > yannick.crt

2-Signature certificat utilisateur avec le CA

openssl ca -policy policy_anything -out yannick.crt -infiles yannick.csr
Using configuration from /usr/lib/ssl/openssl.cnf
Enter pass phrase for /etc/ssl/CertificateAuthority/private/cakey.pem:
Check that the request matches the signature
Signature ok
Certificate Details:
        Serial Number:
            66:30:e8:93:dd:e5:9e:f7:31:4a:76:c8:e9:bd:19:ba:2c:c3:f6:11
        Validity
            Not Before: Oct 26 15:12:50 2019 GMT
            Not After : Oct 25 15:12:50 2020 GMT
        Subject:
            countryName               = FR
            stateOrProvinceName       = Some-State
            organizationName          = Internet Widgits Pty Ltd
            commonName                = Yannick
            emailAddress              = yannick@cinay.xyz
        X509v3 extensions:
            X509v3 Basic Constraints: 
                CA:FALSE
            Netscape Comment: 
                OpenSSL Generated Certificate
            X509v3 Subject Key Identifier: 
                DD:57:57:AA:1D:EA:E6:CD:BF:97:0A:9D:A6:8B:7B:36:9F:73:5A:E1
            X509v3 Authority Key Identifier: 
                keyid:00:72:5B:A1:B0:6A:F6:CC:E9:9C:3C:72:CC:3C:75:71:4C:CA:C5:6A

Certificate is to be certified until Oct 25 15:12:50 2020 GMT (365 days)
Sign the certificate? [y/n]:y


1 out of 1 certificate requests certified, commit? [y/n]y
Write out database with 1 new entries
Data Base Updated

Le certificat signé serait renvoyé à l’utilisateur avec le certificat de l’autorité de certification (pas la clé privée!), Pour installation sur leur appareil.

Création d’un PKCS #12 (PFX)

Maintenant, le certificat signé doit pouvoir être installé sur un périphérique de manière à regrouper les clés client et le certificat. L’archive résultante est en réalité un mot de passe, elle doit donc être gardée aussi sûre que les autres clés privées.

Pour créer le pfx:

openssl pkcs12 -export -out yannick.pfx -inkey yannick.key -in yannick.crt -certfile cacert.pem
Enter Export Password:
Verifying - Enter Export Password:

Il vous sera demandé de fournir un «mot de passe d’exportation». Il est fortement recommandé de le définir, car vous devrez souvent transférer l’archive PFX sur un périphérique tel que votre téléphone. vous ne voulez pas que cette séance dans votre email sans un mot de passe.

L’archive PFX peut maintenant être importée dans votre navigateur Web. C’est plutôt chouette! Vous pouvez voir comment un processus comme celui-ci peut être utilisé pour prouver l’identité et créer un accès valide pour un utilisateur, sans que l’administrateur (CA) ou l’utilisateur ne révèle sa clé privée à un autre.

Voyons maintenant comment configurer nginx pour l’authentification de certificat, avec un proxy inverse pour notre application non authentifiée.

Nginx - accès avec certificat client

Un nginx.conf minimal nginx.conf charge l’authentification de certificat, http redirigé vers https et un proxy inverse se présenterait comme suit pour un exemple de example.com . Notez que le certificat HTTPS dans cet exemple est fourni par letsencrypt .

Configuration pour un accès avec certificat client
Créer un fichier commun /etc/nginx/auth_certificat_client

	# authentification par certificat client
	    # client certificate
	    ssl_client_certificate /etc/ssl/CertificateAuthority/cacert.pem; 
	    # make verification optional, so we can display a 403 message to those
	    # who fail authentication
	    ssl_verify_client optional;

Inclure le fichier dans les configurations nginx des vhosts qui nécessitent un accès avec certificat client

include auth_certificat_client;

Désormais, lorsque vous visiterez le serveur nginx, votre navigateur sera invité à fournir son certificat client. sélectionnez le certificat que vous avez installé
certificat-client
le mot de passe “export” est demandé…
et vous devriez être mandaté par le serveur en amont.
Si vous visitez un navigateur sans certificat client installé, vous devriez voir une erreur 403 sans aucune sorte d’invite.

Liens