FaciLinux

Sui sistemi GNU/Linux, oltre alle partizioni standard, è possibile definire dei Volumi Logici.
I volumi logici sono dei "contenitori" che possono astrarre dalla dimensione dei singoli dischi collegati al computer e creare volumi che si estendono si più dischi fisici, o in partizioni che sarebbero fisicamente separate di uno stesso disco, o una combinazione delle possibilità sopra descritte. Aggiungendo nuovi dischi a un sistema GNU/Linux è possibile estendere i Volumi Logici già configurati per ottenere nuovo spazio sulle partizioni che ne hanno bisogno.
I volumi logici e la gestione dei volumi logici semplificano la gestione dello spazio su disco.
Se un filesystem che ospita un volume logico ha bisogno di più spazio, può essere allocato al suo volume logico dallo spazio libero nel suo gruppo di volumi e il file system può essere ridimensionato.
Se un disco inizia a guastarsi, un disco sostitutivo può essere registrato come volume fisico con il gruppo di volumi e le estensioni logiche del volume possono essere migrate sul nuovo disco.

NB. Non è mai una best practice usare LVM come sistema di gestione delle rotture hardware di un disco. Lo scopo primario di LVM è quello di gestire dinamicamente lo spazio sui volumi logici. La gestione dei fail di disco viene gestita meglio con altri metodi (ridondanza, RAID, backup, virtualizzazione....).

Definizioni per LVM

Device fisici: I dispositivi fisici sono i dispositivi di archiviazione utilizzati per salvare i dati archiviati in un volume logico. Questi sono dispositivi a blocchi e possono essere partizioni del disco, interi dischi, array RAID o dischi SAN. Un dispositivo deve essere inizializzato come volume fisico LVM per essere utilizzato con LVM. L'intero dispositivo verrà utilizzato come volume fisico.
Volumi fisici (PVs): È necessario inizializzare un dispositivo come volume fisico prima di utilizzarlo in un sistema LVM. Gli strumenti di LVM segmentano i volumi fisici in estensioni fisiche (PE), che sono piccoli blocchi di dati che agiscono come il più piccolo blocco di archiviazione su un volume fisico.
Volume groups (VGs): I volume groups sono pool di archiviazione costituiti da uno o più volumi fisici. Questo è l’equivalente funzionale di un intero disco nella memoria di base. Un PV può essere assegnato solo a un singolo VG. Un VG può essere costituito da spazio inutilizzato e un numero qualsiasi di volumi logici.
Logical Volumes (LVs): I logical volumes vengono creati da estensioni fisiche libere in un VG e forniscono il dispositivo di "memorizzazione" utilizzato da applicazioni, utenti e sistema operativo. I LV sono una collezione di estensioni logiche (LE), che mappano le estensioni fisiche, il più piccolo blocco di archiviazione di un PV. Per impostazione predefinita, ogni LE è mappato su un PE.

I pdf firmati sono entrati nella quotidianità della vita digitale.
Ma come controllare che un pdf sia davvero firmato in Linux?
E di controllare la validità della (o delle) firme apposte?

Un tool compreso nelle poppler-utils permette di verificare la presenza e la validità delle firme apposte sui file pdf.

Installazione

Sistemi RedHat e simili

sudo dnf install poppler-utils

Sistemi Debian e simili

sudo apt install poppler-utils

Utilizzo

pdfsig path_to_pdf_file.pdf

Esempio

$ pdfsig test.pdf 
Digital Signature Info of: test.pdf
Signature #1:
  - Signer Certificate Common Name: NOME COGNOME
  - Signer full Distinguished Name: givenName=NOME,dnQualifier=2020711XXXXX,CN=COGNOME NOME,serialNumber=TINIT-XXXXXXXXXXXXXXXX,SN=COGNOME,C=IT
  - Signing Time: Dec 17 2021 11:00:00
  - Signing Hash Algorithm: SHA-256
  - Signature Type: ETSI.CAdES.detached
  - Signed Ranges: [0 - 490397], [523167 - 530133]
  - Not total document signed
  - Signature Validation: Signature is Valid.
  - Certificate Validation: Certificate issuer is unknown.

