Linux

Oh my zsh

Installation avec curl 
sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"

 

Activation des Plugins (zsh-autosuggestions et zsh-syntax-highlighting)

git clone https://github.com/zsh-users/zsh-autosuggestions.git $ZSH_CUSTOM/plugins/zsh-autosuggestions

git clone https://github.com/zsh-users/zsh-syntax-highlighting.git $ZSH_CUSTOM/plugins/zsh-syntax-highlighting

plugins=(git zsh-autosuggestions zsh-syntax-highlighting)

 

Changer de shell par défaut

Si vous êtes convaincu, il est temps de changer votre shell par défaut grâce à la commande suivante :

$ chsh -s /bin/zsh

Commencez par vous amuser un peu avec les fonctionnalités de base de Zsh, notamment celles que je vous ai présenté dans la section précédente. Vous ne devriez pas être perdu puisque toute la base du fonctionnement est très similaire à Bash.

Synology

Synology

Debian Chroot sur Synology DSM6

Que ce soit pour le fun ou par nécessité, comme dans ce cas, sachez qu’on peut installer Debian (en environnement chrooté donc sans risque) sur un NAS Synology. Ici sur DSM6 dernière version.

Installer Debian Chroot

Plutôt que de continuer à tout passer au crible avec df, ls et du j’ai voulu installer ncdu (via IPKG) mais ça ne fonctionnait pas. j’ai donc pris le parti, rapide, d’installer un chroot Debian via les dépôts SynoCommunity (wiki GitHub) qui permet d’installer Debian dans un dossier chrooté (sans risque de faire une boulette sur le NAS) sur Synology.

DebianChrootStoppedButRealRunning.jpg

Téléchargement

 

 

Comme Debian est installé dans un environnement “à part” on n’a pas accès au /Volume1, volume de stockage par défaut d’un NAS Synology. Du coup il faut modifier le script de lancement de l’environnement Debian. Ce qui se fait très simplement en SSH, en root, avec nano.

SSH : à activer dans Panneau de Configuration / Terminal et SNMP

pour passer root en SSH, sur DSM6, il faut taper sudo su et mettre le pwd du compte “Admin”

Nano : cet éditeur n’étant pas installé sur Synology il faut le faire via les paquets SynoCommunity

Et donc éditer ensuite le script de lancement du chroot :

nano /var/packages/debian-chroot/scripts/start-stop-status

Aller à la ligne # Mount if install is finished et ajouter en fin de bloc la commande pour y monter automatiquement le /Volume1

grep -q "${CHROOTTARGET}/volume1 " /volume1 || mount -o bind /volume1 ${CHROOTTARGET}/volume1

Ce qui nous donne

    # Mount if install is finished
    if [ -f ${INSTALL_DIR}/var/installed ]; then
        # Make sure we don't mount twice
        grep -q "${CHROOTTARGET}/proc " /proc/mounts || mount -t proc proc ${CHROOTTARGET}/proc
        grep -q "${CHROOTTARGET}/sys " /proc/mounts || mount -t sysfs sys ${CHROOTTARGET}/sys
        grep -q "${CHROOTTARGET}/dev " /proc/mounts || mount -o bind /dev ${CHROOTTARGET}/dev
        grep -q "${CHROOTTARGET}/dev/pts " /proc/mounts || mount -o bind /dev/pts ${CHROOTTARGET}/dev/pts
grep -q "${CHROOTTARGET}/volume1 " /volume1 || mount -o bind /volume1 ${CHROOTTARGET}/volume1

Il faut ensuite ajouter la commande de démontage à la fin du bloc # Unmount

umount ${CHROOTTARGET}/volume1

Ce qui donne

{
    # Stop running services
    ${INSTALL_DIR}/app/stop.py

    # Unmount
    umount ${CHROOTTARGET}/dev/pts
    umount ${CHROOTTARGET}/dev
    umount ${CHROOTTARGET}/sys
    umount ${CHROOTTARGET}/proc
umount ${CHROOTTARGET}/volume1
}

On enregistre (ctrl o) et quitte (ctrl x).

 

Lancer Debian Chroot et s’y placer

Toujours en root, on peut ensuite lancer le script de chroot Debian

/var/packages/debian-chroot/scripts/start-stop-status start

Les commandes sont très simples :

Du coup on peut ensuite s’y placer

/var/packages/debian-chroot/scripts/start-stop-status chroot

 

Optimisation

  1. apt update
  2. apt upgrade
  3. dpkg-reconfigure tzdata
  4. apt install locales
  5. dpkg-reconfigure locales
Installer htop (ou ce que vous voulez)

C’est un Debian classique. On peut donc y faire un apt-get update && apt-get upgrade histoire d’avoir un environnement à jour. Et j’ai ensuite installé htop.

apt-get install htop

Shell

Awesome Shell Awesome

A curated list of awesome command-line frameworks, toolkits, guides and gizmos. Inspired by awesome-php. This awesome collection is also available on Unix-Shell.ZEEF.com.

 █████╗ ██╗    ██╗███████╗███████╗ ██████╗ ███╗   ███╗███████╗
