NOTA: Questo è principalmente un programma (shell script) che ho creato e so che questo forum è più un sito di domande e risposte che di introduzione di programmi. Ma non ho alcun account GitHub (o simile), né ho avuto il tempo di fare ricerche sul metodo di pubblicazione di un programma Open Source nella comunità. Quindi, fintanto che esiste il rischio che un programma funzionante e utile rimanga inosservato (anche per mesi) a coloro che potrebbero apprezzarlo, e sarebbe triste non condividere un programma già realizzato, lo pubblicherò qui per adesso. Nessun problema per me se gli amministratori decidessero di rimuovere questa discussione, capirò. Spero di aver formulato la questione in una
domanda-risposta modo abbastanza per renderlo utile a questo forum. Se ce ne sono abbastanzautenti interessati , farò del mio meglio per dedicare un po 'di tempo per continuare il progetto (dopo tutte le mie ricerche, non ho trovato nulla di più vicino a questo su Internet, ma, beh ... non so se il mio script è prezioso o è stata una perdita di tempo).
Ho programmato un semplice script shell Linux che funziona (fino ad ora) su CygWin e aiuta (spero) a ridurre il SUDO per l'intervallo di attacco temporale di CygWin. Il programma si chiama TOUACExt (acronimo di " TimeOut and UAC Extension ") e funge da wrapper per SUDO per CygWin (richiesto installato) ed è realmente composto da un set di quattro .shprogrammi.
Caratteristiche :
- Comodo utilizzo : simulando il sudo originale dal comportamento di Linux, il prompt della richiesta di conferma UAC appare solo una volta (più
sudocomandi consecutivi genereranno una sola richiesta UAC). Finché sudoserver.py continua a funzionare (impostazione predefinita per 15 minuti), non ci saranno più richieste di controllo dell'account utente .
- Gli utenti con privilegi (Admin) ricevono solo la richiesta di conferma UAC ( Sì / No ) sullo schermo.
- Gli utenti non privilegiati (non amministratori) ottengono una schermata di immissione dell'account / password dell'amministratore .
- sudoserver.py continua a funzionare, quindi si chiude automaticamente dopo un tempo predefinito (15 minuti) dall'ultima esecuzione del comando sudo.
- sudoserver.py non si chiude (continua a funzionare e controllerà di nuovo in 5 minuti) in caso di qualsiasi istanza di sudo in esecuzione.
- Funziona in remoto (testato tramite SSH):
- Gli utenti non privilegiati non possono avviare sudoserver.py in remoto.
- Crea un registro (ancora semplice e non molto leggibile) su
/var/log/SUDOForCygWin/.
Requisiti (in CygWin):
- SUDO per CygWin .
- pgrep (al
procpspacchetto).
- gregge (al
util-linuxpacchetto).
- nohup (penso che sia installato di default su CygWin, ma non ne sono sicuro).
Supponendo : - I due programmi del progetto SUDO per CygWin sul percorso suggerito dall'autore:
/usr/local/bin/sudoserver.py
/usr/local/bin/sudo
TOUACExt è stato testato lavorando su Windows 7 SP1 e Windows XP SP3, ma non so se abbia senso usarlo su quest'ultimo.
Istruzioni di installazione :
Metti questo script (nome suggerito:) SUDOServer.cmde crea un collegamento (puoi personalizzare la sua icona se vuoi) con il nome SUDOServer.lnk(devi abilitare su questo collegamento Advanced Options --> Execute as Administrator) in qualsiasi punto del tuo percorso di Windows , quindi sudoserver.pypuò essere richiesto direttamente da Windows:
c:\CygWin\bin\python2.7.exe /usr/local/bin/sudoserver.py
Inserisci i quattro script .sh di TOUACExt sul percorso, ad esempio:
/usr/local/bin/SUDO.sh
/usr/local/bin/SUDOServer.sh
/usr/local/bin/SUDOServerWatchDog.sh
/usr/local/bin/SUDOServerWatchDogScheduler.sh
Rinomina lo script Python originale da sudoa sudo.py:
mv /usr/local/bin/sudo /usr/local/bin/sudo.py
ATTENZIONE: lo script Python "sudo" originale non deve rimanere in alcun punto del percorso, altrimenti potrebbe essere eseguito.
Crea questo alias (ad esempio, manualmente o modificando il tuo ~/.bashrc):
alias sudo='SUDO.sh'
Codice per SUDO.sh :
#!/bin/bash
# ********** SUDO.sh v0.04a **********
# Variables:
# LockFile (will use a temporal one for now):
#lockfile=sudoserver-running.lck
LockFile=lockfile.lck
# Creating LogFile (if it does not exist):
mkdir /var/log/SUDOForCygWin 2>/dev/null
chmod 777 /var/log/SUDOForCygWin 2>/dev/null
LogFile=/var/log/SUDOForCygWin/$(date +%Y%m%d).log
exec 5>>$LogFile # Redirector 5 will be the log file.
chmod 777 $LogFile >&5 2>&5 # Writable to anyone (for now).
# Start of the program
echo "========== Starting SUDO Server for CygWin ==========" >&5
echo $(date) >&5
# does the lock file exists as locked?
if [ $(flock -n $TMP/$LockFile echo>/dev/null;echo $?) -eq 0 ]
then
# The lock file is not locked.
echo "LockFile not locked. Testing sudo access..." >&5
if [ $(sudo.py vartemp=0>/dev/null 2>/dev/null;printf $?) -eq 0 ]
then
# Wooops. sudoserver.py is running without the lockfile. Better to correct this.
echo "LockFile not locked, but sudoserver.py seems to be running." >&5
printf "Killing sudoserver.py...\n" >&5
sudo.py kill $(sudo.py pgrep.exe -f -l sudoserver.p[y] | grep "pgrep" -v | awk '{print $1}') >&5 2>&5
fi
# Starting SUDOServer.sh
printf "Requesting SUDOServer start...\n" >&5
nohup SUDOServer.sh >&5 2>&1&
# Wait some time delay for UAC Prompt to start
sleep 2
timeout=$((SECONDS+10))
# Has sudoserver.py already started?
while [ $(flock -w 1 $TMP/$LockFile echo>/dev/null;printf $?) -eq 0 ] || [ $(tasklist | grep "consent.exe" -i>/dev/null;printf $?) -eq 0 ]
do
# No. We have to wait.
# Waiting for SUDOServer.py to be running.
printf "."
if [ $SECONDS -ge $timeout ]
then
# sudoserver.py not responding. Aborting with errorlevel=3.
printf "sudoserver.py not responding. Aborting.\n"
exit 3
fi
done
# Yes. sudoserver.py is up and running.
fi
printf "\n"
# Schedule (add) SUDOServer Watch Dog to Task Scheduler:
SUDOServerWatchDogScheduler.sh
# Invoke requested sudo command
sudo.py $@
#printf "ErrorLevel was: "$?
# ErrorLevel Codes:
# 3 --> timeout waiting for sudoserver.py to respond.
Codice per SUDOServer.sh :
#!/bin/bash
# ********** SUDOServer.sh v0.04a **********
# Variables:
# LockFile (a temporal one for now):
#lockfile=sudoserver-running.lck
LockFile=lockfile.lck
# Check for other instances of sudoserver.py running
if [ $(flock -n $TMP/$LockFile echo>/dev/null;printf $?) -eq 0 ]
then
printf "Creating lockfile: "$TMP/$LockFile"\n"
flock $TMP/$LockFile -c 'cmd /c SUDOServer'
# The file has been unlocked. Send error level=2.
exit 2
else
printf "The lockfile: "$TMP/$LockFile" is locked by another process.\n"
printf "Exiting SUDOServer.sh"
fi
printf "SUDOServer.sh execution finished. Exiting."
# Exiting with no problems.
exit 0
# ErrorLevel Codes:
# 2 --> SUDOServer.lnk (maybe denial of UAC).
Codice per SUDOServerWatchDog.sh :
#!/bin/bash
# ********** SUDOServerWatchDog.sh v0.04a **********
# Variables:
# LockFile (a temporal one for now):
#lockfile=sudoserver-running.lck
LockFile=lockfile.lck
# Redirecting to LogFile:
LogFile=/var/log/SUDOForCygWin/$(date +%Y%m%d).log
exec 5>>$LogFile
if [ $(stat $LogFile -c %a) -ne 777 ]
then
echo "Logfile "$LogFile" has incorrect permissions." >&5
echo "Attemping to change permissions of "$LogFile >&5
chmod 777 $LogFile >&5 2>&5
fi
# Remove Task Scheduler entry, if exists.
if [ $(schtasks.exe /query | grep "SUDOServerWatchDog" -i>/dev/null 2>&5;printf $?) -eq 0 ]
then
sudo.py schtasks.exe /delete /tn "SUDOServerWatchDog" /f >&5 2>&5
fi
# Is sudoserver.py running?
if [ $(flock -n $TMP/$LockFile echo>/dev/null;printf $?) -eq 1 ] || [ $(sudo.py vartemp=0>/dev/null 2>/dev/null;printf $?) -eq 0 ]
then
# Yes. sudoserver.py is running. So...
printf "sudoserver.py detected running...\n" >&5
# Is any instance of sudo running right now?
if [ $(sudo.py pgrep -f -l "/usr/local/bin/sudo.py " | grep -v grep>/dev/null 2>&5;printf $?) -eq 0 ]
then
# Yes. sudo is running right now. So...
printf "There are instances of sudo running.\n" >&5
sudo.py schtasks /create /tn "SUDOServerWatchDog" /tr "SUDOServerWatchDog" /sc minute /mo 5 /sd 10/10/2010 /ru "SYSTEM" >&5 2>&5
printf "Will check again in 5 minutes. Adding Task.\n" >&5
else
# No. sudo is not running right now. So...
# Kill sudoserver.py.
printf "Closing sudoserver.py\n" >&5
sudo.py kill $(sudo.py pgrep.exe -f -l sudoserver.p[y] | grep "pgrep" -v | awk '{print $1}')
fi
else
printf "sudoserver.py not running. Nothing to be done.\n" >&5
fi
Codice per SUDOServerWatchDogScheduler.sh :
#!/bin/bash
# ********** SUDOWatchDogScheduler.sh v0.04a **********
# Check if WatchDog is already scheduled
if [ $(schtasks.exe /query | grep "SUDOServerWatchDog">/dev/null 2>&5;printf $?) -eq 0 ]
then
# Yes. Remove it in order to create a new one.
echo "Task SUDOServerWatchDog already existing." >&5
echo "Removing task SUDOServerWatchDog..." >&5
sudo.py schtasks.exe /delete /tn "SUDOServerWatchDog" /f >&5 2>&5
if [ $? -eq 0 ]
then
# Task correctly deleted.
echo "Task correctly removed." >&5
else
# Something failed in task creation. Report.
echo "ERROR on deleting the SUDOServerWatchDog programmed task." >&5
fi
fi
# Schedule new task for deletion.
echo "Adding new SUDOServerWatchDog task to trigger in 15 minutes." >&5
sudo.py schtasks /create /tn "SUDOServerWatchDog" /tr "SUDOServerWatchDog" /sc minute /mo 15 /sd 10/10/2010 /ru "SYSTEM" >&5 2>&5
if [ $? -eq 0 ]
then
# Task correctly scheduled.
echo "Task SUDOServerWatchDog correctly scheduled." >&5
else
# Something failed in task scheduling. Report.
echo "ERROR on scheduling programmed task SUDOServerWatchDog." >&5
fi
Testare il programma da una shell CygWin Bash:
Luis@Kenobi ~
$ sudo ls -la
<UAC ELEVATION PROMPT APPEARS>
total 49
drwxr-xr-x+ 1 Luis None 0 abr 7 02:23 .
drwxrwxrwt+ 1 Luis- None 0 abr 4 03:27 ..
-rw------- 1 Luis None 13798 abr 14 00:31 .bash_history
-rwxr-xr-x 1 Luis None 1494 mar 3 11:36 .bash_profile
-rwxr-xr-x 1 Luis None 6260 abr 6 05:19 .bashrc
-rwxr-xr-x 1 Luis None 1919 mar 3 11:36 .inputrc
-rw------- 1 Luis None 35 abr 2 01:43 .lesshst
-rwxr-xr-x 1 Luis None 1236 mar 3 11:36 .profile
drwx------+ 1 Luis None 0 mar 8 01:49 .ssh
-rw-r--r-- 1 Luis None 7 mar 4 18:01 d:ppp.txt
-rw-r--r-- 1 Luis None 37 abr 7 02:23 my.log
NOTA 2: questi script sono in versione pre-beta , quindi sono ancora difettosi e il codice non è molto pulito. Ad ogni modo, nei miei test con tre diversi computer Windows 7 sembrano funzionare (principalmente) OK.
Breve spiegazione del programma:
- A causa dell'alias , quando si esegue un comando sudo viene invocato lo script SUDO.sh.
- SUDO.sh chiama SUDOServer.sh , aprendo (via
SUDOServer.lnk) "sudoserver.py" se necessario.
- Il comando originale sudo richiamato dall'utente viene eseguita.
- Quindi SUDO.sh chiama SUDOServerWatchDogScheduler.sh , che pianifica SUDOServerWatchDog.sh per l'esecuzione dopo il tempo specificato (impostazione predefinita di 15 minuti) per la chiusura
sudoserver.py.
- Dopo il tempo predefinito, SUDOServerWatchDog.sh chiude sudoserver.py . Se ci sono istanze di sudo in esecuzione , si programma per la nuova esecuzione dopo 5 minuti.
Da fare :
- Installatore sé che crea tutte le .sh, .cmd e file .lnk automaticamente.
- Stabilisci il file di blocco su un altro (è in $ TMP / lockfile.lck).
- Aggiungi uno script di configurazione o un file .config (per impostazione predefinita in timeout, posizioni dei file ... ecc.).
- Aggiungi comportamento dell'account di sistema (grazie, @ Wyatt8740).
- ¿Cambiare "flock" (modalità SUDO con blocco interno) con "fuser" dove appropriato?
- Suggerimenti accettati.
Bug segnalati :
- La shell bash rimane aperta anche dopo l'input
exitse sudoserver.pyè in esecuzione fino alla chiusura. Soluzioni alternative provvisorie sono benvenute.
Spero che qualcuno userà le lunghe ore di programmazione che ho dedicato a TOUACExt.
Miglioramenti e correzioni accettati.
Sono accettati anche suggerimenti su dove devo andare a pubblicare il codice per smettere di tormentare questo forum ;-).
Ci scusiamo per il lungo post. Non ho molto tempo libero e questo progetto stava per scomparire nel mio armadio (forse per anni, chi lo sa?).