Come monitorare i file di log su Linux e cercare testi specifici utilizzando uno script Bash

Il monitoraggio dei file di log e il rilevamento di specifici modelli di testo è un compito cruciale per i professionisti IT, in particolare nel contesto dell’amministrazione di sistema e della sicurezza informatica. Gli script automatizzati in grado di segnalare stringhe di testo specifiche all’interno dei file sono strumenti preziosi nel kit di strumenti di un professionista IT.

Lo script fornito svolge questo compito in modo efficace, offrendo una soluzione affidabile per monitorare i file di log su Linux e  per inviare avvisi nel momento in cui viene individuata l’occorrenza di stringhe di testo specifiche. In questo articolo approfondiremo le funzionalità dello script, le sue applicazioni concrete e parleremo delle best practice per il suo utilizzo.

Comprendere lo script e la sua importanza

Negli ambienti IT, i file di log vengono continuamente generati da vari sistemi, applicazioni e processi. Questi log contengono informazioni vitali sulle operazioni del sistema, sugli errori, sugli eventi di sicurezza e sulle attività degli utenti. Tuttavia, il monitoraggio manuale di questi file alla ricerca di eventi critici o stringhe di testo è poco pratico e soggetto a errori umani. È qui che l’automazione attraverso lo scripting diventa essenziale.

Lo script fornito è progettato per cercare un testo specifico all’interno di un file di log e generare un avviso quando viene trovato quel testo. Questo script è particolarmente utile per i provider di servizi gestiti (MSP) e gli amministratori IT che devono monitorare i log per individuare incidenti di sicurezza, errori delle applicazioni o altri eventi significativi che potrebbero richiedere un’attenzione immediata.

Lo script per monitorare i file di log su Linux:

#!/usr/bin/env bash

# Description: Alert when the specified Text is found in a text file.
#
# Release Notes: Initial Release
#   By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://ninjastage2.wpengine.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).
#
# Text to trigger on: [Alert]
#
# Below are all the valid parameters for this script.
# Preset Parameter: --file "/opt/MyLogFile.log" --text batman
#   Alerts when the text "batman" is found in the file /opt/MyLogFile.log
#    This is Case Sensitive
#     Example where it will alert: "I am batman!"
#     Example where it will alert: "Iambatman!"
#     Example where it will not alert: "IamBatman!"
#     Example where it will not alert: "I am Batman!"
#
# Preset Parameter: --file "/opt/MyLogFile.log" --text Batman --caseInsensitive true
#   Alerts when the text "Batman" is found in the file /opt/MyLogFile.log, but is case insensitive
#    This is Case Insensitive
#     Example where it will alert: "I am batman!"
#     Example where it will alert: "Iambatman!"
#
# Preset Parameter: --file "/opt/MyLogFile.log" --text Batman --wholeWord true
#   Alerts when the text "Batman" is found in the file /opt/MyLogFile.log, but only if it is a word in a sentence.
#    This is Case Sensitive
#     Example where it will alert: "I am Batman!"
#     Example where it will not alert: "IamBatman!"
#

# Determines whether or not help text is necessary and routes the output to stderr
die() {
    local _ret="${2:-1}"
    test "${_PRINT_HELP:-no}" = yes && print_help >&2
    echo "$1" >&2
    exit "${_ret}"
}

# Function that evaluates whether a value passed to it begins by a character
# that is a short option of an argument the script knows about.
# This is required in order to support getopts-like short options grouping.
begins_with_short_option() {
    local first_option all_short_options='ftiwh'
    first_option="${1:0:1}"
    test "$all_short_options" = "${all_short_options/$first_option/}" && return 1 || return 0
}

# THE DEFAULTS INITIALIZATION - OPTIONALS
_arg_file=
_arg_text=
_arg_caseInsensitive="false"
_arg_wholeWord="false"

# Help text function for when invalid input is encountered
print_help() {
    printf '%s\n' "Alert when the specified Text is found in a text file."
    printf 'Usage: %s [-f|--file [path to file]] [-t|--text [text to search]] [-i|--caseInsensitive <true|false>] [-w|--wholeWord <true|false>] [-h|--help]\n' "$0"
    printf '\t%s\n' "-f, --file: path to a log file"
    printf '\t%s\n' "-t, --text: text to alert when found"
    printf '\t%s\n' "-i, --caseInsensitive: search text with case insensitivity (default: false)"
    printf '\t%s\n' "-w, --wholeWord: search for text as a whole word (default: false)"
    printf '\t%s\n' "-h, --help: Prints help"
}

