Cos'è wireguard e come si configura, lo sappiamo ma mi serviva qualcosa che mi permettesse di fare provisioning e deprovisioning dei certificati in maniera più semplice di quanto già si faccia con i tool disponibili nella userland, wg e wg-quick.

E questo è il motivo principale per cui è nato questo script. Prende come riferimento una configurazione road warrior, il primo scenario di una topologia point-to-site, quella più comune.

Alcune considerazioni

1. Lo script definisce una workdir dove deposita tutte le configurazioni e i certificati. Le precondizioni sono legate alla presenza dei tool userland wg-tools (ovviamente) e di ufw. Vengono comunque verificate nello script.

2. Altra semplificazione è data dal fatto di allocare una /24 come rete wireguard. 254 host per una rete domestica sono più che sufficienti.

3. L'allocazione degli ip viene fatta con un progressivo memorizzato nel file 'ip_renew'. Gli ip dei certificati revocati vengono mantenuti in un file, 'ip_release'. Quando si crea un nuovo certificato, si controlla prima che ci sia un ip da recuperare in ip_release. Se la lista è vuota si ricorre al progressivo.

4. La creazione della configurazione lato server passa da due file di configurazione: una configurazione globale ottenuta tracciando l'evoluzione iniziale in termini di aggiunta o rimozione dei client peer e destinata al rilascio in esecuzione. L'altra contenente la sola configurazione del server e usata unicamente per la rigenerazione della configurazione globale a partire dai peer esistenti.

5. L'operazione di init è propedeutica per addclient, removeclient, rebuild, deploy, share.

Le operazioni a disposizione sono:

• init: inizializza la configurazione di un server wireguard
• addclient: crea il certificato lato client e aggiunge il relativo peer sulla configurazione del server
• removeclient: cancella il certificato lato client e rimuove il relativo peer sulla configurazione del server
• rebuild: rigenera la configurazione del server usando i certificati client esistenti
• deploy: finalizza la configurazione riavviando il servizio con le nuove impostazioni
• share: crea i qr-code per i certificati client da utilizzare nelle configurazioni

Per tutto il resto, i commenti nel codice sono abbastanza esplicativi.

Lo script

#!/bin/bash

# Questo è il file di configurazione globale, i dati sono fittizi.
# Può essere mantenuto nello script o nella home dell'utente 
# (es. $HOME/.config/wg_man.conf) e importato 
# con 'source' all'inizio.
WG_INTERFACE=wg0
PHYSICAL_INTERFACE=eth0
NETWORK="192.168.15.0"
SUBNET_MASK="24"
SERVER_IP_ADDRESS="192.168.15.1"
DNS="1.1.1.1"
LISTEN_PORT="51820"
ENDPOINT=wireguard.nodns.net:51820"
WORKDIR="$HOME/wireguard"



check_dependency() {
    if test -e /usr/sbin/ufw; then
        if test -e /usr/bin/wg; then
            return 0
        else
            return 2
        fi
    else
        return 1
    fi
}



is_init() {
    test -e ${WORKDIR}/conf.d/server_wg.conf && return 0 || return 1
}



# Genera la chiave privata
gen_priv_key() {
    wg genkey | tee ${WORKDIR}/keys/$1_privkey
}



# Genera la pre-shared key
gen_client_psk() {
    # Evita il warning sui permessi del file che devono essere 600
    umask 077
    wg genpsk | tee ${WORKDIR}/psk/$1_psk
}



# Rilascio di un nuovo indirizzo ip. Questa funziona viene invocata da
# addclient().
#
# I primi 3 ottetti li ottengo dalla variabile globale NETWORK.
# L'ultimo ottetto, relativo all'host, lo ricavo dalla lista degli ip
# riutilizzabili ("ip_release").
#
# Se non è vuota, prelevo il primo e lo rimuovo dalla lista. Se è vuota,
# prelevo l'ultimo ottetto da "ip_renew" e lo incremento per il successivo
# assegnamento.
ip_renew() {
    # Selezioni i primi 3 ottetti del network
    SUB_IP=$(echo ${NETWORK}|awk -F "." '{print $1"."$2"."$3}')

    if [[ ! -e ${WORKDIR}/conf.d/ip_release || ! -s ${WORKDIR}/conf.d/ip_release ]]; then
        # Genero il nuovo ip (Incremento di 1 l'ultimo ottetto)
        IP=$(cat ${WORKDIR}/conf.d/ip_renew)
        echo $((++IP)) > ${WORKDIR}/conf.d/ip_renew

        # Restituisco i 3 ottetti + il quarto
        #echo -n ${SUB_IP};cat ${WORKDIR}/conf.d/ip_renew
    else
        IP=$(head -n 1 ${WORKDIR}/conf.d/ip_release)
        sed -i "1d" ${WORKDIR}/conf.d/ip_release
    fi
    echo -n ${SUB_IP}"."${IP}
}



# Riallocazione di un indirizzo ip. Questa funzione viene invocata da
# removeclient().
# Aggiungo l'ultimo ottetto alla lista degli ip riallocabili.
# @par 1: ultimo ottetto.
ip_release() {
    echo $1|cut -d"." -f 4 >> ${WORKDIR}/conf.d/ip_release
}



# Aggiunge il nuovo peer al file di configurazione del server
# @par 1: CLIENT_PUBLIC_KEY
# @par 2: CLIENT_PSK
# @par 3: CLIENT_IP_ADDRESS
# @par 4: CLIENT_NAME
add_peer_to_server() {
    cat >> ${WORKDIR}/conf.d/server_wg.conf << EOF
# $4
[Peer]
PublicKey = $1
PresharedKey = $2
AllowedIPs = $3/32
PersistentKeepalive = 25

EOF
}



# Inizializza la configurazione del server wireguard.
#
# Questa operazione può essere fatta una sola volta a meno che non si
# cancelli tutta la workdir.
#
# Verranno creati due file  di configurazione: server_wg.conf e 
# server_wg_raw.conf
#
# Il primo conterrà la configurazione completa del server e dei peer,
# verrà aggiornato ad ogni modifica dei client (aggiunta o rimozione) e
# verrà usato per il deploy della configurazione.
#
# Il secondo conterrà la configurazione del solo server e verrà usato
# solo per rigenerare il primo file di configurazione.
init() {
    # Controllo che wireguard sia almeno abilitato
    echo -n "Inserire la password di Amministratore: "; read -s PASSWORD
    sudo -k
    if echo $PASSWORD|sudo -S echo "got a root" > /dev/null; then
        if ! sudo systemctl is-enabled --quiet wg-quick@${WG_INTERFACE}; then
            echo -en "\nAttivazione servizio wireguard... "
            #sudo systemctl enable --quiet wg-quick@${WG_INTERFACE}
            echo "fatto."
        fi
        sudo -k 
        
        #Verifico che queste cartelle esistano. Se lo sono, non faccio nulla, se no le creo.
        echo -n "Creazione workdir... "
        [[ ! -e ${WORKDIR}/conf.d || ! -e ${WORKDIR}/psk  || ! -e ${WORKDIR}/keys ]] \
            && { mkdir -p ${WORKDIR}/{conf.d,keys,psk}; } \
            || { echo "inizializzazione già effettuata."; exit; }
        echo "fatto."
        
        # Genero la chiave privata per il server
        echo -n "Creazione chiave private del server..."
        SERVER_PRIV_KEY=$(gen_priv_key "server_wg")
        echo "fatto."

        # Genero il file di configurazione
        echo -n "Inizializzazione del server... "
        cat > ${WORKDIR}/conf.d/server_wg.conf << EOF
[Interface]
Address = ${SERVER_IP_ADDRESS}/${SUBNET_MASK}
# SaveConfig = true

PreUp = ufw route allow in on ${WG_INTERFACE} out on ${PHYSICAL_INTERFACE} log from ${NETWORK}/${SUBNET_MASK} to 0.0.0.0/0
PostDown = ufw route delete allow in on ${WG_INTERFACE} out on ${PHYSICAL_INTERFACE} log from ${NETWORK}/${SUBNET_MASK} to 0.0.0.0/0

# IP masquerading
PreUp = iptables -t nat -A POSTROUTING -o ${PHYSICAL_INTERFACE} -s ${NETWORK}/${SUBNET_MASK} -j MASQUERADE
PostDown = iptables -t nat -D POSTROUTING -o ${PHYSICAL_INTERFACE} -s ${NETWORK}/${SUBNET_MASK} -j MASQUERADE

# IP filtering
PreUp = ufw allow in on ${PHYSICAL_INTERFACE} log to 0.0.0.0/0 app Wireguard
PostDown = ufw delete allow in on ${PHYSICAL_INTERFACE} log to 0.0.0.0/0 app Wireguard

ListenPort = ${LISTEN_PORT}
PrivateKey = ${SERVER_PRIV_KEY}

EOF
        echo "fatto."
        cp ${WORKDIR}/conf.d/server_wg.conf ${WORKDIR}/conf.d/server_wg_raw.conf
        # Inizializza l'erogatore di ip
        echo 1 > ${WORKDIR}/conf.d/ip_renew
    else
        echo "Sono necessarie le credenziali di amministrazione per eseguire questo comando."
        exit 1
    fi
}



