OpenSSL Archivi - Petar Karan

21 Novembre 2020 Nessun commento

[owncloud] Installare ownCloud su Ubuntu Server 20.04.1, configurazione VirtualHost, certificato HTTPS e disco dati con LVM

Vediamo come installare ownCloud su un Ubuntu Server 20.04.1. In aggiunta configureremo anche un VirtualHost con un certificato autofirmato, aggiungendo infine un disco in LVM che ospiti i dati di ownCloud.

1. Configurazione server LAMP

Anzitutto configuriamo il server LAMP installando Apache, MariaDB e il PHP 7.4.

Eseguiamo il seguente comando:

sudo apt install -y apache2 libapache2-mod-php mariadb-server php-imagick php-common php-curl php-gd php-imap php-intl php-json php-mbstring php-mysql php-ssh2 php-xml php-zip php-apcu php-redis redis-server bzip2 rsync curl jq inetutils-ping smbclient coreutils php-ldap

1	sudo apt install -y apache2 libapache2-mod-php mariadb-server php-imagick php-common php-curl php-gd php-imap php-intl php-json php-mbstring php-mysql php-ssh2 php-xml php-zip php-apcu php-redis redis-server bzip2 rsync curl jq inetutils-ping smbclient coreutils php-ldap

A questo punto configuriamo il database eseguendo:

sudo mysql_secure_installation

1	sudo mysql_secure_installation

ATTENZIONE! Se si esegue il commando senza sudo verrà chiesta la password dell’utente root e non ci sarà modo di cambiarla, generando l’errore: ERROR 1698 (28000): Access denied for user 'root'@'localhost'

Digitare in sequenza, per le singole domande:

Change the root password? [Y/n] Y

Remove anonymous users? [Y/n] Y

Disallow root login remotely? [Y/n] Y

Remove test database and access to it? [Y/n] Y

Reload privilege tables now? [Y/n] Y

Una volta completata la configurazione di MariaDB il server LAMP e pronto è possiamo procedere con le specifiche configurazioni.

2. Creiamo il certificato di crittografia

Se non lo abbiamo già fatto installiamo openssl. Questo ci servirà per creare un certificato autofirmato, nel caso in cui si disponga già del certificato si può passare al punto successivo.

sudo apt-get install openssl

1	sudo apt-get install openssl

Creiamo la chiave privata e il certificato:

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/cloud.local.2020.key -out /etc/ssl/certs/cloud.local.2020.crt

1	sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/cloud.local.2020.key -out /etc/ssl/certs/cloud.local.2020.crt

Nel caso specifico stiamo dicendo ad openssl:

req sottocomando col quale specifichiamo che vogliamo usare l’X.509 CSR (certificate signing request), un’infrastruttura standard per le chiavi pubbliche utilizzata tipicamente con SSL e TSL
nodes indica ad OpenSSL di non cifrare il certificato con una password, dal momento che verrà utilizzato su Apache che deve potervi accedere liberamente
days specifica la durata di validità del certificato, nel nostro caso 365 giorni
newkey specifica il tipo di chiave privata (RSA 2048) che si vuole generare e il fatto che la si voglia generare assieme al certificato
keyout indica la posizione dove creare la chiave
out indica la posizione dove creare il certificato

Rispondiamo ai quesiti posti da OpenSSL per la configurazione del certificato. Nel mio caso procederò così:

Country Name (2 letter code) [AU]:IT
State or Province Name (full name) [Some-State]:Firenze
Locality Name (eg, city) []:Firenze
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Torregatti Spa
Organizational Unit Name (eg, section) []:Servizi Cloud
Common Name (e.g. server FQDN or YOUR name) []:cloud.local
Email Address []:scrivi@petarkaran.it

I valori sono per lo più arbitrari, l’unica cosa importante è il Common Name, che può essere l’indirizzo IP del server, oppure il dominio a cui sarà associato il certificato.

Configuriamo Apache affinché utilizzi correttamente i certificati SSL:

sudo nano /etc/apache2/conf-available/certificati.conf

1	sudo nano /etc/apache2/conf-available/certificati.conf

Nel file digitiamo:

SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH
SSLProtocol All -SSLv2 -SSLv3 -TLSv1 -TLSv1.1
SSLHonorCipherOrder On
Header always set X-Frame-Options DENY
Header always set X-Content-Type-Options nosniff
SSLCompression off
SSLUseStapling on
SSLStaplingCache "shmcb:logs/stapling-cache(150000)"
SSLSessionTickets Off

SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH

SSLProtocol All -SSLv2 -SSLv3 -TLSv1 -TLSv1.1

SSLHonorCipherOrder On

Header always set X-Frame-Options DENY

Header always set X-Content-Type-Options nosniff

SSLCompression off

SSLUseStapling on

SSLStaplingCache "shmcb:logs/stapling-cache(150000)"

SSLSessionTickets Off

Affinché la configurazione funzioni dobbiamo attivare il modulo SSL e il modulo Headers in Apache.

sudo a2enmod ssl
sudo a2enmod headers

1 2	sudo a2enmod ssl sudo a2enmod headers

A questo punto attiviamo la configurazione digitando:

sudo a2enconf certificati

1	sudo a2enconf certificati

Affinché la configurazione sia corretta bisogna riavviare Apache, anche se non è necessario farlo adesso, lo possiamo fare anche dopo.

sudo service apache2 reload

1	sudo service apache2 reload

3. Configuriamo il VirtualHost

