Vendredi 23 novembre 2018

Debian stretch 9/VBox

  • Serveur virtuel 64 bits virtualbox : DebianStretch
  • machine : vboxdeb
  • domaine : stretch.tld
  • root : ytreu49
  • Utilisateur : usera
  • Mot de passe : usera49
  • Adresse IP : 192.168.0.11
  • Accès SSH : ssh usera@192.168.0.11
  • SSH + clé : ssh -p 55022 -i ~/.ssh/stretch usera@192.168.0.11
  • Transfert de fichier : scp -P 55022 -i ~/.ssh/stretch fichiera fichierb usera@192.168.0.11:/home/usera
#Démarrage
VBoxManage startvm "DebianStretch" --type headless
alias jstart='VBoxManage startvm "DebianStretch" --type headless' # ajout au fichier ~/.bashrc

#Arrêt
VBoxManage controlvm "DebianStretch" poweroff
alias jstop='VBoxManage controlvm "DebianStretch" poweroff' # ajout au fichier ~/.bashrc

Connexion SSH

ssh usera@192.168.0.11

Passer en root

su

Installer sudo

apt install sudo

Visudo pour les accès root via utilisateur usera

echo "usera     ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers

Additions Invité/Debian

Préalable
Configurer votre machine virtuelle pour un accès au réseau partagé.
'’Configuration’’ –> ‘‘Dossiers partagés’‘
Ajouter le dossier et cocher '’Montage automatique’‘

Installer les additions client dans un Debian en cours d’exécution dans une machine virtuelle.

  • Installez gcc ,make et* *kernel headers** (installateur a besoin d’eux pour construire le module du noyau):
    • sudo apt install gcc make linux-headers-$(uname -r)
  • Allez dans le menu '’Périphériques’’ –> ‘‘Insérer l’image des additions invité…’‘ de la machine virtuelle en cours d’exécution ,si non présent , le télécharger.
  • Monter le cd dans la machine virtuelle : sudo mount /dev/cdrom /media/cdrom
  • Allez dans le dossier monté : cd /media/cdrom
  • Exécutez : sudo ./VBoxLinuxAdditions.run
    • Pas d’environnement graphique : ne pas tenir compte de l'erreur '’Could not find the X.Org or XFree86 Window System, skipping.’‘
  • Il faut ajouter le group vboxsf à votre utilisateur : sudo usermod -a -G vboxsf $USER
  • Pour la prise en compte, redémarrer la machine virtuelle : sudo reboot

/media/ est le répertoire qui contient le(s) dossier(s) partagé(s)

Gestion des clés SSH

Avec gestion des clés
ssh -p 55022 -i ~/.ssh/stretch usera@192.168.0.11
Partage du dossier /var/www en local sur /media/yanspm.net
sshfs -oIdentityFile=~/.ssh/stretch usera@192.168.0.11:/var/www /media/stretch.tld -C -p 55022

nginx+php+mariadb

php --version

PHP 7.0.19-1 (cli) (built: May 11 2017 14:04:47) ( NTS )
Copyright (c) 1997-2017 The PHP Group
Zend Engine v3.0.0, Copyright (c) 1998-2017 Zend Technologies
    with Zend OPcache v7.0.19-1, Copyright (c) 1999-2017, by Zend Technologies

mysql --version

mysql  Ver 15.1 Distrib 10.1.26-MariaDB, for debian-linux-gnu (x86_64) using readline 5.2

auth nginx

https://github.com/sto/ngx_http_auth_pam_module

sudo nano /etc/pam.d/nginx
@include common-auth

To protect everything under /secure you will add the following to the nginx.conf file:

location /secure {
    auth_pam              "Secure Zone";
    auth_pam_service_name "nginx";
}

Note that the module runs as the web server user, so the PAM modules used must be able to authenticate the users without being root; that means that if you want to use the pam_unix.so module to autenticate users you need to let the web server user to read the /etc/shadow file if that does not scare you (on Debian like systems you can add the www-data user to the shadow group).

sudo usermod -aG www-data $USER