# Grabbing the parameters and parsing through them.
parse_commandLine() {
    while test $# -gt 0; do
        _key="$1"
        case "$_key" in
        -f | --file)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_file="$2"
            shift
            ;;
        --file=*)
            _arg_file="${_key##--file=}"
            ;;
        -f*)
            _arg_file="${_key##-f}"
            ;;
        -t | --text)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_text="$2"
            shift
            ;;
        --text=*)
            _arg_text="${_key##--text=}"
            ;;
        -t*)
            _arg_text="${_key##-t}"
            ;;
        -i | --caseInsensitive)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_caseInsensitive="$2"
            shift
            ;;
        --caseInsensitive=*)
            _arg_caseInsensitive="${_key##--caseInsensitive=}"
            ;;
        -i*)
            _arg_caseInsensitive="${_key##-i}"
            ;;
        -w | --wholeWord)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_wholeWord="$2"
            shift
            ;;
        --wholeWord=*)
            _arg_wholeWord="${_key##--wholeWord=}"
            ;;
        -w*)
            _arg_wholeWord="${_key##-w}"
            ;;
        -h | --help)
            print_help
            exit 0
            ;;
        -h*)
            print_help
            exit 0
            ;;
        *)
            _PRINT_HELP=yes die "FATAL ERROR: Got an unexpected argument '$1'" 1
            ;;
        esac
        shift
    done
}

parse_commandLine "$@"

text=$_arg_text
file=$_arg_file
caseInsensitive=$_arg_caseInsensitive
wholeWord=$_arg_wholeWord

# Check if Script Variables where used and overwrite command line parameters
if [[ -n "${textToMatch}" ]]; then
    text=$textToMatch
fi
if [[ -n "${textFile}" ]]; then
    file=$textFile
fi
if [[ -n "${matchWholeWord}" ]]; then
    wholeWord=$matchWholeWord
fi
if [[ -n "${insensitiveToCase}" ]]; then
    caseInsensitive=$insensitiveToCase
fi

# Check if text is not an empty string
if [[ -z "${text}" ]]; then
    echo "[Error] Text not specified"
    exit 2
fi

# Check if text is not an empty string
if [[ -z "${file}" ]]; then
    echo "[Error] File not specified"
    exit 2
fi

# Does file exit and is readable
if [ -f "${file}" ]; then
    echo "[Info] File \"${file}\" exists"
    if [ -r "${file}" ]; then
        echo "[Info] File \"${file}\" is readable"
    else
        echo "[Error] File \"${file}\" is not readable"
        exit 2
    fi
else
    echo "[Error] File \"${file}\" does not exists"
    exit 2
fi

# Detect
count=0
if [[ "${wholeWord}" == "true" ]]; then
    if [[ "${caseInsensitive}" == "true" ]]; then
        count=$(grep -c -i -n -w "$text" "$file")
    else
        count=$(grep -c -n -w "$text" "$file")
    fi
else
    if [[ "${caseInsensitive}" == "true" ]]; then
        count=$(grep -c -i -n -e "$text" "$file")
    else
        count=$(grep -c -n -e "$text" "$file")
    fi
fi

# Alert
if ((count > 0)); then
    echo "[Alert] Found text in file"
    exit 1
else
    echo "[Info] Not found text in file"
    exit 0
fi

 

Descrizione dettagliata dello script

Vediamo più da vicino come funziona questo script per monitorare i file di log su Linux:

1. Parsing dei parametri: 

• Lo script per monitorare i file di log su Linux inizia definendo parametri predefiniti come _arg_file, _arg_text, _arg_caseInsensitive e _arg_wholeWord. Questi parametri vengono quindi processati dalla riga di comando, consentendo all’utente di specificare il file da monitorare, il testo da cercare e se la ricerca deve essere sensibile alle maiuscole e minuscole o limitata alle parole intere.

2. Argomenti della riga di comando: 

• Gli utenti possono utilizzare vari argomenti come –file, –text, –caseInsensitive e –wholeWord per personalizzare il comportamento dello script. Per esempio, –file specifica il percorso del file di log, mentre –text indica il testo da cercare. Lo script supporta anche ricerche senza distinzione tra maiuscole e minuscole e ricerche limitate a parole intere.

3. Convalida:

• Lo script per monitorare i file di log su Linux esegue diversi controlli di convalida, ad esempio per verificare che siano forniti sia il testo da cercare che il percorso del file. Controlla anche se il file specificato esiste ed è leggibile. Queste convalide impediscono l’esecuzione dello script in condizioni non corrette, evitando così potenziali errori.

4. Ricerca del testo:

• La funzionalità principale dello script per monitorare i file di log su Linux ruota attorno al comando grep, che cerca il testo specificato all’interno del file di log. A seconda dei parametri forniti, lo script può eseguire ricerche senza distinzione tra maiuscole e minuscole o cercare solo corrispondenze con parole intere. Il risultato del comando grep viene memorizzato nella variabile count, che indica quante volte è stato trovato il testo specificato.

5. Meccanismo di avviso:

