%--------------------------------------------------------------------
%%\chapter{Logging In And Out}
\chapter{Entrando e saindo do sistema}
\label{ch:logins}
%--------------------------------------------------------------------

        \begin{chapterquote}
		A mente é como um pára-quedas \\
		Ela funciona melhor quando aberta \\
        \end{chapterquote}

        \noindent
	Esta seção descreve o que acontece quando um usuário acessa ou sai de um
	sistema. As várias interações entre os processos executados em segundo
	plano, arquivos de log, arquivos de configuração, etc... são
	descritos em detalhes.

%%\section{Logins via terminals}
\section{Acesso via terminais}

	A figura~\ref{fig:terminal-logins} mostra como acontece o acesso via 
	terminal. Primeiro o \cmd{init} assegura-se de que há um programa 
	\cmd{getty} para aquele terminal ou console. O programa \cmd{getty} fica 
	aguardando que o usuário informe que ele está pronto para acessar o 
	sistema (normalmente através da digitação de qualquer coisa). Ao detectar 
	um usuário, \cmd{getty} apresenta uma mensagem de boas vindas (armazenada 
	em \fn{/etc/issue}) e solicita a identificação do usuário e finalmente 
	executa o programa \cmd{login}. Este recebe o nome do usuário como 
	parâmetro e solicita ao usuário a sua senha. Caso a senha esteja correta, 
	o \cmd{login} iniciará o interpretador de comandos (shell) que está 
	configurado 
	para o usuário. Caso a senha não confira ele simplesmente encerra o 
	processo (talvez após dar ao usuário outra chance de informar seus dados). 
	O processo init percebe que o processo foi concluído e inicia um novo 
	getty para o terminal.


\begin{figure}[htb]
\begin{center}
\includegraphics{logins/logins-via-terminals.ps}
\end{center}
\caption{Acessos via terminal: a interação do \cmd{init}, \cmd{getty},
	\cmd{login}, e shell.}
\label{fig:terminal-logins}
\end{figure}

	Note que o único processo novo é aquele criado pelo init (usando a chamada 
	ao sistema \cmd{fork}); o \cmd{getty} e o \cmd{login} somente substituem o
	programa que estava sendo executado pelo processo (através da chamada ao 
	sistema \cmd{exec}).    

	Um programa em separado, para detectar usuários é necessário para linhas
	seriais, desde que pode (e tradicionalmente é) mais complicado detectar
	quando um terminal se torna ativo. O \cmd{getty} adapta-se ainda a 
	velocidade e outros parâmetros de comunicação, os quais são importantes em 
	conexões discadas, onde esses parâmetros podem variar de conexão para 
	conexão. Existem algumas versões do \cmd{getty} próprias para linhas 
	discadas. O \cmd{mgetty} é uma delas.


	Há ainda diversas versões do \cmd{getty} e \cmd{init} em uso, todas com 
	pontos favoráveis e desfavoráveis. É aconselhável aprender sobre as versões 
	em uso no seu sistema, e também sobre outras versões (pode-se usar o
	``Linux Software Map'' para pesquisas). Caso não se tenha conexões discadas,
	não se preocupe com o \cmd{getty}, porém o \cmd{init} é ainda muito 
	importante.

