Aggiunta o sovrascrittura delle informazioni antivirus su un dispositivo con uno script Bash per macOS 

La gestione delle configurazioni antivirus sui vari dispositivi è un compito critico per i professionisti IT e i provider di servizi gestiti (MSP). Garantire informazioni antivirus accurate e aggiornate nei registri dei dispositivi è essenziale per mantenere un ambiente IT sicuro e conforme.

In questo articolo viene analizzato uno script bash che semplifica l’aggiunta o la sovrascrittura di dettagli antivirus sui dispositivi macOS. Che si tratti di aggiornare i dati della versione dell’antivirus, di modificarne lo stato operativo o di reimpostare completamente le eccezioni, questo script semplifica il processo per impostare le informazioni antivirus con controlli solidi e azioni automatizzate.

Contesto

Negli ambienti IT dinamici, i dati antivirus possono spesso diventare obsoleti o disallineati a causa di cambiamenti nelle configurazioni software, migrazioni di dispositivi o frequenze di aggiornamento variabili. Gli MSP che gestiscono un gran numero di dispositivi devono affrontare delle sfide per mantenere la coerenza tra i dati relativi agli antivirus. Senza un metodo standardizzato per sovrascrivere o aggiornare questi dettagli in modo sistematico, l’intervento manuale può portare a errori e inefficienze.

Questo script affronta queste sfide offrendo un approccio chiaro e strutturato all’aggiornamento delle informazioni antivirus in ambienti macOS. Consente ai professionisti IT di:

• Aggiungere o aggiornare i dettagli dell’antivirus in una configurazione basata su JSON.
• Rimuovere le eccezioni obsolete dai record di sistema.
• Assicurarsi che lo stato dell’antivirus sia conforme ai criteri dell’organizzazione.

Lo script per impostare le informazioni antivirus:

#!/usr/bin/env bash
#
# Description: Add an antivirus to the device details or override the existing antivirus information.
#   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).
#
# Preset Parameter: --antivirusName "ReplaceMeWithYourDesiredName"
#   Name of the antivirus you would like to appear in the device details.
#
# Preset Parameter: --antivirusVersion "1.0.2"
#   Specify the version number of the antivirus.
#
# Preset Parameter: --antivirusStatus "Up-to-Date"
#   Specify whether the antivirus definitions are Up-to-Date, Out-of-Date, or Unknown.
#
# Preset Parameter: --antivirusState "ON"
#   Specify the current status of the antivirus.
#
# Preset Parameter: --removeOverride
#   Remove all existing overrides.
#
# Preset Parameter: --antivirusState
#   Append or update an existing override.
#
# Preset Parameter: --help
#		Displays a help menu.
#
# Release Notes: Initial Release

# Initialize variables
_arg_antivirusName=
_arg_antivirusVersion=
_arg_antivirusStatus=
_arg_antivirusState=
_arg_removeOverride="off"
_arg_append="off"

# Function to display help message
print_help() {
  printf '\n\n%s\n\n' 'Usage: [--antivirusName|-n <arg>] [--antivirusVersion|-v <arg>] [--antivirusStatus|--status <arg>] [--antivirusState|--state <arg>] [--removeOverride|-r] [--append|-a] [--help|-h] '
  printf '%s\n' 'Preset Parameter: --antivirusName "ReplaceMeWithYourDesiredName"'
  printf '\t%s\n' "Name of the antivirus you would like to appear in the device details."
  printf '%s\n' 'Preset Parameter: --antivirusVersion "1.0.2"'
  printf '\t%s\n' "Specify the version number of the antivirus."
  printf '%s\n' 'Preset Parameter: --antivirusStatus "Up-to-Date"'
  printf '\t%s\n' "Specify whether the antivirus definitions are Up-to-Date, Out-of-Date, or Unknown."
  printf '%s\n' 'Preset Parameter: --antivirusState "ON"'
  printf '\t%s\n' "Specify the current status of the antivirus."
  printf '%s\n' 'Preset Parameter: --removeOverride'
  printf '\t%s\n' "Remove all existing overrides."
  printf '%s\n' 'Preset Parameter: --antivirusState'
  printf '\t%s\n' "Append or update an existing override."
  printf '\n%s\n' 'Preset Parameter: --help'
  printf '\t%s\n' "Displays this help menu."
}