Nginx with PAM Authentication

Open Access to Nginx User

Because we will use the OS user name and password for user authentication, we need to open the access of the related password file to the user that runs Nginx server which is www-data. One simple Linux command can achieve it as follows:
# usermod -a -G shadow www-data

Change configurations

Within the /etc/pam.d create a new file called nginx. You can change the file name as long as you reference the new name in later configuration file.
# more /etc/pam.d/nginx
@include common-auth

sso

nginx-sso fonctionne en créant un cookie de session sso. Ce cookie contient des informations sur l’utilisateur, la date de péremption de sa session et l’adresse IP du client connecté. En outre, le cookie contient une signature ECDSA qui protège l’intégrité de la charge utile lors de la connexion. Dans notre cas, l’outil ssologin possède la clé privée ECC nécessaire et crée le cookie et la signature après une connexion réussie.

L’outil ssologin doit être personnalisé pour votre propre architecture de connexion. Il faut que la personnalisation s’adapte à votre magasin d’identification utilisateur (qu’il s’agisse de LDAP, Htdigest, OAuth, homebrew). Le dénominateur commun est qu’il attend une chaîne non vide pour le nom d’utilisateur et une chaîne de groupe facultative (délimitée par des virgules). Ces deux valeurs seront encodées dans le cookie sso.

Tout service en possession de la clé publique correspondante peut alors utiliser les informations stockées dans le cookie sso. Avec nginx-sso, cela se fait par l’outil ssoauth. Cet outil est notre point d’extrémité d’authentification interrogé par nginx. L’outil ssoauth prend le cookie sso, vérifie son intégrité et sa fraîcheur (en utilisant la signature ci-jointe) et vérifie enfin le nom d’utilisateur et les groupes contre une liste d’entrées ACL pour différents vhosts. Si tous ces contrôles passent, il renverra le nom d’utilisateur, les groupes et l’heure d’expiration du cookie au front de Nginx, ce qui peut le transmettre à votre application sous la forme d’un en-tête HTTP simple. Votre application pourrait ensuite utiliser cet en-tête pour trouver l’utilisateur dans sa propre base de données utilisateur qui pourrait contenir des attributs supplémentaires (par exemple, les rôles, les informations de contact, etc.).

golang

How to Install Go 1.8 on Debian 9/8/7

wget https://storage.googleapis.com/golang/go1.8.3.linux-amd64.tar.gz
sudo tar -xvf go1.8.3.linux-amd64.tar.gz
sudo mv go /usr/local
# variables à ajouter au fichier ~/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/nginx-sso
export PATH=$GOPATH/bin:$GOROOT/bin:$PATH

Vérifications
usera@vboxdeb:~$ go version

go version go1.8.3 linux/amd64

usera@vboxdeb:~$ go env

GOARCH="amd64"
GOBIN=""
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH="/home/usera/nginx-sso"
GORACE=""
GOROOT="/usr/local/go"
GOTOOLDIR="/usr/local/go/pkg/tool/linux_amd64"
GCCGO="gccgo"
CC="gcc"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build634920677=/tmp/go-build -gno-record-gcc-switches"
CXX="g++"
CGO_ENABLED="1"
PKG_CONFIG="pkg-config"
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"

nginx-sso

https://github.com/heipei/nginx-sso
https://github.com/heipei/nginx-sso/blob/master/TECHNICAL.md

projet go ~/nginx-sso/

cd /home/usera
git clone https://github.com/heipei/nginx-sso.git
cd nginx-sso/
make
go get github.com/sirupsen/logrus
make
mv src/github.com/sirupsen/ src/github.com/Sirupsen/
make
go get github.com/heipei/nginx-sso/ssocookie
make
go get github.com/mattn/go-sqlite3
make
go build ssologin.go

There is an example nginx.conf in etc/
sudo nano /etc/nginx/conf.d/nginx-sso.conf


