Visualizzazione post con etichetta script. Mostra tutti i post
Visualizzazione post con etichetta script. Mostra tutti i post

venerdì 1 dicembre 2023

PowerShell: Muovere il puntatore del mouse

Tramite PowerShell è possibile muovere il puntatore del mouse utilizzando l'assembly System.Windows.Forms, che contiene le classi per gestire la finestra grafica.

PowerShell


Un semplice script che muove il mouse ogni 30 secondi è il seguente

 Add-Type -AssemblyName System.Windows.Forms  
 # Ciclo infinito che aggiorna la posizione del mouse ogni 30 secondi finchè non viene premuto CTRL+C o chiusa la finestra  
 while ($true)  
 {  
  # Rileva la posizione attuale del mouse  
  $Pos = [System.Windows.Forms.Cursor]::Position  
  # Creo le nuove coordinate del puntatore aggiungendo un pixel e facendo in modo da non uscire dallo schermo (% 500)  
  $x = ($pos.X % 500) + 1  
  $y = ($pos.Y % 500) + 1  
  # Posiziona il puntatore del mouse nelle nuove coordinate  
  [System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point($x, $y)  
  # Attende 30 secondi  
  Start-Sleep -Seconds 30  
 }  
Nello script, per evitare che il mouse finisca fuori dallo schermo, è stato adottato un piccolo espediente: il valore delle coordinate viene diviso per 500 e viene prelevato il resto della divisione (che sarà sicuramente inferiore a 500).

Per muovere il cursore in maniera randomica sullo schermo si può utilizzare il seguente script
 Add-Type -AssemblyName System.Windows.Forms  
   
 # Rileva la risoluzione del monitor principale  
 $WindowSize = [System.Windows.Forms.Screen]::GetWorkingArea(0)  
 $MaxWidth = $WindowSize.Width  
 $MaxHeight = $WindowSize.Height  
   
 #Esegue un loop e aggiorna la posizione del mouse finché non viene premuto CTRL + C o viene chiusa la finestra  
 while ($true)  
 {  
   # Genera randomincamente le nuove coordinale tenendo conto della risoluzione  
   $x = (Get-Random -Minimum 0 -Maximum $MaxWidth)  
   $y = (Get-Random -Minimum 0 -Maximum $MaxHeight)  
   Write-Host "`rNew position: x:$($x),y:$($y)  " -NoNewLine  
   # Posiziona il cursore nelle nuove coordinate  
   [System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point($x, $y)  
   # Attende 30 secondi  
   Start-Sleep -Seconds 30  
 }  
Per chi stesse pensando di utilizzare questo metodo per evitare che Windows vada in stand-by in caso di inattività, dovrà pensare ad una soluzione alternativa. Il movimento del mouse tramite PowerShell, infatti, non è sufficiente affinché il sistema venga considerato "attivo" e Windows provvederà comunque a visualizzare lo screensaver, oscurare/bloccare lo schermo o attivare il risparmio energetico dopo un periodo di inattività.
Per fare in modo che Windows rilevi che il pc sia utilizzato è necessario un input da parte dell'utente e non solo il movimento del mouse. Per simulare l'input da parte dell'utente, ad esempio la pressione di un tasto, si può utilizzare il metodo SendKeys che illustrerò in un altro articolo.




mercoledì 13 luglio 2022

PowerShell: Verificare se un account utente è disabilitato/abilitato in Active Directory

Per verificare se un account utente è abilitato o disabilitato in Active Directory è possibile utilizzare il seguente script PowerShell
 $User = Read-Host -Prompt "Inserisci il nome dell'account";    
 Get-ADUser -Filter {name -like $User -or samaccountname -like $User} | Select Name, SamAccountName, Enabled   
Verifica account
FIG 1 - Verifica account


Se si dispone di un file contenente l'elenco degli utenti da verificare è possibile utilizzare il seguente codice andando a sostituire la stringa C:\Temp\ElencoUtenti.txt con il percorso e il nome del file contenente l'elenco.
 $userList = "C:\Temp\ElencoUtenti.txt"  
 $users = Get-Content $userList  
 foreach ($user in $users){  
  Get-ADUser -Filter {name -like $user -or samaccountname -like $user} | Select Name, SamAccountName, Enabled   
 }  





giovedì 3 febbraio 2022

PowerShell: Ottimizzare le prestazioni degli script

A chi lavora con gli script PowerShell viene spesso richiesto di ottimizzare il codice e i tempi di esecuzione al fine di ridurre gli impatti sul sistema. Per script complessi e lunghi non è semplice individuare la causa di ritardi nell'esecuzione e cosa andare ad ottimizzare. In questi casi può essere d'aiuto un modulo PowerShell chiamato "PSProfiler" che visualizza il tempo di esecuzione di ogni linea presente all'interno dello script.

Per poter utilizzare tale modulo va prima installato con il comando
Install-Module -Name PSProfiler -Scope CurrentUser  
PSProfiler
FIG 1 - PSProfiler

Successivamente lo script da analizzare va invocato mediante Measure-Script
Measure-Script -Path  C:\Users\Virtual\bubble_sort.ps1

Una volta completata l'esecuzione dello script, viene visualizzato un rapporto dettagliato che mostra quante volte ogni linea di codice è stata eseguita e quanto tempo ha impiegato.
Report PSProfiler
FIG 2 - Report PSProfiler






martedì 18 gennaio 2022

PowerShell: Catturare uno screenshot

Tramite PowerShell è possibile catturare lo schermo e salvare lo screenshot all'interno di un file utilizzando i tipi presenti in System.Windows.Forms. Il seguente script mostra come catturare lo schermo virtuale e salvarlo all'interno di un file bitmap per poi aprirlo con il programma associato.
  #specifica il path in cui salvare lo screenshot   
  $Path = "$Env:temp\screenshot.bmp"   
     
  Add-Type -AssemblyName System.Windows.Forms   
     
  #Prepara l'area da catturare   
  $screen = [System.Windows.Forms.SystemInformation]::VirtualScreen   
  $width = $screen.Width   
  $height = $screen.Height   
  $left = $screen.Left   
  $top = $screen.Top   
  #Crea un immagine bitmap   
  $bitmap = [System.Drawing.Bitmap]::new($width, $height)   
  #Crea un nuovo oggetto Graphics dall'oggetto $bitmap   
  $MyDrawing = [System.Drawing.Graphics]::FromImage($bitmap)   
  #Copia il contenuto dello schermo nell'oggetto $bitmap   
  $MyDrawing.CopyFromScreen($left, $top, 0, 0, $bitmap.Size)   
     
  #Salva lo screenshot nel percorso specificato   
  $bitmap.Save($Path)   
  #visualizza l'immagine bmp salvata utilizzando il programma associato   
  Start-Process -FilePath $Path   


Screenshot
FIG 1 - Screenshot

Dal seguente link è possibile scaricare il codice dello script:





mercoledì 24 marzo 2021

PowerShell: Convertire un file eseguibile in un file di testo (Parte 1)

In alcuni contesti, per passare "inosservati" e superare restrizioni e controlli, può essere utile trasformare temporaneamente un file eseguibile in un innocuo file di testo per poi eseguire l'operazione inversa in un secondo momento. Tale conversione può essere eseguita tramite un semplice script PowerShell

La conversione può essere effettuata con poche righe di codice come quelle mostrate di seguito

    [CmdletBinding()] Param(
        [Parameter(Position = 0, Mandatory = $True)]
        [String]
        $FileEXE, 
        
        [Parameter(Position = 1, Mandatory = $False)]
        [String]
        $FileTXT = "$pwd\EseguibileConvertito.txt"
    )
    [byte[]] $dump = Get-Content -encoding byte -path "$FileEXE" -ReadCount 0
    [System.IO.File]::WriteAllLines($FileTXT, ([string]$dump))
    Write-Output "Il file e' stato convertito in $FileTXT"


Innanzitutto andiamo a caricare i parametri passati durante la chiamata dello script. Nella variabile $FileEXE andiamo a caricare il primo parametro passato, obbligatorio, che corrisponde al file eseguibile da convertire.
Il secondo parametro, facoltativo, verrà caricato nella variabile $FileTXT e rappresenta il nome del file di testo in cui verrà salvata la conversione. Nel caso in cui tale parametro non venisse specificato, il file di testo verrà creato nel percorso corrente ($pwd) e gli verrà assegnato il nome EseguibileConvertito.txt.

Le due istruzioni più interessanti sono
    [byte[]] $dump = Get-Content -encoding byte -path "$FileEXE" -ReadCount 0
    [System.IO.File]::WriteAllLines($FileTXT, ([string]$dump))

Con la prima, attraverso il cmdlet Get-Content e il parametro -encoding byte, andiamo a caricare tutti i byte che compongono il file eseguibile in un array di byte. Il parametro -ReadCount 0 permette di leggere tutto il contenuto del file eseguibile in una singola operazione.
Nell'istruzione successiva i byte vengono trasformati in testo per essere scritti all'interno del file di output. Il file di output avrà una dimensione superiore a quella del file eseguibile di partenza. 

Dal seguente link è possibile scaricare lo script Exe2Txt.ps1

Script PowerShell Exe2Txt
FIG 1 - Script PowerShell Exe2Txt.ps1




martedì 3 novembre 2020

PowerShell: Individuare e cancellare gli account utente inutilizzati presenti in Active Directory

Lo script che verrà mostrato in quest'articolo consente di ricercare, all'interno di Active Directory, tutti gli account utente non utilizzati (in base alle condizioni specificate). La ricerca viene eseguita utilizzando il cmdlet Get-ADUser. I risultati saranno salvati all'interno di un file CSV e, con una semplice modifica (assegnando alla variabile $remove_unused_account il valore $true), sarà possibile fare in modo che gli account inutilizzati trovati vengano automaticamente eliminati da Active Directory (mediante il cmdlet Remove-ADUser).

Lo script può essere scaricato dal seguente link e le istruzioni sono ampiamente documentate  dalle righe di commenti.

Account utente inutilizzati
FIG 1 - Account utente inutilizzati




sabato 2 novembre 2019

Fogli Google: Ordinare i fogli in ordine alfabetico

Nell'articolo MS Excel: Ordinare i fogli in ordine alfabetico è stato mostrato come, attraverso l'utilizzo di VBA (Visual Basic for Application) sia possibile ordinare i fogli di una cartella di lavoro di un documento MS ExcelGoogle Docs (Documenti Google) non supporta VBA (proprietario di Microsoft) ma utilizza Google Apps Script: un linguaggio di scripting basato su JavaScript che gira nella cloud. In questo articolo mostrerò come creare uno script all'interno di Fogli Google che consenta di ordinare i fogli presenti all'interno del documento.

I passi da seguire sono semplici:
  • Creare un nuovo foglio di lavoro o aprirne uno già esistente accedendo a Google Docs tramite la pagina https://docs.google.com/spreadsheets/u/0/;
    Fogli Google, creare un nuovo foglio di lavoro
    FIG 1 - Fogli Google, creare un nuovo foglio di lavoro
  • Dal menu Strumenti selezionare Editor di script;
    Google Docs, Editor di script
    FIG 2 - Google Docs, Editor di script
  • Cliccare su Progetto senza titolo quindi assegnare un nome al progetto e cliccare su OK;
    Google Docs, Nome Progetto
    FIG 3 - Google Docs, Nome Progetto
  • Copiare e incollare il seguente codice;
    function onOpen() {
      SpreadsheetApp.getUi().createMenu('Ordina Fogli')
        .addItem('Ordina dalla A alla Z', 'sortAtoZ')
        .addItem('Ordina dalla Z alla A', 'sortZtoA')
        .addItem('Ripristina ordine prec.', 'ripristina')
        .addToUi();
    }
    
    function sortAtoZ() {
      var ss = SpreadsheetApp.getActiveSpreadsheet(), old = [];  
      ss.getSheets().map ( function (d) {
        var name = d.getName();
        old.push(name);
        return name;
      }).sort().reduce ( function  (arr, e, j) {
        ss.setActiveSheet(ss.getSheetByName(e));
        ss.moveActiveSheet(j + 1);
        return arr;
      }, []);
      PropertiesService.getScriptProperties().setProperty('old', JSON.stringify(old));
    }
    
    function sortZtoA() {
      var ss = SpreadsheetApp.getActiveSpreadsheet(), old = [];  
      ss.getSheets().map ( function (d) {
        var name = d.getName();
        old.push(name);
        return name;
      }).sort().reverse().reduce ( function  (arr, e, j) {
        ss.setActiveSheet(ss.getSheetByName(e));
        ss.moveActiveSheet(j + 1);
        return arr;
      }, []);
      PropertiesService.getScriptProperties().setProperty('old', JSON.stringify(old));
    }
    
    function ripristina(range) {
      var ss = SpreadsheetApp.getActiveSpreadsheet();
      var range = JSON.parse(PropertiesService.getScriptProperties().getProperty('old'));  
      range.reduce ( function  (arr, e, j) {
        ss.setActiveSheet(ss.getSheetByName(e));
        ss.moveActiveSheet(j + 1);
        return arr;
      }, []);
    }
    
  • Cliccare sul pulsante che rappresenta un insetto per eseguire il debug e il salvataggio del progetto e seguire le istruzioni a video per autenticare/autorizzare lo script;
    Google Docs, script debug
    FIG 4 - Google Docs, script debug
  • Chiudere e riaprire il foglio di lavoro. Apparirà un nuovo menu Ordina Fogli che consentirà di ordinare i fogli in maniera crescente (dalla A alla Z), decrescente (dalla Z alla A) o ripristinare l'ordine precedente all'ultima modifica.
    Google Docs, nuovo menu Ordina Fogli
    FIG 5 - Google Docs, nuovo menu Ordina Fogli


Come visibile dallo script, i nomi dei fogli vengono considerati come stringhe, ciò significa che se i nomi sono numeri questi vengono ordinati considerando l'ordine alfabetico e non il loro valore numerico.

Dal seguente link è possibile scaricare un file di testo contenente il codice dello script
DOWNLOAD






lunedì 23 settembre 2019

PowerShell: Creare una GUI per uno script PowerShell

Gli script PowerShell vengono generalmente creati ed eseguiti all'interno di un'interfaccia a riga di comando e anche i risultati vengono visualizzati all'interno della finestra CLI (Command Line Interface). Ciò ne scoraggia l'utilizzo da parte degli utenti comuni. Tuttavia, PowerShell è un potente strumento di automazione e consente l'utilizzo di una varietà di oggetti .NET Framework. Per creare una semplice interfaccia grafica per gli script PowerShell basta utilizzare l'API .NET.

In quest'articolo verrà mostrato come creare un semplice Form. Prima di iniziare assicurarsi che la versione di PowerShell installata sul proprio sistema sia 3.0 o superiore. Per farlo basta eseguire $PSVersionTable.PSVersion da una finestra PowerShell per visualizzare un'output come quello mostrato in FIG 1. Se la variabile non esiste allora probabilmente si tratta della versione 1.0

Versioni di PowerShell:
  • Versione 1.0: distribuita nel 2006 come download opzionale. Obsoleta
  • Versione 2.0: distribuita nel 2009 come parte di Windows 7/Windows Server 2008. L'unica versione che supporta Windows XP e Windows Server 2003.
  • Versione 3.0: distribuita nel 2012 come parte di Windows 8/Windows Server 2012. Sono state completate le caratteristiche principali del linguaggio ed è stato riprogettato l'editor ISE.
  • Versione 4.0: distribuita nel 2013 come parte di Windows 8.1/Windows Server 2012R2. Aggiunto DSC (Desired State Configuration).
  • Versione 5.0: distribuita nel 2016 come parte di Windows 10. In tale versione sono state introdotte numerose funzionalità ed estensioni.
  • Versione 5.1: distribuita nel 2017 come parte di Windows 10 Anniversary Update\Windows Server 2016.

PowerShell, visualizzare la versione installata nel sistema
FIG 1 - PowerShell, visualizzare la versione installata nel sistema
Il blocco di codice per creare un semplice Form è il seguente:

Add-Type -assembly System.Windows.Forms
$form = New-Object System.Windows.Forms.Form
$form.Text ='La mia finestra in PowerShell'
$form.Width = 400
$form.Height = 200
$form.AutoSize = $true
$form.ShowDialog()

Per la creazione del Form viene utilizzata la classe System.Windows.Forms di .NET. Per caricare tale classe all'interno dello script PowerShell si utilizza tale codice:
Add-Type -assembly System.Windows.Forms

Nell'istruzione successiva 
$form = New-Object System.Windows.Forms.Form
viene avviata una nuova istanza della classe System.Windows.Forms.Form di .NET Framework che genera una finestra vuota (Form o modulo) in cui è possibile iniziare ad aggiungere controlli.

Successivamente viene impostato un titolo per la finestra attraverso la proprietà Text, quindi vengono impostate le dimensioni (larghezza e altezza) tramite le proprietà Width e Height
$form.Text ='La mia finestra in PowerShell'
$form.Width = 400
$form.Height = 200

Per fare in modo che il Form si ridimensioni automaticamente in base al suo contenuto viene utilizzata la proprietà AutoSize.
$form.AutoSize = $true

L'ultima istruzione 
$form.ShowDialog()
non fa altro che richiamare il metodo ShowDialog per visualizzare a video il Form.

Per creare lo script basta copiare il blocco di codice sopra indicato all'interno di un editor di testo (come ad es. Blocco Note) e salvare il file con estensione .ps1 (ad es. Form1.ps1). Per eseguirlo da PowerShell digitare il nome del file .ps1 comprensivo del percorso (ad es. c:\Users\glubrano\desktop\Form1.ps1). Il risultato sarà quello mostrato in FIG 2.

Dal seguente link è possibile scaricare il file contenente il blocco di codice.
DOWNLOAD Form1.ps1
Form in PowerShell
FIG 2 - Form in PowerShell



Il Form così creato serve a ben poco. Possiamo aggiungere altri elementi come un etichette (label), una casella combinata (combobox) e un pulsante (button). Quello che andremo a costruire nelle prossime righe è uno script PowerShell che permette di selezionare, all'interno della combobox, una specifica cartella e, cliccando sul pulsante, visualizzarne la data dell'ultima modifica.

Iniziamo ad inserire un etichetta. Per farlo basta aggiungere il seguente blocco di codice prima dell'ultima istruzione $form.ShowDialog().

$Label1 = New-Object System.Windows.Forms.Label
$Label1.Text = "Directory:"
$Label1.Location  = New-Object System.Drawing.Point(5,10)
$Label1.AutoSize = $true
$form.Controls.Add($Label1)

Con la prima istruzione viene creata una nuova istanza della classe System.Windows.Forms.Label che genera l'etichetta. Successivamente viene specificato il testo che l'etichetta andrà a visualizzare quindi, tramite System.Drawing.Point(5,10) andiamo a specificare la posizione, all'interno del Form, in cui verrà visualizzata l'etichetta. Anche in questo caso viene impostata la proprietà AutoSize in modo che le dimensioni dell'elemento si adeguano in base al contenuto. 
L'ultima istruzione 
$form.Controls.Add($Label1)
aggiunge l'etichetta al form precedentemente creato.


Il passo successivo consiste nell'inserire una casella combinata accanto all'etichetta. Aggiungiamo il seguente blocco di codice al nostro file .PS1 (assicurandoci che l'ultima istruzione sia sempre $form.ShowDialog()) .

$ComboBox1 = New-Object System.Windows.Forms.ComboBox
$ComboBox1.Width = 150
$Folders = get-childitem -dir | Select Name
Foreach ($Folder in $Folders){
 $ComboBox1.Items.Add($Folder.Name);
}
$ComboBox1.Location  = New-Object System.Drawing.Point(60,10)
$form.Controls.Add($ComboBox1)

In questo blocco gran parte delle istruzioni sono analoghe a quanto visto per i blocchi precedenti. Con l'istruzione
$Folders = get-childitem -dir | Select Name
andiamo ad assegnare alla variabile $Folders l'elenco delle directory presenti nel path da cui stiamo richiamando lo script. Il ciclo ForEach non fa altro che estrarre il nome delle directory e inserirle all'interno della combobox.


Il blocco successivo provvede ad inserire all'interno del Form due etichette: Label2 e Label3. Quest'ultima mostrerà la data dell'ultima modifica della cartella selezionata quando si clicca sul pulsante presente alla destra della combobox.

$Label2 = New-Object System.Windows.Forms.Label
$Label2.Text = "Data modifica:"
$Label2.Location  = New-Object System.Drawing.Point(5,40)
$Label2.AutoSize = $true
$form.Controls.Add($Label2)

$Label3 = New-Object System.Windows.Forms.Label
$Label3.Text = ""
$Label3.Location  = New-Object System.Drawing.Point(90,40)
$Label3.AutoSize = $true
$form.Controls.Add($Label3)

Blocco codice relativo al pulsante. 

$Button1 = New-Object System.Windows.Forms.Button
$Button1.Location = New-Object System.Drawing.Point(220,10)
$Button1.Size = New-Object System.Drawing.Size(150,20)
$Button1.Text = "Visualizza data modifica"
$form.Controls.Add($Button1)

Anche questi 2 blocchi vanno inseriti prima dell'istruzione $form.ShowDialog(). Nel blocco relativo al pulsante troviamo l'istruzione 
$Button1.Size = New-Object System.Drawing.Size(120,20)
che consente di specificare la dimensione dell'elemento.

Adesso non resta che inserire un'ultimo blocco in cui andiamo ad aggiungere un evento relativo al click sul pulsante. 

$Button1.Add_Click(
 {
  $Label3.Text =  (get-item  $ComboBox1.selectedItem).LastWriteTime 
 }
)

L'istruzione
$Label3.Text =  (get-item  $ComboBox1.selectedItem).LastWriteTime 
rileva la data di modifica della directory selezionata all'interno della combobox e la visualizza attraverso la Label3.

L'intero script può essere scaricato dal seguente link
DOWNLOAD Form2.ps1

Eseguendo lo script, l'output sarà simile a quello mostrato in FIG 3.
PowerShell, Visualizzare la data di modifica di una data cartella attraverso il Form
FIG 3 - PowerShell, Visualizzare la data di modifica di una data cartella attraverso il Form


In modo analogo possono essere inseriti ulteriori elementi all'interno del Form come:
- CheckBox
- ChekedListBox
- ContextMenu
- DateTimePicker
- GroupBox
- HScrollBar
- ListBox
- ListView
- Menu
- PictureBox
- ProgressBar
- RadioButton
- TabControl
- TextBox
- TrackBar
- TreeView
- VScrollBar


Per creare in maniera semplice Form accattivanti per script in PowerShell, è possibile usare l'editor online https://poshgui.com/Editor. Tale editor, attraverso una semplice interfaccia grafica, consente di progettare/realizzare una GUI per i propri script PowerShell anche a chi è poco pratico e scaricare il codice sorgente.
POSHGUI, Editor online GUI PowerShell
FIG 4 - POSHGUI, Editor online GUI PowerShell





mercoledì 27 marzo 2019

PowerShell: Disabilitare il risparmio energetico sulle schede di rete

Quando il PC entra in modalità sospensione/ibernazione, Windows disabilita tutte le periferiche non necessarie per risparmiare energia comprese le schede di rete. Tale comportamento può causare malfunzionamenti quando si riprende la sessione di lavoro: ad es. la scheda di rete potrebbe non riattivarsi.
Una soluzione a questo tipo di problemi consiste nell'impedire al sistema operativo di spegnere le schede di rete per risparmiare energia. 


Disabilitare il risparmio energetico sulla scheda di rete tramite GUI

  • Premere la combinazione di tasti WIN+R per aprire la finestra di dialogo Esegui e digitare devmgmt.msc seguito da invio per avviare Gestione dispositivi;

    Gestione dispositivi
    FIG 1 - Gestione dispositivi
  • Espandere la sezione Schede di rete ed eseguire un doppio click sulla scheda di rete su cui si intende disabilitare il risparmio energetico;
  • Nella finestra delle Proprietà, selezionare la scheda Risparmio energia quindi rimuovere la spunta alla voce Consenti al computer di spegnere il dispositivo per risparmiare energia e confermare cliccando sul pulsante OK.
    Proprietà scheda di rete
    FIG 2 - Proprietà scheda di rete



Disabilitare il risparmio energetico sulle schede di rete tramite PowerShell


Nello script PowerShell andremo a verificare le proprietà delle schede di rete presenti nel registro di sistema al seguente percorso
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Class\{4D36E972-E325-11CE-BFC1-08002BE10318}
All'interno delle sottochiavi del registro andremo a verificare la proprietà *ifType per individuare le schede di rete Wi-Fi (con *ifType=6) e le schede di rete Ethernet (con *ifType=71). Per tali schede il risparmio energetico verrà disattivato valorizzando la proprietà PnPCapabilities a 18 in esadecimale (24 in decimale).
Lo script, oltre a visualizzare l'output a video, genera un file di log DisablePowerSavingNIC.log che è possibile consultare successivamente anche dopo aver chiuso la finestra di PowerShell.
Script DisablePowerSavingNIC.ps1
FIG 3 - Script DisablePowerSavingNIC.ps1
Lo script può essere scaricato dal seguente link
DOWNLOAD

Terminata l'esecuzione, l'output sarà simile a quello mostrato in FIG 4 ed è necessario procedere al riavvio del sistema affinché le modifiche siano applicate.
Output script PowerShell DisablePowerSavingNIC.ps1
FIG 4 - Output script PowerShell DisablePowerSavingNIC.ps1




giovedì 14 marzo 2019

PowerShell: Creare un documento MS Excel contenente i risultati dei ping ad un elenco di postazioni

Potremmo trovarci nella situazione in cui ci viene richiesto di controllare se diverse postazioni siano connesse in rete. Il modo più semplice per eseguire tale controllo consiste nel verificare se le postazioni rispondono al ping. In questo articolo mostrerò come raggiungere tale obiettivo con uno script PowerShell che, dato un elenco di postazioni contenuto in un file di testo, provvede ad eseguire il ping e a memorizzare i risultati all'interno di un documento MS Excel.
Lo script può essere scaricato dal seguente link
DOWNLOAD
Script PowerShell PingHost2Excel
FIG 1 - Script PowerShell PingHost2Excel

La prima istruzione consiste nell'assegnare alla variabile $path il nome del file, comprensivo di percorso, contenente l'elenco delle workstation da verificare. Il contenuto del file sarà simile a quello mostrato in FIG 2: ogni riga contiene il nome della postazione da verificare.
Elenco Workstation da verificare
FIG 2 - Elenco Workstation da verificare

Successivamente con Test-Path verifichiamo se il file è presente, in caso contrario terminiamo lo script visualizzando il messaggio di file non trovato
$path = ".\ElencoWKS.txt"
if (Test-Path $path) 

Se il file contenente l'elenco delle workstation viene trovato procediamo alla creazione di un nuovo documento MS Excel e a posizionarci sul primo foglio di lavoro. 
$objExcel = new-object -comobject excel.application 

$objWorkbook = $objExcel.Workbooks.Add() 
$objWorksheet = $objWorkbook.Worksheets.Item(1)

Con la seguente istruzione facciamo in modo che il documento MS Excel sia visibile a video durante la compilazione.
$objExcel.Visible = $True

La prima riga del foglio di lavoro la utilizziamo come intestazione assegnando un nome a ciascuna colonna in base al contenuto che andremo successivamente ad inserire.
$objWorksheet.Cells.Item(1, 1) = "Nome Host"
$objWorksheet.Cells.Item(1, 2) = "Ping"
$objWorksheet.Cells.Item(1, 3) = "Indirizzo IP"


Nella variabile $wks andiamo a caricare l'elenco delle postazioni da analizzare. La variabile $row viene inizializzata a 2 (nella prima riga del foglio di lavoro abbiamo inserito l'intestazione) e verrà utilizzata per spostarci alla riga successiva man mano che verranno analizzate/inserite le workstation in elenco.
$wks= gc $path
$row=2

La parte più importante dello script è rappresentata dal ciclo foreach-object: per ogni postazione presente in elenco provvede ad inserire, all'interno del file MS Excel, il nome della postazione, l'esito del ping (OK se andato a buon fine o KO nel caso in cui non si riceve risposta) e l'eventuale indirizzo IP della postazione.
$wks| foreach-object{
 $ping=$null
 $workstation = $_
 $ping = Test-Connection $workstation -Count 1 -ea silentlycontinue
 $objWorksheet.Cells.Item($row,1) = $workstation
 
 if($ping){
  $objWorksheet.Cells.Item($row,2) = "OK"
  $objWorksheet.Cells.Item($row,3) = $ping.IPV4Address.IPAddressToString   
 }
 else {
  $objWorksheet.Cells.Item($row,2) = "KO"
  $objWorksheet.Cells.Item($row,3) = "-"
 }
  
 $row++
}


Foglio MS Excel con i risultati della verifica
FIG 3 - Foglio MS Excel con i risultati della verifica




lunedì 11 marzo 2019

PowerShell: Creazione di un documento Excel contenente l'elenco dei processi in esecuzione

Lo script PowerShell presentato in quest'articolo consente di creare un documento MS Excel in cui vengono elencati i processi in esecuzione sulla postazione con relative informazioni su Nome del processo, ID, tempo di CPU ed eventuale percorso del file eseguibile. Un prerequisito per l'esecuzione di tale script è che sulla postazione sia installato MS Excel.
Se eseguendo lo script si riceve errore relativo a restrizioni impostate sulla postazione, eseguire il comando
set-executionpolicy unrestricted

Analizziamo lo script nel dettaglio.
Nella variabile $path andiamo ad inserire il nome, comprensivo di percorso, da assegnare al documento MS Excel una volta creato.
$path = "c:\ElencoProcessi.xlsx"
Con le successive tre istruzioni viene avviato MS Excel, creata una nuova cartella di lavoro e all'interno di quest'ultima ci si posiziona sul foglio di lavoro che andrà a contenere le informazioni sui processi.
$objExcel = new-object -comobject excel.application 
$objWorkbook = $objExcel.Workbooks.Add() 
$objWorksheet = $objWorkbook.Worksheets.Item(1)

Per non visualizzare a video la finestra di MS Excel in fase di creazione del file, nello script viene utilizzata l'istruzione
$objExcel.Visible = $False
All'interno del foglio di lavoro utilizziamo la prima riga come riga di intestazione assegnando un nome a ciascuna colonna in base al contenuto che andremo successivamente ad inserire.
$objWorksheet.Cells.Item(1, 1) = "Process"
$objWorksheet.Cells.Item(1, 2) = "ID"
$objWorksheet.Cells.Item(1, 3) = "CPU"
$objWorksheet.Cells.Item(1, 4) = "Path"
Il cuore dello script è rappresentato dalle seguenti istruzioni. 
$row=2
Get-Process | Sort-Object ProcessName | Select ID, ProcessName,CPU, Path | foreach-object{ 
 $objWorksheet.Cells.Item($row,1) = $_.processname;
 $objWorksheet.Cells.Item($row,2) = $_.id;
 $objWorksheet.Cells.Item($row,3) = $_.cpu;
 $objWorksheet.Cells.Item($row,4) = $_.path;
 $row++
}
La variabile $row viene inizializzata a 2 (nella prima riga del foglio di lavoro abbiamo inserito l'intestazione) e verrà utilizzata per spostarci alla riga successiva man mano che verranno trovati e inseriti i processi all'interno del foglio. Tramite il cmdlet Get-Process otteniamo i processi in esecuzione che vengono ordinati per nome  con Sort-Object ProcessName e inseriti all'interno del foglio di lavoro.
Al termine non resta che salvare il documento creato e chiudere MS Excel. Nel caso in cui il nome del file risulti già presente, apparirà una finestra di dialogo in cui viene richiesto all'utente se intende sovrascriverlo.
$objWorkbook.SaveAs($path)
$objWorkbook.Close()
$objExcel.Quit()
PowerShell, Script ElencoProcessi.ps1
FIG 1 - PowerShell, Script ElencoProcessi.ps1

Lo script può essere scaricato dal seguente link
DOWNLOAD
All'interno dello script è presente la funzione Use-RunAs che forza l'esecuzione con i privilegi amministrativi (PowerShell: Forzare l'esecuzione di uno script con privilegi elevati). L'utilizzo di tale funzione non è strettamente necessaria ma può essere utile se si tenta di salvare il file in path che richiedono privilegi elevati.

MS Excel, Elenco Processi
FIG 2 - MS Excel, Elenco Processi