lindev.fr

Aller au contenu | Aller au menu | Aller à la recherche

01 oct. 2015

EC2, ajouter un compte utilisateur avec certificat .pem

A la création d'une instance EC2, vous avez un compte par défaut ( ec2-user ou admin selon la distrib ) .
Ce compte vous permet d’accéder et d'administrer votre instance via une connexion SSH , avec une authentification par certificat ( que vous avez préalablement téléchargé à la création de l'instance ).

On va voir ici comment ajouter un compte utilisateur avec un nouveau certificat pour qu'il puisse également se connecter sur cette instance EC2.

Première étape le certificat

Nous allons commencer par créer ce nouveau certificat via l'interface d'amazon ( la clef privée )

Clef privée ( .pem )

C'est très simple, suivez le guide...

Dirigez-vous vers le service EC2 Capture_d_e_cran_2015-10-01_a__09.22.02.png

Gestion des clef Capture_d_e_cran_2015-10-01_a__09.22.13.png

Créer un clef Capture_d_e_cran_2015-10-01_a__09.22.23.png

Vous devrez alors télécharger cette nouvelle clef ( ici elle s'appelle lindev.pem )

Clef public

Coté serveur, nous allons devoir spécifier la clef publique liée à cette clef privée pour le nouvel utilisateur.
Commençons donc par récupérer cette clef publique.

Changez les droits du certificat
chmod 400 lindev.pem
Générer les clef publique à partir de la clef privée
ssh-keygen -y

Cette commande va vous demander le chemin vers la clef privée. Suite à quoi il va vous sortir la clef public .
Par exemple :

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCISBb/pQYoSz1tm2mWrBBK8Yfs+8z2rdcbYhCIgz7oLE2YNrT/cs8D9WXduTezS1p/SjdfA4zhXSJNBvjNP0A0M2s1Mj3E+edpENhsYrLBxDc1F60CQ4be0hLICX2e2mDzPYi7sLgAzAdVI67Eo2Zmj/0QYwckS4JgFl7JXedV8Fz4D2gm8xjByxbtlsPhG84Y9wq7GGmtHuaHzi+H+RVS1hlDZIH8QKwX9U5eWJY3BaQjXpwnorNvn2OrlO9wmTE+22A7F0vF8zsRia+t5TwqPaVYmfX7DN5zqBMcd8tQC1LdYS0b+h6+fLAkUdaqQ0kXGm1FCxYH00hTYNS+JV/V

Gardez cette clef nous allons en avoir besoin bientôt coté serveur.

Coté serveur

Nous sommes maintenant sur notre instance EC2 avec l'utilisateur par defaut, nous allons donc créer notre second utilisateur et lui transmettre notre clef publique.

Création de l'utilisateur

root@ip-172-41-26-237:/home/admin# adduser lindev
Adding user `lindev' ...
Adding new group `lindev' (1001) ...
Adding new user `lindev' (1001) with group `lindev' ...
Creating home directory `/home/lindev' ...
Copying files from `/etc/skel' ...
Enter new UNIX password: 
Retype new UNIX password: 
passwd: password updated successfully
Changing the user information for lindev
Enter the new value, or press ENTER for the default
	Full Name []: Lindev
	Room Number []: 
	Work Phone []: 
	Home Phone []: 
	Other []: 
Is the information correct? [Y/n] Y

Voilà mon utilisateur créé, ne nous reste plus qu'à lui créer sa configuration ssh

ssh

Création du répertoire contenant la configuration ssh de l'utilisateur

sudo -s
su - lindev
mkdir /home/lindev/.ssh
chmod 700 /home/lindev/.ssh

Création du fichier contenant les clefs publiques

touch /home/lindev/.ssh/authorized_keys
chmod 600 /home/lindev/.ssh/authorized_keys

Editer le fichier authorized_keys et y coller votre clef public .

vim /home/lindev/.ssh/authorized_keys

je colle donc :

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCISBb/pQYoSz1tm2mWrBBK8Yfs+8z2rdcbYhCIgz7oLE2YNrT/cs8D9WXduTezS1p/SjdfA4zhXSJNBvjNP0A0M2s1Mj3E+edpENhsYrLBxDc1F60CQ4be0hLICX2e2mDzPYi7sLgAzAdVI67Eo2Zmj/0QYwckS4JgFl7JXedV8Fz4D2gm8xjByxbtlsPhG84Y9wq7GGmtHuaHzi+H+RVS1hlDZIH8QKwX9U5eWJY3BaQjXpwnorNvn2OrlO9wmTE+22A7F0vF8zsRia+t5TwqPaVYmfX7DN5zqBMcd8tQC1LdYS0b+h6+fLAkUdaqQ0kXGm1FCxYH00hTYNS+JV/V

On enregistre et on quitte.

Tests

Il ne vous reste plus qu'à tester a connexion avec votre nouvel utilisateur .

ssh -i "lindev.pem" lindev@52.29.115.207

Normalement vous devriez être connecté sans avoir à rentrer le moindre mot de passe, en utilisant le certificat Amazon.

01 août 2014

Proxy Socks sous android NON Rooté

En cette période de vacances, nous sommes nombreux à nous connecter depuis nos terminaux ( smartphone, tablette .. ) pour surfer, parfois travailler , dépanner .
Il est vrai que ces appareils sont formidables sur ce point ( le coté nomade ). Mais le revers de la médaille, c'est la sécurité !
Lorsque vous vous connectez à une borne wifi ( gratuite ou non ), qui vous assure que votre navigation n'est pas épiée ?
Voilà pour le coté sécurité, mais il peut être aussi utile de se connecter à son réseau local depuis l'extérieur.
Nous allons pour cela nous connecter via un serveur proxy de type socks.
Maintenant peu importe ce qui motive l'utilisation d'une telle connexion, voyons comment faire pour nous y connecter depuis un client Android non chrooté

Les apps à installer

  1. juiceSSH
  2. Firefox

JuiceSSH est un client SSH qui fonctionne vraiment bien, gratuit pour les fonctionnalités de base, mais payant pour faire une redirection de port. Vous allez donc devoir l'acheter, mais l'investissement en vaut la peine.
D'autres ont utilisé ConnectBOT qui lui est à 100% gratuit, mais de mon coté il plantait régulièrement je n'ai donc pas insisté.

Configuration de juiceSSH

Nous allons commencer par créer une connexion SSH de base, le tout en image :

2014_08_01_12.06.59.png

2014_08_01_12.08.03.png

  • Nickname : nom de la connexion
  • Type : SSH
  • Adresse : Adresse du serveur SSH
  • Identity : Login pour se connecter au serveur SSH
  • Port : port à utiliser pour se connecter au serveur SSH

Configuration de la redirection de port

Allez dans l'onglet PORT FORWARD, et nous allons utiliser la connexion SSH précédemment crée, comme ceci.

2014_08_01_12.08.40.png

Il est ensuite possible de mettre une icône sur votre page principale, pour se connecter plus rapidement au serveur proxy SOCKS

2014_08_01_12.08.57.png

Configuration de Firefox

Pour utiliser le serveur proxy ( après s'y être connecté ), dans firefox, ouvrez un nouvel onglet et entrez dans la barre d'adresse :

about:config


Voici les 5 paramètres à configurer comme ceci

2014_08_01_12.05.51.png 2014_08_01_12.06.11.png

Tests

Voilà maintenant vous pouvez tester le bon fonctionnement en entrant l'url suivante : http://www.whatismyip.com/, qui devrait vous afficher l'ip du serveur SSH à partir duquel vos requêtes sont envoyés .

Bonnes vacances .

03 mar. 2013

Motd encore un outil pratique

Business-Surveillance.jpg Si comme moi vous avez l'occasion d'administrer diverses serveurs de tailles plus ou moins importantes ( en fait la taille importe peu, pour moi c'est un réflexe ), vous avez certainement pris l'habitude, à chaque connexion journalière/hebdomadaire ou mensuelle ( ça dépend de beaucoup de choses ), de vérifier les "constantes" ( comme ils disent en médecine ) du serveur .

  • Espace disque
  • Charge système
  • Mémoire
  • Quelques services
  • ...

Alors l'outil que je vais vous présenter va certainement vous intéresser.
Simple efficace et administrable, je vous présente Motdstat

MotdStat

Le principe est extrêmement simple, un petit script est exécuté toutes les X minutes via une ligne de crontab qui se charge de relever ces fameuses constantes ( Espace disque des différentes partitions, charge système etc ... ), d'écrire un petit rapport dans le fichier /etc/motd et, en cas de dépassement de seuil, avertir par mail d'un possible problème ( bon, ce n'est clairement pas le but de cette solution d'offrir un systéme de monitoring, le fonctionnement étant trop simple pour être efficace en production mais reste pratique si l'on ne veut pas sortit l'artillerie lourde ( nagios , shinken, zabbix ) pour un petit serveur perso qui ne nécessite pas une surveillance accrue ). Peut importe, le coté avertissement par mail n'étant qu'un petit plus, ce que j'aime, c'est le rapport Motd qui permet d'afficher les dernières "constantes" mesurées lorsque je me connecte via ssh . Voilà ce que ça peu donner par exemple :

MOTDstat.png

Cool ... après tout, cela ne mange pas de pain, autant en profiter ... comment mettre cela en place.

Installation MotsStat

L'installation est extrêmement simple, ( comme d'habitude dans mes articles, je n'aime pas les choses compliqués ;) ) commençons par télécharger la dernière version sur le site principal.

cd /usr/local/src
wget http://www.gelogic.net/wp-content/uploads/2013/02/MOTDstat-0.0.3.tar.gz
tar xzf MOTDstat-0.0.3.tar.gz

Puis comme précisé dans le fichier INSTALL, nous exécutons la commande

cd MOTDstat-0.0.3
make install

Puis il nous faut ( toujours en root ) ajouter la ligne à notre crontab

crontab -e

Et l'on ajoute

*/5 * * * *   /usr/bin/motdstat --generate

Toutes les 5 minutes, le fichier /etc/motd ( pour info, motd = message of the day ), sera mis à jour avec les derniéres contantes relevées du système.

Et voilà c'est tout ! Vous pouvez déjà tester ( enfin dans les 5 minutes ;) ), en vous dé-connectant - re-connectant en ssh pour voir apparaitre un petit rapport concernant votre système.

Pourquoi n'ai-je aucun service dans la colonne "service status" ? A oui .. la conf .. regardons ce point .

Configuration de Motdstat

Toute la configuration se passe au même endroit ( j'adore quand c'est simple est logique ), soit dans /etd/motdstat , ou vous pouvez lister les fichiers suivants :

  • fstab_limits
  • motdstat.conf
  • netservice
  • process

fstab_limits

Ce fichier permet de lister les différentes partitions du système, avec les niveaux d'alertes, par exemple:

# Mount point   usage limit Warn [%] Critical [%]
/                              80       90
/boot                          80       90
/home/webadmin/www/site-web   80       90

ici toutes les partitions sont soumises aux mêmes rélges ( par défaut ), à savoir 80% d'espace disque utilisé pour déclencher un warning, et 90% pour déclencher une alerte dite "critique".

motdstat.conf

C'est LE fichier de configuration de l'utilitaire, ou vous pouvez configurer le destinataire des alertes, les seuils par défaut des différentes alertes ( disque, swap, cpu ... ), mais aussi des commandes à exécuter en cas de dépassement de seuil . ( toujours pratique ).

Le fichier est ben documenté, vous n'aurez aucun mal à retrouver vos petits.

netservice

Et bien voilà, c'est dans ce fichier que vous devrez configurer les services à surveiller ( sur le bon fonctionnement ). Motdstat se base sur une simple regexp du résultat de la commande netstat pour dire si oui ou non le service est "up" ou "down", d'ou mon avertissement sur le fait que ce n'est pas le but premier de cet utilitaire !

voilà un exemple pour surveiller le service ssh :

#
# List of local network services
#
# PROTOCOL	IP_ADDRESS:PORT		PROCESS NAME
#tcp     	127.0.0.1:80		httpd
tcp		0.0.0.0:22		sshd

il faut vraiment que je détail les colonnes ? ... non je ne pense pas :)

process

De la même manière que les services, certains process peuvent être surveillés ( affiché dans le resultat de ps -xa = On sinon Off et alerte ! ).
Par exemple pour surveiller le service httpd

#
# List of processes that MUST be running
#
#ntpd
httpd 
#snmpd


Voilà toujours aussi simple. :) ( comme j'aime )

Conclusion

Encore un petit utilitaire qui vous affiche ( sans aucune config ) l'état de votre serveur, à la connexion ssh, et qui en prime peut vous avertir en cas de problème. ( la détection est rudimentaire mais toujours mieux que rien :) )

Vous avez aimé cet article ? faites le savoir en répondant au sondage en haut à droite de cette page :)

A bientôt,

Ch.

14 sept. 2010

Git pour une petite équipe

header.gif Un billet sans prétention , qui explique comment mettre en place GIT sur un serveur pour partager les sources entres développeurs afin de permettre le travail en équipe sans risquer de se marcher dessus .

Installation

Cette étape est la même sur les postes clients et sur le serveur .

L'installation est très simple , dans un premier temps vérifier que les paquets suivants sont bien installé :

apt-get install curl-devel expat-devel gettext-devel openssl-devel zlib-devel

Une fois fait ,

apt-get install git-core

Votre identité

Il vous faut ( sur chaque poste client ) définir au moins deux paramètres qui permettrons de vous identifier à chaque commit , il est donc important de les initialiser .

cd ~
git config --global user.name "Mon nom"
git config --global user.email monemail@mondomaine.fr

Nous voilà maintenant prêt à utiliser git .

Créer l'utilisateur git

Pour simplifier les étapes suivantes ( connexion ssh ) nous allons créer tout de suite l'utilisateur **git**

sudo adduser git

Nous allons limiter les possibilités de ce nouvel utilisateur sur le serveur , pour celà , nous allons lui attribuer un autre interpréteur de commande .

sudo vim /etc/passwd

Remplacer /bin/bash à la ligne ( selon l'interpréteur par défaut )

git:x:1002:1003:,,,:/home/git:/bin/bash

par

git:x:1002:1003:,,,:/home/git:/usr/bin/git-shell

Créer un Dépôt vierge sur le serveur

Voilà une étape importante et indispensable pour ce que nous souhaitons faire .
Rendez-vous sur votre serveur de développement , dans le répertoire qui contiendra les dépôts .

su git
cd /var/www/depotsGit
mkdir monProjet.git
git --bare init 

Et voilà votre dépôt est bien créé.

Accès ssh

Afin de na pas avoir à rentrer le mot de passe de git à chaque "push" nous allons mettre en place l'authentification ssh par certificats .
Suivez les étapes suivantes :

Sur votre poste utilisateur

Génération des clef

N'entrer ni passphrase ni mot de passe , passer les étapes en tapant "enter" ...

cd ~
ssh-keygen -t rsa 

Copie de la clef public

Copier le contenu de se fichier

vim ~/.ssh/id_rsa.pub

Sur le serveur

Nous allons ajouter la clef public au compte git .

su git
cd ~
mkdir .ssh
vim authorized_keys

Copier la clef public dans de fichier , enregistrez et quittez .

Répéter cette étape ( copier-coller de clef publique ) pour chaque poste qui doit avoir un accès aux dépôt GIT .

Premier git push

Retournez sur votre machine ( poste utilisateur ) , vérifiez tout de même que vous avez un accès ssh sans mot de passe

ssh git@ipduserveur

Vous devriez avoir un message de ce type :

fatal: What do you think I am? A shell?
Connection to golum closed.

Si c'est la cas bravo tout va bien , sinon, revoyez le passage clef ssh/public.

Nous allons maintenant nous occuper de nos fichiers sources , rendez-vous dans le répertoire qui va contenir vous sources .

mkdir /var/www/monSite
cd /var/www/monSite

Le répertoire est pour le moment vide , nous allons donc créer un premier fichier , **.giignore** qui vous servira peut être plus tard ( vous pouvez créer ce que vous voulez comme fichier , j'utilise .gitignore car quite à faire un test , autant faire quelque chose qui me servira :) )

Initialisation du dépôt local

Il nous faut initialiser notre dépôt local , afin que **git** gère les fichiers de ce répertoire .

touch .gitignore
git init
git add .
git commit -a -m "Initialisation Dépôt local"

Et voilà , vous avez désormais un dépôt local sur lequel vous pouvez gérer vos versions , vos branches ect .. bref utiliser toute la puissance de GIT.

Synchronisation avec le serveur de dépôts

Étape importante maintenant puisque nous souhaitons rendre nos sources public ( enfin public pour les postes qui auront copié leur clef public sur le serveur )

cd /var/www/monSite
git remote add origin git@ipduserveur:/var/www/depotsGit/monProjet.git
git push origin master

Cette dernière ligne aura pour effet d'envoyer les modifications dans le dépôt sur le serveur sur a branche "master".

Chaque développeur déclaré dans authorized_keys peut maintenant cloner le dépôt à partir du serveur , mais aussi envoyer leurs modifications .
Par exemple , si je veux cloner le dépôt actuel et donc récupérer le fichier **.gitignore** que vous avez posté .

cd /var/www/
git clone git@ipduserveur:/var/www/depotsGit/monProjet.git

Fin

Je vous laisse lire les nombreux tutoriaus concernant les commandes de bases de GIT , pour ajouter supprimer renommer les fichiers branches ect ...

www.deimos.fr
www.alexgirard.com
www.siteduzero.com
www.unixgarden.com

20 janv. 2009

Exemple d'utilisation du module SSH

sshphp.jpeg

Exemple d'utilisation du module ssh2 via php

N'ayant jamais moi même utilisé ssh via php , je me suis permis de creer un petit bout de code pour compléter l'article précédent ...

Nous allons donc utiliser quelques fonctions Sell2 dont la liste se trouve ici

Note : le code ci-dessous n'est qu'un exemple , loin d'être complet , mais il peut permettre de servir pour la compréhension des bases d'utilisation des fonctions ssh2

Dans un premier temps , la connexion :

Elle se fait via la finction ssh2_connect . Simple à comprendre , elle doit avoir deux paramétres obligatoires , à savoir : Host: qui correspond à l'hôte auquel nous souhaitons nous connecter port: Bien évidemment le numéro du port à utiliser

Ensuite , vient des paramètres facultatifs , méthods qui est un tableau dans lequel , nous allons pouvoir spécifier des méthodes de connexions , ici , nous n'allons pas entrer dans ces détails , les valeurs par défaut fonctionnent trés bien pour ce que nous souhaitons faire .

Un autre paramètre intéressant , ( le dernier ) est callbacks qui comme methods est un tableau associatif , qui permet d'appeler votre propre méthode pour un type de paquet SSH reçu . Encore une fois , nous n'allons pas l'utiliser ici , mais il est important de savoir que cela existe .

L'identification :

Une fois connecté , il faut s'identifier , pour celà , il existe plusieurs méthodes , à savoir :

ssh2_auth_password pour l'identification pas mot de passe ( ce que nous allons utiliser ici )

ssh2_auth_pubkey_file identification par clef publique

ssh2_auth_none identification en tant que "none"

ssh2_auth_hostbased_file identification par clef d'hôte publique

NOTE: Pour des raisons de sécurité , il peut être intéressant d'utiliser une identification par clef d'hôte publique

La fonction ssh2_auth_password est simple , elle demande trois paramétres , la ressource qu'a retourné la fonction précédente ssh2_connect , suivi , de l'utilisateur , et du mot de passe ...

A savoir , le tout est en clair !!

Ouverture d'un terminal

Une fois connecté et identifié , nous allons ouvrir un terminale pour y entrer des commandes à exécuter sur le serveur distant . Il existe encore une fois plusieurs façons de le faire , par la méthode ssh2_exec et ssh2_shell

La différence , est mince , via ssh2_exec , un terminal est ouvert , la commande passé en paramètre est exécuté , et un flux est retourné en cas de succès , alors qu'avec ssh2_shell , on ne fait qu'ouvrir un terminale , sans lui passer de commande , celui-ci renvoie un flux dans lequel nous allons écrire et lire dans un second temps .

Pour utiliser ssh2_shell , seuls deux paramètres sont encore nécessaires , à savoir , la ressource de connection , suivie du type de terminal à utiliser .. ici xterm

Écriture et lecture commandes

Voici venu le temps d'envoyer une commande à notre hôte ... Pour ce faire , il suffit d'utiliser la fonction fwrite() pour écrire dans un flux , nous allons l'utiliser comme ceci :

fwrite(ressource,commande);

Et pour récupérer ce qui s'affiche sur la sortie standard , nous allons utiliser fgets() comme ceci :

while($line = fgets(ressource)) { echo nl2br($line);}

Et voilà pour les explications de bases sur une utilisation simplifié du protocole ssh via php ... Et pour finir , je vais donc vous donner une classe exemple , qui vous permettra de tester tout ça .. ( classe qui peut être complété sans problème )

Code source

class ssh2{
	
	private $handle;
	private $std_out;
	
	public $host;
	public $port;
	public $term;
	public $user;
	public $pass;
	public $cmd_line; 
	
	
	public function __construct($user='', $pass='', $host='127.0.0.1', $port=22){
		
		
		if(!empty($user) && !empty($pass)){
			$this->user	=	$user;
			$this->pass	=	$pass;
			$this->host	=	$host;
			$this->port	=	$port;
				
		
			try {
				
				$this->handle	=	ssh2_connect($this->host, $this->port);
				
				if(!$this->handle){
					throw new Exception('Exception n°1: erreur à la connection ssh !', 1);
				}
				
				if(!ssh2_auth_password( $this->handle, $this->user, $this->pass )){
							throw new Exception('Exception n°2: erreur à l\'identification ssh !', 2);
				}
				
			}catch (Exception $e){
				echo $e->getCode().PHP_EOL;
				echo $e->getMessage().PHP_EOL;
			}
			
		}//end if
	}
	
	/*
	 * Fermeture de la ressource si elle est encoe active
	 */
	public function __destruct(){
	
		if(is_resource($this->std_out))
		{
			fclose($this->std_out);
		}
		
	}
	
	
	public function __get(string $name){
		
		return $this->$name;
	}
	public function __set(string $name, $value){
		
		$this->$name	=	$value;
	}
	
	public function __call(string $name,array $args){
		
		if(function_exists($name)){
			return $this->$name(implode(',',$args));
		}
	}
	
	
	
	
	/*
	 * Ouvre un terminal Par defaut et retourne le flux
	 */
	public function terminal(){
		
		//ouverture d'un terminal
		$this->std_out	=	ssh2_shell($this->handle,$this->term);
		//retourne la sortie 
		while($line = fgets($this->std_out)) { flush(); echo nl2br($line);}
	}

	
	/*
	 * Execute une commande , en supprimant le flux 
	 * Cette commande s'effectue donc de façon invisible
	 */	
	public function exec_secret_cmd($cmd=''){
		
		if(!empty($cmd)){
			$this->cmd_line	=	$cmd;
		}
		
		//Si la ressource n'hexiste pas encore
		if(!is_resource($this->std_out)){
			$this->terminal();
		}
		
		ob_start();
	
		fwrite($this->std_out,$this->cmd_line.PHP_EOL);
		sleep(1);
		
		while($line = fgets($this->std_out)) { echo nl2br($line);}
		
		ob_end_clean();
		
		//efface les traces
		$this->cmd_line	=	'';
	
	}
	
	
	/*
	 * Execute une commande et retourne le flux
	 */
	public function exec_cmd($cmd=''){
		
		if(!empty($cmd)){
			$this->cmd_line	=	$cmd;
		}
		
		//Si la ressource n'hexiste pas encore
		if(!is_resource($this->std_out)){
			$this->terminal();
		}
		
		fwrite($this->std_out,$this->cmd_line.PHP_EOL);
		sleep(1);
		
		while($line = fgets($this->std_out)) { flush(); echo nl2br($line)."\n";}
		
	}
}


/*
*
*Exemple d'utilisation de la classe ssh2
*
* Ici la connexion se fait en local , l'interet est donc limité 
* Mais cela permet par exemple de lancer des scripts d'un autre 
* utilisateur que www-data , sans changer la configuration 
* du php.ini ou apache 
*/

$P	=	new ssh2("user", "password");

$P->term	=	"xtrem";

$P->terminal();

$P->exec_secret_cmd("sudo -s");
$P->exec_secret_cmd("password");

$P->exec_cmd("apt-get upgrade");