\documentclass[11pt, a4paper, oneside, openany, twocolumn]{article}


\usepackage[frenchb]{babel}
\usepackage[latin1]{inputenc}

\RequirePackage{calc}

\setlength{\textwidth}{17cm}
\setlength{\marginparwidth}{0cm}
\setlength{\oddsidemargin}{-1in+2cm}
\setlength{\evensidemargin}{-1in+2cm}
\setlength{\headheight}{0cm}
\setlength{\topmargin}{0cm}
\setlength{\headsep}{0cm}
\setlength{\footskip}{0cm}
\setlength{\textheight}{26.5cm}
\setlength{\voffset}{-1.5cm}
\pagestyle{empty}


\title{{\sf SSH} et {\sf CVS}}
\author{Thomas Petazzoni}
\date{Atelier du Club LinUT du 13 décembre 2001}

\begin{document}
\maketitle

\section{{\sf SSH}}

{\sf SSH} (\emph{Secure Shell Server}) permet plusieurs choses :
\begin{itemize}
\item de se connecter sur une machine distante pour y éxécuter des
commandes
\item de réaliser des connections X11
\item de forwarder des ports
\end{itemize}

Le principal avantage de {\sf ssh} est que ceci se fait de manière
{\bf sécurisée} (les données sont cryptées).

Pour se connecter sur une machine distante :

{\tt ssh login@nom\_d\_hote}


Deux moyens pour se connecter :
\begin{itemize}
\item directement avec le mot de passe
\item avec une pass-phrase
\end{itemize}

La connexion avec un mot de passe est simple, on tape la commande, on
donne le mot de passe et on est connecté.  La connexion via une
pass-phrase met en jeu une paire de clé (clé publique/clé privée)
générée par la commande {\tt ssh-keygen}. Ensuite si la clé publique
est dans {\tt .ssh/authorized\_keys}, alors vous pouvez vous connecter
à l'hôte avec la pass-phrase, et non avec le mot de passe. Si votre
clé n'est pas dans ce fichier alors il demandera le mot de passe. Pour
copier votre clé dans le {\tt .ssh/authorized\_keys}, il faut utiliser
la commande {\tt ssh-copy-id}.

L'utilisation de {\tt ssh-agent} (à lancer via {\tt eval `ssh-agent`})
puis de {\tt ssh-add} permet tout au long d'une session de se
dispenser de taper la pass-phrase.

D'autre part, {\sf ssh} maintient une liste des hôtes auxquels vous
vous connectez {\tt .ssh/known\_hosts}, avec une clé RSA. Si l'hôte
change, la clé RSA change et donc {\sf ssh} pourra le savoir.

{\sf ssh} permet aussi de rediriger de réaliser des connections X11
dans un tunnel {\sf SSH} (sécurisé) ou bien de sécuriser des connections
(Pop par exemple), en les faisant passer dans un tunnel {\sf SSH}.

Pour plus d'informations, consultez le {\tt man} sur {\tt ssh,
ssh-add, ssh-agent, ssh-keygen, ssh-copy-id}.

\section{{\sf CVS}}

