Differenze tra le versioni di "Inserire le password per lanciare comandi"
| Riga 293: | Riga 293: | ||
...... | ...... | ||
| + | |||
'''End''' | '''End''' | ||
Versione delle 08:48, 10 apr 2015
A volte può capitare che per poter utilizzare alcuni comandi, sia necessario inserire la propria parola-chiave di root.
A seconda delle circostanze vi sono alcune modilità.
Indice
Utilizzo della funzione Gambas: Desktop.RunAsRoot
Innanzitutto possiamo lanciare un comando bash attraverso la funzione propria di Gambas: Desktop.RunAsRoot. Essa presuppone innanzitutto che sia stato impostato il componente gb.desktop, e che sia presente nel sistema il programma xterm.
Nelle parentesi va scritta fra virgolette l'intera linea di comando da lanciare, e non il solo comando:
Public Sub Button1_Click()
Desktop.RunAsRoot("Intera_linea_di_comando")
End
Esempio:
Desktop.RunAsRoot("cat /dev/input/mouse0")
Se il codice prevede l'intercettazione di dati, questi potrebbero essere raccolti servendosi, laddove possibile, di una variabile d'appoggio.
Prendendo in considerazione l'esempio precedente:
Private fl As File
Private sFile As String
Public Sub Form_Open()
' Temp$() rappresenta il file temporaneo d'appoggio:
sFile = Temp$()
Desktop.RunAsRoot("cat /dev/input/mouse0 > " & sFile)
' Restiamo in attesa sino a quando il file non sarà creato:
Do
Wait 0.1
Loop Until Exist(sFile)
fl = Open sFile For Read Watch
End
Public Sub File_Read()
Dim s As String
s = File.Load(sFile)
TextEdit1.Text = s
End
Attendere sino a quando non è stata immessa la password
Nel precedente esempio abbiamo visto una modalità per far attendere al programma l'immissione della password necessaria per l'esecuzione del comando inserito nella funzione Desktop.RunAsRoot. In quel caso il codice attendeva la creazione di un file:
' Restiamo in attesa sino a quando il file non sarà creato:
Do
Wait 0.1
Loop Until Exist(sFile)
Ora vediamo una possibile soluzione nel caso in cui, invece, si debba attendere la chiusura della finestra di xterm, nella quale viene immessa la password, ossia la chiusura del processo di quel programma:
Public Sub Form_Open()
Dim s As String
' Intendo avviare il comando come "root":
Desktop.RunAsRoot("linea_di_comando")
' Per ciascun processo in questo momento attivo...
For Each s In Dir("/proc", "", gb.Directory)
' ...vado a vedere il file "comm":
If Exist("/proc" &/ s &/ "comm") Then
' Se in quel file c'è una stringa simile a "xterm",...
If File.Load("/proc" &/ s &/ "comm") Like "*xterm*" Then
' ...allora avvio il ciclo,
Do
Wait 0.01
' ...che gira in attesa fino a quando
' il processo di "xterm" non è stato terminato:
Loop Until Exist("/proc" &/ s) = False
Endif
Endif
Next
' Allora sono sicuro che ho passato *innanzitutto* la password,
' ed il comando bash dovrebbe così poter partire tranquillamente.
End
Dare una volta sola la password di root per aprire un file protetto
Per dare una volta sola la password di root per aprire un file protetto si utilizza il comando chmod |1| e il codice 4777 (corrispondente a: rwsrwxrwx) per impostare il setUID. Tale comando consentirà con effetto temporaneo, ossia limitato alla sola attuale sessione di sistema, di modificare i permessi del file, in modo tale ad esempio che tutti possano eseguire tranquillamente un programma o accedere ad un file che di norma richiede i permessi di root.
In sostanza, la password verrà sì inserita, ma 1 volta soltanto.
Esempio:
Private pr as Process
Public Sub Form_Open()
' Se il file non possiede i più ampi permessi...
If Stat("/dev/input/mouse0").Auth <> "rwsrwxrwx" Then
' ...allora modificheremo in quel senso i permessi del file:
Desktop.RunAsRoot("chmod 4777 /dev/input/mouse0")
' Restiamo in attesa fino a che i permessi non vengono modificati, come desiderato:
Do
Wait 0.01
Loop Until Stat("/dev/input/mouse0").Auth = "rwsrwxrwx"
Endif
' Modificati i permessi, passiamo, dunque, avanti per gestire il file:
pr = Shell "cat /dev/input/mouse0" For Read As "pro"
End
Public Sub pro_Read()
Dim b As Byte
Read #pr, b
Print b
End
Uso diretto di comandi bash lanciati mediante Shell
Far aprire un terminale per inserire la propria password con su
La seguente riga di comando farà aprire una finestra di Terminale, nella quale si potrà inserire la propria parola-chiave:
Public Sub Button1_Click() Shell "xterm -e su -c \"comando_da_lanciare > percorso_file_d'appoggio\" \"$user\"" ' oppure anche con "x-terminal-emulator": Shell "/usr/bin/x-terminal-emulator -e su -c \"comando_da_lanciare\" \"$user\"" End
Il risultato del comando però si svolgerà tutto all'interno della finestra del terminale. Altrimenti potremo deviare il flusso di dati verso un qualsiasi file d'appoggio:
Shell "xterm -e su -c \"comando_da_lanciare > percorso_file_d'appoggio\" \"$user\""
e raccogliere successivamente i dati salvati nel file d'appoggio:
Private c As File
Public Sub Form_Open()
c = Open "/tmp/c" For Read Watch
Shell "xterm -e su -c \"comando_da_lanciare > percorso_file_d'appoggio\" \"$user\""
' oppure anche con "x-terminal-emulator":
Shell "/usr/bin/x-terminal-emulator -e su -c \"comando_da_lanciare > percorso_file_d'appoggio\" \"$user\""
End
Public Sub File_Read()
Dim s As String
s = File.Load("percorso_file_d'appoggio")
Print s
End
Uso di gksu
Si potrà utilizzare semplicemente il comando gksu lanciato con Shell. Nel primo spazio presente nella finestra, che sarà mostrata, si dovrà inserire l'intera riga di comando che si intende lanciare come root.
Public Sub Button1_Click() Shell "gksu" End
Dare una volta sola la password di root per aprire un file protetto
Per far immettere la propria password di root, con Shell si utilizza il comando gksu (o gksudo):
Shell "gksu file_ad_accesso_protetto"
che fa aprire un'apposita finestra. Si dovrà, però, inserire ogni volta la password, se dobbiamo utilizzare il nostro applicativo più volte nella medesima sessione di sistema.
Si può ovviare a questo fastidio, utilizzando il comando chmod una volta sola per impostare il setUID. Tale comando consentirà con effetto temporaneo, limitato alla sola attuale sessione di sistema, che tutti possano eseguire tranquillamente un programma o accedere ad un file che richiede i permessi di root. In sostanza, la password verrà sì inserita, ma 1 volta soltanto:
Shell "gksu chmod 4777 file_ad_accesso_protetto"
Se il comando che dobbiamo lanciare prevede delle opzioni indicate con il segno – (come ad esempio: wmctrl -l -p) il comando da eseguire dovrà inserito tra degli apici semplici es:
gksu 'wmctrl -l -p'
Vediamo di seguito un paio di esempi con l'intento di ottenere libero accedesso ai file-device.
Uso di Process
Private flPro As Process
Public Sub Form_Open()
' Riconosce se il programma è stato già lanciato nell'attuale sessione di sistema operativo.
' Se non è stato lanciato almeno una volta, fa inserire la password di root
' per impostare il setUID e consentire l'apertura del file protetto:
If Not Exist("/tmp/chmod.txt") Then
Exec ["gksu", "chmod 4777", "percorso_del_file-device"] Wait
File.Save("/tmp/chmod.txt", "c'è")
Endif
' Va a gestire il file-device:
flPro = Exec ["cat", "percorso_del_file-device"] For Read As "flPro"
End
Public Sub flPro_Read()
Dim b As Byte
' legge i dati provenienti dal file-device del mouse...
Read #flPro, b
' ...e li mostra in console:
Print b
End
Uso di Open.... For
Private fl As File
Public Sub Form_Open()
' Riconosce se il programma è stato già lanciato nell'attuale
' sessione di sistema operativo. *Se non* è stato lanciato almeno
' una volta, fa inserire la password di root per impostare il setUID
' e consentire l'apertura del file protetto:
If Not Exist("/tmp/chmod.txt") Then
Exec ["gksu", "chmod 4777", "percorso_del_file-device"] Wait
File.Save("/tmp/chmod.txt", "c'è")
Endif
' va a gestire il file-device:
fl = Open "percorso_del_file-device" For Read Watch
End
Public Sub File_Read()
Dim b As Byte
' legge i dati provenienti dal file-device della porta...
Read #fl, b
' ...e li mostra in console:
Print b
End
Uso di sudo
Si potrà utilizzare anche il comando sudo, da far lanciare però all'interno di un terminale, per sbloccare sino alla chiusura della sessione un file protetto:
Shell "xterm -e sudo chmod 4777 file_protetto_da_sbloccare"
oppure se si vuole lanciare un comando che necessita dell'inserimento della parola-chiave:
Shell "xterm -e sudo comando_da_lanciare"
Si aprirà la finestra del terminale, nella quale inserire la propria parola-chiave. Anche in questo i dati saranno mostrati all'interno della finestra del terminale.
Senza far aprire la finestra del Terminale per l'inserimento della password
Se non si vuole far aprire la finestra del terminale per l'inserimento della password, allora si potrà utilizzare la seguente modalità.
Per sbloccare un file protetto:
Shell "echo password | sudo -S chmod 4777 file_protetto_da_sbloccare"
Esempio:
Public Sub Main()
Dim fl As File
Shell "echo mia_password | sudo -S chmod 4777 '/dev/tty0'"
Do
Wait 0.01
Loop Until Stat("/dev/tty0").Auth = "rwsrwxrwx"
fl = Open "/dev/tty0" For Write
If IsNull(fl) Then Error.Raise("Impossibile aprire il dispositivo '/dev/tty0' !")
......
End
Per lanciare un comando che necessita dell'inserimento della parola-chiave:
Shell "echo password | sudo -S comando_da_lanciare"
Note
[1] Va sottolineato che il comando chmod andrà scritto tutto in minuscolo !