Gli utenti di Gnome e KDE possono godere di azioni di crittazione/decrittazione di file direttamente dai rispettivi filemanager, cliccando con il tasto destro del mouse sul file interessato.
Thunar, il FileManager di Xfce, non presenta questa funzionalità integrata ma, grazie alle “Azioni personalizzate”, è possibile estenderne il comportamento; vediamo come fare.

Prerequisiti

Innanzitutto è necessario installare i pacchetti necessari; per Debian/Ubuntu il comando da dare è:

user@debby:~$ sudo apt install seahorse seahorse-nautilus seahorse-daemon

Seahorse è un’interfaccia grafica per gestire le chiavi GPG negli ambienti Gnome/Gtk, mentre del pacchetto seahorse-nautilus ci serve il binario seahorse-tool, come vedremo più avanti.

Azione personalizzata “Cifra..”

• Aprire Thunar e selezionare il menu Modifica > Imposta azioni personalizzate, quindi:
• Premere sul pulsante +
• Nel campo Nome inserire “Cifra…”
• Nel campo Descrizione inserire “cifra con GPG”
• Nel campo Comando inserire “seahorse-tool -e %F”
• Selezionare un’icona a proprio piacimento
• Nel tab “Condizioni di visibilità” selezionare tutte le tipologie di file, escludendo le cartelle e come “Schema del file” mantenere il predefinito “*” Dato che un video vale più di mille parole, ecco qui sotto il riepilogo di quanto fatto:

Azione personalizzata “Decifra..”

• Aprire Thunar e selezionare il menu Modifica > Imposta azioni personalizzate, quindi:
• Premere sul pulsante +
• Nel campo Nome inserire “Decifra…”
• Nel campo Descrizione inserire “decifra con GPG”
• Nel campo Comando inserire “seahorse-tool -d %f”
• Selezionare un’icona a proprio piacimento
• Nel tab “Condizioni di visibilità” selezionare solo “Altri file” e come “Schema del file” impostare “.gpg;.pgp” Anche in questo caso ecco qui sotto il riepilogo a video di quanto fatto:

Normalmente zip è installato.
È possibile eseguire il comando seguente per installare zip e unzip. Se non è già installato, verrà installato ora.

sudo apt install zip unzip

La sintassi per l'utilizzo del comando zip è piuttosto semplice.

zip [option] output_file_name input1 input2

Se l'unico scopo è creare un file zip da un gruppo di file e directory, il comando è il seguente:

zip -r output_file.zip file1 folder1

L'opzione -r attiverà la ricorsione nelle directory e comprimerà anche i contenuti di queste.
L'estensione .zip nei file di output è facoltativa poiché .zip viene aggiunto per impostazione predefinita.

Esempio

$ zip -r test.zip a.txt d/
  adding: a.txt (deflated 34%)
  adding: d/ (stored 0%)
  adding: d/b.txt (deflated 34%)

Riprendiamo l'articolo "Scaricare un mp3 da un video di Youtube da linea di comando".
E se si volesse normalizzare il volume di un file audio scaricato da YouTube?
In realtà l'audio di YouTube viene già in qualche modo normalizzato e l'unica elaborazione con un certo senso sarebbe quella di alzarne il volume ossia una normalizzazione di picco.

Normalizzazione di un file audio

Il processo di normalizzazione dell'audio è l'applicazione di una quantità costante di guadagno a una registrazione audio per portare l'ampiezza a un livello target. Poiché la stessa quantità di guadagno viene applicata all'intera registrazione, il rapporto segnale-rumore e la dinamica relativa rimangono invariati.

Esistono due principali tipi di normalizzazione audio:

• peak normalization o normalizzazione del picco che regola la registrazione in base al livello di segnale più alto presente nella registrazione
• loudness normalization o normalizzazione del volume che regola la registrazione in base al volume percepito

Peak normalization

In questo tipo di normalizzazione il guadagno viene modificato per portare il più alto valore dei singoli campionamenti PCM o il picco del segnale analogico a un dato livello (solitamente 0 dBFS, il livello più alto consentito in un sistema digitale).

Poiché cerca solo il livello più alto, questo tipo di normalizzazione non tiene conto del volume apparente dell'audio.

Loudness normalization