A questo punto configuriamo il nostro VirtualHost, immaginiamo che il nostro ownCloud debba trovarsi all’indirizzo cloud.local. (nel caso specifico da http://cloud.local e https://cloud.local)

Creiamo anzitutto due cartelle in /var/www, una per i file, una per i dati ed una per i log, entrambe sottocartelle di cloud.local, nella maniera seguente.

sudo mkdir -p /var/www/cloud.local/httpdocs
sudo mkdir -p /var/www/cloud.local/logs
sudo mkdir -p /var/www/cloud.local/dati

sudo mkdir -p /var/www/cloud.local/httpdocs

sudo mkdir -p /var/www/cloud.local/logs

sudo mkdir -p /var/www/cloud.local/dati

Grazie all’argomento -p creiamo l’intero percorso anche se non esiste.

A questo punto procediamo con la creazione del file del VirtualHost vero e proprio.

sudo nano /etc/apache2/sites-available/cloud.local.conf

1	sudo nano /etc/apache2/sites-available/cloud.local.conf

Nel file inseriamo le seguenti istruzioni.

<VirtualHost *:80>

        ServerName cloud.local
        ServerAlias www.cloud.local

        DocumentRoot /var/www/cloud.local/httpdocs

        ErrorLog /var/www/cloud.local/logs/error.log
        CustomLog /var/www/cloud.local/logs/access.log combined

        Redirect permanent "/" "https://cloud.local/"

</VirtualHost>

<IfModule mod_ssl.c>
        <VirtualHost *:443>

                ServerName cloud.local
                ServerAlias www.cloud.local

                DocumentRoot /var/www/cloud.local/httpdocs

                ErrorLog /var/www/cloud.local/logs/error.log
                CustomLog /var/www/cloud.local/logs/access.log combined

                SSLEngine on

                SSLCertificateFile      /etc/ssl/certs/cloud.local.2020.crt
                SSLCertificateKeyFile   /etc/ssl/private/cloud.local.2020.key

                <FilesMatch "\.(cgi|shtml|phtml|php)$">
                        SSLOptions +StdEnvVars
                </FilesMatch>
                <Directory /usr/lib/cgi-bin>
                        SSLOptions +StdEnvVars
                </Directory>

        </VirtualHost>
</IfModule>

<Directory /var/www/cloud.local/httpdocs/>
        Options +FollowSymlinks -Indexes
        AllowOverride All

        <IfModule mod_dav.c>
                Dav off
        </IfModule>

        SetEnv HOME /var/www/cloud.local/httpdocs
        SetEnv HTTP_HOME /var/www/cloud.local/httpdocs
</Directory>

ServerName cloud.local

ServerAlias www.cloud.local

DocumentRoot /var/www/cloud.local/httpdocs

ErrorLog /var/www/cloud.local/logs/error.log

CustomLog /var/www/cloud.local/logs/access.log combined

Redirect permanent "/" "https://cloud.local/"

</VirtualHost>

ServerName cloud.local

ServerAlias www.cloud.local

DocumentRoot /var/www/cloud.local/httpdocs

ErrorLog /var/www/cloud.local/logs/error.log

CustomLog /var/www/cloud.local/logs/access.log combined

SSLEngine on

SSLCertificateFile /etc/ssl/certs/cloud.local.2020.crt

SSLCertificateKeyFile /etc/ssl/private/cloud.local.2020.key

SSLOptions +StdEnvVars

</FilesMatch>

SSLOptions +StdEnvVars

</Directory>

</VirtualHost>

</IfModule>

Options +FollowSymlinks -Indexes

AllowOverride All

Dav off

</IfModule>

SetEnv HOME /var/www/cloud.local/httpdocs

SetEnv HTTP_HOME /var/www/cloud.local/httpdocs

</Directory>

In questo modo forziamo il redirect sul HTTPS e abilitiamo il certificato creato in precedenza.

A questo punto riavviamo apache:

sudo service apache2 restart

1	sudo service apache2 restart

4. Creazione partizione per i dati con LVM

Aggiungiamo al nostro server un disco aggiuntivo a creiamo un nuovo disco logico con LVM. Per ulteriori approfondimenti sulla procedura rimando all’articolo LVM, gestore logico dei volumi su Ubuntu [per pinguini alle prime armi]

Anzitutto vediamo i dischi dei quali disponiamo con:

sudo fdisk -l

1	sudo fdisk -l

Nel mio caso (sto utilizzando VirtualBox per l’esempio con 2 dischi da 10GB ciascuno):

Il disco che utilizzerò è /dev/sdb. Procediamo quindi a preparare il disco:

sudo fdisk /dev/sdb

1	sudo fdisk /dev/sdb

Su fdisk digitiamo in ordine:

n per creare una nuova partizione
p per una partizione primaria
1 numero di partizione
INVIO per confermare il primo settore di default 2048
INVIO per confermare l’ultimo settore
t per modificare la partizione
8e per impostare Linux LVM
w per scrivere e salvare il tutto

Utilizzando sudo fdisk -l dovremmo vedere qualcosa di simile:

Creiamo un volume fisico digitando:

sudo pvcreate /dev/sdb1

1	sudo pvcreate /dev/sdb1

Creiamo un gruppo di volumi chiamato dati-cloud digitando:

sudo vgcreate dati-cloud /dev/sdb1

1	sudo vgcreate dati-cloud /dev/sdb1

Creiamo sopra il volume logico dati:

sudo lvcreate -l 100%FREE -n dati dati-cloud

1	sudo lvcreate -l 100%FREE -n dati dati-cloud

Formattiamo il volume in ext4.

sudo mkfs -t ext4 /dev/dati-cloud/dati

1	sudo mkfs -t ext4 /dev/dati-cloud/dati

A questo punto montiamo il nuovo volume logico sulla cartella /var/www/cloud.local/dati

sudo mount /dev/dati-cloud/dati /var/www/cloud.local/dati

1	sudo mount /dev/dati-cloud/dati /var/www/cloud.local/dati

Siccome vogliamo che il disco sia montato in modo permanente, modifichiamo /etc/fstab.

sudo nano /etc/fstab

1	sudo nano /etc/fstab

In fondo al file aggiungiamo la seguente riga:

/dev/dati-cloud/dati /var/www/cloud.local/dati ext4 rw,defaults 0 0

1	/dev/dati-cloud/dati /var/www/cloud.local/dati ext4 rw,defaults 0 0

In questo modo al riavvio del server il volume logico verrà caricato automaticamente.

5. Creiamo un database per ownCloud

ownCloud necessita di un database per funzionare, pertanto creiamone uno nuovo all’interno di MariaDB.

Entriamo in MariaDB/MySQL:

sudo mysql -u root

1	sudo mysql -u root

Una volta dentro creiamo un nuovo database chiamato cloud_db:

CREATE DATABASE cloud_db;

1	CREATE DATABASE cloud_db;

Creiamo anche un utente per il database appena creato, che potrà accedere esclusivamente da locale (agli scopi dell’esercizio metterò una password banale):

CREATE USER 'cloud_user'@'localhost' IDENTIFIED BY 'password123';
GRANT ALL PRIVILEGES ON cloud_db.* TO 'cloud_user'@'localhost';
FLUSH PRIVILEGES;

CREATE USER 'cloud_user'@'localhost' IDENTIFIED BY 'password123';

GRANT ALL PRIVILEGES ON cloud_db.* TO 'cloud_user'@'localhost';

FLUSH PRIVILEGES;

6. Installazione ownCloud

Scarichiamo ownCloud nella cartella httpdocs. Da qui possiamo scegliere da dove scaricarlo.

sudo wget https://download.owncloud.org/community/owncloud-complete-20200731.zip

1	sudo wget https://download.owncloud.org/community/owncloud-complete-20200731.zip

Se non abbiamo installato unzip facciamolo:

sudo apt-get install unzip

1	sudo apt-get install unzip

A questo punto estraiamo il file zip.

sudo unzip owncloud-complete-20200731.zip

1	sudo unzip owncloud-complete-20200731.zip

Spostiamo i file dalla cartella owncloud creata dall’unzip, nella radice del virtualhost.

sudo rm owncloud-complete-20200731.zip
sudo mv owncloud/* .
sudo mv owncloud/.* .
sudo rm -r owncloud/

sudo rm owncloud-complete-20200731.zip

sudo mv owncloud/* .

sudo mv owncloud/.* .

sudo rm -r owncloud/

In questo modo rimuoviamo anche la cartella aggiuntiva ed il file zip.

Assegniamo adesso l’utente apache a tutta la cartella ed i file creati.

sudo chown -R www-data:www-data /var/www/cloud.local/

1	sudo chown -R www-data:www-data /var/www/cloud.local/

Infine abilitiamo la configurazione e riavviamo apache:

sudo a2ensite cloud.local
sudo service apache2 restart

1 2	sudo a2ensite cloud.local sudo service apache2 restart

Se tutto è andato bene potremo aprire ownCloud all’indirizzo https://cloud.local/

Inseriamo i parametri nella maniera seguente (utilizzando quelli creati):

Scegliamo un utente ed una password
Per la cartella dati impostiamo la cartella creata all’inizio
Inseriamo i dati del database configurati in precedenza:

Una volta fatto tutto possiamo premere su TERMINA CONFIGURAZIONE.

Se tutto è andato bene vedremo una schermata come la seguente:

Fatto tutto questo possiamo accedere al sistema. Spostandoci su Impostazioni > Generali, potremmo notare delle notifiche come le seguenti:

Apportiamo quindi ancora un paio di modifiche per aggiustare il tutto correttamente.

Anzitutto configuriamo correttamente il crontab affinché esegua gli script di ownCloud.

Digitiamo:

sudo crontab -u www-data -e

1	sudo crontab -u www-data -e

Se è la prima volta che lo apriamo ci chiederà quale editor preferiamo utilizzare, io scelgo 1 per nano.

Aggiungiamo la seguente riga:

*/15  *  *  *  * /var/www/cloud.local/httpdocs/occ system:cron

1	/15 * * * /var/www/cloud.local/httpdocs/occ system:cron

Salviamo con CTRL+O e usciamo.

Nelle suddette impostazioni di ownCloud selezioniamo come meccanismo di aggiornamento Cron.

Spostiamoci nella nostra cartella di installazione con:

cd /var/www/cloud.local/httpdocs/

1	cd /var/www/cloud.local/httpdocs/

Eseguiamo i seguenti comandi:

sudo -u www-data ./occ config:system:set memcache.local --value '\OC\Memcache\APCu'
sudo -u www-data ./occ config:system:set memcache.locking --value '\OC\Memcache\Redis'
sudo -u www-data ./occ config:system:set redis --value '{"host": "127.0.0.1", "port": "6379"}' --type json

sudo -u www-data ./occ config:system:set memcache.local --value '\OC\Memcache\APCu'

sudo -u www-data ./occ config:system:set memcache.locking --value '\OC\Memcache\Redis'

sudo -u www-data ./occ config:system:set redis --value '{"host": "127.0.0.1", "port": "6379"}' --type json

L’utilizzo di sudo -u www-data è necessario perché l’esecuzione deve essere effettuata da Apache. Eseguendolo senza sudo lo faremmo usando il nostro utente, con sudo come root. In entrambi i casi non andrebbe bene.

Per risolvere l’avviso di HTTP "Strict-Transport-Security" dobbiamo aggiungere a <VirtualHost *:443> le seguenti tre righe:

<IfModule mod_headers.c>
        Header always set Strict-Transport-Security "max-age=15552000; includeSubDomains"
</IfModule>

Header always set Strict-Transport-Security "max-age=15552000; includeSubDomains"

</IfModule>

Il file definitivo del virtualhost sarà come il seguente:

<VirtualHost *:80>

        ServerName cloud.local
        ServerAlias www.cloud.local

        DocumentRoot /var/www/cloud.local/httpdocs

        ErrorLog /var/www/cloud.local/logs/error.log
        CustomLog /var/www/cloud.local/logs/access.log combined

        Redirect permanent "/" "https://cloud.local/"

</VirtualHost>

<IfModule mod_ssl.c>
        <VirtualHost *:443>

                ServerName cloud.local
                ServerAlias www.cloud.local

                DocumentRoot /var/www/cloud.local/httpdocs

                ErrorLog /var/www/cloud.local/logs/error.log
                CustomLog /var/www/cloud.local/logs/access.log combined

                SSLEngine on

                SSLCertificateFile      /etc/ssl/certs/cloud.local.2020.crt
                SSLCertificateKeyFile   /etc/ssl/private/cloud.local.2020.key

                <FilesMatch "\.(cgi|shtml|phtml|php)$">
                        SSLOptions +StdEnvVars
                </FilesMatch>
                <Directory /usr/lib/cgi-bin>
                        SSLOptions +StdEnvVars
                </Directory>

                <IfModule mod_headers.c>
                        Header always set Strict-Transport-Security "max-age=15552000; includeSubDomains"
                </IfModule>

        </VirtualHost>
</IfModule>

<Directory /var/www/cloud.local/httpdocs/>
        Options +FollowSymlinks
        AllowOverride All

        <IfModule mod_dav.c>
                Dav off
        </IfModule>

        SetEnv HOME /var/www/cloud.local/httpdocs
        SetEnv HTTP_HOME /var/www/cloud.local/httpdocs
</Directory>

ServerName cloud.local

ServerAlias www.cloud.local

DocumentRoot /var/www/cloud.local/httpdocs

ErrorLog /var/www/cloud.local/logs/error.log

CustomLog /var/www/cloud.local/logs/access.log combined

Redirect permanent "/" "https://cloud.local/"

</VirtualHost>

ServerName cloud.local

ServerAlias www.cloud.local

DocumentRoot /var/www/cloud.local/httpdocs

ErrorLog /var/www/cloud.local/logs/error.log

CustomLog /var/www/cloud.local/logs/access.log combined

SSLEngine on

SSLCertificateFile /etc/ssl/certs/cloud.local.2020.crt

SSLCertificateKeyFile /etc/ssl/private/cloud.local.2020.key

SSLOptions +StdEnvVars

</FilesMatch>

SSLOptions +StdEnvVars

</Directory>

Header always set Strict-Transport-Security "max-age=15552000; includeSubDomains"

</IfModule>

</VirtualHost>

</IfModule>

Options +FollowSymlinks

AllowOverride All

Dav off

</IfModule>

SetEnv HOME /var/www/cloud.local/httpdocs

SetEnv HTTP_HOME /var/www/cloud.local/httpdocs

</Directory>

Riavviamo ancora una volta apache.

sudo service apache2 restart

1	sudo service apache2 restart

A questo punto è tutto pronto e possiamo cominciare ad usare ownCloud.

Vedi articolo

23 Febbraio 2018 Nessun commento

Configurare VirtualHost su Apache, database MySQL e accesso FTP per un utente con BASH

L’esercizio in bash che propongo stavolta consiste nell’automatizzare la configurazione di un hosting sul nostro server Apache, ovvero la configurazione del VirtualHost, di un nuovo utente e database MySQL e di un accesso FTP.

L’obiettivo è quello di arrivare ad avere uno script utilizzabile nel modo seguente:

sudo ./addhosting.sh -u pippo -d sito-diprova.com --dbadmin root --dbpass passwor

1	sudo ./addhosting.sh -u pippo -d sito-diprova.com --dbadmin root --dbpass passwor

I parametri che vogliamo passare al nostro script sono:

-u: il nome dell’utente che vogliamo creare
-d: il nome del dominio che vogliamo registrare come VirtualHost di Apache
–dbadmin: il nome utente dell’amministratore del database, quello in grado di creare altri utenti all’interno del MySQL
–dbpass: la password del suddetto utente del database MySQL

Questo ci darà occasione per esplorare diverse caratteristiche di bash.

Anzitutto vogliamo acquisire ed elaborare i vari parametri passati al nostro script. Finora abbiamo visto che i parametri possono essere letti usando $# per contare il numero di argomenti, $0 per visualizzare il nome dello script, $1 per prendere il primo parametro, $2 per prendere il secondo e via discorrendo.

Adesso vogliamo prendere un numero indefinito di argomenti e parametrizzarli, vediamo come fare:

while [[ $# -gt 0 ]]
do

	parametro="$1"

	case $parametro in
		-d|--domain)
		dominio="$2"
		shift
		shift
		;;
		-u|--user)
		utente="$2"
		shift
		shift
		;;
		--dbadmin)
		dbadmin="$2"
		shift
		shift
		;;
		--dbpass|--dbpassword)
		dbpass="$2"
		shift
		shift
		;;
		-h|--help)
		aiuto=true
		shift
		;;
		-f|--fix)
		ripristina=true
		shift
		;;
		*)
		shift
		;;
	esac

