Software Público Brasileiro

<?xml version='1.0' encoding="utf-8"?>
<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
   "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd"  [ ]>
<chapter id="security">

	<title>Segurança</title>
	
	<para>
		Neste capítulo será tratada uma questão de grande importância para a maioria das aplicações e motivo de infindáveis
		discussões nas equipes de desenvolvimento: controle de acesso. Assim como tudo relacionado ao framework, a
		implementação de segurança foi projetada de forma simples e flexível, independente de camada de apresentação ou
		tecnologia, te deixando livre para implementar sua própria solução ou utilizar as extensões existentes.
	</para>
	<para>
		Para utilizar o modelo de segurança proposto basta utilizar o Framework Demoiselle, pois no núcleo do framework estão as
		interfaces e anotações que definem o comportamento básico da implementação.
	</para>
	
	<section>
    	<title>Configurando</title>

    	<para>
    	Para um correto funcionamento do Demoiselle é necessário inserir os interceptadores de segurança no arquivo <filename>src/main/webapp/WEB-INF/beans.xml</filename>.
    	</para>

		<programlisting role="XML"><![CDATA[<beans xmlns="http://java.sun.com/xml/ns/javaee" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
			        http://java.sun.com/xml/ns/javaee/beans_1_0.xsd">
	<interceptors>
		<class>br.gov.frameworkdemoiselle.security.RequiredPermissionInterceptor</class>
		<class>br.gov.frameworkdemoiselle.security.RequiredRoleInterceptor</class>
	</interceptors>
</beans>]]></programlisting>

		<para>
			Opcionalmente é possível configurar o comportamento do módulo de segurança definindo propriedades no arquivo <emphasis>demoiselle.properties</emphasis>
			da sua aplicação.
		</para>
		
		<table>
			<title>Propriedades de segurança do Framework Demoiselle</title>
			<tgroup cols="3">
				<colspec align="left" colwidth="40*"/>
				<colspec align="left" colwidth="40*"/>
				<colspec align="right" colwidth="20*"/>
	
				<thead>
					<row valign="top">
						<entry><emphasis role="bold">Propriedade</emphasis></entry>
						<entry><emphasis role="bold">Descrição</emphasis></entry>
						<entry><emphasis role="bold">Valor padrão</emphasis></entry>
					</row>
				</thead>
				<tbody>
					<row valign="top">
						<entry>frameworkdemoiselle.&#8203;security.&#8203;enabled</entry>
						<entry>
							<para>
								Habilita ou desabilita o mecanismo de segurança
							</para>
						</entry>
						<entry>true</entry>
					</row>
					
					<row valign="top">
						<entry>frameworkdemoiselle.&#8203;security.&#8203;authenticator.&#8203;class</entry>
						<entry>
							<para>
								Define a classe que implementa o mecanismo de autenticação.
								(Detalhes na seção <link linkend="criando_implementacao_seguranca">Criando sua implementação</link>)
							</para>
						</entry>
						<entry>
							-
						</entry>
					</row>
					
					<row valign="top">
						<entry>frameworkdemoiselle.&#8203;security.&#8203;authorizer.&#8203;class</entry>
						<entry>
							<para>
								Define a classe que implementa o mecanismo de autorização.
								(Detalhes na seção <link linkend="criando_implementacao_seguranca">Criando sua implementação</link>)
							</para>
						</entry>
						<entry>
							-
						</entry>
					</row>
				</tbody>
			</tgroup>
		</table>

    </section> 
	
	<section>
		<title>Autenticação</title>
		<para>
			O mecanismo de autenticação busca verificar a identidade do usuário de um sistema. A forma mais conhecida - e comum - para
			executar essa verificação se dá por meio de um formulário de login, geralmente solicitando um nome de usuário e
			sua respectiva senha. No entanto, outras formas como reconhecimento biométrico e autenticação por token, para citar
			apenas duas, tem ganhado um grande número de adeptos.
		</para>
		<para>
			O Framework Demoiselle deixa o desenvolvedor livre para definir qual forma usar, de acordo com a sua conveniência e necessidade.
			A peça chave para tornar isso possível é o contexto de segurança, representado pela interface <code>SecurityContext</code>. Nessa
			estão definidos os métodos responsáveis por gerenciar os mecanismos de autenticação como, por exemplo, executar
			login/logout de usuários e verificar se os mesmos estão ou não autenticados.
		</para>
		<para>
			Para utilizar o <code>SecurityContext</code>, basta injetá-lo em seu código. O método <code>login</code> ativa o mecanismo de autenticação
			e o método <code>logout</code> remove as credenciais atualmente autenticadas do sistema. A classe <code>SecurityContext</code> possui
			outros métodos que permitem verificar se há um usuário autenticado e acessar o objeto <emphasis>gerente</emphasis> (representado pela
			classe <code>javax.security.Principal</code>), um objeto que contém dados adicionais sobre o usuário atualmente autenticado. Consulte
			a documentação da classe <code>SecurityContext</code> para consultar as funcionalidades que ela oferece.
		</para>
		<para>
			Um exemplo do uso do <code>SecurityContext</code> para autenticação segue abaixo:
		</para>
		<programlisting role="JAVA"><![CDATA[public class ExemploAutenticacao { 

	@Inject 
	private SecurityContext securityContext; 

	public void efetuarAutenticacao() { 
		/*
		Obtem as credenciais do usuario, pode ser um login e senha ou um certificado digital. O mais
		comum e exibir uma tela HTML contendo um formulario que solicita as informacoes.
		*/
		
		try{
			securityContext.login();
		
			//Executa codigo que requer autenticacao
		
			securityContext.logout();
		}
		catch(InvalidCredentialsException exception){
			//Trata credenciais invalidas
		}
		 
	} 
}]]></programlisting>
	</section>
	
	<section>
		<title>Autorização</title>
		<para>
			Em certos sistemas é necessário não apenas autenticar um usuário, mas também proteger funcionalidades individuais e separar
			usuários em grupos que possuem diferentes autorizações de acesso. O mecanismo de autorização é responsável por garantir que apenas
			usuários autorizados tenham o acesso concedido a determinados recursos de um sistema.
		</para>
			
		<para>
			No modelo de segurança do Framework Demoiselle, a autorização pode acontecer de duas
			formas:
			<itemizedlist>
				<listitem><para>Permissão por funcionalidade, através da anotação @RequiredPermission</para></listitem>
				<listitem><para>Permissão por papel, através da anotação @RequiredRole</para></listitem>
			</itemizedlist>
		</para>
		
		
		<section>
			<title>Protegendo o sistema com <emphasis>@RequiredPermission</emphasis></title>
		
			<para>
				A anotação <code>@RequiredPermission</code> permite marcar uma classe ou método e informar que acesso a esse recurso requer
				a permissão de executar uma <emphasis>operação</emphasis>. Operação nesse contexto é um nome definido pelo desenvolvedor
				que representa uma funcionalidade do sistema. Por exemplo, determinada classe pode ter métodos responsávels por criar, editar,
				listar e remover bookmarks, o desenvolvedor pode decidir agrupar esses métodos sobre a operação <emphasis>gerenciar bookmark</emphasis>.
			</para>
		
			<programlisting role="JAVA"><![CDATA[class GerenciadorBookmark { 

	@RequiredPermission(resource = "bookmark" , operation = "gerenciar") 
	public void incluirBookmark(Bookmark bookmark) {
		//Ccdigo do metodo 
	} 

	@RequiredPermission(resource = "bookmark", operation = "gerenciar") 
	public List<Bookmark> listarBookmarks() {
		//Codigo do metodo 
	}
   	
	@RequiredPermission
	public List<Bookmark> apagarBookmark(Long idBookmark) {
		public List<Bookmark> listarBookmarks() {
	}
}]]></programlisting>

			<tip>
				Perceba que a anotação <code>@RequiredPermission</code> sobre o método <code>apagarBookmark</code> não contém parâmetros. Quando não
				são passados parâmetros o valor padrão para o parâmetro <code>resource</code> é o nome da classe e o valor padrão para <code>operation</code>
				é o nome do método. 
			</tip>
			
			<tip>
				É possível anotar a classe inteira com <code>@RequiredPermission</code>, isso protegerá o acesso a todos os métodos dessa classe.
				
				<programlisting role="JAVA"><![CDATA[@RequiredPermission(resource="bookmark" , operation="gerenciar")
class GerenciadorBookmark { 

	public void incluirBookmark(Bookmark bookmark) {
		//Codigo do metodo 
	} 

	public List<Bookmark> listarBookmarks() {
		//Codigo do metodo 
	}
   	
	public List<Bookmark> apagarBookmark(Long idBookmark) {
		public List<Bookmark> listarBookmarks() {
	}
}]]></programlisting>
			</tip>
		</section>
		
		<section>
			<title>Protegendo o sistema com <emphasis>@RequiredRole</emphasis></title>
			
			<para>
				Diferente de <code>@RequiredPermission</code>, a anotação <code>@RequiredRole</code> utiliza o conceito
				de papéis - ou perfís - para proteger recursos. Uma classe ou método anotado com <code>@RequiredRole</code>
				exigirá que o usuário autenticado possua o papel indicado para acessar o recurso.
			</para>
			
			<para>
				Voltando ao exemplo de nosso aplicativo de bookmarks, vamos supor que a função de listar os bookmarks existentes
				pode ser acessada por qualquer usuário autenticado, mas apenas administradores podem criar um novo bookmark. A classe
				responsável por tais funcionalidades pode ser criada da seguinte forma: 
			</para>

			<programlisting role="JAVA"><![CDATA[class GerenciadorBookmark { 

	@RequiredRole("administrador") 
	public void inserirBookmark(Bookmark bookmark) { 
	}
	 
	@RequiredRole({"convidado" , "administrador"}) 
	public List<Bookmark> listarBookmarks() { 
	} 

}]]></programlisting>
			<tip>
				É possível informar mais de um papel para a anotação <code>@RequiredRole</code>, neste caso basta que o usuário
				autenticado possua um dos papéis listados para ter acesso ao recurso.
			</tip>
			
			<para>
				Da mesma forma que a anotação <code>@RequiredPermission</code>, a anotação <code>@RequiredRole</code> pode ser usada
				a nível de classe para proteger todos os métodos contidos nessa classe.
			</para>
		</section>
		
		<section>
			<title>Protegendo porções do código</title>
			
			<para>
				É possível proteger apenas parte de um código ao invés de todo o método ou toda a classe. Isso pode ser necessário em
				expressões condicionais, onde um trecho só deve ser executado caso o usuário possua a autorização necessária.
				Para isso voltamos a usar a interface <code>SecurityContext</code>, pois ela contém métodos que são funcionalmente equivalentes
				às anotações <code>@RequiredPermission</code> e <code>@RequiredRole</code>.
			</para>
			
			<para>
				Como um exemplo, vamos supor que ao remover um bookmark um email seja enviado ao administrador, mas se o próprio
				administrador executou a operação não é necessário enviar o email.
			</para>
			
			<programlisting role="JAVA"><![CDATA[class GerenciadorBookmark {
			
	@Inject
	private SecurityContext securityContext; 

	public void removerBookmark(Long idBookmark) {
	
		//Codigo que remove o bookmark
		
		if  ( ! securityContext.hasRole("administrador") ){
			//Envia um email ao administrador
		}
	 
	} 

}]]></programlisting>
			
		</section>
		
		<section>
			<title>Protegendo porções de páginas <code>Java Server Faces</code></title>

			<para>
				As restrições de segurança podem ser utilizadas ainda em páginas web, com o auxílio de Expression Language. A interface
				<code>SecurityContext</code> está automaticamente disponível para páginas <code>Java Server Faces</code> como um <emphasis>bean</emphasis>
				de nome <code>securityContext</code>, bastando então acessar seus métodos a partir deste bean.
			</para>
			
			<programlisting role="XHTML"><![CDATA[<p:commandButton value="#{messages['button.save']}" action="#{contactEditMB.insert}" 
				ajax="false" disabled="#{!securityContext.hasPermission('contact', 'insert')}" />]]></programlisting>
			
			<para>
				Nesse caso, a habilitação de um botão está condicionada à existência de permissão para o usuário autenticado no momento
				executar a operação “insert” no recurso “contact”.		
			</para>
		</section>
	</section>
	
	<section>
		<title>Redirecionando automaticamente para um formulário de acesso</title>
		
		<para>
			Se sua aplicação usa a extensão <emphasis>demoiselle-jsf</emphasis> ou se você utilizou o arquétipo <emphasis>demoiselle-jsf-jpa</emphasis>
			durante a criação de seu projeto, então você pode definir uma página de login e o Framework Demoiselle vai automaticamente lhe redirecionar
			para essa página caso haja a tentativa de acessar um recurso protejido e nenhum usuário esteja autenticado no sistema.
		</para>
		
		<tip>
			<para>Para acrescentar a extensão <emphasis>demoiselle-jsf</emphasis> em um projeto Maven, adicione a dependência abaixo
			no arquivo <emphasis>pom.xml</emphasis>.</para>
			
			<programlisting role="XML"><![CDATA[
<dependency>
  <groupId>br.gov.frameworkdemoiselle</groupId>
  <artifactId>demoiselle-jsf</artifactId>
  <scope>compile</scope>
</dependency>]]></programlisting>

			<para>
				O arquétipo <emphasis>demoiselle-jsf-jpa</emphasis> já contém essa extensão, se você criou seu projeto
				baseado nesse arquétipo nada precisa ser feito.
			</para>
		</tip>
		
		<para>
			Por padrão a página contendo o formulário de login deve se chamar <emphasis>login.jsp</emphasis> ou <emphasis>login.xhtml</emphasis>
			(a depender de como sua aplicação esteja configurada para mapear páginas JSF). Para mudar esse padrão, é possível
			editar o arquivo <emphasis>demoiselle.properties</emphasis> para configurar qual página deve ser utilizada.
		</para>
		
		<table>
			<title>Propriedades de segurança da extensão <emphasis>demoiselle-jsf</emphasis></title>
			<tgroup cols="3">
				<colspec align="left" colwidth="40*"/>
				<colspec align="left" colwidth="40*"/>
				<colspec align="right" colwidth="20*"/>
	
				<thead>
					<row valign="top">
						<entry><emphasis role="bold">Propriedade</emphasis></entry>
						<entry><emphasis role="bold">Descrição</emphasis></entry>
						<entry><emphasis role="bold">Valor padrão</emphasis></entry>
					</row>
				</thead>
				<tbody>
					<row valign="top">
						<entry>frameworkdemoiselle.&#8203;security.&#8203;login.&#8203;page</entry>
						<entry>
							<para>
								Define a página de login da aplicação.
							</para>
						</entry>
						<entry>"/login"</entry>
					</row>
					<row valign="top">
						<entry>frameworkdemoiselle.&#8203;security.&#8203;redirect.&#8203;after.&#8203;login</entry>
						<entry>
							<para>
								Define a tela para qual o usuário será redirecionado após o processo de <emphasis>login</emphasis> bem sucedido.
							</para>
						</entry>
						<entry>"/index"</entry>
					</row>
					<row valign="top">
						<entry>frameworkdemoiselle.&#8203;security.&#8203;redirect.&#8203;after.&#8203;logout</entry>
						<entry>
							<para>
								Define a tela para qual o usuário será redirecionado após o processo de <emphasis>logout</emphasis> bem sucedido.
							</para>
						</entry>
						<entry>"/login"</entry>
					</row>
					<row valign="top">
						<entry>frameworkdemoiselle.&#8203;security.&#8203;redirect.&#8203;enabled</entry>
						<entry>
							<para>
								Habilita ou desabilita o redirecionamento automático para a página de login após uma tentativa
								de acessar recurso protegido.
							</para>
						</entry>
						<entry>true</entry>
					</row>
				</tbody>
			</tgroup>
		</table>
		
	</section>
	
	<section>
		<title>Integrando o Framework Demoiselle com a especificação JAAS</title>
		
		<para>
			Até agora vimos como criar código protegido em uma aplicação Demoiselle, mas nada foi dito sobre a tecnologia que implementa essa
			proteção. A verdade é que o Framework Demoiselle dá ao desenvolvedor a liberdade de implementar a solução que mais se adequa ao sistema
			desenvolvido, mas o framework também conta com suporte nativo à especificação JAAS (<emphasis>Java Authentication and
			Authorization Service</emphasis>).
		</para>
		
		<para>
			O suporte a JAAS é fornecido para aplicações WEB e está implementado na extensão
			<emphasis>demoiselle-servlet</emphasis>, então é necessário declarar a dependência a essa extensão em sua aplicação.
		</para>
		
		<tip>
			<para>Para acrescentar a extensão <emphasis>demoiselle-servlet</emphasis> em um projeto Maven, adicione a dependência abaixo
			no arquivo <emphasis>pom.xml</emphasis>.</para>
			
			<programlisting role="XML"><![CDATA[
<dependency>
  <groupId>br.gov.frameworkdemoiselle</groupId>
  <artifactId>demoiselle-servlet</artifactId>
  <scope>compile</scope>
</dependency>]]></programlisting>
		</tip>
		
		<tip>
			<para>
				O arquétipo <emphasis>demoiselle-jsf-jpa</emphasis> já conta com a dependência à extensão <emphasis>demoiselle-jsf</emphasis>, que
			 	por sua vez depende da extensão <emphasis>demoiselle-servlet</emphasis>. Se sua aplicação é baseada no arquétipo
			 	<emphasis>demoiselle-jsf-jpa</emphasis> você já possui a extensão <emphasis>demoiselle-servlet</emphasis>.
			 </para>
		</tip>
		
		<para>
			Uma vez que sua aplicação contenha a extensão <emphasis>demoiselle-servlet</emphasis>, tudo que você precisa fazer é configurar
			o suporte a JAAS em seu servidor de aplicação e criar os usuários e papéis necessários. Esta configuração depende do servidor de
			aplicação utilizado e foge ao escopo deste documento.
		</para>
		
		<para>
			Para autenticar um usuário presente no servidor de aplicação através do JAAS, a extensão <emphasis>demoiselle-servlet</emphasis>
			oferece a classe <code>Credentials</code>, que deve ser injetada em seu código. O código abaixo mostra como realizar a autenticação a partir de um servlet. 
		</para>
		
		<programlisting role="JAVA"><![CDATA[class LoginServlet extends HttpServlet {
			
	@Inject
	private SecurityContext securityContext;
	
	@Inject
	private Credentials credentials; 

	public void doPost(HttpServletRequest req, HttpServletResponse resp) {
	
		credentials.setUsername( req.getParameter("username") );
		credentials.setPassword( req.getParameter("password") );
		
		securityContext.login();
	 
	} 

}]]></programlisting>

		<para>
			Uma vez autenticado o usuário, a anotação <code>@RequiredRole</code> passará a verificar se o usuário presente no JAAS possui o papel informado.  
		</para>
		
		<caution>
			<para>
				A especificação JAAS não prevê o uso de permissões para proteger recursos, apenas papéis de usuários. Por isso ao utilizar a segurança
				da especificação JAAS o uso da anotação <code>@RequiredPermission</code> fica vetado. Utilizar essa anotação em um sistema que utilize
				JAAS para autorização causará uma exceção quando o recurso for acessado.
			</para>
		</caution>
		
		<tip>
			<para>
				É possível utilizar o JAAS para autenticar e autorizar papéis de usuários mas criar sua própria implementação para
				implementar a autorização de permissões. Para isso crie uma classe que herde a classe
				<code>br.gov.frameworkdemoiselle.security.ServletAuthorizer</code> e sobrescreva o método <code>hasPermission(String resource, String operation)</code>
				para implementar seu próprio mecanismo. Feito isso, basta definir sua classe no arquivo <emphasis>demoiselle.properties</emphasis> usando
				a propriedade <code>frameworkdemoiselle.security.authorizer.class</code>.
			</para>
			
			<para>
				Mais detalhes sobre como criar sua própria implementação ou extender uma implementação existente podem
				ser vistos na seção <link linkend="criando_implementacao_seguranca">Criando sua implementação</link>.
			</para>
		</tip>
		
	</section>
	
	<section id="criando_implementacao_seguranca">
		<title>Criando sua implementação</title>
		
		<para>
			Para os mecanismos de autenticação não cobertos pelo Framework Demoiselle, é possível criar sua própria implementação e integra-la
			ao framework. Também é possível extender uma implementação existente e acrescentar funcionalidades inexistentes.
		</para>
		
		<para>
			O ponto de extensão para o módulo de segurança são as interfaces <code>Authenticator</code> e <code>Authorizer</code>. Para criar
			um novo mecanismo de autenticação e autorização, é necessário apenas implementar essas duas interfaces em sua aplicação. Segue
			abaixo um exemplo de implementação.
		</para>

		<programlisting role="JAVA"><![CDATA[public class MeuAuthenticator implements Authenticator { 

	@Override 
	public void authenticate() throws Exception { 
		// Execute o procedimento necessario para autenticar o usuario 
		// Apos isso, a chamada ao metodo getUser() deve returnar o usuario corrente autenticado,
		// e ira retornar nulo (null) se o processo de autenticacao falhar
	} 

	@Override 
	public User getUser(){ 
		// Retorna o usuario que esta autenticado, ou nulo (null) se nao houver usuario autenticado
	} 

	@Override 
	public void unauthenticate() throws Exception { 
		// Execute o procedimento necessario para desautenticar um usuario
		// Apos isso,  a chamada ao metodo getUser() deve returnar nulo (null)
	} 
}]]></programlisting>
		<programlisting role="JAVA"><![CDATA[public class MeuAuthorizer implements Authorizer { 

	@Override 
	public boolean hasRole(String role) throws Exception { 
		// Verifique se o usuario autenticado tem o papel informado, retorne true em caso positivo 
		return false; 
	} 

	@Override 
	public boolean hasPermission(String resource, String operation) throws Exception { 
		// Escreva aqui seu codigo de verificacao de permissao 
		return false; 
	} 
}]]></programlisting>
		<note>
			<para>
				Fique atento! Note que para garantir que o usuário não esteja logado, não basta lançar uma
				exceção (InvalidCredencialsException) no método authenticator.autenticate(), mas é preciso que o método
				authenticator.getUser() retorne null para que o método securityContext.isLoggedIn() retorne false.
			</para>
		</note>
		<para>
			Pronto! Sua aplicação já possui uma implementação de segurança definida.
		</para>
		
		<tip>
			<para>
				Você nunca deve chamar diretamente em sua aplicação as implementações das interfaces <code>Authenticator</code>
				e <code>Authorizer</code>, o Framework Demoiselle vai automaticamente chamar os métodos implementados
				quando for necessário.
			</para>
		</tip>

		<para>
			Em um sistema que use as anotações <code>@RequiredRole</code> ou <code>@RequiredPermission</code>, deve haver pelo menos uma implementação
			dessas duas interfaces. Ao processar essas anotações, o Framework Demoiselle vai buscar uma implementação para essas interfaces
			e disparar uma exceção caso não encontre uma implementação adequada.
		</para>

		<para>
			Se existe mais de uma implementação de <code>Authenticator</code> e/ou <code>Authorizer</code> (o que pode acontecer, por exemplo, quando
			seja necessário uma implementação na aplicação principal e outra para os testes), é possível definir no arquivo <filename>demoiselle.properties</filename>
			a classe que deve ser usada por padrão:
 		</para>
 		
 		<informaltable width="100%">
			<tgroup cols="3">
				<colspec align="left" colwidth="40%"/>
				<colspec align="left" colwidth="40%"/>
				<colspec align="right" colwidth="20%"/>
	
				<thead>
					<row valign="top">
						<entry><emphasis role="bold">Propriedade</emphasis></entry>
						<entry><emphasis role="bold">Descrição</emphasis></entry>
						<entry><emphasis role="bold">Valor padrão</emphasis></entry>
					</row>
				</thead>
				<tbody>
					<row valign="top">
						<entry>frameworkdemoiselle.&#8203;security.&#8203;authenticator.&#8203;class</entry>
						<entry>
							<para>
								Define a classe concreta utilizada como implementação da interface Authenticator
							</para>
						</entry>
						<entry>
							<emphasis>
								nenhum, se houver apenas uma implementação o framework a detectará
								automaticamente sem necessidade de definir essa propriedade
							</emphasis>
						</entry>
					</row>
					
					<row valign="top">
						<entry>frameworkdemoiselle.&#8203;security.&#8203;authorizer.&#8203;class</entry>
						<entry>
							<para>
								Define a classe concreta utilizada como implementação da interface Authorizer
							</para>
						</entry>
						<entry>
							<emphasis>
								nenhum, se houver apenas uma implementação o framework a detectará
								automaticamente sem necessidade de definir essa propriedade
							</emphasis>
						</entry>
					</row>
				</tbody>
			</tgroup>
		</informaltable>
	</section>
</chapter>