██╔══██╗██║    ██║██╔════╝██╔════╝██╔═══██╗████╗ ████║██╔════╝
███████║██║ █╗ ██║█████╗  ███████╗██║   ██║██╔████╔██║█████╗
██╔══██║██║███╗██║██╔══╝  ╚════██║██║   ██║██║╚██╔╝██║██╔══╝
██║  ██║╚███╔███╔╝███████╗███████║╚██████╔╝██║ ╚═╝ ██║███████╗
╚═╝  ╚═╝ ╚══╝╚══╝ ╚══════╝╚══════╝ ╚═════╝ ╚═╝     ╚═╝╚══════╝
███████╗██╗  ██╗███████╗██╗     ██╗
██╔════╝██║  ██║██╔════╝██║     ██║
███████╗███████║█████╗  ██║     ██║
╚════██║██╔══██║██╔══╝  ██║     ██║
███████║██║  ██║███████╗███████╗███████╗
╚══════╝╚═╝  ╚═╝╚══════╝╚══════╝╚══════╝

 

Shells

Choose your base shell.

Command-Line Productivity

Search, bookmarks, multiplexing, and other tools that make your terminal experience more productive.

Customization

Custom prompts, color themes, etc.

For Developers

Command-line development, version control, and deployment.

System Utilities

Downloading and Serving

Self-hosted, lightweight servers and networking tools written in shell scripts.

Multimedia and File Formats

Tools for handling video and audio files.

Applications

Command line-based applications or command line access to existing services.

Games

All work and no play is a cruddy way to spend your day.

Shell Package Management

Tools for managing multiple shell configurations. For zsh-specific tools, see the Zsh section.

Shell Script Development

Tools for writing, improving, or organizing Bash or other shell scripts

Guides

Other Awesome Lists

Other amazingly awesome lists can be found in awesome-awesome and awesome-awesomeness.

See also

OSX

Nouvelle page

Ubuntu RDP server Xfce4

installation

Ubuntu RDP server Xfce4

RDP XFCE4

après l'installation de Xubuntu, 

installer openSsh,

 

sudo apt install openssh-server

Après avoir modifié le fichier /etc/ssh/sshd_config, enregistrez-le et redémarrez le service sshd afin de prendre en compte les changements. Pour cela, saisissez la commande suivante dans un terminal :

sudo systemctl restart sshd.service

 

installation du serveur XRDP

 

sudo apt-get install xrdp
echo xfce4-session >~/.xsession
sudo nano /etc/xrdp/startwm.sh

Mise en veille de l'écran de l'imac sous linux

 

Modification de GRUB pour la mise en veille automatique :

sudo nano /etc/default/grub

si vous voulez que la commande soit exécutée automatiquement au démarrage, vous pouvez l'ajouter à la ligne de commande GRUB, pour ce faire, nous devons éditer le fichier suivant:

Une fois là-bas, ajoutez simplement consoleblank=60 à GRUB_CMDLINE_DEFAULT, cela devrait ressembler à ceci:

GRUB_CMDLINE_LINUX_DEFAULT="quiet consoleblank=60"

Ensuite, fermez le fichier et enregistrez-le, après cela, lancez simplement sudo update-grub et le tour est joué, chaque fois que vous démarrez, l'écran s'éteint automatiquement toutes les 60 secondes. (encore une fois, si inactif).

sudo update-grub

Et de cette façon (l'ajout de consoleblank au GRUB) fonctionne même à partir de terminaux distants (ssh).

Voilà !

 

Bonus :

Si l'écran se rallume, voici petit alias pour allumer ou éteindre : 

alias screenon="bash -c 'echo 255 > /sys/class/backlight/radeon_bl0/brightness;'"
alias screenoff="bash -c 'echo 0 > /sys/class/backlight/radeon_bl0/brightness;'"

 

Apple File System APFS sur Linux

installation des dépendances :
sudo apt update
sudo apt install fuse libfuse-dev libicu-dev bzip2 libbz2-dev cmake clang git libattr1-dev libbz2-dev libfuse3-dev libz-dev
téléchargement des sources GIT :
git clone https://github.com/sgan81/apfs-fuse.git
cd apfs-fuse
git submodule init
git submodule update
Construction de fuse
mkdir build
cd build
cmake ..
make

Après la compilation, les binaires se trouvent dans le répertoire de construction. Je recommande de copier les outils apfs * dans un répertoire accessible dans le chemin, par exemple / usr / local / bin. Pour les copier, faites simplement ceci :

sudo cp apfs-* /usr/local/bin
Montage de la partition APFS

Nous devons maintenant savoir sur quelle partition de disque se trouve macOS. En utilisant la commande fdisk -l, vous pourrez voir la disposition du disque.

sudo fdisk -l
--- 8>--snipped the loop volumes--<8 ---
Disk /dev/sda: 465.9 GiB, 500277790720 bytes, 977105060 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Disklabel type: gpt
Disk identifier: 6153AD88-FE14-4E88-8D9A-60E8AA465516

Device         Start       End   Sectors   Size Type
/dev/sda1         40    409639    409600   200M EFI System
/dev/sda2     409640 764593231 764183592 364.4G unknown
/dev/sda3  764594176 781570047  16975872   8.1G Microsoft basic data
/dev/sda4  781832192 976842751 195010560    93G Microsoft basic data
--- 8>--snipped the loop volumes--<8 ---

Vous pouvez voir dans mon exemple ci-dessus qu'il existe une partition inconnue de 364,4 Go. Je sais qu'il s'agit de ma partition macOS car je sais que la taille de ma partition macOS est de 365 Go. Cela signifie que l'identifiant de l'appareil est / dev / sda2, c'est donc ce que nous allons monter.

Vérifions-le et voyons si cela fonctionne….

sudo mkdir -p /media/$USERNAME/macos
sudo ./apfs-fuse -o allow_other /dev/sda2 /media/$USERNAME/macos

Si vous souhaitez que votre partition macos se monte automatiquement à chaque fois que vous démarrez votre ordinateur, vous devrez modifier la table de votre système de fichiers (fstab). Pour ce faire, nous devrons créer un lien symbolique vers l'outil de montage apfs, puis éditer le fstab (si vous n'avez pas nano, utilisez vim):