done

while [[ $# -gt 0 ]]

parametro="$1"

case $parametro in

-d|--domain)

dominio="$2"

shift

;;

-u|--user)

utente="$2"

shift

;;

--dbadmin)

dbadmin="$2"

shift

;;

--dbpass|--dbpassword)

dbpass="$2"

shift

;;

-h|--help)

aiuto=true

shift

;;

-f|--fix)

ripristina=true

shift

;;

shift

;;

esac

done

Usiamo quindi un ciclo while che continuerà ad andare avanti finché il numero di parametri passati allo script non sarà 0. Quindi acquisiamo il primo parametro $1 e lo passiamo ad una variabile chiamata parametro. Utilizziamo adesso un interruttore (case…esac) per cui in base al valore di parametro si attiveranno diverse opzioni.

Ciascuna opzione è scritta nella forma

valore)
...
...
;;

valore)

...

;;

Qui al posto di valore può essere un singolo valore oppure un gruppo diviso da |, nella maniera di valore1|valore2. Al posto dei puntini ci va del codice a piacere che vogliamo attivare in base alla variabile. Il principio, concettualmente, è identico a quello della realizzazione del programma in bash con menu.

Il comando shift, in bash, rimuove gli argomenti passati ad uno script a partire dall’inizio della lista, cioè dal primo argomento. Questo significa che ad ogni ciclo del while non prenderemo il primo argomento, lo controlleremo e poi lo rimuoveremo dall’elenco. Quando si digita due volte shift, si estraggono due parametri.