\subsection{Qu'est-ce que {\sf CVS} ?}

{\sf CVS} \emph{(Concurrent Versions System)} est un outil de gestion de
versions. Il permet de tenir à jour l'historique de chacun des
fichiers source d'un projet. Grâce à ce mécanisme, il est possible de
récupérer n'importe quelle version d'un fichier source, de la
modifier, et de reporter ces modifications sur les versions
postérieures du projet. {\sf CVS} s'occupe alors de gérer les éventuels
conflits entre ces modifications et les évolutions qu'il aurait pu y
avoir entre temps. {\sf CVS} gère le développement simultané du même projet par
plusieurs utilisateurs éventuellement distants ({\sf CVS} s'articule alors
autour d'un serveur). Dans les cas extrêmes où les développements se
recoupent (travail sur le même fichier source par exemple), {\sf CVS} est
capable de gérer les conflits.

\subsection{Principes}

{\sf CVS} s'articule autour d'un dépôt unique centralisé (le \emph{repository})
des sources du projet. Ce dépôt renferme, pour chaque fichier source,
tout l'historique de l'évolution de ces sources. {\sf CVS} vous permet d'y accéder
à distance. Notons que ce \emph{repository} peut renfermer les sources de
plusieurs projets : chaque projet est un module, selon la terminologie
{\sf CVS}.

\subsection{Accéder à un {\em repository}}

Trois méthodes existent pour accéder à un {\em repository} :
\begin{itemize}
\item La méthode locale : {\em /var/cvs/repository}, par exemple
\item La méthode distante : {\em
:pserver:login@host:/var/cvs/repository}, par exemple
\item Une autre méthode distante : {\em :ext:login@host:/var/cvs/repository}, par exemple.
\end{itemize}

La méthode locale est extrêmement simple, il suffit d'avoir un accès
local sur la machine, et d'avoir les droits sur le \emph{repository}.

La première méthode distante permet d'accéder depuis le réseau à un
{\em repository}, mais les données circulent de manière non sécurisée. La
gestion des utilisateurs et des mots de passe se fait directement dans
le \emph{repository}.

La deuxième méthode distante permet d'accéder au \emph{repository} en
utilisant en shell externe, défini par la variable {\tt CVS\_RSH}. En
utilisant {\tt ssh}, ce système permet une utilisation sécurisée de
{\sf CVS}. Il faut alors avoir un compte sur la machine.

\subsection{Authentification}

Dans le premier et le troisième cas, il faut pour s'authentifier
disposer d'un compte Unix sur la machine ou se trouve le
\emph{repository} et que ce compte ai les droits suffisants sur ce
\emph{repository}.

Dans le second cas, il faut créer trois fichiers dans le
répertoire \emph{CVSROOT} du \emph{repository} :
\begin{itemize}
\item {\tt passwd} qui contient des lignes de la forme
user\_cvs:password:user\_unix. En effet, dans ce cas il existe des
utilisateurs propres à {\sf CVS}, mais il faut qu'ils soient ``mappés'' sur
un utilisateur Unix.
\item {\tt readers} donnant la liste des utilisateurs ayant le droit
de lecture.
\item {\tt writers} donnant la liste des utilisateurs ayant le droit
d'écriture.
\end{itemize}

\subsection{Créer un {\em repository}}

La création d'un {\em repository} n'intervient qu'à la création du serveur,
la toute première fois.

On utilise la commande

{\tt cvs -d chemin\_d\_acces init}

Où {\tt chemin\_d\_acces} spécifie l'emplacement du \emph{repository}
tel que nous l'avons vu précédemment.

\subsection{Créer un module}

On se place dans le répertoire des sources du module à importer, puis
on utilise la commande :

{\tt cvs -d chemin\_d\_acces import nom\_module branche release}

\subsection{Télécharger un module}

Télécharger un module n'a lieu qu'une seule fois, la toute première
fois que vous téléchargez ce module. Par la suite, seules des mises à
jour seront nécessaires.

{\tt cvs -d chemin\_d\_acces checkout nom\_module}

\subsection{Mettre à jour un module}

Placez-vous dans le répertoire du module et tapez :

{\tt cvs update -dP}

\subsection{Soumettre les changements au {\em repository}}

Il suffit de se placer dans le répertoire du module et de taper :

{\tt cvs commit}

\subsection{Ajouter ou supprimer un fichier}

Pour ajouter un fichier non présent lors de l'import du module au
\emph{repository}, il faut utiliser la commande

{\tt cvs add nom\_fichier}

De même pour supprimer un fichier, on utilisera la commande

{\tt cvs remove nom\_fichier}

\subsection{Variables d'environnements}

La variable d'environnement \emph{CVSROOT} désigne le
\emph{repository} à utiliser, ce qui évite de le donner à chaque fois.

La variable d'environnement \emph{CVS\_RSH} désigne le shell à
utiliser dans le cas de l'utilisation de la méthode \emph{ext}.

La variable d'environnement \emph{EDITOR} désigne l'éditeur à utiliser
pour rédiger les logs de commit.

Pour plus d'informations, vous pouvez consulter {\tt man cvs}.

\section{Liens}

\begin{itemize}
\item OpenSSH : http://www.openssh.org
\item {\sf CVS} : http://www.cvshome.org
\item Une doc simple, mais plus complète sur {\sf CVS} :
http://kos.enix.org/cvs.php\#doc
\end{itemize}

\end{document}
