Dinâmica da Digitação Aplicada a Ambientes Web - Projetos

1
RODRIGO SERVIUC PAVEZI
Dinâmica da Digitação Aplicada a Ambientes Web
Orientador:
Prof. Dr. rer.nat. Aldo von Wangenheim
Florianópolis, 2007
2
RODRIGO SERVIUC PAVEZI
Dinâmica da Digitação aplicada a um ambiente WEB
Projeto de Pesquisa para elaboração do
Trabalho de Conclusão de Curso apresentado
como exigência para a obtenção do título de
Bacharel em Ciências da Computação à
Universidade Federal de Santa Catarina UFSC, no curso de Ciências da Computação.
Orientador:
Prof. Dr. rer.nat. Aldo von Wangenheim
BACHARELADO EM CIÊNCIAS DA COMPUTAÇÃO
DEPARTAMENTO DE INFORMÁTICA E ESTATÍSTICA - INE
CENTRO DE TECNOLÓGICO - CTC
UNIVERSIDADE FEDERAL DE SANTA CATARINA - UFSC
Florianópolis, 2007
3
Trabalho de conclusão de curso sob o título “Dinâmica da digitação aplicada a um
ambiente WEB”, defendido por Rodrigo Serviuc Pavezi sob aprovação, em Florianópolis,
Santa Catarina, pela banca examinadora constituída:
Prof. Dr. rer.nat. Aldo von Wangenheim
Departamento de Informática e Estatística - INE
Orientador
M.Sc. Rafael Andrade
Departamento de Informática e Estatística - INE
M.Sc. Rafael Simon Maia
Departamento de Informática e Estatística - INE
4
“Artificial Intelligence: the art of
making computers that behave like the ones
in movies.”
Bill Bulko
5
SUMÁRIO
LISTA DE FIGURAS.................................................................................................................................................. 6
LISTA DE TABELAS ................................................................................................................................................. 7
RESUMO...................................................................................................................................................................... 8
ABSTRACT.................................................................................................................................................................. 9
1.INTRODUÇÃO....................................................................................................................................................... 10
1.1 CONTEXTO ..................................................................................................................................................... 10
1.2 OBJETIVOS ..................................................................................................................................................... 12
1.2.1 OBJETIVO GERAL ................................................................................................................................... 12
1.2.2 OBJETIVOS ESPECÍFICOS ..................................................................................................................... 12
1.3 METODOLOGIA ............................................................................................................................................. 13
1.3.1 ETAPAS DO DESENVOLVIMENTO ........................................................................................................ 13
1.4 JUSTIFICATIVA.............................................................................................................................................. 14
1.5 SISTEMA FOCO PARA O TRABALHO......................................................................................................... 14
1.4 MOTIVAÇÃO .................................................................................................................................................. 15
2 BASE TEÓRICA .................................................................................................................................................... 16
2.1 BIOMETRIA..................................................................................................................................................... 16
2.2 DINÂMICA DA DIGITAÇÃO ......................................................................................................................... 22
2.3 TÉCNICAS DE CLASSIFICAÇÃO ................................................................................................................. 26
2.3.1 K-NEAREST NEIGHBOR ......................................................................................................................... 28
2.3.1 CENTRÓIDE............................................................................................................................................. 30
3 DESENVOLVIMENTO......................................................................................................................................... 32
3.1 TECNOLOGIAS UTILIZADAS ...................................................................................................................... 32
3.2 FERRAMENTAS UTILIZADAS ..................................................................................................................... 33
3.2 PROCESSO DE ANÁLISE............................................................................................................................... 34
3.2.1 VISÃO GERAL DO SISTEMA ................................................................................................................... 34
3.2.2 ALGORITMOS DE CLASSIFICAÇÃO...................................................................................................... 36
3.2.2 ARQUITETURA ........................................................................................................................................ 36
3.2.3 LEVANTAMENTO REQUISITOS ............................................................................................................. 37
3.2.3 CASOS DE USO........................................................................................................................................ 38
3.2.4 DIAGRAMA DE CLASSE.......................................................................................................................... 39
4 IMPLEMENTAÇÃO.............................................................................................................................................. 42
4.1 CONSIDERAÇÕES SOBRE A IMPLEMENTAÇÃO ..................................................................................... 42
4.1.1 APPLET CLIENTE DE ACESSO .............................................................................................................. 43
4.1.2 APPLET CLIENTE DE TREINAMENTO.................................................................................................. 43
4.2 AVALIAÇÃO ................................................................................................................................................... 44
4.3 RESULTADOS................................................................................................................................................. 46
4.4 ANÁLISE.......................................................................................................................................................... 51
4.4.1 TÉCNICAS DE CLASSIFICAÇÃO............................................................................................................ 51
4.4.2 OPINIÃO DOS USUÁRIOS ...................................................................................................................... 52
5 CONCLUSÃO......................................................................................................................................................... 53
REFERÊNCIAS....................................................................................................................................................... 564
ANEXO A – CÓDIGO FONTE DA APLICAÇÃO ............................................................................................ 5691
ANEXO B - ARTIGO................................................................................................................................................ 91
6
LISTA DE FIGURAS
FIGURA 1 - NÍVEL DE SEGURANÇA VERSUS CUSTO DE IMPLANTAÇÃO. ...................................................................... 18
FIGURA 2 - LINHAS DOS ERROS DE AVALIAÇÃO. ......................................................................................................... 21
FIGURA 3 - CAPTURA DOS TEMPOS DA DIGITAÇÃO. .................................................................................................... 24
FIGURA 4 - UM PADRÃO XU E SEUS VIZINHOS MAIS PRÓXIMOS.................................................................................. 29
FIGURA 5 – CIRCUNFERÊNCIA COM CENTRÓIDE E RAIO. ............................................................................................ 31
FIGURA 6 – PADRÃO CLASSIFICADO COMO NÃO VÁLIDO. ........................................................................................... 31
FIGURA 7 – PADRÃO CLASSIFICADO COMO VÁLIDO. ................................................................................................... 31
FIGURA 8 - DIAGRAMA DE ATIVIDADES DO SISTEMA. .................................................................................................. 35
FIGURA 9 - ARQUITETURA DO SISTEMA....................................................................................................................... 37
FIGURA 10 - DIAGRAMA DE CLASSES DO MÓDULO CLIENTE. ...................................................................................... 40
FIGURA 11 - DIAGRAMA DE CLASSE DO MÓDULO SERVIDOR. ..................................................................................... 41
FIGURA 12 – DIFERENÇA DO ERRO FAR ENTRE OS TESTES DE 5 E 10 REPETIÇÕES COM O K-NN. ......................... 47
FIGURA 13 - DIFERENÇA DO ERRO FAR ENTRE OS TESTES DE 5 E 10 REPETIÇÕES COM O CENTRÓIDE................. 48
FIGURA 14 – COMPARAÇÃO ENTRE OS RESULTADOS DOS CLASSIFICADORES NO TREINO COM 5 REPETIÇÕES....... 49
FIGURA 15 - COMPARAÇÃO ENTRE OS RESULTADOS DOS CLASSIFICADORES NO TREINO COM 10 REPETIÇÕES. .... 50
7
LISTA DE TABELAS
TABELA 1 - COMPARATIVO ENTRE AS POSSÍVEIS TECNOLOGIAS PARA SE UTILIZAR NA IMPLEMENTAÇÃO DA DINÂMICA
DA DIGITAÇÃO..................................................................................................................................................... 33
TABELA 2 - CASO DE USO DO CADASTRAR USUÁRIO. ............................................................................................... 38
TABELA 3 - CASO DE USO DO VALIDAR USUÁRIO. ..................................................................................................... 39
TABELA 4 - RESULTADOS DOS TESTES COM O K-NN. ................................................................................................. 46
TABELA 5 - RESULTADOS DOS TESTES COM O CENTRÓIDE. ...................................................................................... 47
8
RESUMO
A grande maioria dos sistemas de informação, que necessitam de autenticação por
usuário, utiliza os dados: usuário e senha, como processo de autenticação. Com a
evolução do meio de comunicação e principalmente da Internet, tal processo tornou-se
não mais tão seguro. O grande problema desse processo de segurança tem sido a perda
ou o roubo dos dados de autenticação. Com isso, dando a chance de um indivíduo não
autorizado acessar o sistema com o nome de usuário e senha de um verdadeiro usuário
do sistema. Foi pensando nesse problema e, em alguma forma de resolvê-lo, que neste
trabalho foi feito um estudo e a implementação da técnica biométrica, dinâmica da
digitação (Keystroke dynamics), a qual serviu de base para a criação de um sistema de
segurança aplicado a um ambiente WEB. O sistema implementado é um sistema de
autenticação de usuário que foi implementado utilizando a tecnologia applet e dois
algoritmos de classificação: k vizinhos mais próximos(K-nearest neighbor) e algoritmo do
Centróide.
Palavras-chave: Dinâmica da digitação. Vizinho mais próximo. WEB. Applet. RMI.
Centróide
9
ABSTRATC
The great majority of the information systems, that need authentication for user,
uses the data: user and password, as authentication process. With the evolution of the
media and mainly of the Internet, such process became not more so safe. The great
problem of this process of security has been the loss or the robbery of the authentication
data. With this, giving the possibility of a not authorized individual to have access the
system with the user name and password of a true user of the system. It was thinking
about this problem and, in some form to decide it, that in this work a study was made and
the implementation of the biometric technique, Keystroke dynamics, which served of base
for the creation of a system of security applied to an environment WEB. The implemented
system is a system of user authentication that was implemented using the technology
applet and two algorithms of classification: K-nearest neighbor and Centroid algorithm.
Key-words: Keystroke dynamics. K-nearest neighbor. WEB. Applet. RMI. Centroid
10
1.INTRODUÇÃO
1.1 CONTEXTO
Pessoas que utilizam a Internet em seu cotidiano necessitam de bons níveis de
segurança para proteger as informações que estão sendo acessadas. Quando
acessamos nossa caixa de e-mail, temos que ter a segurança de que somente nós é que
podemos acessar ela, pois ninguém quer que outras pessoas tenham acesso a nossas
informações. Esta segurança deve ser oferecida pelos sistemas que guardam e
gerenciam tais informações, com o foco principal para os que estão presentes na
Internet, onde o acesso é compartilhado por diversas pessoas. Alguns desses sistemas:
prontuário eletrônico, banco on-line e gerenciadores de e-mail.
Na grande maioria dos sistemas hodiernos, usuários são autenticados através do
par: nome de usuário e senha. O grau de segurança dessa autenticação depende da
complexidade da senha escolhida pelo usuário, da segurança do sistema operacional
que dá acesso ao sistema e principalmente dos navegadores. Muitos usuários escolhem
senhas pouco complexas, como: data de aniversário, nomes de familiares e seqüências
de números.
Em sistemas que são implementados em cima do ambiente WEB, tem a
necessidade de um módulo de segurança, pois nem toda a informação pode ser
acessada por qualquer usuário que esteja navegando pela Internet. Esse módulo de
segurança vem sendo implementado com a utilização de um simples sistema de
autenticação de usuário. Geralmente essa autenticação é feita através de um par de
valores: nome de usuário e senha. Esse modo de autenticação tem suas vantagens e
11
desvantagens. As vantagens vêm desde a fácil implementação até a fácil utilização pelo
usuário. Já a desvantagem vem da perda do par de valores pelo usuário utilizador ou o
par de valores do usuário utilizador ser roubado por algum individuo malicioso. Como é
um sistema WEB, esse indivíduo malicioso pode acessar o sistema de qualquer lugar do
mundo e a hora que bem quiser.
Alguns sistemas que estão no meio WEB e precisam de um alto nível de segurança,
necessitam de outro meio de autenticação que não sofra com as desvantagens do
processo tradicional citado.
Uma das formas de elevar os níveis de segurança é através do uso de técnicas
biométricas. A utilização das técnicas biométricas tem o objetivo de aumentar a
segurança entre usuários e sistemas.
O custo aliado aos níveis de segurança que serão implantados são requisitos de
extrema importância para sistemas. Por este motivo, analisar qual técnica biométrica se
adapta melhor ao sistema é fundamental para o sucesso do projeto. Uma técnica que
tem um baixo e um nível médio de segurança é a Dinâmica da Digitação.
Dinâmica de digitação tem o objetivo de aumentar a segurança entre usuários e
qualquer tipo de sistemas de informação. Sendo uma das técnicas da Biometria, ela tem
como característica a utilização da fisiologia e do comportamento humano para identificar
a identidade única de um indivíduo. Com a dinâmica de digitação cada usuário será
autenticado conforme o ritmo com que ele digita em um teclado, sendo esse ritmo uma
característica única de cada um.
A dinâmica da digitação necessita de um algoritmo de classificação, sendo o
principal responsável pelo funcionamento dessa e de outras técnica biométrica. Um
classificador é uma entidade que contem um certo tipo de conhecimento. Com esse
12
conhecimento, que ele adquiri durante um treinamento, ele deve ser capaz de classificar.
No caso da dinâmica da digitação o classificador é treinado com os tempos de digitação
de um determinado usuário. Com isso, ele pode classificar se um conjunto de tempos de
digitação é ou não pertencente ao mesmo usuário, o qual foi base para o treinamento.
1.2 OBJETIVOS
1.2.1 OBJETIVO GERAL
O trabalho em questão tem como objetivo central, a utilização da técnica biométrica
dinâmica da digitação como adjetivo no processo de autenticação de sistemas que são
implementados no ambiente WEB.
1.2.2 OBJETIVOS ESPECÍFICOS
Análise do Projeto
Implementar o sistema de autenticação;
Implementar técnicas de classificação;
Fazer testes de validação;
Gerar análises estáticas;
13
1.3 METODOLOGIA
Em conjunto com o estudo da dinâmica da digitação, será feito o estudo dos
métodos ou algoritmos de classificação, utilizando o estado da arte como comparativo.
Obaidat e Sadoun (1999) realizaram um estudo comparativo entre diferentes
técnicas de classificação aplicadas à dinâmica da digitação. Dividiram elas em dois
principais grupos: grupo das técnicas de reconhecimento de padrões e grupo das
técnicas de redes neurais artificiais. Com base em seus estudos, será feita a aplicação da
técnica de reconhecimento de padrão k-nearest neighbor (K-NN, os k vizinhos mais
próximos) e de técnica que utiliza o cálculo do centróide.
A partir dos estudos, será feita a implementação do sistema protótipo, o qual será
um sistema de autenticação de usuários implementado em um ambiente WEB. Tendo
isso em vista, será feito um estudo sobre as tecnologias e formas de implementação que
deverão ser utilizadas no desenvolvimento do sistema.
1.3.1 ETAPAS DO DESENVOLVIMENTO
1. Levantamento de requisitos;
2. Definição de casos de uso;
3. Geração do diagrama de classes;
4. Implementação
5. Validação;
6. Análise.
14
1.4 JUSTIFICATIVA
Todo esse estudo visa à aplicação da dinâmica da digitação em sistemas WEB, os
quais necessitam de uma melhor segurança. Essa aplicação deve garantir a esses
sistemas WEB uma segurança maior, sem a necessidade de um grande investimento, ou
seja, algo de custo baixo, tanto de implementação, como também de utilização.
1.5 SISTEMA FOCO PARA O TRABALHO
Para uma aplicação prática do desenvolvimento do trabalho será utilizado um
sistema protótipo. Mas o sistema que motiva esse trabalho é um sistema de prontuário
eletrônico, o qual é projetado para o ambiente WEB. Esse sistema tem como prioridade o
requisito de segurança dos dados que ele armazena.
Os usuários que terão acesso ao sistema, são na grande maioria pessoas que
trabalham na área hospitalar, por isso, a grande preocupação com a restrição de acesso.
O sistema em si trabalhará com informações a respeito de pacientes que contenham um
prontuário cadastrado no hospital.
Pelo fato desse sistema ser um sistema WEB, todo cuidado com a segurança deve
ser tomado, pois não será necessário o acesso físico para a utilização do mesmo, assim
facilitando o acesso de intrusos e de pessoas não autorizadas.
15
1.4 MOTIVAÇÃO
Sistemas de informação WEB estão, cada vez mais, se tornando vulneráveis a
invasões de intrusos. Isso nos motiva a estudar técnicas que possam vir a ajudar na
segurança desses sistemas. Principalmente para garantir a segurança dos usuários
utilizadores.
Também temos um grande interesse em nos especializar na área de do
Aprendizado de Máquinas. Pois toda a teoria que vamos estudar e colocar em prática,
pode ser facilmente utilizada em problemas de áreas diversas.
16
2 BASE TEÓRICA
Para andamento do trabalho tivemos que fazer estudar alguns trabalhos já
realizados em tono do mesmo assunto. Como também dos conceitos que envolvem o
projeto em geral. Neste capitulo é feita uma explanação sobre essa teoria.
2.1 BIOMETRIA
De acordo com Faundez-Zanuy (2006), a palavra biometria vem das palavras
gregas: “bios” (vida) e “metrikos” (medida). Ou seja, uma ciência que envolve uma análise
estatística das características biológicas, estudando as características físicas e
comportamentais do ser humano com o intuito de identificá-lo. As que utilizam as
características físicas do ser humano são: impressão digital, íris, retina, etc. E que
utilizam as características comportamentais temos: dinâmica da digitação e o
reconhecimento da assinatura.
Com todo esse estudo sobre o corpo humano, podemos capturar a biometria das
pessoas, e com isso, criar uma aplicação de segurança que analise as características
biológicas e faça uma verificação de uma identidade única do individuo. Esse sistema
nada mais é que um sistema de autenticação de pessoas. Geralmente as pessoas
esperam que um sistema desses não seja invasivo ou constrangedor. Pois suas
características comportamentais ou fisiológicas estão sendo testadas. Então todo cuidado
deve ser tomado quando se está criando um sistema baseado na biometria.
17
Hoje em dia há diversos tipos de biometria, cada tipo com os seus benefícios e suas
desvantagens. Alguns dos tipos são:
Veias da palma da mão;
Impressão digital;
Reconhecimento de face;
Identificação pela íris;
Reconhecimento pela retina;
Reconhecimento de voz;
Geometria da mão;
Reconhecimento da assinatura;
Reconhecimento da digitação.
A Figura 1 mostra as diferenças entre as técnicas biométricas, considerando o custo
e o nível de segurança de cada uma. O nível de segurança influencia diretamente no
custo, pois a técnica que fornece a maior segurança utiliza-se de equipamentos e
tecnologias caras. A identificação pela íris, o reconhecimento da retina e o
reconhecimento da face, são os mais seguros e com isso, os de maior custo. Também
podemos encontrar técnicas de baixo custo, mas com um nível de segurança não tão
elevado.
Tanto o custo como o nível de segurança, são requisitos de grande importância
para sistemas de segurança. Por isso, temos que analisar qual técnica biometria se
adapta melhor ao sistema que estamos criando.
18
Nos anos 90, a tecnologia de reconhecimento de face, com o seu rápido
crescimento e desenvolvimento, acabou saindo dos laboratórios e começou a ser
aplicada em sistemas comerciais. Nos dias de hoje muitos sistemas utilizam o
reconhecimento de face [Phillips et al 2000]. Isso mostra que muita tecnologia que está
ainda nos laboratórios pode vim a ser utilizada comercialmente.
Figura 1 - Nível de segurança versus custo de implantação.
Umas das técnicas biométricas que vem sendo bastante usada é a impressão
digital. Tanto pelo fado dela ser uma técnica de custo acessível, como também, por ter
uma precisão aceitável. Algumas pessoas se sentem desconfortáveis ao usarem a
impressão digital, pelo fato de estar tocando no aparelho.
19
Já outras técnicas como identificação pela íris ou reconhecimento pela retina, são
técnicas de custo elevado, mas que tem uma grande precisão. Um dos fatores do custo
elevado vem da necessidade de um hardware próprio para o sistema, principalmente das
técnicas de biometria física. Já algumas técnicas de biometria comportamental, não
precisam de um hardware próprio. Por exemplo: para o reconhecimento de voz, tem-se a
necessidade de um simples microfone, pois os computadores de hoje em dia já fazem a
captura do sinal da voz em suas placas de som [Magalhães et al. 2005].
Além do custo, outro aspecto que influenciam na hora de se escolher uma técnica
para um sistema, é o fato do constrangimento dos usuários na utilização do sistema.
Alguns usuários se sentem constrangidos ao usar a reconhecimento pela íris. Isso ocorre
pelo fato desses usuários não se sentirem tranqüilos com a luz que passa pelos seus
olhos.
No presente trabalho, será abordada a técnica biométrica de reconhecimento da
digitação, também chamada de dinâmica da digitação. Tanto por ser uma técnica de
baixo custo como também de fácil aplicação em um sistema de acesso a usuário de uma
página na Internet.
Toda técnica biométrica tem as suas vantagens e desvantagens. Pois nenhum
aprendizado de máquina é 100% correto. Sempre se tem uma margem de erro [ Moore
2007]. O importante é saber se essa margem de erro afeta, de maneira considerável, a
utilização do sistema que implementa a técnica biometria. Por exemplo: um sistema de
autenticação não pode aceitar intrusos, como também, não pode rejeitar verdadeiros
usuários do sistema. Tais situações devem ser testadas e analisadas como erros da
técnica implementada.
20
Uma forma de testar uma especifica técnica, é avaliar os erros:
Falsa Aceitação (FAR - False Acceptance Rate): quando um sistema de
autenticação aceita ou autentica um impostor como um usuário cadastrado
no sistema.
Falsa Rejeição (FRR - False Rejection Rate): quando um sistema de
autenticação rejeita um usuário válido cadastrado no sistema.
Os dois tipos de erros valem para a avaliação de qualquer técnica biométrica. A
avaliação é feita através de testes de aceitação, os quais são simulações da utilização do
sistema que aplica a técnica biométrica.
Em um sistema de autenticação as simulações são realizadas com os possíveis
usuários que utilizaram o sistema. Cada usuário deve ser cadastrado no sistema e o
algoritmo de aprendizado de máquina deve aprender o padrão correspondente ao
usuário. Essa fase é chamada de treinamento. Depois do treinamento, o usuário testa se
o sistema reconhece ele como um usuário válido. Se por um acaso o sistema rejeitar o
usuário válido, um erro de FRR é constatado. Um outro teste é feito para verificar o FAR.
Nesse caso, um usuário intruso tenta obter acesso com a sua biometria. Caso ele
obtenha acesso, o erro FAR é constatado.
Após os testes, é feita um analise sobre a porcentagem de ocorrência dos
erros(FRR e FAR). Com a junção desses dois erros(FRR e FAR) podemos gerar um
novo valor conceitual (CER – Cross-Over Error Rate) para avaliar as técnicas
biométricas. A Figura 2 mostra as linhas dos erros.
A análise dos erros é a forma de validar uma técnica biométrica. Com os erros
podemos avaliar se o sistema está aceitando muitos usuários intrusos ou se ele está
bloqueando muitos usuários verídicos. Dessa forma podemos ajeitar o classificador até
21
que se tenha um valor considerável de erro, assim, não afetando o uso do sistema.
Podemos diminuir ou aumentar os erros, mas é impossível fazer com que não ocorra
nenhum erro. Isso seria um sistema ideal. O que podemos fazer é tentar achar um valor
ótimo para o tipo de aplicação que está se criando.
Figura 2 - Linhas dos erros de avaliação.
22
2.2 DINÂMICA DA DIGITAÇÃO
Jarmo Ilonen (2003) define dinâmica da digitação como uma biometria baseada na
suposição de que pessoas diferentes digitam de maneiras características. Nos seus
estudos, ele também relata que no século 19, os operadores de telégrafo já tinham
padrões de telegrafar, com isso, um operador reconhecia o outro. Isso caracteriza o
marco inicial da idéia de dinâmica da digitação.
Dinâmica da digitação se baseia no modo em que as pessoas digitam, ou seja, no
ritmo de digitação. Isto é, o comportamento de um ser humano diante a uma tarefa. Por
isso a dinâmica da digitação é uma técnica biométrica comportamental e não física.
Conforme Jarmo Ilonen (2003) há várias maneiras de medir a dinâmica da digitação
quando os usuários digitam em um teclado normal de um computador. Algumas das
maneiras são:
• O intervalo de tempo entre o pressionamento de teclas consecutivas;
• O tempo que uma tecla fica pressionada;
• O tempo total da digitação;
• A freqüência da digitação de teclas erradas;
• O hábito de usar teclas diferentes do teclado.
Revett et al. (2005) citado por Magalhães et al. (2005), concluiu que dividindo o
teclado de um computador em setores, reduz-se a taxa de sucesso de impostores (False
Acceptance Rate - FAR). As senhas que tem dígitos em cada setor forçam os usuários a
utilizarem teclas que estão dispersas pelo teclado, garantindo uma melhor captura do
ritmo de digitação dos usuários.
23
Além da forma de captura, tem também o processo de captura, ou seja, o
treinamento do classificador. Temos dois tipos de processos. Em um dos processos se
utiliza a digitação de um texto durante o treinamento [Curtin 2006]. No outro é utilizado a
própria senha cadastrada pelo usuário [Cho 2000].
Os tempos de digitação podem ser adquiridos através de um simples teclado de um
computador normal ou de um telefone. Cada sistema de autenticação tem seus próprios
meios de obter os tempos.
Pelo fato de não precisar de um equipamento dedicado, a técnica de dinâmica da
digitação tem um custo mais baixo dentre as técnicas biométricas. Esse custo baixo
beneficia muitos sistemas que necessitam de um nível médio de segurança, ou seja,
sistemas como: prontuário eletrônico ou qualquer outro tipo de sistemas de informação
que se encontra na Internet, os quais geralmente se utilizam o par de valores: nome de
usuário e senha.
De acordo com [Cavalcanti 2005], o ritmo de digitação dos usuários, podem ser
capturados a partir de duas diferentes medidas que contabilizam o tempo. Uma
contabiliza o tempo que os usuários mantêm cada tecla pressionada. A outra contabiliza
o intervalo de tempo entre uma tecla e outra que são consecutivamente pressionadas.
Essa diferença de capturas do ritmo é demonstrada na Figura 3, onde temos uma
seqüência de letras digitadas durante um espaço de tempo.
Após a captura do ritmo de digitação, os tempos formam um vetor, o qual
caracterizara o padrão do usuário para o sistema classificador. Esse vetor composto
pelos tempos tem um tamanho dependente da quantidade de teclas que foram
pressionadas. Com isso podemos formar uma equação onde, com n teclas pressionadas,
o tamanho do vetor ou a quantidade de tempos vai ser igual a 2n – 1. Por exemplo: uma
24
senha de seis dígitos formará um vetor composto por 11 tempos, sendo que, seis são
tempos de pressionamento de teclas e 5 são intervalos de tempos entre teclas
pressionadas consecutivamente.
Haider, Abbas e Zaidi (2000) em seus estudos utilizam a captura dos tempos de
pressionamento entre as teclas. O padrão de digitação do usuário foi formado por n-1
vetores, sendo n, o número de dígitos que compõe a senha. Cada vetor tem o tamanho
igual ao número de treinos realizados. Por exemplo: um padrão montado a partir de uma
senha de seis dígitos(1a2b3c) com a digitação repetida cinco vezes, seria formado por
cinco vetores e cada um com o tamanho cinco.
Figura 3 - Captura dos tempos da digitação.
Como qualquer processo de identificação através da biometria é dividido em duas
etapas: cadastro do usuário e autenticação do usuário cadastrado. A dinâmica da
digitação também é dividia nessas etapas.
25
No processo de cadastro, o sistema deve treinar o classificador que será utilizado
no processo de autenticação. O classificador depende de um conjunto de treinamento,
esse conjunto pode ser construído de diferentes maneiras. No caso da dinâmica da
digitação o conjunto pode ser construído através da digitação repetitiva de uma
seqüência de dígitos. Cada vez que se termina a digitação de uma seqüência, o vetor de
tempos é adicionado no conjunto de treinamento.
Já no processo de autenticação, o sistema deve receber o vetor de tempos e utilizar
o classificador, previamente gerado na etapa de treino, para classificar.
Como as técnicas biométricas são avaliadas conforme a medição dos erros: FAR,
FRR e CER. A dinâmica da digitação também deve ser analisada e validade a partir
desses erros.
A dinâmica de digitação tem os seus benefícios, mas também tem as suas
desvantagens. O principal benefício é a obtenção de algo mais seguro, mas com um
custo baixo. Como a dinâmica de digitação depende do comportamento do usuário, a
desvantagem vem de que o usuário sempre deve usar o mesmo comportamento. Isso
geralmente não acontece, pois nós seres humanos podemos mudar de comportamento a
qualquer momento em nossas vidas. Essa mudança geralmente é gradativa. Então, o
que se pode fazer para que a dinâmica de digitação não sofra com essa mudança, é a
implementação de um classificador que aprenda com essas mudanças.
26
2.3 TÉCNICAS DE CLASSIFICAÇÃO
Reconhecimento de Padrões (RP) é a ciência que estuda a classificação de objetos,
ou seja, qual quer coisa que possa ser classificada. Essa ciência é estudada juntamente
com Inteligência Artificial (IA). IA tem por objetivo estudar técnicas para que máquinas
como os computadores ou dispositivos que tenham como propriedades o processamento
e o armazenamento, possam ter a habilidade de aprendizagem, ou seja, fazer com que a
máquina tenha uma inteligência própria [McCarthy 2004].
Reconhecimento de Padrões também utilizam técnicas de medidas que servem
para mostrar o quão distante um padrão está de outro. Assim podendo unir essas
medidas para gerar uma função de similaridade entre os padrões.
Um exemplo de reconhecedor de padrões:
[...] O melhor reconhecedor de padrões em a maioria de exemplos são os seres humanos,
contudo nós não compreendemos como os seres humanos reconhecem padrões. (JAIN; ANIL,
DUIN; ROBERT, MAO; JIANCHANG, 2000, p. 1, tradução nossa).
Para a dinâmica da digitação o classificador deve distinguir entre usuários
autênticos e impostores. O tempo de treinamento do classificador é uma característica
importante, pois em sistemas WEB, esse tempo não deve ter um valor elevado.
Haider, Abbas e Zaidi (2000) em seus estudos utilizam a captura dos tempos de
pressionamento entre as teclas. O padrão de digitação do usuário foi formado por n-1
vetores, sendo n, o número de dígitos que compõe a senha. Também se trabalhou com
um classificador que utilizava três diferentes técnicas de reconhecimento de padrões:
lógica fuzzy, redes neurais e métodos estatísticos. As avaliações foram feitas sobre cada
técnica separadamente e sobre a união das três técnicas. Os testes mostraram que a
27
união das três técnicas no processo de classificação obteve um melhor resultado do que
a utilização de qualquer uma delas separadamente. Em relação à utilização em separado
a técnica que obteve o melhor resultado foi à baseada em métodos estatísticos. Foram
feitos dois testes, no primeiro a rejeição de acesso ao sistema na primeira tentativa de
ingresso do usuário era contabilizada como erro, no segundo teste os usuários tinham
duas chances de acesso. Os resultados mostraram que geralmente os usuários válidos
são rejeitados na primeira vez.
No trabalho de Cho (2000), foi desenvolvido um sistema para um ambiente Web, o
qual foi implementado com duas técnicas de classificação: medida de distância do vizinho
mais próximo e uma rede MLP (Multi Layer Perceptron). Os testes foram feitos com 21
usuários que tiveram um número de padrões de treinamento variando entre 76 a 388. Os
resultados apontaram por uma superioridade da rede MLP sobre a medida de distância.
Sendo que foi estabelecido índice de erro para falsa aceitação como 0,0% , a média do
erro para falsa rejeição no caso da MLP foi de 1,0% e da técnica do vizinho mais próximo
foi de 19,5%.
Cavalcanti (2005) mostrou em seu trabalho a típica extração do ritmo de digitação
do usuário. A técnica utilizada foi capturar os tempos de pressionamento de cada tecla e
o intervalo de tempo entre o pressionamento entre cada tecla. Também foi desenvolvido
um sistema que utiliza uma normalização e uma seleção baseada no desvio padrão das
características capturadas. Esses dois passos são feitos antes da aplicação de uma
medida de distância como classificador. . Os resultados mostraram que com o índice de
falsa aceitação igual a zero, o erro falsa rejeição atingiu 6,04% quando utilizadas a
normalização e a seleção. Já sem os dois passos o erro de falsa rejeição atingiu 30,99%.
28
2.3.1 K-NEAREST NEIGHBOR
O K-nn é um algoritmo de aprendizado supervisionado pertencente à área de
reconhecimento de padrões. O algoritmo necessita que os padrões estejam
representados na forma de objetos do espaço dimensional, ou seja, na forma de um vetor
de n dimensões.
O K-nn classifica os padrões através dos k vizinhos mais próximos do conjunto de
treinamento, ou seja, dado um padrão x, são encontrados os k padrões contidos no
conjunto de treinamento mais próximo de x. Diante disto, a classe mais freqüente dentre
os k padrões será atribuída ao padrão x. Para encontrar os k vizinhos mais próximos o
algoritmo utiliza uma técnica de medida de distância, neste caso, a distância euclidiana.
A Figura 4 demonstra essa classificação, sendo que, o ponto Xu é o padrão a ser
classificado e cada seta representa a ligação com os seus vizinhos mais próximos. Neste
caso, como a variável k foi atribuída com o valor 5, o algoritmo K-nn encontrou os cinco
pontos mais próximos de Xu. Sendo que dos 5 mais próximos, quatro pertencem a classe
dos padrões vermelhos e um pertence a classe dos verdes. O padrão Xu será
classificado como um ponto vermelho, pois ele se encontra mais perto dos vermelhos do
que dos demais.
29
Figura 4 - Um padrão Xu e seus vizinhos mais próximos.
A variável k deve ser bem selecionada, pois um k muito alto aumenta a
dissimilaridade entre os padrões, e um k muito pequeno pode fazer com a classificação
não seja confiável.
Para se classificar é preciso construir o classificador, o qual é construído com os
dados do treinamento. Isso torna o K-NN um algoritmo que precisa de uma grande
capacidade de armazenamento.
Para encontrar os k vizinhos mais próximos o algoritmo usa uma técnica de medida
de distância. Há diversas técnicas de medidas de distância, nesse trabalho será usada à
distância euclidiana, que pode ser obtida pela expressão:
30
onde:
DE = Distância Euclidiana.
xi = valor do primeiro ponto.
yi = valor do segundo ponto.
n = número de dimensões.
O fato de K-NN precisar de um tempo pequeno para o treinamento, faz dessa
técnica uma boa alternativa para sistemas WEB, como em nosso caso.
2.3.1 CENTRÓIDE
O centróide é uma forma de representar o ponto central de um conjunto de pontos.
Ou seja, o centróide é o padrão central de um conjunto de padrões representados num
espaço dimensional. A teoria do centróide vem do algoritmo de classificação Kmédias
[MacQueen 1967].
O cálculo do centróide é obtido através da média dos valores que compõe um
padrão. Por exemplo: um conjunto de padrões representado por dois pontos de duas
dimensões X = (x1, x2, x3) e Y = (y1, y2, y3). Então podemos obter o centróide C = (c1, c2,
c3), onde c1 = (x1 + y1)/2 e c2 = (x2 + y2)/2 e c3 = (x3 + y3)/2.
A partir do centróide podemos calcular o raio de uma circunferência que representa
o conjunto de padrões. O raio é obtido através do cálculo da distancia euclidiana entre o
centróide e os padrões que compõe o conjunto. Sendo o raio a distancia do padrão mais
afastado em relação ao centróide.
Com a circunferência podemos classificar um padrão X calculando a distancia entre
ele e o centróide. Se a distancia for menor ou igual ao raio. Então padrão é classificado
31
com pertencente ao conjunto de padrões. Se a distancia for maior que o raio o padrão é
classificado como não pertencente ao conjunto.
A Figura 5 mostra um exemplo de uma circunferência formada por um conjunto de
padrões. Sendo o ponto vermelho o centróide e a linha vermelha o raio da circunferência.
Na Figura 6 é mostrada a classificação de um padrão como não válido. Onde o
ponto amarelo está fora da circunferência. E na Figura 7 é mostrada a classificação de
um padrão como válido, pois se encontra dentro da circunferência.
Figura 5 – Circunferência com centróide e raio.
Figura 6 – Padrão classificado como não válido.
Figura 7 – Padrão classificado como válido.
32
3 DESENVOLVIMENTO
Neste capitulo será apresentado o desenvolvimento do trabalho proposto, levando
em consideração as tecnologias e ferramentas utilizadas e o processo de análise.
3.1 TECNOLOGIAS UTILIZADAS
Para a implementação do presente trabalho foi utilizado a linguagem de
programação orientada a objetos Java, principalmente pela necessidade de se utilizar um
Java applet. De acordo com [Cho 2000], o applet é a melhor tecnologia para ser utilizada,
por ter um baixo custo, ter um linguagem base orientada a objeto e ser multiplataforma.
Outra questão, é que para se capturar os tempos de digitação a partir do navegador é
necessário que a linguagem de implementação tenha uma boa biblioteca de captura de
eventos e outra de calculo de tempo. O applet tem as duas propriedades, pode-se tratar
facilmente os eventos gerados pelo teclado, selecionando as teclas que influenciam na
captura dos tempos. A Tabela 1 mostra uma comparação entre três diferentes
tecnologias conforme.
Para guardar as informações dos usuários cadastrados foi utilizado o banco de
dados postgreSQL. Mas para a conexão entre a aplicação e o banco de dados foi
utilizado um framework Java chamado Hibernate.
O Hibernate é um framework Java que faz a persistência dos objetos da aplicação
para o banco de dados. Ou seja, faz o mapeamento objeto-relacional(MOR). A utilização
do Hibernate torna a implementação mais rápida, pelo fato de abstrair as funções
necessárias para a comunicação com o banco de dados e por conter uma função que
33
cria automaticamente a base de dados. Essa criação automática é feita a partir do prévio
mapeamento das classes que devem ser persistidas.
Para fazer a comunicação entre o applet e o servidor, foi necessário o uso da
tecnologia RMI(Remote Method Invocation). RMI é uma tecnologia usada em aplicações
cliente-servidor. Ele tem como propriedade a invocação de métodos que se encontram na
aplicação servidor. Essa invocação é feita através de uma comunicação socket entre o
cliente e o servidor.
Todas as tecnologias utilizadas são licenciadas como software livre.
Tabela 1 - Comparativo entre as possíveis tecnologias para se utilizar na implementação da
dinâmica da digitação.
3.2 FERRAMENTAS UTILIZADAS
Para o desenvolvimento do trabalho foi utilizada a linguagem de programação Java
e o ambiente de desenvolvimento Eclipse. Para a criação dos diagramas das classes foi
utilizado o software Enterprise Architect.
34
3.2 PROCESSO DE ANÁLISE
O processo de análise se deu da seguinte forma: uma visão geral do sistema, a
arquitetura, o levantamento de requisitos, definição dos casos de uso e a criação dos
diagramas que representam as classes do sistema.
3.2.1 VISÃO GERAL DO SISTEMA
A dinâmica da digitação implementada a um portal WEB tem como vantagem dar
uma maior segurança para o acesso ao portal. O processo dessa implementação é
mostrado na Figura 8. O módulo de autenticação é dividido em dois processos separados
que são divididos em páginas separadas do portal.
Quando um novo usuário necessita cadastrar-se no sistema é necessário que ele
faça um treino, que nada mais é que, a digitação repetitiva da senha que ele mesmo
escolheu. Durante a fase de treino o usuário entra com um nome de usuário e escolhe
uma senha, que deve ser composta por 6 dígitos para o algoritmo K-nn. A digitação deve
ser repetida cinco vezes ou mais. A senha foi limitada em seis dígitos, porque o algoritmo
K-nn precisa que os padrões tenham a mesma quantidade de dimensões. Já para o
algoritmo do centróide a senha não é limitada. Após o treino o padrão de digitação e o
nome do usuário são armazenados no banco de dados.
Usuários que já são cadastrados no sistema devem ir para a tela de acesso. Sendo
necessário que o usuário entre com nome de usuário e a senha, mas a senha deve ser
digitada como foi previamente digitada na situação de treino. No acesso, após a captura
dos tempos na entrada da senha, o sistema procura o usuário no banco de dados e se o
35
usuário existir, então o sistema faz a classificação através da dinâmica de digitação. Se o
usuário for classificado como verdadeiro, então é liberado o acesso ao sistema para o
usuário, senão o sistema rejeita o usuário (Figura 8).
Figura 8 - Diagrama de atividades do sistema.
36
3.2.2 ALGORITMOS DE CLASSIFICAÇÃO
A idéia de desenvolver o algoritmo K-nn vem da tentativa de proporcionar uma
classificação a partir de um confronto entre os padrões treinados. Onde, todos os
padrões capturados de todos os usuários serviram de comparação para a classificação.
Isso faz como que o conjunto dos padrões ou descritor conceitual esteja na memória em
tempo de execução da classificação.
Para a utilização do algoritmo K-nn foi limitado o tamanho da senha em 6 dígitos
pelo fato de a medida de distância utilizada só aceitar padrões de mesma dimensão.
Com isso todos os padrões dos usuários são formados por um vetor de 11 tempos.
Foi analisando as restrições do algoritmo K-nn em relação à limitação do tamanho
da senha, que se iniciou o desenvolvimento do algoritmo do centróide, o qual não
necessita dos padrões de todos os usuários para a classificação. Sendo necessários
somente os padrões individuais de cada usuário.
3.2.2 ARQUITETURA
A Figura 6 demonstra a arquitetura do sistema. Como é um ambiente WEB, temos
uma situação de cliente-servidor, nessa situação temos o navegador na parte cliente, que
contem um applet, o qual se comunica com o servidor através do navegador e de uma
conexão remota com uma aplicação que é um servidor RMI. Esse servidor RMI faz a
conexão com o banco de dados.
37
Figura 9 - Arquitetura do sistema.
3.2.3 LEVANTAMENTO REQUISITOS
Para o projeto do sistema foi feito um levantamento de requisitos, os quais tem a
função de suprir as necessidades de um usuário ao utilizar um sistema de autenticação.
Foram levantados os seguintes requisitos:
Requisito 1: Durante o cadastro do usuário inserir as informações: nome de
usuário e senha, sendo que a senha deve ser repedida para uma
confirmação de igualdade.
Requisito 2: Durante o acesso ao sistema o usuário deve inserir as
informações: nome de usuário e senha, pré-cadastradas durante o cadastro
de usuário.
38
3.2.3 CASOS DE USO
Conforme as características do sistema, foram levantados os seguintes casos de
uso: Cadastrar Usuário e Validar Usuário.
Tabela 2 - Caso de Uso do Cadastrar Usuário.
Caso de Uso: Cadastrar Usuário
Atores
Todos os usuários do sistema.
Finalidade
Cadastrar o usuário no sistema e treinar o
classificador.
Visão Geral
O usuário preenche seus dados: nome e
senha, sendo que a sem ha deve ser
digitada repetidamente para a captura do
ritmo de digitação. Após o preenchimento
pressiona o botão “Treinar”.
Seqüência de eventos:
1. O usuário acessa a tela de treinamento
2. É exibido um formulário contendo o campo: “Nome de usuário” e os campos
para a digitação da senha
3. O usuário preenche o “Nome de usuário”
4. O usuário preenche os campos das senhas, sempre digitando a mesma
senha
5. O usuário pressiona o botão “Cadastrar”
6. Uma tela de confirmação é mostrada para o usuário.
39
Tabela 3 - Caso de Uso do Validar Usuário.
Caso de Uso: Validar Usuário
Atores
Todos os usuários do sistema.
Finalidade
Autenticar o usuário que pede acesso.
Visão Geral
O usuário preenche os campos nome de
usuário e senha e pressiona o botão
“Acessar”.
Seqüência de eventos:
1. O usuário vai para a tela de Acesso.
2. É exibida uma tela contendo dois campos: “Nome de usuário” e “senha”
3. O usuário preenche o campo “Nome de usuário”
4. O usuário preenche o campo “senha”
5. O usuário pressiona o botão “Acessar”
6. Uma tela de confirmação aparece para o usuário, mostrando se ele é um
usuário aceito ou rejeitado.
3.2.4 DIAGRAMA DE CLASSE
A partir dos casos de uso e considerando a arquitetura da aplicação, temos dois
diagramas de classe um para o cliente RMI e outro para o servidor RMI. A Figura 7 e a
Figura 8 mostram os diagramas.
40
Figura 10 - Diagrama de classes do módulo cliente.
41
Figura 11 - Diagrama de classe do módulo servidor.
42
4 IMPLEMENTAÇÃO
4.1 CONSIDERAÇÕES SOBRE A IMPLEMENTAÇÃO
O sistema é composto por duas telas applets e um servidor. Essa divisão foi feita
para tornar a aplicação mais leve, pois quando um applet é chamado pelo navegador,
todas as classes que ele utiliza é baixada para o computador onde ele foi chamado.
Também levamos em consideração a conexão com o banco de dados, que deve ser feita
no servidor e não no cliente.
Através da tecnologia RMI foi possível dividir a aplicação em cliente e servidor.
Sendo assim, foi construída uma interface que é implementada pela classe do servidor e
ao mesmo tempo essa interface tem uma associação com os clientes applets. Com a
utilização do RMI o cliente só troca informações leves com o servidor. Assim foi possível
que os clientes fossem implementados somente com funções de interface gráfica, sem
nenhuma função lógica. Toda a lógica e comunicação com o banco de dados são
responsabilidades do servidor.
As telas applets tiveram que ser compostas por um tratador de eventos, o qual trata
os eventos gerados pelo teclado, assim, inviabilizando a ocorrência de erros durante a
captura do ritmo de digitação de um usuário.
Para a utilização do algoritmo K-nn foi feito o tratamento da quantidade de digito
que a senha é composta, essa quantidade foi definida em 6 dígitos. Como os applets
fazem uma conexão com o servidor através do RMI, foi preciso que eles fossem
assinados digitalmente, pois essa é uma regra de segurança da Máquina Virtual Java.
43
O sistema foi desenvolvido em módulos, os quais são:
Applet cliente de acesso;
Applet cliente de treinamento;
Servidor.
4.1.1 APPLET CLIENTE DE ACESSO
O applet de acesso é uma tela com dois campos, um para o nome do usuário e o
outro para a senha. O campo da senha tem uma instancia do tratador de evento. Quando
o usuário preenche os campos e clica em acessar, o cliente chama o método classificar
que se encontra no servidor, levando como parâmetro o vetor dos tempos capturados,
nome de usuário e senha.
4.1.2 APPLET CLIENTE DE TREINAMENTO
O applet de treinamento é tela com um campo para o nome de usuário e outros
campos para a digitação repetida da senha. Cada campo de senha tem uma instancia do
tratador de evento. Quando o usuário pressiona o botão Enviar, o cliente chama o
método adicionar padrão que se encontra no servidor, levando como parâmetro os
vetores de tempos capturados, nome do usuário e senha.
44
4.1.3 SERVIDOR
O servidor é parte da aplicação que cuida do controle, da lógica e do modelo do
sistema. O controle é responsável por toda a aplicação servidor, deste a classificação de
um padrão, até a comunicação com o banco de dados. A lógica tem todas as classes e
métodos responsáveis pela classificação.
Já o modelo fica responsável por toda a
estrutura do mapeamento objeto relacional.
O servidor utiliza as tecnologias RMI e Hibernate, o RMI faz a comunicação com os
clientes applets e o Hibernate faz todo o mapeamento objeto relacional com o banco de
dados.
Ao iniciar o servidor, o descritor conceitual ou conjunto de padrões é trazido do
banco de dados para a memória. Assim deixando a aplicação mais leve durante a
execução. Principalmente no lado do cliente. Quando o cliente de treinamento faz uma
requisição, o servidor adiciona o novo padrão no descritor conceitual que está na
memória e também adiciona o novo padrão no banco de dados. Já no momento que um
cliente de acesso faz uma requisição, o servidor chama o método de classificação
utilizando o descritor conceitual que está na memória.
Para o servidor ser executado é necessário que uma aplicação chamada rmiregistry
esteja em execução. O rmiregistry é o serviço de nomes do RMI. Ele obtém e passa as
referencias dos objetos remotos. Com isso os clientes conseguem enxergar o servidor.
4.2 AVALIAÇÃO
45
Na avaliação do sistema e dos classificadores, K-nn e centróide, foi efetuado um
teste prático, no qual os usuários se cadastravam no sistema e depois tentavam obter o
acesso. Também foi pedido a eles que fizessem uma tentativa de acesso com o nome de
usuário e senha de um outro usuário cadastrado no sistema.
Para avaliar os algoritmos de classificação foram feitos dois testes, um como uma
entrada de cinco repetições no treinamento e outro com uma entrada de dez repetições
no treinamento.Também foi criado um teste com quinze repetições, mas só para o
sistema com o algoritmo do centróide. No caso do K-nn, para o treinamento com cinco
repetições foi atribuído o valor 5 (cinco) para o k do classificador, ou seja, o classificador
K-nn procurou os cinco padrões mais semelhantes. Já para o treinamento com dez
repetições foi atribuído o valor 10 (dez) para o k.
Para computar a avaliação, nas telas de aceitação e rejeição de acesso, foi
adicionado um formulário, o qual tinha a função de capturar as ocorrências dos erros
(FAR e FRR). Para isso era preciso saber se o usuário que foi rejeitado ou aceito era um
usuário válido ou um intruso tentando ter acesso. Cada usuário que tentava o acesso ao
sistema respondia o questionário do formulário. Se o usuário tentou o acesso como
intruso ele respondia a opção de tentativa como intruso. Para o caso da tentativa ser
como verídico ele respondia a opção de tentativa como verídico. Cada vez que um
usuário válido era rejeitado, um erro de falsa rejeição (FRR) era computado. Quando um
intruso era aceito pelo sistema, um erro de falsa aceitação (FAR) era computado.
Os testes foram feitos com um total de 20 (vinte) usuários e um total de 100 (cem)
tentativas, cada pessoa fez o seu cadastro nos sistemas, um com cinco, outro com dez e
um com quinze repetições da senha durante o treinamento. Depois, cada pessoa tinha
uma tentativa de acessar com o seu próprio usuário e outra tentativa de acessar com os
46
dados de outro usuário, ou seja, como um intruso. Em alguns casos ouve repetição
desse procedimento de acesso.
4.3 RESULTADOS
Com os resultados(FAR e FRR) capturados a partir dos testes foi gerada um
estatística que faz a comparação entre os algoritmos de classificação levando em
consideração as quantidades de repetições durante o treino.
As Tabelas 4 e 5 mostram as variáveis estatísticas e os resultados obtidos em cima
dos testes realizados com cada um dos algoritmos de classificação. A principal
comparação é feita sobre os valores de erros (FAR e FRR) e a quantidade de repetições
durante o treino. Nos outros valores temos a relação entre a quantidade de tentativas
como usuário verídico e como usuário intruso, onde dessas tentativas temos a
quantidade de falsa aceitação e falsa rejeição.
Tabela 4 - Resultados dos testes com o K-nn.
47
Tabela 5 - Resultados dos testes com o Centróide.
Na Figura 12 é mostrado um comparativo entre os erros do tipo FAR e FRR que
ocorreram durantes os testes com cinco e dez repetições utilizando o algoritmo K-nn.
Percebemos que entre os dois testes houve um aumento de 6% no valor do tipo de erro
FAR e um aumento de 4% no tipo de erro FRR. Isso demonstra que o aumento de
repetições durante o treinamento fez com que o sistema aceitasse mais usuários intrusos
e rejeitasse mais usuários verídicos.
Knn
35,00%
30,00%
30,00%
26,00%
25,00%
20,00%
16,00%
FAR
FRR
15,00%
10,00%
10,00%
5,00%
0,00%
5 repetições no treino
10 repetições no treino
Figura 12 – Diferença do erro FAR entre os testes de 5 e 10 repetições com o K-nn.
48
Já na Figura 13 é mostrado um comparativo entre os erros do tipo FAR e FRR que
ocorreram durantes os testes com cinco, dez e quinze repetições utilizando o algoritmo
do Centróide. Percebemos que entre os três testes houve um aumento do erro do FAR e
ao mesmo tempo uma diminuição do erro do tipo FRR. O índice FAR começou com 0%
no teste com cinco repetições, passou para 10% no teste com dez repetições e
aumentou ainda mais, atingindo 18% no teste com quinze repetições. Já o índice de FRR
começou com 30% no teste com cinco repetições, passou para 10% no teste com dez
repetições e atingiu 6% no teste com quinze repetições. Isso demonstra que o aumento
de repetições durante o treinamento fez com que o sistema aceitasse mais usuários
intrusos e rejeitasse menos usuários verídicos.
Centróide
35,00%
30,00%
30,00%
25,00%
18,00%
20,00%
15,00%
10,00%
FRR
10,00%
10,00%
5,00%
FAR
6,00%
0,00%
0,00%
5 repetições no
treino
10 repetições no
treino
15 repetições no
treino
Figura 13 - Diferença do erro FAR entre os testes de 5 e 10 repetições com o Centróide.
49
Na Figura 14 é mostrado um comparativo entre os erros do tipo FAR e FRR que
ocorreram durantes os testes com cinco repetições utilizando os dois algoritmos de
classificação. Percebe-se que o algoritmo do centróide teve um melhor índice do tipo
FAR do que K-nn. Já o índice do tipo FRR ficou pior com o centróide do que com o K-nn.
Isso demonstra que o algoritmo de centróide ficou mais preciso do que o K-nn, sendo que
a taxa de erro FAR diminuiu ao ponto ideal de 0% e ao mesmo tempo a taxa de FRR teve
um leve aumento de 4%.
5 repetições no treino
35,00%
30,00%
30,00%
26,00%
25,00%
20,00%
15,00%
FAR
FRR
10,00%
10,00%
5,00%
0,00%
0,00%
Knn
Centroíde
Figura 14 – Comparação entre os resultados dos classificadores no treino com 5 repetições.
Temos um comparativo entre os algoritmos de classificação que é mostrado na
Figura 15. Nota-se que tanto a taxa de erro FAR quanto a taxa FRR obtiveram um melhor
valor com a utilização do algoritmo do centróide em relação ao algoritmo K-nn. Isso
demonstra que o algoritmo do centróide obteve melhores resultados do que o algoritmo
K-nn quando se utilizou um treino com 10 repetições.
50
10 repetições no treino
35,00%
30,00%
30,00%
25,00%
20,00%
FAR
16,00%
FRR
15,00%
10,00% 10,00%
10,00%
5,00%
0,00%
Knn
Centroíde
Figura 15 - Comparação entre os resultados dos classificadores no treino com 10 repetições.
Durante os testes o sistema protótipo se comportou bem, mas um pouco pesado
durante a inicialização do applet na primeira vez. Já durante o processo de treinamento e
classificação não ouve uma demora considerável.
Como os testes foram feitos na maioria nas próprias máquinas dos usuários, em
alguns casos não se pode fazer o teste, por causa da incompatibilidade com as versões
entre o código compilado e a versão da máquina virtual Java que estava instalada ou
porque não tinha a máquina virtual instalada.
51
4.4 ANÁLISE
Com os resultados dos testes, ou seja, os valores de erros (FAR, FRR). Pôde-se
então começar o trabalho de análise. Tal análise foi feita levando em consideração
algumas questões:
Qual técnica de classificação é melhor técnica?
O que os usuários acharam da nova forma de autenticação?
A autenticação através da dinâmica da digitação teve sucesso?
4.4.1 TÉCNICAS DE CLASSIFICAÇÃO
As técnicas de classificação K-nn e centróide tiveram resultados bastante
diferentes. O classificador K-nn não obteve um desempenho esperado. Sendo que a
intenção de combater o padrão de um usuário com o outro era algo que limitava o
tamanho das senhas. Já o classificador utilizando o centróide obteve bons resultados.
Como também trouxe a vantagem de não limitar o tamanho da senha.
Com os resultados do K-nn, Pode-se observar que os testes com o sistema que
tinha um treinamento com cinco repetições obtiveram uma taxa menor de erro aos testes
que tinham treinamento com dez repetições. Isso pode ter ocorrido pelo fato de o valor do
K, no caso do treinamento com dez repetições, ser dez, com isso, abranger uma maior
área de vizinhança, assim podendo obter uma maior dissimilaridade entre os dez vizinhos
encontrados.
52
O algoritmo do centróide poderia ser utilizado em produção, sendo que um sistema
com cinco repetições durante o treino teria um alto nível de segurança. Pois não aceitaria
intruso. Mas teria uma grande taxa de rejeição de usuários verídicos.
Outra técnica poderia ser utilizada com o intuito de melhorar a calcificação do
usuário. Esse classificador poderia ser implementado com a característica de verificar
uma pequena mudança do padrão do usuário e aprender esse padrão.
4.4.2 OPINIÃO DOS USUÁRIOS
Alguns usuários ficaram incomodados durante o treinamento, pode-se notar que
durante o treinamento com cinco repetições não ouve tanta reclamação, mas durante o
treinamento com dez repetições ouve uma maior reclamação. Os usuários acharam um
pouco maçante repetir várias vezes à mesma coisa, ou seja, a senha.
Outros usuários tentaram testar o sistema digitando a senha de um modo no
treinamento e de outro modo no acesso, claro que nesses casos o sistema não aceitou.
Percebi que os usuários que não sabiam que era pelo tempo da digitação que o sistema
capturava o padrão, se saíram melhor durante os treinamentos e obtiveram uma melhor
aceitação pelo sistema, não ocorria erro de falsa rejeição(FRR).
Para diminuir a irritação do usuário utilizadores do sistema, a forma de treinamento
poderia ser melhorada. Sendo que, o cadastro do usuário ao sistema seria um cadastro
normal, onde o usuário repete a senha duas vezes. Entretanto, nas primeiras vezes que o
usuário fosse obter acesso ao sistema, automaticamente o ritmo de digitação do usuário
seria capturado, com isso, obtendo o conjunto de treino.
53
5 CONCLUSÃO
O estudo da dinâmica da digitação e outras técnicas biométricas mostram que a
técnica da dinâmica da digitação é uma técnica de custo baixo, mas que garante uma
elevação significativa nos níveis de segurança dos sistemas. Isso é fundamental para
sistemas que estão na Web. A cada dia mais sistemas estão sendo criados na Internet e
o sistema protótipo criado neste trabalho pode perfeitamente ser utilizado em produção,
pois a sua arquitetura garante um bom funcionamento.
Os resultados obtidos com a utilização do classificador K-nn não foram satisfatórios.
Já o classificador utilizando o centróide teve um resultado bom comparado com o K-nn e
trabalhos relacionados.
O sistema protótipo criado pode muito bem ser utilizado em produção, pois a sua
arquitetura garante um bom funcionamento.
Para trabalhos futuros é importante o desenvolvimento de um classificador que
venha a melhorar o processo de classificação. Esse classificador poderia ser
implementado com a característica de verificar uma pequena mudança temporal do
padrão do usuário e aprender essa mudança. Pode-se também, melhorar a etapa de
treinamento, sendo que, no lugar de treinar o usuário no cadastro, o treino seria realizado
durantes os primeiros acessos do usuário ao sistema.
Um classificador utilizando a distancia de Mahalanobis poderia ser implementado. O
algoritmo baseado Mahalanobis descreve melhor o espaço composto pelos padrões.
Sendo que, em vez de formar uma circunferência para descrever o comportamento dos
padrões, Mahalanobis formaria uma elipse.
54
REFERÊNCIAS
OBAIDAT, M. S.; SADOUN, B.; BOLLE, Ruud M.; PANKANTI, Sharath. Keystroke
dynamics based authentication. Biometrics: Personal Identification in Networked
Society. Springer, 1999. p. 213-231.
FAUNDEZ Z., M. Biometric security technology. Aerospace and Electronic Systems
Magazine, IEEE, v. 21, n. 6, p. 15-26, jun. 2006.
PHILLIPS, P.J.; MARTIN, A.; WILSON, C.L.; PRZYBOCKI, M. An introduction
evaluating biometric systems. Computer, IEEE, v. 33, n. 2, p. 56-63, feb. 2000.
MAGALHÃES, S. T.; REVETT, KENNETH; SANTOS, HENRIQUE M. D. Password
Secured Sites – Stepping Forward With Keystroke Dynamics. Proceedings of the
International Conference on Next Generation Web Services Practices, 2005.
ILONEN,
Jarmo.
Keystroke
Dynamics.
Disponível
em
<http://www.caslon.com.au/biometricsnote6.htm#keystroke.htm>. Acessado em 22 oct.
2006.
REVETT, K. and KHAN, A., 2005, Enhancing login compatible with those produced by
very expensive security using keystroke hardening and keyboard gridding, Proceedings
of the IADIS MCCSIS 2005.
CAVALCANTI, GEORGE D. C.; PINHEIRO, EGGO H. F.; CARVALHO, EDSON C. B. Um
sistema de verificação de identidade pessoal através de dinâmica da digitação. XXV
Congresso da Sociedade Brasileira de Computação, jul. 2005.
HAIDER, S.; ABBAS, A.; ZAIDI, A.K. A multi-technique approach for user identification
through keystroke dynamics. Systems, Man, and Cybernetics, 2000 IEEE International
Conference on, v. 2, p.1336-1341, oct. 2000.
CHO, SUNGZOON et al. Web based Keystroke Dynamics Identity Verification using
Neural Network. Journal of Organizational Computing and Electronic Commerce, v.
10, n. 4, p. 295-307, dec. 2000.
CURTIN MARY et al. Keystroke Biometric Recognition on Long-Text Input: A
Feasibility Study. International MultiConference of Engineers and Computer Scientists,
jun. 2006.
LAU, EDMOND et al. Enhanced User Authentication Through Keystroke Biometrics.
Massachusetts Institute of Technology, 09 dec. 2004.
55
JAIN; ANIL, DUIN; ROBERT, MAO; JIANCHANG. Statistical Pattern Recognition: A
Review. IEEE TRANSACTIONS ON PATTERN ANALYSIS AND MACHINE
INTELLIGENCE, Michigan, v.22, n.1, p.4-34, jan.2000.
RANDALL; WILSON, MARTINEZ; TONY. Reduction Techniques for Instance-Based
Learning Algorithms. Machine Learning, Utah, v.38, p.257-286, 2000.
McCarthy, John. What Is Artificial Intelligence?. Disponível em < [21]
http://wwwformal.stanford.edu/jmc/whatisai/whatisai.html >. Acessado em: 15 jan. 2007
MacQueen, J. B. Some Methods for classification and Analysis of Multivariate
Observations, Proceedings of 5-th Berkeley Symposium on Mathematical Statistics and
Probability, Berkeley, University of California Press, 1:281-297. 1967
56
ANEXO A – CÓDIGO FONTE DA APLICAÇÃO
Servidor.java
package rmi;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.List;
public interface Servidor extends Remote{
public void adicionaPadrao(List<Double> tempos) throws RemoteException;
public boolean classifica(List<Double> tempos) throws RemoteException;
public boolean usuarioExitente(String nome, String senha) throws RemoteException;
public void fechaSessaoComHibernate() throws RemoteException;
public void salvaUsuario() throws RemoteException;
public void criaCircunferencia() throws RemoteException;
public void atribuiNomeESenha(String nome, String senha) throws RemoteException;
}
AppletDeAcesso.java
package cliente.gui;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.MalformedURLException;
import java.net.URL;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
import cliente.observador.Observador;
import rmi.Servidor;
57
public class AppletDeAcesso extends JApplet implements ActionListener, Observador{
/**
*
*/
private static final long serialVersionUID = 1L;
private JLabel nomeLabel, senhaLabel, resultadoLabel;
private JTextField nomeField,senhaField, resultadoField;
private JButton fazAcesso;
private Container container;
private EventoDaSenha eventoDaSenha;
private Servidor servidor;
public void init(){
try {
SwingUtilities.invokeAndWait(new Runnable() {
public void run() {
criaGUI();
}
});
} catch (Exception e) {
e.printStackTrace();
System.err.println("Não foi possível criar a GUI");
}
System.out.println("iniciando... ");
}
private void criaGUI() {
try{
Registry registry = LocateRegistry.getRegistry("150.162.67.73",1500);
servidor = (Servidor) registry.lookup ("Servidor5");
System.out.println("Objeto controle instanciado");
}catch(RemoteException Re){
System.out.println(Re.getMessage());
}catch(NotBoundException NBe){
System.out.println(NBe.getMessage());
}
container = getContentPane();
container.setLayout( new FlowLayout());
nomeLabel = new JLabel( "Nome de usuário: ");
container.add(nomeLabel);
nomeField = new JTextField(10);
container.add(nomeField);
nomeField.addActionListener(this);
senhaLabel = new JLabel("senha: ");
container.add(senhaLabel);
58
senhaField = new JTextField(10);
container.add(senhaField);
eventoDaSenha = new EventoDaSenha(this);
senhaField.addKeyListener(eventoDaSenha);
fazAcesso = new JButton("Acessar");
fazAcesso.addActionListener(this);
container.add(fazAcesso);
}
public void start() {
System.out.println("começando... ");
}
public void stop() {
System.out.println("parando... ");
}
public void destroy() {
System.out.println("destroindo... ");
}
public void actionPerformed(ActionEvent e) {
if(nomeField.getText().length() == 0){
System.out.println("O campo nome deve ser preenchido.");
}
if(confereCampos()){
String nome = nomeField.getText();
String senha = senhaField.getText();
int estado = 0;
try {
if(servidor.usuarioExitente(nome, senha)){
if(!servidor.classifica(eventoDaSenha.getTemposDaDigitacao())){
estado = 2;
}
}else{
estado = 1;
}
System.out.println("classifica: "+estado);
servidor.fechaSessaoComHibernate();
mudarDePagina(estado);
} catch (RemoteException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
}
private boolean confereCampos() {
boolean retorno = true;
59
String mensagem="";
if((nomeField.getText().trim().length() < 1)){
mensagem = "\n-O campo nome deve ser preenchido.";
nomeField.requestFocus();
retorno = false;
}
if((senhaField.getText().trim().length() < 1)){
mensagem +="\n"+ "-O campo senha deve ser preenchido.";
if(retorno != false){
senhaField.requestFocus();
}
retorno = false;
}
if(!retorno){
JOptionPane.showMessageDialog(null,"ERRO: "+ mensagem,"ERRO",
JOptionPane.INFORMATION_MESSAGE );
}
return retorno;
}
private void mudarDePagina(int estado) {
String pagina="";
URL url;
switch (estado) {
case 0:
pagina =
"aceito.php?pagina=aceito&nomeDeUsuario="+nomeField.getText()+"&senha="+senhaField.getText();
break;
case 1:
pagina =
"usuarioInexistente.html?nomeDeUsuario="+nomeField.getText()+"&senha="+senhaField.getText();
break;
case 2:
pagina =
"rejeitado.php?pagina=rejeitado&nomeDeUsuario="+nomeField.getText()+"&senha="+senhaField.getText();
break;
default:
break;
}
try {
String documentString = getDocumentBase().toString();
if (documentString.endsWith("/")) {
url = new URL(getDocumentBase()+pagina);
getAppletContext().showDocument(url, "_top");
}
else {
url = new URL(getDocumentBase()+"/../"+pagina);
60
getAppletContext().showDocument(url, "_top");
}
}catch (Exception e) {
e.printStackTrace();
}
}
public void atualize(String mensagem) {
if(senhaField.hasFocus()){
JOptionPane.showMessageDialog(null,"ERRO: "+mensagem+"\n Por Favor redigite a
senha.","ERRO", JOptionPane.INFORMATION_MESSAGE );
senhaField.setText("");
senhaField.requestFocus();
eventoDaSenha = new EventoDaSenha(this);
senhaField.addKeyListener(eventoDaSenha);
}
}
}
AppletDeTreinamento.java
package cliente.gui;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.LinkedList;
import java.util.List;
import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
import rmi.Servidor;
import cliente.observador.Observador;
public class AppletDeTreinamento extends JApplet implements ActionListener, Observador{
/**
*
*/
private static final long serialVersionUID = 1L;
private static final int QUANTIDADE_DE_SENHAS = 5;
private JLabel nomeLabel, senhaLabel, resultadoLabel;
61
private JTextField nomeField;
private List<JTextField> listaDeTextField;
private JButton fazAcesso;
private Container container;
private List<EventoDaSenha> listaDeEventoDaSenha;
private Servidor servidor;
public void init(){
try {
SwingUtilities.invokeAndWait(new Runnable() {
public void run() {
criaGUI();
}
});
} catch (Exception e) {
System.err.println("Não foi possível criar a GUI");
e.printStackTrace();
}
System.out.println("iniciando... ");
}
private void criaGUI() {
try{
Registry registry = LocateRegistry.getRegistry("150.162.67.73",1500);
servidor = (Servidor) registry.lookup ("Servidor5");
System.out.println("Objeto controle instanciado");
}catch(RemoteException Re){
System.out.println(Re.getMessage());
}catch(NotBoundException NBe){
System.out.println(NBe.getMessage());
}
listaDeTextField = new LinkedList<JTextField>();
listaDeEventoDaSenha = new LinkedList<EventoDaSenha>();
container = getContentPane();
container.setLayout( new FlowLayout());
nomeLabel = new JLabel( "Nome de usuário: ");
container.add(nomeLabel);
nomeField = new JTextField(10);
container.add(nomeField);
nomeField.addActionListener(this);
senhaLabel = new JLabel("senha repetida: ");
container.add(senhaLabel);
for(int i=0; i < QUANTIDADE_DE_SENHAS; i++){
62
JTextField textField = new JTextField(10);
listaDeTextField.add(i, textField);
container.add(textField);
EventoDaSenha eventoDaSenha = new EventoDaSenha(this);
listaDeEventoDaSenha.add(i,eventoDaSenha);
textField.addKeyListener(eventoDaSenha);
}
fazAcesso = new JButton(" Enviar ");
fazAcesso.addActionListener(this);
container.add(fazAcesso);
}
public void start() {
System.out.println("começando... ");
}
public void stop() {
System.out.println("parando... ");
}
public void destroy() {
System.out.println("destruindo... ");
}
public void actionPerformed(ActionEvent e) {
if(confereCampos()){
String nome = nomeField.getText();
String senha = listaDeTextField.get(0).getText();
try {
servidor.atribuiNomeESenha(nome, senha);
for(EventoDaSenha eventoDaSenha : listaDeEventoDaSenha){
System.out.println("SAsadsa:
"+eventoDaSenha.getTemposDaDigitacao());
servidor.adicionaPadrao(eventoDaSenha.getTemposDaDigitacao());
}
servidor.criaCircunferencia();
servidor.salvaUsuario();
mudarDePagina("treinado.html");
} catch (RemoteException e1) {
mudarDePagina("erro.html");
e1.printStackTrace();
}
}
}
63
private boolean confereCampos() {
boolean retorno = true;
String mensagem="";
boolean erro = false;
if((nomeField.getText().trim().length() < 1)){
mensagem = "\n-O campo nome deve ser preenchido.";
nomeField.requestFocus();
retorno = false;
}
if(listaDeTextField.get(0).getText().trim().length() >= 1){
for(JTextField jTextField : listaDeTextField){
if(jTextField.getText().trim().length() < 1 ||
!listaDeTextField.get(0).getText().equals(jTextField.getText())){
erro = true;
}
}
}else{
erro = true;
}
if(erro){
mensagem +="\n"+"-Os 5 campos não comtem a mesma senha, por favor digite
novamente";
if(retorno != false){
listaDeTextField.get(0).requestFocus();
}
retorno = false;
limpaCamposDaSenha();
}
if(!retorno){
JOptionPane.showMessageDialog(null,"ERRO: "+ mensagem,"ERRO",
JOptionPane.INFORMATION_MESSAGE );
}
return retorno;
}
private void limpaCamposDaSenha() {
for(int i=0;i < QUANTIDADE_DE_SENHAS; i++){
listaDeTextField.get(i).setText("");
EventoDaSenha eventoDaSenha = new EventoDaSenha(this);
listaDeEventoDaSenha.set(i,eventoDaSenha);
listaDeTextField.get(i).addKeyListener(eventoDaSenha);
64
}
}
private void mudarDePagina(String pagina) {
URL url;
try {
String documentString = getDocumentBase().toString();
if (documentString.endsWith("/")) {
url = new URL(getDocumentBase()+pagina);
getAppletContext().showDocument(url, "_top");
}
else {
url = new URL(getDocumentBase()+"/../"+pagina);
getAppletContext().showDocument(url, "_top");
}
}catch (Exception e) {
e.printStackTrace();
}
}
public void atualize(String mensagem) {
for(int i=0;i < QUANTIDADE_DE_SENHAS; i++){
if(listaDeTextField.get(i).hasFocus()){
JOptionPane.showMessageDialog(null,"ERRO: "+mensagem+"\n Por Favor
redigite a senha.","ERRO", JOptionPane.INFORMATION_MESSAGE );
EventoDaSenha eventoDaSenha = new EventoDaSenha(this);
listaDeEventoDaSenha.set(i,eventoDaSenha);
listaDeTextField.get(i).addKeyListener(eventoDaSenha);
listaDeTextField.get(i).setText("");
//listaDeTextField.get(i).requestFocus();
}
}
}
}
EventoDaSenha.java
package cliente.gui;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.LinkedList;
import java.util.List;
import cliente.observador.Observador;
65
public class EventoDaSenha implements KeyListener {
private double tempoQuandoPressionar;
private double tempoQuandoSoltar;
private double tempoTemporario;
private List<Double> temposDaDigitacao;
private TratadorDeEventoPressionado tratadorDeEventoPressionado;
private TratadorDeEventoSolto tratadorDeEventoSolto;
public EventoDaSenha(Observador observador){
this.temposDaDigitacao = new LinkedList<Double>();
tratadorDeEventoPressionado = new TratadorDeEventoPressionado(this);
tratadorDeEventoPressionado.adicionarObservador(observador);
tratadorDeEventoSolto = new TratadorDeEventoSolto(this);
tratadorDeEventoSolto.adicionarObservador(observador);
}
public EventoDaSenha(List<Double> temposDaDigitacao, Observador observador){
this.temposDaDigitacao = temposDaDigitacao;
tratadorDeEventoPressionado = new TratadorDeEventoPressionado(this);
tratadorDeEventoPressionado.adicionarObservador(observador);
tratadorDeEventoSolto = new TratadorDeEventoSolto(this);
tratadorDeEventoSolto.adicionarObservador(observador);
}
public List<Double> getTemposDaDigitacao() {
return temposDaDigitacao;
}
public double getTempoQuandoPressionar() {
return tempoQuandoPressionar;
}
public void setTempoQuandoPressionar(double tempoQuandoPrecionar) {
this.tempoQuandoPressionar = tempoQuandoPrecionar;
}
public double getTempoQuandoSoltar() {
return tempoQuandoSoltar;
}
public void setTempoQuandoSoltar(double tempoQuandoSoltar) {
this.tempoQuandoSoltar = tempoQuandoSoltar;
}
public double getTempoTemporario() {
return tempoTemporario;
}
public void setTempoTemporario(double tempoTemporario) {
this.tempoTemporario = tempoTemporario;
}
public void setTemposDaDigitacao(List<Double> temposDaDigitacao) {
66
this.temposDaDigitacao = temposDaDigitacao;
}
public void keyPressed(KeyEvent key){
tratadorDeEventoPressionado.trataEvento(key);
//tempoQuandoPrecionar = System.nanoTime();
}
public void keyReleased(KeyEvent key) {
/*tempoQuandoSoltar = System.nanoTime();
double tempoEntrePrecionarESoltar = tempoQuandoSoltar - tempoQuandoPrecionar;
System.out.println("Tempo de precionar e soltar: "+tempoEntrePrecionarESoltar);
temposDaDigitacao.add(tempoEntrePrecionarESoltar);*/
tratadorDeEventoSolto.trataEvento(key);
}
public void keyTyped(KeyEvent key) {
}
}
TratadorDeEvento.java
package cliente.gui;
import java.awt.event.KeyEvent;
import cliente.observador.Observador;
import cliente.observador.Observavel;
public abstract class TratadorDeEvento implements Observavel{
protected EventoDaSenha eventoDaSenha;
protected Observador observador;
public TratadorDeEvento(EventoDaSenha eventoDaSenha) {
this.eventoDaSenha = eventoDaSenha;
}
public void trataEvento(KeyEvent evento){
switch (evento.getKeyCode()) {
case KeyEvent.VK_BACK_SPACE:
trataBackSpace();
break;
67
case KeyEvent.VK_ENTER:
trataEnter();
break;
case KeyEvent.KEY_LOCATION_STANDARD:
trataBackSpace();
break;
default:
trataOResto(evento);
break;
}
}
private void trataOResto(KeyEvent evento) {
char c = evento.getKeyChar();
if(Character.isLetterOrDigit(c)){
calculaOsTempos();
}
}
protected abstract void calculaOsTempos();
protected abstract void trataEnter();
protected abstract void trataBackSpace();
}
TratadorDeEventoPressionado.java
package cliente.gui;
import cliente.observador.Observador;
public class TratadorDeEventoPressionado extends TratadorDeEvento{
public TratadorDeEventoPressionado(EventoDaSenha eventoDaSenha) {
super(eventoDaSenha);
}
@Override
protected void calculaOsTempos() {
double tempoEntreUmaTeclaEOutra;
eventoDaSenha.setTempoTemporario(eventoDaSenha.getTempoQuandoPressionar());
eventoDaSenha.setTempoQuandoPressionar(System.nanoTime());
System.out.println(eventoDaSenha.getTempoQuandoPressionar());
if(eventoDaSenha.getTempoTemporario() != 0){
tempoEntreUmaTeclaEOutra = eventoDaSenha.getTempoQuandoPressionar() eventoDaSenha.getTempoTemporario();
68
eventoDaSenha.getTemposDaDigitacao().add(tempoEntreUmaTeclaEOutra);
}
}
@Override
protected void trataBackSpace() {
notificaObservadores("tecla backspace pressionada");
}
@Override
protected void trataEnter() {
notificaObservadores("tecla enter pressionada");
}
public void adicionarObservador(Observador observador) {
super.observador = observador;
}
public void notificaObservadores(String mensagem) {
super.observador.atualize(mensagem);
}
}
TratadorDeEventoSolto.java
package cliente.gui;
import cliente.observador.Observador;
public class TratadorDeEventoSolto extends TratadorDeEvento{
public TratadorDeEventoSolto(EventoDaSenha eventoDaSenha) {
super(eventoDaSenha);
}
@Override
protected void calculaOsTempos() {
eventoDaSenha.setTempoQuandoSoltar(System.nanoTime());
System.out.println(eventoDaSenha.getTempoQuandoSoltar());
double tempoEntrePrecionarESoltar = eventoDaSenha.getTempoQuandoSoltar() eventoDaSenha.getTempoQuandoPressionar();
System.out.println(tempoEntrePrecionarESoltar);
eventoDaSenha.getTemposDaDigitacao().add(tempoEntrePrecionarESoltar);
}
@Override
protected void trataBackSpace() {
//notificaObservadores("tecla backspace pressionada");
}
@Override
protected void trataEnter() {
//notificaObservadores("tecla enter pressionada");
69
}
public void adicionarObservador(Observador observador) {
super.observador = observador;
}
public void notificaObservadores(String mensagem) {
super.observador.atualize(mensagem);
}
}
Observador.java
package cliente.observador;
public interface Observador {
public void atualize(String mensagem);
}
Observável.java
package cliente.observador;
public interface Observavel {
public void adicionarObservador(Observador observador);
public void notificaObservadores(String mensagem);
}
Controle.java
package servidor.controle;
import java.io.Serializable;
import java.util.List;
import servidor.logica.Usuario;
import servidor.logica.classificacao.PertencenteACircunferencia;
import servidor.logica.metricas.Distancia;
import servidor.logica.metricas.DistanciaEuclidiana;
import servidor.logica.padrao.Padrao;
import servidor.modelo.Dao;
import servidor.modelo.DaoFactory;
public class Controle implements Serializable{
70
private Distancia distancia;
private Usuario usuario;
private PertencenteACircunferencia pertencenteACircunferencia;
private DaoFactory daoFactory;
public Controle(){
this.usuario = new Usuario();
this.distancia = new DistanciaEuclidiana();
this.pertencenteACircunferencia = new
PertencenteACircunferencia(distancia,usuario.getCircunferencia());
}
public void adicionaPadrao(List<Double> tempos){
Padrao padrao = new Padrao(tempos);
usuario.getCircunferencia().getPadroes().add(padrao);
}
public boolean classifica(List<Double> tempos){
Padrao padraoASerClassificado = new Padrao(tempos);
return pertencenteACircunferencia.classifica(padraoASerClassificado);
}
public void atribuiNomeESenha(String nome, String senha){
this.usuario = new Usuario();
this.distancia = new DistanciaEuclidiana();
this.pertencenteACircunferencia = new
PertencenteACircunferencia(distancia,usuario.getCircunferencia());
usuario.setNome(nome);
usuario.setSenha(senha);
}
public void criaCircunferencia(){
usuario.getCircunferencia().calculaCentroide();
usuario.getCircunferencia().calculaRaio(distancia);
}
public void salvaUsuario(){
try {
if(daoFactory == null){
this.daoFactory = new DaoFactory();
}
Dao<Usuario> usuarioDAO = daoFactory.getUsuarioDao();
usuarioDAO.adiciona(usuario);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private void selecionaUsuario(String nome, String senha){
try {
if(daoFactory == null){
71
this.daoFactory = new DaoFactory();
}
Dao<Usuario> usuarioDAO = daoFactory.getUsuarioDao();
this.usuario = usuarioDAO.procura(nome, senha);
if(usuario != null){
this.pertencenteACircunferencia = new
PertencenteACircunferencia(distancia,usuario.getCircunferencia());
}
} catch (Exception e) {
e.printStackTrace();
}
}
public boolean usuarioExitente(String nome, String senha){
boolean condicao = false;
this.selecionaUsuario(nome, senha);
if(this.usuario != null){
condicao = true;
}
System.out.println("usuário exixtente: "+condicao);
return condicao;
}
public void fechaSessaoComHibernate(){
if(daoFactory.hasTransaction()){
daoFactory.close();
}
}
}
NearestNeighbour.java
package servidor.logica.classificacao;
import java.util.List;
import servidor.logica.metricas.Distancia;
import servidor.logica.padrao.Classe;
import servidor.logica.padrao.Padrao;
public class NearestNeighbour implements Classificacao{
private List<Padrao> conjuntoDePadroes;
private Padrao padraoASerClassificado;
private Distancia metrica;
private double melhorDistancia;
public NearestNeighbour(Distancia metrica,List<Padrao> conjuntoDePadroes){
this.conjuntoDePadroes = conjuntoDePadroes;
this.metrica = metrica;
72
}
public void classifica(){
Padrao padraoMaisPerto = new Padrao();
double distanciaMelhor = java.lang.Double.MAX_VALUE;
double distanciaProx = 0;
metrica.setPadrao2(padraoASerClassificado);
for(Padrao p : conjuntoDePadroes){
metrica.setPadrao1(p);
distanciaProx = metrica.calcula();
if(distanciaProx < distanciaMelhor){
padraoMaisPerto = p;
distanciaMelhor = distanciaProx;
}
}
Classe classe = padraoMaisPerto.getClasse();
padraoASerClassificado.setClasse(classe);
setMelhorDistancia(distanciaMelhor);
}
public List<Padrao> getConjuntoDePadroes() {
return conjuntoDePadroes;
}
public void setConjuntoDePadroes(List<Padrao> conjuntoDePadroes) {
this.conjuntoDePadroes = conjuntoDePadroes;
}
public Padrao getPadraoASerClassificado() {
return padraoASerClassificado;
}
public void setPadraoASerClassificado(Padrao pontoASerClassificado) {
this.padraoASerClassificado = pontoASerClassificado;
}
public Distancia getMetrica() {
return metrica;
}
public void setMetrica(Distancia metrica) {
this.metrica = metrica;
73
}
public void adicionarPadraoAoConjunto(Padrao p){
conjuntoDePadroes.add(p);
}
public double getMelhorDistancia() {
return melhorDistancia;
}
public void setMelhorDistancia(double melhorDistancia) {
this.melhorDistancia = melhorDistancia;
}
}
KnearestNeighbour.java
package servidor.logica.classificacao;
import java.io.Serializable;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import servidor.logica.metricas.Distancia;
import servidor.logica.padrao.Classe;
import servidor.logica.padrao.Padrao;
public class KnearestNeighbour implements Classificacao, Serializable {
private List<Padrao> conjuntoDePadroes;
private Padrao padraoASerClassificado;
private Distancia metrica;
private int k;
public KnearestNeighbour(Distancia metrica,List<Padrao> conjuntoDePontos, int k){
this.conjuntoDePadroes = conjuntoDePontos;
this.metrica = metrica;
this.k = k;
}
private List<AssociacaoPadraoDistancia> geraListaDosMaisProximos(){
List<AssociacaoPadraoDistancia> listaDePadroesMaisProximos = new
LinkedList<AssociacaoPadraoDistancia>();
int tamanhoDaLista = k;
boolean adicionado;
double distanciaDoP = 0;
int i = 0;
74
metrica.setPadrao2(padraoASerClassificado);
for(Padrao p : conjuntoDePadroes){
metrica.setPadrao1(p);
distanciaDoP = metrica.calcula();
if(listaDePadroesMaisProximos.isEmpty()){
AssociacaoPadraoDistancia a = new
AssociacaoPadraoDistancia(p,distanciaDoP);
listaDePadroesMaisProximos.add(a);
}else{
i=0;
adicionado = false;
while(i < listaDePadroesMaisProximos.size()){
if(distanciaDoP <
listaDePadroesMaisProximos.get(i).getDistancia() && (listaDePadroesMaisProximos.size() <= tamanhoDaLista)){
AssociacaoPadraoDistancia a = new
AssociacaoPadraoDistancia(p,distanciaDoP);
listaDePadroesMaisProximos.add(i,a);
i=tamanhoDaLista;
adicionado = true;
}
i++;
}
if(listaDePadroesMaisProximos.size() <= tamanhoDaLista){
if(!adicionado){
AssociacaoPadraoDistancia a = new
AssociacaoPadraoDistancia(p,distanciaDoP);
listaDePadroesMaisProximos.add(a);
}
}
if(listaDePadroesMaisProximos.size() > tamanhoDaLista)
listaDePadroesMaisProximos.remove(tamanhoDaLista);
}
}
return listaDePadroesMaisProximos;
}
public void classifica(){
classifica(geraListaDosMaisProximos());
}
private void classifica(List<AssociacaoPadraoDistancia> listaDePadraosMaisProximos) {
HashMap<Classe,Integer> hash = new HashMap<Classe,Integer>();
Classe classeDeMaiorOcorrencia = null;
75
int aux = 0;
for(AssociacaoPadraoDistancia associacao : listaDePadraosMaisProximos){
if (hash.containsKey(associacao.getPadrao().getClasse())){
int incremento = hash.get(associacao.getPadrao().getClasse());
incremento++;
hash.put(associacao.getPadrao().getClasse(),incremento);
} else {
hash.put(associacao.getPadrao().getClasse(),1);
}
}
Set<Classe> set = hash.keySet();
for (Classe c : set){
if (hash.get(c) > aux){
aux = hash.get(c);
classeDeMaiorOcorrencia = c;
}
}
padraoASerClassificado.setClasse(classeDeMaiorOcorrencia);
}
public List<Padrao> getConjuntoDePadroes() {
return conjuntoDePadroes;
}
public void setConjuntoDePadroes(List<Padrao> conjuntoDePadraos) {
this.conjuntoDePadroes = conjuntoDePadraos;
}
public int getK() {
return k;
}
public void setK(int k) {
this.k = k;
}
public Distancia getMetrica() {
return metrica;
}
public void setMetrica(Distancia metrica) {
this.metrica = metrica;
}
public Padrao getPadraoASerClassificado() {
return padraoASerClassificado;
}
public void setPadraoASerClassificado(Padrao padraoASerClassificado) {
this.padraoASerClassificado = padraoASerClassificado;
}
76
public void adicionarPadraoAoConjunto(Padrao p){
conjuntoDePadroes.add(p);
}
}
Classificacao.java
package servidor.logica.classificacao;
import java.util.List;
import servidor.logica.metricas.Distancia;
import servidor.logica.padrao.Padrao;
public interface Classificacao {
public void classifica();
public List<Padrao> getConjuntoDePadroes();
public void setConjuntoDePadroes(List<Padrao> conjuntoDePadroes);
public Padrao getPadraoASerClassificado();
public void setPadraoASerClassificado(Padrao pontoASerClassificado);
public Distancia getMetrica();
public void setMetrica(Distancia metrica);
public void adicionarPadraoAoConjunto(Padrao p);
}
AssociacaoPadraoDistancia.java
package servidor.logica.classificacao;
import servidor.logica.padrao.Padrao;
public class AssociacaoPadraoDistancia {
private Padrao padrao;
private double distancia;
public AssociacaoPadraoDistancia(Padrao padrao,double distancia){
this.padrao = padrao;
this.distancia = distancia;
}
public Padrao getPadrao() {
return padrao;
77
}
public void setPadrao(Padrao padrao) {
this.padrao = padrao;
}
public double getDistancia() {
return distancia;
}
public void setDistancia(double distancia) {
this.distancia = distancia;
}
}
Circunferencia.java
package servidor.logica.agrupamento;
import java.util.LinkedList;
import java.util.List;
import servidor.logica.metricas.Distancia;
import servidor.logica.padrao.Padrao;
public class Circunferencia {
private List<Padrao> padroes;
private Padrao centroide;
private double raio;
public Circunferencia(){
this.padroes = new LinkedList<Padrao>();
centroide = new Padrao();
}
public Circunferencia(List<Padrao> padroes){
this.padroes = padroes;
centroide = new Padrao();
}
public Padrao getCentroide() {
return centroide;
}
public void setCentroide(Padrao centroide) {
this.centroide = centroide;
}
public List<Padrao> getPadroes() {
return padroes;
}
public void setPadroes(List<Padrao> padroes) {
this.padroes = padroes;
78
}
public double getRaio() {
return raio;
}
public void setRaio(double raio) {
this.raio = raio;
}
public void calculaCentroide(){
for(int i =0; i< padroes.get(0).getValoresDoPadrao().size(); i++){
centroide.getValoresDoPadrao().add(i, null);
for(Padrao padrao : padroes){
if(centroide.getValoresDoPadrao().get(i) == null){
centroide.getValoresDoPadrao().set(i,padrao.getValoresDoPadrao().get(i));
}else{
centroide.getValoresDoPadrao().set(i,
centroide.getValoresDoPadrao().get(i) + padrao.getValoresDoPadrao().get(i));
}
}
centroide.getValoresDoPadrao().set(i,
centroide.getValoresDoPadrao().get(i)/padroes.size());
}
}
public void calculaRaio(Distancia distancia){
double distanciaMaior = java.lang.Double.MIN_VALUE;
double distanciaAux =0d;
distancia.setPadrao1(centroide);
for(Padrao padrao : padroes){
distancia.setPadrao2(padrao);
distanciaAux = distancia.calcula();
if(distanciaMaior < distanciaAux){
distanciaMaior = distanciaAux;
}
}
this.raio = distanciaMaior;
}
}
PertencenteACircunferencia.java
package servidor.logica.classificacao;
import servidor.logica.agrupamento.Circunferencia;
import servidor.logica.metricas.Distancia;
79
import servidor.logica.padrao.Padrao;
public class PertencenteACircunferencia{
private Distancia metrica;
private Circunferencia circunferencia;
public PertencenteACircunferencia(Distancia metrica){
this.metrica = metrica;
}
public PertencenteACircunferencia(Distancia metrica, Circunferencia circunferencia){
this.metrica = metrica;
this.circunferencia = circunferencia;
}
public boolean classifica(Padrao padraoASerClassificado){
boolean retorno = false;
double distancia = 0d;
metrica.setPadrao1(circunferencia.getCentroide());
metrica.setPadrao2(padraoASerClassificado);
distancia = metrica.calcula();
double novoRaio = circunferencia.getRaio();
System.out.println("distancia: "+distancia);
System.out.println("raio: "+circunferencia.getRaio());
System.out.println("novo raio: "+novoRaio);
if(distancia <= novoRaio){
retorno = true; //aceito
}else{
retorno = false; //rejeitado
}
return retorno;
}
public Distancia getDistancia() {
return metrica;
}
public void setDistancia(Distancia distancia) {
this.metrica = distancia;
}
}
Distancia.java
package servidor.logica.metricas;
import servidor.logica.padrao.Padrao;
public interface Distancia {
80
public double calcula();
public Padrao getPadrao1();
public void setPadrao1(Padrao padrao1);
public Padrao getPadrao2();
public void setPadrao2(Padrao adrao2);
}
DistanciaEuclidiana.java
package servidor.logica.metricas;
import java.io.Serializable;
import java.util.List;
import servidor.logica.padrao.Padrao;
public class DistanciaEuclidiana implements Distancia, Serializable {
private Padrao padrao1;
private Padrao padrao2;
public DistanciaEuclidiana(Padrao padrao1, Padrao padrao2){
this.padrao1 = padrao1;
this.padrao2 = padrao2;
}
public DistanciaEuclidiana() {
}
public double calcula() {
double resultado = 0;
double valorParcial;
List<Double> valoresDoPadrao1 = padrao1.getValoresDoPadrao();
List<Double> valoresDoPadrao2 = padrao2.getValoresDoPadrao();
for(int i = 0;i < valoresDoPadrao1.size();i++){
valorParcial = Math.pow((valoresDoPadrao1.get(i) - valoresDoPadrao2.get(i)),2);
81
resultado += valorParcial;
}
return Math.sqrt(resultado);
}
public Padrao getPadrao1() {
return padrao1;
}
public void setPadrao1(Padrao padrao1) {
this.padrao1 = padrao1;
}
public Padrao getPadrao2() {
return padrao2;
}
public void setPadrao2(Padrao padrao2) {
this.padrao2 = padrao2;
}
}
Padrao.java
package servidor.logica.padrao;
import java.io.Serializable;
import java.util.LinkedList;
import java.util.List;
public class Padrao implements Serializable{
private Long id;
private List<Double> valoresDoPadrao;
public Padrao(){
this.valoresDoPadrao = new LinkedList<Double>();
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Padrao(List<Double> valoresDoPadrao){
this.valoresDoPadrao = valoresDoPadrao;
}
82
public List<Double> getValoresDoPadrao() {
return valoresDoPadrao;
}
public void setValoresDoPadrao(List<Double> valoresDoPadrao) {
this.valoresDoPadrao = valoresDoPadrao;
}
}
Usuário.java
package servidor.logica;
import servidor.logica.agrupamento.Circunferencia;
public class Usuario {
private Long id;
private Circunferencia circunferencia;
private String nome;
private String senha;
public Usuario(){
circunferencia = new Circunferencia();
}
public Circunferencia getCircunferencia() {
return circunferencia;
}
public void setCircunferencia(Circunferencia circunferencia) {
this.circunferencia = circunferencia;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getSenha() {
return senha;
}
public void setSenha(String senha) {
this.senha = senha;
}
}
83
Dao.java
package servidor.modelo;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
public class Dao<T>{
protected final Session session;
private final Class classe;
public Dao(Session session, Class classe) {
this.session = session;
this.classe = classe;
}
protected Session getSession(){
return this.session;
}
public void adiciona(T u){
Transaction t = session.beginTransaction();
session.save(u);
t.commit();
}
public List<T> listaTudo() {
return this.session.createCriteria(this.classe).list();
}
public T procura(Long id) {
return (T) session.load(this.classe, id);
}
public T procura(String nome, String senha) {
Query query = session.createQuery("from Usuario u where u.nome = :usuarioNome and u.senha =
:usuarioSenha");
query.setString("usuarioNome", nome);
query.setString("usuarioSenha", senha);
return (T) query.uniqueResult();
}
public void remove(T u) {
Transaction t = session.beginTransaction();
session.delete(u);
t.commit();
}
public void atualiza(T u) {
Transaction t = session.beginTransaction();
session.merge(u);
84
t.commit();
}
}
DaoFactory.java
package servidor.modelo;
import org.hibernate.Session;
import org.hibernate.Transaction;
import servidor.logica.Usuario;
public class DaoFactory {
private final Session session;
private Transaction transaction;
private Dao<Usuario> daoUsuario;
public DaoFactory() {
session = HibernateUtil.getSession();
}
public void beginTransaction() {
this.transaction = session.beginTransaction();
}
public void commit() {
this.transaction.commit();
this.transaction = null;
}
public boolean hasTransaction() {
return this.transaction != null;
}
public void rollback() {
this.transaction.rollback();
this.transaction = null;
}
public void close() {
this.session.close();
}
public Dao<Usuario> getUsuarioDao() {
return daoUsuario = new Dao<Usuario>(this.session, Usuario.class);
}
}
85
ServidorImpl.java
package servidor;
import java.io.IOException;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import rmi.Servidor;
import servidor.controle.Controle;
import servidor.logica.padrao.Padrao;
public class ServidorImpl implements Servidor{
private Controle controle;
public ServidorImpl(){
controle = new Controle();
inicia();
}
public void adicionaPadrao(List<Double> tempos) throws RemoteException {
controle.adicionaPadrao(tempos);
}
public boolean classifica(List<Double> tempos) throws RemoteException {
return controle.classifica(tempos);
}
public void salvaUsuario() throws RemoteException {
controle.salvaUsuario();
}
public boolean usuarioExitente(String nome, String senha) throws RemoteException {
return controle.usuarioExitente(nome, senha);
}
public void fechaSessaoComHibernate() throws RemoteException {
controle.fechaSessaoComHibernate();
}
public void criaCircunferencia() throws RemoteException {
controle.criaCircunferencia();
}
public void atribuiNomeESenha(String nome, String senha) throws RemoteException {
controle.atribuiNomeESenha(nome, senha);
86
}
public void inicia(){
try{
Servidor stub = (Servidor) UnicastRemoteObject.exportObject (this, 2500);
LocateRegistry.createRegistry(2500);
Registry registry = LocateRegistry.getRegistry(2500);
registry.bind ("Servidor15", stub);
System.out.println ("Servidor 15 iniciado?");
}catch(RemoteException Re){
System.out.println(Re.getMessage());
}catch(AlreadyBoundException ABe){
System.out.println(ABe.getMessage());
}catch(IOException IOe){
System.out.println(IOe.getMessage());
}
}
public static void main(String args[]){
new ServidorImpl ();
}
}
hibernate.cfg.xml
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- Database connection settings -->
<property name="connection.driver_class">org.postgresql.Driver</property>
<property name="connection.url">jdbc:postgresql://150.162.67.6/rodrigo4</property>
<property name="connection.username">pgsql</property>
<property name="connection.password"></property>
<!-- SQL dialect -->
<property name="dialect">org.hibernate.dialect.PostgreSQLDialect</property>
<!-- Echo all executed SQL to stdout -->
<property name="show_sql">true</property>
<!-- Drop and re-create the database schema on startup -->
87
<!--property name="hbm2ddl.auto">create</property-->
<mapping resource="servidor/modelo/Usuario.hbm.xml"/>
<mapping resource="servidor/modelo/Padrao.hbm.xml"/>
</session-factory>
</hibernate-configuration>
HibernateUtil.java
package servidor.modelo;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtil {
private static SessionFactory factory;
static {
Configuration conf = new Configuration();
conf.configure();
factory = conf.buildSessionFactory();
}
public static Session getSession() {
return factory.openSession();
}
}
Circunferencia.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="servidor.logica.agrupamento.Circunferencia" table="circunferencia">
<id name="id"
column="id">
<generator class="foreign">
<param name="property">usuario</param>
</generator>
</id>
<property name="raio" type="double"/>
88
<one-to-one
name="centroide"
class="servidor.logica.padrao.Centroide" cascade="none" outer-join="auto"
constrained="true"/>
<one-to-one
name="usuario"
class="servidor.logica.Usuario" cascade="none" outer-join="auto" constrained="true"/>
<list name="padroes"
table="padroes" cascade="all">
<key column="idCircunferencia"/>
<index column="posn"/>
<one-to-many class="servidor.logica.padrao.Padrao" />
</list>
</class>
</hibernate-mapping>
Padrao.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="servidor.logica.padrao.Padrao" table="padrao">
<id name="id">
<column name="id" not-null="true"/>
<generator class="native" />
</id>
<list name="valoresDoPadrao"
table="valoresdopadrao" cascade="all">
<key column="idpadrao"/>
<index column="posn"/>
<element column="valoresdopadrao" type="double" />
</list>
</class>
</hibernate-mapping>
89
Usuario.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="servidor.logica.Usuario" table="usuario">
<id name="id">
<column name="id" not-null="true"/>
<generator class="native" />
</id>
<property name="nome" type="string"/>
<property name="senha" type="string"/>
<component name="circunferencia" class="servidor.logica.agrupamento.Circunferencia">
<property name="raio" type="double"/>
<list name="padroes"
table="padroes" cascade="all">
<key column="idCircunferencia"/>
<index column="posn"/>
<one-to-many class="servidor.logica.padrao.Padrao" />
</list>
<component name="centroide" class="servidor.logica.padrao.Padrao">
<list name="valoresDoPadrao"
table="valoresdocentroide" cascade="all">
<key column="idpadrao"/>
<index column="posn"/>
<element column="valoresdocentroide" type="double" />
</list>
</component>
</component>
</class>
</hibernate-mapping>
90
log4j.properties
#aqui esta a configuração para o log do hibernate
log4j.appender.hibernate=org.apache.log4j.FileAppender
log4j.appender.hibernate.File=hibernate.log
log4j.appender.hibernate.layout=org.apache.log4j.PatternLayout
log4j.appender.hibernate.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
#aponta os niveis de log para os pacotes específicos
log4j.rootLogger=fatal, hibernate
log4j.logger.org.hibernate=debug, hibernate
91
ANEXO B - ARTIGO
Dinâmica da Digitação Aplicada a Ambientes Web
Rodrigo Pavezi1, Douglas Dyllon J. de Macedo1,2, Rafael Andrade1,2,
Aldo von Wangenheim1
1
Departamento de Informática e Estatística – INE – Cyclops Group
Universidade Federal de Santa Catarina (UFSC) – Florianópolis, SC – Brasil
2
Programa de Pós-Graduação em Engenharia e Gestão do Conhecimento – PPGEGC
Universidade Federal de Santa Catarina (UFSC) – Florianópolis, SC – Brasil
{rsp,macedo,andrade,awangenh}@inf.ufsc.br
Abstract. The majority of the information systems, that need authentication for user,
had been conceived to use the data name of user and password, as authentication
process. Such process of authentication makes with that the systems currently are
considered little safe. The problem of this process of security has been the loss or the
robbery of the authentication data. It was thinking about this problem and, in some
form to decide it, that the present work aims at to develop a study of the keystroke
dynamic biometric technique, about which served of base for the creation of an applied
system of security environments WEB. The system was implemented using the technique
of classification K-nearest neighbor.
Resumo. A maioria dos sistemas de informação, que necessitam de autenticação por
usuário, foram concebidos para utilizarem os dados, nome de usuário e senha, como
processo de autenticação. Tal processo de autenticação faz com que os sistemas sejam
atualmente considerados pouco seguros. O problema desse processo de segurança tem
sido a perda ou o roubo dos dados de autenticação. Foi pensando neste problema e, em
alguma forma de resolvê-lo, que o presente trabalho visa desenvolver um estudo da
técnica biométrica dinâmica da digitação, na qual serviu de base para a criação de um
sistema de segurança aplicado a ambientes WEB. O sistema foi implementado
utilizando a técnica de classificação k vizinhos mais próximos.
1. Introdução
Pessoas que utilizam a Internet em seu cotidiano necessitam de bons níveis de segurança para
proteger as informações que estão sendo acessadas. Esta segurança deve ser oferecida pelos
sistemas que guardam e gerenciam tais informações, com o foco principal para os que estão
presentes na Internet, onde o acesso é compartilhado por diversas pessoas.
Alguns desses sistemas como o prontuário eletrônico de paciente (PEP), bancos on-line e
gerenciadores de e-mail, exigem uma preocupação muito grande por parte das empresas que
administram essas informações. Desta forma, para garantir a constante evolução dos negócios,
investimentos em tecnologias de segurança são altamente necessários. Observando, por exemplo,
92
o PEP pela ótica de segurança, tem o seu tripé básico: a autenticidade, integridade e
confidencialidade que são assegurados com o uso de assinatura eletrônica, protocolação digital e
criptografia com chave certificada, respectivamente. Porém, com o crescimento dos ataques por
parte de usuários mal intencionados, vemos a necessidade de criação de um controle de acesso
mais eficiente. Sendo que esta é uma das áreas que atrai grande interesse de pesquisadores nos
últimos anos [Beznosov 1999].
Uma das formas de elevar os níveis de segurança é através do uso de técnicas biométricas.
As técnicas biométricas têm o objetivo de aumentar a segurança entre usuários e sistemas. De
acordo com Faundez-Zanuy (2006), a palavra biometria vem das palavras gregas: “bios” (vida) e
“metrikos” (medida). Ou seja, uma ciência que envolve uma análise estatística das características
biológicas, estudando as características físicas e comportamentais do ser humano com o intuito
de identificá-lo.
O custo aliado aos níveis de segurança que serão implantados, são requisitos de extrema
importância para sistemas. Por este motivo, analisar qual técnica biométrica se adapta melhor ao
sistema é fundamental para o sucesso do projeto. Umas das técnicas biométricas que vem sendo
muito utilizada é a impressão digital, tanto pelo fato desta técnica ter um custo acessível, como
também, por ter uma precisão aceitável [Moore 2007].
Para aplicações em ambientes Web a utilização da técnica de impressão digital não seria
muito viável, pois necessita de um equipamento para ler a impressão e neste caso todos os
computadores com acesso a Internet teriam que ter tal leitor, o que inviabilizaria sua utilização
em larga escala.
Uma outra técnica biométrica é a dinâmica da digitação (Keystroke Dynamics) que é
baseada no comportamento do ser humano ao digitar em um teclado. Jarmo Ilonen (2003) define
dinâmica da digitação como uma biometria baseada na suposição em que pessoas diferentes
digitam de maneiras características. Em seus estudos, ele também relata que no século 19, os
operadores de telégrafo já tinham padrões de telegrafar, com isso, um operador reconhecia o
outro. Isso caracteriza o marco inicial da idéia de dinâmica da digitação.
No presente trabalho é desenvolvido um sistema de autenticação baseado na técnica
biométrica dinâmica da digitação. Este sistema foi implementado em versão para Internet, com o
objetivo de aumentar os níveis de segurança dos sistemas de autenticação atualmente utilizados.
2. Trabalhos Relacionados
Conforme Jarmo Ilonen (2003) há várias maneiras de medir a dinâmica da digitação quando os
usuários digitam em um teclado normal de um computador. Algumas das maneiras são:
O intervalo de tempo entre o pressionamento de teclas consecutivas;
O tempo que uma tecla fica pressionada;
O tempo total da digitação;
A freqüência da digitação de teclas erradas;
O hábito de usar teclas diferentes do teclado.
Revett et al. (2005) citado por Magalhães et al. (2005), concluiu que dividindo o teclado
de um computador em setores, reduz-se a taxa de sucesso de impostores (False Acceptance Rate -
93
FAR). As senhas que tem dígitos em cada setor forçam os usuários a utilizarem teclas que estão
dispersas pelo teclado, garantindo uma melhor captura do ritmo de digitação dos usuários.
Além da forma de captura, tem também o processo de captura, ou seja, o treinamento do
classificador. Temos dois tipos de processos. Em um dos processos se utiliza a digitação de um
texto durante o treinamento [Curtin 2006]. No outro é utilizado a própria senha cadastrada pelo
usuário [Cho 2000].
Haider, Abbas e Zaidi (2000) em seus estudos utilizam a captura dos tempos de
pressionamento entre as teclas. O padrão de digitação do usuário foi formado por n-1 vetores,
sendo n, o número de dígitos que compõe a senha. Também se trabalhou com um classificador
que utilizava três diferentes técnicas de reconhecimento de padrões: lógica fuzzy, redes neurais e
métodos estatísticos. As avaliações foram feitas sobre cada técnica separadamente e sobre a união
das três técnicas.
Os testes mostraram que a união das três técnicas no processo de classificação obteve um
melhor resultado do que a utilização de qualquer uma delas separadamente. Em relação à
utilização em separado a técnica que obteve o melhor resultado foi à baseada em métodos
estatísticos. Foram feitos dois testes, no primeiro a rejeição de acesso ao sistema na primeira
tentativa de ingresso do usuário era contabilizada como erro, no segundo teste os usuários tinham
duas chances de acesso. Os resultados mostraram que geralmente os usuários válidos são
rejeitados na primeira vez [Haider 2000].
No trabalho de Cho (2000), foi desenvolvido um sistema para um ambiente Web, o qual
foi implementado com duas técnicas de classificação: medida de distância do vizinho mais
próximo e uma rede MLP (Multi Layer Perceptron). Os testes foram feitos com 21 usuários que
tiveram um número de padrões de treinamento variando entre 76 a 388. Os resultados apontaram
por uma superioridade da rede MLP sobre a medida de distância. Sendo que foi estabelecido
índice de erro para falsa aceitação como 0,0% , a média do erro para falsa rejeição no caso da
MLP foi de 1,0% e da técnica do vizinho mais próximo foi de 19,5%.
Cavalcanti (2005) mostrou em seu trabalho a típica extração do ritmo de digitação do
usuário. A técnica utilizada foi capturar os tempos de pressionamento de cada tecla e o intervalo
de tempo entre o pressionamento entre cada tecla. Também foi desenvolvido um sistema que
utiliza uma normalização e uma seleção baseada no desvio padrão das características capturadas.
Esses dois passos são feitos antes da aplicação de uma medida de distância como classificador. .
Os resultados mostraram que com o índice de falsa aceitação igual a zero, o erro falsa rejeição
atingiu 6,04% quando utilizadas a normalização e a seleção. Já sem os dois passos o erro de falsa
rejeição atingiu 30,99%.
3. Metodologia
De acordo com Cavalcanti (2005), os ritmos de digitação dos usuários, podem ser capturados a
partir de duas diferentes medidas que contabilizam o tempo. Uma contabiliza o tempo que os
usuários mantêm cada tecla pressionada. A outra contabiliza o intervalo de tempo entre uma tecla
e outra que são consecutivamente pressionadas.
Após a captura do ritmo de digitação, os tempos formam um vetor, o qual caracterizara o
padrão do usuário para o sistema classificador. Esse vetor composto pelos tempos tem um
tamanho dependente da quantidade de teclas que foram pressionadas. Com isso podemos formar
uma equação onde, com n teclas pressionadas, o tamanho do vetor ou a quantidade de tempos vai
94
ser igual a 2n – 1. Por exemplo, uma senha de seis dígitos formará um vetor composto por 11
tempos, sendo que, seis são tempos de pressionamento de teclas e 5 são intervalos de tempos
entre teclas pressionadas consecutivamente.
A classificação foi efetuada através da utilização do algoritmo k vizinhos mais próximos
(K-Nearest Neighbor – K-nn). O K-nn é um algoritmo de aprendizado supervisionado
pertencente à área de reconhecimento de padrões. O algoritmo necessita que os padrões estejam
representados na forma de objetos do espaço dimensional, ou seja, na forma de um vetor de n
dimensões.
O K-nn classifica os padrões através dos k vizinhos mais próximos do conjunto de
treinamento, ou seja, dado um padrão x, são encontrados os k padrões contidos no conjunto de
treinamento mais próximo de x. Diante disto, a classe mais freqüente dentre os k padrões será
atribuída ao padrão x. Para encontrar os k vizinhos mais próximos o algoritmo utiliza uma técnica
de medida de distância, neste caso, a distância euclidiana.
A Figura 1 demonstra essa classificação, sendo que, o ponto Xu é o padrão a ser
classificado e cada seta representa a ligação com os seus vizinhos mais próximos. Neste caso,
como a variável k foi atribuída com o valor 5, o algoritmo K-nn encontrou os cinco pontos mais
próximos de Xu. Sendo que dos 5 mais próximos, quatro pertencem a classe dos padrões
vermelhos e um pertence a classe dos verdes. O padrão Xu será classificado como um ponto
vermelho, pois ele se encontra mais perto dos vermelhos do que dos demais.
Figura 16 - Um padrão Xu e seus vizinhos mais próximos.
A idéia de desenvolver o algoritmo K-nn, vem da tentativa de proporcionar uma
classificação a partir de um confronto entre os padrões treinados. Onde, todos os padrões
capturados de todos os usuários serviram de comparação para a classificação. Isso faz como que
o conjunto dos padrões ou descritor conceitual esteja na memória em tempo de execução da
classificação.
Nesse artigo foi limitado o tamanho da senha em 6 dígitos pelo fato de a medida de
distância utilizada pelo algoritmo K-nn só aceitar padrões de mesma dimensão. Com isso todos
os padrões dos usuários são formados por um vetor de 11 tempos.
95
3.1 Parâmetros de Avaliação
Toda técnica biométrica tem as suas vantagens e desvantagens. Pois nenhum aprendizado de
máquina ou cálculo estatístico é 100% correto, sendo assim sempre se tem uma margem de erro.
O importante é saber se essa margem de erro afeta, de maneira considerável, a utilização do
sistema que implementa a técnica biométrica [Moore 2007].
Um sistema de autenticação não pode aceitar intrusos, como também, não pode rejeitar os
verdadeiros usuários do sistema. Tais situações devem ser testadas e analisadas como erros da
técnica desenvolvida. De acordo com Cavalcanti (2005) uma forma de testar uma especifica
técnica, é avaliar os erros:
Falsa Aceitação (FAR - False Acceptance Rate): quando um sistema de autenticação
aceita ou autentica um impostor como um usuário cadastrado no sistema.
Falsa Rejeição (FRR - False Rejection Rate): quando um sistema de autenticação rejeita
um usuário válido cadastrado no sistema.
3.2 Visão Geral do Sistema
A dinâmica da digitação aplicada a ambientes Web tem como vantagem dar uma maior segurança
para o portal. Na Figura 2 é mostrado o diagrama de atividades do sistema desenvolvido. Nesse
diagrama temos o módulo de autenticação que é dividido em dois processos separados e que são
representadas como páginas separadas no sistema.
Quando um novo usuário necessita cadastrar-se no sistema é necessário que ele faça um
treino, que nada mais é que, a digitação repetitiva da senha que ele mesmo escolheu. Durante a
fase de treino o usuário entra com um nome de usuário e escolhe uma senha, que deve ser
composta por 6 dígitos. A digitação deve ser repetida 5 vezes ou mais. A senha foi limitada em 6
dígitos, devido ao algoritmo K-nn. Após o treino, o padrão de digitação e o nome do usuário são
armazenados no banco de dados. Usuários que já são cadastrados no sistema devem ir para a tela
de acesso. Sendo necessário que o usuário entre com nome de usuário e a senha, mas a senha
deve ser digitada como foi previamente digitada na situação de treino. No acesso, após a captura
dos tempos na entrada da senha, o sistema procura o usuário no banco de dados e se o usuário
existir, então o sistema faz a classificação através da dinâmica de digitação. Se o usuário for
classificado como verdadeiro, então é liberado o acesso ao sistema para o usuário, senão o
sistema rejeita o usuário (figura 2).
O sistema é composto por duas páginas, onde cada uma possui um Applet, e um servidor
RMI (Remote Method Invocation). O Applet de treinamento e o Applet de acesso tiveram que ser
assinados digitalmente por causa da conexão entre eles e o servidor RMI. É através dessa
conexão que cada Applet envia para o servidor o vetor de tempos do usuário.
96
Figura 2 – Diagrama de atividades.
A Figura 3 demonstra a arquitetura do sistema. Como se trata de um ambiente Web,
temos uma situação de cliente-servidor, nessa situação temos o navegador na parte cliente, que
contém um Java Applet, o qual se comunica com o servidor através do navegador e de uma
conexão remota com uma aplicação que é um servidor RMI. Esse servidor RMI faz a conexão
com o banco de dados.
Figura 3 - Arquitetura do sistema.
97
4. Resultados
Na avaliação do sistema e do classificador K-nn foi efetuado um teste prático, no qual os usuários
se cadastravam no sistema e depois tentavam obter o acesso. Também foi pedido a eles que
fizessem uma tentativa de acesso com o nome de usuário e senha de um outro usuário cadastrado
no sistema.
Para avaliar o algoritmo de classificação foram feitos dois testes, um como uma entrada
de cinco repetições no treinamento e outro com uma entrada de dez repetições no treinamento.
Para o treinamento com cinco repetições foi atribuído o valor 5 (cinco) para o k do classificador,
ou seja, o classificador K-nn procurou os cinco padrões mais semelhantes. Já para o treinamento
com dez repetições foi atribuído o valor 10 (dez) para o k.
Para computar a avaliação, nas telas de aceitação e rejeição de acesso, foi adicionado um
formulário, no qual servia para saber se o usuário que foi rejeitado ou aceito era um usuário
válido ou um intruso tentando ter acesso. Cada vez que um usuário válido era rejeitado, um erro
de falsa rejeição (FRR) era computado. Quando um intruso era aceito pelo sistema, um erro de
falsa aceitação (FAR) era computado.
Os testes foram feitos com um total de 20 (vinte) usuários e um total de 100 (cem)
tentativas, cada pessoa fez o seu cadastro nos dois sistemas, um com 5 repetições e outro com 10
repetições da senha durante o treinamento. Depois, cada pessoa tinha uma tentativa de acessar
com o seu próprio usuário e outra tentativa de acessar com os dados de outro usuário, ou seja,
como um intruso. Em alguns casos ouve repetição desse procedimento de acesso.
A Tabela 1 mostra as variáveis estatísticas e os resultados obtidos em cima dos testes
realizados. A principal comparação é feita sobre os valores de erros (FAR e FRR) e a quantidade
de repetições durante o treino. Nos outros valores temos a relação entre a quantidade de tentativas
como usuário verídico e como usuário intruso, onde dessas tentativas temos a quantidade de falsa
aceitação e falsa rejeição.
Tabela 6 - Resultados dos testes.
Quantidade de Tentativas
Tentativas
tentativas como verídico como intruso
5 repetições no treino
10 repetições no treino
100
100
50
50
50
50
Quantidade de
falsa aceitação
Quantidade de
falsa rejeição
FAR
FRR
5
8
13
15
10,00%
16,00%
26,00%
30,00%
Na Figura 4 é mostrado um comparativo entre os erros do tipo FAR e FRR que ocorreram
durantes os testes com 5 repetições e 10 repetições. Percebemos que entre os dois testes houve
um aumento de 6% no valor do tipo de erro FAR e um aumento de 4% no tipo de erro FRR. Isso
demonstra que o aumento de repetições durante o treinamento fez com que o sistema aceitasse
mais usuários intrusos e rejeitasse mais usuários verídicos.
98
35,00%
30,00%
30,00%
26,00%
25,00%
20,00%
16,00%
FAR
FRR
15,00%
10,00%
10,00%
5,00%
0,00%
5 repetições no treino
10 repetições no treino
Figura 4 – Gráfico comparativo dos testes.
6. Conclusões e trabalhos futuros
O estudo da dinâmica da digitação e outras técnicas biométricas mostram que a técnica da
dinâmica da digitação é uma técnica de custo baixo, mas que garante uma elevação significativa
nos níveis de segurança dos sistemas. Isso é fundamental para sistemas que estão na Web. A cada
dia mais sistemas estão sendo criados na Internet e o sistema protótipo criado neste trabalho pode
perfeitamente ser utilizado em produção, pois a sua arquitetura garante um bom funcionamento.
A intenção de combater o padrão de um usuário com o outro, utilizando a técnica de
classificação K-nn, não obteve bons resultados se comparado com os trabalhos relacionados.
Pode-se observar que os testes com o sistema que tinha um treinamento com 5 repetições
obtiveram uma taxa menor de erro aos testes que tinham treinamento com 10 repetições.
Para trabalhos futuros é importante o desenvolvimento de um classificador que venha a
melhorar o processo de classificação. Esse classificador poderia ser implementado com a
característica de verificar uma pequena mudança temporal do padrão do usuário e aprender essa
mudança. Pode-se também, melhorar a etapa de treinamento, sendo que, no lugar de treinar o
usuário no cadastro, o treino seria realizado durantes os primeiros acessos do usuário ao sistema.
Referências
Beznosov, K.; Deng, Y.; Blakley, B.; Burt, C. e Barkley, J. “A Resource Access Decision Service
for CORBA-based Distributed Systems”, Proceedings. of the 15th Annual Computer Security
Applications Conference (ACSAC '99)., (1999), 310-319.
Cavalcanti, George D. C.; Pinheiro, Eggo H. F.; Carvalho, Edson C. B. (2005) “Um sistema de
verificação de identidade pessoal através de dinâmica da digitação”. Em XXV Congresso da
Sociedade Brasileira de Computação.
Cho, Sungzoon et al. (2000) “Web based Keystroke Dynamics Identity Verification using Neural
Network”. Em Journal of Organizational Computing and Electronic Commerce, v. 10, n. 4, p.
295-307.
99
Curtin, Mary et al. (2006) “Keystroke Biometric Recognition on Long-Text Input: A Feasibility
Study”. Proc. Int. Workshop Sci Comp/Comp Stat (IWSCCS 2006), Hong Kong, June 2006.
Faundez Z., M. (2006) “Biometric security technology”, IEEE Aerospace and Electronic Systems
Magazine, v. 21, n. 6, p. 15-26.
Haider, S.; Abbas, A.; Zaidi, A.K. (2000) “A multi-technique approach for user identification
through keystroke dynamics. Systems, Man, and Cybernetics”, IEEE International Conference
on, v. 2, p.1336-1341.
Ilonen
Jarmo
(2003)
“Keystroke
04/010970000/seminars/Ilonen.pdf, Outubro.
Dynamics”,
http://www.it.lut.fi/kurssit/03-
Magalhães, S. T.; Revett, Kenneth; Santos, Henrique M. D. (2005) “Password Secured Sites –
Stepping Forward With Keystroke Dynamics”, Proceedings of the International Conference
on Next Generation Web Services Practices.
Moore, A. M. (2007) “Biometric technologies — an introduction”. Em Biometric Technology
Today, v. 15, n. 1, p. 6-7.
Revett, K. and Khan, A. (2005) “Enhancing login compatible with those produced by very
expensive security using keystroke hardening and keyboard gridding”, Proceedings of the
IADIS MCCSIS.
This document was created with Win2PDF available at http://www.win2pdf.com.
The unregistered version of Win2PDF is for evaluation or non-commercial use only.
This page will not be added after purchasing Win2PDF.