Você está na página 1de 72

UNIVERSIDADE TECNOLGICA FEDERAL DO PARAN DEPARTAMENTO ACADMICO DE INFORMTICA CURSO DE ESPECIALIZAO EM TECNOLOGIA JAVA

RICARDO VASSELAI PAULINO

API JAVA PARA A PERSISTNCIA E CRIPTOGRAFIA DE ARQUIVOS DE CONFIGURAO XML E PROPERTIES

MONOGRAFIA

CURITIBA 2009

RICARDO VASSELAI PAULINO

API JAVA PARA A PERSISTNCIA E CRIPTOGRAFIA DE ARQUIVOS DE CONFIGURAO XML E PROPERTIES

Monografia apresentada ao Programa de PsGraduao em Especializao em Tecnologia Java da Universidade Tecnolgica Federal do Paran, como requisito parcial para a obteno do ttulo de Especialista em Tecnologia Java
Orientador: Prof. Robson Ribeiro Linhares, Msc.

CURITIBA 2009

Dedico a todos os professores, colegas de trabalho e amigos que trabalham com Java. Dedico Tambm a todos familiares.

AGRADECIMENTOS

Agradeo a Deus, aos meus professores, familiares, colegas de trabalho e amigos.

RESUMO Esta monografia apresenta a API para persistncia de configurao de sistemas em arquivos, que opcionalmente podem ser gravados no formato Properties ou XML. Sero abordadas as tecnologias de cdigo aberto utilizadas, bem como o funcionamento de cada uma delas com respectivos exemplos, e mais frente, como a API as utiliza. Este documento aplica nfase na forma como a API implementa criptografia para resguardar os dados que sero gravados e sua importncia. Por fim, atravs de um manual, o documento explana como a API funciona e logo aps descreve os sistemas que atualmente j esto utilizando a API. Palavras-chave: Criptografia. API. Properties. XML.

ABSTRACT This monograph presents the API for persistence of system settings in files, that optionally can be recorded in the format Properties or XML. It will be approached the open source technologies used, as well as the operation of each one with the respective examples, and moreover, how the API utilizes them. This work highlights how the API implements cryptography to protect data that will be recorded and their significance. Finally, with a manual, the document explains how the API works and afterwards describes the systems that currently are using the API. Keywords: Cryptography. API. Properties. XML.

SUMRIO 1. INTRODUO ............................................................................................................. 9 1.1. Estudo de domnio do problema................................................................................ 9 1.2. Objetivo ................................................................................................................... 10 1.3. Justificativa .............................................................................................................. 10 1.4. Escopo .................................................................................................................... 12 1.5. Organizao dos captulos ...................................................................................... 13 2. ESTUDO DAS TECNOLOGIAS UTILIZADAS .......................................................... 14 2.1. Anotaes (Annotations) ......................................................................................... 14 2.1.1. Criando uma Annotation ....................................................................................... 14 2.1.2. Utilizando uma Annotation.................................................................................... 15 2.2. Reflexo (Reflection) ............................................................................................... 16 2.2.1. Classe Method ..................................................................................................... 17 2.2.2. Classe Constructor ............................................................................................... 18 2.2.3. Como Invocar Mtodos ........................................................................................ 19 2.3. Genricos (Generics) .............................................................................................. 20 2.3.1. Como funciona ..................................................................................................... 20 2.3.2. Wildcards com Generics....................................................................................... 21 2.4. Criptografia .............................................................................................................. 22 2.4.1. Chave ................................................................................................................... 23 2.4.1.1. Algoritmos de Chave Simtrica ......................................................................... 24 2.4.1.1.1. Algoritmo DES para chave Simtrica ............................................................. 24 2.4.1.1.2. Algoritmo RC2, RC4 e RC5 para chave Simtrica ......................................... 25 2.4.1.1.3. Algoritmo IDEA para chave Simtrica ............................................................ 25 2.4.1.2. Algoritmos de Chave Assimtrica ...................................................................... 25 2.4.1.3. O algoritmo PBEWithMD5AndDES ................................................................. 26 2.4.2. Java Cryptography Architecture (JCA) ................................................................. 26 2.4.2.1. Assinaturas Digitais ........................................................................................... 28 2.4.2.2. Message Digests ............................................................................................... 28 2.4.2.3. Java Cryptography Extension (JCE).................................................................. 29 2.4.2.4. Classes Java JCA e JCE e Suas Funcionalidades ........................................... 29 2.4.2.5. Implementaes de Criptografia Suportadas pelo Java .................................... 30 2.5. Arquivos de Propriedades ....................................................................................... 31 2.5.1. Formato de um Arquivo de Propriedades ............................................................. 31 2.5.2. A classe Properties .............................................................................................. 32 2.6. Arquivos XML .......................................................................................................... 33 2.6.1. Como Utilizar ........................................................................................................ 33 3. DESENVOLVIMENTO DO TRABALHO .................................................................... 36 3.1. Padro de Projeto Utilizado ..................................................................................... 36 3.2. Persistncia e Criptografia por Java Annotations .................................................... 36 3.2.1. Importncia de Criptografar Dados ...................................................................... 37 3.3. Mtodo para Informar o Tipo de Atributos Persistidos ............................................ 38 3.4. Gerenciamento de Persistncia dos Arquivos ......................................................... 39 3.4.1. ConfigLoader Identifica os Dados ........................................................................ 39 3.4.2. ConfigLoader Salva os Dados .............................................................................. 40

3.4.3. ConfigLoader Gerenciada Pela Classe ConfigManager ....................................... 40 3.5. Anlises do Sistema com UML................................................................................ 41 3.5.1. Casos de Uso ....................................................................................................... 42 3.5.1.1. Casos de Uso Resumidos ................................................................................. 42 3.5.1.2. Casos de Uso Detalhados ................................................................................. 43 3.5.1.3. Diagrama de Casos de Uso .............................................................................. 47 3.5.2. Diagrama de Classes ........................................................................................... 48 3.5.3. Diagramas de Seqncia ..................................................................................... 49 3.6. Telas do Sistema (Screenshots) ............................................................................. 53 3.7. Manual do Usurio .................................................................................................. 54 3.7.1. Adicionando a API um Projeto ........................................................................... 54 3.7.2. Criando Uma Entidade de Propriedades .............................................................. 55 3.7.3. Informando Tipo de Arquivo de Propriedades ...................................................... 57 3.7.4. Informando Atributos de Propriedades ................................................................. 58 3.7.5. Alterando Dados de uma Entidade de Propriedades ........................................... 59 4. ESTUDO DO CASO ................................................................................................... 62 4.1. Utilizao do ConfigAPI ........................................................................................... 62 5. CONCLUSO ............................................................................................................ 67 5.1. Sobre o Desenvolvimento da API............................................................................ 67 5.2. Dificuldades Encontradas ........................................................................................ 68 5.3. Trabalhos Futuros ................................................................................................... 68 6. REFERNCIAS BIBLIOGRFICAS .......................................................................... 70

LISTA DE FIGURAS Figura 1 Exemplo de Annotation ................................................................................. 14 Figura 2 Exemplo de Utilizao de Annotation ............................................................ 15 Figura 3 Exemplo para capturar uma Annotation ........................................................ 16 Figura 5 Exemplo para impresso de de dados de uma Annotation ........................... 16 Figura 6 Exemplo de reflexo para visualizar todos os mtodos de uma classe ........ 17 Figura 7 Exemplo para imprimir dados de um mtodo utilizando a classe Method ..... 18 Figura 8 Exemplo de utilizao da classe Constructor ................................................ 19 Figura 9 Exemplo de como invocar mtodos .............................................................. 20 Figura 10 Exemplo de Generics .................................................................................. 21 Figura 11 Exemplo de Generics com Parameter Type ................................................ 21 Figura 12 Exemplo de lao sem Widcards .................................................................. 22 Figura 13 Exemplo de lao com Wildcards ................................................................. 22 Figura 14 Exemplo de Cdigo Java Utilizando Algoritmo PBEWithMD5AndDES ..... 26 Figura 15 Exemplo de comentrio de arquivo Properties ............................................ 31 Figura 16 Exemplo de formato de propriedade de arquivo Properties ........................ 32 Figura 17 Exemplo de leitura de propriedade de arquivo Properties........................... 32 Figura 18 Exemplo para alterar ou criar uma propriedade de arquivo Properties ....... 33 Figura 19 Exemplo de utilizao de tag XML com atributo na tag............................... 34 Figura 20 Exemplo de utilizao de tag XML com atributo entre tags ......................... 34 Figura 21 Exemplo de utilizao de XML com tipos de atributos diversos .................. 34 Figura 22 Exemplo de utilizao de XML com tipos de atributos diversos .................. 35 Figura 23 Diagrama de Casos de Uso ........................................................................ 47 Figura 24 Diagrama de Classes .................................................................................. 49 Figura 25 Diagrama Carregar Entidade de Configurao de um Properties ............... 50 Figura 26 Diagrama Carregar Entidade de Configurao de um XML ........................ 51 Figura 27 Diagrama Persistir Entidade de Configurao em Properties ..................... 52 Figura 28 Diagrama Persistir Entidade de Configurao em XML .............................. 53 Figura 29 Tela CryptoConverter .................................................................................. 54 Figura 30 Tela Generate Keys .................................................................................... 54 Figura 31 Exemplo para criar uma entidade de propriedades ..................................... 56 Figura 32 Exemplo para informar atributos de uma entidade de propriedades ........... 57 Figura 33 Exemplo para informar tipo de arquivo de propriedades ............................. 58 Figura 34 Exemplo para informar atributos de propriedades....................................... 58 Figura 35 Exemplo para criptografar um atributo ........................................................ 59 Figura 36 Arquivo de configurao do OpenDoc......................................................... 65 Figura 37 Arquivo de configurao do OpenDoc......................................................... 66

1. INTRODUO

1.1. Estudo de domnio do problema

Muitos projetos de software Java utilizam arquivos de configurao para armazenar informaes que influenciam no comportamento do programa. Usualmente so utilizados para guardar informaes como IP para conexo com banco de dados, usurio de banco de dados, senha de banco de dados, parmetros de inicializao, pendncias de conectividades com servios e etc. Arquivos de configurao so geis, pois, no necessitam de compilao e sim apenas de sua leitura. Podem ser editados por usurios sem conhecimento de programao. Suas formas mais utilizadas so XML e Arquivos de Propriedades. Usualmente para cada projeto escrito toda rotina de leitura e persistncia dos arquivos de configurao e tambm sua criptografia quando necessrio, quando no, fica a cargo dos implementadores a funo de atualizar manualmente at mesmo os arquivos, tanto na sua criao, como nas alteraes. O ideal que esse processo seja automatizado e aprimorado. O que se pode perceber que arquivos de propriedades de aplicaes no so acessados de forma automatizada na maioria dos sistemas disponveis, nem ao menos gerados de forma programtica. Justamente pela facilidade de ficar separado dos arquivos fontes, no necessitando ser compilado at mesmo, o programador prefere alterar esse tipo de arquivo manualmente, quando necessrio, alm do que, prefervel evitar ter que automatizar todo o processo, at mesmo pra poupar tempo. Mas percebendo que arquivos de propriedades no so compilados, o mesmo pode ser ento compreendido pelo homem, no sendo possvel gravar dados secretos, por exemplo. Uma sada para isso seria gravar dados criptografados, mas isso s seria possvel atravs de um clculo, usando linguagem de programao, tambm seria necessrio recuperar estes dados, decifrando os mesmos, o mesmo por linguagem de programao. Outro grande problema seria tratar dados tipados. Arquivos de propriedades

10

no conseguem por si s tratar e separar dados por tipos. Tudo isso leva a crer que uma automao de dados persistidos em arquivos de propriedades se torna necessrio. Os arquivos de propriedades possuem vantagens que devem ser aproveitadas, mas que necessitam de automao para aumentar as possibilidades.

1.2. Objetivo