Un altro tipo di normalizzazione si basa sulla misurazione del volume. Il guadagno viene modificato per portare l'ampiezza media a un livello target. Questa media può essere una semplice misurazione della potenza media (come il valore RMS) oppure può essere una misura del volume percepito dall'uomo (come l' EBU R128).

Normalizzazione a riga di comando

Per normalizzare un file audio a riga di comando in Linux possiamo usare ffmpeg-normalize

ffmpeg-normalize

La pagina web di riferimento è https://github.com/slhck/ffmpeg-normalize

Prerequisiti per l'installazione sono: - python 2.7 o 3 - ffmpeg v3.1 o successivi

Per installarlo utilizzare questo comando

pip3 install ffmpeg-normalize

Alcuni esempi

• normalizzare (EBU R128) un file mp3 (è necessario specificare encoder e output)
  ffmpeg-normalize input.mp3 -c:a libmp3lame -b:a 320k -o output.mp3
• normalizzare (peak normalization) un file mp3
  ffmpeg-normalize input.mp3 --normalization-type peak --target-level 0 -c:a libmp3lame -b:a 320k -o output.mp3 ffmpeg-normalize input.mp3 -nt peak -t 0 -c:a libmp3lame -b:a 320k -o output.mp3

Integrazione con youtube-dl

Per integrare la normalizzazione audio con youtube-dl si usa lo switch --exec

Per es. una normalizzazione EBU R128

youtube-dl -i --extract-audio --audio-format mp3 --audio-quality 0 https://www.youtube.com/watch?v=xymjDyGIvQ4 --exec 'ffmpeg-normalize {} -c:a libmp3lame -b:a 320k -o output.mp3 && rm {} && mv output.mp3 {}'

Per es. una normalizzazione peak

youtube-dl -i --extract-audio --audio-format mp3 --audio-quality 0 https://www.youtube.com/watch?v=xymjDyGIvQ4 --exec 'ffmpeg-normalize {} --normalization-type peak --target-level 0 -c:a libmp3lame -b:a 320k -o output.mp3 && rm {} && mv output.mp3 {}'

Come già detto l'audio di YouTube viene già normalizzato e una normalizzazione EBU R128 potrebbe risultare controproducente.

Esempio

Scarichiamo una traccia audio da YouTube e la rinominiamo orig.mp3

youtube-dl -i --extract-audio --audio-format mp3 --audio-quality 0 https://www.youtube.com/watch?v=xymjDyGIvQ4 --exec 'mv {} orig.mp3'

e analizziamone il volume

$ ffmpeg -i orig.mp3 -filter:a volumedetect -f null /dev/null

[Parsed_volumedetect_0 @ 0x55a943b5e2c0] n_samples: 20695734
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] mean_volume: -15.7 dB
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] max_volume: -3.0 dB
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] histogram_2db: 1
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] histogram_3db: 18
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] histogram_4db: 1696
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] histogram_5db: 76023

Ora applichiamo una normalizzazione EBU R128

ffmpeg-normalize orig.mp3 -c:a libmp3lame -b:a 320k -o ebur128.mp3

e poi una peak con volume target 0 db

ffmpeg-normalize orig.mp3 --normalization-type peak --target-level 0 -c:a libmp3lame -b:a 320k -o peak0.mp3

Ora analizziamo il volume dei due file normalizzati

$ ffmpeg -i ebur128.mp3 -filter:a volumedetect -f null /dev/null

[Parsed_volumedetect_0 @ 0x555d11c94780] n_samples: 20695734
[Parsed_volumedetect_0 @ 0x555d11c94780] mean_volume: -24.4 dB
[Parsed_volumedetect_0 @ 0x555d11c94780] max_volume: -10.1 dB
[Parsed_volumedetect_0 @ 0x555d11c94780] histogram_10db: 382
[Parsed_volumedetect_0 @ 0x555d11c94780] histogram_11db: 2813
[Parsed_volumedetect_0 @ 0x555d11c94780] histogram_12db: 6570
[Parsed_volumedetect_0 @ 0x555d11c94780] histogram_13db: 31148

$ ffmpeg -i peak0.mp3 -filter:a volumedetect -f null /dev/null

[Parsed_volumedetect_0 @ 0x5636f8793780] n_samples: 20695734
[Parsed_volumedetect_0 @ 0x5636f8793780] mean_volume: -12.7 dB
[Parsed_volumedetect_0 @ 0x5636f8793780] max_volume: -0.0 dB
[Parsed_volumedetect_0 @ 0x5636f8793780] histogram_0db: 16
[Parsed_volumedetect_0 @ 0x5636f8793780] histogram_1db: 1741
[Parsed_volumedetect_0 @ 0x5636f8793780] histogram_2db: 76022