server {
    listen 80;
    listen [::]:80;
    server_name test.domain.dev;
    root /var/www/ ;

    index index.php index.html index.htm;
        location ~ \.php$ {
           fastcgi_split_path_info ^(.+\.php)(/.+)$;
           # fastcgi_pass unix:/var/run/php5-fpm.sock;    # PHP5
           fastcgi_pass unix:/run/php/php7.0-fpm.sock;    # PHP7.0 
           # fastcgi_pass unix:/run/php/php7.1-fpm.sock   # PHP7.1
           fastcgi_index index.php;
           include fastcgi_params;
	   fastcgi_param SCRIPT_FILENAME $request_filename;
        }


}
	server {
		server_name secret.domain.dev;
		listen 8080;

		# It has one /auth URI which is the endpoint that protected
		# resources have to query. The /auth endpoint does not need the
		# request_body, but it obviously needs the IP, Host and
		# original URI for the request.
		location = /auth {
			internal;

			proxy_pass http://127.0.0.1:8082;

			proxy_pass_request_body     off;

			proxy_set_header Content-Length "";
			proxy_set_header X-Original-URI $request_uri;
			proxy_set_header Host $http_host;
			proxy_set_header X-Real-IP $remote_addr;

		}

		# This is an example of a protected resource. The first line
		# should be auth_request. If you want to pass the headers from
		# the authentication backend to your application (Remote-User
		# etc), you'll have to include the lines with auth_request_set
		# and proxy_set header. 
		location /secret {
			auth_request /auth;

			auth_request_set $user $upstream_http_remote_user;
			proxy_set_header Remote-User $user;
			auth_request_set $groups $upstream_http_remote_groups;
			proxy_set_header Remote-Groups $groups;
			auth_request_set $expiry $upstream_http_remote_expiry;
			proxy_set_header Remote-Expiry $expiry;

			return 200 "Open Sesame!";
			#proxy_pass http://127.0.0.1:52342;
		}

	}

	# This is the vserver for your login service
	server {
		server_name login.domain.dev;
		listen 8080 default_server;

		# The login endpoint also needs the Host and real IP of the
		# client to build the sso cookie.
		location /login {
                        auth_pam    "Secure Zone";
                        auth_pam_service_name   "nginx";
			proxy_set_header X-Original-URI $request_uri;
			proxy_set_header Host $http_host;
			proxy_set_header X-Real-IP $remote_addr;
			proxy_pass http://127.0.0.1:8081;

		}
	}

Relancer nginx (si temporaire, nginx -c $PWD/etc/nginx.conf)
sudo systemctl restart nginx
cd ~/nginx-sso

Pour les tests on utilise sqlite3
sudo apt install sqlite3
Accéder base
sqlite3 run/users.db
On arrive sur le prompt sqlite3
sqlite>
Créer une table users
create table users (username string not null primary key, password string not null, groups string default null);
Ajouter un utilisateur et un mot de passe
insert into "users" (username,password) values("yann","yann49"); Pour présenter les résultat d’une requête sous forme de tableau dans le terminal on utilisera:
.headers on
.mode column
Afficher
select * from users;

username    password    groups    
----------  ----------  ----------
yann        yann49                

Sortir de la base
.quit

Mise à jour table
sqlite3 run/users.db
UPDATE users SET groups = "users" WHERE username = "yann";

Générer une paire de clé avec l’outil tools/ecc.go
go run tools/ecc.go

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIHQcrabk3e+RA5B9KKrRLvygQUUN4lIvs95DK3perLbhoAoGCCqGSM49
AwEHoUQDQgAEoJ4rRAM8YxhBnIpb0Q9lls7ybv0kRcolPRomEjesdcB7wgzRYDEt
sRaTP9tqfSgTm3fBiN57CxZVQ6eBEfy0AQ==
-----END EC PRIVATE KEY-----

-----BEGIN EC PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoJ4rRAM8YxhBnIpb0Q9lls7ybv0k
RcolPRomEjesdcB7wgzRYDEtsRaTP9tqfSgTm3fBiN57CxZVQ6eBEfy0AQ==
-----END EC PUBLIC KEY-----

Copie de la clé publique dans un fichier
nano run/prime256v1-public.pem