Viene da se che se l’argomento $1 è, per esempio, uguale a “-d“, allora l’argomento $2 dovrà contenere il nome del dominio e quindi una volta letti li rimuoveremo entrambi.

Se invece l’argomento $1 fosse uguale a “-h” oppure a “–help“, allora visualizzeremmo, senza ulteriori opzioni, una guida allo script. In questo caso dovremmo rimuovere un solo argomento.

Fatto questo cominciamo ad elaborare i parametri acquisiti. Anzitutto controlliamo se sia stato passato un nome utente del database:

call_check_dbadmin() {

	if [[ $dbadmin = "" ]]
	then
		errore "Inserire utente amministratore del database"
	fi

}

call_check_dbadmin() {

if [[ $dbadmin = "" ]]

then

errore "Inserire utente amministratore del database"

}

Se non c’è un nome utente del database chiamiamo una funzione che stampi l’errore:

errore() {

        echo -e "${ROSSO}ERRORE!${NC} $1. Per aiuto usare -h o --help"
	exit

}

errore() {

echo -e "${ROSSO}ERRORE!${NC} $1. Per aiuto usare -h o --help"

exit

}

In questo caso vogliamo usare, visto che possiamo, anche dei colori, e quindi colorare di rosso la parola “ERRORE!”. Per farlo facciamo riferimento all’ANSI escape code.