Come si può vedere l'audio normalizzato EBU R128 risulta più basso di volume dell'originale

Risorse:
https://github.com/slhck/ffmpeg-normalize http://www.audiosonica.com/it/recensioni/post/16881/Loudness_e_sua_normalizzazione

Introduzione

SSH Port Forwarding è un meccanismo che utilizza SSH per il tunneling delle porte tcp da client a server o viceversa. Può essere utilizzato per aggiungere la crittografia alle applicazioni legacy o passare attraverso i firewall.

Local Forwarding

E' utilizzato per inoltrare una connessione indirizzata a una porta del client verso una porta di un server, eventualmente differente dal server ssh utilizzato.

In SSH, il local port forwarding viene impostato con l'opzione -L:

ssh -L 80:intra.example.com:80 gw.example.com

Questo esempio crea un tunnel ssh al server gw.example.com (jump server) e inoltra le connessioni indirizzate alla porta 80 sul computer locale alla porta 80 del server intra.example.com attraverso il tunnel.

Per impostazione predefinita, vengono inoltrate le connessioni indirizzate alla porta 80 di qualsiasi ip del client, quindi altri client potrebbero utilizzare il tunnel. Tuttavia, questo può essere limitato ai fornendo un indirizzo di bind:

ssh -L 127.0.0.1:80:intra.example.com:80 gw.example.com

L'opzione LocalForward nel file di configurazione del client ssh /etc/ssh/ssh_config può essere utilizzata per configurare il bind senza doverlo specificare nel comando

LocalForward  

Specifies that a TCP port on the local machine be forwarded over the secure channel to the specified host and port from the remote machine.
The first argument must be [bind_address:]port and the second argument must be host:port.

Esempio

ssh -f user@personal-server.com -L 2000:personal-server.com:25 -N

Il flag -f imposta ssh in background prima che venga eseguito il comando.
Il flag -L 2000:personal-server.com:25 imposta un Local Forwarding nella forma -L local-port:host:remote-port.
Il flag -N imposta ssh in modo che non venga eseguito alcun comando sul server remoto.

L'NLA (Network Level Authentication) è un flag aggiuntivo e attivo di default nelle recenti installazioni di Windows per garantire maggiore sicurezza nelle connessioni RDP. Supponiamo di avere dei computer nel proprio dominio (MYDOMAIN.ADDS) con RDP attivo solo con autenticazione NLA , come nello screenshot qui riportato: In tali casi, cercare di collegarsi via rdp da linux con i parametri standard porterebbe al fallimento della connessione, perché servono alcune configurazioni aggiuntive e preliminari.

Occorre innanzitutto installare il software necessario per lo scambio di ticket kerberos:

Per debian/ubuntu:

user@linbox~$ sudo apt install krb5-user

Per Fedora:

user@linbox~$  sudo dnf install krb5-workstation