# Genera un certificato per il client composto da:
# * chiave privata del client
# * chiave pre-condivisa
# * client ip
# * chiave pubblica del server
# * nome simbolico del client
#
# Dopo la creazione e il salvataggio in <WORKDIR>/conf.d, verrà aggiunto
# il relativo peer nella configurazione del server (server_wg.conf).
# @par_1 @par_2 @par_3...: lista di nomi relativi ai certificati da creare.
add_client() {
    if is_init; then
        # Se non c'è alcun input, esco.
        if [[ $# -lt 1 ]]; then
            echo -e "Devi inserire almeno un nome."
            exit 1
        else
            # Per ogni nome presente in input, creo una configurazione 
            # client e l'aggiungo alla configurazione del server.
            for CLIENT_NAME in "$@"; do
                echo -n "Creazione certificato per il client \"${CLIENT_NAME}\"... "
                
                # Controllo se la configurazione esista già discriminando
                # in base al nome del file.
                if [[ -e ${WORKDIR}/conf.d/client_${CLIENT_NAME}.conf ]]; then
                    echo "già esistente."
                else
                    # Creo la configurazione del client
                    CLIENT_PRIV_KEY=$(gen_priv_key ${CLIENT_NAME})
                    CLIENT_PUBLIC_KEY=$(echo ${CLIENT_PRIV_KEY} | wg pubkey)
                    CLIENT_PSK=$(gen_client_psk ${CLIENT_NAME})
                    CLIENT_IP_ADDRESS=$(ip_renew)
                    SERVER_PUBLIC_KEY=$(grep PrivateKey ${WORKDIR}/conf.d/server_wg.conf | cut -d " " -f 3 | tr -d " " | wg pubkey)
                    CLIENT_NAME_UPPER=$(echo ${CLIENT_NAME} | tr '[:lower:]' '[:upper:]')
                    cat > ${WORKDIR}/conf.d/client_${CLIENT_NAME}.conf << EOF
    # ${CLIENT_NAME_UPPER}
    [Interface]
    Address = ${CLIENT_IP_ADDRESS}/${SUBNET_MASK}
    DNS = ${DNS}
    PrivateKey = ${CLIENT_PRIV_KEY}

    [Peer]
    PublicKey = ${SERVER_PUBLIC_KEY}
    PresharedKey = ${CLIENT_PSK}
    AllowedIPs = 0.0.0.0/0
    Endpoint = ${ENDPOINT}
    PersistentKeepalive = 25
EOF
                    echo "fatto."
                    echo -n "Aggiunta peer \"${CLIENT_NAME}\" al file di configurazione del server... "
                    
                    # Aggiungo il peer alla configurazione del server.
                    add_peer_to_server ${CLIENT_PUBLIC_KEY} ${CLIENT_PSK} ${CLIENT_IP_ADDRESS} ${CLIENT_NAME_UPPER}
                    echo -e "fatto.\n"                
                fi
            done
        fi
    else
        echo "È necessario inizializzare il server con 'wg_init.sh init'."
        echo "L'operazione richiesta non sarà completata"
    fi
}



# Rimuove file di configurazioni, chiavi e pre-shared key realtive a file
# dati in input.
# Rimuove inoltre il peer dal file di configurazione server_wg.conf.
# @par_1 @par_2 @par_3...: lista di nomi relativi ai certificati da rimuovere.
remove_client() {
    if is_init; then
        if [[ $# -lt 1 ]]; then
            echo -e "Devi inserire almeno un nome."
            exit 1
        else
            for CLIENT_NAME in "$@"; do
                echo -n "Rimozione client \"${CLIENT_NAME}\"... "
                if [[ ! -e ${WORKDIR}/conf.d/client_${CLIENT_NAME}.conf ]]; then
                    echo "non esistente."
                else
                    # Estraggo l'ultimo ottetto dell'ip del client.
                    IP=$(grep "Address" ${WORKDIR}/conf.d/client_${CLIENT_NAME}.conf|cut -d " " -f 3|tr -d " "|cut -d "/" -f 1)
                    
                    # Lo inserisco nella lista degli ip riallocabili.
                    ip_release ${IP}
                    
                    # Cancello file di configurazione, chiave e psk del client.
                    rm ${WORKDIR}/conf.d/client_${CLIENT_NAME}.conf ${WORKDIR}/keys/${CLIENT_NAME}_privkey ${WORKDIR}/psk/${CLIENT_NAME}_psk
                    echo "terminata con successo."
                    echo -n "Rimozione peer \"${CLIENT_NAME}\" dal file di configurazione del server... "
                    
                    # Rimuovo il peer dalla configurazione del server.
                    CLIENT_NAME_UPPER=$(echo ${CLIENT_NAME} | tr '[:lower:]' '[:upper:]')
                    sed -i "/# ${CLIENT_NAME_UPPER}/,+6d" ${WORKDIR}/conf.d/server_wg.conf
                    echo -e "terminata con successo.\n"   
                fi
            done
        fi
    else
        echo "È necessario inizializzare il server con 'wg_init.sh init'."
        echo "L'operazione richiesta non sarà completata"
    fi
}



rebuild() {
    if is_init; then
        # Rigenero il file di configurazione del server da server_wg_raw.conf.
        echo -n "Ripristino del file di configurazione del server... "
        cat ${WORKDIR}/conf.d/server_wg_raw.conf > ${WORKDIR}/conf.d/server_wg.conf
        echo "fatto."
        
        # Per ogni file di configurazione client, aggiungo il relativo peer
        # nel file di configurazione server_wg.conf.
        for FILE_CONF in ${WORKDIR}/conf.d/client_*.conf; do
            CLIENT_PUBLIC_KEY=$(grep "PrivateKey" ${FILE_CONF}|cut -d " " -f 3|tr -d " " | wg pubkey)
            CLIENT_PSK=$(grep "PresharedKey" ${FILE_CONF}|cut -d " " -f 3|tr -d " ")
            CLIENT_IP_ADDRESS=$(grep "Address" ${FILE_CONF}|cut -d " " -f 3|tr -d " "|cut -d "/" -f 1)
            CLIENT_NAME_UPPER=$(grep "#" ${FILE_CONF} | cut -d " " -f 2)
            echo -n "Aggiunta peer \"$(echo ${CLIENT_NAME_UPPER} | tr '[:upper:]' '[:lower:]')\"... "
            add_peer_to_server ${CLIENT_PUBLIC_KEY} ${CLIENT_PSK} ${CLIENT_IP_ADDRESS} ${CLIENT_NAME_UPPER}
            echo -e "fatto."
        done
    else
        echo "È necessario inizializzare il server con 'wg_init.sh init'."
        echo "L'operazione richiesta non sarà completata"
    fi
}



# Avvia il server wireguard con la nuova configurazione
deploy() {
    if is_init; then
        echo -n "Inserire la password di Amministratore: "; read -s PASSWORD
        sudo -k
        if echo $PASSWORD|sudo -S echo "got a root" > /dev/null; then
   
            # Stoppo il servizio wireguard
            echo -ne "\nStop wireguard... "
            sudo systemctl stop wg-quick@${WG_INTERFACE}
            echo "fatto."
            
            # Aggiorno la configurazione
            echo -n "Copia della nuova configurazione... "
            sudo cp ${WORKDIR}/conf.d/server_wg.conf /etc/wireguard/${WG_INTERFACE}
            echo "fatto."
            
            # Riavvio il servizio wireguard
            echo -n "Riavvio wireguard... "
            sudo systemctl start wg-quick@${WG_INTERFACE}
            echo "fatto."
            
            # Revoco i privilegi di amministrazione
            sudo -k
        else
            echo "Sono necessarie le credenziali di amministrazione per eseguire questo comando."
            exit 1
        fi
    else
        echo "È necessario inizializzare il server con 'wg_init.sh init'."
        echo "L'operazione richiesta non sarà completata"
    fi
}



# Crea il qr-code della configurazione del client nella cartella corrente.
share() {
    if is_init; then
        if [[ $# -lt 1 ]]; then
            echo -e "Devi inserire almeno un nome."
            exit 1
        else
            for CLIENT_NAME in "$@"; do
                echo -n "Creazione qr-code per il client \"${CLIENT_NAME}\"... "
                qrencode -r ${WORKDIR}/conf.d/client_${CLIENT_NAME}.conf -o qrcode_client_${CLIENT_NAME}.jpg
                echo "fatto."
            done
        fi
    else
        echo "È necessario inizializzare il server con 'wg_init.sh init'."
        echo "L'operazione richiesta non sarà completata"
    fi
}



help() {

[[ $1 != "" && $1 != "help" ]] && echo -e "Comando inesistente."

    cat<<EOF
Usa come: ./wg_man.sh [command] ARG
dove:
    [command]
        init                     : Inizializza la configurazione del server.
        addclient <lista nomi>   : Aggiunge i client indicati in <lista nomi>.
        removeclient <lista nomi>: Rimuove i client indicati in <lista nomi>.
        rebuild                  : Ricostruisce il file di configurazione
                                   del server partendo dalle configurazioni
                                   di tutti i client registrati.
        deploy                   : Riavvia il server wireguard con l'ultima
                                   configurazione disponibile.
        share <lista nomi>       : Genera i qr-code relativi ai client indicati in <lista nomi>.
        help                     : Stampa questa pagina di help.

ESEMPI:
    INiZIALIZZA IL SERVER WIREGUARD
    wg_man.sh init

    AGGIUNGE I CLIENT 'macbook_pro', 'mobile'
    wg_man.sh addclient macbook_pro mobile

    RIMUOVE I CLIENT 'iphone_luca', 'workstation'
    wg_man.sh removeclient iphone_luca workstation

    RICOSTRUISCE LA CONFIGURAZIONE DEL SERVER WIREGUARD
    wg_man.sh rebuild
    
    ATTIVA LA NUOVA CONFIGURAZIONE
    wg_man.sh deploy

    GENERA I QRCODE PER 'pc_ufficio', 'laptop'
    wg_man.sh share pc_ufficio laptop
EOF
}



main() {
    case $1 in
        init         ) init ;;
        addclient    ) shift; add_client "$@" ;;
        removeclient ) shift; remove_client "$@" ;;
        rebuild      ) rebuild ;;
        deploy       ) deploy ;;
        share        ) shift; share "$@" ;;
        *            ) help ;;
    esac
}