sudo ln -s /usr/local/bin/apfs-fuse /usr/sbin/mount.apfs
sudo nano /etc/fstab

Ajoutez une ligne au bas du fichier (le tout sur une seule ligne) qui dit ceci:

mount.apfs#/dev/sda2    /media/<your username>/macos/    fuse    user,allow_other        0       0

Si vous voulez voir si cela fonctionne immédiatement, démontez simplement le disque (voir la section nettoyage ci-dessous). Tapez ensuite sudo mount -a pour monter le disque à partir du fstab.

Apprendre à connaître votre partition


Lorsque la partition est montée, vous verrez deux répertoires, private-dir et root. La racine du répertoire est celle que vous souhaitez. À l'intérieur se trouve le système de fichiers racine de votre mac. Vous trouverez vos informations dans le dossier "Utilisateurs".

Nettoyage (démontage)


Pour démonter correctement le répertoire macos, vous devez utiliser la commande fusermount:

 

Authentification SSH par clés

Jusqu'à présent, nous avons pris pour habitude d’utiliser comme seul facteur d'authentification le mot de passe. Il faut néanmoins savoir qu'il est également possible d'utiliser un autre facteur, une clé. Cela est parfois préféré car la clé permet de ne pas avoir à retenir systématiquement des mots passe différents. Nous allons ici voir le fonctionnement général de cette méthode d'authentification.

Il est courant sur des serveurs SSH de n’autoriser uniquement l’authentification par clé afin de sécuriser ce protocole. La plupart du temps la génération de la clé se fait sous Linux sans trop de problème étant donné qu’OpenSSH y est nativement présent. Sous Windows toutefois, quelques manipulations sont à effectuer afin de générer et d’envoyer notre clé au serveur.

L'authentification par clés se fait donc via une paire de clés, le client va donc générer une paire de clés, une publique et une privée. Il va bien entendu garder sa clé privée pour lui et envoyer la clé publique au serveur SSH qui la stockera dans un endroit prévu cet effet.

Si vous souhaitez avec plus d'informations sur le système de clé privée/clé publique, je vous invite à lire ce cours écrit par Florian Burnel :

- Clés asymétriques : 

I. Génération de la clé

Étant donné qu'un client SSH peut être un client Linux ou un client Windows, nous allons voir comment générer cette paire de clés sous Linux en ligne de commande, et sous Windows via PuttyGen.

Générer une paire de clés sous Linux

Voyons tout d'abord comment générer une paire de clés sous Linux en ligne de commande. Pour cela, nous allons utiliser la commande "ssh-keygen" :

ssh-keygen

Si aucune option n'est spécifiée, une clé RSA de 2048 bits sera créée, ce qui est acceptable aujourd'hui en termes de sécurité. Si vous souhaitez spécifier une autre taille de clé, vous pouvez utiliser l'option "-b" :

ssh-keygen -b 4096

Par défaut, la clé va être stockée dans le répertoire .ssh/ de l'utilisateur courant (Exemple : /root/.ssh pour l'utilisateur root).

Note : Pour une sécurité correcte de vos communications, il est aujourd'hui recommandé d'utiliser des clés de 4096 bits.

Il va ensuite nous être proposé de saisir une passphrase, je vous recommande d'en mettre une ! Concrètement, nous avons vu qu'une clé pourra être envoyé à plusieurs serveurs pour éviter d'avoir à saisir un mot de passe, en tant que possesseur de la clé privée correspondant à la clé publique envoyée au serveur SSH sur lequel on souhaite se connecter, le serveur nous acceptera directement.

Néanmoins, si un tiers parvient à nous dérober notre clé privée, il arrivera à se connecter aux serveurs sans mot de passe. Ainsi, une passphrase permet la protection de notre clé privée via un mot de passe, ou plutôt une phrase de passe ("passphrase"). L'avantage par rapport à un mot de passe SSH est que vous n'avez qu'un mot de passe à retenir, celui de votre clé privée et pas un mot de passe par serveur SSH.

Une fois créées, vous pourrez donc voir vos clés dans le répertoire ".ssh" de l'utilisateur :

root@itc-serveur-01:~# ls -al .ssh

total 20

drwx------ 2 root root 4096 juin 8 11:15 .

drwx------ 10 root root 4096 juin 8 11:11 ..

-rw------- 1 root root 3247 juin 8 11:18 id_rsa

