Come controllare lo stato dello storage USB in Linux utilizzando lo scripting shell

I dispositivi di archiviazione rimovibili come le unità USB sono strumenti indispensabili per il trasferimento dei dati, i backup e il ripristino del sistema. Tuttavia, se non gestiti, rappresentano anche un grave rischio per la sicurezza, soprattutto in ambienti enterprise o MSP. Sapere se l’accesso allo storage USB è abilitato sui tuoi sistemi Linux non è solo una questione di convenienza; è una questione di applicazione delle criteri, di conformità alla sicurezza e di consapevolezza operativa. In questo articolo analizzeremo uno script in shell che automatizza il processo di verifica dello stato dello storage USB in Linux e che si integra facoltativamente con NinjaOne per inserire i risultati in un report.

Contesto

In Linux, il controllo dell’accesso allo storage USB è gestito principalmente dai moduli del kernel, in particolare dai driver usb_storage e uas (USB Attached SCSI). Gli amministratori di sistema possono disabilitare questi driver inserendoli nella lista nera o configurandoli in modo che eseguano comandi innocui invece di essere caricati.

Lo script qui esaminato per controllare lo stato dello storage USB in Linux è progettato per ispezionare la directory /etc/modprobe.d, dove di solito risiedono queste regole di caricamento dei moduli. È particolarmente importante negli ambienti gestiti tramite NinjaOne, dove la supervisione centralizzata e i controlli di conformità automatizzati sono essenziali. I provider di servizi gestiti (MSP) e i team IT interni traggono vantaggio da questo tipo di strumenti per garantire che gli endpoint siano conformi ai criteri aziendali.

Lo script per controllare lo stato dello storage USB in Linux:

#!/usr/bin/env bash

# Description: Checks if the linux machine currently allows access to USB storage devices and optionally saves the results to a custom field.
# By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/terms-of-use.
# Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
# Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
# Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
# Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
# Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
# Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
# EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
#
#   The script checks the modprobe.d folder for any files that may block the USB storage driver or the USB Attached SCSI driver.
#   There are two methods of loading USB storage drivers that allow mounting of USB storage devices:
#       1. Implicit loading: The USB storage driver is loaded automatically when a USB storage device is connected.
#       2. Explicit loading: The USB storage driver is loaded manually by a user, program, or script.
#
# Release Notes: Initial Release
#
# Preset Parameter: -CustomField "usbStorageStatus"
#   The custom field to save the USB storage status to.
#
# Preset Parameter: --help
#   Displays the help menu.
#

# Functions
# Print an error message and exit with a specific status code
die() {
    local _ret="${2:-1}"
    test "${_PRINT_HELP:-no}" = yes && print_help >&2
    echo "$1" >&2
    exit "${_ret}"
}

print_help() {
    printf '\n\n%s\n\n' 'Usage: [-CustomField "custom_field_name"]'
    printf '  %s\n' '-CustomField'
    printf '    The custom field to save the USB storage status to.\n'
}

# Parse the command-line arguments
parse_commandline() {
    while test $# -gt 0; do
        _key="$1"
        case "$_key" in
        -CustomField | --CustomField | -customfield | --customfield | -cf | --cf)
            _arg_customfield="CustomField"
            ;;
        --help | -help | -h | --h)
            _PRINT_HELP=yes die "" 0
            ;;
        *)
            _PRINT_HELP=yes die "[Error] Got an unexpected argument '$1'" 1
            ;;
        esac
        shift
    done
}