check_dependency
case $? in
    "0" ) main $* ;;
    "1" ) echo -e "UFW non presente. Installare UFW."; exit 1 ;;
    "2" ) echo -e "wireguard-tools non presenti. È necessario installarli."; exit 1 ;;
esac

#bash #wireguard #psk #chiavi #certificati #crittografia

Piccolo script scritto di fretta per avere sotto mano la versione fresh di Libreoffice su Fedora invece che quella pacchettizzata. Un giorno ci ritornerò come ho fatto con “Gestione TOTP in bash“

#!/bin/bash
#download.documentfoundation.org

usage() {
cat<<EOF
Usa come: ./libreoffice-update.sh [options]
dove:
    [options]
        -u verifica l esistenza di una nuova versione
        -i <numero_version> installa la nuova versione di libreoffice
        -h stampa questa pagina di help

ESEMPI:
    VERIFICA CHE UN AGGIORNAMENTO SIA DISPONIBILE
    libreoffice-update -u

    INSTALLA L ULTIMA VERSIONE DI LIBREOFFICE
    libreoffice-update -i

    VISUALIZZA l HELP
    libreoffice-update -h
EOF
}

download_lo_suite() {
    echo -n "Inizio download LibreOffice $VERSION... "
    [[ $(aria2c https://download.documentfoundation.org/libreoffice/stable/"$VERSION"/rpm/x86_64/LibreOffice_"$VERSION"_Linux_x86-64_rpm.tar.gz | grep ERROR) ]] \
        && { echo "*** Impossibile scaricare LibreOffice $VERSION ***"; ERROR_CODE=64; return ${ERROR_CODE}; } \
        || echo "Fatto."

    echo -n "Inizio download LibreOfficeLangack $VERSION... "
    [[ $(aria2c https://download.documentfoundation.org/libreoffice/stable/"$VERSION"/rpm/x86_64/LibreOffice_"$VERSION"_Linux_x86-64_rpm_langpack_it.tar.gz | grep ERROR) ]] \
        && { echo "*** Impossibile scaricare LibreOfficelangPack $VERSION ***"; ERROR_CODE=65; return ${ERROR_CODE}; } \
        || echo "Fatto."

    echo -n "Inizio download LibreOfficeHelppack $VERSION... "
    [[ $(aria2c https://download.documentfoundation.org/libreoffice/stable/"$VERSION"/rpm/x86_64/LibreOffice_"$VERSION"_Linux_x86-64_rpm_helppack_it.tar.gz | grep ERROR) ]] \
        && { echo "*** Impossibile scaricare LibreOfficeHelppack $VERSION ***"; ERROR_CODE=66; return ${ERROR_CODE}; } \
        || echo -e "Fatto.\n"
}


decomprimi_lo_suite() {
    echo -n "Decompressione tar LibreOffice $VERSION in corso... "
    [[ $(tar -xzf LibreOffice_"$VERSION"_Linux_x86-64_rpm.tar.gz 2>/dev/null) ]] \
        && { echo "*** Impossibile decomprimere il tar di LibreOffice $VERSION ***"; ERROR_CODE=67; return ${ERROR_CODE}; } \
        || echo "Fatto."

    echo -n "Decompressione tar LibreOfficeLangpack $VERSION in corso... "
    [[ $(tar -xzf LibreOffice_"$VERSION"_Linux_x86-64_rpm_langpack_it.tar.gz  2>/dev/null) ]] \
        && { echo "*** Impossibile decomprimere il tar di LibreOfficeLangpack $VERSION ***"; ERROR_CODE=68; return ${ERROR_CODE}; } \
        || echo "Fatto."

    echo -n "Decompressione tar LibreOfficeHelppack $VERSION in corso... "
    [[ $(tar -xzf LibreOffice_"$VERSION"_Linux_x86-64_rpm_helppack_it.tar.gz 2>/dev/null) ]] \
        && { echo "*** Impossibile decomprimere il tar di LibreOfficeHelppack $VERSION ***"; ERROR_CODE=69; return ${ERROR_CODE}; } \
        || echo -e "Fatto.\n"
        
    [[ $? -gt 0 ]] && return $?
}

install_lo_suite() {
    cd $(tar -tf LibreOffice_"$VERSION"_Linux_x86-64_rpm.tar.gz|head -1) && sudo dnf -y localinstall RPMS/* && cd ..
    cd $(tar -tf LibreOffice_"$VERSION"_Linux_x86-64_rpm_langpack_it.tar.gz|head -1) && sudo dnf -y localinstall RPMS/* && cd ..
    cd $(tar -tf LibreOffice_"$VERSION"_Linux_x86-64_rpm_helppack_it.tar.gz|head -1) && sudo dnf -y localinstall RPMS/* && cd $HOME
}

is_lo_upgradeable() {
    VERSIONE_INSTALLATA=$(dnf info installed|grep -A 2 libreoffice|grep Version|head -n 1|cut -d ":" -f 2|cut -c 2-7)
    VERSIONE_ONLINE=$(curl https://it.libreoffice.org/download/download/ 2>/dev/null|grep "version="|head -n 1|cut -d "&" -f 2|cut -d "=" -f 2)
    echo "VERSIONE INSTALLATA: $VERSIONE_INSTALLATA"
    echo "VERSIONE ONLINE:     $VERSIONE_ONLINE"
    [[ ${VERSIONE_INSTALLATA} == ${VERSIONE_ONLINE} ]] \
        && echo -e "Nessun aggiornamento disponibile." \
        || echo -e "Una nuova versione è disponibile.\n"
}

cleanup() {
    rm -r /tmp/tmp.*
}

remove_old_lo_suite() {
    sudo dnf -y remove libreoffice*
}

install() {
    VERSION=$1
    cd $(mktemp -d)
    ! download_lo_suite && { cleanup; exit ${ERROR_CODE}; }
    ! decomprimi_lo_suite && { cleanup; exit ${ERROR_CODE}; }
    ! remove_old_lo_suite && { cleanup; exit ${ERROR_CODE}; }
    install_lo_suite && cleanup || exit ${ERROR_CODE}?
}

noparam() {
    clear;
    usage
    exit 0
}

main() {
    while getopts "ui:h" opt; do
        case $opt in
            u ) is_lo_upgradeable ;;
            i ) install $OPTARG ;;
            h ) clear;usage; exit;;
            * ) clear;echo -e "[ERRORE] Opzione non valida.";usage; exit 1;;
        esac
    done
    shift $(($OPTIND - 1))
}

[[ $# -eq 0 ]] && noparam || main $*

#bash #libreoffice #scripting

In una giornata in cui avevo un po’ di tempo da investire, ho ripreso la versione 2 dello script “Generazione OTP via bash”, e ho deciso di renderlo un po’ più flessibile introducendo una logica crud. Anzi, il termine corretto dovrebbe essere “dave” (Delete, Add, View, Edit). Che altro aggiungere?

• Il file è ancora un insieme di coppie chiave-valore (nome account e chiave privata).
• Il separatore è il simbolo “:”. Ma può essere configurato cambiando il valore della variabile “DELIMITER”.
• Lo script è discretamente commentato così, in futuro, riuscirò a ricordare perché ho fatto quello che ho fatto (tipo “Memento”).
• Le opzioni di gpg per la cifratura/decifratura del file sono configurabili nello script modificando il valore delle variabili “GPG_ENC_OPTIONS” e “GPG_DEC_OPTIONS”.
• L’uso di getopts, mi rendo conto, è solo un esercizio di stile. Non è molto utile per come l’ho usato, visto che ogni optarg corrisponde ad un’operazione autoconclusiva.
• Ero partito per rimpiazzare ogni costrutto if con combinazioni di lista and / lista or ma le condizioni risultavano talmente complesse da rendere il codice francamente molto più incomprensibile di adesso. In alternativa avrei potuto delegare l’esecuzione delle condizioni ad un insieme di funzioni con una stratificazione tale da ricadere nel punto precedente: offuscamento permanente del codice che va a vanificare l’intenzione iniziale di semplificare il codice e renderlo più leggibile.

#!/usr/local/bin/bash


init() {
    # CODICI D'ERRORE
    DECRYPT_ERR=64
    INVALID_OPTION_ERR=65
    INVALID_ACCOUNT_ERR=66
    ACCOUNT_NOT_FOUND_ERR=67
    ACCOUNT_NAME_EMPTY_ERR=68
    ACCOUNT_EXISTS_ERR=69
    INVALID_KEY_ERR=70

    # Colorscheme
    LIGHT_GREEN='\033[1;32m'
    LIGHT_RED='\033[1;31m'
    NC='\033[0m'

    # Path del file cifrato contentente i codici 2FA
    KEYS_2FA_FILE="<path/file_enc.gpg>"

    # Separatore delle coppie chiave-valore
    DELIMITER=":"

    # path gpg e opzioni di cifratura/decifratura
    GPG_TTY=$(tty)
    export GPG_TTY

    #GPG_COMMAND="/usr/local/bin/gpg"
    GPG_ENC_OPTIONS="--yes -c --s2k-cipher-algo aes256 --s2k-digest-algo sha512 --s2k-mode 3 --s2k-count 260000 - "
    GPG_DEC_OPTIONS='-d'

    # Caratteri consentiti nel nome account
    PATTERN='^[a-zA-Z0-9._-]+$';

    # Su MacOS è disponibile "pbcopy", su *nix "xsel"
    case "$(sysctl hw.targettype 2>/dev/null)" in
        "")
            CLIPBOARD="xsel -bi"
            GPG_COMMAND="/usr/bin/gpg";;
         *)
            CLIPBOARD="pbcopy"
            GPG_COMMAND="/usr/local/bin/gpg";;
    esac

    # Decifra e carica in ram il contenuto del file cifrato.
    echo "Decifratura del file degli account in corso..."
    KEYS_2FA_FILE_DEC=$(${GPG_COMMAND} ${GPG_DEC_OPTIONS} "${KEYS_2FA_FILE}" 2>/dev/null)

    # Se la password non è corretta, restituisce un errore.
    [[ -z "${KEYS_2FA_FILE_DEC}" ]] && { err_msg "${DECRYPT_ERR}" 1; }
    info_msg "Fatto."
}


get_account() {
    ACCOUNT_STDIO="$1"

    # Check nome account vuoto
    [[ -z "${ACCOUNT_STDIO}" ]] && return "${ACCOUNT_NAME_EMPTY_ERR}"

    # Check caratteri invalidi nel nome account
    [[ ! "${ACCOUNT_STDIO}" =~ $PATTERN ]] && return "${INVALID_ACCOUNT_ERR}"

    # Estrae l'elemento contenente l'id dato in input
    OTP_LINE=$(echo "${KEYS_2FA_FILE_DEC}" | grep "${ACCOUNT_STDIO}:")

    # Se l'account non esiste, restituisce un errore
    [[ -z "${OTP_LINE}" ]] && return "${ACCOUNT_NOT_FOUND_ERR}"

    ACCOUNT=$(echo $OTP_LINE | cut -d"${DELIMITER}" -f 1)
    KEY=$(echo $OTP_LINE | cut -d"${DELIMITER}" -f 2)
}


crypt_account_file() {
    ACCOUNT_FILE="$1"
    echo -e "\nCifratura del file degli account in corso..."
    ${GPG_COMMAND} -o "$KEYS_2FA_FILE" ${GPG_ENC_OPTIONS} <<< $(echo -e "${ACCOUNT_FILE}")
}


no_param() {
    clear
    help
    exit 0
}


# Visualizza messaggi di errore su stdio
err_msg() {
    if [[ $# -ne 2 ]]; then
        echo -r"${LIGHT_RED}[DEBUG] [err_msg] Numero di parametri non corretto.${NC}."; exit 1
    else
        case $1 in
            "${DECRYPT_ERR}"            ) echo -e "${LIGHT_RED}[ERRORE] Impossibile decriptare il file.${NC}";;
            "${INVALID_OPTION_ERR}"     ) echo -e "${LIGHT_RED}[ERRORE] Opzione \"$OPTARG\" non valida.${NC}";;
            "${INVALID_ACCOUNT_ERR}"    ) echo -e "${LIGHT_RED}[ERRORE] Rilevati caratteri non consentiti.\nI caratteri ammessi sono: [a-z][A-Z][0-9].-_${NC}";;
            "${ACCOUNT_NOT_FOUND_ERR}"  ) echo -e "${LIGHT_RED}[ERRORE] Account non trovato${NC}";;
            "${ACCOUNT_NAME_EMPTY_ERR}" ) echo -e "${LIGHT_RED}[ERRORE] Nome account vuoto.${NC}";;
            "${ACCOUNT_EXISTS_ERR}"     ) echo -e "${LIGHT_RED}[ERRORE] Nome account già esistente${NC}";;
            "${INVALID_KEY_ERR}"        ) echo -e "${LIGHT_RED}[ERRORE] Chiave privata nulla o non corretta.\nLa chiave privata deve essere base32.\n${NC}";;
            *                           ) echo -e "${LIGHT_RED}[ERRORE] Errore generico.${NC}";;
        esac

        [[ $2 -eq 1 ]] && exit $2;
    fi
}


# Visualizza messaggi info su stdio
info_msg() {
    echo -e "${LIGHT_GREEN}$1${NC}"
}


continue_msg() {
    case $1 in
        "insert"    ) ACTION="creato";;
        "edit"      ) ACTION="modificato";;
        "delete"    ) ACTION="cancellato";;
    esac

    echo -n "L'account \"${ACCOUNT}\" sta per essere ${ACTION}. Vuoi continuare? [y|N]: "; read ANSWER;
}


continue_yn() {
        ANSWER="0"
        while [[ "${ANSWER}" != "y" ]]; do
            [[ -z "${ANSWER}" || "${ANSWER}" == "N" ]] && { echo "Operazione annullata"; exit; }
            [[ "${ANSWER}" != "y" || "${ANSWER}" != "N" ]] && continue_msg "$1"
        done
}


totp() {
    # Se la'ccount non esiste o è invalido, esco con errore
    get_account "$1"; RET_CODE=$?
    case "${RET_CODE}" in
        "${ACCOUNT_NOT_FOUND_ERR}"  ) err_msg "${ACCOUNT_NOT_FOUND_ERR}" 1;;
        "${INVALID_ACCOUNT_ERR}"    ) err_msg "${INVALID_ACCOUNT_ERR}" 1;;
    esac

    echo -e "\nCopia OTP nella clipboard..."
    # Calcola l'otp e lo trasferisce nella clipboard con xsel
    oathtool --totp -b "${KEY}" | $CLIPBOARD
    info_msg "Fatto."
    exit
}


insert() {
    # Se l'account non esiste o è invalido, esco con errore
    get_account "$1"; RET_CODE=$?
    case "${RET_CODE}" in
        0                           ) err_msg "${ACCOUNT_EXISTS_ERR}" 1;;
        "${INVALID_ACCOUNT_ERR}"    ) err_msg "${INVALID_ACCOUNT_ERR}" 1;;
    esac

    ACCOUNT="$1"

    # Inserisci la chiave
    echo -en "Nuovo account: ${ACCOUNT}\nInserisci la nuova chiave privata: "; read KEY
    while [[ -z "${KEY}" || ! $(echo ${KEY} | oathtool -b - 2>/dev/null) ]]; do
        err_msg "${INVALID_KEY_ERR}" 0
        echo -n "Inserisci la chiave privata: "; read KEY
    done

    info_msg "\nNuovo account:        ${ACCOUNT}\nNuova chiave privata: ${KEY}"
    continue_yn "insert"

    # Appendo il nuovo record nel file degli account
    KEYS_2FA_FILE_DEC+="\n${ACCOUNT}${DELIMITER}${KEY}"
    info_msg "L'account \"${ACCOUNT}\" è stato creato con successo."

    # Cifratura del file degli account
    crypt_account_file "${KEYS_2FA_FILE_DEC}"
    info_msg "Fatto."
    exit
}


edit() {
    # Se la'ccount non esiste o è invalido, esco con errore
    get_account "$1"; RET_CODE=$?
    case "${RET_CODE}" in
        "${ACCOUNT_NOT_FOUND_ERR}"  ) err_msg "${ACCOUNT_NOT_FOUND_ERR}" 1;;
        "${INVALID_ACCOUNT_ERR}"    ) err_msg "${INVALID_ACCOUNT_ERR}" 1;;
    esac

    # Faccio una copia dell'account per un eventuale ripristino durante
    # la fase di input
    ACCOUNT_TEMP="${ACCOUNT}"
    ACCOUNT_MOD="${ACCOUNT}"

    # Inserisco il nuovo nome account.
    # 1. Se è vuoto: è la conferma dell'account inserito all'inizio e proseguo
    # 2. Se il nome è invalido: sollevo un'eccezione e reitero
    # 3. Se il nome è valido:
    #    a. Se è un nome nuovo: acquisisco il nuovo nome, recupero nome e chiave dell'account di partenza e proseguo
    #    b. Sè è lo stesso nome di partenza: è la conferma dell'account iniziale e proseguo
    #    c. Se è un altro nome esistente o invalido: come il punto 2.
    while true; do
        echo
        echo -en "Account: ${ACCOUNT}\nInserisci nuovo nome account: "; read ACCOUNT_MOD;
        get_account "${ACCOUNT_MOD}"; RET_CODE=$?
        case "${RET_CODE}" in
            # Punto 1.
            "${ACCOUNT_NAME_EMPTY_ERR}" ) ACCOUNT_MOD="${ACCOUNT}"; break;;
            # Punto 2
            "${INVALID_ACCOUNT_ERR}"    ) err_msg "${INVALID_ACCOUNT_ERR}" 0;;
            # Punto 3a.
            "${ACCOUNT_NOT_FOUND_ERR}"  ) get_account "${ACCOUNT_TEMP}"; break;;
            # Punti 3b e 3c, rispettivamente
            0                           ) [[ "${ACCOUNT_MOD}" == "${ACCOUNT_TEMP}" ]] && break \
                                                                                 || { get_account "${ACCOUNT_TEMP}"; err_msg "${ACCOUNT_EXISTS_ERR}" 0; };;
        esac
    done

    [[ "${ACCOUNT}" != "${ACCOUNT_MOD}" && ! -z "${ACCOUNT_MOD}" ]] && msg="\nL'account \"${ACCOUNT}\" è stato modificato in \"${ACCOUNT_MOD}\"." \
                                                                    || msg="\nNessuna modifica rilevata.\n"
    info_msg "${msg}"

    # Modifica la chiave privata
    KEY_MOD="${KEY}"
    echo

    while true; do
        echo -en "Chiave privata: ${KEY}\nInserisci la nuova chiave privata: "; read KEY_MOD
        if [[ -z $KEY_MOD ]]; then
            KEY_MOD="${KEY}"; break
        elif [[ ! $(echo "${KEY_MOD}" | oathtool -b - 2>/dev/null) ]]; then
            err_msg "${INVALID_KEY_ERR}" 0; KEY_MOD="${KEY}"
        else
            break
        fi
    done

    # Se c'è stata almeno una modifica (account/key), sovrascrivo il record. Altrimenti esco senza fare nulla.
    if [[ "${ACCOUNT}" != "${ACCOUNT_MOD}" || "${KEY}" != "${KEY_MOD}" ]]; then
        # Conferma modifica

        info_msg "\nAccount:              ${ACCOUNT}\nChiave privata:       ${KEY}\nNuovo account:        ${ACCOUNT_MOD}\nNuova chiave privata: ${KEY_MOD}\n"
        continue_yn "edit"

        # Modifica del file degli account
        KEYS_2FA_FILE_DEC_TEMP=$(sed "s/${ACCOUNT}${DELIMITER}${KEY}/${ACCOUNT_MOD}${DELIMITER}${KEY_MOD}/" <<< "${KEYS_2FA_FILE_DEC}")
        info_msg "L'account \"${ACCOUNT}\" è stato modificato con successo."

        # Cifratura del file degli account
        crypt_account_file "${KEYS_2FA_FILE_DEC_TEMP}"
    else
        info_msg "Nessuna modifica rilevata."
    fi
    info_msg "Fatto."
}


delete() {
    if get_account "$1"; then
        # Conferma eliminazione
        info_msg "\nAccount:              ${ACCOUNT}\nChiave privata:       ${KEY}\n"
        continue_yn "delete"

        # Cancellazione account
        KEYS_2FA_FILE_DEC_TEMP=$(sed "/$ACCOUNT/d" <<< "${KEYS_2FA_FILE_DEC}")
        info_msg "L'account \"$ACCOUNT\" è stato eliminato."

        # Cifratura del nuovo file degli account
        crypt_account_file "${KEYS_2FA_FILE_DEC_TEMP}"
        info_msg "Fatto."
    else
        err_msg "${ACCOUNT_NOT_FOUND_ERR}" 1
    fi
}


list() {
    echo
    while read LINE; do
        cut -d"${DELIMITER}" -f 1 <<< "${LINE}"
    done <<< "${KEYS_2FA_FILE_DEC}"
}


help() {
cat<<EOF
Usa come: ./totp.sh [options] ARG
dove:
    [options]
        -l restituisce la lista degli account.
        -t <nome_account> restituisce l'otp per quell'account.
        -i <nome_account> inserisce un nuovo account.
        -d <nome_account> cancella <nome_account>.
        -e <nome_account> modifica <nome_account>.
        -h stampa questa pagina di help.

ESEMPI:
    RESTITUISCE LA LISTA DEGLI ACCOUNT
    totp.sh -l

    INSERISCE UN ACCOUNT
    totp.sh -i dropbox

    CANCELLA UN ACCOUNT
    totp.sh -d megaupload

    MODIFICA UN ACCOUNT
    totp.sh -e paypal

    GENERA OTP
    totp.sh -t firefoxsync
EOF
}


main() {
    init
    while getopts "lt:i:e:d:" opt; do
        case $opt in
            l ) list ;;
            t ) totp $OPTARG ;;
            i ) insert $OPTARG ;;
            e ) edit $OPTARG ;;
            d ) delete $OPTARG ;;
            * ) clear;err_msg "${INVALID_OPTION_ERR}" 1;;
        esac
    done
    shift $(($OPTIND - 1))
}

[[ $# -eq 0 || $# -eq 1 && "$1" == "-h" ]] && no_param || main $*

#bash #totp #cryptography #gpg #scripting

Android Debug Bridge, adb, permette di connettere device ad un pc. Oltre che consentire l'accesso all'intero file system del device invece che della sola parte multimediale, mette a disposizione un set di comandi per la manipolazione di:

• rete
• installazione app
• filesystem
• scripting
• debugging

Do per scontata la presenza degli android tools e la conoscenza di come si attivi la modalità sviluppatore per accedere alla parte di debugging.

Modalità di connessione

Posso collegare il device all'host in 3 modi: usb, tcpip, wireless (da android 11 in poi).

Probabilmente la modalità usb è quella più sicura trattandosi di un collegamento fisico, ma il wireless, per me, è una gran comodità.

USB

Giusto per dovere di cronaca. Chiunque possegga un telefono android, credo l'abbia fatto almeno una volta.

1. Collegare il telefono alla porta usb del pc.
2. Abilitare il Debug Usb dalle opzioni sviluppatore.
3. Autorizzare l'host sul device.

Come avviene l'autorizzazione

L'autorizzazione dell'host consiste in un'autenticazione con chiave pubblica. Sull'host, in ~/.android (almeno sui sistemi *nix) è presente:

• una coppia di chiavi pubblica e privata
• il file adb_known_hosts.pb.

Quando si avvia il server adb sull'host per la prima volta, viene generata una coppia di chiavi. La chiave pubblica dell'host viene inviata al device durante la prima connessione, ed è quella che deve essere accettata dal device affinché sia possibile accedervi via adb. Quando si effettua una “revoca delle autorizzazioni” sul device, si cancellano le chiavi pubbliche che devono essere riaccettate se avviene una nuova connessione.

Il file adb_known_hosts.pb contiene gli identificativi dei device connessi all'host via adb.

Se si vuole rigenerare la coppia di chiavi per ruotarle, si può ricorrere al seguente comando:

adb keygen adbkey

che produce una chiave privata rsa-2048 e la corrispondente chiave pubblica.

Le chiavi così generate andranno posizionate in ~/.android e il daemon adb andrà riavviato.

adb kill-server
adb start-server

TCPIP

L'abilitazione della modalità tcpip richiede il preventivo collegamento fisico all'host in modalità usb. Una volta abilitata, questa rimarrà la modalità di collegamento predefinita finché il daemon sarà attivo.

• Collegare il device in modalità debug usb (vedi USB).
• adb tcpip <port> per abilitare la modalità tcpip su una porta. Verrà avviato un altro daemon in ascolto sulla porta .
• recuperare l'ip del device sulla nostra rete locale (normalmente disponibile su Info telefono / Info stato).
• adb connect <ip>:<port>.
• Staccare il device dalla porta usb. Per le successive operazioni di connessione | disconnessione basta il solito:
• adb connect | disconnect <ip>:<port>, connette | disconnette il device.

Wi-Fi

A differenza della modalità tcpip, non richiede un collegamento fisico all'host perché il pairing viene fatto sia sulla rete a cui ci si assesta, sia sull'host attraverso un PIN. Inoltre ogni connessione avviene su una porta randomica.

• La prima volta:
  • abilitare Debug wireless da Opzioni per sviluppatori.
  • Confermare il pairing alla rete.
  • Andare su Debug wireless, accoppiare un nuovo dispositivo e prendere nota dell'ip, della porta e del PIN.
  • Sull'host adb pair <ip>:<port>, per associare il device all'host attraverso il PIN segnato in precedenza.
• Ad ogni connessione:
  • adb connect | disconnect <ip>:<port> per connettere | disconnettere il device.

Una volta che l'host è autorizzato, basterà effettuare una connect alla porta opportuna anche se il server venisse riavviato.

Usare ADB su un host con dispositivi multipli connessi

Quando più device sono connessi ad un host, per lanciare un comando, dobbiamo sapere come selezionare il device corretto via adb. Ci vengono in aiuto due flag, “-s” e “-t”, che selezionano il device rispettivamente in base al seriale o al “transport id”, informazione che ottengo con adb devices. Faccio l'esempio di 3 device, due connessi via usb e uno connesso via wireless (da Android 11 in poi) su cui vogliamo aprire una shell.

adb devices
List of devices attached
141*****             device
52004************    device
<ip>:<porta>         device

Per avere l'info sul transport id è necessaria la modalità “verbose”

adb devices -l

List of devices attached
141*****             device usb:1-3 product:<serial_product_1> model:<model_name_1> device:<device_name_1> transport_id:10

52004************    device usb:1-2 product:<serial_product_2> model:<model_name_2> device:<device_name_2> transport_id:8

<ip>:<porta>         device product:<serial_product_3> model:<model_name_3> device:<device_name_3> transport_id:11

da cui: adb -s 141***** shell o adb -t 10 shell, per aprire una shell sul primo device.

adb -s 52004************ shell o adb -t 8 shell, per aprire una shell sul secondo device.

adb -s <ip>:<porta> shell o adb -t 11 shell, per aprire una shell sul terzo device.

Riferimenti:

• https://developer.android.com/tools/adb

#adb #android #bash

Faccio un po’ d’ordine rispetto all’ultimo post.

brew ha “fattorizzato” la fase di aggiornamento.

Non sono più disponibili le istruzioni esplicite di gestione dei cask perché l’update / upgrade ora comprende formule e cask rendendo il tutto molto più coerente. Quindi:

• brew update : Aggiorna il database interno sulle nuove versioni disponibili per formule e cask
• brew upgrade : Aggiorna formule e cask
• brew upgrade --cask : Aggiorna solo i cask

Per quel che riguarda i cask, sappiamo che l’upgrade di brew prende in considerazione solo i cask che non dispongono della funzionalità di autoupdate o che hanno latest come versione.

Per forzare l’aggiornameno dei cask residui basta una singola istruzione:

brew upgrade --cask -n --greedy|tail -n +2|grep -v latest|cut -d " " -f 1|xargs brew upgrade --cask

• Aggiorna esplicitamente tutti i cask con autoupdate (esclusi i “latest”)

#brew #bash #macos #scripting

Sul Mac trovo comodo usare brew . Permette di gestire tante applicazioni con un gestore di pacchetti.

• Nota positiva: in generale, funziona bene, per quello che lo conosco.
• Nota negativa: in contraddizione col punto precedente, l’upgrade dei cask mi pare faccia cilecca ^[1]

In passato, eseguivo l’update / upgrade delle formule e l’upgrade dei cask. Col tempo, la gestione dei cask è diventata più omogenea con quella delle formule ma l’update / upgrade mi rimane ancora un po’ misterioso.

Eseguendo un brew update && brew upgrade, soprattutto dalle ultime versioni (dalla 3.0.7 in poi di sicuro), l’update sembra fare il suo lavoro e trova un po’ di cask aggiornare.

Càpita però che l’upgrade ne aggiorni qualcuno, un brew upgrade --cask ne aggiorni qualcun altro (senza raggiungere il totale iniziale) e provando a rifare l’update subito dopo (e anche l’upgrade) il sistema rimane intatto come se fosse up-to-date.

Agendo puntualmente sul cask invece, l’aggiornamento parte eccome. Come se fossero rimaste in cache delle informazioni discordanti sullo stato reale dell’applicazione e su quello potenziale.

Ho cercato un po’ in rete, sembra un problema comune.

Al solito, è partito lo script.

#!/usr/bin/bash
echo -e '\E[37;44m'"\033[1m***************\033[0m"
echo -e '\E[37;44m'"\033[1m* brew update *\033[0m"
echo -e '\E[37;44m'"\033[1m***************\033[0m"
brew update
 
 
echo -e "\n"
echo -e '\E[37;44m'"\033[1m****************\033[0m"
echo -e '\E[37;44m'"\033[1m* brew upgrade *\033[0m"
echo -e '\E[37;44m'"\033[1m****************\033[0m"
if [[ -z $(brew upgrade) ]]; then
    echo -e "Nothing."
fi
 
 
echo -e "\n"
echo -e '\E[37;44m'"\033[1m***********************\033[0m"
echo -e '\E[37;44m'"\033[1m* brew upgrade --cask *\033[0m"
echo -e '\E[37;44m'"\033[1m***********************\033[0m"
for c in $(brew list --cask -1); do
    printf %-30s "$c"
    info=$(brew info --cask "$c")
     
    current_ver=$(head -n1 <<< "$info" | cut -d " " -f 2)
    installed_ver=$(head -n3 <<< "$info" | tail -n1 | cut -d"/" -f 6 | cut -d " " -f 1)
     
    if [ "$installed_ver" != "$current_ver" ]; then
        answer=""
        while [[ -z $answer ]]; do
         
        read -r -p "$c installed version is '$installed_ver', but the current version is '$current_ver'. Do you want to upgrade $c? ["$'\e[;32;1mYES\e[0m/no] ' answer
 
        case ${answer,,} in
            yes|"")
                brew upgrade --cask --force $c
                answer="yes"
                ;;
            no)
                echo "Installation of $c $current_ver skipped"
                ;;
            *)
                answer=""
                ;;
            esac
        done
    else
        printf ": \033[38;5;70mis up-to-date (ver. $installed_ver)\033[0m\n"
    fi
done
 
 
echo -e "\n"
echo -e '\E[37;44m'"\033[1m****************\033[0m"
echo -e '\E[37;44m'"\033[1m* brew cleanup *\033[0m"
echo -e '\E[37;44m'"\033[1m****************\033[0m"
if [[ -z $(brew cleanup) ]]; then
    echo -e "Nothing."
fi
 
 
echo -e "\n"
echo -e '\E[37;44m'"\033[1m***************\033[0m"
echo -e '\E[37;44m'"\033[1m* brew doctor *\033[0m"
echo -e '\E[37;44m'"\033[1m***************\033[0m"
brew doctor

Al di là dello zucchero sintattico, la soluzione è stata brutale e ruvida: un ciclo sulla lista dei cask con il force sull’upgrade (righe 21-50). La cosa ancora più singolare è che in questo modo vengono aggiornati dei cask che non risultavano nemmeno nel primo upgrade.

Sicuramente si potrà fare anche meglio. ^[2]

1. Ho provato a usare brew livecheck per recuperare più elegantemente le info nelle righe 25-26 ma mi dà qualche problema, ogni tanto va in crash. Ho optato per la scansione secca della lista.
2. Non so bene come lavori brew outdated, se soffra degli stessi problemi degli altri comandi (sospetto di sì ma devo verificare).
3. In realtà basterebbe una sola riga:

brew list --cask|xargs brew upgrade --cask

solo che così non riesco a controllare il numero di versione causando un aggiornamento quasi sempre inutile per tutti quei cask che hanno come versione “latest” (come Cisco Webex)

Lo script fa il suo lavoro ma ho trovato anche questa alternativa (decisamente più elegante): https://github.com/buo/homebrew-cask-upgrade

Un comando esterno, brew cu nella sua forma compatta, che sostituisce ed estende le funzionalità di brew upgrade. Avendo aggiornato da poco, non l’ho ancora visto all’opera.

Edit (31/03/2021):

In realtà, leggendo anche il man e il log dell’applicazione su stdout, ho capito che il funzionamento di brew è corretto.

upgrade e outadated prendono in esame solo i cask che non dispongono di autoupdate.

==> Casks with ‘auto_updates’ or ‘version :latest’ will not be upgraded; pass --greedy to upgrade them.

Un atteggiamento prudenziale che è facile comprendere. Laddove sia disponibile una funzionalità di autoupdate, si preferisce che sia l’applicazione stessa a gestire questo aspetto, lasciando a brew upgrade --cask (e ai file .rb di configurazione del cask, di conseguenza) la gestione di tutto il resto.

In questo modo, i cask che possono autoaggiornarsi, possono farlo in autonomia appena possibile, senza dipendere dalla modifica necessaria al file di configurazione che innesca l’aggiornamento.

Volendo bypassare questo comportamento, si può ricorrere all’opzione --greedy che forza l’upgrade sia per le app con autoupdate che per quelle che gestiscono il numero di versione con l’orrendo “latest”

Quindi:

brew outdated --greedy --cask

e

brew upgrade --greedy --cask

permettono rispettivamente:

• di elencare tutti i cask che necessitano di un aggiornamento, compresi quelli con autoupdate e con versione “latest”
• di forzare l’aggiornamento dei cask di cui sopra

Forzando l’aggiornamento in questo modo, si potrà andare incontro ad un disallineamento, tipo:

• sul sistema può essere presente una versione più aggiornata di quanto non dica il file di configurazione
• affidandosi all’autoupdate, l’opzione --greedy continuerà a rilevare comunque un aggiornamento da fare (ecco perché brew preferisce ignorare questo tipo di applicazioni)

N.B. brew cu funziona benissimo permettendo di gestire separatamente sia l’autoupdate che il latest

Note all’articolo

#brew #bash #macos #scripting

Questo script permette di scaricare le puntate intere di Ciao Belli o DeeJay Time da Deejay Reload perché le ascolto offline praticamente da sempre. In alternativa, è possibile ascoltare direttamente il live streaming delle trasmissioni. I pattern che uso per lo scraping sono molto elementari e sono ovviamente sensibili ai minimi cambiamenti che avvengono sulle pagine di Radio Deejay.

La versione attuale è attiva da un paio di mesi a questa parte perché il pattern prima era leggermente diverso. E più si va indietro, più le differenze aumentano. Per dirne una, lo streaming hls è molto recente, Prima di esso, il reload era disponibile solo in mp3. Questa sarà la 15^a versione dello script 🙂

Il download restituisce un file in mp3 o aac. Quest'ultimo ottenuto in maniera rudimentale estrando i singoli segmenti aac ottenuti dall'analisi della playlist hls e ricombinati attraverso ffmpeg.

In linea di principio sarebbe possibile estendere lo script aumentando la scelta delle trasmissioni disponibili e, volendo migliorare l'interazione con l'utente sacrificando l'automatismo e la “scriptabilità”, dotandolo di un menù.

help() {
    echo "$1"
    echo
    echo "Usa come: wget_deejay.sh <YYYYMMDD> <prg> <format>"
    echo "Es. wget_deejay.sh 2019062 cb mp3  [Scarica Ciao Belli in mp3]"
    echo "    wget_deejay.sh 2019062 djt aac [Scarica Deejay Time in aac]"
    echo "    wget_deejay.sh live            [Deejay Live]"
}



download() {
    if [[ ${FMT} == "mp3" || -z ${FMT} ]]; then
        if ! check_and_download_mp3; then
            return 1
        fi
    elif [[ ${FMT} == "aac" ]]; then
        if ! check_aac; then
            return 1
        else
            download_aac
        fi
    else
        help "Formato non corretto."
        return 1
    fi
}



check_and_download_mp3() {
    #if ! wget -q https://${HOST}/${DATA_URL}/episodes/${TITLE}/${DATA}.mp3 -O "${PRG}_${DATA}.mp3"; then
    echo https://${HOST}/${DATA_URL}/episodes/${TITLE}/${TITLE}-${DATA}.mp3
    if ! wget https://${HOST}/${DATA_URL}/episodes/${TITLE}/${TITLE}-${DATA}.mp3 -O "${PRG}_${DATA}.mp3"; then
        help "Puntata di ${TITLE} del ${ERR_DATA}, non trovata."
        return 1
    fi
}



check_aac() {
    #if ! wget -qO- https://${HOST}/"${DATA_URL}"/episodes/${TITLE}/hls-010000/hls-010000.m3u8 1>/dev/null; then
    echo https://${HOST}/"${DATA_URL}"/episodes/${TITLE}/hls-"${TITLE}"-"${DATA}"/hls-"${TITLE}"-"${DATA}".m3u8
    if ! wget -qO- https://${HOST}/"${DATA_URL}"/episodes/${TITLE}/hls-"${TITLE}"-"${DATA}"/hls-"${TITLE}"-"${DATA}".m3u8 1>/dev/null; then
        help "Puntata di ${TITLE} del ${ERR_DATA}, non trovata."
        return 1
    else
        return 0
    fi
}


download_aac() {
    echo -n "Scarico la traccia............. "
    ffmpeg -i https://${HOST}/"${DATA_URL}"/episodes/${TITLE}/hls-"${TITLE}"-"${DATA}"/hls-"${TITLE}"-"${DATA}".m3u8 -c copy $HOME/deejay/"${PRG}_${DATA}".aac 2>/dev/null
    echo "Fatto."

}


DATA=$1
PRG=$2
FMT=$3


if [[ $1 == "live" ]]; then
    mpv http://radiodeejay-lh.akamaihd.net/i/RadioDeejay_Live_1@189857/master.m3u8
else
    case "${PRG}" in
        "cb")
            HOST="media.deejay.it"
            TITLE="ciao_belli"
            ;;
        "djt")
            HOST="media.deejay.it"
            TITLE="deejay_time"

            ;;
        "live")
            TITLE="live"
            ;;
        *)
            help "Programma Deejay mancante o non esistente."
            exit 1
    esac


    DATA_URL="${DATA:0:4}/${DATA:4:2}/${DATA:6:2}"
    ERR_DATA="${DATA:6:2}-${DATA:4:2}-${DATA:0:4}"

    if [[ -z ${DATA:0:4} ]]; then help "Manca l'anno."; exit 1
    elif [[ -z ${DATA:4:2} ]]; then help "Manca il mese."; exit 1
    elif [[ -z ${DATA:6:2} ]]; then help "Manca il giorno."; exit 1
    elif ! download; then exit 1
    fi
fi

#bash #shell #scripting

Per buona parte del mio tempo sul pc apro una shell, per cui trovo comodo spostare il meno possibile le mani dalla tastiera. Usando spesso 2FA, ho pensato ad un modo per avere un OTP usando bash. Il tool che fa al caso mio è oathtool che, per i miei scopi, è sufficiente invocare in questo modo:

oathtool --totp -b <key>

dove <key> è una stringa base32 bella lunga.

Chiaramente non voglio doverla scrivere ogni volta, nè voglio lasciarla in chiaro. Occorre che:

1. la chiave sia cifrata e decifrata solamente quando occorre;
2. l'output non arrivi su stdout per non doverlo copiare a mia volta (e lasciarlo comunque visibile)

Al punto 1. si risponde con gpg o openssl.

Al punto 2. si risponde con xsel (Gnu/Linux) o pbcopy (MacOS) che trasferiscono l'output di un comando nella clipboard.

oathtool --totp -b <<< $(gpg -q --decrypt --pinentry-mode loopback <file_chiave_cifrato>) | xsel -bi

E veniamo quindi alla:

Versione 1

#!/bin/bash

# Path del file cifrato contentente la chiave # supponiamo sia di google
KEY_2FA_FILE="$1"

oathtool --totp -b <<< $(gpg -q --decrypt --pinentry-mode loopback "${KEY_2FA_FILE}") | xsel -bi

Non è nemmeno uno script. Potrebbe essere direttamente un alias.

VANTAGGI

• Estremamente compatto
• Si sfrutta nativamente l'autocomplete col TAB per i file da dare all'input
• L'univocità dei nomi è garantita dal file system

SVANTAGGI

• Crea un file per ogni codice e, alla lunga potrebbe generare confusione
• Necessità di creare una password di cifratura per ogni file (potenzialmente tutte diverse)

Versione 2

Mi occorre quindi un file nome-valore con separatore. Ad es. il simbolo “:”

account_1:JD88EIDIKJDKMDI3IEJDMDKJKDJKDKPA
account_2:JDNBLASPUQRIEKM89478JMFKOVJDOQKJ
account_3:OIJWGDVLOIQ94KDKSUD9KSLWOER9W3ODF
account_4:MVNMWIQPQYSKGPRIGNFG24KFG9E49RPWQ
    
    ...
    
account_n:IWPQSLNCGK49TOWODIR483IRIWOFOPIQO

Nello script, la variabile KEYS_2FA_FILE memorizza il full path del file cifrato dei codici, mentre l'account deve essere fornito in input. In caso contrario, viene restituita la lista degli account disponibili.

Se l'account è valido, il file viene decifrato e viene estratto il corrispondente codice che viene memorizzato direttamente nella clipboard.

#!/usr/bin/bash

# Path del file cifrato contentente i codici 2FA
KEYS_2FA_FILE="<path>/keys_2fa.gpg"

# Acquisisce il nome account
ACCOUNT=$1

# Decifra e carica in ram il contenuto del file cifrato
KEYS_2FA_FILE_DEC=$(gpg --decrypt  --pinentry-mode loopback  "${KEYS_2FA_FILE}" 2>/dev/null)

# Se non c'è nessun argomento, restituisce la lista degli account
if [[ -z "${ACCOUNT}" ]]; then
    while read LINE; do
        cut -d":" -f 1 <<< ${LINE}
    done <<< $(echo "${KEYS_2FA_FILE_DEC}")
    exit
else
    # Estrae l'elemento contenente l'id dato in input
    KEY=$(echo "${KEYS_2FA_FILE_DEC}" | grep ${ACCOUNT} | cut -d":" -f 2)

    # Se la chiave esiste, restituisce l'otp direttamente nella clipboard
    # altrimenti esce con errore
    if [[ -z "${KEY}" ]]; then
        echo "Account non esistente"
        exit 1
    else
        # Calcola l'otp e lo trasferisce nella clipboard con pbcopy
        oathtool --totp -b "${KEY}" | xsel -bi
        echo "Fatto."
    fi
fi

VANTAGGI

• Unico entry-point per la gestione degli account (un'unica password per la cifratura del file
• Più semplice da allocare

SVANTAGGI

• L'univocità degli account deve essere garantita dall'utente.
• Perdita della funzionalità di autocomplete in fase di inserimento dati

Provo ad esplorare anche una struttura differente, più espressiva se vogliamo. Invece di un file nome-valore, uso un json così strutturato:

Versione 3

{
  "accounts": [
    {
      "id": "account_1",
      "secret": "JD88EIDIKJDKMDI3IEJDMDKJKDJKDKPA"
    },
    {
      "id": "account_2",
      "secret": "JDNBLASPUQRIEKM89478JMFKOVJDOQKJ"
    },
    {
      "id": "account_3",
      "secret": "OIJWGDVLOIQ94KDKSUD9KSLWOER9W3ODF"
    },
    {
      "id": "account_4",
      "secret": "MVNMWIQPQYSKGPRIGNFG24KFG9E49RPWQ"
    },
    
    ...
    
    {
      "id": "account_n",
      "secret": "IWPQSLNCGK49TOWODIR483IRIWOFOPIQO"
    }
  ]
}

Un array, accounts, di oggetti nome-valore.

Lo script che fa il parsing e l'estrazione non è molto diverso dal precedente.

#!/usr/local/bin/bash

# Path del file cifrato contentente i codici 2FA
JSON_2FA_FILE=<path>/json_2fa.gpg

# Acquisisce il nome account
ACCOUNT=$1

# Carica in ram il contenuto del file json cifrato
JSON_2FA_FILE_DEC=$(gpg --decrypt  --pinentry-mode loopback  "${JSON_2FA_FILE}" 2>/dev/null)

# Se non c'è nessun argomento, restituisce la lista degli account
# - jq -c '.accounts[]' restituisce una lista contenenente tante linee per quanti sono gli elementi.
# - La lista viene data in pasto al ciclo while attraverso l'operatore <<< (here-string)
# - Da ogni linea viene estratto il valore del campo "id" sempre attraverso l'operatore <<<

if [[ -z "${ACCOUNT}" ]]; then
    while read LINE; do
        jq -r '.id' <<< ${LINE}
    done <<< $(echo "${JSON_2FA_FILE_DEC}" | jq -c '.accounts[]')
    exit
else
    # Estrae dall'array l'elemento contenente l'id dato in input
    KEY=$(jq -r --arg ID ${ACCOUNT} '.accounts[] | select(.id | contains($ID)).secret' <<< ${JSON_2FA_FILE_DEC})

    # Se la chiave esiste, restituisce l'otp direttamente nella clipboard
    # altrimenti esce con errore
    if [[ -z "${KEY}" ]]; then
        echo "Account non esistente"
        exit 1
    else
        # Calcola l'otp e lo trasferisce nella clipboard con xsel
        oathtool --totp -b "${KEY}" | xsel -bi
        echo "Fatto."
    fi
fi

#bash #otp #scripting #shell

1. Introduzione

Quando si eseguono varie istanze di shell bash (zsh mi pare l'abbia già) nasce l'esigenza di disporre di una history unificata per non correre il rischio che comandi digitati su una certa istanza non siano più disponibili per un riutilizzo futuro. In alcune configurazioni, le history si sincronizzano quando si chiude esplicitamente la sessione con “exit” o con CTRL-D ma il vantaggio vero sarebbe quello di disporre del merge da subito, senza aspettare di chiudere la sessione. Anche perché, se per errore, l'emulatore di terminale viene chiuso senza prima aver chiuso le sessioni (crash o anche terminando esplicitamente l'applicazione se questo non coincide con il termine della sessione), le history non saranno più disponibili.

Il merge delle history, in sè, è banale. C'è bisogno di un pizzico di magia del comando history stesso e di un minimo di conoscenza della cosidetta “shell”.

Nota a margine: Su Gnu/Linux, tutto ciò è applicabile senza eccezioni. Su Mac OS uso bash 5 fornito da homebrew definendo un nome custom per il file history (HISTFILE in .bashrc) che altrimenti viene resettato impietosamente dopo non più di 500 linee, ogni tot riavvi e dopo tot tempo. Le ho provate tutte per andare oltre questo vincolo (sia modificando .bashrc e .profile sia usando alcune chicche specifiche del Mac che però hanno fallito tutte miseramente) e l'unica cosa che ha funzionato è stato il nome custom.

2. La ricettina

1. La shell
2. configurazione history
3. creazione script

1. La shell (Spiegone iniziale)

In un'istanza di shell i comandi di uno script vengono solitamente eseguiti come sottoprocesso del processo genitore. Uno stesso comando può essere invocato esternamente o essere implementato direttamente dalla shell (incorporato o builtin). I comandi implementati nativamente possono essere più efficienti degli equivalenti esterni perché questi ultimi richiedono la generazione di un processo figlio per essere eseguiti. Inoltre un comando builtin può accedere a parti interne della shell. D'altro canto, l'esecuzione di comandi esterni, col loro meccanismo di sottoprocesso, rende più semplice il ricorso ad un certo grado di parallelismo. Piuttosto che eseguire sequenzialmente n comandi interni, potrei decidere di ricorrere agli equivalenti esterni meno efficienti ma in grado di sfruttare il parallelismo dei sottoprocessi e lasciare al sistema operativo la gestione di questo aspetto.

Il merge delle history viene ottenuto sfruttando questi concetti.

Più facile a farsi che a dirsi:

1. si scrive una funzione history (che sarà quella invocata dalla shell come se fosse un alias)
2. nel corpo della funzione history, si usa opportunamente il builtin history che effettuerà il merge vero e proprio
3. particolare attenzione verrà data all'innesco di questa invocazione

2. Configurazione history

In ogni istanza di shell:

1. si appende la sessione corrente al file history (history -a)
2. si cancella la history attualmente in sessione (history -c)
3. si ripristina la history in sessione dal file history (history -r)
4. si riscrive history come funzione in modo che possa essere invocata dall'utente in maniera trasparente, eseguendo il sync e richiamando il builtin history (volendo scomodare impropriamente i design pattern, tutto ciò potrebbe ricordare l'adapter per es.)

Queste due funzioni andranno collocate in .bashrc (o .profile o .bash_profile, dipende dalla vostra configurazione) e richiamate attraverso il PROMPT_COMMAND in modo che, prima di ogni visualizzazione del prompt, si esegua il merge come volevamo

3. creazione script

In .bashrc:

...
history(){
  syncHistory
  builtin history "$@"
}
 
syncHistory(){
  builtin history -a
  HISTFILESIZE=$HISTFILESIZE
  builtin history -c
  builtin history -r
}
...
PROMPT_COMMAND=syncHistory

Appendice

terminale vs. shell vs. emulatore di terminale Quando ci si vuole sentire fighi e veri hacker, confessando con un falso senso di colpa e una strizzatina d'occhio, “di lavorare solo aprendo delle shell”, commettiamo due piccole leggerezze:

• si dice una sciocchezza
• se la contrazione intrinseca nella frase “aprire una shell” non è voluta, allora non si ha nessuna idea di quello che si sta facendo.

1. La shell è un interprete di comandi (bash, dash, ksh, csh, zsh ecc.) e basta. Come può esserlo python per es. Mai sentito dire: “ora apro un bel python”, al di là del senso vagamente inquietante della frase.
2. Un terminale reale è una console collegata ad uno pseudo-dispositivo tty, collegato a sua volta fisicamente ad una porta seriale.
3. Un terminale virtuale in ambienti *nix è una console collegata ad uno pseudo-dispositivo tty virtuale (note anche come “console tty”) che permette di eseguire una shell all'interno di una sessione X. Di solito accessibili con CTRL-ALT-Fn (per n=1..7 ma comunque configurabile).
4. Infine, quando si “apre una shell”, quello che si fa in realtà al 99,9999%, è aprire un emulatore di terminale (xterm, Gnome Terminal, Konsole, Iterm2, PuTTY, ecc.), ossia un terminale virtuale all'interno di un ambiente grafico, su cui eseguire una shell come per i terminali reali/virtuali.

Ulteriore suddivisione può essere operata considerando la tipologia di sessioni aperte e la possibilità o meno di disporre di un accesso al sistema.

• Il terminale virtuale esegue una shell interattiva con login (o shell di login). È ciò che avviene quando non si dispone di un login manager come KDM, GDM, LightDM ecc. che sono shell di login con GUI.
• L'emulatore di terminale permette di eseguire invece una shell interattiva senza login.
• L'esecuzione di uno script invece eseguirà una shell non interattiva.

Quindi “eseguo” una shell, la “uso”. Ma non la “apro”, pur essendo una “conchiglia”.

#bash #shell