%%\section{Logins via the network}
\section{Acessos via rede}

	Dois computadores na mesma rede estão normalmente conectados através de um
	único cabo físico. Quando eles comunicam-se através da rede, os programas
	em cada computador que interagem na comunicação estão interligados por uma
	\defin{conexão virtual}, algo como um cabo imaginário. Até onde os 
	programas e a
	conexão virtual interessam, eles tem o monopólio de seu próprio cabo. Uma
	vez que o cabo não é real, somente imaginário, o sistema operacional de
	cada computador pode ter diversas conexões virtuais compartilhando o mesmo
	cabo físico. Desta forma usando somente um único cabo, diversos programas
	podem comunicar-se sem ter que se preocupar com as outras conexões. É
	posssível ainda ter-se diversos computadores usando o mesmo cabo; as 
	conexões virtuais existem entre dois computadores, e os demais ignoram 
	aquelas conexões das quais eles não fazem parte.


	Esta é uma descrição resumida da realidade, porém deve ser boa o
	suficiente para o entendimento de porque o acesso via rede é bastante
	diferente de acessos normais. As conexões virtuais são estabelecidas
	quando há dois programas em diferentes computadores que desejam
	comunicar-se. Desde que, a princípio, qualquer computador pode
	comunicar-se com qualquer outro, há um grande número de potenciais
	comunicações virtuais. Devido a isso, não é muito prático iniciar um
	processo \cmd{getty} para cada acesso em potencial.


	Há somente um único processo denominado \cmd{inetd} (correspondente ao
	\cmd{getty}) que administra todos os acessos de rede. Quando é detectada 
	um pedido de acesso via rede (isto é, a detecção de uma requisição de 
	abertura de nova conexão virtual com algum outro computador), é iniciado 
	um novo processo que administra aquela conexão. O processo original é 
	mantida e continua atendendo a novos pedidos de acesso.


	Para tornar as coisas um pouco mais complexas, há diversos protocolos de
	acesso via rede. Os dois mais utilizados são telnet e rlogin. Em adição
	aos acessos há diversos outros tipos de conexões virtuais que podem ser
	realizadas (como FTP, Gopher, HTTP, e outros serviços de rede). É
	desnecessária a manutenção de processos separados para diferentes tipos de
	conexões. Então, ao invés disso, há somente um processo que pode reconhecer
	o tipo de conexão e iniciar o tipo correto de programa para atender o
	serviço solicitado. Este processo é o \cmd{inetd}. Para maiores informações 
	sobre o inetd consulte o ``Guia do Administrador de Redes''.
	%% Verificar nome do livro ???

%%\section{What \cmd{login} does}
\section{O que o \cmd{login} faz}


	O \cmd{login} preocupa-se com a autenticação do usuário
	(assegurando que o nome do usuário e a senha conferem), e por disponibilizar
	um ambiente inicial para o usuário através das configurações de permissões
	para a linha serial e início do shell.

	Parte da configuração inicial é a apresentação do conteúdo do arquivo
	\fn{/etc/motd} (mensagens do dia) e da checagem do correio eletrônico. Isso
	pode ser desabilitado através da criação de um arquivo chamado 
	\fn{.hushlogin} no diretório pessoal do usuário.

	Caso o arquivo \fn{/etc/nologin} exista, os acessos estarão desabilitados. 
	Este arquivo é criado tipicamente através do comando \cmd{shutdown} e 
	comandos relacionados. O \cmd{login} verifica a existência desse arquivos e 
	irá recusar qualquer acesso, caso ele exista. Neste caso, o  \cmd{login}
	apresentará o conteúdo deste arquivo no terminal antes de ser 
	finalizado.


	As falhas de logins são registradas em um arquivo
	de log do sistema\footnote{\fn{/var/log/messages} no Conectiva \linux}
	(via \cmd{syslog}). Ele ainda armazena todos os acessos realizados pelo
	\texttt{superusuário}. Ambos podem ser úteis na detecção de intrusos.


	Os usuário conectados no momento estão listados no arquivo
	/var/run/utmp. Este arquivo é válido somente até a próxima inicialização
	do sistema. Ele lista cada usuário e terminal (ou conexão de rede) que 
	esteja sendo utilizada, em conjunto com algumas outras informações 
	adicionais. Os comandos \cmd{who}, \cmd{w} e outros similares lêem o 
	conteúdo do \fn{utmp} a fim de verificar quem está conectado.


	Todos os acessos bem sucedidos são gravados em \fn{/var/log/wtmp}. 
	Este arquivo é incrementado sem limites, devendo ser limpo periodicamente, 
	por exemplo, através de uma tarefa semanal programada no \cmd{cron}.
	\footnote{Boas distribuições do \linux\ fazem isto automaticamente.}
	O comando last mostra o conteúdo do \fn{wtmp}.


	Tanto \fn{utmp} quanto \fn{wtmp} estão em formato binário (vide a página 
	de manual do \fn{utmp}); o que torna incoveniente o seu acesso sem o uso 
	de programas especiais.     