Atender a necessidade de automatizar o processo de gerar arquivos de propriedades, entre outras funcionalidades necessrias, desenvolvendo uma API que tenha como principal funo gerar arquivos no formato Properties e tambm no formato XML, deixando a escolha do formato pelo implementador, alm de poder tambm ler estes arquivos e suas propriedades. Estes arquivos tero atributos gerados baseandose em classes mapeadas por anotaes (Java Annotations), conforme desejado tambm pelo implementador. Estes atributos podero ou no ser criptografados, alm de atender suporte a tipos variados. A API dever possuir uma interface para possibilitar cifrar e decifrar atributos criptografados, que foram persistidos em arquivos de propriedades, tudo isso para visualizao e conferncia dos dados que forem cifrados.

1.3. Justificativa Atravs da utilizao de arquivos de configurao em diversos projetos, notouse que o cdigo para fazer a leitura e persistncia se repetia de forma semelhante entre eles. Outra caracterstica com maior nfase em Arquivos de Propriedade da presena de cdigos extensos de manuteno ruim e de baixo reaproveitamento para efetuar a leitura e persistncia de configuraes, isso tambm ocorre dependendo da implementao usada, para XML. Isso pode ser melhorado criando uma API especfica para esse fim, evitando reescrita de cdigo para ler Arquivos de Propriedades, podendo a implementao ser reutilizada.

11

Arquivos de Propriedades no incentivam de forma natural o uso de entidades (POJOS com os atributos correspondentes ao arquivo de propriedade) para armazenar as informaes. um arquivo contendo texto natural e legvel, no tendo uma estrutura como XML, por exemplo. possvel gravar dados em Arquivos de Propriedades e carregar em classes com os atributos gravados. Apesar da grande semelhana dos cdigos de diversos projetos, em sua forma comum no possvel reaproveitar o cdigo de um projeto para outro de forma satisfatria, uma alternativa reescrever o cdigo ou copiar trechos de cdigos e adapt-los. Desta forma o tempo gasto para criar e manter estes cdigos acaba sendo grande dependendo da quantidade de propriedades/atributos que se encontram dentro do arquivo. Outra caracterstica negativa que tanto Arquivo de Propriedades quanto XML em suas formas comuns no apresentam nenhum tipo de criptografia, podendo deixar dados sensveis a mostra, como por exemplo, o caso de usurios e senhas de bancos de dados. Dificilmente encontramos sistemas que no tenham necessidade de gravar dados de propriedades, tanto configurao, quanto propriedades de XML. Sistemas grandes e robustos precisam guardar dados que correspondem ao prprio sistema, e no as suas regras de negcio. Para as regras de negcio utilizamos um banco de dados especfico. Alguns sistemas precisam acessar outros servidores. Para isso precisam saber o endereo IP ou DNS do servidor que devero acessar, talvez a porta do mesmo. Algumas opes, como essa que foi citada como exemplo, no so aconselhveis deixar fixa no cdigo fonte da aplicao, justamente porque podem mudar num tempo no planejado. E no seria muito aconselhvel gerar e instalar um novo deploy do sistema, apenas para mudar uma propriedade. Nesses casos se tornam teis arquivos de propriedades para armazenar dados que no podem ou no devem estar em banco de dados ou em hardcode.

12

1.4. Escopo A API de arquivos de configurao utilizando anotaes deve possibilitar leitura e persistncia nos formatos Properties e XML, dando a possibilidade de criptografar atributos do tipo String. Ir contemplar os seguintes tipos de dados: Int; Integer; long; Long; float; Float; double; Double; char; Char; String; Date; int[]; Integer[]; long[]; Long[]; float[]; Float[]; double[]; Double[]; char[]; Character[]; String[];

13

Date[].

Possibilitar o uso de arquivos de configurao dentro e fora do empacotamento do projeto, alm de uma interface com usurio, para gerao de chaves aleatrias e para codificao e decodificao de atributos criptografados.

1.5. Organizao dos captulos O prximo captulo ser de detalhamento das tecnologias utilizadas pela API, explicando o funcionamento de cada uma delas, com exemplos diretos de utilizao geral. Uma explanao especfica e mais detalhada ser empregada na criptografia de dados, explicando as vrias formas de criptografia, a aplicabilidade de cada uma delas e como a API as utilizar. Outro destaque dado nos tipos de arquivo Properties e XML, sendo estes as duas formas de persistncia dos dados que a API utiliza. destacado logo aps todos os sistemas que atualmente j utilizam a API como forma de persistncia de parmetros de configuraes, sendo estes desenvolvidos pelo Instituto Curitiba de Informtica (ICI). A concluso descreve como foi o desenvolvimento da API utilizando as tecnologias de cdigo aberto, detalha as dificuldades encontradas e por fim, os trabalhos futuros propostos.

14

2. ESTUDO DAS TECNOLOGIAS UTILIZADAS 2.1. Anotaes (Annotations) Para entender Annotations necessrio entender o conceito de metadados. Metadados so informaes diversas inseridas em um cdigo, mas que podem ser manipuladas pela linguagem de programao. Essas informaes dizem respeito a uma parte especfica do cdigo, sendo ou uma classe, ou atributo, ou mtodo, entre outras opes. So exatamente anotaes sobre uma parte especfica de cdigo. Essas informaes podem conter atributos tipados at mesmo, podendo usar os tipos inteiro, texto, booleanos, dentre outros. No Java 1.4, o que era usado para fazer essas anotaes era o Xdoclet. J na verso 5, Java adquiriu uma API especfica pra isso, chamada de Annotations.

2.1.1. Criando uma Annotation Uma anotao pode ser criada da seguinte forma:

@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface MinhaAnnotation { int exemplo(); String exemploTeste() default teste; }
Figura 1 Exemplo de Annotation

Na criao ento de uma anotao utiliza-se @interface. justamente como se fosse criar uma interface do Java, s que adicionando arroba na frente da palavra interface. A anotao acima da declarao da interface @Retention utilizada para informar, atravs da classe RetentionPolicy, onde ser possvel executar essa anotao criada, que pode ser em tempo de execuo (constante RUNTIME), ou que so descartadas pelo compilador (constante SOURCE), ou que no seja em tempo de execuo (constante CLASS). Mais acima, atravs da anotao @Target,

15

especificado onde essa anotao ser usada, com vrias opes de uso, alguns deles so mtodo (METHOD), classes (TYPE), pacote (PACKAGE), entre outros. notvel no exemplo citado, a assinatura de dois mtodos, sendo que o primeiro retorna um tipo int. Isso significa que ao utilizar esta anotao, ser possvel informar uma propriedade como inteiro. Esta propriedade tem nome exemplo. O segundo mtodo retorna um tipo String, sendo que existe uma propriedade default. Com isso, caso no seja informado para essa anotao, na propriedade exemploTeste uma informao qualquer, a informao default ser teste.

2.1.2. Utilizando uma Annotation interessante poder restringir onde uma Annotation ser usada, atravs da @Target, com isso sabemos que ela ser usada somente onde queremos, caso um outro implementador for utilizar. Um exemplo de uso em um mtodo seria:

public class MinhaClasse { @MinhaAnnotation (exemplo=1, testeExemplo=outroTeste) public void fazAlgumaCoisa() { ... } }
Figura 2 Exemplo de Utilizao de Annotation

Dessa forma possvel verificar as anotaes possveis do mtodo fazAlgumaCoisa atravs de reflexo (Reflection), e a partir da verificar as encontradas uma por uma e suas propriedades. A classe Method possu um mtodo chamado getAnnotation, onde possvel recuperar todas para manipular conforme desejado. Exemplo:

Method[] methods = clazz.getDeclaredMethods(); for (Method method : methods) { if (method.isAnnotationPresent(MinhaAnnotation.class)) { Annotation annotation = method.getAnnotation(MinhaAnnotation.class); }

16

}
Figura 3 Exemplo para capturar uma Annotation

Com a Annotation em mos possvel recuperar seus dados, conforme a assinatura de seus mtodos declarados na interface:

MinhaAnnotation an = (MinhaAnnotation) method.getAnnotation(MinhaAnnotation.class); System.out.println(Metodo1: + an.exemplo()); System.out.println(Metodo2: + an.testeExemplo());


Figura 5 Exemplo para impresso de de dados de uma Annotation

Pode-se citar como exemplo de uso de anotaes o JPA, que a API de persistncia Java, totalmente baseada em anotaes justamente para possibilitar o mapeamento objeto relacional. Suas anotaes ligam classes a tabelas, atributos de classes a colunas de tabelas e tambm definem como ser o relacionamento entre tabelas dentro de uma classe Java. Um dos frameworks de persistncia que implementam JPA o Hibernate, citando em seu livro, chamado Java Persistence com Hibernate, a utilizao do padro, sendo at mesmo participante no desenvolvimento dessa implementao:
O Hibernate, portanto, como sendo uma soluo de persistncia de dados de sucesso, teve um papel importante na parte de persistncia desse novo padro.
1

Outros exemplos podem ser citados, como EJB3 e WebServices.

2.2. Reflexo (Reflection) Quando se faz necessrio conhecer ou manipular os atributos, mtodos, ter vrias informaes de uma classe, tudo isso em tempo de execuo, uma tima soluo o Java Reflection API. Ela est presente no Java desde a verso 1.1 e permite que um programa possa varrer uma classe, consultando suas propriedades, mtodos, at mesmo invocar mtodos de uma determinada classe, ou seja no

17

somente conhecer uma classe, mas poder manipular a mesma sem ao menos conhecer os mtodos previamente, tudo em tempo de execuo. Conforme diz o artigo tcnico da Sun Microsystems:
Reflection is a feature in the Java programming language. It allows an executing Java program to examine or "introspect" upon itself, and manipulate internal properties of the program. For example, it's possible for a Java class to obtain the names of all its members and display them.
2

Todas essas funcionalidades encontram-se na classe Class do Java. Para recuperar a lista dos mtodos de uma classe, podemos utilizar o mtodo getDeclaredMethods(). Para visualizar todos os mtodos de uma classe, um exemplo seria:

Class c = Class.forName("java.lang.String"); Method m[] = c.getDeclaredMethods(); for (int i = 0; i < m.length; i++) { System.out.println(m[i].toString()); }
Figura 6 Exemplo de reflexo para visualizar todos os mtodos de uma classe

Dessa forma o nome de todos os mtodos declarados da classe sero impressos na sada padro.

2.2.1. Classe Method A classe Method possui alguns mtodos teis como o getName(), que informa o nome do mtodo, alm de poder invocar o mesmo atravs do mtodo invoke(Object obj, Object[] args), podendo passar os parmetros do mtodo a invocar. Alm disso, com a classe Method possvel saber at mesmo quais tipos de excees o mtodo pode lanar, atravs do getExceptionTypes(), que retorna uma lista dessas classes excees. Outros mtodos interessantes so getReturnType(), que retorna o tipo de objeto que o mtodo pode retornar, getParameterTypes(), que retorna os tipos de parmetros que o mtodo pode receber, dentro outros mtodos.

18

Um exemplo de como conseguir vrios dados de um mtodo de uma classe, utilizando a classe Method:

Class cls = Class.forName("Classe1"); Method methlist[] = cls.getDeclaredMethods(); for (int i = 0; i < methlist.length; i++) { Method m = methlist[i]; System.out.println("nome = " + m.getName()); System.out.println("membro da classe = " + m.getDeclaringClass()); System.out.println("modificador = " + Modifier.toString( m.getModifiers() )); Class pvec[] = m.getParameterTypes(); for (int j = 0; j < pvec.length; j++) System.out.println("parmetro #" + j + " " + pvec[j]); Class evec[] = m.getExceptionTypes(); for (int j = 0; j < evec.length; j++) System.out.println("exceo #" + j + " " + evec[j]); System.out.println("tipo de retorno = " + m.getReturnType());

} }
Figura 7 Exemplo para imprimir dados de um mtodo utilizando a classe Method

2.2.2. Classe Constructor Com essa classe ainda podemos possuir informaes sobre os construtores de uma classe qualquer, incluindo os parmetros de cada construtor e suas excees. Um exemplo seria:

Class cls = Class.forName("constructor1"); Constructor ctorlist[] = cls.getDeclaredConstructors(); for (int i = 0; i < ctorlist.length; i++) { Constructor ct = ctorlist[i]; System.out.println("nome = " + ct.getName()); System.out.println("membro da classe = " + ct.getDeclaringClass()); Class pvec[] = ct.getParameterTypes(); for (int j = 0; j < pvec.length; j++) System.out.println("parmetro #" + j + " " + pvec[j]); Class evec[] = ct.getExceptionTypes();

19

for (int j = 0; j < evec.length; j++) System.out.println("exceo #" + j + " " + evec[j]); }
Figura 8 Exemplo de utilizao da classe Constructor

2.2.3. Como Invocar Mtodos possvel atravs da API de Reflexo do Java invocar mtodos em tempo de execuo. A classe Method fornece um mtodo que torna isso possvel. Basta apenas que o programador tenha conhecimento do nome do mtodo, mas se ainda no souber, possvel tambm encontrar o nome dos mtodos e invocar qual quiser. Por exemplo:

// Atribui-se dois objetos do tipo Integer no array partypes. // Esses objetos sero usados para declarar quais // sero os tipos de parmetros Class partypes[] = new Class[2]; partypes[0] = Integer.TYPE; partypes[1] = Integer.TYPE; // Instancia-se a classe, utilizando o mtodo forName Class cls = Class.forName("InvocaMetodo"); // A classe Method instanciada atravs do getMethod. // passando os tipos de parmetro do mtodo a ser invocado. // este exemplo til para mtodos sobrecarregados Method meth = cls.getMethod("umMetodo", partypes); // Declarando as Object arglist[] arglist[0] = new arglist[1] = new variveis que sero usadas como parmetros. = new Object[2]; Integer(37); Integer(47);

// A classe InvocaMetodo um exemplo de classe qualquer // com um mtodo chamado umMetodo InvocaMetodo methobj = new InvocaMetodo(); // Aps a classe ser instanciada o mtodo invoke invocado // passando os parmetros desejados. // Um tipo Object retornado. Este o retornado pelo mtodo // invocado. Object retobj = meth.invoke(methobj, arglist); // Feito cast e utilizado o retorno da forma que desejar. Integer retval = (Integer)retobj;

20

System.out.println(retval.intValue());
Figura 9 Exemplo de como invocar mtodos

2.3. Genricos (Generics) Uma das dificuldades que um programador Java encontrava na verso 4, era usar casting sempre que uma informao fosse retirada de uma lista de dados, por exemplo, e por algumas vezes a exceo ClassCastException era lanada. Quando um objeto derivado de List era instanciado, objetos de todos os tipos poderiam ser adicionados e um problema surgia, pois no era possvel restringir os tipos de objetos a inserir. Programadores da linguagem C++ j possuam uma funcionalidade que na verso 5 do Java entraria como nova: Generics. uma das caractersticas mais importantes da verso 5, uma soluo elegante ao casting de objetos. A funo necessria era exatamente restringir os tipos de dados em vrias partes do cdigo e restringir de formas diferentes, tanto em classes, interfaces e mtodos (JANDIL, 2007). Assim como se pode restringir o acesso a uma classe, atravs do controle de acesso, utilizando as palavras reservadas private, protected, um programador tambm poderia definir qual nico tipo de classes ou classes poderiam ser parmetro de um mtodo, por exemplo, ou qual tipo de classe faria parte de um objeto do tipo Collection.

2.3.1. Como funciona O caracter utilizado no cdigo para informar a utilizao de Generics so os smbolos menor < e maior >, sendo que em seu contedo est a informao de restrio e tipagem. Exemplos disso so:

21

public interface List<E> { void add(E x); Iterator<E> iterator(); }


Figura 10 Exemplo de Generics

Nesse exemplo acima, quando criado um objeto que implementa a interface List, deve-se informar um objeto (Parameter Type) para E, sendo que esse tipo de objeto poder ser utilizado em toda a classe. Com isso podemos saber em tempo de execuo com qual objeto estaremos trabalhando. No caso da interface List, ao utilizar o mtodo iterator(), ser retornado um tipo Iterator j parametrizado com o objeto informado na interface List. Isso restringe o tipo de dado utilizado na interface List e evita o uso de cast.

public void informarNovoAnimal(<T extends Animal> animal) { ... }


Figura 11 Exemplo de Generics com Parameter Type

Acima mostrado Generics sendo usado em um mtodo como exemplo. Dessa forma se tem a certeza que somente receberemos um objeto que herda de uma classe Animal. Isso torna o cdigo mais elegante, evitando erros de objetos diferentes do desejado no parmetro de mtodos.

2.3.2. Wildcards com Generics

Outra facilidade que surgiu no Java 5, atravs do Generics, o Wildcards. Os laos utilizados com freqncia, antes do Generics poderiam ser dessa forma:

void printCollection(Collection c) { Iterator i = c.iterator(); for (k = 0; k < c.size(); k++) { System.out.println(i.next()); }

22

}
Figura 12 Exemplo de lao sem Widcards

Os Wildcards vieram justamente para poupar quantidade de cdigo e facilitar a visualizao e entendimento. O lao anterior pode ser substitudo no Java 5 por:

void printCollection(Collection<Object> c) { for (Object e : c) { System.out.println(e); } }


Figura 13 Exemplo de lao com Wildcards

