System

   génerale 
connaitre la version du systeme lsb_release -a
cat /etc/issue
cat /etc/debian_version
uname -a


    Le SGF 
dossier
description
/home
dossier des utilisateurs
/bin 
/usr/bin
commandes systeme
/sbin 
/usr/sbin
commandes systeme "admin"
/etc
fichier de configuration
/var
dossier de log/spooler/mouchard etc...
/dev
point d'entré des périphériques
/dev/urandom
générateur aléatoire de texte
/proc
fichier systeme spéciaux
apt-cache search libSDL
chercher une librairie
fsck /dev/la_partition
pour restaurer un disque
ps aux
pour voir les processus zombie avec z
exiftool
affiche les info meta d'un fichier
editeur exadecinmale
GHex
filtrer les lignes
$(echo top) | grep 'fire'
filtrer les lignes dans un dossier
grep -RFl "pattern recherchee" <dossier>
rechercher les depots
apt-cache search xxx





Paquets et dépôts 
dpkg
i install
r remove (garde les fichier conf)
l liste l'enssemble des pacquets
contents contenue d'un pacquet
info info sur un pacquet
purge supprime les fichiers de conf
L liste les fichiers du pacquet déja installé
—get-selections > liste btenir la liste des paquets installés sur un système
—set-selections < liste ré-installer les paquets sur une autre machine à partir d’une liste (obtenue par –get- selections)(avec apt-get : apt-get dselect-upgrade pour installer la sélection.)
-S Nom_Partiel_Du_Fichier Rechercher un fichier contenu dans un paque
-L Nom_Exacte_Du_Paquet Connaître la liste des fichiers d’un paquet
-p Nom_Du_Paquet Informations complètes sur un paquet
—configure paquet Re-configurer un paquet pas encore installé :
-reconfigure paquet Un paquet déjà installé
cat /var/log/dpkg.log historique des actions effectuées par dpkg
-S Nom_Fichier retrouver le paquet origine d’un fichier installé
-s nom-de-paquet (--status) Rapporte l'état du paquet indiqué (le contenue du fichier status)
apt-get
apt-get install Nom_Paquet Installation d'un paquet
apt-get remove Nom_Paquet Suppression d'un paquet
apt-get purge Nom_Paquet Suppression avec les fichiers de configuration
apt-get installl –reinstall Nom_Paquet réinstallation d'un paquet
apt-get autoremove Nom_Paquet désinstaller les paquets indiqués avec leurs dépendances
apt-get clean supprime la totalité des paquets présents dans /var/cache/apt/archives
apt-get installl --download-only Nom_Paquet télécharge le packet dans /var/cache/apt/archives
le fichier /etc/apt/preferences (si le fichier n'existe pas, le créer) pour y insérer les lignes suivantes: Package: nom_du_paquet Pin: version du paquet à conserver Pin-priority: 1001 Bloquer la mise à jour d'un paquet
update mettre à jour les catalogues de la base local des différents dépôt
upgrade (ou dist-upgrade) pour mettre à jour les paquets installés
apt-cache
cache apt-cache gencaches Pour utiliser cette commande, il faut installer le paquet : apt-get install apt-cache et générer le
permet de consulter des infos du cache d’apt
search pop permet de trouver un paquet / à un mot clé (ici pop),
dumpavail affiche les entêtes de tous les paquet
pkgnames affiche les noms de tous les paquets
show paquet pour afficher l’info d’un paquet
showpkg paquet pour avoir les dépendances, la version...
ar
t pacquet.deb affiche le contenue d'un pacquet
x pacquet.deb extrait le contenue





les dépots 
/etc/apt/sources.list
lister les pacquets installés dpkg –list
deb http://fr.archive.ubuntu.com/ubuntu/ gutsy main restricted
[deb=bianire deb-src=source] nature du dépot
[http/ftp/disk] adresse du dépot
[updates(correctif bug)/security/backport(maj officiel)] distribution et type de débpot
[main(logiciel libre)/restricted(pilote propriétaire)/universe(libre pris en charge par la communauté)/multiverse(logiciel a utilisation restreinte)]





modules 
lsmod lister les modules actifs (également cat /proc/modules)
rmmod décharger un module
insmod charger un module
modinfo information sur un module
modprobe permet également de charger les modules dynamiques et prend en charge les dépendances de modules. Par exemple pour monter les clés USB, il faut monter les modules suivants : Directement en ligne de commande :
modprobe usbcore
modprobe usb-storage
Si un périphérique de stockage est connecté sur un port usb, le système sait alors l'identifier et créer un device (sous /dev) pour permettre son utilisation.
modprobe module_carte io=0x280 irq=9 (on passe des options au module)
insmod insérer un module dans le kernel exemple: insmod mondriver.o exemple un driver avec le major 10
Le système à chargé le module et lui a affecté un numéro d'instance 62 (minor)
mknod /dev/mondriver c 10 62
loop mount -o loop=/dev/loop0 disk-image Point_Montage
lspci -nnv fait le lien entre le matériel et le module affiche les informations





librairies 
Afficher les bibliothèques partagées nécessaires ldd (ldd /bin/ls)





Systeme et authentification





les logs





le matériel
affiche des informations sur les unités Virtual I/O Server lsdev
affiche des informations très détaillées sur les périphériques du bus PCI d'un ordinateu lspci
affiche des informations relatives aux bus USB du système et aux périphériques qui y sont connectés. lsusb
afficher des informations sur l'architecture du processeur lscpu
affiche des informations très détaillées sur les périphériques d'un ordinateur lshw





,, wireshark, ping, arp, traceroute, tcpcheck, iptraf, jnet
le réseau
permet de capturer des pacquets iftop
affiche la configuration réseau des interfcaces (déprécated) ip addr ifconfig
affiche la configuration wifi iwconfig
un analyseur de pacquets tcpdump
un outils de sniff du réseau wireshark





les disques
crée un fichier tres grand dd if=/dev/urandom of=file.xt bs=2048 count=10000000
pvdisplay
lvdisplay
vgdisplay
affihes les informations des (disques physiques, des volumes logiques, des groupes de volumes
pvcreate permet de crée un volume (de dire que ce volume seras utilisable par lvm) pvcreate /dev/sdb1
lvcreate crée un volume logique lvcreate -L XXG vg0 -n lv-usr
mkfs crée un systeme de fichier mkfs ext4 /dev/vg0/lv-usr
mount -o remount ,ro /usr remonte un lecteur mount -o remount ,ro /usr
lsof voir ce qui est ouvert
lvreduce réduit mais ecrase le formatage
resize2fs redimentionne le File System d'une partition resize2fs /dev/mapper/vg0-lv-xxx YY MB
df affiche les informations des volumes df -h
lvresize redimentionne la taille d'un volume logique lvresize -L -30G /dev/vg0/lv-home
fdisk
etc/fstab
file system mount point type options dump pass
UUID=d773855f-be34-4c1b-a34f-acdfe48f1640 /mnt/Images ext4 defaults 0 2
file system:le volume a monter (ici une partition identifié par son UUID)
mount point:un point de montage: (le dossier /mnt/Images)
type: de quel type de système de fichier il s'agit (ext4)
options: qui a les droits de lecture, écriture et exécution sur ce volume (ici defaults )
dump: Indicateur pour l'utilitaire de sauvegarde dump (0).
pass: Indicateur pour la vérification par la commande fsck(2)
sudo ./configure --help





options de montage du systeme de fichier
[ ] discard réduit les blocs libéré du périphérique support
[ ] noatime pas de MAJ des heures d'accèdes des inodes
[ ] nodiratime pas de MAJ des heures d'accèdes des inodes de répertoires
[ ] relatime MAJ relative des dates et heures d'accès des inodes
[ ] nodev pas de gestion des périphériques blocs ou caractère
[ ] nosuid pas de gestion des bits setuid ou setgid
[ ] noexec interdiction de l'execution des programmes
[ ] ro montage en lecture seule
[ ] sync toutes les entrees/sorties sont synchrones
[ ] usrquota gestion des quota des utilisateurs
[ ] grpquota gestion du quota des groupes
[ ] user_xattr gestion des attributs étendus pour les utilisateurs





l'interface graphique





les dockers

    environnement chrootè 
Proc
les fichiers
buddyinfo informations sur la mémoire et la fragmentation dans les différentes zones mémoire cgroups : liste des groupes de contrôle activés
cmdline ligne de commande du noyau
consoles consoles enregistrées sur le système
cpuinfo informations sur les CPUs de la machine
crypto chiffrements utilisables par le noyau
devices périphériques configurés sur le système dont le module noyau est chargé
diskstats statistiques sur les entrées/sorties
dma canaux DMA utilisés par le système
execdomains domaines d’exécution supportés par le noyau 1
fb périphériques "framebuffer" disponibles
filesystems systèmes de fichiers supportés par le noyau
interrupts nombre d’interruptions processeur gérées par le système (x86)
iomem mapping de la mémoire système pour les périphériques gérés par le noyau
ioports mapping des ports d’entrées/sorties des périphériques
kallsyms ensemble des symboles du noyau
kcore accès à la mémoire physique du système
keys tables des clés cryptographiques utilisées par le système
kmsg messages générés par le noyau
loadavg moyenne de charge du système depuis 1, 5 et 10 minutes
locks verrous posés par le noyau sur des fichiers
meminfo (nombreuses) informations sur la mémoire du système
modules liste des modules noyau chargés
mounts liste des montages de systèmes de fichiers en cours
partitions liste des partitions détectées par le système
self lien symbolique vers le répertoire "proc" de l’appelant
stat statistiques diverses sur le système depuis son lancement
swaps informations sur la ou les partition d’échange du système
uptime temps en seconde écoulé depuis le lancement / temps IDLE
version version du noyau chargé
les repertoires
bus accès aux périphériques et aux informations sur ceux-ci (classiquement bus/pci; bus/input) driver : informations sur des drivers spécifiques utilisés par le système
fs informations sur les systèmes de fichiers utilisés par le système
irq informations/configuration des IRQs du système
sys informations/configurations des paramètres du noyau
tty informations sur les périphérique tty en cours d’utilisation
quelques fichiers (dans Proc/xxx/)
/proc/PID/cmdline contient la ligne de lancement du processus
/proc/PID/exe pointe sur le fichier bianire contenue dans usr/bin/
/proc/PID/environ contient la liste des variabels d'environnement
/proc/PID/cwd boucle (cwd change le repertoire de travail)
/proc/PID/stat les informations relatives au processus (c.f. man proc)
/proc/PID/fd Il s'agit d'un sous-répertoire contenant une entrée pour chaque fichier que le processus a ouvert. Chaque entrée a le descripteur du fichier pour nom, et est représentée par un lien symbolique sur le vrai fichier. Ainsi, 0 correspond à l'entrée standard, 1 à la sortie standard, 2 à la sortie d'erreur, etc...
les dockers

   commande processus 
SIGINT 2 Terminer le processus Il s'agit d'une demande venant du clavier, le plus souvent à l'aide la combinaison de touches Ctrl+C
SIGKILL 9 Terminer le processus Ce signal permet d'arrêter tout programme car il ne peut être géré différemment que le comportement par défaut. L'arrêt du programme est brutal.
SIGUSR1 10 Terminer le processus Ce signal n'a pas de signification particulière. Il peut être utilisé de manière différente par chaque programme.
SIGSEGV 11 Terminer le processus Ce signal est envoyé à un programme lorsque qu'il tente d'accéder à un endroit invalide en mémoire.
SIGUSR2 12 Terminer le processus Identique à SIGUSR1.
SIGTERM 15 Terminer le processus Si le programme n'a pas prévu de gérer ce signal, l'arrêt sera aussi brutal que pour SIGKILL. Mais comme le comportement par défaut peut être changé, le programme a la possibilité de réaliser des opérations avant de se terminer.
SIGCHLD 17 Ignorer ce signal Envoyé à un processus dont un fils est arrêté ou terminé.
SIGCONT 18 Reprendre le processus Permet de faire se continuer un processus qui avait été arrêté par exemple à l'aide de SIGSTOP (voir ci-après).
SIGSTOP 19 Arrêter le processus Ce signal demande au processus de suspendre son exécution. Comme SIGKILL, ce signal ne peut être géré différemment.
exempleskill -s SIGSTOP 256
kill -SIGSTOP 256
les dockers

    commande ps 
ps
-a afficher les informations sur les processus des autres utilisateurs en plus de l'utilisateur lui-même (lorsque c'est possible - cf option hidepid du fs proc par exemple )
-c ne pas afficher la ligne de commande complète mais seulement le nom de l'exécutable
-u affiche les informations suivantes : user,pid,%cpu,%mem,vsz,rss,tty,stat,start,time,command
-w affichage large (jusqu'à 132 caractères avec un seul "w", autant que nécessaire si plusieurs "w")
-x afficher aussi les informations sur les processus qui ne sont pas attachés à un terminal
exemple
user pid %cpu %mem vsz rss tty stat start time command
propriétaire du processus PID du processus pourcentage de CPU utilisé par le processus pourcentage de mémoire utilisé par le processus taille de la mémoire virtuelle du processus taille de la mémoire résidente du processus terminal auquel est attaché le processus état du processus (idle, running, ...) heure du démarrage du processus temps cumulé d'utilisation du CPU par le processus ligne de commande du processus
programmes pour crée un environnement chrootè

    environnement chrootè 
copier dans un repertoire la commande et ses dépendances #!/bin/bash
#########################################
# Fichier rapatrie_dependance : copie les librairie d'une commande
# Auteur : schnellbach tanguy
# exemples : <sudo ./rpatriedep.sh <commande> <destination> >
# sudo ./rpatriedep.sh /bin/touch /mnt/chroot
#########################################

[ $# -lt 2 ] && echo "lisez la règle bordel" && exit 1
c_source=`echo $2 |sed 's/^\(.*\)\/$/\1/p'`

for i in $(ldd $1 | awk 'NF == 4 {print $3}; NF == 2 {print $1}')
do
chemin="$(dirname $i)"
mkdir -p $c_source$chemin
cp $i "$2$chemin" 2> /dev/null
done
mkdir $c_source/bin 2> /dev/null
cp $1 $c_source/bin/"$(basename $1)" 2> /dev/null
pour crée une image d'un repertoire genisoimage -o image.iso /home/fred/rep/
pour changer le repertoire chroot chroot /mnt/chroot/ /bin/bash
    name spaces
unshare permet de lancer un nouveau processus après création d'un ou plusieurs nouveaux namespaces des types demandés.
echo "kernel.unprivileged_userns_clone = 1" >> /etc/sysctl.conf pour le rendre persistant
echo "kernel.unprivileged_userns_clone=1" >> /etc/sysctl.conf (autoriser un user normal à crée un namespace)
--mountAnnuler le partage de l'espace de noms de montage. Si le fichier est spécifié, un l'espace de noms persistant est créé par un montage de liaison. Notez que le fichier doit être situé sur un système de fichiers avec la propagation indicateur défini sur privé
--userAnnuler le partage de l'espace de noms utilisateur. Si le fichier est spécifié, un espace de noms persistant est créé par un montage de liaison
chroot permet de lancer la commande chroot avec la commande unshare
--pidDissociez l'espace de noms PID. Si le fichier est spécifié,l'espace de noms persistant est créé par un montage de liaison. Voir aussi les Options --fork et --mount-proc.
--map-root-user (-r)Exécutez le programme uniquement après l'utilisateur effectif actuel et les ID de groupe ont été mappés à l'UID et au GID du superutilisateur dans le espace de noms utilisateur nouvellement créé
--forkFork le programme spécifié comme un processus enfant de non-partage plutôt que de l'exécuter directement. Ceci est utile lors de la création un nouvel espace de noms PID
--utsle processus a une copie distincte du nom d'hôte et du nom de domaine NIS (maintenant presque inutilisé), de sorte qu'il peut le définir sur autre chose sans affecter le reste du système.
nsenterpermet de rentrer dans un namespace
--netDissociez l'espace de noms du réseau.
ip link add vhost type veth peer name vguestOn crée ici un lien réseau de type "virtuel" (veth) entre une interface nommée "vhost" (côté "hôte") reliée à une interface nommée "vguest" qui sera accessible dans le namespace du bash lancé via unshare. (Remarque : on peut tout à fait choisir un nom différent pour les interfaces) ip link list
$ ip link set vguest netns <PID du bash >
serveurip link set vhost up
dockersip link set vguest up
serveurip addr add 192.168.100.1/24 dev vhost
dockersip addr add 192.168.100.2/24 dev vguest
ip route add default via 192.168.100.1 dev vguest on lie les deux adresses
unshare --cgroup --mount-proc --user -r --mount --pid --uts --net --fork bash -c "mount --rbind /sys chroot/sys ; mount --rbind /dev chroot/dev ; /sbin/chroot chroot/ bash"
pour donner un nombash -c "exec -a '[definir un nom]' ps -aux &"
l'interface graphique
boot

  Bios





Bootloader





 Noyau





 Initrd 
Les niveaux d’exécutions
0 les services qui doivent s'arréter lorsque l'on éteint physiquement la machine
1 ou (single) : uniquement pour root, permet de faire la maintenance (service minimum) equi mode sans echec
2 niveau par default sur ubuntu/debian, permet de définir un niveau de fonctionnement pour l'administrateur
3 niveau fonctionnel, tout les services sont démarré mais pas encore fonctionels
4 laissé à la disposition de l’administrateur qui pourra établir à partir de ce niveau un mode de fonctionnement particulier avec seulement certains services démarrés.
5 tous les services sont démarrés, et l’interface graphique est disponible
6 Temporaire par définition, le niveau 6 est celui d’un système en train de redémarrer. La configuration du niveau 6 consistera donc à déterminer quels services doivent être arrêtés au redémarrage du système. Après le redémarrage, un nouveau niveau d’exécution s’appliquera (en général le niveau par défaut) et les services associés à ce niveau seront démarrés.
Structure /etc/inittab -> identifiant:niveau:mode_action:commande
identifiant Chaîne alphanumérique d’un ou deux caractères. Identifie la ligne. Pas d’autres contraintes que d’éviter d’avoir deux lignes avec le même identifiant.
niveau Le ou les niveaux d’exécution (en chiffres) pour lesquels la ligne est pertinente.
mode_action À choisir parmi quelques mots­clés, définit la façon dont la commande du quatrième champ sera exécutée.
initdefault un peu particulier, initdefault ne régit pas la façon dont la commande du quatrième champ sera exécutée. D’ailleurs, quand le mode d’action est initdefault, le quatrième champ est vide. initdefault ne sert en fait qu’à définir le niveau d’exécution du système par défaut.
sysinit ert à exécuter des scripts à l’initialisation du système, indépendamment du niveau d’exécution. Pour cette raison, sysinit n’admet pas de valeur pour le deuxième champ.
wait exécute la commande du quatrième champ (souvent un script), et attend la fin de cette exécution pour passer aux lignes suivantes du fichier inittab.
respawn exécute la commande du quatrième champ, et laisse tourner le processus à l’arrière­plan. Passe ensuite aux lignes suivantes du fichier inittab. Si le processus appelé par la commande s’arrête, init le relancera systématiquement.
commande La commande à exécuter au(x) niveau(x) défini(s) dans le deuxième champ selon le mode d’action du troisième champ
gestion des services /etc/init.d/nom action
nom du service à gerer
action start ou stop
#!/bin/bash
case $1 in
start)
# commande de lancement du service
;;
stop)
# commande d’arrêt du service
;;
esac





 Systemd
systemctl enable nom_du_service.service demarre un service au demarrage # systemctl enable sshd.service
ln -s '/usr/lib/systemd/system/sshd.service' '/etc/systemd/system/multi-user.target.wants/sshd.service'
systemctl disable nom_du_service.service arrete u service au demarrage # systemctl disable sshd.service
rm '/etc/systemd/system/multi-user.target.wants/sshd.service'
systemctl is-active nom_du_service.service connaitre le status d'un service
systemctl start nom_du_service.service démarrer un service
systemctl stop nom_du_service.service stop un service
systemctl restart nom_du_service.service redemarre un service # systemctl restart sshd.service
systemctl reload nom_du_service.service recharge la configuration d'un service systemctl reload smb.service
systemctl get-default multi-user.target
systemctl isolate nom.target basculer de run level systemctl isolate graphical.target
systemctl set-default nom.target changer le runlevel par default systemctl set-default graphical.target
exemple touch /etc/systemd/system/mon-service.service
-------------mon-service.service
Description=Je dis ici à quoi sert le service
ConditionPathExists=/usr/sbin/commande
[Service]
Type=forking
ExecStart=/bin/sh -c 'commande'
TimeoutSec=0
StandardOutput=tty
RemainAfterExit=yes
SysVStartPriority=99
[Install]
WantedBy=multi-user.target
------------------------------------------------
#Ensuite, rendre exécutable ce service :
chmod a+x /etc/systemd/system/mon-service.service
#On recharge systemd
systemctl --system daemon-reload
#On tente de démarrer le service et on constate que ça marche bien :
systemctl start mon-service.service
#On peut ajouter ce service au démarrage si on le souhaite :
systemctl enable mon-service.service





 Systemd.conf
CtrlAltDelBurstAction= Définit quelle action sera effectuée si l'utilisateur appuie sur Ctrl-Alt-Suppr plus de 7 fois en 2 secondes. Peut être réglé sur " reboot-force ", " poweroff-force ", " reboot-immediate ", " poweroff-immediate " ou désactivé avec " none ". Par défaut, " reboot-force ".
CPUAffinity= Configure l'affinité CPU pour le gestionnaire de services ainsi que l'affinité CPU par défaut pour tous les processus dérivés. Prend une liste d'indices ou de plages CPU séparés par des espaces ou des virgules. Les plages de CPU sont spécifiées par les indices de CPU inférieur et supérieur séparés par un tiret. Cette option peut être spécifiée plusieurs fois, auquel cas les masques d'affinité CPU spécifiés sont fusionnés. Si la chaîne vide est affectée, le masque est réinitialisé, toutes les affectations antérieures n'auront aucun effet. Les services individuels peuvent remplacer l'affinité CPU pour leurs processus avec le CPUAffinity= dans les fichiers d'unité, voir systemd.exec (5) .
NUMAPolicy= Configure la stratégie de mémoire NUMA pour le gestionnaire de services et la stratégie de mémoire NUMA par défaut pour tous les processus dérivés. Les services individuels peuvent remplacer la stratégie par défaut avec le NUMAPolicy= dans les fichiers d'unité, voir systemd.exec (5) .
NUMAMask= Configure le masque de nœud NUMA qui sera associé à la stratégie NUMA sélectionnée. Notez que local stratégies NUMA local et default ne nécessitent pas de masque de nœud NUMA explicite et que la valeur de l'option peut être vide. De manière similaire à NUMAPolicy= , la valeur peut être remplacée par des services individuels dans les fichiers d'unité, voir systemd.exec (5) .
RuntimeWatchdogSec= , RebootWatchdogSec= , KExecWatchdogSec= Configurez le chien de garde matériel à l'exécution et au redémarrage. Prend une valeur de temporisation en secondes (ou dans d'autres unités de temps si elles sont suffixées avec " ms ", " min ", " h ", " d ", " w "). Si RuntimeWatchdogSec= est défini sur une valeur non nulle, le matériel du chien de garde ( /dev/watchdog ou le chemin spécifié avec WatchdogDevice= ou l'option du noyau systemd.watchdog-device= ) sera programmé pour redémarrer automatiquement le système s'il ne l'est pas. contacté dans le délai spécifié. Le gestionnaire du système veillera à le contacter au moins une fois dans la moitié de l'intervalle de temporisation spécifié. Cette fonctionnalité nécessite la présence d'un dispositif de surveillance matériel, comme c'est généralement le cas dans les systèmes embarqués et serveurs. Tous les chiens de garde matériels ne permettent pas de configurer toutes les valeurs de délai de redémarrage possibles, auquel cas le délai disponible le plus proche est sélectionné. RebootWatchdogSec= peut être utilisé pour configurer le chien de garde matériel lorsque le système est invité à redémarrer. Il fonctionne comme un filet de sécurité pour garantir que le redémarrage a lieu même si une nouvelle tentative de redémarrage expire. Notez que le délai d'expiration RebootWatchdogSec= s'applique uniquement à la deuxième phase du redémarrage, c'est-à-dire après que tous les services réguliers sont déjà terminés et après que le processus du système et du gestionnaire de services (PID 1) a été remplacé par le binaire systemd-shutdown , voir démarrage du système ( 7) pour plus de détails. Pendant la première phase de l'opération d'arrêt, le système et le gestionnaire de services continuent de fonctionner et, par conséquent, RuntimeWatchdogSec= est toujours RuntimeWatchdogSec= . Afin de définir un délai d'expiration sur cette première phase d'arrêt du système, configurez JobTimeoutSec= et JobTimeoutAction= dans la section " [Unit] " de l'unité shutdown.target . Par défaut, RuntimeWatchdogSec= défaut à 0 (désactivé) et RebootWatchdogSec= à 10 RebootWatchdogSec= . KExecWatchdogSec= peut être utilisé pour activer en plus le chien de garde lorsque kexec est exécuté plutôt que lors du redémarrage. Notez que si le noyau ne réinitialise pas le chien de garde sur kexec (en fonction du matériel et / ou du pilote spécifique), dans ce cas, le chien de garde peut ne pas être désactivé après la réussite de kexec et donc le système peut être redémarré, sauf si RuntimeWatchdogSec= est également activé à la fois. Pour cette raison, il est recommandé d'activer KExecWatchdogSec= uniquement si RuntimeWatchdogSec= est également activé. Ces paramètres n'ont aucun effet si aucun chien de garde matériel n'est disponible.
WatchdogDevice= Configurez le périphérique de surveillance du matériel que les temporisateurs de surveillance d'exécution et d'arrêt ouvriront et utiliseront. Par défaut, /dev/watchdog . Ce paramètre n'a aucun effet si aucun chien de garde matériel n'est disponible.
CapabilityBoundingSet= Contrôle les capacités à inclure dans l'ensemble de limites de capacités pour PID 1 et ses enfants. Voir les capacités (7) pour plus de détails. Prend une liste de noms de capacités séparés par des espaces tels que lus par cap_from_name (3) . Les capacités répertoriées seront incluses dans l'ensemble de délimitation, toutes les autres sont supprimées. Si la liste des capacités est précédée de ~, toutes les capacités sauf celles répertoriées seront incluses, l'effet de l'affectation étant inversé. Notez que cette option affecte également les capacités respectives dans les ensembles de capacités efficaces, autorisés et héritables. L'ensemble de limites de capacité peut également être configuré individuellement pour les unités à l'aide de la directive CapabilityBoundingSet= pour les unités, mais notez que les capacités supprimées pour le PID 1 ne peuvent pas être récupérées dans les unités individuelles, elles sont perdues pour de bon.
NoNewPrivileges= Prend un argument booléen. Si vrai, garantit que PID 1 et tous ses enfants ne pourront jamais obtenir de nouveaux privilèges via execve (2) (par exemple via les bits setuid ou setgid, ou les capacités du système de fichiers). La valeur par défaut est false. Les distributions à usage général reposent généralement sur des exécutables avec des bits setuid ou setgid et ne fonctionneront donc pas correctement avec cette option activée. Les unités individuelles ne peuvent pas désactiver cette option. Voir également Pas de nouveau drapeau de privilèges .
SystemCallArchitectures= Prend une liste d'identifiants d'architecture séparés par des espaces. Sélectionne à partir de quelle architecture les appels système peuvent être appelés sur ce système. Cela peut être utilisé comme un moyen efficace de désactiver l'invocation de binaires non natifs à l'échelle du système, par exemple pour interdire l'exécution de binaires x86 32 bits sur des systèmes x86-64 64 bits. Cette option fonctionne à l'échelle du système et agit de manière similaire au paramètre SystemCallArchitectures= des fichiers d'unité, voir systemd.exec (5) pour plus de détails. Ce paramètre correspond par défaut à la liste vide, auquel cas aucun filtrage des appels système basé sur l'architecture n'est appliqué. Les identificateurs d'architecture connus sont " x86 ", " x86-64 ", " x32 ", " arm " et l'identifiant spécial " native ". Ce dernier correspond implicitement à l'architecture native du système (ou plus précisément, l'architecture pour laquelle le gestionnaire de système a été compilé). Définissez ce paramètre sur " native " pour interdire l'exécution de tous les fichiers binaires non natifs. Lorsqu'un binaire exécute un appel système d'une architecture qui n'est pas répertoriée dans ce paramètre, il se termine immédiatement avec le signal SIGSYS.
TimerSlackNSec= Définit le relâchement du minuteur en nanosecondes pour le PID 1, qui est hérité par tous les processus exécutés, sauf s'il est remplacé individuellement, par exemple avec le TimerSlackNSec= dans les unités de service (pour plus de détails, voir systemd.exec (5) ). Le jeu du minuteur contrôle la précision des réveils déclenchés par les minuteurs du système. Voir prctl (2) pour plus d'informations. Notez que contrairement à la plupart des autres définitions d'intervalle de temps, ce paramètre prend une valeur entière en nano-secondes si aucune unité n'est spécifiée. Les unités de temps habituelles sont également comprises.
StatusUnitFormat= Prend le name ou la description comme valeur. Si name , le gestionnaire système utilisera les noms d'unité dans les messages d'état, au lieu des descriptions plus longues et plus informatives définies avec Description= , voir systemd.unit (5) .
DefaultTimerAccuracySec= Définit la précision par défaut des unités de minuterie. Cela contrôle la valeur par défaut globale pour le paramètre AccuracySec= des unités de temporisation, voir systemd.timer (5) pour plus de détails. AccuracySec= défini dans des unités individuelles remplace la valeur par défaut globale pour l'unité spécifique. Par défaut à 1 min. Notez que la précision des unités de temporisation est également affectée par le jeu de temporisation configuré pour le PID 1, voir TimerSlackNSec= ci-dessus.
DefaultTimeoutStartSec= , DefaultTimeoutStopSec= , DefaultTimeoutAbortSec= , DefaultRestartSec= Configure les délais d'expiration par défaut pour le démarrage, l'arrêt et l'interruption des unités, ainsi que le délai de mise en veille par défaut entre les redémarrages automatiques des unités, comme configuré par unité dans TimeoutStartSec= , TimeoutStopSec= , TimeoutAbortSec= et RestartSec= (pour les services, voir systemd .service (5) pour plus de détails sur les paramètres par unité). Désactivé par défaut, lorsque le service avec Type=oneshot est utilisé. Pour les unités hors service, DefaultTimeoutStartSec= définit la valeur TimeoutSec= par défaut. DefaultTimeoutStartSec= et DefaultTimeoutStopSec= par défaut à 90 s. DefaultTimeoutAbortSec= n'est pas défini par défaut afin que toutes les unités reviennent à TimeoutStopSec= . DefaultRestartSec= défaut à DefaultRestartSec= .
DefaultStartLimitIntervalSec= , DefaultStartLimitBurst= Configurez la limitation de taux de démarrage d'unité par défaut, telle que configurée par service par StartLimitIntervalSec= et StartLimitBurst= . Voir systemd.service (5) pour plus de détails sur les paramètres par service. DefaultStartLimitIntervalSec= défaut à 10 s. DefaultStartLimitBurst= 5 par défaut.
DefaultEnvironment= Définit les variables d'environnement du gestionnaire transmises à tous les processus exécutés. Prend une liste des affectations de variables séparées par des espaces. Voir environ (7) pour plus de détails sur les variables d'environnement.
Exemple:
DefaultEnvironment = "VAR1 = mot1 mot2" VAR2 = mot3 "VAR3 = mot 5 6"
Définit trois variables " VAR1 ", " VAR2 ", " VAR3 ".
DefaultCPUAccounting= , DefaultBlockIOAccounting= , DefaultMemoryAccounting= , DefaultTasksAccounting= , DefaultIOAccounting= , DefaultIPAccounting= Configurez les paramètres de comptabilité des ressources par défaut, tels que configurés par unité par CPUAccounting= , BlockIOAccounting= , MemoryAccounting= , TasksAccounting= , IOAccounting= et IPAccounting= . Voir systemd.resource-control (5) pour plus de détails sur les paramètres par unité. DefaultTasksAccounting= défaut à yes, DefaultMemoryAccounting= à yes. DefaultCPUAccounting= défaut à yes si l'activation de la comptabilité CPU ne nécessite pas d'activer le contrôleur CPU (Linux 4.15+ en utilisant la hiérarchie unifiée pour le contrôle des ressources), sinon il est par défaut à no. Les trois autres paramètres sont définis par défaut sur non.
DefaultTasksMax= Configurez la valeur par défaut pour le paramètre TasksMax= par unité. Voir systemd.resource-control (5) pour plus de détails. Ce paramètre s'applique à tous les types d'unités qui prennent en charge les paramètres de contrôle des ressources, à l'exception des unités de tranche. La valeur par défaut est 15%, ce qui équivaut à 4915 avec les valeurs par défaut du noyau sur l'hôte, mais peut être plus petit dans les conteneurs du système d'exploitation.
DefaultLimitCPU= , DefaultLimitFSIZE= , DefaultLimitDATA= , DefaultLimitSTACK= , DefaultLimitCORE= , DefaultLimitRSS= , DefaultLimitNOFILE= , DefaultLimitAS= , DefaultLimitNPROC= , DefaultLimitMEMLOCK= , DefaultLimitLOCKS= , DefaultLimitSIGPENDING= Ces paramètres contrôlent diverses limites de ressources par défaut pour les unités. Voir setrlimit (2) pour plus de détails. La limite de ressource est possible de spécifier dans deux formats, la value pour définir des limites logicielles et strictes à la même valeur, ou soft:hard pour définir les deux limites individuellement (par exemple DefaultLimitAS = 4G: 16G). Utilisez la chaîne infinity pour configurer aucune limite sur une ressource spécifique. Les suffixes multiplicatifs K (= 1024), M (= 1024 * 1024) et ainsi de suite pour G, T, P et E peuvent être utilisés pour les limites de ressources mesurées en octets (par exemple DefaultLimitAS = 16G). Pour les limites se référant aux valeurs de temps, les unités de temps habituelles ms, s, min, h et ainsi de suite peuvent être utilisées (voir systemd.time (7) pour plus de détails). Notez que si aucune unité de temps n'est spécifiée pour DefaultLimitCPU= l'unité de secondes par défaut est implicite, tandis que pour DefaultLimitRTTIME= l'unité de microsecondes par défaut est implicite. Notez également que la granularité effective des limites peut influencer leur application. Par exemple, les délais spécifiés pour DefaultLimitCPU= seront arrondis implicitement à des multiples de 1. Ces paramètres peuvent être remplacés dans des unités individuelles à l'aide des directives LimitXXX = correspondantes. Notez que ces limites de ressources ne sont que des valeurs par défaut pour les unités, elles ne sont pas appliquées au PID 1 lui-même.
DefaultOOMPolicy= Configurez la stratégie par défaut pour réagir aux processus tués par le tueur Linux hors mémoire (OOM). Cela peut être utilisé pour choisir une valeur par défaut globale pour le paramètre OOMPolicy= par unité. Voir systemd.service (5) pour plus de détails. Notez que cette valeur par défaut n'est pas utilisée pour les services pour lesquels Delegate= activé.





 rc





maintenance
/etc/nologin interdit tout utilisateur sauf root de se connecter.
au démarrage de la machine se fichier est effacé
chattr option +i. fait persister le fichier no-login apres le redémarrage





PAM
PAM Pour commencer, PAM définit des services qui ont généralement pour nom celui des applications qui l'utilisent. Par exemple nous avons le service login qui correspond à la commande du même nom, chargée de la connexion de l'utilisateur en mode console. De même nous avons les services ftp, gdm, ssh, etc. En fait chaque application qui utilise PAM aura son propre service. Service qui généralement prendra la forme d'un fichier du même nom dans le dossier /etc/pam.d. les serice exemple : /usr/lib/x86_64-linux-gnu/security/pam_faildelay.so
auth Vérification de l'identité d'un utilisateur et mise en place des accréditations associées.
account Vérification du compte d'un utilisateur (expiration, plannings, etc.).
password Vérification de la validité des mots de passes lorsqu'ils sont assignés à un utilisateur.
session Vérification de la session d'un utilisateur, de son dossier de travail, etc.
required Tous les modules utilisant ce contrôle doivent passer avec succès pour que la vérification soit accordée. Le cas échéant l'utilisateur n'est averti qu'à la fin du traitement de la pile.
requisite La même chose que required sauf que l'utilisateur est averti tout de suite.
optionnal L'échec ou le succès de ce module importe peu et ne peut faire échouer la vérification.
sufficient S'il réussi et qu'il n'y a pas de required en échec, le traitement s'arrête là. Le reste de la pile n'est alors pas traité.





MOTD
crée une baniere personalisée le fichier /etc/motd est généré automatiquement
procedure sudo touch /etc/profile.d/motd.sh
[...] script sh
sudo chmod +x /etc/profile.d/motd.sh
#!/bin/bash
name=`cat /etc/os-release |grep "^PRETTY_NAME=" |sed "s/^PRETTY_NAME=\"\(.*\)\"/\1/"`
date=` date +"%c"`
memoire=`grep MemTotal /proc/meminfo | grep -o "[0-9]*"`
memg=$(($memoire % 1000000))

thread=`lscpu | egrep 'Model name|Thread\(s\)'| grep -o "[0-9]*" `
nbcoeur=`cat /proc/cpuinfo | grep processor | wc -l`
memoire_racine=$(df -B1 | grep "/$" | grep -o "[0-9]*" | head -3 | tail -1 )
user=$(whoami)
machine=$(hostname)
c0=`printf '\033[0m'`
c1=`printf '\033[0;22;35m'`
c2=`printf '\033[21;31m'`
vert=`printf '\033[1;32;32m'`
printf ' '$c1'[]'$c0'-----'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'---'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'-'$c1'[]'$c0' '
echo
printf ' '$c1'[]]'$c0' '
echo
printf ' '$c1'[]'$c0'-'$c1'[]'$c0' '
printf $vert;printf " NAME ";printf $c0' : ';printf "$name"
echo
printf ' '$c1'[]'$c0'---'$c1'[]'$c0' '
printf $vert;printf " DATE ";printf $c0' : ';printf "$date"
echo
printf ' '$c1'[]'$c0'------'$c1'[]'$c0' '
printf $vert;printf " MEMOIRE VIVE";printf $c0' : ';printf "$(($memoire / 1000000))Go $(($memoire / 1000 % 1000 ))Mo $(($memoire % 1000))ko"
echo
printf ' '$c1'[]'$c0'--------'$c1'[]'$c0' '
printf $vert;printf " NB COEURS ";printf $c0' : ';printf "$nbcoeur"
echo
printf ' '$c1'[]'$c0'----by----'$c1'[]'$c0' '
printf $vert;printf " THREAD/COEUR ";printf $c0' : ';printf "$thread"
echo
printf ' '$c1'[]'$c0'schnellbach-'$c1'[]'$c0''
printf $vert;printf " SPACE ";printf $c0' : ';echo "$(($memoire_racine / 1000000000))Go $(($memoire_racine / 1000000 % 1000 ))Mo $(($memoire_racine % 1000000 / 1000))ko $(($memoire_racine % 1000 ))o"
printf ' '$c1'[]'$c0'----------'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'--------'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'------'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'----'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'--'$c1'[]'$c0' '
echo
printf ' '$c1'[[]'$c0' '
echo
printf ' '$c1'[]'$c0'-'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'---'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'-----'$c1'[]'$c0' '
printf $vert' BIENVENUE '$c2; echo "$user"$c0" sur "$c2"$machine"$c0
/usr/games/fortune -s
#!/bin/bash
name=`cat /etc/os-release |grep "^PRETTY_NAME=" |sed "s/^PRETTY_NAME=\"\(.*\)\"/\1/"`
date=` date +"%c"`
memoire=`grep MemTotal /proc/meminfo | grep -o "[0-9]*"`
memg=$(($memoire % 1000000))

thread=`lscpu | egrep 'Model name|Thread\(s\)'| grep -o "[0-9]*" | wc -l`
nbcoeur=`cat /proc/cpuinfo | grep processor | wc -l`
memoire_racine=$(df -B1 | grep "/$" | head -1 | tail -4 | cut -d" " -f9)
user=$(whoami)
machine=$(hostname)
c0=`printf '\033[0m'`
c1=`printf '\033[0;22;35m'`
c2=`printf '\033[21;31m'`
vert=`printf '\033[1;32;32m'`
printf ' '$c1'[]'$c0'-----'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'---'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'-'$c1'[]'$c0' '
echo
printf ' '$c1'[]]'$c0' '
echo
printf ' '$c1'[]'$c0'-'$c1'[]'$c0' '
printf $vert;printf " NAME ";printf $c0' : ';printf "$name"
echo
printf ' '$c1'[]'$c0'---'$c1'[]'$c0' '
printf $vert;printf " DATE ";printf $c0' : ';printf "$date"
echo
printf ' '$c1'[]'$c0'------'$c1'[]'$c0' '
printf $vert;printf " MEMOIRE VIVE";printf $c0' : ';printf "$(($memoire / 1000000))Go $(($memoire / 1000 % 1000 ))Mo $(($memoire % 1000))ko"
echo
printf ' '$c1'[]'$c0'--------'$c1'[]'$c0' '
printf $vert;printf " NB COEURS ";printf $c0' : ';printf "$nbcoeur"
echo
printf ' '$c1'[]'$c0'----by----'$c1'[]'$c0' '
printf $vert;printf " THREAD/COEUR ";printf $c0' : ';printf "$thread"
echo
printf ' '$c1'[]'$c0'schnellbach-'$c1'[]'$c0''
printf $vert;printf " SPACE ";printf $c0' : ';echo "$(($memoire_racine / 1000000000))Go $(($memoire_racine / 1000000 % 1000 ))Mo $(($memoire_racine % 1000000 / 1000))ko $(($memoire_racine % 1000 ))o"
printf ' '$c1'[]'$c0'----------'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'--------'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'------'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'----'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'--'$c1'[]'$c0' '
echo
printf ' '$c1'[[]'$c0' '
echo
printf ' '$c1'[]'$c0'-'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'---'$c1'[]'$c0' '
echo
printf ' '$c1'[]'$c0'-----'$c1'[]'$c0' '
printf $vert' BIENVENUE '$c2; echo "$user"$c0" sur "$c2"$machine"$c0
/usr/games/fortune -s

echo "" echo ""