# Function to print an error message and exit
die() {
  local _ret="${2:-1}"
  echo "$1" >&2
  test "${_PRINT_HELP:-no}" = yes && print_help >&2
  exit "${_ret}"
}

# Function to parse command line arguments
parse_commandline() {
  while test $# -gt 0; do
    _key="$1"
    case "$_key" in
    --antivirusName | --antivirusname | --name | -n)
      test $# -lt 2 && die "Missing value for the argument '$_key'." 1
      _arg_antivirusName=$2
      shift
      ;;
    --antivirusName=*)
      _arg_antivirusName="${_key##--antivirusName=}"
      ;;
    --antivirusVersion | --antivirusversion | --version | -v)
      test $# -lt 2 && die "Missing value for the argument '$_key'." 1
      _arg_antivirusVersion=$2
      shift
      ;;
    --antivirusVersion=*)
      _arg_antivirusVersion="${_key##--antivirusVersion=}"
      ;;
    --antivirusStatus | --antivirusstatus | --status)
      test $# -lt 2 && die "Missing value for the argument '$_key'." 1
      _arg_antivirusStatus=$2
      shift
      ;;
    --antivirusStatus=*)
      _arg_antivirusStatus="${_key##--antivirusStatus=}"
      ;;
    --antivirusState | --antivirusstate | --state)
      test $# -lt 2 && die "Missing value for the argument '$_key'." 1
      _arg_antivirusState=$2
      shift
      ;;
    --antivirusState=*)
      _arg_antivirusState="${_key##--antivirusState=}"
      ;;
    --removeOverride | --remove | -r)
      _arg_removeOverride="on"
      ;;
    --append | --Append | -a)
      _arg_append="on"
      ;;
    --help | -h)
      _PRINT_HELP=yes die 0
      ;;
    *)
      _PRINT_HELP=yes die "[Error] Got an unexpected argument '$1'" 1
      ;;
    esac
    shift
  done
}

# Parse the command line arguments
parse_commandline "$@"

# Replace commandline parameters with script form variables
if [[ -n $avName ]]; then
  _arg_antivirusName="$avName"
fi
if [[ -n $avVersion ]]; then
  _arg_antivirusVersion="$avVersion"
fi
if [[ -n $avStatus ]]; then
  _arg_antivirusStatus="$avStatus"
fi
if [[ -n $avState ]]; then
  _arg_antivirusState="$avState"
fi
if [[ -n $append && $append == "true" ]]; then
  _arg_append="on"
fi
if [[ -n $removeOverride && $removeOverride == "true" ]]; then
  _arg_removeOverride="on"
fi

# Ensure that removing an override and adding/updating an override are not done simultaneously
if [[ $_arg_removeOverride == "on" && (-n $_arg_antivirusName || -n $_arg_antivirusState || -n $_arg_antivirusStatus || -n $_arg_antivirusVersion || $_arg_append == "on") ]]; then
  _PRINT_HELP=no die "[Error] Cannot remove an override and add an override at the same time." 1
fi

# Check for required antivirus name and escape special characters if necessary
reservedCharacters='[\"]'
if [[ -z $_arg_antivirusName && $_arg_removeOverride != "on" ]]; then
  if [[ $_arg_append == "on" ]]; then
    _PRINT_HELP=yes die "[Error] Antivirus name was not given. The antivirus name is required when updating or adding a new override!" 1
  else
    _PRINT_HELP=yes die "[Error] Antivirus name was not given. Antivirus name, state, and status are required when adding a new override!" 1
  fi