Quindi possiamo usare le seguenti combinazioni:

Black        0;30     Dark Gray     1;30
Red          0;31     Light Red     1;31
Green        0;32     Light Green   1;32
Brown/Orange 0;33     Yellow        1;33
Blue         0;34     Light Blue    1;34
Purple       0;35     Light Purple  1;35
Cyan         0;36     Light Cyan    1;36
Light Gray   0;37     White         1;37

Black 0;30 Dark Gray 1;30

Red 0;31 Light Red 1;31

Green 0;32 Light Green 1;32

Brown/Orange 0;33 Yellow 1;33

Blue 0;34 Light Blue 1;34

Purple 0;35 Light Purple 1;35

Cyan 0;36 Light Cyan 1;36

Light Gray 0;37 White 1;37

Questo significa che se nella string “ERRORE! C’è un errore” fosse scritto “\033[0;31mERRORE!\033[0m C’è un errore” la stringa verrebbe colorata tutta di rosso, fino al nuovo colore che è, in questo caso, quello nullo predefinito. Ovvero così:

Per comodità vogliamo parametrizzare alcuni colori inserendo, in cima allo script il seguente codice:

GIALLO='\033[1;33m'
ROSSO='\033[0;31m'
CELESTE='\033[1;34m'
NC='\033[0m'

GIALLO='\033[1;33m'

ROSSO='\033[0;31m'

CELESTE='\033[1;34m'

NC='\033[0m'

La variabile NC starebbe per No Color, ovviamente i nomi sono a piacere.

Fatto questo controlliamo se sia stata passata anche la password, se non è stato fatto la richiediamo:

call_check_dbpass() {

	if [[ $dbadmin != "" && $dbpass = "" ]]
	then
		echo -n "$dbadmin password: "
		read -s dbpass
		echo
	fi

}

call_check_dbpass() {

if [[ $dbadmin != "" && $dbpass = "" ]]

then

echo -n "$dbadmin password: "

read -s dbpass

echo

}

Potremmo aggiungere altri controlli (per esempio sul nome del dominio, ecc.) ma per ora tralasciamo ed andiamo a creare la cartella del vhost sotto a /var/www.

www="/var/www/"

call_crea_cartella() {

	mkdir $www$dominio 2>/dev/null || errore "Permesso negato. Eseguire come root"

}

www="/var/www/"

call_crea_cartella() {

mkdir $www$dominio 2>/dev/null || errore "Permesso negato. Eseguire come root"

}

Utilizziamo 2>/dev/null per reindirizzare l’output di un eventuale errore e non mostrarlo a schermo, mentre il connettore || vuol dire che, dati due comandi A e B per cui A || B, se A non va a buon fine, allora esegui B.

Fatto questo creiamo subito l’utente FTP dedicato e la relativa password. In questo esempio do per scontato che abbiamo installato ProFTPd e che sia già stato configurato correttamente sul nostro server:

ftppassword="$(openssl rand -base64 12)"

call_crea_ftp() {

	useradd --shell /bin/false $utente
	chown $utente:www-data $www$dominio
	usermod -d $www$dominio $utente
	echo $utente:$ftppassword | /usr/sbin/chpasswd
	echo "FTP Password: $ftppassword"

}

ftppassword="$(openssl rand -base64 12)"

call_crea_ftp() {

useradd --shell /bin/false $utente

chown $utente:www-data $www$dominio

usermod -d $www$dominio $utente

echo $utente:$ftppassword | /usr/sbin/chpasswd

echo "FTP Password: $ftppassword"

}

Con il primo comando creiamo una password casuale di 12 caratteri.

Creiamo poi un utente chiamato come da argomento e assegniamo, alla cartella creata in precedenza, come proprietario l’utente appena creato e come gruppo www-data (ricordiamoci che sulla cartella deve poter interagire anche Apache). Fatta questa modifica con il comando usermod -d assegniamo la cartella alla home dell’utente. Questo viene fatto per motivi di sicurezza, per cui l’utente che accede al FTP acceda direttamente alla sua “home“, corrispondente anche allo spazio web.

Dopodiché impostiamo la password appena creata come password del nostro utente, ed infine stampiamola a video.

Faccio notare che perché –shell /bin/false non dia problemi, così come la questione della home, è necessario che nel file di configurazione di ProFTPd (/etc/proftpd/proftpd.conf) siano presenti i seguenti parametri così configurati (tipicamente va tolto il cancelletto):

DefaultRoot                     ~
RequireValidShell               off

1 2	DefaultRoot ~ RequireValidShell off

Fatto questo scriviamo il nostro file del VirtualHost:

sites="/etc/apache2/sites-available/"

call_crea_vhost() {

cat << EOF > "${sites}${dominio/./_}.conf"
<VirtualHost *:80>
        ServerName $dominio

        ServerAdmin webmaster@localhost
        DocumentRoot $www$dominio

        ErrorLog \${APACHE_LOG_DIR}/error.log
        CustomLog \${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
EOF

}

sites="/etc/apache2/sites-available/"

call_crea_vhost() {

cat << EOF > "${sites}${dominio/./_}.conf"

ServerName $dominio

ServerAdmin webmaster@localhost

DocumentRoot $www$dominio

ErrorLog \${APACHE_LOG_DIR}/error.log

CustomLog \${APACHE_LOG_DIR}/access.log combined

</VirtualHost>

EOF

}

In questo caso vogliamo creare un file del tipo nomedominio.conf dentro a /etc/apache2/sites-available/, già che ci siamo sostituiamo il . con un _, in modo tale che nomedominio.com diventi nomedominio_com e il nome del file nomedominio_com.conf. Con l’istruzione EOF possiamo scrivere direttamente dentro il file il testo contenuto in mezzo.

Fatto questo ricarichiamo Apache:

call_agg_vhost() {

	a2ensite "${dominio/./_}" 2>/dev/null || errore "Apache non è installato o configurato correttamente."
	service apache2 reload 2>/dev/null

}

call_agg_vhost() {

a2ensite "${dominio/./_}" 2>/dev/null || errore "Apache non è installato o configurato correttamente."

service apache2 reload 2>/dev/null

}

Adesso ci manca solamente il database:

newpassword="$(openssl rand -base64 12)"

call_crea_db() {

	dbname="${dominio/./_}"
	dbname="${dbname/-/_}"
	mysql -u$dbadmin -p$dbpass -e "DROP DATABASE IF EXISTS $dbname" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "DROP USER $dbname@localhost" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "CREATE DATABASE $dbname" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "CREATE USER $dbname@localhost IDENTIFIED BY '$newpassword'" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "GRANT ALL PRIVILEGES ON $dbname.* TO $dbname@localhost" 2>/dev/null

}

newpassword="$(openssl rand -base64 12)"

call_crea_db() {

dbname="${dominio/./_}"

dbname="${dbname/-/_}"

mysql -u$dbadmin -p$dbpass -e "DROP DATABASE IF EXISTS $dbname" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "DROP USER $dbname@localhost" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "CREATE DATABASE $dbname" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "CREATE USER $dbname@localhost IDENTIFIED BY '$newpassword'" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "GRANT ALL PRIVILEGES ON $dbname.* TO $dbname@localhost" 2>/dev/null

}

Anche in questo caso abbiamo creato una password che assoceremo ad un utente chiamato come il database medesimo e che ha accesso solamente dal server locale.

Infine, per testare il tutto (questo certo non sarebbe uno standard opportuno per un vero hosting) creiamo un file index.php nel VirtualHost appena configurato e inseriamo dentro i seguenti parametri:

call_crea_index() {

cat << EOF > "${www}$dominio/index.php"
<?php

        echo "<h1>$dominio under construction</h1>";
        mysqli_connect("localhost", "$dbname", "$newpassword", "$dbname") or die("Errore database");

?>
EOF

}

call_crea_index() {

cat << EOF > "${www}$dominio/index.php"

<?php

echo "<h1>$dominio under construction</h1>";

mysqli_connect("localhost", "$dbname", "$newpassword", "$dbname") or die("Errore database");

EOF

}

Se tutto è andato bene collegandoci al dominio del hosting appena registrato dovremmo veder scritto Nome_Dominio under construction e nessun avviso di Errore database.

Aggiungo anche un’ultima funzione utile per ripristinare il tutto quando si usa il parametro –fix, cancellando quindi il vhost e le relative cartelle:

call_rimuovi() {

	if $ripristina
	then
		a2dissite "${dominio/./_}"
		rm -R $www$dominio 2>/dev/null
		rm "${sites}${dominio/./_}.conf"
	fi

}

call_rimuovi() {

if $ripristina

then

a2dissite "${dominio/./_}"

rm -R $www$dominio 2>/dev/null

rm "${sites}${dominio/./_}.conf"

}

Il codice completo, riorganizzando quanto detto prima, è questo:

#!/bin/bash

# CONFIGURAZIONE SISTEMA
sites="/etc/apache2/sites-available/"
www="/var/www/"

# CODICE DA NON MODIFICARE
GIALLO='\033[1;33m'
ROSSO='\033[0;31m'
CELESTE='\033[1;34m'
NC='\033[0m'
TAB1='\t'
TAB2='\t\t'

aiuto=false
ripristina=false

newpassword="$(openssl rand -base64 12)"
ftppassword="$(openssl rand -base64 12)"

errore() {

        echo -e "${ROSSO}ERRORE!${NC} $1. Per aiuto usare -h o --help"
	exit

}


while [[ $# -gt 0 ]]
do

	parametro="$1"

	case $parametro in
		-d|--domain)
		dominio="$2"
		shift
		shift
		;;
		-u|--user)
		utente="$2"
		shift
		shift
		;;
		--dbadmin)
		dbadmin="$2"
		shift
		shift
		;;
		--dbpass|--dbpassword)
		dbpass="$2"
		shift
		shift
		;;
		-h|--help)
		aiuto=true
		shift
		;;
		-f|--fix)
		ripristina=true
		shift
		;;
		*)
		shift
		;;
	esac

