Category Archives: GNU/Linux

Password di root nei propri programmi


Ci sono volte in cui nello scrivere i propri programmi si ricorra ai comandi che GNU/Linux offre da riga di comando. Scegliere questo approccio semplifica la vita ai programmatori rendendo i programmi più leggeri e sfruttando appieno la più potente delle “armi” *nix: il terminale!

Si sa però (basta avere un minimo di dimestichezza con il mondo del pinguino) che ci sono dei comandi che possono essere eseguiti solo dall’amministratore del sistema che nei sistemi operativi GNU/Linux prende il nome di root. Quand si prova ad eseguire un comando da amministratore viene chiesta la password, ovvero la password di root. Come fare allora a restituire al sistema questa parola chiave in maniera sicura? Il primo problema che sorge infatti è la sicurezza. Trasmettere una parola così delicata in chiaro significherebbe compromettere quella sicurezza su cui il sistema operativo libero basa la sua diffusione. Ovviamente ci sarebbe la possibilità di criptare la parola digitata e poi decriptarla solo per permettere al comando del terminale di leggerla, ma questo renderebbe il programma alquanto complesso. Come fare allora?
Se si sta sviluppando un programma ad interfaccia grafica e si lavora su sistemi *buntu e derivate è possibile usare due ottimi strumenti gksudo e ksudo; entrambi svolgono lo stesso lavoro ma la differenza tra i due è che uno lavora in ambiente GNOME e l’altro in ambiente KDE. Essi vanno a sostituire il normale uso di sudo in modo che al momento di immettere la password di root si presenti una finestra che vada ad agevolare il lavoro di trasmissione della stessa al comando senza compromettere la normale sicurezza del sistema e quindi del nostro codice.

ESEMPIO

Immaginiamo di voler installare un normale software mediante terminale. Il comando sarebbe

sudo apt-get install programma

e il terminale ci mostrebbere la classica richiesta

[sudo] password for user:

Se invece sostuiamo il comando con

gksudo apt-get install programma

allora ci si presenta davanti una finestra nella quale immettere la parola chiave.

In questo modo si può con molta praticità eseguire comandi da root senza preoccuparsi di gestire la correttezza della sua password.

E’ da precisare che qualora il comando da eseguire con permessi di root prevede alcuni parametri contraddistinti dal segno – allora tale comando va chiuso tra apici.

ESEMPIO:

gksudo 'cat -h'

Qualora sappiate se questo metodo funziona anche con altri sistemi o conoscete per altre distro che svolgano lo stesso lavoro vi chiedo di segnalarmelo per poter completare il post.

Giocare coi codici: alfabeto farfallino.


Ci sono dei giochi appartenenti al nostro periodo infantile che per un motivo o per l’altro ci restano nella mente.
L’altro giorno mentre camminavo per strada e sentito alcune bambine esprimersi in una maniera al quanto strana; non ci ho messo molto per capire che parlavano tra loro in un particolare alfabeto detto farfallino.

Ascoltare le bambine mi ha fatto venire in mente un piccolo dubbio: è possibile creare un traduttore che mi permetta di passare dall’italiano al farfallino e dal farfallino all’italiano? Diciamo che il traduttore no l’ho creato ma mi sono preso la briga di creare due funzioni per passare da una a l’altra codifica. Ovviamente ho scelto Gambas come linguaggio per via della rapidità con la quale si può scrivere il codice.

Dopo varie prove sono arrivato alla stesura delle due funzioni che svolgessero il lavoro che avevo il bisogno che svolgesse. Il lavoro si è dimostrato molto più semplice di quanto pensassi e ora analizziamo il codice delle funzioni.

DA ITALIANO A FARFALLINO

PUBLIC FUNCTION farfallino(parola AS String) AS String

DIM temp_st AS String
DIM ritorno_st AS String

temp_st = parola

ritorno_st = Replace(temp_st, "a", "afa")
temp_st = ritorno_st

ritorno_st = Replace(temp_st, "e", "efe")
temp_st = ritorno_st

ritorno_st = Replace(temp_st, "i", "ifi")
temp_st = ritorno_st

ritorno_st = Replace(temp_st, "o", "ofo")
temp_st = ritorno_st

ritorno_st = Replace(temp_st, "u", "ufu")

RETURN ritorno_st

END

Come si può vedere il codice è molto semplice e si basa sulla sostituzione delle vocali con l’equivalente struttura farfallina. La funzione infatti accetta una parola come argomento e restituisce una stringa. La parola viene copiata in una variabile stringa nella quale viene di volta in volta cercata e sostituita la vocale. Da notare che dopo ogni sostituzione la nuova stringa viene salvata in quella in cui si cercano le vocali…questo perchè, se ciò non venisse fatto, verrebbe vista e sostituita solo la vocale u, essendo l’ultima ed essere visualizzata.

DA FARFALLINO A ITALIANO

PUBLIC FUNCTION sfarfallino(parola AS String) AS String