-rw-r--r-- 1 root root 745 juin 8 11:18 id_rsa.pub

-rw-r--r-- 1 root root 444 avril 23 03:34 known_hosts

Pour rappel, nous nous situons toujours ici sur un Linux client, on remarque l'existence d'un autre fichier "known_hosts", il s'agit ici d'un fichier permettant d'identifier un serveur. Si vous vous connectez en SSH à plusieurs serveurs depuis votre utilisateur ("root" dans mon cas), votre fichier known_host va peu à peu se remplir. Cela entraîne entre autre le fait qu'une demande validation de la clé serveur est demandée à la première connexion du serveur mais pas lors des connexions suivantes.

II. Mettre la clé sur le serveur

Il nous faut maintenant faire l’opération consistant à envoyer notre clé publique sur le serveur afin de pouvoir s’y authentifier, sous Linux, une commande est prévue à cet effet. (“ssh-copy-id” sous Linux). Il nous faut pour cela établir une connexion SSH sur le serveur par mot de passe (une dernière fois) avec la commande "ssh-copy-id" :


Par exemple si je souhaite, en tant que client, ajouter ma clé sur le serveur SSH 192.168.240.132 pour l'utilisateur root :

Notez que par défaut, cette commande va envoyer la clé publique ".ssh/id_rsa.pub". On peut néanmoins, si l'on possède plusieurs paires de clés, spécifier la clé publique à envoyer au serveur, par exemple :

On devra donc saisir une dernière fois le mot de passe SSH de l'utilisateur visé sur le serveur SSH, puis nous aurons quelques messages de validation :

Ici, on voit donc qu'une nouvelle clé a été ajoutée au serveur. Le message qui suit nous le valide :


En effet, maintenant que notre clé publique est présente sur le serveur que nous possédons dans notre répertoire .ssh sa clé privée associée, nous allons pouvoir nous connecter au serveur juste en saisissant la commande suivante :

La passphrase de la clé publique nous sera demandée, puis on sera connecté en SSH à notre serveur.

L'avantage est le suivant : si cette même clé publique est envoyée à 30 autres serveurs, la passphrase sera la même pour toutes les connexions alors qu'il faudra retenir 30 mots de passe différents si vous utilisez la méthode d'authentification habituelle par mot de passe.

Dans le cas où vous êtes sous Windows ou alors que la méthode précédemment proposée n'est pas envisageable, on peut aussi faire cette manipulation manuellement. Il nous suffira alors simplement de copier le contenu de notre clé publique (par défaut ".ssh/id_rsa.pub") dans le fichier ".ssh/authorized_keys" de l'utilisateur du serveur visé.

Nous supposons ici que nous voulons une connexion sur le compte "root" (c’est bien sûr déconseillé dans un cadre réel). Nous allons donc aller dans le dossier "home" de cet utilisateur et créer le dossier ".ssh" s'il n’existe pas déjà :

Le dossier ".ssh" est là où vont se situer les informations relatives aux comptes et aux connexions SSH de l’utilisateur. Nous y créerons le fichier "authorized_keys" s’il n’existe pas. Ce fichier contient toutes les clés publiques que permettent d’établir des connexions avec le serveur et l’utilisateur dans lequel il se trouve (selon le dossier "home" dans lequel il se trouve). Nous allons ensuite dans ce fichier mettre notre clé publique (éviter de mettre les "=== BEGIN===" et "===END===" générés automatiquement par PuttyGen).

Note : Sous Windows, il est possible de récupérer le contenu de la clé publique en l'ayant ouverte avec un simple bloc-notes pour le transférer dans le fichier "authorized_keys".

Il nous faudra ensuite donner les droits les plus restreints à ce fichier par sécurité et pour les exigences d’OpenSSH :


Notre clé est maintenant présente sur le serveur, il nous reste plus qu’à nous connecter pour tester !

Pour les curieux, vous pourrez aller voir sur votre serveur SSH le contenu du fichier "authorized_keys" qui se situe dans le répertoire .ssh de l'utilisateur destinataire. Oui, notez bien qu'une connexion SSH est une autorisation faite sur un utilisateur précis de la machine serveur. On peut avoir les identifiants pour se connecter à une machine Linux en tant qu'utilisateur "mickael" par exemple, mais pas en tant que root, ou inversement. Il s'agit en fait de l'accès à un compte sur une machine plutôt qu'à une machine, simple précision technique. 🙂

Mount Epson Cifs

Mounter dans Fstab au boot la carte mémoire de l'imprimante

editer le fichier /etc/fstab

//printer/MEMORYCARD /media/printer_card cifs vers=1.0,username=guest,password=foo,sec=ntlm,uid=0

Monter un disque local dans une LXC

pct set 103 -mp0 /mnt/NAS,mp=/mnt/NAS

 

installer docker dans LXC 

 

editer le fichier de conf dans /etc/pve/lxc/

#insert docker part below
lxc.apparmor.profile: unconfined
lxc.cgroup.devices.allow: a
lxc.cap.drop:

Configurer Synology sur un sous-domaine NGinx