done

call_aiuto() {

	if $aiuto
	then
		echo
		echo -e "${TAB1}${ROSSO}GUIDA ALL'UTILIZZO${NC}"
		echo
		echo -e "${TAB1}$0"
		echo
		echo -e "${TAB1}${CELESTE}Comando${NC}"
		echo -e "${TAB1}$0 -d|--domain DomainName -u|--user DomainUser --dbadmin DatabaseRootUser [--dbpass|--dbpassword DatabaseRootPassword] [-f|--fix]"
		echo 
		echo -e "${TAB1}${CELESTE}Parametri${NC}"
		echo -e "${TAB1}${GIALLO}DomainName${NC}${TAB2}nome del dominio che vogliamo creare, per esempio: -d miosito.com"
		echo -e "${TAB1}${GIALLO}DomainUser${NC}${TAB2}nome dell'utente che gestirà il dominio, per esempio: -u mariorossi"
		echo -e "${TAB1}${GIALLO}DatabaseRootUser${NC}${TAB1}nome dell'utente amministratore del database, tipicamente root"
		echo -e "${TAB1}${GIALLO}DatabaseRootPassword${NC}${TAB1}Password dell'utente amministratore del database"
		echo
		exit
	fi

}

call_check_dbadmin() {

	if [[ $dbadmin = "" ]]
	then
		errore "Inserire utente amministratore del database"
	fi

}