DIM temp_st AS String
DIM ritorno_st AS String

temp_st = parola

ritorno_st = Replace(temp_st, "afa", "a")
temp_st = ritorno_st

ritorno_st = Replace(temp_st, "efe", "e")
temp_st = ritorno_st

ritorno_st = Replace(temp_st, "ifi", "i")
temp_st = ritorno_st

ritorno_st = Replace(temp_st, "ofo", "o")
temp_st = ritorno_st

ritorno_st = Replace(temp_st, "ufu", "u")

RETURN ritorno_st

END

La funzione che svolge il lavoro inverso della funzione farfallino (fantasiosamente chiamata sfarfallino :-D) si basa sullo stesso principio della funzione precedente. Si cerca nella parola passata alla funzione la componente farfallina e la si sostituisce con la semplice vocale. Ad ogni sostituzione la parola in cui cercare viene aggiornata altrimenti si presenterebbe l’errore spiegato prima.

Da notare che a differenza della prima funzione, che è sempre corretta e non presenta mai errori, la seconda può cadere in false traduzioni. Basti pensare alla parola afa ad esempio. Essa verrà riscritta come una semplice a nonostante il suo senso sia giusto. Pertanto se si volesse rendere la funzione migliore si dovrebbero scrivere delle eccezioni, in base alla lingua in uso, sulla conversione delle parole.

Come sempre ho implementato le funzioni in una classe Gambas da poter implementare nei proprio progetti. Trovare la classe nella colonna a destra tra i Download col nome di Gambas-classe-stringa.

IMPORTARE LA CLASSE

Come fare ad importare la classe nel proprio progetto?Prima di tutto scaricare il file, una volta terminato il download scompattiamo l’archivio zip e dalla cartella copiamo il file stringa.class e incolliamolo nella cartella dove risiede il nostro progetto Gambas. Ora apriamo Gambas e come prima riga nel codice del form in cui utilizzeremo le funzioni della classe scriviamo quanto segue:


PRIVATE Stringa AS NEW stringa

In questo modo possiamo accedere alla funzione con la sintassi:

Stringa.farfallino(stringa_da_convertire)

Stringa.sfarfallino(stringa_da_convertire)

Ovviamente questo è solo un gioco e non pretendo che la funzione possa essere davvero utile a qualcuno.

Sapere se un software è installato

Quando si creano programmi abbastanza complessi, alle volte può essere utile ricorrere a programmi esterni per agevolare il lavoro di stesura del codice del nostro software per evitare di riscrivere funzioni che potrebbero essere svolte benissimo da programmi di terze parti. La cosa funziona di sicuro se il programma viene scritto ed eseguito sul nostro computer poichè si presue che noi stessi sappiamo quali programmi che sono instalati su di esso; ma la cosa si complica se il nostro software deve essere distribuito: chi ci assicura che il programma a cui abbiamo chiesto aiuto sia installato anche sui pc di eventuali utenti finali?

Per ovviare a questa cosa è possibile interrogare il terminale mediante codice. Ovviamente ciò che sto per dire potrà essere usato solo su sistemi GNU/linux vista la notevole potenza dei comandi del terminale.

Esso prevede una comoda funzione che prende il nome di which; questo comando accetta come parametro il nome di un programma e ne restituisce il path in cui è installato se esiste o non restituisce nulla se nel computer esso non è presente. Proprio analizzando la risposta della shell si può capire se il programma non c’è e quindi avvisare l’utente di installarlo per far si che il nostro software funzioni come dovrebbe.

In gambas la cosa molto semplice. Per analizzare come fare scriviamo il codice di una funzione che accetta una stringa contenente il nome del programma e restituisce un booleano che vale 0 se il programma non c’è o 1 se il programma è installato.


Codice:


STATIC PUBLIC FUNCTION SoftExist(software AS String) AS Boolean

DIM control AS String

SHELL "which " & software
WAIT

IF InStr(control, software) THEN
  RETURN TRUE

ELSE
  RETURN FALSE

END IF

END


Analizziamo il codice. Inizialmente dichiariamo la stringa control nella quale verrà salvato il risultato del terminale. Il comando SHELL permette di eseguire istruzioni come se si lavorasse nel terminale. In questo caso diciamo al comando SHELL di eseguire which e di accettare come parametro la stringa che viene passata ala funzione; dopodichè aspetta che il terminale abbia finito con il comando WAIT.
Ora, grazie ad un ciclo IF si controlla che la risposta del comando contenga il nome del programma. Questo è possibile farlo poichè se il programma è installato, which restituirà il path che contiene al suo interno il nome stesso del programma. Proprio grazie alla funzione InStr si analizza che nella stringa control sia presente il nome del programma. Se così fosse restituisce 1 altrimenti (ELSE) si ottiene 0.

Per chi volesse ho implementato questa funzione nella classe sistema, di cui ho già parlato in un altro post. Potete scaricare il pacchetto Gambas-classe-sistema nell’apposita box DOWNLOAD qui a lato.