function SetCustomField() {
    if [[ -z "$1" ]] || [[ -z "$2" ]]; then
        echo "[Error] Missing required arguments."
        return 1
    fi
    local customfieldName=$1
    local customfieldValue=$2
    if [ -f "${NINJA_DATA_PATH}/ninjarmm-cli" ]; then
        if [ -x "${NINJA_DATA_PATH}/ninjarmm-cli" ]; then
            if "$NINJA_DATA_PATH"/ninjarmm-cli get "$customfieldName" >/dev/null; then
                # check if the value is greater than 10000 characters
                if [ ${#customfieldValue} -gt 10000 ]; then
                    echo "[Warn] Custom field value is greater than 10000 characters" >&2
                    return 1
                fi
                if ! echo "${customfieldValue::10000}" | "$NINJA_DATA_PATH"/ninjarmm-cli set --stdin "$customfieldName"; then
                    echo "[Warn] Failed to set custom field" >&2
                    return 1
                else
                    echo "[Info] Custom field value set successfully"
                fi
            else
                echo "[Warn] Custom Field ($customfieldName) does not exist or agent does not have permission to access it" >&2
                return 1
            fi
        else
            echo "[Warn] ninjarmm-cli is not executable" >&2
            return 1
        fi
    else
        echo "[Warn] ninjarmm-cli does not exist" >&2
        return 1
    fi
}

parse_commandline "$@"

# If script form variables are used, replace the command line parameters with their value.
if [[ -n "${customField}" ]]; then
    _arg_customfield="${customField}"
fi

# Variables
# Modprobe.d folder
modprobFolder="/etc/modprobe.d"

# Check if we have read access to the modprobe.d folder
if ! [ -r "${modprobFolder}" ]; then
    if [[ -n "${_arg_customfield}" ]]; then
        SetCustomField "${_arg_customfield}" "Unable to Determine"
    fi
    die "[Error] User ${USER} has no read access to modprobe.d folder" 1
fi

# Check if modprobe.d folder does not exist
if ! [ -d "${modprobFolder}" ]; then
    if [[ -n "${_arg_customfield}" ]]; then
        SetCustomField "${_arg_customfield}" "Unable to Determine"
    fi
    die "[Error] Modprobe folder does not exist" 1
fi

# Set default values
UsbStorage="Enabled"
usb_storage_status="Enabled"
uas_status="Enabled"
usb_storage_driver_status="Enabled"
uas_driver_status="Enabled"

# Check if usb_storage or uas is blocked in other files
for file in "${modprobFolder}"/*; do

    if ! [ -r "${file}" ]; then
        echo "[Warn] User ${USER} has no read access to ${file}"
    fi

    # Check if implicit loading is blocked
    if grep -q "blacklist usb_storage" "${file}"; then
        echo "[Info] USB storage driver is blocked in ${file}"
        usb_storage_status="Disabled"
    fi
    # Check if implicit loading is blocked
    if grep -q "blacklist uas" "${file}"; then
        echo "[Info] USB Attached SCSI driver is blocked in ${file}"
        uas_status="Disabled"
    fi

    # Check if explicit loading is blocked
    if grep -q "install usb-storage /bin/true" "${file}"; then
        echo "[Info] USB storage driver is blocked in ${file}"
        usb_storage_driver_status="Disabled"
    fi
    # Check if explicit loading is blocked
    if grep -q "install uas /bin/true" "${file}"; then
        echo "[Info] USB Attached SCSI driver is blocked in ${file}"
        uas_driver_status="Disabled"
    fi
done

# Output the status of implicit loading
if [ "${usb_storage_status}" == "Disabled" ] && [ "${uas_status}" == "Disabled" ]; then
    echo "[Info] USB storage driver implicit loading: Blocked"
elif [ "${usb_storage_status}" == "Enabled" ] && [ "${uas_status}" == "Enabled" ]; then
    echo "[Info] USB storage driver implicit loading: Allowed"
else
    echo "[Info] USB storage driver implicit loading: Partially Allowed"
fi

# Output the status of explicit loading
if [ "${usb_storage_driver_status}" == "Disabled" ] && [ "${uas_driver_status}" == "Disabled" ]; then
    echo "[Info] USB storage driver manual loading: Blocked"
elif [ "${usb_storage_driver_status}" == "Enabled" ] && [ "${uas_driver_status}" == "Enabled" ]; then
    echo "[Info] USB storage driver manual loading: Allowed"
else
    echo "[Info] USB storage driver manual loading: Partially Allowed"
fi

# Determine the overall status of USB storage
if [ "${usb_storage_status}" == "Disabled" ] && [ "${uas_status}" == "Disabled" ] && [ "${usb_storage_driver_status}" == "Disabled" ] && [ "${uas_driver_status}" == "Disabled" ]; then
    UsbStorage="Disabled"
elif [ "${usb_storage_status}" == "Enabled" ] && [ "${uas_status}" == "Enabled" ] && [ "${usb_storage_driver_status}" == "Enabled" ] && [ "${uas_driver_status}" == "Enabled" ]; then
    UsbStorage="Enabled"
elif [ "${usb_storage_status}" == "Enabled" ] || [ "${uas_status}" == "Enabled" ] || [ "${usb_storage_driver_status}" == "Enabled" ] || [ "${uas_driver_status}" == "Enabled" ]; then
    UsbStorage="Partially Allowed"
else
    UsbStorage="Unable to Determine"
fi

echo "[Info] USB storage is ${UsbStorage}"

if [[ -n "${_arg_customfield}" ]]; then
    SetCustomField "${_arg_customfield}" "${UsbStorage}"
fi

Analisi dettagliata dello script per controllare lo stato dello storage USB in Linux

Questo script shell per controllare lo stato dello storage USB in Linux esegue diverse operazioni in modo strutturato e con tolleranza ai malfunzionamenti. Ecco una spiegazione passo per passo:

1. Parsing degli argomenti della riga di comando

   • Supporta l’argomento opzionale -CustomField per specificare un campo personalizzato di NinjaOne.
   • Fornisce l’opzione –help per una guida all’uso.

2. Controlli delle autorizzazioni e delle cartelle

   • Convalida l’esistenza e la leggibilità della directory /etc/modprobe.d.
   • Se l’accesso è negato o la cartella è mancante, viene mostrato l’errore “Impossibile determinare” e, se configurato, viene scritto nel campo personalizzato NinjaOne.

3. Valutazione dello stato del driver

   • Controlla ogni file in /etc/modprobe.d.
   • Cerca:
     1. blacklist usb_storage o blacklist uas (blocca il caricamento implicito).
     2. install usb-storage /bin/true oppure install uas /bin/true (blocca il caricamento esplicito).
   • Traccia lo stato di ciascun metodo per ciascun driver.

4. Determinazione dello stato

   • Categorizza il caricamento del driver come Consentito, Bloccato o Parzialmente Consentito.
   • Aggrega il risultato in uno stato finale di Abilitato, Disabilitato o Parzialmente permesso.

5. Integrazione con NinjaOne

   • Se viene specificato -CustomField e lo strumento ninjarmm-cli è presente, lo script scrive lo stato della memoria USB nel campo personalizzato designato.

Casi d’uso potenziali

Caso di studio:

Un MSP del settore sanitario gestisce centinaia di chioschi basati su Linux nelle cliniche. I criteri di sicurezza impongono di disattivare l’archiviazione USB per evitare l’estrazione di dati non autorizzati. Utilizzando questo script per controllare lo stato dello storage USB in Linux, l’MSP può:

• Distribuire lo script per controllare lo stato dello storage USB in Linux su tutti gli endpoint utilizzando NinjaOne.
• Registrare automaticamente lo stato dell’USB in un campo personalizzato.
• Generare rapporti di conformità.
• Avvisare i tecnici se una macchina non rispetta i criteri stabiliti.

Questo monitoraggio proattivo della conformità consente di risparmiare ore di verifiche manuali e garantisce la conformità alle normative (per esempio HIPAA).

Confronti

Altri metodi

L’efficacia di questo script per controllare lo stato dello storage USB in Linux è data dalla semplicità, dalla portabilità e dall’integrazione nativa con l’ecosistema NinjaOne, che lo rende ideale per gli ambienti in cui la semplicità e l’automazione prevalgono sulle necessità di personalizzazione.

Domande frequenti

Quali distribuzioni Linux sono supportate dallo script per controllare lo stato dello storage USB in Linux?

La maggior parte delle distribuzioni basate su Debian e Red Hat con /etc/modprobe.d sono compatibili.

Questo script per controllare lo stato dello storage USB in Linux blocca l’archiviazione USB?

No, ne controlla solo lo stato. Il blocco deve essere gestito tramite la configurazione del sistema.

Che cos’è ninjarmm-cli?

È l’interfaccia a riga di comando di NinjaOne per leggere/scrivere i dati dei campi personalizzati sugli endpoint.

Che cosa significa “Parzialmente consentito”?

Indica che alcuni metodi di caricamento dei driver sono consentiti, mentre altri sono bloccati.

Posso utilizzarlo senza NinjaOne?

Sì, ma non sarà possibile salvare i risultati in un campo personalizzato senza ninjarmm-cli.

Implicazioni

Capire se l’archiviazione USB è consentita ha un impatto sulla tua posizione di rischio. Consentire l’accesso illimitato all’USB aumenta il potenziale di perdita di dati, introduzione di malware e trasferimenti accidentali di dati. Nei settori regolamentati come finanza, sanità, pubblica amministrazione, dimostrare di avere il controllo dell’accesso USB è spesso obbligatorio. Questo script per controllare lo stato dello storage USB in Linux consente di effettuare tale supervisione in modo minimamente invasivo e ripetibile.

Raccomandazioni

• Esegui lo script con permessi elevati per garantire l’accesso completo a /etc/modprobe.d.
• Standardizza il nome del campo personalizzato su tutti i dispositivi per una reportistica unificata in NinjaOne.
• Abbina questo script agli strumenti di correzione che impongono il blocco se viene rilevata una non conformità.
• Pianifica la sua distribuzione come attività ricorrente all’interno di NinjaOne per la convalida periodica della conformità.

Considerazioni finali

L’uso dello scripting shell per verificare lo stato dello storage USB in Linux offre un metodo leggero, verificabile e automatizzabile per la verifica della conformità degli endpoint. Se usato insieme a NinjaOne, questo script diventa un potente strumento per l’applicazione centralizzata dei criteri e la visibilità. Che si tratti di un MSP che gestisce le flotte dei clienti o di un team IT interno che protegge le risorse aziendali, questa soluzione offre il giusto equilibrio tra semplicità e potenza.