Depuis quelques temps déjà j’ai décidé de configurer mon NAS Synology sur un sous-domaine. Là vous allez surement me dire que cela ne sert absolument à rien puisque QuickConnect offre cette fonctionnalité. Je vous répondrai donc que je préfère désactiver QuickConnect pour des raisons de sécurité, en effet si une vulnérabilité est découverte sur DSM il suffira à des petits malins de scanner tous les sous-domaines de quickconnet.to et d’essayer d’exploiter cette faille.

 

 

Configurer Synology sur un sous-domaine NGinx

Dans cette exemple je partirai du principe que vous souhaitez accèder à votre NAS depuis l’url https://nas.mon-domaine.tld.

Si vous souhaitez vous connecter en http (ce que je vous déconseille) ajoutez le bloc suivant

location / {
 # check your DSM configuration to redirect to the right port
 proxy_pass http://IP.LOCALE.DU.NAS:5000;
 proxy_redirect http://IP.LOCALE.DU.NAS:5000 https://nas.noobunbox.net;
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 proxy_redirect off;
 proxy_buffering off;}

 

Si vous souhaitez vous connecter en https (conseillé) ajoutez le bloc suivant

location / {
 # check your DSM configuration to redirect to the right port
 proxy_pass https://IP.LOCALE.DU.NAS:5001;
 proxy_redirect https://IP.LOCALE.DU.NAS:5001 https://nas.noobunbox.net;
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 proxy_redirect off;
 proxy_buffering off;}

 

Testez votre configuration puis relancez NGinx

sudo nginx -t
sudo service nginx reload

 

Si vous n’avez pas d’erreur vous pouvez maintenant accéder à Synolgoy sur un sous-domaine via l’url http(s)://nas.votre-domaine.tld

Nextcloud configuration domain

In addition to post above let me disclose requirements to the Nextcloud config.php file specified for reverse bypass. Following rows must be added into the file

  'trusted_domains' => 
  array (
    0 => '192.168.1.4:23456',
    1 => 'allcash.asuscomm.com',
  ),

and following past in the bottom of file before );

  'trusted_proxies' => 
  array (
    0 => '192.168.1.32',
    1 => 'localhost',
    2 => 'allcash.asuscomm.com,
  ),

Also you can override route to direct all requests over DDNS and https:// adding these rows:

  'overwritehost' => 'allcash.asuscomm.com:443',
  'overwriteprotocol' => 'https',
  'overwritewebroot' => '/Nextcloud',

 

  'trusted_domains' => 
  array (
    0 => '192.168.1.85:444',
    1 => 'home.server.com',
  ),
  'overwrite.cli.url' => 'https://home.server.com',
  'overwritehost'     => 'home.server.com',
  'overwriteprotocol' => 'https',
  'overwritewebroot'  => '/nextcloud',

 

Configuration du Reverse Proxy :
 location /nextcloud {
 proxy_pass http://192.168.1.8;
 proxy_redirect off;
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 }

 

Configuration Bonux :

I am running Nextcloud ver 19
This is what works for me in NPM:

In Advanced

    location = /.well-known/carddav {
      return 301 $scheme://$host:$server_port/remote.php/dav;
    }
    location = /.well-known/caldav {
      return 301 $scheme://$host:$server_port/remote.php/dav;
    }

Proxmox Dark Theme

The installation is done via the CLI utility. Run the following commands on the PVE node serving the Web UI:

 

wget https://raw.githubusercontent.com/Weilbyte/PVEDiscordDark/master/PVEDiscordDark.sh
bash PVEDiscordDark.sh install

 

Source : https://github.com/Weilbyte/PVEDiscordDark

Tester votre bande passante avec Iperf

Comment mesurer ma bande passante avec Iperf ?

Iperf est un outil pour mesurer la bande passante et la qualité d’un lien réseau. Ce dernier est délimité par deux machines sur lesquelles est installé Iperf.

Présentation Iperf

La qualité d’un lien est déterminée principalement par les facteurs suivants :
– Latence (temps de réponse ou RTT): peut être mesurée à l’aide d’un Ping.
– La variation de la latence (gigue): peut être mesurée par un test Iperf UDP.
– Perte de paquet: peut être mesurée avec un test Iperf UDP.

Test débit bande passante avec Iperf

Quant à la bande passante, elle est mesurée par des tests TCP.
La bande passante se mesure entre deux points du réseau, un serveur d’un côté et un client de l’autre, la bande passante mesurée correspondra au lien le plus faible.

Où télécharger Iperf ?

Télécharger iperf depuis le site officiel pour votre (ou vos) système d’exploitation : https://iperf.fr/fr/iperf-download.php (Privilégier la version 3)

Quel est le port par défaut de Iperf ?

Par défaut, le client Iperf se connecte au serveur Iperf sur le port TCP 5001 (vérifier les ouvertures Firewall) et la bande passante affichée par Iperf est celle du client au serveur (donc upload depuis le client, pour tester le download il faut inverser les rôles des machines)

Test débit TCP avec Iperf

Coté machine client, voici la commande a saisir :

iperf -c 10.1.1.1
------------------------------------------------------------ 
Client connecting to 10.1.1.1, TCP port 5001 
TCP window size: 16384 Byte (default) 
------------------------------------------------------------ 
[ 3] local 10.6.2.5 port 33453 connected with 10.1.1.1 port 5001 
[ 3]   0.0-10.2 sec   1.26 MBytes   1.05 Mbits/sec