No cdigo acima se percebe que a parte for (k = 0; k < c.size(); k++) { foi substitudo por for (Object e : c) {. Isso pode ser aplicado em todos os tipos Collection do Java. muito simples: se uma classe Collection est restringida por um tipo qualquer, sabemos que um lao conter esse tipo. Com isso, a cada interao do lao um novo tipo restringido instanciado, no sendo necessrio casting a cada interao do lao.

2.4. Criptografia

Quando existe a necessidade de transportar dados que no devem ser compartilhados e so confidenciais, usamos a tcnica de Criptografia. Criptografia (Do Grego krypts, "escondido", e grphein, "escrita") consiste em transformar uma informao na sua forma natural em ilegvel. Com isso possvel passar toda a informao por qualquer mecanismo de transporte de dados, sem se preocupar com a descoberta de seu contedo por algum no autorizado. Existe a necessidade de criptografar dados quando estes devem ser visveis somente pessoas autorizadas, conforme diz Cludio em seu livro Introduo a Criptografia Computacional:

23

Mensagens e dados precisam ser protegidos de sorte que somente pessoas ou processos autorizados consigam utiliz-los; deve-se evitar alterao fraudulenta da informao. .
3

Baseado em uma chave, que pode ser uma seqncia de caracteres qualquer ou mais de uma seqncia, um texto pode ser transformado, atravs de um clculo, em outro texto totalmente diferente e ilegvel at mesmo. Somente quem possuir a chave e o algoritmo utilizado, pode retornar o contedo em seu formato original. Na tecnologia da informao essa tcnica necessria quando se tem a necessidade de armazenar dados confidenciais ou pessoais, como senhas de usurios por exemplo. Entende-se que o ato de cifrar passar um contedo legvel para ilegvel e decifrar o contrrio, transformar um contedo ilegvel em legvel. Existem ainda algoritmos que apenas servem para cifrar certo dado, no podendo mais voltar ao valor contedo original. Um exemplo disso o algoritmo MD5, amplamente utilizado no meio computacional. O MD5 utilizado para gerao de hash para conferir a integridade de arquivos transferidos. Por exemplo, se um banco de dados possu um item gravado cifrado pelo MD5, possvel validar se uma pessoa conhece seu contedo cifrando o dado informado pelo MD5. Se o contedo cifrado for o mesmo do gravado no banco, este verdadeiro. Mas pode ser possvel retornar um dado cifrado pelo MD5 usando dicionrios e fora bruta. Algoritmos de criptografia se tornaram mais robustos quando passaram a utilizar chaves para cifrar e decifrar seu contedo.

2.4.1. Chave

Uma chave define como um algoritmo de criptografia ir se comportar. O resultado de um algoritmo de criptografia dever ser diferente sempre que uma chave diferente da utilizada for usada para decifrar, justamente para dificultar uma possvel engenharia reversa de um algoritmo. Uma chave diferente da chave usada para cifrar um cdigo provavelmente emitir um outro contedo totalmente ilegvel, um problema srio acontece se a chave utilizada pra cifrar um contedo for perdida, pois fica praticamente impossvel retornar o dado cifrado sem a chave utilizada para cifrar.

24

A escolha da chave muito importante quando for utilizado no algoritmo para cifrar. Justamente para evitar que uma chave seja descoberta, preciso que ela mesma seja ilegvel, sendo at necessrio gerar com seqncia de caracteres aleatrios. Existe um RFC sobre a gerao de aleatoriedade (RFC 1750, Randomness Recommendations for Security [Recomendaes de Aleatoriedade para Segurana]).

2.4.1.1. Algoritmos de Chave Simtrica

um algoritmo que utiliza uma nica chave privada para cifrar e decifrar um contedo qualquer. Esse tipo de criptografia utilizado quando necessrio fazer transferncia de dados e esses dados somente devem ser cifrados e decifrados por quem possui a chave. Por exemplo, em uma troca de mensagens entre computadores, para que ambos os lados possam trocar mensagens, devero conhecer a chave para assim poder cifrar os dados, enviar e o outro lado poder decifrar os dados e vice-versa. Uma das dificuldades desse tipo de algoritmo que a chave precisa ser compartilhada entre ambos os lados, por isso recomenda-se a troca constante da chave, para que a mesma no seja descoberta por algum no desejado.

2.4.1.1.1. Algoritmo DES para chave Simtrica

O algoritmo DES um dos mais simples entre os existentes para esse tipo de chave. Esse algoritmo utiliza uma chave de 56 bits operando em blocos de 64 bits 4. A utilizao desse tipo de algoritmo torna-se muito criteriosa e deve ser usado de preferncia em sistemas que exigem proteo simples para seus dados. Para sistemas mais exigentes, que devem ter seus dados com proteo rigorosa, recomenda-se um algoritmo mais elaborado, devido ao fato de uma empresa chamada Electronic Frontier Foundation ter criado uma mquina de US$ 200.000 capaz de decifrar mensagens cifradas por meio deste processo.

25

2.4.1.1.2. Algoritmo RC2, RC4 e RC5 para chave Simtrica

pedidos da RSADSI (RSA Data Security Inc.), esses algoritmos de cifragem de dados foram desenvolvidos pelo americano Ronald Rivest. A grande vantagem desse tipo de algoritmo que o tamanho da quantidade de caracteres de uma chave pode ser variada, podendo ser de 1 a 1028 bits, tornando a possibilidade de chaves grande o suficiente para dificultar a interpretao dos dados. Alm dessa vantagem sobre o algoritmo DES, algoritmos RC so mais rpidos, sendo o RC2 duas vezes mais rpido e RC4 pode ser at dez vezes mais rpido. A vantagem do RC5 sobre os outros RC que o usurio pode definir o tamanho do bloco e o nmero de passos pelo algoritmo de encriptao.

2.4.1.1.3. Algoritmo IDEA para chave Simtrica

Este algoritmo de criptografia foi criado por James Massey e Xuejia Lai em 1991. um algoritmo muito parecido com o DES, sendo que a diferena o funcionamento mais rpido em microprocessadores especficos. tambm um algoritmo utilizado no famoso programa de criptogrfica de e-mails, chamado PGP.

2.4.1.2. Algoritmos de Chave Assimtrica

Consiste em trocar informaes contendo duas chaves, uma delas somente para cifrar e a outra para decifrar, sendo a chave para cifrar pblica e a de decifrar privada. Com isso possvel disponibilizar livremente a chave pblica, que somente tem a finalidade de cifrar os dados, sendo possvel transmitir a mensagem cifrada para qualquer pessoa, e somente quem possui a chave privada pode decifrar os dados. Assim possvel enviar dados cifrados, por onde foi espalhada a chave pblica, onde somente o destinatrio, que possui a chave privada, consegue decifrar. Dessa forma tambm quem recebeu consegue fazer autenticao da mesma, pois somente quem

26

possui a chave privada pode decifrar. Algoritmos que utilizam essa tcnica so ElGamal, DSS (Digital Signature Standard) e RSA.

2.4.1.3. O algoritmo PBEWithMD5AndDES

Esta forma de algoritmo uma espcie muito segura para criptografia de dados. No usa somente uma chave especfica para cifrar e decifrar os dados, mas trs formas, sendo estas: uma senha, um array de bytes conhecido como salt e uma compilao de mensagem MD5. Sendo assim, para que um dado criptografado seja descoberto, alm da senha, outros dados devem ser conhecidos. Na perspectiva do desenvolvedor, o livro Segurana de dados em Java declara:
Este algoritmo vincula a utilizao de uma senha, um array de bytes conhecido como salt e uma conta de iterao junto com uma compilao de mensagem MD5 para gerar uma chave secreta DES; esta chave ento usada para realizar a codificao e a decodificao DES.
5

Com isso possvel at mesmo compartilhar a senha verbalmente com que for utilizar o algoritmo, pois a iterao e o salt que tornaro a senha algo realmente seguro. Um exemplo prtico em Java de como o algoritmo PBEWithMD5AndDES utilizado pode ser descrito da seguinte forma:

String password = Teste de Senha; Byte[] salt = {(byte)0xc9, (byte)0x36, (byte) 0x78, (byte)0x99, (byte)0x52, (byte)0x3e, (byte)0xea, (byte) 0xf2); PBEParameterSpec paramSpec new PBEParameterSpec(salt, 20); PBEKeySpec keySpec = new PBEKeySpec(password); SecretKeyFactory kf = SecretKeyFactory.getInstance(PBEWithMD5AndDES); SecretKey key = kf.generateSecret(keySpec); Cipher c = Cipher.getInstance(PBEWithMD5AndDES); c.init(Ciper.ENCRYPT_MODE, key, paramSpec); Figura 14 Exemplo de Cdigo Java Utilizando Algoritmo PBEWithMD5AndDES

2.4.2. Java Cryptography Architecture (JCA)

27

Uma das vantagens de utilizar a linguagem de programao Java a sua infinidade de APIs desenvolvidas especialmente para fins especficos. Muito se v, navegando pela internet, vrios algoritmos de criptografia prontos, criados por programadores que adaptaram at mesmo de outras linguagens a forma de criar dados cifrados e de decifrar os mesmos. O problema a necessidade de grande conhecimento pra lidar com esses tipos de algoritmos, lidar com deslocamento de bytes, se preocupar com a segurana do algoritmo, fazendo com que seja de difcil descoberta, no deixando que dados sejam decifrados. Justamente para evitar toda preocupao de desenvolvimento dos algoritmos de criptografia e suas complexidades, a Sun Microsystems disponibilizou uma API que tem a implementao de vrios tipos de algoritmos de criptografia, desde os mais simples aos mais complexos. Essa API chama-se JCA. JCA (Java Cryptography Architecture) um framework do Java que oferece vrios servios de criptografia de dados. Uma grande vantagem que toda implementao, cdigo, todo algoritmo fica encapsulado, ou seja, tudo foi implementado e padronizado pelo Java, fica tudo a cargo da API JCA. Dessa forma, criptografar dados fica muito fcil e mais seguro do que se imagina, pois no vai ser preciso muita coisa alm de informar o dado a criptografar, o tipo de algoritmo desejado e uma chave, dessa forma o programador fica fora da implementao do algoritmo de criptografia. Sobre esse assunto, o mestre em cincias, Leandro Batista de Almeida destaca:
Independncia de implementao e de algoritmos so complementares, permitem aos usurios da API utilizarem conceitos de criptografia, como assinaturas digitais e digests de mensagens sem se preocupar com as implementaes ou algoritmos utilizados para implementar tais conceitos.
6

Mas o framework no impede que o programador melhore a implementao, novas melhorias e funcionalidades podem ser desenvolvidas e tudo ser usado em conjunto com a API, ou seja, a implementao pode ser tanto de alto, como de baixo nvel, tudo depende do que o programador preferir e exatamente isso o que diz a Sun em seu site de especificao e referncia: This API is designed to allow developers to incorporate both low-level and high-level security functionality into their programs..

28

Em

sua

primeira

verso,

introduzida

ao

Java

1.1,

JCA

foi

feito

especificadamente para assinaturas digitais e message digests, importante destacar o significado destes:

2.4.2.1. Assinaturas Digitais

Uma mensagem importante pode ser enviada a um destinatrio qualquer e esta at mesmo pode ser criptografada, evitando a descoberta por algum no autorizado. Mas como ter certeza que o destinatrio realmente aquele que esperamos? Como saber se a mensagem que se identifica enviada por certo destinatrio foi realmente enviada pelo mesmo? As assinaturas digitais foram criadas para garantir que um dado qualquer foi enviado pela pessoa que se identifica na mensagem. A idia a mesma da assinatura de cheques, por exemplo, um banco quando recebe um cheque, analisa a assinatura para assegurar-se de que realmente o mesmo foi assinado pelo dono da conta do banco que est descrita no cheque. Para o banco, de suma importncia esta conferncia, pois se um talo de cheques roubado, podese evitar utilizar o mesmo para retirar uma quantia da conta do dono do cheque. No caso das mensagens criptografadas, a assinatura serve para assegurar quem o autor real da mensagem enviada ao receptor.

2.4.2.2. Message Digests

Existem dados que so necessrios cifrar e no podem de forma alguma ser decifrveis. Para isso surgiu as mensagens digests, que justamente so algoritmos elaborados para cifrar dados sem permitir volta a partir do dado cifrado, ou seja, aps cifrado no tem como voltar ao seu estado decifrado. Essa tcnica muito utilizada para armazenar senhas, por exemplo. Quando uma senha cifrada gerada, a mesma pode ser gravada num banco e dados, sem problemas de ser decifrada, pois em teoria no existe mtodo de interpretao dos

29

dados. Para validar a senha, o usurio envia a senha, o sistema cifra o que foi enviado e confere com o que tem tambm cifrado em seu banco de dados. Se os dados cifrados forem idnticos, a senha do usurio vlida.

2.4.2.3. Java Cryptography Extension (JCE)

JCE uma extenso ao JCA, como o prprio nome sugere. Ou seja, alm da JCA, outras funcionalidades mais complexas podem ser encontradas atravs da JCE. Essa extenso oferece classes especficas, mais avanadas como gerao de chaves, conferncia de assinaturas digitais, dentre outras funcionalidades mais especficas.

2.4.2.4. Classes Java JCA e JCE e Suas Funcionalidades

Segue abaixo algumas das principais classes que fazem parte da API JCA e classes tambm do JCE: MessageDigest: Usada para calcular e gerar mensagens digests. Signature: Serve para gerar assinaturas, atravs de uma chave especfica

e esta deve ser privada, e a mesma assinatura pode ser conferida atravs de uma chave pblica. KeyParGeneration: Classe especfica para criar um par de chaves, sendo KeyFactory: Classe para criar chaves, dependendo do algoritmo que uma delas pblica e outra privada. especificado. CertificateFactory: Usada para criar certificados pblicos. KeyStore: Classe especfica para administrar e armazenar chaves. AlgorithmParameters: Usada para manipular e gerenciar parmetros de um

algoritmo de criptografia.

30

AlgorithmParameterGenerator: Usada para gerar e administrar uma quantia SecureRandom: Usada para criar um nmero randmico de nmeros. CertPathBuilder: Usada para gerar certificados. CertPathValidator: Usada para validar certificados. CertStore: Usada para remover certificados e CRLs de um repositrio.

de parmetros de um algorimo de criptografia.

2.4.2.5. Implementaes de Criptografia Suportadas pelo Java

A Sun disponibilizou atravs do Java, a implementao de alguns algoritmos de criptografia, sendo estes os mais comuns e conhecidos no meio computacional. Atravs da API da Sun de criptografia, essas implementaes ficam encapsuladas, tirando a necessidade do programador de implement-las. So elas: Uma implementao da Digital Signature Algorithm (DSA), descrito em Uma implementao da MD5 (RFC 1321) e SHA-1 (NIST FIPS 180-1) Uma implementao para gerar um par de chaves, sendo uma pblica e Implementao do gerador e gerenciador de parmetro de algoritmo DSA. Uma implementao do gerador de nmeros randmicos "SHA1PRNG", Certificados digitais e validadores para PKIX, definido na chave pblica de Implementaes para recuperar certificados e CRLs de colees e Uma fbrica de certificados X.509 e CRLs (Certificate Revocation Lists). Implentaes de chaves proprietrias nomeadas JKS. NIST FIPS 186. algoritmo de message digest. outra privada, utilizando o algoritmo DSA.

que segue as recomendaes IEE P1363 (Appendix G.7). internet X.509. diretrios LDAP, usando o esquema PKIX LDAP V2 (RFC 2587).

31

2.5. Arquivos de Propriedades

A principal vantagem dos arquivos de propriedades que, diferente dos arquivos Java (arquivos .java), no preciso compilar. possvel utilizar propriedades gerais de uma aplicao no cdigo fonte Java, mas no seria uma soluo elegante, muito menos prtica. A facilidade de ter arquivos de propriedades em uma aplicao se destaca quando gerado um deploy e o arquivo de propriedades fica separado do arquivo WAR. Com isso, podemos alterar, por exemplo, uma propriedade de configurao de banco, uma URL que com freqncia precisa ser alterada, entre outros dados. Um arquivo de propriedades tem justamente a finalidade de armazenar variveis que precisam ser alteradas com freqncia, sem a necessidade de reiniciar uma aplicao ou ter o trabalho de recompilar a mesma. No seria funcional ter que gerar um novo deploy pra apenas trocar o valor de uma ou algumas propriedades da aplicao.

2.5.1. Formato de um Arquivo de Propriedades

Um arquivo de propriedades tem basicamente o caractere # usado para comentrios. Para formar uma propriedade basta apenas informar um nome qualquer para o nome da propriedade e um valor para esta propriedade, sendo que o nome e o valor so separados pelo caractere =. Assim:

#Este um exemplo de comentrio em um arquivo de propriedade nomeDaPropriedade=Valor da Propriedade


Figura 15 Exemplo de comentrio de arquivo Properties

Lembrando que cada propriedade deve estar em uma linha, dessa forma:

#Este um exemplo de comentrio em um arquivo de propriedade nomeDaPropriedadeUm=Valor da Propriedade Um

32

nomeDaPropriedadeDois=Valor da Propriedade Dois


Figura 16 Exemplo de formato de propriedade de arquivo Properties

A nomenclatura para determinar um nome para um arquivo de propriedades determina que o formato deve ser <nome_do_arquivo>.properties.

2.5.2. A classe Properties

Java possui uma classe muito importante para poder ler tipos de propriedades. Recebendo uma chave, que seria o nome da propriedade, a classe pode retornar o valor desta chave, alm de persistir um novo valor preferido. Ou seja, dessa forma possvel atravs de cdigo Java manipular arquivos de propriedades, para uso direto em cdigo. Para carregar um arquivo de propriedades utilizando a classe Properties, devemos informar qual ser o tipo de entrada de propriedade, que dever ser uma classe que extenda de InputStream, que no caso da API ser a classe FileInputStream, pois manipulado um arquivo comum. Para ler ento, utilizamos o mtodo load da classe Properties, passando o FileInputStream como parmetro. Dessa forma podemos ler as propriedades:

Properties defaultProps = new Properties(); FileInputStream in = new FileInputStream("arquivo_teste.properties"); defaultProps.load(in); String um = defaultProps.getProperty("nomeDaPropriedadeUm"); String dois = defaultProps.getProperty("nomeDaPropriedadeDois"); in.close();
Figura 17 Exemplo de leitura de propriedade de arquivo Properties

bom lembrar que o mtodo getProperty sempre retorna uma String, fazendo necessrio convert-la pelo programador para se adaptar em algum tipo diferente, caso ache necessrio. Ainda possvel no somente ler as propriedades de um arquivo, mas tambm se pode gravar uma nova propriedade, alm de alterar o contedo de alguma j existente.

33

Dessa forma podemos alterar ou criar propriedades:

FileOutputStream out = new FileOutputStream("arquivo_teste.properties"); applicationProps.setProperty("nomeDaPropriedadeUm ", "alterado1"); applicationProps.setProperty("nomeDaPropriedadeDois ", "alterado2"); applicationProps.store(out, "---comentrio qualquer ---"); out.close(); Figura 18 Exemplo para alterar ou criar uma propriedade de arquivo Properties

2.6. Arquivos XML

Muitos sistemas precisam trocar informaes entre si e uma grande barreira pra que isso acontea a diferena entre linguagens de programao. Java no consegue entender a linguagem .Net, por exemplo, e essa dificuldade se reflete para vrias outras linguagens, a no ser que essa comunicao acontea por certos artifcios, utilizando mtodos e formas de acesso nativo outra linguagem. Java, por exemplo pode invocar C++ de forma nativa. O padro de arquivos XML (eXtensible Markup Language) foi criado pensando na soluo dessa dificuldade como principal atributo. O padro de arquivos XML muito utilizado por diversos meios eletrnicos, conforme diz Ray em seu livro Aprendendo XML: um veculo configurvel para qualquer tipo de informao e um padro aberto e em evoluo, abraado por todos, desde banqueiros at webmasters.8. Um arquivo contendo diversas tags encadeadas ou no entre si, que suportam atributos e valores diversos, sendo dessa forma legvel no s para linguagens de programao, mas tambm para humanos. Tudo separado em tags simples e com nomes da preferncia do implementador.

2.6.1. Como Utilizar

Existem formas diversas de se utilizar XML. Pode-se declarar somente a tag sem valor, contendo apenas atributos com valores dessa forma:

34

<exemplo atributo=valor1 /> <exemplo atributo=valor2 />


Figura 19 Exemplo de utilizao de tag XML com atributo na tag

Nesse exemplo a tag foi fechada logo no final da declarao. Pode-se tambm criar uma tag sem nenhum atributo, somente com nome e valor de tag:

<exemplo>valor</exemplo> <!-- ou --> <loja> <aparelho>Televiso</aparelho> <aparelho>DVD</aparelho> </loja>


Figura 20 Exemplo de utilizao de tag XML com atributo entre tags

O XML foi criado como recomendao pela W3C, justamente para padronizao dos dados, organizando os mesmos de forma hierrquica, atravs de tags sem limitao de forma em sua criao. Essas tags podem suportar ainda atributos diversos, com nome e valor, alm do valor da prpria tag. Um exemplo de tags com atributos seria:

<loja nome="Pinheiros"> <aparelho fabricante="Sansung" modelo="S100">Televiso</aparelho> <aparelho fabricante="Panasonic" modelo="VintageII">DVD</aparelho> </loja>


Figura 21 Exemplo de utilizao de XML com tipos de atributos diversos

A facilidade do XML que a representao dos dados pode ser variada, deixando a formatao da forma que preferir. Nem sempre um dado como atributo a forma mais apropriada, ou um dado como nome de tag fica representado de forma ideal. A refatorao do exemplo anterior pode ser feito da seguinte forma:

<loja> <nome>Pinheiros</nome> <produto>

35

<codigo>1</codigo> <nome>Televisor</nome> <marca>Sansung</marca> <modelo>S100</modelo> </produto> </loja>


Figura 22 Exemplo de utilizao de XML com tipos de atributos diversos

Para utilizar comentrios em XML, basta usar o smbolo <!-- para comeo de comentrio e --> para fim de comentrio. Arquivos XML suportam ainda validadores, que fazem a verificao da integridade do arquivo, chamados DTD (Document Type Definition). Estes validadores verificam a estrutura dos arquivos XML, analisando se tags especficas foram usadas e quais valores vlidos para atributos e valores de cada tag. Estes verificadores so inseridos geralmente no topo dos arquivos XML. Existem ferramentas, at mesmo gratuitas, que fazem a verificao de arquivos XML, seguindo DTD especfico.

36

3. DESENVOLVIMENTO DO TRABALHO

3.1. Padro de Projeto Utilizado

O framework desenvolvido utilizada o padro de projeto MVC (Modelo, Viso e Controlador), pela facilidade de reutilizao de cdigo e separao da camada de modelo e controlador, apesar de no possuir necessariamente uma camada de viso. Sobre a forma como o padro MVC trabalha, o livro Padres de Projeto (Solues Reutilizveis de Software Orientado a Objetos) destaca:
A abordagem MCV composta por trs tipos de Objetos. O Modelo o objeto de aplicao, a Viso a apresentao na tela e o Controlador a que define a maneira como a interface do usurio reage s entradas do mesmo.
8

Essa forma de padro de projeto separa os bens (Modelo) da camada de controle, destacados no sistema como sendo os objetos ConfigManager e ConfigLoader. Assim possvel fazer alteraes e melhoria no framework, sem alteraes em todas as classes, pois sendo o projeto dividido em camadas especficas, seus mtodos e funcionalidades ficam encapsulados, facilitando e agilizando a manuteno.

3.2. Persistncia e Criptografia por Java Annotations

Para que fosse possvel desenvolver esta funcionalidade, a utilizao da API Java Annotations foi muito importante, visto que a partir dela que parte a base de toda configurao para persistir, tanto o arquivo em formato Properties, quanto em XML.

37

Atravs de anotaes informado o nome do arquivo a ser persistido, propriedade a propriedade, se uma delas deve ser criptografada, entre outras opes. Dessa forma torna-se muito simples informar dados de um arquivo a ser criado, mas o mesmo tem que existir, mesmo que vazio, pois a API lana um erro quando no encontra o arquivo, todos esses so obtidos por anotaes pela aplicao e logo aps so persistidos. Atravs das anotaes pode-se informar at mesmo uma mscara para campos que so do tipo data. Quando se torna necessrio gravar um atributo de propriedade e este sigiloso, pode-se utilizar a opo de criptografar atravs do sistema. Basta apenas informar no atributo da classe escolhida para persistir, a anotao @Encrypted. Ao gravar esta propriedade, automaticamente a mesma ser persistida criptografada. O sistema utiliza o algoritmo de codinome PBEWithMD5AndDES para processar os dados informados e gravar o resultado de criptografia, sendo ainda possvel informar uma chave de preferncia do implementador. Basta apenas que esta chave seja informada na mesma anotao @Encrypted, utilizado o atributo cryptoKey, informando a chave aps o sinal de igualdade, ficando dessa forma, por exemplo: @Encrypted(cryptoKey="ricardo1"). Este dado, no momento de recuperar o arquivo de propriedade restaurado (descriptado), da mesma forma em que foi salvo, lembrando que para que isso acontea, caso uma chave especfica for utilizada, esta nunca deve ser alterada, com a penalidade dos dados recuperados se tornarem ilegveis, isso s deve ocorrer de forma planejada com auxilio da interface de criptografia. Um dado cifrado com uma chave especfica somente torna-se o mesmo recuperado (decifrado), quando a mesma chave utilizada. Uma chave geral ainda pode ser gerada e esta servir para todos os atributos de uma classe de propriedades, ou seja, esta chave serve para todos os atributos da classe e quando a mesma persistida, todos os atributos sero cifrados, utilizando a mesma chave. Para que isso acontea, basta apenas que a chave seja informada na anotao @XmlEntity ou na @PropertiesEntity, utilizando a propriedade cryptoKey. Um exemplo de utilizao seria: @XmlEntity(file="tipo.xml", cryptoKey="22").

3.2.1. Importncia de Criptografar Dados

38

Torna-se necessrio criptografar algum dado quando este no deve de maneira alguma ser descoberto por algum em especfico, ou quando somente a uma pessoa cabe saber a informao. Em alguns casos, at mesmo ao programador ou administrador do sistema fica indisponvel certo dado. de suma importncia um sistema ter a funcionalidade de criptografar dados especficos, justamente para no comprometer a segurana de usurios e do prprio sistema utilizado. At mesmo um banco de dados fortemente protegido contra invases no est imune e pelo menos existe uma chance, atravs da criptografia, de evitar o conhecimento de dados secretos, pois o mesmo ser gravado com forma ilegvel.

3.3. Mtodo para Informar o Tipo de Atributos Persistidos

Um atributo qualquer de uma classe a ser persistida como Arquivo de Propriedades pode ainda ser de um tipo definido. No somente possvel persistir dados do tipo String, que so do tipo texto e estes so mais utilizados nos Arquivos de Propriedades e XML. Vrios outros tipos de atributos podem ser persistidos, sabendo que os mesmos sero carregados da mesma forma e com mesmo tipo. Outra opo ainda poder persistir arrays de tipos variados de atributos. Dessa forma no necessrio fazer casting de dados que so recuperados, no existe essa preocupao, pois o sistema faz isso automaticamente. No caso dos Properties, um array de dados persistido separado por vrgulas, independente do tipo informado. Ao retornar estes dados entidade, os mesmos so inseridos no devido lugar. J para arquivos XML, a separao de cada ndice de um array de dados separado por tags, sendo que todas elas contm o mesmo nome. Dessa forma at mesmo algum que visualiza o arquivo diretamente capaz de informar quando um dado lido se trata de um array de dados ou de um dado simples. Alguns exemplos poderiam ser citados, quando se trata de um arquivo de propriedades com atributos tipados. Um atributo do tipo data (Date) til quando queremos informar a ltima alterao de um arquivo persistido, informar at mesmo a data e hora em que foi criado, quando um sistema qualquer entrou no ar para saber a

39

permanncia no ar e assim a sua instabilidade, entre outros exemplos, isso s com o tipo data. Informado um tipo, tambm possvel filtrar o que ser atribudo em certo atributo, no permitindo que seja inserido um tipo que no seja numrico, por exemplo, quando o mesmo exige um tipo numrico. Quando se filtra tipos de dados a gravar, erros so evitados, fazendo com que aumente a credibilidade do sistema.

3.4. Gerenciamento de Persistncia dos Arquivos

Atravs do processo de configurao, utilizando as anotaes em uma classe destinada para ser propriedade (classe de entidade estilo Pojo anotado do JPA), a classe ConfigLoader cuida de todo o processo de tratamento de dados, identificao de tipos de atributos, persistncia e recuperao dos dados. Aps criar uma classe que servir como base para um arquivo de propriedades, informar as anotaes necessrias para identificar atributos e criptografia, identificar tambm qual ser o tipo de propriedade, a classe ConfigLoader cuida de todo processamento necessrio para lidar com os dados.

3.4.1. ConfigLoader Identifica os Dados

Toda verificao dos dados que vo ser persistidos efetivada pela classe ConfigLoader. A primeira verificao qual o tipo de arquivo de propriedade a ser gravado. Isso feito, verificando se a classe de persistncia contm a Annotation @PropertiesEntity, o que identifica como destinado a ser um tipo de arquivo Properties, caso contrrio este ser um tipo de arquivo XML. Como o escopo dessa API destina-se apenas estes dois tipos de arquivos, somente a verificao ser feita para estes dois tipos. Aps isso, uma varredura feita por toda a classe destinada a ser persistida, procurando por atributos que sero uma propriedade. Nesta mesma varredura, outra verificao feita em cada atributo, se o mesmo contm a Annotation @Encrypted. Caso esta anotao seja encontrada, esta propriedade deve ser persistida cifrada,

40

usando uma chave padro, que na anotao @Encrypted 7-BDy%q6V8fbk9C2. Esta chave pode ser alterada, pois a anotao @Encrypted permite que seja informado manualmente uma chave de preferncia. Outra opo informar ou na anotao @XmlEntity ou na @PropertiesEntity, a propriedade cryptoKey uma chave de preferncia, sendo essa destinada todas os atributos que estiverem com a anotao @Encrypted.

3.4.2. ConfigLoader Salva os Dados

Aps identificar os dados extrados das anotaes na classe e atravs de reflexo, a classe ConfigLoader persiste estes dados em um arquivo de propriedades, que pode ser um Properties ou um XML, lembrando que cada tipo de arquivo possui suas particularidades para persistncia. Para que um arquivo Properties seja gravado necessrio utilizar a API Properties do Java, que contm mtodos especficos para informar cada propriedade. J para arquivos XML, uma outra tecnologia utilizada, a chamada JAXB (Java Architecture for XML Binding), que possui formas diferentes de persistir arquivos. Da mesma forma os atributos de uma classe, que ser persistida em arquivo XML, sero procurados e preparados, verificando se existe a necessidade de haver criptografia nos dados, e logo aps inseridos em um arquivo XML. Ou seja, a nica diferena o tipo de arquivo de propriedades e a forma como ser persistido. A parte de classes que sero persistidas fica transparente e independente da forma como sero persistidas as propriedades. As Annotations permitem escolher, mudando apenas uma palavra, qual ser o tipo de arquivo a ser persistido, seja Properties ou XML. O processo anterior a isso unificado, independente do tipo de arquivo de propriedades, ou seja, a classe a ser persistida muda apenas uma anotao para mudar o tipo de arquivo, tornando a codificao simples e rpida.

3.4.3. ConfigLoader Gerenciada Pela Classe ConfigManager

41

Existe uma camada intermediria classe ConfigLoader, que faz justamente o controle de transaes entre o cliente, ou seja, um programador que est utilizando a API, e a classe que faz a persistncia dos dados. Essa camada, implementada na classe ConfigManager, faz alguns tratamentos bsicos necessrios, antes dos dados serem persistidos ou carregados atravs da classe ConfigLoader. So tratamentos que verificam se o arquivo pode ser lido ou gravado, pois pode acontecer que uma pasta no tenha permisso de escrita, por exemplo, entre outras excees genricas, referente a erros de entrada e sada, que podem lanar a exceo IOException. A classe ConfigManager muito importante, pois tambm uma camada intermediria onde os dados so informados por Generics, ou seja, o tipo de arquivo que foi informado para carregar ser o mesmo tipo de classe retornado, evitando uso do cast. Alm disso, essa camada pode lanar outras excees especficas da classe ConfigLoader, dentre elas: ConfigEntityException, que uma exceo genrica da API; NotAnnotatedEntityException, nesse caso quando uma entidade foi para ser manipulada mas ela no possui a Annotation

informada

@PropertiesEntity ou a @XmlEntity; NotValidAnnotationException, para quando a anotao utilizada for invlida ou diferente das que a API utiliza; FileNotFoundException, que se auto explica. Existe ainda tipos diferentes de construtores para a classe ConfigManager. Basicamente, se pode instanciar esta classe informando o caminho de um arquivo em forma texto, ou uma classe do tipo File apontando para o arquivo desejado, ou at mesmo sem informar arquivo algum, iniciando o mesmo como nulo. Mtodos para ler ou gravar um arquivo de propriedades chamam-se respectivamente load, passando a classe que se deseja ler como parmetro e persist, passado tambm o objeto desejado como parmetro. Em ambos os casos o mesmo objeto devolvido.

3.5. Anlises do Sistema com UML

42

Nos prximos itens de sumrio, seguem os diagramas de UML (Unified Modeling Language). Todos estes diagramas so baseados no livro Utilizando UML e Padres, de Craig Larman9.

3.5.1. Casos de Uso

3.5.1.1. Casos de Uso Resumidos Criar Entidade Properties ou XML: O programador cria uma nova classe com o nome que desejar e logo aps informa se a entidade ser persistida no formato Properties ou em XML, utilizando a Annotation @PropertiesEntity ou @XmlEntity. Dever ser informado o nome do arquivo a ser gravado no atributo file da Annotation selecionada. Caso sinta necessidade de criptografar algum atributo da classe, insere a Annotation @Encrypted em algum atributo. Caso houver necessidade de selecionar uma chave de criptografia especfica que no seja a padro utilizada na Annotation, dever inserir valor para o atributo cryptoKey na Annotation @Encrypted do atributo que desejar. Caso o programador desejar inserir uma chave especifica para criptografia e que essa seja padro em toda a classe, dever inserir essa chave no atributo cryptoKey da Annotation @PropertiesEntity ou @XmlEntity. Persistir uma Entidade Properties ou XML: O programador, aps criar a entidade de propriedades dever instanciar uma nova classe do tipo ConfigManager, informando o caminho da pasta onde o arquivo dever ser gravado em seu construtor. Aps isso, o programador invoca o mtodo load da classe instanciada, passando a entidade como parmetro. A API devolve a instncia do arquivo passado no parmetro (VERIFICAR EXCEES). O programador informa os atributos da entidade. O programador invoca o mtodo persist da classe ConfigManager instanciada, passando a entidade com os atributos preenchidos no parmetro (VERIFICAR EXCEES). A API persiste a entidade. A API devolve a mesma entidade.

43

Carregar uma Entidade Properties ou XML: O programador dever instanciar uma nova classe do tipo ConfigManager, informando o caminho da pasta onde o arquivo dever ser gravado em seu construtor. O programador invoca o mtodo load da classe instanciada, passando como parmetro a classe que deseja carregar. A API carrega a classe conforme os dados do arquivo persistido anteriormente, decifra os dados criptografados e retorna a classe para o programador.

3.5.1.2. Casos de Uso Detalhados Nome: Criar Entidade Properties ou XML Escopo: ConfigAPI Nvel: Objetivo do Programador Ator Principal: Programador Interessados e Interesses: - Programador: Deseja criar uma entidade, preparando a mesma para ser persistida em formato de arquivo de propriedades Properties ou XML, sendo que a entidade e os atributos da entidade devero aceitar Annotations para configurao. Pr-Condies: No necessita. Garantia de Sucesso: A entidade foi criada e pronta para ser validada para persistncia. Cenrio de Sucesso Principal: 1. O programador cria uma nova classe com o nome que desejar. 2. O programador informa se a entidade ser persistida no formato Properties ou em XML, utilizando a Annotation @PropertiesEntity ou @XmlEntity. 3. Dever ser informado o nome do arquivo a ser gravado no atributo file da Annotation selecionada. 4. O programador quer criptografar algum atributo da classe. 4.1. O programador insere a Annotation @Encrypted em algum atributo. 4.2. O programador quer informar uma chave de criptografia especfica que no seja a padro utilizada na Annotation,

44

4.2.1. O programador insere valor para o atributo cryptoKey na Annotation @Encrypted do atributo que desejar. 5. O programador deseja inserir uma chave especifica para criptografia e que essa seja padro em toda a classe, 5.1. O programador insere essa chave no atributo cryptoKey da Annotation @PropertiesEntity ou @XmlEntity. Fluxos Alternativos: No existem. Nome: Persistir uma Entidade Properties ou XML Escopo: ConfigAPI Nvel: Objetivo do Programador Ator Principal: Programador Interessados e Interesses: - Programador: Persistir uma entidade criada por ele, com os dados que desejar, do tipo que desejar e com opo de criptografia de alguns atributos ou todos os atributos da entidade. - API: Persistir a entidade informada pelo programador, criptografando dados escolhidos por ele e retornar a mesma. Pr-Condies: Possuir uma entidade criada com as devidas Annotatios informadas e atributos preenchidos. Garantia de Sucesso: A entidade foi persistida, possvel agora utilizar a mesma para consulta. Cenrio de Sucesso Principal: 1. O programador dever instanciar uma nova classe do tipo ConfigManager. 2. O programador informa o caminho da pasta onde o arquivo dever ser gravado no construtor da classe ConfigManager instanciada. 3. O programador invoca o mtodo load da classe ConfigManager instanciada, passando a entidade como parmetro. 4. A API recebe a entidade para persistir. 5. A API instancia uma classe do tipo File com o caminho informado pelo programador.

45

6. A API instancia classe ConfigLoader, passando como parmetro dessa classe o objeto a ser persistido e o objeto File. 7. A API invoca o mtodo saveEntity para salvar. 8. A API retorna a entidade salva para o programador. Fluxos Alternativos: 1. O arquivo informado pelo programador no existe. 1.2 . A API lana a exceo FileNotFoundException. 2. A entidade informada pelo programador no possui a Annotation @PropertiesEntity ou @XmlEntity. 2.1. A API lana a exceo NotAnnotatedEntityException. 3. A entidade informada pelo programador possui a Annotation @PropertiesEntity e tambm a @XmlEntity. 3.1. A API lana a exceo NotAnnotatedEntityException. 4. A entidade utiliza a Annotation @XmlEntity, mas esta no utiliza a @XmlRootElement. 4.1. A API lana a exceo NotAnnotatedEntityException. Nome: Carregar uma Entidade Properties ou XML Escopo: ConfigAPI Nvel: Objetivo do Programador Ator Principal: Programador Interessados e Interesses: - Programador: Informar os dados de um entidade que deseja carregar e receber a entidade carregada, com todas as propriedades. - API: Receber os parmetros de uma entidade que o Programador deseja carregar e retornar a entidade carregada. Pr-Condies: A entidade estar previamente cadastrada. Garantia de Sucesso: A entidade informada pelo Programador foi retornada populada pela API. Cenrio de Sucesso Principal: 1. O programador dever instanciar uma nova classe do tipo ConfigManager.

46

2. O programador informa o caminho da pasta onde o arquivo foi gravado no construtor da classe ConfigManager instanciada. 3. O programador invoca o mtodo load da classe ConfigManager instanciada, passando a entidade que deseja carregar como parmetro. 4. A API carrega a classe conforme os dados do arquivo persistido anteriormente, decifra os dados criptografados e retorna a classe para o programador. Fluxos Alternativos: 1. O arquivo informado pelo programador no existe. 1.2 . A API lana a exceo FileNotFoundException. 2. A entidade informada pelo programador no possui a Annotation @PropertiesEntity ou @XmlEntity. 2.1. A API lana a exceo NotAnnotatedEntityException. 3. A entidade informada pelo programador possui a Annotation @PropertiesEntity e tambm a @XmlEntity. 3.1. A API lana a exceo NotAnnotatedEntityException. 4. A entidade utiliza a Annotation @XmlEntity, mas esta no utiliza a @XmlRootElement. 4.1. A API lana a exceo NotAnnotatedEntityException.

47

3.5.1.3. Diagrama de Casos de Uso

Figura 23 Diagrama de Casos de Uso

48

3.5.2. Diagrama de Classes

49

Figura 24 Diagrama de Classes

3.5.3. Diagramas de Seqncia

50

Figura 25 Diagrama Carregar Entidade de Configurao de um Properties

51

Figura 26 Diagrama Carregar Entidade de Configurao de um XML

52

Figura 27 Diagrama Persistir Entidade de Configurao em Properties

53

Figura 28 Diagrama Persistir Entidade de Configurao em XML

3.6. Telas do Sistema (Screenshots)

CryptoConverter uma ferramenta disponvel na API, que torna possvel cifrar e decifrar dados diversos, servindo at mesmo para conferncia de dados persistidos

54

em arquivos properties ou XML. Nesta tela encontramos trs campos, sendo o primeiro Key, onde informados a chave que ser utilizada para cifrar ou decifrar os dados; Entry, o valor que ser cifrado ou decifrado e Output a sada do processo de criptografia desejado. Abaixo dos campos, encontram-se os botes Encrypt, para cifrar os dados e Decrypt, que decifra os dados. O boto Exit fecha a aplicao.

Figura 29 Tela CryptoConverter

Tela utilitria da API para gerar chaves com tamanhos definidos pelo usurio. Esta tela muito til para gerar chaves complexas.

Figura 30 Tela Generate Keys

3.7. Manual do Usurio

3.7.1. Adicionando a API um Projeto

55

O projeto que for escolhido para utilizar o ConfigAPI dever conter as classes do mesmo. Se a API estiver no formato de um arquivo JAR, fica fcil implantar no projeto, bastando apenas que este arquivo JAR esteja no classpath do mesmo, alm do JAR gnu-crypto.jar, disponvel para download as IDEs no possuem site a http://www.gnu.org/software/gnu-crypto/. Normalmente

funcionalidade de inserir um arquivo JAR no classpath da aplicao. Caso no esteja utilizando uma IDE especfica, como o Eclipse ou Netbeans, dever incorporar manualmente o arquivo JAR pela linha de comando que inicia a aplicao. Um exemplo seria: java -cp configapi.jar MinhaApp Dessa forma a API ser utilizada independente do sistema. O mais aconselhvel, at mesmo para facilitar a implementao, seria a utilizao de uma IDE especfica (NetBeans, Eclipse e afins). Um Exemplo para adicionar um arquivo JAR em um projeto no Eclipse seria atravs da opo Properties do projeto, quando clicado com o boto da direita do mouse em cima do mesmo. Na janela de propriedades do sistema, entrar na opo Java Build Path. Na aba Libraries, clicar no boto add Jars, selecionar o arquivo JAR e clicar em OK. Aps essa ao o arquivo desejado ficara no classpath da aplicao.

3.7.2. Criando Uma Entidade de Propriedades

Antes de utilizar a as funcionalidades de consultar ou alterar dados de um arquivo de propriedades ou XML, se faz necessrio criar a entidade que servir como base para o mesmo, e exatamente a que fica todo o mapeamento entre a aplicao e os arquivos de propriedades. vlido destacar que o processo de criar uma entidade de propriedades algo fcil, tendo em vista que as propriedades e opes so informados atravs de Annotations, uma funcionalidade Java que foi incorporado na API.

56

Antes de criar uma entidade, leva-se em conta escolher se ela ser em arquivo formato Properties ou XML, ainda mais se estes arquivos forem compartilhados para outros sistemas consultarem, deve ser um formato legvel a um sistema que ir utilizar tambm. Mas mesmo assim nada impede que este formato seja alterado com facilidade mais tarde, atravs de uma Annotation. Aps decidir o tipo de arquivo a ser gerado pela entidade, deve criar uma classe java que ser a entidade. O nome pode ser da preferncia do implementador. Aps criar a classe, pode-se tambm criar todas as propriedades necessrias, que sero persistidas no arquivo de propriedades, podendo ficar assim, por exemplo:

public class ClasseTeste { private String nomeUm; private int numeroUm; }


Figura 31 Exemplo para criar uma entidade de propriedades

Logo aps, para cada atributo criado, o implementador dever gerar mtodos pblicos get e set para cada um deles, ficando assim:

public class ClasseTeste { private String nomeUm; private int numeroUm; public setNomeUm(String nomeUm) { this.nomeUm = nomeUm; } public String getNomeUm() { return nomeUm; } public setNumeroUm(int numeroUm) { this.numeroUm = numeroUm; } public getNumeroUm()

57

{ return this.numeroUm; } }
Figura 32 Exemplo para informar atributos de uma entidade de propriedades

Isso se faz necessrio, pois a forma da API capturar os dados que sero persistidos atravs de Reflection. Ou seja, para que funcione corretamente a persistncia dos dados, cada atributo da entidade que servir como mapeamento de arquivo de propriedades dever ter um mtodo get e set. Este o formato padro para uma entidade de propriedades. Uma classe com atributos diversos, sempre contendo cada um o seu mtodo get e set.

3.7.3. Informando Tipo de Arquivo de Propriedades

Aps uma entidade estar formada, se faz necessrio informar atravs de Annotatios, qual tipo de arquivo de propriedade ser, ou seja, se vai ser um arquivo Properties ou se vai ser um arquivo XML. Para isso utilizamos a Annotation @PropertiesEntity, quando desejamos que seja um arquivo em formato Properties ou a Annotation @XmlEntity, quando este deve ser em formato XML. Alm disso, nessas duas Annotations possvel informar qual ser o nome do arquivo, utilizando a propriedade file. Em suma, um exemplo ficaria assim:

@PropertiesEntity(file = "config.properties") public class ClasseTeste { } //ou @XmlEntity(file = "config.xml") public class ClasseTeste { }

58

Figura 33 Exemplo para informar tipo de arquivo de propriedades

Dessa forma fica fcil fazer alteraes do tipo de arquivo que ser persistido, apenas mudando a Annotation, alm de ter a opo de poder tambm informar qual ser o nome do arquivo, que conter as informaes de propriedades.

3.7.4. Informando Atributos de Propriedades

Aps informar qual ser o tipo de arquivo a ser persistido, informar tambm o nome do arquivo, todas as propriedades podero ser informadas, atravs tambm de Annotations. Para cada propriedade a Annotation @Property pode ser utilizada, para informar a API que a mesma um atributo da entidade. Esta Annotation ainda pode receber um nome diferenciado para ser gravado no arquivo de propriedades, sendo este atributo chamado de name, sendo somente possvel ser gravado em arquivos do tipo properties. Por exemplo:

@PropertiesEntity(file = "config.properties") public class ClasseTeste { @Property(name="nome-um") private String nomeUm; public setNomeUm(String nomeUm) { this.nomeUm = nomeUm; } public String getNomeUm() { return nomeUm; } }
Figura 34 Exemplo para informar atributos de propriedades

Dessa forma tem-se a opo de informar, caso seja necessrio, um nome de atributo no arquivo de propriedades, diferente do nome do atributo que se tem na classe.

59

Ainda possvel criptografar um atributo desejado na entidade escolhida para servir de propriedades. Atravs da Annotation @Encrypted, podemos dizer que um atributo deve ser criptografado. O algoritmo de criptografia utilizado como padro a chave 7-BDy%q6V8fbk9C2, mas nada impede de quem est implementando, informar uma outra chave de sua escolha. Para utilizar uma outra chave para criptografia, basta informar na mesma Annotation a propriedade cryptoKey. Dessa forma uma chave especfica informada por quem est utilizando a API ser utilizada para cifrar os dados. Por exemplo:

@PropertiesEntity(file = "config.properties") public class ClasseTeste { @Encrypted(cryptoKey="ricardo1") private String nomeUm; public setNomeUm(String nomeUm) { this.nomeUm = nomeUm; } public String getNomeUm() { return nomeUm; } }
Figura 35 Exemplo para criptografar um atributo

Assim, a propriedade da classe servida como exemplo ser cifrada atravs do algoritmo de criptografia PBEWithMD5AndDES. Esta mesma chave ser utilizada para decifrar os dados. Essa funcionalidade torna-se muito til para gravar dados importantes como senhas e outros dados que sejam restritos. Com dados cifrados, mesmo algum que tenha o arquivo de propriedades de forma no autorizada, no conseguir saber do que se trata o dado, mesmo possuindo a chave, para desvendar os dados necessrio possuir o vetor de inicializao do algoritmo.

3.7.5. Alterando Dados de uma Entidade de Propriedades

60

Parte-se do princpio que o arquivo, tanto do tipo Properties, quanto XML, j tenha sido criado em uma pasta da preferncia do utilizador da API para que as informaes a seguir sejam possveis de efetuar. Aps informar qual ser o tipo de arquivo e suas propriedades em uma classe de entidade de propriedades, ser possvel persistir a entidade gerada, conforme as Annotations feitas. Para isso a API dever ser informada onde ser o repositrio, ou seja, onde o arquivo de propriedades ser gravado. Sempre que a entidade for persistida, os atributos sero atualizados no arquivo de propriedades, sobrescrevendo os dados antigos. Para persistir os dados da entidade de propriedades, a classe ConfigManager dever ser instanciada. Esta classe responsvel por gerenciar a persistncia e a leitura de uma entidade que foi definida pelo utilizador da API. O construtor desta classe dever receber uma classe do tipo File, contendo o caminho onde o arquivo dever ser persistido e mais tarde recuperado seus dados para leitura. Exemplo: ConfigManager cm = new ConfigManager(new File(Util.getPath("/pasta1 /"))); A classe Util, faz parte da API e contm mtodos que facilitam sua utilizao. Nesse caso torna-se til para inicializar a classe File, utilizada para instanciar a classe ConfigManager. Aps ter instanciado uma varivel do tipo ConfigManager, basta apenas invocar o mtodo load desta classe, atribuindo em seu parmetro a entidade de propriedades. Exemplo: Config config = pm.load(Config.class); Sendo que a classe Config a entidade de propriedades, devidamente configurada pelo utilizador da API, com as respectivas Annotations.

61

Aps ler a entidade de propriedades, seus atributos podero ser conferidos apenas utilizados mtodos get e alterados informando os novos dados pelos mtodos set. Aps alterar os dados da forma que desejar, para persistir os dados alterados, basta somente utilizar o mtodo persist, da classe Config instanciada, passando a classe entidade de persistncia como parmetro. Dessa forma, todos os atributos da classe de persistncia que foram alterados sero persistido no arquivo de propriedades, tanto XML quanto Properties.

62

4. ESTUDO DO CASO

O ConfigAPI, recentemente desenvolvido, j utilizado em mais de duas aplicaes de importante utilidade para grandes empresas, sendo a mais importante a prefeitura da cidade de Curitiba. Dentre as aplicaes que utilizam a API esto o OpenDoc, que faz gerenciamento de redes corporativas, incluindo gerenciamento de usurios, grupos de usurios, compartilhamentos de arquivos, dentre outras funcionalidades. Para que um sistema, em tempos de recesso, seja bem sucedido, de grande valia possuir cdigo aberto e isso a API tem em sua totalidade. Todas as tecnologias utilizadas na API so de cdigo aberto.

4.1. Utilizao do ConfigAPI

Para empresas que precisam administrar suas redes, sem depender de aplicaes e ferramentas proprietrias, o Instituto Curitiba de Informtica (ICI) desenvolveu um sistema chamado OpenDoc. O ICI uma das empresas que utiliza o ConfigAPI em vrias de suas aplicaes. O OpenDoc um sistema que atualmente utilizado pela prefeitura de Curitiba e engloba vrias utilidades, centralizando o gerenciamento de redes e usurios. A revista Tecnologia da Informao fez um artigo sobre esse utilitrio de redes, destacando suas principais funcionalidades como sendo: criao de usurios, grupos, compartilhamentos, gerenciamento de senhas, permisses e relao de confiana entre domnios.10, sendo de grande valia para quem necessita de um software de gerenciamento desse tipo, evitando um custo muito alto. A prpria revista destaca em seu artigo, que os gastos para desenvolvimento so menores, pois no h custo de licenciamento. O Active Directory da Microsoft, por exemplo, representa um valor muito alto para a Prefeitura. Teramos que pagar licenciamento para cada estao de trabalho, e h cerca de 30 mil estaes. 10.

63

O OpenDoc no deixou a sua principal vantagem de lado, quando incorporou o ConfigAPI em suas funcionalidades: ser um sistema desenvolvido totalmente com cdigo aberto, justamente porque toda a API tambm toda em cdigo aberto. Vale a pena destacar que o custo bem menor, se outras tecnologias proprietrias fossem utilizadas. O ICI uma empresa que desenvolve aplicaes voltadas para uso governamental, uma empresa paranaense, mas com softwares em produo em vrios pontos do Brasil. Outras tecnologias desenvolvidas pelo ICI que utilizam a API ConfigAPI so: GedFaturas: O projeto tem como objetivo gerenciar faturas, contratos e

relatrios da prefeitura do municpio de Curitiba separadas por secretarias utilizando GED, possibilitando a criao de diferentes papeis para usurios para organizar o trabalho. O GED (Gesto Eletrnica de Documentos) utilizado para administrar documentos digitalizando os mesmos, de forma a agilizar o processo de pesquisa e visualizao destes atravs do computador. GedSMF: Sistema da Secretaria Municipal de Finanas. GedSMU: Sistema da Secretaria Municipal de Urbanismo. GedSMRH: Sistema da Secretaria Municipal de Recursos Humanos. GedSMAD: Sistema da Secretaria Municipal de Administrao Pblica.

Segue arquivo de configurao do OpenDoc:

#Banco de dados aplicacao #Tipo do Banco de Dados, utilizado sobrescrevendo #o com um map o persistence.xml tipoBaseDados=postgresql #Usurio do banco de dados tambm sobrescreve #o persistence.xml, criptografado contaBD=oz5V+FZuc21N3Tf1obVPCg== #Senha do usurio do banco de dados tambm sobrescreve #o persistence.xml, criptografado senhaBD=F8W5sA9MCD4= #IP do servedor do banco de dados tbm sobrescreve o persistence.xml

64

ipServidorBd=127.0.0.1 #Nome do banco tbm sobrescreve o persistence.xml nomeBaseDados=admGeralRedes # #Banco de dados Gessi #Porta de conexo para o segundo banco de dados tbm sobrescreve o persistence.xml portaBDGessi=5000 #Tipo do banco tipoBDGessi=sqlserver #Usurio dp banco da dados tbm sobrescreve o persistence.xml, criptrografado contaBDGessi=P/5em/YUQMGkSm0q7c1OyQ== #Senha do usurio do banco de dados tbm sobrescreve o persistence.xml, criptografado senhaBDGessi=69f6H4AOKhRXUa/Lq1r5Lg== #IP do bd tbm sobrescreve o persistence.xml ipServidorBDGessi=172.19.200.74 #nome do bd nomeBDGessi=admredes # #Dados para conectar no novo LDAP acessando o servidor ldap #LDAP um servio de rvore diretrios utilizado para autenticao de usurios #parecido com Active Directory da MS, na intenet tem muita coisa sobre ele #IP do servidor LDAP ipServidorLDAP=172.16.30.93 #Porta de conexo LDAP nrPortaLdap=389 #Usurio administrador do Ldap, criptografado usuarioLdap=vi1iMVynUdoNn9dY8CxlZA== #senha do usurio adm Ldap, criptografado senhaLdap=glQqv9MVApk= #raiz da rvore de diretrios #(De nvel mais alto no tem nenhum diretrio acima) organizacao=ICI #sub-raiz onde se encontra os domnios suborganizacao=domains #sub-raiz onde se encontra os grupos entradaGrupos=groups #sub-raiz onde se encontra os usurios entradaUsuarios=users #sub-raiz onde se encontra os computadores entradaComputadores=computers #entrada de dominios entradaDominios=domains #opo inicial de autenticacao #opcao para autenticar no Ldap opcaoAutenticar=ldap #atributos utilizados na autenticacao, isto um array atributosAutenticar=statusUsuario

65

#valor esperado para confirmar a autenticacao, isto um array valoresAutenticar=ativo #Chave criptogrfica para web-services, criptografado chaveDES=QXZ7Qh3f53KGU51JR99z6Q== # #Validar em Ldap antigo #Dados utilizados para conectar no Ldap antigo #pois preciso fazer consultas #Obs: somente apagar os atributos quando no forem mais utilizados #pois a migrao esta sendo feita em pequenos domnios e #no tudo de uma s vez #os dados so so identicos ao descritos acima ipLdapAntigo=172.19.200.31 nrPortaLdapAntigo=389 caminhoBaseUsuarioAntigo=ou=domains,o=ldap caminhoUsuarioAntigo=ou=users atributoDominioAntigo=dc= contaAdminAntigo= variavelContaUsuarioAntigo=uid= senhaAdminAntigo= opcaoAntigo=ldap caminhoInicialAntigo=o=ldap caminhoDominioAntigo=ou=domains #Servios controlados pela aplicao em cada servidor #de domnio necessrios para um servidor Linux #Servicos controlados pelo projeto #se tornar um servidor de domnio em uma rede onde mista de computadores Linux e Windows #Nomes de apresentao na interface com usuarios dos servios nomesServicos=Samba,Winbind,Nscd,Vsftp,Dhcp #nomes respectivos dos servios controlados por ssh java seguidos por suas descries nomesServicosLinux=smb,winbind,nscd,vsftpd,dhcpd descricoesServicos=Servi&ccedil;o Samba fornece protocolo SMB
Figura 36 Arquivo de configurao do OpenDoc

Segue arquivo de configurao do GedFaturas:

## Constantes Gerais - Desenvolvimento Local / GedFaturas ## #Banco de Dados ipServidorBD=172.19.200.117 nomeBD=faturasGED # Este possivel colocar nome do driver por aqui no lugar do tipo do banco driverBD=org.postgresql.Driver #criptografado usuarioBD=HMb1QTTLSx0= #criptografado

66

senhaBD=026J663LZDg= #abcdoc #O servidor de documentos armazena em forma de arquivos todo tipo de #documento j incluindo #assinatura digital consiste em um servidor de #implementao prpria feito em Java #IP do servidor onde esta rodando o processo ipServidorAbc=172.19.200.117 #Porta para conexo nrPortaAbc=4760 #Usurio administrador do Servidor de documentos usuarioAbc=spwHM8r+/Qs= #Senha do usurio #administrador do servidor de documentos senhaAbc=spwHM8r+/Qs= # Nome da aplicao que esta utilizando o servidor de documentos aplicacaoAbc=1eIsOSNLJEU= #Autenticador LDAP Atributos indenticos aos descritos anteriormente, #porm nesta aplicao usado somente para autenticao e #pesquisa de usurios ldapOpcao=ldap ipServidorLdap=172.19.200.31 nrPortaLdap=389 baseDnUsuarioLdap=ou=domains,o=ldap * #caminho de diretrios para montar a pesquisa de usurios dnDominioLdap=dc= #raiz dos domnios dnUsuariosLdap=ou=users #raiz dos usurios variavelContaUsuarioLdap=uid= #nome do atributo que armazena o login do usurio bindDnLdap= #caminho e usurio do usurio administrador do Ldap esta #em branco pois o Ldap atual no esta configurado #para exigir usurio e senha para consultas ou seja #possivel consulta anonima. #senha do usurio adm do Ldap bindSenhaLdap= #array de atributos para autenticao atributosValidarLdap = iciStatusConta #array dos valores esperado para comparar dutante a autenticao atributosValidarValorLdap = ativo
Figura 37 Arquivo de configurao do OpenDoc

67

5. CONCLUSO 5.1. Sobre o Desenvolvimento da API

Algo muito importante sobre a vantagem de fazer uma monografia ou um projeto de uma API especfica justamente o aprendizado. Pode-se at conhecer a uma determinada ferramenta que utilizada em um projeto, mas quando necessrio aprofundar-se para poder realmente utiliz-la, o aprendizado se torna muito forte. Na API ConfigAPI, procurou-se sempre minimizar a programao da parte do implementador que utilizar a API, sobre tudo que poderia ser feito diretamente na API. Buscou-se o encapsulamento dos processos que fossem possveis fazer, deixando, por exemplo, somente ao programador informar o lugar onde o arquivo ser gravado, ou carregado. Tecnologias atuais foram incorporadas, que trazem produtividade da parte de implementao da API em especfico e tambm da parte de quem utilizar a API. importante frisar que ao utilizar Annotations, torna-se possvel deixar produtiva a criao de uma entidade que ser um arquivo de propriedades, pois basta somente informar anotaes especficas em uma propriedade de uma classe Java, por exemplo, ou na assinatura da classe, deixando a implementao limpa e simples, mas poderosa, alm de Generics, proporcionando facilidade de leitura no cdigo, evitando casting. Duas opes, sendo elas as mais populares, foram utilizadas: Properties e XML, justamente pela facilidade de utilizao e at mesmo facilidade de compreenso por humanos, lembrando que nenhuma das opes so compiladas. Alm disso, arquivos Properties e XML so compartilhveis com outras aplicaes. Pode-se utilizar o ConfigAPI pra gerar estes arquivos de propriedades e ainda permitir que outra aplicao leia estes mesmos para utilizar da forma que preferir. Percebeu-se ao longo do planejamento da API que dados importantes no poderiam ser legveis a humanos, sendo assim, formas de criptografia foram ainda incorporadas na API. No existe motivo para deixar de usar por motivo de dados importantes serem descobertos. Essa implementao de criptografia ajuda muito, quando dados devem estar ilegveis, no importando quem esteja com o arquivo de propriedades em mos. Somente quem tem a chave em mos pode ler os dados

68

criptografados. E essa opo fornecida apenas informando uma Annotation especfica. Enfim, chegou-se a satisfao de um sistema completo de gravao de configuraes atravs desta API, muito til para sistemas que desejam gravar dados especficos.

5.2. Dificuldades Encontradas

Apesar da vasta documentao sobre as vrias formas de criptografia, esta foi dificuldade quando foi necessrio aprofundar-se em seus conceitos em nvel de documentao do projeto. Java possui muita facilidade de utilizao de criptografias diversas, justamente por tudo estar encapsulado. No necessrio entender o que se passa por trs de um mtodo de criptografia, sendo este pertencendo a API criptografia do Java, tudo se torna mais fcil, mas sempre necessrio se aprofundar no assunto, pra ter conhecimento suficiente. Houve ainda uma preocupao de deixar tudo muito facilitado para quem for utilizar a API. De nada vale deixar mtodos a cargo do utilizador da API, sendo que estes poderiam ser implementados pela mesma. Pensou-se sempre em deixar tudo facilitado ao utilizador da API de forma a encapsular e essa forma de cuidado pode ter sido uma das dificuldades.

5.3. Trabalhos Futuros

Apesar de a API estar equipada com o que existe de mais atual em tecnologias Java, possveis melhorias poderiam ser incorporadas, ainda existem possibilidades de utilizar mecanismos que facilitem ainda mais. O forte da API tambm a funcionalidade de criptografia, tendo ela somente a forma PBEWithMD5AndDES como utilizada por hora. Uma soluo seria permitir ao programador selecionar qual algoritmo de criptografia utilizar, dependendo da sua necessidade ou preferncia. Talvez no haja necessidade de utilizar um algoritmo de

69

complexidade to forte, ou talvez o que deveria ser utilizado um algoritmo mais potente. Essa flexibilidade de escolha de algoritmo poderia ser uma melhoria, alm de uma forma de inicializar o vetor de algoritmos utilizados. Alm de tudo o que pode ser feito ainda uma interface grfica rica em opes da API, contendo opes como um lugar padro para gravao de arquivos de propriedades, criar arquivos de propriedades pela interface grfica, com quantas propriedades preferir, se criptografadas ou no, podendo informar o nome do arquivo, se ser Properties ou XML, dentre outras opes que poderia conter numa interface grfica. As interfaces grficas podem agilizar o processo da API, alm de interessar a pessoas que no tem intimidade suficiente com cdigos de programao.

70

6. REFERNCIAS BIBLIOGRFICAS

1. BAUER, C.; KING, G. Java Persistence com Hibernate. ed. Rio de Janeiro: Editora Cincia Moderna, 2007. 2. MCCLUSKEY, G. Using Java Reflection. [S.l.] 2000. Disponvel em: <http://java.sun.com/developer/technicalArticles/ALT/Reflection/>. Acesso em: 10/05/2009. 3. LEONARDO, C. L. Introduo Criptografia Computacional. ed. Campinas: Editora da Unicamp, 1986, pag 1. 4. SCHNEIDER, B. Applied Cryptography, Second Edition. ed. Canad: Wiley, 2001, pag 270. 5. OAKS, S. Segurana de Dados em Java. ed. Rio de Janeiro: Editora Cincia Moderna, 1999, pag 298. 6. BATISTA, L. de A. Modelo Estrutural de um Sistema Criptogrfico em Java. Dissertao (Mestre em Cincias) Programa de Ps-Graduao em Engenharia Eltrica e Informtica Industrial. Curitiba: Centro Federal de Educao Tecnolgica do Paran, 2001, pag 67. 7. RAY, E. T. Aprendendo XML. ed. Rio de Janeiro: Campus, 2001, pag 1. 8. GAMMA, E; HELM R.; JOHNSN, R.; VLISSIDES, J. Padres de Projeto Solues Reutilizveis de Software Orientado a Objetos. ed. Porto Alegre: Bookman, 2008, pag 20. 9. LARMAN, C. Utilizando UML e Padres. ed. Porto Alegre: Bookman, 2007.

71

10.Tecnologia da Informao 27 Edio Ano VIII. Circulao Nacional ASSESPRO PR Abril/2009 JANDIL, P. J. Java Guia do Programador. ed. So Paulo: Novatec Editora, 2007, pag 135.