FaciLinux

Guide Facili per Linux

linux

linux

Firefox e Thunderbird con Wayland

- Posted in linux by

Sia Firefox sia Thunderbird si avviano di default con il collaudato (e per certi versi obsoleto e insicuro) protocollo X11 per la gestione delle finestre.

È però possibile, con versioni recenti dei due prodotti, forzare l'avvio con Wayland, impostando una variabile d'ambiente.

Per firefox il comando da eseguire è:

MOZ_ENABLE_WAYLAND=1 firefox

Per thunderbird, similmente, occorre digitare:

MOZ_ENABLE_WAYLAND=1 thunderbird

È possibile verificare in firefox quale gestore di finestre si sta usando digitando sulla barra degli indirizzi about:support e cercando il valore per la variabile "Protocollo finestra" ("Window protocol" per la versione inglese)

enter image description here

Ultimamente mi è capitato di dover lavorare con file di testo generati da script powershell, in particolare dall'utility Out-File.

Il problema che ho trovato è stato nell'encoding del file generato da Powershell, che nel mio caso era UTF16-Little Endian, un encoding che mal si sposa con le utility di parsing dei file della bash.

Per scoprire con quale encoding ci stiamo confrontando, ci viene in aiuto il comando file; infatti Out-File supporta parecchi encoding in output (https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/out-file?view=powershell-6#parameters), quindi nel caso questa guida è da aggiustare con l'encoding che fa al caso vostro.

Il primo passo, come detto, è scoprire con quale encoding si ha a che fare:

[user@pc ~]$ file -i output_powershell.txt 
output_powershell.txt: text/plain; charset=utf-16le

La desiderata è di ottenere un file in UTF8, con i carriage return di linux, ed ecco come fare:

iconv -f UTF-16LE -t UTF8 output_powershell.txt | dos2unix > converted_output.txt

In caso manchi l'utiliy dos2unix è possibile installarla con il proprio gestore di pacchetti; per Arch ad esempio il comando è

sudo pacman -Su dos2unix

Il nostro file convertito è ora un ottimo candidato per passare sotto altri strumenti di parsing.

Buon lavoro!

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 "Cifra..."

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: enter image description here

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

SSH Port Forwarding

- Posted in linux by

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. SSH Tunneling

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: rdp-NLA 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'

Sfruttando il software illustrato nell'articolo "Scaricare un video di Youtube da linea di comando", è possibile anche ottenere un file audio da un video o una playlist di Youtube.

Il processo è composto da due passi principali:

  1. viene scaricato il media nel formato originario (.webm)
  2. il media viene convertito nel formato desiderato (.mp3)

Per il passo di conversione il software youtube-dl si appoggia a:

  • avconv
  • ffmpeg (consigliato)

Andiamo quindi ad installare il software ffmpeg con il comando

sudo apt-get update
sudo apt-get install ffmpeg
ffmpeg -version

Per convertire in un file mp3 un video di Youtube possiamo utilizzare il comando

youtube-dl -i --extract-audio --audio-format mp3 --audio-quality 0 https://www.youtube.com/watch?v=xymjDyGIvQ4

dove

-i - ignora gli errori
--extract-audio - estrae la traccia audio
--audio-format mp3 - converte l'audio in formato mp3
--audio-quality 0 - imposta la qualità audio migliore

Se vogliamo aggiungere i tag ID3 partendo dai metadati del video di Youtube basta aggiungere lo switch --add-metadata

youtube-dl -i --extract-audio --audio-format mp3 --audio-quality 0 --add-metadata https://www.youtube.com/watch?v=xymjDyGIvQ4

Da Gnome >=3.8 occorre usare gvfs-mime (gio mime per Gnome >= 3.20) per manipolare l'applicazione associata di default per gestire il calendario.

Controllo dell'applicazione predefinita:

Gnome <3.20

gvfs-mime --query text/calendar

Gnome >= 3.20

gio mime text/calendar

Impostare la propria applicazione predefinita (google calendar):

Gnome <3.20

gvfs-mime --set text/calendar google-calendar.desktop

Gnome >= 3.20

gio mime text/calendar google-calendar.desktop

Il file google-calendar.desktop può essere creato in questo modo:

gnome-desktop-item-edit --create-new ~/.local/share/applications/google-calendar.desktop

Completare la finestra di dialogo con il seguente comando per aprire il browser con google calendar:

xdg-open <https://www.google.com/calendar>

Quindi riavviare la gnome-shell o rifare il logon nel proprio ambiente desktop perl'applicazione delle modifiche.

Se si vuole utilizzare il calendario California come predefinito (https://wiki.gnome.org/Apps/California) dare questo comando:

Gnome <3.20

gvfs-mime --set text/calendar california.desktop

Gnome >= 3.20

gio mime  text/calendar california.desktop