Et coté serveur :

------------------------------------------------------------ 
Server listening on TCP port 5001 
TCP window size: 8.00 KByte (default) 
------------------------------------------------------------ 
[852] local 10.1.1.1 port 5001 connected with 10.6.2.5 port 33453 
[ ID]   Interval          Transfer       Bandwidth 
[852]   0.0-10.6 sec   1.26 MBytes   1.03 Mbits/sec

Test débit UDP avec Iperf

Coté machine client, voici la commande a saisir sur la base suivante (iperf -c Adresse_IP -u -b Bande_Passante ) :

iperf -c 10.1.1.1 -u -b 10M
------------------------------------------------------------ 
Client connecting to 10.1.1.1, UDP port 5001 
Sending 1470 byte datagrams 
UDP buffer size: 108 KByte (default) 
------------------------------------------------------------ 
[ 3] local 10.6.2.5 port 32781 connected with 10.1.1.1 port 5001 
[ 3]   0.0-10.0 sec   11.8 MBytes   9.89 Mbits/sec 
[ 3] Sent 8409 datagrams 
[ 3] Server Report: 
[ 3]   0.0-10.0 sec   11.8 MBytes   9.86 Mbits/sec   2.617 ms   9/ 8409   (0.11%)

Et coté serveur :

iperf -s -u -i 1
------------------------------------------------------------ 
Server listening on UDP port 5001 
Receiving 1470 byte datagrams 
UDP buffer size: 8.00 KByte (default) 
------------------------------------------------------------ 
[904] local 10.1.1.1 port 5001 connected with 10.6.2.5 port 32781 
[ ID]   Interval         Transfer        Bandwidth         Jitter        Lost/Total Datagrams 
[904]   0.0- 1.0 sec   1.17 MBytes   9.84 Mbits/sec   1.830 ms   0/ 837   (0%) 
[904]   1.0- 2.0 sec   1.18 MBytes   9.94 Mbits/sec   1.846 ms   5/ 850   (0.59%) 
[904]   2.0- 3.0 sec   1.19 MBytes   9.98 Mbits/sec   1.802 ms   2/ 851   (0.24%) 
[904]   3.0- 4.0 sec   1.19 MBytes   10.0 Mbits/sec   1.830 ms   0/ 850   (0%) 
[904]   4.0- 5.0 sec   1.19 MBytes   9.98 Mbits/sec   1.846 ms   1/ 850   (0.12%) 
[904]   5.0- 6.0 sec   1.19 MBytes   10.0 Mbits/sec   1.806 ms   0/ 851   (0%) 
[904]   6.0- 7.0 sec   1.06 MBytes   8.87 Mbits/sec   1.803 ms   1/ 755

 

Proxmox redimentioner la partition pve-root

# Check disk space before
df -h

# Delete local-lvm storage in gui

    lvremove /dev/pve/data

    lvresize -l +100%FREE /dev/pve/root

    resize2fs /dev/mapper/pve-root

# Check disk space after

df -f

Raspberry pi zero wifi boot

Mise en place du wifi sans écran 

Sur la carte mémoire dans la partition BOOT ajouter un fichier wpa_supplicant.conf

country=fr
update_config=1
ctrl_interface=/var/run/wpa_supplicant

network={
 scan_ssid=1
 ssid="MyNetworkSSID"
 psk="Pa55w0rd1234"
}

Webcam Stream RTSP serveur

Installation d'un serveur RTSP :

mise en place du docker pour le serveur RTSP

docker run --rm -it --network=host aler9/rtsp-simple-server

une fois le serveur lancé configurer avec ffmpeg l'encodage de la webcam vers le serveur RTSP

/usr/bin/ffmpeg -f v4l2 -i /dev/video0 -s 704x576 -input_format yuyv422 -r 25 -vcodec libx265 -f rtsp rtsp://192.168.1.69:8554/cam

Ajout de la webcam dans Home Assistant :

  - platform: ffmpeg
    input: '-i rtsp://192.168.1.69:8554/cam'
    extra_arguments: '-q:v 2 -r 25'
    name: ImaCam

Ajout de la lovecard :

  - platform: ffmpeg
    input: '-i rtsp://192.168.1.69:8554/cam'
    extra_arguments: '-q:v 1 -r 25 -vf "scale=640:360"'
    name: ImaCam

Script webcam.sh 

docker run -d --name RTSP --network=host aler9/rtsp-simple-server
/usr/bin/ffmpeg -loglevel quiet -stats -f v4l2 -i /dev/video0 -s 704x576 -input_format yuyv422 -r 25 -vcodec libx264 -f rtsp rtsp://192.168.1.69:8554/cam &

Organize tools

installation de organize tools :

pip install organize-tool

Configuration de Organize :

organize config