-----BEGIN EC PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoJ4rRAM8YxhBnIpb0Q9lls7ybv0k
RcolPRomEjesdcB7wgzRYDEtsRaTP9tqfSgTm3fBiN57CxZVQ6eBEfy0AQ==
-----END EC PUBLIC KEY-----

Copie de la clé privée dans un fichier
nano run/prime256v1-key.pem

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIHQcrabk3e+RA5B9KKrRLvygQUUN4lIvs95DK3perLbhoAoGCCqGSM49
AwEHoUQDQgAEoJ4rRAM8YxhBnIpb0Q9lls7ybv0kRcolPRomEjesdcB7wgzRYDEt
sRaTP9tqfSgTm3fBiN57CxZVQ6eBEfy0AQ==
-----END EC PRIVATE KEY-----
usera@vboxdeb:~/nginx-sso$ cat etc/ssoauth.json
{
	"cookie": "sso",
	"debug": true,
	"pubkeyfile": "run/prime256v1-public.pem",
	"headers": {
		"ip": "X-Real-Ip",
		"uri": "X-Original-Uri"
	},
	"returnheaders": {
		"user": "Remote-User",
		"groups": "Remote-Groups",
		"expiry": "Remote-Expiry"
	},
	"port": 8082,
	"acl": {
		"auth.domain.dev:8080": {
			"Users": ["jg123456"],
			"Groups": ["x:"],
			"UrlPrefixes": {
				"/secret/": {
					"Users": ["jg666666"],
					"Groups": ["y:engineering:cloud"]
				}
			}
		}
	}
}

Start ssoauth: ./ssoauth -config etc/ssoauth.json

INFO[0000] ssoauth starting                             
DEBU[0000] Public key:
-----BEGIN EC PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoJ4rRAM8YxhBnIpb0Q9lls7ybv0k
RcolPRomEjesdcB7wgzRYDEtsRaTP9tqfSgTm3fBiN57CxZVQ6eBEfy0AQ==
-----END EC PUBLIC KEY-----
 
DEBU[0000] Read ECC public key from run/prime256v1-public.pem 
INFO[0000] ssoauth server running on 127.0.0.1:8082     
usera@vboxdeb:~/nginx-sso$ cat etc/ssologin.json 
{
	"cookie": "sso",
	"debug": false,
	"secure": false,
	"expiration": 3600,
	"domain": ".domain.dev",
	"privkeyfile": "run/prime256v1-key.pem",
	"headers": {
		"ip": "X-Real-Ip",
		"uri": "X-Original-Uri"
	},
	"port": 8081
}

Start ssologin: ./ssologin -config etc/ssologin.json

INFO[0000] ssologin starting                            
INFO[0000] ssologin server running on 127.0.0.1:8081    

Add login.domain.dev and auth.domain.dev to 127.0.0.1 to /etc/hosts
127.0.0.1 localhost login.domain.dev auth.domain.dev

  • Browse to http://username:password@login.domain.dev:8080/login http://yann:yan49@login.domain.dev:8080/login
  • Browse to http://auth.domain.dev:8080/secret

Test connexion
$ curl -v -u yann:yann49 http://login.domain.dev:8080/login