call_check_dbpass() {

	if [[ $dbadmin != "" && $dbpass = "" ]]
	then
		echo -n "$dbadmin password: "
		read -s dbpass
		echo
	fi

}

call_crea_cartella() {

	mkdir $www$dominio 2>/dev/null || errore "Permesso negato. Eseguire come root"

}

call_crea_ftp() {

	useradd --shell /bin/false $utente
	chown $utente:www-data $www$dominio
	usermod -d $www$dominio $utente
	echo $utente:$ftppassword | /usr/sbin/chpasswd
	echo "FTP Password: $ftppassword"

}

call_crea_vhost() {

cat << EOF > "${sites}${dominio/./_}.conf"
<VirtualHost *:80>
        ServerName $dominio

        ServerAdmin webmaster@localhost
        DocumentRoot $www$dominio

        ErrorLog \${APACHE_LOG_DIR}/error.log
        CustomLog \${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
EOF

}

call_agg_vhost() {

	a2ensite "${dominio/./_}" 2>/dev/null || errore "Apache non è installato o configurato correttamente."
	service apache2 reload 2>/dev/null

}

call_crea_db() {

	dbname="${dominio/./_}"
	dbname="${dbname/-/_}"
	mysql -u$dbadmin -p$dbpass -e "DROP DATABASE IF EXISTS $dbname" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "DROP USER $dbname@localhost" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "CREATE DATABASE $dbname" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "CREATE USER $dbname@localhost IDENTIFIED BY '$newpassword'" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "GRANT ALL PRIVILEGES ON $dbname.* TO $dbname@localhost" 2>/dev/null

}

call_crea_index() {

cat << EOF > "${www}$dominio/index.php"
<?php

        echo "<h1>$dominio under construction</h1>";
        mysqli_connect("localhost", "$dbname", "$newpassword", "$dbname") or die("Errore database");

?>
EOF

}


call_rimuovi() {

	if $ripristina
	then
		a2dissite "${dominio/./_}"
		rm -R $www$dominio 2>/dev/null
		rm "${sites}${dominio/./_}.conf"
	fi

}

call_rimuovi
call_aiuto
call_check_dbadmin
call_check_dbpass
call_crea_cartella
call_crea_vhost
call_agg_vhost
call_crea_db
call_crea_index
call_crea_ftp

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

#!/bin/bash

# CONFIGURAZIONE SISTEMA

sites="/etc/apache2/sites-available/"

www="/var/www/"

# CODICE DA NON MODIFICARE

GIALLO='\033[1;33m'

ROSSO='\033[0;31m'

CELESTE='\033[1;34m'

NC='\033[0m'

TAB1='\t'

TAB2='\t\t'

aiuto=false

ripristina=false

newpassword="$(openssl rand -base64 12)"

ftppassword="$(openssl rand -base64 12)"

errore() {

echo -e "${ROSSO}ERRORE!${NC} $1. Per aiuto usare -h o --help"

exit

}

while [[ $# -gt 0 ]]

parametro="$1"

case $parametro in

-d|--domain)

dominio="$2"

shift

;;

-u|--user)

utente="$2"

shift

;;

--dbadmin)