configuration du fichier confid.yaml

 

   rules:
  #   - folders: ~/Desktop
  #     filters:
  #       - extension:
  #           - jpeg
  #           - jpg
  #     actions:
  #       - move: '~/Desktop/images/'
  #     enabled: true
  #     subfolders: true    
  #   # move incomplete downloads older > 30 days into the trash
  #   - folders:
  #       - ~/Downloads
  #     filters:
  #       - extension:
  #           - crdownload
  #           - part
  #           - download
  #       - lastmodified:
  #           days: 30
  #     actions:
  #       - trash


  #   - folders: ~/
  #     filters:
  #       - extension:
  #           - cbz
  #           - cbr
  #     actions:
  #       - macos_tags: BD (green)
  #       - move: '~/Downloads/bd/'
  #     enabled: true
  #     subfolders: true 

  #   - folders: ~/Downloads
  #     filters:
  #       - extension:
  #           - mkv
  #     actions:
  #       - move: '~/Downloads/Film_A_Encoder/'
  #       - macos_tags: Encodage (blue)
  #       - shell : 'find ~/Downloads/. -type d -empty -print -delete'
  #     enabled: true
  #     subfolders: true


    - folders: 
        - /Volumes/garfieldtux/Documents
        - /Volumes/garfieldtux/Downloads
        - /Volumes/garfieldtux/Desktop
      filters:
        - extension:
            - pdf
      actions:
        - move: '~/Downloads/Pdf/'
        - macos_tags: MacMini (red)
      enabled: true
      subfolders: true      


    - folders: 
        - /Volumes/garfieldtux/Documents
        - /Volumes/garfieldtux/Downloads
        - /Volumes/garfieldtux/Desktop
      filters:
        - extension:
            - png
            - jpeg
            - jpg
      actions:
        - move: '~/Downloads/Images/'
        - macos_tags: MacMini-Images (blue)
        - shell : 
          - 'find /Volumes/garfieldtux/Documents/. -type d -empty -print -delete'
      enabled: true
      subfolders: true

bash script a partir d'un fichier variable

filename='url.txt'
n=1
rm -rf downloadURL.txt
while read line;
do
# for read each line
echo "docker exec -i StreamRip tidal-dl -l $line" >> downloadURL.txt
n=$((n+1))
done < $filename

download='downloadURL.txt'
while read line;
do
n=$((n+1))
done < $download
bash downloadURL.txt

Fstab sshd

mount ssh on device : 


créer un dossier dans /mnt et donner les droits : 

sudo mkdir /mnt/NAS
chmod -R 777 /mnt/NAS


sshfs garfieldtux@192.168.1.45:/ /mnt/NAS -o port=22,idmap=user,gid=1001,allow_other,reconnect,ServerAliveInterval=15,ServerAliveCountMax=3



Samba Docker ipad

Création du docker-compose :

version: '3'
services:
  samba:
   container_name: samba-2to3
   hostname: samba
   image: sixeyed/samba
   volumes:
    - /mnt/2to:/media/2to:z
   ports:
    - "139:139"
    - "445:445"
    - "137:137/udp"
    - "138:138/udp"
   command: samba.sh -p -s "2to;/media/2to;yes;no;yes;all"
   mem_limit: 1g
   restart: always

 

Lancement du docker avec la commande :

docker-compose up -d

connection au docker 

docker exec -it samba-2to3 bash

installation de packages complémentaires :

apt update
apt install -y samba-vfs-modules nano

nano /etc/samba/smb.conf

   # Ipad OS
   vfs objects = catia fruit streams_xattr
   fruit:nfs_aces = no
   ea support = yes
   min protocol = SMB2
   fruit:metadata = stream
   fruit:model = MacSamba
   fruit:veto_appledouble = no
   fruit:posix_rename = yes
   fruit:zero_file_id = yes
   fruit:delete_empty_adfiles = yes
   recycle:keeptree = yes
   recycle:maxsize = 0
   recycle:repository = .deleted
   recycle:versions = yes

   # Security
   client ipc max protocol = SMB3
   client ipc min protocol = SMB2_10
   client max protocol = SMB3
   client min protocol = SMB2_10
   server max protocol = SMB3
   server min protocol = SMB2_10

   # Time Machine
   fruit:delete_empty_adfiles = yes
   fruit:time machine = yes
   fruit:veto_appledouble = no
   fruit:wipe_intentionally_left_blank_rfork = yes

 

Reboot du container ...

 

Installer SSH keychain pour éviter d’avoir à saisir ses passphrases

Lorsqu’on a plusieurs clés SSH et que l’on souhaite éviter de saisir sans arrêt sa passphrase, keychain est la solution. Cet outil permet de gérer les clés SSH (et GPG mais ce n’est pas le sujet) de façon très pratique et sécurisée. Il agit en tant que frontal aux commandes ssh-agent et ssh-add. Contrairement à ssh-agent qui fonctionne sur une session (du login à la déconnexion), keychain conserve un agent fonctionnel tant que le serveur n’a pas été redémarré. Ceci diminue le nombre de fois où vous devrez saisir votre passphrase. De plus, il est facile d’utiliser l’agent dans un script exécuté par cron.

Installation

On utilise le gestionnaire de paquets sous Linux, et sous MacOS on utilisera Homebrew.

# sur un système Linux Debian
apt-get install keychain

# sur un MacOS
brew install keychain

Ensuite, on édite notre fichier ~/.bash_profile pour y ajouter le contenu suivant.

eval `keychain --eval --agents ssh ~/.ssh/neptune_key ~/.ssh/ma_cle_perso`

On indique ici que l’on utilise la commande eval via l’option --eval, ceci permet de ne pas se soucier du SHELL que l’on exécute. On n’utilise que la partie SSH de l’agent --agents ssh et on indique les clés à déverrouiller en argument.