%%\section{X and xdm}
%%\section{X e xdm}
%%
%%	\meta X implements logins via xdm; also: xterm -ls

%%\section{Access control}
\section{Controle de acesso}

	A base de dados de usuários está tradicionalmente localizada no arquivo
	\fn{/etc/passwd}. Alguns sistemas utilizam o \defin{shadow}, o qual move as
	senhas para o arquivo \fn{/etc/shadow}. Redes que tenham muitos
	computadores que compartilhem contas de acesso podem usar NIS ou outros
	métodos de armazenamento da base de dados de usuários, podendo copiar
	automaticamente a base de dados de uma localização central para todos os
	computadores da rede.

	A base de dados de usuários não contém somente as senhas, mas 
	também informações adicionais sobre os usuários, como os seus nomes reais,
	diretórios pessoais e shells do sistema. Estas informações devem ser 
	públicas para que qualquer usuário possa lê-las, sendo que a
	senha dos usuários é armazenada encriptada. Isso produz o
	inconveniente de que qualquer usuário que tenha acesso ao sistema e algum
	conhecimento técnico, possa usar métodos criptográficos para descobrir as
	senhas dos demais, sem ao menos tentar acessar o sistema com outra conta. O
	shadow tenta evitar isso, movendo as senhas para outro arquivo, o
	qual somente pode ser acessado pelo superusuário (root), sendo que as
	senhas ainda permanecem cifradas. Cabe ressaltar que a instalação do shadow
	em sistemas que não tem suporte a esta funcionalidade pode ser um tanto 
	difícil.

	É importante assegurar-se e orientar os usuários para que todas as
	senhas existentes sejam complexas o suficiente para que não sejam facilmente
	quebradas. O programa \cmd{crack} pode ser usado para quebrar senhas;
	qualquer senha que ele conseguir quebrar, é por definição uma senha ruim.
	Apesar do \cmd{crack} poder ser executado por intrusos, o administrador
	deve executá-lo também para inibir senhas ruins. Boas senhas podem ainda ser
	``forçadas'' pelo programa \cmd{passwd}; estas senhas são teoricamente mais 
	difíceis de serem quebradas, pois exigem mais esforço computacional na 
	tentativa.

	A base da dados dos grupos é mantida no \fn{/etc/group}; para sistemas com 
	shadow, pode existir um arquivo \fn{/etc/shadow.group}.  

	O \texttt{superusuário} normalmente não pode conectar-se via rede ou em 
	determinados terminais, somente nos terminais listados no arquivo 
	\fn{/etc/securetty}. Isso obriga o acesso físico a um
	desses terminais. É possível ainda conectar-se via qualquer terminal como
	um outro usuário, e utilizar o comando \cmd{su} para tornar-se o 
	\texttt{superusuário}.   

%%\section{Shell startup}
\section{Inicialização da Shell}

	Quando um shell interativo é iniciado, automaticamente são executados um 
	ou mais arquivos pré-definidos. Diferentes shells podem executar 
	diferentes arquivos. Para maiores informações, deve ser examinada a 
	documentação de cada shell.

	Muitos shells executam inicialmente um arquivo global. O Bourne shell 
	(\cmd{/bin/sh}) e seus derivados executam o \fn{/etc/profile},
	e adicionalmente executam o arquivo \fn{.profile} no diretório pessoal do
	usuário. O arquivo \fn{/etc/profile} permite que o administrador do sistema
	possa definir algumas variáveis de ambiente comum a todos os usuários,
	especialmente o  PATH para inclusão de diretórios de programas e
	comandos em adição aos diretórios padrões. Por outro lado o arquivo
	\fn{.profile} permite que o usuário possa customizar o ambiente de acordo 
	com as suas próprias necessidades, e se necessário alterar as opções padrão 
	do ambiente.