dbadmin="$2"

shift

;;

--dbpass|--dbpassword)

dbpass="$2"

shift

;;

-h|--help)

aiuto=true

shift

;;

-f|--fix)

ripristina=true

shift

;;

shift

;;

esac

done

call_aiuto() {

if $aiuto

then

echo

echo -e "${TAB1}${ROSSO}GUIDA ALL'UTILIZZO${NC}"

echo

echo -e "${TAB1}$0"

echo

echo -e "${TAB1}${CELESTE}Comando${NC}"

echo -e "${TAB1}$0 -d|--domain DomainName -u|--user DomainUser --dbadmin DatabaseRootUser [--dbpass|--dbpassword DatabaseRootPassword] [-f|--fix]"

echo

echo -e "${TAB1}${CELESTE}Parametri${NC}"

echo -e "${TAB1}${GIALLO}DomainName${NC}${TAB2}nome del dominio che vogliamo creare, per esempio: -d miosito.com"

echo -e "${TAB1}${GIALLO}DomainUser${NC}${TAB2}nome dell'utente che gestirà il dominio, per esempio: -u mariorossi"

echo -e "${TAB1}${GIALLO}DatabaseRootUser${NC}${TAB1}nome dell'utente amministratore del database, tipicamente root"

echo -e "${TAB1}${GIALLO}DatabaseRootPassword${NC}${TAB1}Password dell'utente amministratore del database"

echo

exit

}

call_check_dbadmin() {

if [[ $dbadmin = "" ]]

then

errore "Inserire utente amministratore del database"

}

call_check_dbpass() {

if [[ $dbadmin != "" && $dbpass = "" ]]

then

echo -n "$dbadmin password: "

read -s dbpass

echo

}

call_crea_cartella() {

mkdir $www$dominio 2>/dev/null || errore "Permesso negato. Eseguire come root"

}

call_crea_ftp() {

useradd --shell /bin/false $utente

chown $utente:www-data $www$dominio

usermod -d $www$dominio $utente

echo $utente:$ftppassword | /usr/sbin/chpasswd

echo "FTP Password: $ftppassword"

}

call_crea_vhost() {

cat << EOF > "${sites}${dominio/./_}.conf"

ServerName $dominio

ServerAdmin webmaster@localhost

DocumentRoot $www$dominio

ErrorLog \${APACHE_LOG_DIR}/error.log

CustomLog \${APACHE_LOG_DIR}/access.log combined

</VirtualHost>

EOF

}

call_agg_vhost() {

a2ensite "${dominio/./_}" 2>/dev/null || errore "Apache non è installato o configurato correttamente."

service apache2 reload 2>/dev/null

}

call_crea_db() {

dbname="${dominio/./_}"

dbname="${dbname/-/_}"

mysql -u$dbadmin -p$dbpass -e "DROP DATABASE IF EXISTS $dbname" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "DROP USER $dbname@localhost" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "CREATE DATABASE $dbname" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "CREATE USER $dbname@localhost IDENTIFIED BY '$newpassword'" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "GRANT ALL PRIVILEGES ON $dbname.* TO $dbname@localhost" 2>/dev/null

}

call_crea_index() {

cat << EOF > "${www}$dominio/index.php"

<?php

echo "<h1>$dominio under construction</h1>";

mysqli_connect("localhost", "$dbname", "$newpassword", "$dbname") or die("Errore database");

EOF

}

call_rimuovi() {

if $ripristina

then

a2dissite "${dominio/./_}"

rm -R $www$dominio 2>/dev/null

rm "${sites}${dominio/./_}.conf"

}

call_rimuovi

call_aiuto

call_check_dbadmin

call_check_dbpass

call_crea_cartella

call_crea_vhost

call_agg_vhost

call_crea_db

call_crea_index

call_crea_ftp

Il codice è stato scritto e testato su Ubuntu Server 16.04, con sopra installati Apache, MySQL, PHP, OpenSSL e ProFTPd.

Vedi articolo