Si vous ne savez pas comment utiliser les clés SSH, vous pouvez aller faire un tour sur l’article créer vos clés publique et privée SSH.

Première ouverture du terminal

La première fois que j’ouvre mon terminal, keychain sait qu’aucune clé SSH n’est chargée, alors il demande les passphrases de chacune des clés. Si deux clés ont la même passphrase, à priori, keychain ne demande la passphrase qu’une seule fois, c’est mon cas dans cet exemple.

 * keychain 2.8.3 ~ http://www.funtoo.org
 * Starting ssh-agent...
 * Adding  2 ssh key(s): /Users/matthieu/.ssh/neptune_key /Users/matthieu/.ssh/ma_cle_perso
Enter passphrase for /Users/matthieu/.ssh/neptune_key:
 * ssh-add: Identities added: /Users/matthieu/.ssh/neptune_key /Users/matthieu/.ssh/ma_cle_perso

Sessions de terminal suivantes

Lorsque j’ouvre d’autres sessions de mon terminal, keychain indique que des clés sont chargées, il ne redemande donc pas les passphrases.

 * keychain 2.8.3 ~ http://www.funtoo.org
 * Found existing ssh-agent: 33235
 * Known ssh key: /Users/matthieu/.ssh/neptune_key
 * Known ssh key: /Users/matthieu/.ssh/ma_cle_perso

Dans le cas où l’agent est exécuté sur un serveur, la passphrase ne sera demandé qu’après un reboot.

Se connecter à un serveur SSH

La connexion se fait de manière classique, on spécifie simplement la clé à utiliser. La passphrase ne doit pas être demandée si la clé privée correspondante est chargée en mémoire.

ssh -i ~/.ssh/neptune_key matthieu@monserveur.local

Lister les clés chargées

Cette commande liste les signatures des clés chargées en mémoire.

keychain --list
SHA256:zz7Jx7tHoUpCdAAMSRXU7nl+zmbYdKeO9oYmQfsUg2s
SHA256:PYdgMViJ7OrcL8bVBV0aAsJkglFS7w9xDazNAMxWd84

Utiliser depuis un script via cron

Si j’ai un script qui est exécuté par cron (le crontab de ma session), et que ce script doit se connecter à un serveur distant, pour faire une sauvegarde par exemple, voici comment utiliser keychain dans le script.

#!/bin/bash

# chemin vers la clé privée à utiliser
SSH_PRIVATE_KEY=~/.ssh/ma_cle_perso
# l'empreinte de la clé
SSH_KEY_FINGERPRINT=`ssh-keygen -E sha256 -lf "$SSH_PRIVATE_KEY" | cut -d\  -f2`

# chargement de keychain en mode silencieux
eval `keychain --quiet --agents ssh --noask --eval "$SSH_PRIVATE_KEY"`

# vérification que la clé privée est bien chargée dans keychain
if keychain --list | grep $SSH_KEY_FINGERPRINT > /dev/null; then

    # on déroule notre script ici.

    # exemple, on veut lister le répertoire distant de monserveur.local
    LS=`ssh -i "$SSH_PRIVATE_KEY" matthieu@monserveur.local ls`
else
    printf "Erreur, clé %s non chargée...\n" "$SSH_PRIVATE_KEY" >&2

    # envoyer un email pour prévenir l'utilisateur, par exemple
fi

L’option --noask indique à keychain qu’il ne doit pas demander la passphrase, étant donné qu’il s’agit d’un script exécuté sans intervention humaine, personne ne sera là pour la saisir si la clé privée est verouillée. On teste ensuite que notre clé est bien chargée en mémoire, pour cela on calcule son empreinte, puis on vérifie si elle est dans la liste des clés chargées.

Décharger les clés en mémoire

Si on doit laisser quelqu’un utiliser son ordinateur quelques minutes, on ne veut pas que cette personne puisse se connecter à un de nos serveurs. On doit donc décharger les clés en mémoire.

keychain --clear

 * keychain 2.8.3 ~ http://www.funtoo.org
 * Found existing ssh-agent: 33235
 * ssh-agent: All identities removed.

Sur un serveur distant, afin d’améliorer la sécurité de keychain, on peut utiliser cette option dans le .bash_profile. Ainsi, on prend pour hypothèse que chaque nouvelle session SSH est considérée comme étant initiée par un intrus, l’intrus doit donc prouver qu’il est un utilisateur légitime en saisissant la passphrase, même si la clé était déjà en mémoire auparavant. Les scripts lancés par cron pourront toujours s’exécuter lorsque vous vous déconnecterez, sauf si un intrus s’est réellement connecté, et dans ce cas, la passphrase n’aura pas été saisie.

Sur un serveur, il est courant de mettre cette ligne dans le fichier ~/.bash_profile.

eval `keychain --eval --clear --agents ssh ~/.ssh/neptune_key ~/.ssh/ma_cle_perso`

Un point sur la sécurité

Utiliser un agent SSH a une incidence sur la sécurité, voici ce qu’il faut savoir.

Concernant ce dernier point, on pourra ajouter ceci dans notre fichier ~/.ssh/config pour interdire l’agent forwarding.