elif [[ -n $_arg_antivirusName && $_arg_antivirusName =~ $reservedCharacters ]]; then
  _arg_antivirusName=${_arg_antivirusName//\\/\\\\}
  _arg_antivirusName=${_arg_antivirusName//\"/\\\"}
fi

# Check for required antivirus status
if [[ -z $_arg_antivirusStatus && $_arg_removeOverride != "on" && $_arg_append != "on" ]]; then
  _PRINT_HELP=yes die "[Error] Antivirus status was not given. Antivirus name, state, and status are required!" 1
fi

# Validate antivirus status
if [[ -n $_arg_antivirusStatus && $_arg_antivirusStatus != "Up-to-Date" && $_arg_antivirusStatus != "Out-of-Date" && $_arg_antivirusStatus != "Unknown" ]]; then
  _PRINT_HELP=no die "[Error] An invalid antivirus status of '$_arg_antivirusStatus' was given. Only the following statuses are valid. 'Up-to-Date', 'Out-of-Date', and 'Unknown'." 1
fi

# Check for required antivirus state
if [[ -z $_arg_antivirusState && $_arg_removeOverride != "on" && $_arg_append != "on" ]]; then
  _PRINT_HELP=yes die "[Error] Antivirus state was not given. Antivirus name, state, and status are required!" 1
else
  _arg_antivirusState=$(echo "$_arg_antivirusState" | tr '[:lower:]' '[:upper:]')
fi

# Validate antivirus state
if [[ -n $_arg_antivirusState && $_arg_antivirusState != "ON" && $_arg_antivirusState != "OFF" && $_arg_antivirusState != "EXPIRED" && $_arg_antivirusState != "SNOOZED" && $_arg_antivirusState != "UNKNOWN" ]]; then
  _PRINT_HELP=no die "[Error] An invalid antivirus state of '$_arg_antivirusState' was given. Only the following states are valid. 'ON', 'OFF', 'EXPIRED', 'SNOOZED', and 'UNKNOWN'." 1
fi

# Validate antivirus version
if [[ -n $_arg_antivirusVersion && $_arg_antivirusVersion =~ [^0-9\.] ]]; then
  _PRINT_HELP=no die "[Error] The antivirus version given '$_arg_antivirusVersion' contains an invalid character. Only the following characters are allowed. '0-9' and '.'" 1
fi

# Check if the removeOverride flag is set to "on"
if [[ $_arg_removeOverride == "on" ]]; then
  echo "Removing override as requested."
  # Check if the override file exists
  if [[ ! -f "/Applications/NinjaRMMAgent/programdata/customization/av_override.json" ]]; then
    echo "No override present."
    exit 0
  # Try to remove the override file and capture any error output
  elif output=$(rm "/Applications/NinjaRMMAgent/programdata/customization/av_override.json" 2>&1); then
    echo "Succesfully removed override!"
    exit 0
  # Print an error message if the removal fails
  else
    echo "[Error] Failed to remove override!"
    echo "[Error] $output"
  fi
fi

# Check if the customization directory exists
if [[ ! -d "/Applications/NinjaRMMAgent/programdata/customization" ]]; then
  echo "Creating customization folder at '/Applications/NinjaRMMAgent/programdata/customization'."
  # Try to create the customization directory and capture any error output
  if output=$(mkdir "/Applications/NinjaRMMAgent/programdata/customization" 2>&1); then
    echo "Folder created."
  else
    # Print an error message if the creation fails
    echo "[Error] Unable to create customization folder." >&2
    echo "[Error] $output" >&2
    exit 1
  fi
fi

# Check if the append flag is set to "on" and the override JSON file exists
if [[ $_arg_append == "on" && -f "/Applications/NinjaRMMAgent/programdata/customization/av_override.json" ]]; then
  # Extract antivirus names, versions, statuses and states from the JSON file
  avNames=$(grep "av_name" "/Applications/NinjaRMMAgent/programdata/customization/av_override.json" | tr -s " " | sed s/\"av_name\"://g | sed -e 's/^[[:space:]]*//' | sed 's/[\",]//g' | sed -e 's/[[:space:]]*$//')
  avVersions=$(grep "av_version" "/Applications/NinjaRMMAgent/programdata/customization/av_override.json" | tr -s " " | sed s/\"av_version\"://g | sed -e 's/^[[:space:]]*//' | sed 's/[\",]//g' | sed -e 's/[[:space:]]*$//')
  avStatuses=$(grep "av_status" "/Applications/NinjaRMMAgent/programdata/customization/av_override.json" | tr -s " " | sed s/\"av_status\"://g | sed -e 's/^[[:space:]]*//' | sed 's/[\",]//g' | sed -e 's/[[:space:]]*$//')
  avStates=$(grep "av_state" "/Applications/NinjaRMMAgent/programdata/customization/av_override.json" | tr -s " " | sed s/\"av_state\"://g | sed -e 's/^[[:space:]]*//' | sed 's/[\",]//g' | sed -e 's/[[:space:]]*$//')

  # Find the line number of the existing antivirus entry with the given name
  existingAV=$(echo "$avNames" | grep -n "$_arg_antivirusName" | sed 's/:.*//g')

  # Determine the desired antivirus status
  if [[ -n $_arg_antivirusStatus ]]; then
    desiredStatus=$_arg_antivirusStatus
  elif [[ -n $existingAV ]]; then
    desiredStatus=$(echo "$avStatuses" | sed -n "${existingAV}p")
  fi

  # Determine the desired antivirus state
  if [[ -n $_arg_antivirusState ]]; then
    desiredState=$_arg_antivirusState
  elif [[ -n $existingAV ]]; then
    desiredState=$(echo "$avStates" | sed -n "${existingAV}p")
  fi

  # Check if both status and state are provided
  if [[ -z $desiredStatus || -z $desiredState ]]; then
    _PRINT_HELP=no die "[Error] Antivirus state or status are missing from the override entry. Please provide both in addition to the antivirus name!" 1
  fi

  # Update the existing antivirus entry if found
  if [[ -n $existingAV ]]; then
    echo "Attempting to update override."

    # Update antivirus version if provided
    if [[ -n $_arg_antivirusVersion ]]; then
      modified_json=$(awk -v target="$existingAV" -v value="$_arg_antivirusVersion" 'BEGIN { av_count = 1 }
      /av_version/ { 
        if (av_count == target){ 
          sub( /av_version.*/ , "av_version\":  \""value"\"," ) 
        }
        av_count++
      }{ print }' "/Applications/NinjaRMMAgent/programdata/customization/av_override.json")

      if echo "$modified_json" >"/Applications/NinjaRMMAgent/programdata/customization/av_override.json"; then
        echo "Successfully updated the antivirus version!"
      else
        echo "[Error] Failed to update the antivirus version!" >&2
        exit 1
      fi
    fi

    # Update antivirus status if provided
    if [[ -n $_arg_antivirusStatus ]]; then
      modified_json=$(awk -v target="$existingAV" -v value="$_arg_antivirusStatus" 'BEGIN { av_count = 1 }
      /av_status/ { 
        if (av_count == target){ 
          sub( /av_status.*/ , "av_status\":  \""value"\"," ) 
        }
        av_count++
      }{print}' "/Applications/NinjaRMMAgent/programdata/customization/av_override.json")

      if echo "$modified_json" >"/Applications/NinjaRMMAgent/programdata/customization/av_override.json"; then
        echo "Successfully updated the override status!"
      else
        echo "[Error] Failed to update the override status!" >&2
        exit 1
      fi
    fi

    # Update antivirus state if provided
    if [[ -n $_arg_antivirusState ]]; then
      modified_json=$(awk -v target="$existingAV" -v value="$_arg_antivirusState" 'BEGIN { av_count = 1 }
      /av_state/ { 
        if (av_count == target){ 
          sub( /av_state.*/ , "av_state\":  \""value"\"" ) 
        }
        av_count++
      }{print}' "/Applications/NinjaRMMAgent/programdata/customization/av_override.json")

      if echo "$modified_json" >"/Applications/NinjaRMMAgent/programdata/customization/av_override.json"; then
        echo "Successfully updated the override state!"
      else
        echo "[Error] Failed to update the override state!" >&2
        exit 1
      fi
    fi

    exit
  fi

  # Print a message indicating that the script is attempting to append an override
  echo "Attempting to append override."
  # Initialize a counter for indexing
  i=1
  # Initialize the JSON structure for antivirus overrides
  avOverrides="{
  \"av_override\": [
"
  # Loop through each antivirus name
  for avName in $avNames; do
    # Extract the corresponding antivirus version, status and state for the current index
    avVersion=$(echo "$avVersions" | sed -n "${i}p")
    avStatus=$(echo "$avStatuses" | sed -n "${i}p")
    avState=$(echo "$avStates" | sed -n "${i}p")

    # Append the current antivirus entry to the JSON structure
    avOverrides+="    {
      \"av_name\":  \"${avName}\",
      \"av_version\": \"${avVersion}\",
      \"av_status\":  \"${avStatus}\",
      \"av_state\": \"${avState}\"
    },
"
    # Increment the counter for the next iteration
    i=$((i + 1))
  done

  # Close the JSON structure
  avOverrides+="    {
      \"av_name\":  \"${_arg_antivirusName}\",
      \"av_version\": \"${_arg_antivirusVersion}\",
      \"av_status\":  \"${_arg_antivirusStatus}\",
      \"av_state\": \"${_arg_antivirusState}\"
    }
  ]
}
"

  # Attempt to write the JSON structure containing antivirus overrides to the specified file
  if echo "$avOverrides" >"/Applications/NinjaRMMAgent/programdata/customization/av_override.json"; then
    echo "Succesfully added override."
    exit
  else
    echo "[Error] Failed to add override." >&2
    exit 1
  fi
fi

# Check if the antivirus state or status arguments are missing
if [[ -z $_arg_antivirusState || -z $_arg_antivirusStatus ]]; then
  _PRINT_HELP=no die "[Error] Antivirus name, state and status are required when adding a new override!" 1
fi

# Construct the JSON string for the antivirus override
JSON_STRING="{
  \"av_override\": [
    {
      \"av_name\":  \"${_arg_antivirusName}\",
      \"av_version\":  \"${_arg_antivirusVersion}\",
      \"av_status\":  \"${_arg_antivirusStatus}\",
      \"av_state\":  \"${_arg_antivirusState}\"
    }
  ]
}
"

# Attempt to write the JSON string to the specified file
if echo "$JSON_STRING" >"/Applications/NinjaRMMAgent/programdata/customization/av_override.json"; then
  # If the write operation is successful, print a success message
  echo "Succesfully created override."
else
  # If the write operation fails, print an error message to standard error
  echo "[Error] Failed to create override." >&2
  exit 1
fi

 

Analisi dettagliata dello script per impostare le informazioni antivirus

Analizziamo lo script per impostare le informazioni antivirus e comprendiamo le sue funzionalità principali:

Parametri di ingresso e convalida

Lo script per impostare le informazioni antivirus accetta diversi parametri preimpostati tramite argomenti della riga di comando:

• –antivirusName definisce il nome del programma antivirus.
• –antivirusVersion specifica il numero di versione.
• –antivirusStatus indica se le definizioni sono aggiornate, non aggiornate o sconosciute.
• –antivirusState descrive lo stato operativo del programma (ad esempio, ON, OFF, EXPIRED).
• Flag come –removeOverride e –append determinano se cancellare o aggiornare le sovrascritture esistenti.

Lo script per impostare le informazioni antivirus convalida rigorosamente gli input, garantendo che nessun dato non valido, come caratteri o stati non supportati, corrompa la configurazione delle eccezioni.

Guida e gestione degli errori

La funzione print_help fornisce agli utenti istruzioni dettagliate sull’uso, mentre la gestione degli errori assicura che l’uso scorretto o gli input imprevisti vengano affrontati generando con messaggi chiari. Per esempio, la notifica agli utenti di argomenti mancanti o di stati antivirus non validi.

Gestione delle eccezioni tramite JSON

Lo script per impostare le informazioni antivirus interagisce con un file di override situato in /Applications/NinjaRMMAgent/programdata/customization/av_override.json. In base alle azioni dell’utente:

1. Rimuove l’eccezione: Cancella il file di override, se presente, assicurando che nessuna configurazione residua influisca sul comportamento del dispositivo.
2. Aggiunge/aggiorna l’eccezione: Aggiunge nuovi dati antivirus o modifica le voci esistenti. Questo comporta l’analisi del file JSON, l’individuazione di voci specifiche e l’aggiornamento dei campi, se necessario.

Gestione delle directory

Se la directory di personalizzazione non esiste, lo script per impostare le informazioni antivirus la crea per garantire che il file di override possa essere archiviato in modo affidabile. Se la creazione della directory non riesce, vengono registrati messaggi di errore.

Uscita e feedback

Gli utenti ricevono un feedback dettagliato a ogni passo, come per esempio dopo gli aggiornamenti riusciti o non riusciti durante la manipolazione di JSON.

Casi d’uso potenziali

Caso d’uso Aggiornamento dei dettagli dell’antivirus su un dispositivo macOS gestito

Immagina un MSP che gestisce un parco dispositivi macOS in cui un sottoinsieme di dispositivi ha registrazioni antivirus obsolete. Utilizzando questo script, l’amministratore IT può:

1. Aggiungere o aggiornare i record antivirus con la versione e lo stato più recenti (–antivirusVersion “2.5.3” –antivirusStatus “Up-to-Date”).
2. Rimuovere le eccezioni obsolete per i dispositivi che non richiedono più configurazioni antivirus (–removeOverride).
3. Automatizzare la gestione della configurazione su più dispositivi distribuendo lo script tramite strumenti RMM come NinjaOne.

Questo processo semplificato riduce al minimo l’intervento manuale e garantisce un reporting accurato nelle verifiche di conformità.

Confronti

Script e modifica manuale del file JSON a confronto

La modifica manuale dei file JSON è soggetta a errori di sintassi e manca di scalabilità. Questo script automatizza il processo per impostare le informazioni antivirus, riducendo l’errore umano e consentendo aggiornamenti in batch su tutti i dispositivi.

Script e strumenti di automazione personalizzati

Le grandi aziende enterprise potrebbero preferire piattaforme di automazione complesse, ma questo script per impostare le informazioni antivirus offre un’alternativa leggera e conveniente per gli ambienti IT di piccole e medie dimensioni.

Domande frequenti

1. Questo script per impostare le informazioni antivirus può essere utilizzato su sistemi non MacOS?
   No, questo script per impostare le informazioni antivirus è stato progettato specificamente per macOS, sfruttando percorsi e comandi unici della piattaforma.
2. Cosa succede se un file di override non esiste?
   Lo script per impostare le informazioni antivirus gestisce questo problema creando automaticamente la struttura necessaria di directory e file.
3. Posso aggiornare solo campi specifici senza influenzare gli altri?
   Sì, il flag –append consente aggiornamenti selettivi senza sovrascrivere campi non correlati.
4. Come gestisce lo script le azioni in conflitto, come l’aggiunta e la rimozione simultanea delle eccezioni?
   Previene esplicitamente tali conflitti, inducendo gli utenti a scegliere un’azione alla volta.

Implicazioni

Informazioni antivirus accurate contribuiscono alla sicurezza dell’ambiente IT, consentendo il monitoraggio in tempo reale e il rilevamento delle minacce. Automatizzando le eccezioni, i team IT possono concentrarsi sulle misure di sicurezza proattive piuttosto che sulle correzioni manuali dei dati. Tuttavia, un uso improprio di questo script per impostare le informazioni antivirus potrebbe inavvertitamente sovrascrivere le configurazioni critiche, sottolineando la necessità di un uso attento e di test approfonditi.

Raccomandazioni

• Testa lo script per impostare le informazioni antivirus in un ambiente controllato prima di distribuirlo su larga scala.
• Conserva un backup dei file JSON originali per recuperare da eventuali modifiche non intenzionali.
• Utilizza convenzioni di denominazione chiare e coerenti per le voci antivirus per evitare duplicazioni.
• Sfrutta strumenti RMM come NinjaOne per distribuire ed eseguire questo script per impostare le informazioni antivirus su tutti i dispositivi senza interruzioni.

Considerazioni finali

Questo script per impostare le informazioni antivirus è un ottimo esempio di come l’automazione possa migliorare l’efficienza e l’accuratezza della gestione IT. Per i professionisti IT che utilizzano NinjaOne, l’integrazione di tali script nel toolkit della piattaforma offre un modo potente per gestire i dispositivi macOS anche su larga scala. Che tu voglia aggiornare le configurazioni dell’antivirus o semplificare i processi di conformità, questo script per impostare le informazioni antivirus rappresenta un’aggiunta preziosa al tuo arsenale IT.