Su sistemi debian like parte una configurazione guidata in fase di installazione del pacchetto krb5-user che chiede i dati relativi al dominio windows da configurare (nome del dominio e FQDN dei domain controller, che nell'esempio qui sotto sono dc01 e dc02); in ogni caso alla fine il file /etc/krb5.conf deve contenere le seguenti voci:

[..]
    [libdefaults]
            default_realm = MYDOMAIN.ADDS
    [..]
    [realms]
            ATENEO.UNIVR.IT = {
                    kdc = dc01.mydomain.adds
                    kdc = dc03.mydomain.adds
                    admin_server = dc01.mydomain.adds
    [..]

Da terminale, come utente non privilegiato, dare il seguente comando

    user@linbox~$ kinit mydomainuser
    Password for mydomainuser@MYDOMAIN.ADDS: 
    user@linbox~$

A questo punto usare normalmente il comando rdesktop. Se la macchina remota accetta connessioni sia con NLA sia senza, verrà privilegiata la connessione sicura NLA.

XfreeRDP

Su Fedora e su altri sistemi viene privilegiato il pacchetto xfreerdp al posto di rdesktop; anche questo software può collegarsi a sistemi rdp con NLA attivo, basta utilizzare i seguenti flag:

xfreerdp /v:remotewindows.mydomain.adds /u:mydomainuser /w:1280 /h:1024 +clipboard

Ticket kerberos

La durata del ticket kerberos creato con il comando kinit è limitata e comunque non sopravvive al riavvio; per conoscere i ticket presenti nella propria sessione usare il comando klist:

user@linbox~$ klist 
    Ticket cache: FILE:/tmp/krb5cc_1000
    Default principal: mydomainuser@MYDOMAIN.ADDS

Valid starting       Expires              Service principal
    20/03/2019 10:48:37  20/03/2019 20:48:37  krbtgt/MYDOMAIN.ADDS@MYDOMAIN.ADDS
        renew until 21/03/2019 10:48:32

Automatizzare il tutto

Volendo, è possibile eseguire uno script all'accesso al proprio desktop linux perché venga automaticamente scambiato un ticket kerberos che sarà poi utile per collegarsi via RDP. Prima di tutto è necessario un file di credenziali (da salvare nella propria Home directory, ad esempio con il nome .cred_mydomain), contenente i seguenti campi:

user=mydomainuser
pass=mypassword
dom=MYDOMAIN.ADDS

Ecco quindi lo script da inserire nel proprio avvio automatico:

#!/bin/bash
#Chiedo un ticket kerberos al dominio mydomain.adds per l'utente myuserdomain
    PASS=$(cat ~/.cred_mydomain |grep pass=|sed s/"pass="//)
    echo -n "$PASS"| kinit 01codiceGIA

Lavorando a riga di comando su una piattaforma Linux, prima o poi, abbiamo bisogno di un aiuto sui comandi della shell. Anche se sono disponibili i comandi di sistema man e whatis, a volte l'aiuto del primo è troppo descrittivo mentre il secondo lo è poco.

Ci sono poi applicazioni di terze parti come cheat, che mostra l'aiuto sul comando della shell anche quando il computer non è connesso a Internet, ma solo su comandi predefiniti.

E' possibile creare un nuovo comando attraverso uno script scritto da Jackson (https://www.mankier.com/explain), che è in grado di spiegare i comandi di shell all'interno della shell bash in modo molto efficace e indovinando quale parte della pagina di aiuto sia la migliore da visualizzare. Il comando si chiama explain.

L'unico requisito è il pacchetto curl. Se non è già installato sul sistema in uso, installarlo con i comandi:

apt-get install curl

Installazione del comando explain in Linux

Bisogna inserire il codice sottostante come nel file ~/.bashrc dell'utente.

# Add this to ~/.bash_profile or ~/.bashrc
explain () {
  if [ "$#" -eq 0 ]; then
    while read  -p "Command: " cmd; do
      curl -Gs "https://www.mankier.com/api/v2/explain/?cols="$(tput cols) --data-urlencode "q=$cmd"
    done
    echo "Bye!"
  elif [ "$#" -eq 1 ]; then
    curl -Gs "https://www.mankier.com/api/v2/explain/?cols="$(tput cols) --data-urlencode "q=$1"
  else
    echo "Usage"
    echo "explain                  interactive mode."
    echo "explain 'cmd -o | ...'   one quoted command to explain it."
  fi
}

# Update 26-03-2015. If using this command gives no output, see if running a simple fetch causes this error:
# $ curl https://www.mankier.com
# curl: (35) Cannot communicate securely with peer: no common encryption algorithm(s).
# If so, try specifying a cipher in the curl commands: curl --ciphers ecdhe_ecdsa_aes_128_sha

https://www.mankier.com/blog/explaining-shell-commands-in-the-shell.html

Dopo aver inserito il codice e averlo salvato, è necessario disconnettersi dalla sessione corrente e accedere nuovamente per rendere effettive le modifiche.

Utilizzo del comando explain

Proviamo alcuni esempi:

1. Cosa fa 'du -h': explain 'du -h'

2. Cosa fa 'tar -zxvf': explain 'tar -zxvf'

3. Confrontare due comandi
   E' possibile andare in modalità interattiva semplicemente digitando il comando explain e poi digitare i comandi uno dopo l'altro per vedere cosa fanno.
   Per uscire dalla modalità interattiva, è sufficiente fare Ctrl + c.

4. E' possibile chiedere cosa fanno più comandi in pipeline: explain 'ls -l | grep -i Desktop'