• Se il testo viene trovato all’interno del file, lo script genera un avviso stampando un messaggio ed uscendo con un codice di stato pari a 1. Se il testo non viene trovato, lo script termina con un codice di stato 0, che indica che non è stata attivata alcuna condizione di avviso.

Casi d’uso concreti

Immagina un MSP incaricato di monitorare i log dei server di un cliente alla ricerca di minacce specifiche alla sicurezza, come i tentativi di accesso non riusciti. Questo script per monitorare i file di log su Linux potrebbe essere configurato per cercare nei file di log frasi come “Password fallita” o “Autenticazione fallita”. Quando lo script rileva queste frasi, avvisa immediatamente l’MSP, consentendogli di intervenire rapidamente per indagare e ridurre i rischi delle potenziali violazioni della sicurezza.

Un altro esempio potrebbe essere quello di un amministratore di sistema che deve monitorare i log delle applicazioni per individuare eventuali errori critici. Configurando lo script per la ricerca di parole chiave come “ERROR” o “CRITICAL”, l’amministratore può assicurarsi di essere avvisato tempestivamente di qualsiasi problema che possa influire sulle prestazioni o sulla disponibilità dell’applicazione.

Confronto con altri metodi

Sebbene esistano vari strumenti e metodi per monitorare i file di log su Linux, per esempio l’utilizzo di soluzioni di gestione dei log centralizzate come lo stack ELK (Elasticsearch, Logstash, Kibana) o strumenti di monitoraggio basati su cloud, questo script offre una soluzione leggera e diretta che non richiede infrastrutture aggiuntive. È ideale per gli scenari in cui la semplicità e la rapidità di implementazione sono fondamentali, o in cui un sistema di monitoraggio completo potrebbe essere eccessivo.

Domande frequenti

• D: Questo script per monitorare i file di log su Linux può essere utilizzato su sistemi non Linux?
• R: Questo script è stato progettato per sistemi Unix-like, come Linux. Si basa su comandi come grep, che sono standard in questi ambienti. Anche se in teoria potrebbe essere adattato ad altri sistemi, questo richiederebbe delle modifiche.
• D: Come gestisce lo script i file di log di grandi dimensioni?
• R: Lo script per monitorare i file di log su Linux utilizza grep, che è efficiente anche con file di grandi dimensioni. Tuttavia, nel caso di file estremamente grandi, le prestazioni potrebbero essere compromesse. In questi casi, potrebbe essere consigliabile utilizzare un meccanismo di rotazione dei log o strumenti di gestione dei log più avanzati.
• D: Cosa succede se vengono trovate più istanze del testo?
• R: Lo script per monitorare i file di log su Linux conta tutte le istanze del testo nel file e attiva un avviso se vengono trovate delle corrispondenze, indipendentemente dal numero di occorrenze.

Implicazioni per la sicurezza informatica

La capacità di monitorare i file di log su Linux e di cercare stringhe di testo specifiche è fondamentale per mantenere la sicurezza e la stabilità dei sistemi IT. Questo script può essere un componente critico di una strategia di sicurezza più ampia, e può aiutare i professionisti IT a rilevare e rispondere rapidamente a potenziali minacce. Automatizzando il processo di monitoraggio, lo script riduce il rischio di avvisi mancanti e garantisce che i problemi critici vengano segnalati in tempo reale.

Raccomandazioni per l’uso dello script

• Aggiorna regolarmente lo script: Assicurati che lo script per monitorare i file di log su Linux sia aggiornato con le ultime funzionalità e miglioramenti. Gli aggiornamenti regolari possono anche aiutare a risolvere potenziali vulnerabilità di sicurezza.
• Integra lo script con altri strumenti: Considera la possibilità di integrare questo script per monitorare i file di log su Linux con strumenti di notifica come gli avvisi via e-mail o SMS per garantire che gli avvisi vengano ricevuti tempestivamente, anche quando l’amministratore non sta monitorando attivamente il sistema.
• Esegui test in un ambiente sicuro: Prima di distribuire lo script per monitorare i file di log su Linux in un ambiente di produzione, testalo in un ambiente controllato per assicurarti che si comporti come previsto con i file di log e i casi d’uso specifici.

Considerazioni finali

Il monitoraggio dei file di log attraverso la ricerca di stringhe di testo specifiche è una pratica fondamentale nell’amministrazione e nella sicurezza IT. Questo script fornisce una soluzione semplice ma potente per automatizzare il processo per monitorare i file di log su Linux, facilitando il rilevamento e la risposta dei professionisti IT agli eventi critici in tempo reale. Per chi utilizza NinjaOne, uno script di questo tipo potrebbe essere parte integrante della strategia di monitoraggio IT complessiva, al fine di garantire che i sistemi rimangano sempre sicuri e operativi.