*   Trying 192.168.0.11...
* TCP_NODELAY set
* Connected to login.domain.dev (192.168.0.11) port 8080 (#0)
* Server auth using Basic with user 'yann'
> GET /login HTTP/1.1
> Host: login.domain.dev:8080
> Authorization: Basic eWFubjp5YW5uNDk=
> User-Agent: curl/7.55.1
> Accept: */*
> 
< HTTP/1.1 200 OK
< Server: nginx/1.13.5
< Date: Sat, 16 Sep 2017 08:11:08 GMT
< Content-Type: text/plain; charset=utf-8
< Content-Length: 25
< Connection: keep-alive
< Set-Cookie: sso=%7B%22R%22%3A40793564329734296575681372593984674445032360946321672191631800730805894913803%2C%22S%22%3A94833192066600614578429001238291441797514257228853836547717561132152092937581%2C%22E%22%3A1505553068%2C%22P%22%3A%7B%22U%22%3A%22yann%22%2C%22G%22%3A%22users%22%7D%7D; Domain=domain.dev; Expires=Sat, 16 Sep 2017 09:11:08 GMT
< 
You have been logged in!
* Connection #0 to host login.domain.dev left intact

$ curl -v http://secret.domain.dev:8080/secret

*   Trying 192.168.0.11...
* TCP_NODELAY set
* Connected to secret.domain.dev (192.168.0.11) port 8080 (#0)
> GET /secret HTTP/1.1
> Host: secret.domain.dev:8080
> User-Agent: curl/7.55.1
> Accept: */*
> 
< HTTP/1.1 200 OK
< Server: nginx/1.13.5
< Date: Sat, 16 Sep 2017 08:13:37 GMT
< Content-Type: text/plain
< Content-Length: 12
< Connection: keep-alive
< 
* Connection #0 to host secret.domain.dev left intact
Open Sesame!

http://www.meridianoutpost.com/resources/etools/php-functions/php-crypt-md5-sha1.php?

Hash Results
Test String:
	yannick49
Crypt Hash Value:
	$1$imBCDMto$/hMSwKk/efClEbdPDUojN/
MD5 Hash Value:
	47f47402cfed6c8f3d058dd93fb3f7ef
SHA1 Hash Value:
	c107559c59960a2340913287fd386c7c1c2aa92b

Ajouter un utilisateur et un mot de passe crypt
sqlite3 run/users.db
insert into "users" (username,password,groups) values("yannick","$1$imBCDMto$/hMSwKk/efClEbdPDUojN/","users");
Test connexion
$ curl -v -u 'yannick:$1$imBCDMto$/hMSwKk/efClEbdPDUojN/' http://login.domain.dev:8080/login

fonction login

http://www.supinfo.com/articles/single/653-php-550-avancement-systeme-inscription-connexion

Créer une base utilisateur login mot de passe mariadb root 2qwHz8Z9
sudo -s
Accès mariadb
mysql -uroot -p2qwHz8Z9

CREATE DATABASE utilisateurs;
GRANT ALL PRIVILEGES ON utilisateurs.* TO 'utilisateurs'@'localhost' IDENTIFIED BY 'm9pB26Fd';
FLUSH PRIVILEGES;
quit

Créer une table

use utilisateurs;

CREATE TABLE users (
id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(30) NOT NULL,
password VARCHAR(255) NOT NULL,
email VARCHAR(50),
reg_date TIMESTAMP
);

/var/www/index.php

<!DOCTYPE html>
<html>
	<head>
	<title>Exemple - Mot de passe</title>
	</head>
	<body>
	<h2>Enregistrement</h2>
	<form action="register.php" method="POST">
		<label>Identifiant :</label>
		<input type="text" name="username" required /><br /><br />
		<label>Mot de passe :</label>
		<input type="password" name="password" required /><br /><br />
		<label>Retapez mot de passe :</label>
		<input type="password" name="password2" required /><br /><br />
		<input type="submit" />
	</form>
	<br /><hr />
	<h2>Connexion</h2>
	<form action="login.php" method="POST">
		<label>Identifiant :</label>
		<input type="text" name="username" required /><br /><br />
		<label>Mot de passe :</label>
		<input type="password" name="password" required /><br /><br />
		<input type="submit" />
	</form>
	</body>
</html>

register.php

<?php
//Connexion à la base de données
//(via PDO, utilisez la méthode de votre choix comme le type de base de données de votre choix)
$pdo = new PDO(
    'mysql:host=localhost;dbname=utilisateurs', 'utilisateurs', 'm9pB26Fd');
	
//On vérifie que l'utilisateur a bien envoyé les informations demandées 
if(isset($_POST["username"]) && isset($_POST["password"]) && isset($_POST["password2"])){
	//On vérifie que password et password2 sont identiques
	if($_POST["password"] == $_POST["password2"]){
		//On utilise alors notre fonction password_hash :
		$hash = password_hash($_POST["password"], PASSWORD_DEFAULT);
		//Puis on stock le résultat dans la base de données :
		$query = $pdo->prepare('INSERT INTO users (username, password) VALUES(:username, :password);');
		$query->bindParam(':username', $_POST["username"], PDO::PARAM_STR, 30);
		$query->bindParam(':password', $hash, PDO::PARAM_STR, 255);
		$query->execute();
		header('Location: index.php');
		exit();
	}
}
?>

login.php

<?php
//Connexion à la base de données
//(via PDO, utilisez la méthode de votre choix comme le type de base de données de votre choix)
$pdo = new PDO(
    'mysql:host=localhost;dbname=utilisateurs', 'utilisateurs', 'm9pB26Fd');
	
//Nous vérifions que l'utilisateur a bien envoyé les informations demandées 
if(isset($_POST["username"]) && isset($_POST["password"])){
	//Nous allons demander le hash pour cet utilisateur à notre base de données :
	$query = $pdo->prepare('SELECT password FROM users WHERE username = :username');
	$query->bindParam(':username', $_POST["username"], PDO::PARAM_STR, 30);
	$query->execute();
	$result = $query->fetch();
	$hash = $result[0];
	
	//Nous vérifions si le mot de passe utilisé correspond bien à ce hash à l'aide de password_verify :
	$correctPassword = password_verify($_POST["password"], $hash);
	
	if($correctPassword){
		//Si oui nous accueillons l'utilisateur identifié
		echo "Bienvenu ".$_POST["username"];
	}else{
		//Sinon nous signalons une erreur d'identifiant ou de mot de passe
                echo "le hash lu dans la base : ".$hash."\n";
		echo "login/password incorrect";
	}
}
?>

lecture de la base users
mysql -uroot -p2qwHz8Z9 utilisateurs -e "select * from users;"
Insertion
mysql -uroot -p2qwHz8Z9 utilisateurs -e 'INSERT INTO users(username, password) VALUES("test4", "$2y$10$3la5Q8aHasr1RC0WRVrEhOajYGpe4vQn3yWz0TI3uAAcnXORQ5NJq");'
script bash mariadb
mysql -uroot -p2qwHz8Z9 utilisateurs -e "DROP DATABASE utilisateurs; CREATE DATABASE utilisateurs; use utilisateurs; CREATE TABLE users (id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,username VARCHAR(30),password VARCHAR(255) NOT NULL,email VARCHAR(50),reg_date TIMESTAMP);"

bash php ./test.php

#!/usr/bin/php
<?php
//Connexion à la base de données
//(via PDO, utilisez la méthode de votre choix comme le type de base de données de votre choix)
$user="yannick";
$pass="yannick49";
$pdo = new PDO(
    'mysql:host=localhost;dbname=utilisateurs', 'utilisateurs', 'm9pB26Fd');
	
		//On utilise alors notre fonction password_hash :
		$hash = password_hash($pass, PASSWORD_DEFAULT);
		echo "hash : ".$hash."\n";
		//Puis on stock le résultat dans la base de données :
		$query = $pdo->prepare('INSERT INTO users (username, password) VALUES(:username, :password);');
		$query->bindParam(':username', $user);
		$query->bindParam(':password', $hash);
		$query->execute();
?>

Test yanfi ht4b82T3AJ

8Niy3BzgYu422N

CREATE DATABASE utilisateurs; GRANT ALL PRIVILEGES ON utilisateurs.* TO ‘utilisateurs’@’localhost’ IDENTIFIED BY ‘m9pB26Fd’; FLUSH PRIVILEGES;

DROP TABLE members;

Database “utilisateurs”
mysql -uutilisateurs -pm9pB26Fd
Création de la table members

CREATE TABLE `members` (
  `memberID` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) NOT NULL,
  `password` varchar(255) NOT NULL,
  `email` varchar(255) NOT NULL,
  `active` varchar(255) NOT NULL,
  `resetToken` varchar(255) DEFAULT NULL,
  `resetComplete` varchar(3) DEFAULT 'No',
  PRIMARY KEY (`memberID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

quit