the hardware-based pkcs#11 standard using the rsa algorithm · de 1977 pelos professores do mit...

Abstract— In this paper, we have proposed and implemented

a hardware-based security system, which executes RSA-based cryptography operations by using the PKCS#11 standard. It was implemented in C, VHDL and FPGAs and it is modular and easily adaptable to the future upgrades for the communication among machines and devices. Any cryptography algorithm can be used; however, in our project we only used the RSA as a case study. We did simulations and real tests that allowed verifying the correct behavior and execution of our project; we used the RSA with keys up to 512 bits. Real tests showed the transmission of ciphered data between our project (PKCS#11 and RSA) and a PC by using serial communication.

Keywords— Security, PKCS#11 Standard, RSA Algorithm, FPGAs

I. INTRODUÇÃO grande gargalo nas comunicações tem sido o

equipamento de rede, principalmente os roteadores. Eles centralizam o tráfego de pacotes e muitas vezes são os responsáveis pela falta de eficiência da rede. As tecnologias de rede têm evoluído, principalmente com os avanços da internet e os roteadores precisam aumentar a capacidade de processamento dos pacotes para evoluir juntamente com as demais tecnologias e deixar aos poucos de ser um dos gargalos das comunicações [4].

A falta de segurança na transmissão de dados e pacotes na rede é muito grande, por isso é necessária a criação de mecanismos de segurança para rede, tais como algoritmos criptográficos, protocolos de segurança, entre outros [22]. Essas soluções podem ser implementadas em software ou em hardware. Recentemente, uma tendência é ter soluções de segurança em hardware, onde a inserção de criptografia é fundamental para a transferência segura de pacotes na rede.

Existem diversas soluções de segurança baseadas em criptografia, porém a maior parte dos estudos atuais se concentra em processadores específicos melhor conhecidos como criptoprocessadores.

É importante também considerar que existem soluções de segurança inseridas em processadores de rede, como exemplo

Fernando Augusto Garcia Muzzi, pesquisador do LSI-TEC, Sao Paulo,

Brasil, [email protected]. Rodolfo Barros Chiaramonte, prof do UNIVEM (Centro Universitário

Euripides de Marilia), [email protected]. Edward David Moreno Ordoñez, profesor do DCOMP/UFS Depto. de

Computação da Universidade Federal de Sergipe, Aracaju, Brasil, [email protected].

o Network Processors) [12] [13] mas que não têm primitivas de segurança. Assim, é recomendável que os processadores de rede tenham um módulo de segurança para o processamento de pacotes, para prover maior segurança na rede.

Assim, os processadores de rede têm fundamental importância para a comunicação de dados, já que a velocidade de transmissão de dados tem aumentado consideravelmente [15]. No entanto é necessário segurança para os processadores de rede, ou seja, a criptografia de pacotes, para garantir a segurança da informação.

Há também soluções já padronizadas, por exemplo, o PKCS (Public Key Cryptography Standard) – padrão criptográfico de chaves públicas. São poucos os sistemas de segurança que seguem as padronizações, e maioria delas é implementada em software e poucas são as versões conhecidas em hardware.

A implementação de um algoritmo de criptografia baseado na norma PKCS#11 é importante para segurança dos dados (pacotes que trafegam na rede) e pode ser implementado em hardware. O padrão PKCS#11 é utilizado como interface para invocar operações criptográficas em hardware e é utilizado para prover suporte aos tokens [16-21].

Com um módulo de segurança baseado no PKCS#11, o dado poderá ser criptografado e quando o dado chegar no destino será decifrado conforme processo indicado pelo padrão. Importante salientar que o PKCS#11 é um padrão criado para interagir com hardware podendo ser utilizado em rede e é baseado em segurança de dados que utilizam como base o algoritmo de criptografia RSA.

A principal contribuição deste artigo é apresentar uma implementação em hardware (FPGAs) do padrão PKCS#11. Os resultados usando o algoritmo RSA mostram a viabilidade do projeto e a possibilidade de inserir este módulo de segurança em outros protótipos em hardware.

O artigo está organizado em 5 seções. As seções 2 e 3 apresentam os conceitos fundamentais do algoritmo RSA e do padrão PKCS, a seção 4 apresenta os detalhes da implementação em hardware e finaliza com as conclusões e idéias para trabalhos futuros na seção 5.

II. O ALGORITMO RSA O RSA é um algoritmo de criptografia de chave assimétrica

ou criptografia de chave pública que foi inventado por volta de 1977 pelos professores do MIT (Massachsetts Institute of Technology) Ronald Rivest, Adi Shamir e o professor

O

The Hardware-Based PKCS#11 Standard using the RSA Algorithm

F. A. Muzzi, R. B. Chiaramonte, E. D. Moreno

160 IEEE LATIN AMERICA TRANSACTIONS, VOL. 7, NO. 2, JUNE 2009

Leonard Adleman da USC (University of Southern Califórnia) [16-21], [23].

O sistema consiste em gerar uma chave pública (geralmente utilizada para cifrar os dados) e uma chave privada (utilizada para decifrar os dados) através de números primos grandes, o que dificulta a obtenção de uma chave a partir do conhecimento da outra chave.

Quanto maior os números primos utilizados para a criação da chave, maior é a segurança proporcionada por esse algoritmo. Hoje em dia os números primos que são utilizados, combinados, formam geralmente uma chave de 512 bits ou maiores. Em algumas aplicações como, por exemplo, bancárias, que exigem o máximo de segurança, a chave chega a ser de 1024 ou 2048 bits para autoridades certificadoras [2][3][8][10].

Com o passar do tempo, a tendência é que o comprimento da chave aumente cada vez mais. Esse fenômeno acontece, em grande parte, pelo avanço nos sistemas computacionais que acompanham o surgimento de computadores que são capazes de fatorar (ou quebrar) chaves cada vez maiores em um tempo menor [2].

O algoritmo RSA usa uma forma simples para a geração das chaves pública e privada, que são usadas para cifrar e decifrar as mensagens. O processo de geração das chaves se observa a seguir [16-21], [10]:

• Escolhem-se dois números primos grandes (p e q); • Gera-se um número “n” usando a multiplicação dos

números escolhidos anteriormente (n = p . q); • Escolhe-se um número “d”, tal que “d” é menor que

“n” e “d” é relativamente primo à (p-1).(q-1); • Escolhe-se um número “e” tal que (ed-1) seja

divisível por (p-1).(q-1). Para realizar esse cálculo é necessário o algoritmo de Euclides estendido.

• Os valores “e” e “d” são os expoentes públicos e privados, respectivamente. O par (n,e) é a chave pública e o par (n,d) é a chave privada. Os valores “p” e “q” devem ser mantidos em segredo ou destruídos.

• Para cifrar uma mensagem com esse algoritmo é realizado o seguinte cálculo: C = Te mod n, onde “C” é a mensagem cifrada, “T” é o texto original, e os valores “e” e “n” são dados a partir da chave pública (n,e).

• A única chave que pode decifrar a mensagem C é a chave privada (n,d) usando o calculo de: T = Cd mod n.

Neste trabalho, um dos objetivos foi implementar o

algoritmo RSA em software (linguagem C) e hardware (descrição em VHDL e prototipação em FPGAs), verificando o tempo de execução quando se aumenta o tamanho das chaves. Alguns dados da performance em software são mostrados na Fig.1, usando um Pentium IV com 512 Mbytes de RAM e sistema operacional XP.

Figura 1. Tempo para cifrar e decifrar arquivos usando RSA em C

A Fig.1 mostra o tempo em segundos para cifrar e decifrar

arquivos de 1,0 MB e 1,5 MB usando o algoritmo RSA, para duas chaves diferentes: 24 e 56 bits. Pode-se observar no gráfico da Fig.1 que para criptografar o arquivo de 1,0 MB levou 16 segundos utilizando o módulo RSA de 24 bits, já utilizando o módulo RSA de 56 bits levou 18 segundos, o que significa que aumentando a chave aumenta-se o tempo de cifrar, neste caso um aumento de 12%. Já o arquivo de 1,5 MB, usando o módulo de 24 bits e 56 bits, precisou respectivamente de 24 e 35 segundos. Isso implica em um aumento de 45,8 % quando se aumenta o tamanho da chave do algoritmo RSA de 24 para 56 bits. Assim, percebe-se que aumentando o tamanho da chave aumenta-se o tempo de cifrar e este processo se torna ainda mais dispendioso quando se trata de arquivos maiores. Processo similar acontece quando se trata da operação de decifrar. Isso acontece pois os dois processos são similares e baseiam-se nas mesmas operações: cifrar é C = Te mod n e decifrar é T = Cd mod n. Como se observa, o algoritmo baseia-se nas operações de exponenciação e cálculo do módulo, que são críticas em termos de processamento computacional. A nossa implementação em software foi simples e somente conseguimos executar o RSA com chaves até 56 bits. Em uma aplicação real e que precise de segurança, deve-se usar chaves bem maiores. Para isso é necessário usar bibliotecas especiais que permitam a execução de chaves do algoritmo com chaves maiores. Em hardware, nós conseguimos a execução com chaves maiores de até 512 bits, usando técnicas simples de implementação.

III. O PADRÃO PKCS

A. Definição do Padrão O PKCS Padrão de Criptografia de Chave Pública (Public

Key Cryptography Standards) é uma série de especificações produzidas pelos Laboratórios RSA em cooperação com projetistas de sistemas de segurança, de várias partes do mundo, que visa acelerar, por meio da padronização, a

Tempo de cifrar e decifrar

20

14

16 seg

24

34

22

35

18

0

5

10

15

20

25

30

35

40

cifrar 1.0 cifrar 1.5 decifrar 1.0 decifrar 1.5Tamanho da chave em bits

tempo em segundos

24 bits 56 bits

GARCIA MUZZI et al.: THE HARDWARE-BASED PKCS 161

utilização e o desenvolvimento de algoritmos de chave pública [16-21].

Os objetivos globais do PKCS são manter compatibilidade com Internet PEM (Privacy-Enhanced Mail Protocol), de modo a estender o Internet PEM para lidar com qualquer tipo de dados e tratar um número maior de atividades e servir como base para ser parte dos padrões OSI [1][11][16-21].

A empresa RSA Data Security formada pelos inventores das técnicas RSA de criptografia de chave pública, tem um papel importante na criptografia moderna. Nomeadamente a divisão dos Laboratórios RSA [16-21] mantém uma série de padrões (standards) denominados de Padrões Criprográficos de Chaves Públicas (PKCS - Public Key Cryptography Standards) muito importantes na implementação e utilização de Infraestruturas de Chaves Públicas (PKIs - Public-Key Infrastructure) [1].

Os objetivos da RSA na publicação destes padrões são [16-21]:

- Os PKCS visam preencher o vazio que existe nas normas internacionais relacionadas a formatos para transferência de dados que permitam a compatibilidade/interoperabilidade entre aplicações que utilizem criptografia de chave pública.

- Manter a compatibilidade com os padrões existentes, nomeadamente com PEM (Privacy-Enhanced Mail Protocol).

- Ir além dos padrões existentes, para permitir uma melhor e mais completa integração entre aplicações, normalizando a troca segura de qualquer tipo de dados.

- Produzir um padrão que possa ser incluído numa futura versão dos padrões de Interconexões de Sistemas Abertos (OSI Open Systems Interconnection).

Atualmente existem doze padrões deste tipo, denominados de PKCS#1, #3, #5, #6, #7, #8, #9, #10, #11, #12, #13 e #15 [16 – 21].

A especificação do PKCS responsável pela padronização da criptografia e verificação de assinatura e pela decriptografia e geração de assinatura digital utilizando o criptosistema RSA é constituída de 12 tipos de documentos gerados pelo PKCS entre elas o PKCS#11, conforme se observa na tabela 1.

Os PKCS descrevem a sintaxe de mensagens de uma forma abstrata, utilizando o ASN.1, e não restringem a sua codificação.

Neste artigo somente implementamos o algoritmo RSA em FPGA seguindo o padrão PKCS#11, enfatizando principalmente no projeto e implementação em hardware, para funcionar em um FPGA.

B. ESPECIFICAÇÃO DO PKCS#11 A maioria das chaves utilizadas nos dias de hoje tem 1024

ou 2048 bits de comprimento [10][16-21] e quando a implementação é em hardware, usa-se a norma PKCS#11, que é o mais utilizado em interfaces API (Application

Programming Interface) para módulos criptográficos. Este padrão especifica uma interface (API), chamado Cryptoki, para dispositivos que fazem segurança usando criptografia e executam funções de criptografia usando uma chave que é chamada de crypto-chave.

O padrão usa o ANSI (Padrão de Nacional Americano para linguagens de programação C) e são providas funções tipicamente usando cabeçalhos da linguagem C por meio de uma biblioteca chamada de Cryptoki [16-21].

A biblioteca Cryptoki é planejada para dispositivos de criptografia associados com um único usuário, assim são omitidas algumas características que poderiam ser incluídas em uma interface de propósito geral. Por exemplo, Cryptoki não tem usuários múltiplos e distintos [16-21]. Existe uma implementação do PKCS#11 em linguagem C [16-21].

TABELA I

DESCRIÇÃO GERAL DOS PADRÕES PKCS Padrão Especificação PKCS #1 Como cifrar e assinar usando sistemas criptográficos RSA PKCS #3 Padrão de Normalização de chave Diffie-Hellman PKCS#5 – Como cifrar com chaves secretas derivadas de um

password PKCS#7 Sintaxe de mensagens cifradas contendo assinaturas

digitais PKCS #8 Formato da informação de uma chave privada PKCS #9 Tipos de atributos e sua utilização nas normas PKCS PKCS #10 Requisição de certificados PKCS #11 Define API de criptografia (Criptoki) PKCS #12 Formato portável para armazenamento ou transporte

(exportação/importação de certificados)

PKCS #13 Como cifrar e assinar com criptografia de curva elíptica PKCS #14 Padrão para geração de números pseudo-random PKCS #15 Está ainda em desenvolvimento. Tem em vista propor uma

norma para rmazenamento de credenciais em “token-based devices” (incluindo smart cards)

C. FUNCIONAMENTO DO PADRÃO PKCS#11 A Fig.2 mostra a abertura de sessões conforme o login de

usuário no Sistema Operacional (SO). Quando o usuário faz a autenticação no sistema através de um login e senha, é aberta uma sessão, na qual o usuário tem permissões de leitura e escrita e, finalmente, quando o usuário faz um logout, ou seja, sai do login, a sessão é fechada.

Pode-se verificar que há 3 tipos de funções quando a sessão é aberta: operações de leitura e escrita (R/W) do sistema operacional, operações R/W públicas e operações R/W do usuário. Quando é efetuado o logout, a sessão é fechada e os dispositivos usados na operação são removidos.

A Fig.3 mostra duas aplicações acessando a biblioteca Cryptoki do padrão PKCS#11 do RSA, logo após é acessado um dispositivo que contém slots e esses slots por sua vez possuem um token. Assim, é possível verificar que no padrão PKCS#11 existe um dispositivo chamado de slot que pode ser usado para transmitir um dado.


Figura 2. Estados de uma Sessão Leitura/Escrita [21]

Figura 3. Modelo da biblioteca cryptoki [21]

A seguir se descrevem os itens que são necessários para que o padrão PKCS#11 possa funcionar corretamente:

• Cryptoki provê uma interface a um ou mais

dispositivos de criptografia que são ativos no sistema por vários " slots ". Cada slot corresponde a um leitor físico ou a uma interface de dispositivo que pode conter um token.

• Um token está tipicamente presente em um slot. • A visão lógica de Cryptoki de um token é um

dispositivo que armazena objetos e pode executar funções de criptografia.

Se um usuário normal foi autenticado ao TOKEN, então a

aplicação tem acesso de leitura e escrita. Assim, esse processo se inicia com uma chamada à biblioteca Cryptoki e logo após, a chamada de um slot para comunicação entre computadores. O slot por sua vez faz a chamada ao token e nesse momento é aberta uma sessão entre as duas aplicações em dois dispositivos diferentes. O token está implícito em um slot, o

slot pode ser, por exemplo, uma porta serial, paralela, USB ou uma placa de rede.

As especificações do padrão PKCS#11, é constituída por funções (ver Fig.4). Esta Fig.4 mostra a seqüência de funções da biblioteca criptoki implementada em software. Em uma implementação em hardware é necessário abstrair a especificação do PKCS#11 para o correto funcionamento em hardware.

Na Fig.4 se observa, como exemplo, que uma mensagem de 8 bits poderá ser enviada de um computador (indicado como PC A) para outro (PC B) usando a biblioteca cryptoki, executando as funções que aparecem na Fig.4.

Em uma implementação em hardware, é necessário abstrair o funcionamento de cada função de modo a cada uma delas funcionar sem precisar chamar a biblioteca cryptoki, uma vez que em hardware não é possível “chamar” uma biblioteca.

IV. O PKCS#11 EM HARDWARE

A. O Módulo de Segurança

Devido ao pioneirismo e simplicidade do algoritmo RSA e das funções do padrão PKCS, estes tornaram-se o padrão de fato em PKIs.

O padrão PKCS#11 é utilizado para operações criptográficas em hardware (tokens, smart cards e etc.) para prover suporte aos tokens. O PKCS#11 é baseado no padrão que fornece recomendações para a execução de criptografia baseada em chave pública e o algoritmo criptográfico usado é o RSA. Esta seção apresenta uma versão em hardware do PKCS#11, projetado e implementado pelos autores deste artigo.

A Fig.5 mostra a transição de estados da FSM que implementa o controle do padrão PKCS#11. No estado 1 é efetuado o login, no estado 2 é enviado um token serialmente e a variável `Lib_est_dois` recebe o bit de valor 1 indicando que foi enviado serialmente. No estado 3 é realizada a criptografia RSA, enquanto que no estado 4 transmite-se o dado criptografado. O estado 5 realiza a decifragem do dado e o estado 6 é usado para enviar o dado decifrado para o computador destino.

A segurança da informação se torna mais importante no mundo de hoje, e é necessário que o equipamento de networking permita funções de criptografia. Neste artigo foi criado um protótipo em hardware que efetua criptografia RSA com as especificações do padrão PKCS#11.

A Fig.6 mostra a arquitetura do datapath de nosso módulo de segurança, que implementa as operações de cifrar e decifrar dados segundo especificações do algoritmo RSA, seguindo o padrão PKCS#11. A unidade de controle de nosso módulo baseia-se em uma máquina de estados finito. A FSM consiste em diversos módulos, cada um com uma função determinada, a começar pelo token que tem a função de “pegar” um token escolhido pelo usuário. Esse token terá saída em s_token onde aparecerão informações do token.

R/W SO Funções

R/W Public Session

Logi

n SO

Logo

ut

Abre sessão

Abre Sessão

Fecha Sessão/ Remove Dispositivo

Fecha Sessão/ Remove Dispositivo

R/W Função Usuário

Logi

n U

suár

io

Logo

ut

Abre Sessão Fecha Sessão/

Remove Dispositivo

Token 1 (Dispositivo 1)

Token n (Dispositivo n)

Dispositivo

Aplicação 1

Regra

Cryptoki

Aplicação k

Regra

Cryptoki

Slot 1 Slot 1


Figura 4 . Seqüência de operações e criptografia no padrão PKCS#11 [11]

Figura 5. Diagrama de transição de estados da FSM que implementa o controle do padrão PKCS#11

Na Fig.6 se destacam os módulos que fazem o processamento do token (S_TOKEN), aqueles que realizam as operações de cifrar (RSA_CRIP) e decifrar (RSA_DECRIP) e aqueles que preparam o dado (cifrado ou não) para ser enviado a outro sistema computacional por alguma unidade de entrada/saída, neste caso a porta serial.

Figura 6. Arquitetura da Máquina de estados Finito RSA no Padrão PKCS#11

A tabela 2 mostra a descrição dos estados na máquina de estado finito (FSM). Esta FSM faz a criptografia RSA usando o padrão PKCS#11. A nossa FSM tem 10 estados, necessários para o funcionamento da máquina.

Cada estado faz uma parte, ou seja cada um deles é responsável pela execução de uma parte da máquina de estados [14]. A principal vantagem da FSM RSA versão 6.2 (chamada assim, pois usamos a versão 6.2 da ferramenta da Xilinx Foundation Series) no padrão PKCS#11 é que todos os processos são executados partindo de um dado original, que é criptografado e enviado por um slot, que neste projeto é a porta serial do computador.

B. Resultados de Simulação

Esta seção apresenta os resultados obtidos usando a criptografia RSA em hardware (FPGAs). Na obtenção e análise dos resultados foram utilizados um computador Pentium IV 1.6 GHZ com 128 de memória RAM e sistema

C_initialize Inicializa a biblioteca Cryptoki

C_Getslotlist Obtém a lista Informações sobre os Slots

C_Getslotinfo Obtém Informações particular de um Slot

C_Getokeninfo Obtém informações particular sobre um token

C_EncryptInit Inicializa operações de Criptografia

C_Encrypt Encripta o dado

Envia o dado para o micro B B. PC B

C_InitToken Inicializa um Token

C_InitPIN Inicializa um usuário normal PIN

C_OpenSession Abre a conexão entre uma aplicação e um token

C_login Login em um Token

Mensagem 8 bits Criptografada

PC A Mensagem de 8 bits

Toke

RSA_CRI

S_D_ CRI RSA_DECRIP

D_CRI P_CRI

D_CRI

P_DECRI

S_TOKE Serial

Estado 1 Login

Estado 2 envia token serialmente Lib_est_dois recebe 1 Indica que enviou serialmente

Estado 3 Criptografia RSA Estado recebe 4, indica que acabou criptografia

Estado 4 Transmite dado criptografado Lib_est_quatro recebe 1 indica que já enviou Serialmente.

Estado 5 Efetua decifragem, Estado recebe Seis, indica que acabou decifragem

Estado 6 Envia serialmente dado decifrado Lib_est_seis recebe 1, indica que enviou serialmente.

Computador recebe o dado cifrado ou decifrado


operacional Windows 2000 e a ferramenta ISE Foundation Series. [24].

Foram criadas três versões da máquina de estados finito (FSM): a versão 3.1, a 6.1 e a 6.2. A versão 3.1 foi implementada na ferramenta Xilinx versão 3.1 e simulada usando a ferramenta de síntese FPGA Express. A versão 6.1 foi implementada no Xilinx 6.2 e finalmente a versão 6.2 foi também implementada no Xilinx 6.2. O projeto foi evoluindo em complexidade, até chegarmos na última versão 6.2 que possui os estados descritos na tabela 2.

A Fig.7 mostra o funcionamento da simulação do nosso módulo de segurança, no qual se observa o correto funcionamento da FSM, permitindo a passagem por todos os estados e realizando as operações necessárias em cada estado.

TABELA II

ESTADOS DA FSM NO PADRÃO PKCS#11

Estado d

Descrição do estado 0 Inicializa Máquina

1 Atríbue valores ao token

2 Monta informações do TOKEN

3 Envia informações do TOKEN serialmente

4 Libera a Criptografia do dado

5 Monta o dado criptografado

6 Transmite o dado criptografado

7 Libera a decriptografia

8 Monta o dado decriptografado

9 Transmite o dado decriptografado

A Fig.7 mostra os resultados obtidos da máquina de

estados que implementa todas as operações indicadas no padrão PKCS#11 para realizar uma conexão segura. Essa versão foi implementada para funcionar no Xilinx 6.2, e foi implementada com 10 estados, sendo o inicial 0 e o último estado 9 (ver descrição de cada estado na tabela 2). Na Fig 7 pode-se verificar os estados da FSM e a saída de s_out pela porta serial, enquanto que a variável S_D_CRIP corresponde ao dado cifrado e S_D_DECRIP ao dado decifrado e clk corresponde ao clock.

A Fig.8 mostra o padrão PKCS#11 executando as operações de criptografia usando o algoritmo RSA, por meio dos módulos RSA_CRIP e RSA_DECRIP (indicados na Fig.6).

No exemplo de simulação da Fig.8 pode-se notar que no estado 1 é mostrado que a variável VAR_CH está no valor 6768, que corresponde ao dado que será criptografado, no estado 2 mostra-se que é criptografado o dado usando o algoritmo RSA e enviado pela porta serial usando o sinal D_OUT. Na variável S_D_CRIP tem-se o dado criptografado que corresponde a 1A68FE que está em hexadecimal. Os valores atribuídos representam um exemplo do funcionamento deste projeto.

A variável “conta” corresponde a um contador que varia de 1 até 83333 e sincroniza o clock (CLK) da máquina principal com o clock (s_clk) da saída do dado criptografado, pela porta serial, denominado slot pelo padrão PKCS#11 e que em nosso projeto é o slot default. Quando o valor do contador `conta` for igual a 166666, a variável conta recebe novamente o valor 0, para sincronizar com 50 Megahertz do FPGA que foi a freqüência de funcionamento no teste usado.

O sinal de `reset` é usado para zerar a máquina quando se encontra com o valor 0. Quando recebe o valor 1, dá inicio ao funcionamento da máquina de estados finito.

O sinal S_D_DECRIP recebe o valor decriptografado quando o estado da máquina for igual a 5.

O vetor CH, de tamanho 4, corresponde ao Token, onde pode-se determinar qual será o valor do token a ser usado. Quando se escolhe o 3, por exemplo corresponde ao valor 67 e 68 que na tabela ASCII corresponde aos bytes C e D, esse valores são exemplos de utilização no teste, podendo ser usado qualquer outro valor. O “contb” é um contador usado para indicar que o dado foi enviado pela porta serial. Quando o valor da variável “contb” for igual a 15, a variável contb é zerada, e Lib_Est_DOIS recebe o valor 1 indicando que o dado criptografado foi enviado serialmente. Quando for igual ao valor 23, indica que o dado decriptografado foi enviado pela serial, e o sinal “Lib_est_seis” recebe o valor 1, assim quando “contb” chegar a esse número, a variável “Lib_est_seis” receberá o valor 1 indicando que o dado já foi enviado serialmente.

Em nosso projeto também implementamos o algoritmo RSA em hardware, especificamente em FPGAs. Além disso, o nosso módulo RSA em hardware é parametrizado, permitindo mudar facilmente o tamanho da chave.

Em nosso projeto implementamos uma versão simples do RSA e conseguimos fazer simulações usando a ferramenta XILINX Foundation Series e um protótipo com experimentos reais, com chaves de até 512 bits. Importante observar que na versão em software (linguagem C) somente foi possível executar o RSA com chaves de até 56 bits [11]. Os tempos de execução são bem mais rápidos na versão em hardware (ver a Fig.9 que mostra o tempo de execução do circuito dado em nanosegundos - ns).

A Fig.9 apresenta o impacto do tamanho da chave (em bits) do algoritmo RSA na velocidade dos processos de cifragem e decifragem. Como se esperava, aumentando o tamanho da chave do algoritmo RSA, a velocidade de cifrar e decifrar diminui. Nós verificamos esse comportamento em 3 diferentes placas de FPGA, como se observa na Fig.9, onde usamos chaves 24 bits, 56 bits, 128 bits, 256 bits e 512 bits.

Na Fig.10 é possível observar que quanto maior o número de bits usados na chave, maior será a ocupação do FPGA.


Figura 7. Simulação do padrão PKCS#11 através dos diferentes estados da FSM

Figura 8. Simulação das operações de Cifrar e Decifrar no RSA com o padrão PKCS#11


Isto é possível de ser observado na Fig.10 (que define a porcentagem de slices usados em função do número total disponível por cada placa de FPGA usada) e Fig.11 (que mostra o número de slices ocupados), enquanto que a Fig.12 (mostra o número de flip-flops usadso no FPGA), conforme destaca Moreno [9][10] que deve ser mostrada a ocupação e uso dos recursos de hardware fornecidos pelos FPGAs.

A ocupação do circuito no FPGA também pode ser visto usando o número de LUT (3 e 4 entradas), o de Flip-Flop e o de elementos de I/O. O principal é o número de slices (Fig.11), e a respectiva porcentagem no FPGA (ver Fig.10), mas os outros elementos acompanham o mesmo comportamento de utilização como se observa na Fig.12 (que mostra os Flip-Flops usados em cada placa).

Tempo em ns do RSA

21.178

30.241

40.481

55.429

83.382

12.60916.841

22.895

56.480

34.178

14.89920.441

28.547

72.456

43.331

010.00020.00030.00040.00050.00060.00070.00080.00090.000

24 bits 56 bits 128 bits 256 bits 512 bits

xc2vp100-6ff1704 (Virtex II -Pro) Xcv3200e-8fg1156 (Virtex E ) xc3s5000-5fg1156(Spartan 3 )

Figura 9. Tempo do processo de cifrar no RSA

% de Ocupação FPGA

0,74%

4,85%

9,24%

17,96%

1,42%

2,84%

5,45%

10,43%

1,17%

2,30%

8,96%

17,36%

1,13%

2,24%

4,63%

0,00%

2,00%

4,00%

6,00%

8,00%

10,00%

12,00%

14,00%

16,00%

18,00%

20,00%


xc2vp100-6ff1704 (Virtex II -Pro) Xcv3200e-8fg1156 (Virtex E )

xc3s5000-5fg1156(Spartan 3 )

Figura 10 Impacto do tamanho das chaves na velocidade do algoritmo RSA

Número de Slices (Ocupação FPGA)

325626

1253

2404

4599

381746

1575

2999

5828

376747

1540

2983

5776

0

1000

2000

3000

4000

5000

6000

7000



Figura 11 Números de Slices utilizados pelo RSA

Número de Flip Flop

211369

211372

740

2666

211375

737

1380

2663

1380

737

1384

2663

0

500

1000

1500

2000

2500

3000



Figura 12 Números de Flip Flop utilizados pelo RSA

Interessante observar que o número de slices aumenta conforme se aumenta o tamanho da chave, porém para uma chave de 512 bits a ocupação é de 18%, o que permite afirmar que muito espaço da placa ainda pode ser usado para outros circuitos e sistemas, podendo então projetar processadores ou soluções de segurança mais complexas, em hardware, e ainda usar o algoritmo RSA e o padrão PKCS#11 integrados a essas novas soluções.

C. Resultados da Prototipação Real em FPGAs

As Fig.13 e Fig.14 mostram fotos do circuito funcionando em um experimento real, no qual se usou um osciloscópio, multímetros, computador e o circuito de segurança prototipado em um FPGA. A Fig.13 mostra o módulo sendo testado individualmente, enquanto que a Fig.14 mostra ele integrado a um PC e fazendo a comunicação do FPGA e PC via comunicação serial. Neste teste usou-se um FPGA do tipo Spartan2E.

Finalmente, é importante salientar que no padrão PKCS#11 está implícita uma série de especificações para estabelecer uma comunicação segura entre slots, comunicações baseadas em tokens, como por exemplo, o login de um usuário no token e a abertura de uma sessão, coforme se explicou na seção 3. Enquanto a sessão estiver aberta a comunicação entre dois slots é estabelecida, quando termina a sessão a mesma é fechada. Isso foi comprovado nos testes realizados e mostrado nas Fig.13 e Fig.14.


Figura 13 Teste individual do protótipo

Figura 14 Teste da Comunicação real de um PC e o módulo RSA no padrão PKCS#11 em hardware.

V. CONCLUSÕES

A criação de um protótipo de segurança em hardware que siga as recomendações de algum padrão é importante para aumentar a segurança das comunicações. Neste trabalho projetou-se e implementou-se um módulo que cifra e decifra informações usando o algoritmo RSA, e o mais importante, esse processo é realizado seguindo as indicações do padrão PKCS#11.

O PKCS#11 é um padrão de segurança criado para criptografia baseada em token, podendo ser usado tanto em software como em hardware.

A implementação do protótipo que realiza operações criptográficas com o padrão PKCS#11 foi descrita em VHDL e prototipado em hardware usando FPGA. A unidade de controle foi projetada usando uma implementação baseada em máquinas de estado finito.

Nós fizemos simulações e verificamos o correto funcionamento do nosso protótipo. Além disso, foi possível a comunicação de um PC e nosso módulo, fazendo o envio de dados criptografados com o RSA e usando o padrão PKCS#11 de nosso módulo para outro computador através de comunicação serial, e o processo inverso também, isto é, recebendo dados de um PC e decifrando no nosso módulo de

segurança. Foi usado o FPGA Spartan2E, no qual foi possível a

realização de teste enviando um dado criptografado para outro computador usando uma comunicação serial e o software chamado.

Obtiveram-se resultados significativos para demonstrar o padrão PKCS#11 usando criptografia RSA se comunicando com o slot e com outro computador. Foi possível enviar um dado original, um cifrado e um decifrado usando hardware o que torna possível maior segurança para a comunicação entre computadores e dispositivos.

A nossa implementação permite que qualquer outro algoritmo de criptografia seja usado, apesar de ter feito testes somente com o RSA. Assim, o nosso protótipo é modular.

O importante neste projeto foi mostrar que o padrão de criptografia PKCS#11 pode ser implementado em hardware e não somente em software, enfatizando nos poucos recursos utilizados em um determinado FPGA e alta velocidade no processo, quando comparado a soluções em software.

Foi realizada a implementação em linguagem C e em VHDL e foi possível verificar a diferença entre a implementação em software usando linguagem C e em hardware (VHDL e FPGAs), e como esperado, em hardware houve um desempenho superior.

O algoritmo RSA, em nossa implementação básica em C somente executa com chaves de até 56 bits. Nesta implementação não foi possível aumentar o número de bits devido às variáveis em C não aceitarem tamanho maior que 32 bits. Implementações com chaves maiores requerem o uso de bibliotecas especiais.

Na descrição usando VHDL foi possível implementar o RSA com 56 bits, 128 bits, 256 bits e 512 bits. Não foi possível implementar 1024 bits devido a que em nossa implementação usou-se um vetor de 1024 bits, e a ferramenta Xilinx 6.2 tem restrições para vetores deste tamanho.

Para implementação em software usando o padrão PKCS#11 é possível usar uma biblioteca em C chamada cryptoki, em hardware não foi possível usar essa biblioteca sendo necessário abstrair o padrão PKCS#11 para a realização da implementação em hardware usando FPGA.

As estatísticas de utilização de recursos espaciais do módulo RSA seguindo as especificações do padrão PKCS#11 em hardware (FPGAs), permite concluir que é possível termos este módulo integrado a outras soluções de segurança em hardware ainda no mesmo chip.

Como trabalho futuros deseja-se inserir outros algoritmos criptográficos que sejam integrados ao padrão, além de criar estratégias de implementação diferentes que permitam que o algoritmo RSA execute com chaves ainda maiores e com tempo de execução razoável. Outro trabalho futuro é a implementação de processadores de segurança que integrem o nosso módulo RSA e PKCS#11, como exemplo integrado a um processador de rede.


REFERÊNCIAS

[1.] ADAMS, C. e Lloyd, S. Understanding Public-Key Infrastructure: Concepts, Standards and Deployment Considerations. Macmillan Technical Publishing, 1999.

[2.] CHIARAMONTE, BARROS, R. C. SICO Um Sistema Inteligente de Comunicação Segura e Adaptativa. Dissertação de Mestrado, Ciência da Computação, UNIVEM – Centro Universitário Eurípides Soares da Rocha de Marília, p.134, 2006.

[3.] CHIARAMONTE, BARROS, R. C, “Implementação e teste em Hardware e Software de Sistemas Criptográficos, 2003, Relatório de TCC – UNIVEM, Marilia, Brasil.

[4.] CROWLEY, P., et al, “Characterizing processor architectures for programmable network interfaces”, Em Procedings of International Conference on Supercomputing, Santa Fé, 2000.

[5.] DYER, Joan G., Mark Lindemann, Ronald Perez, Reiner Sailer, Leendert van Doorn, Sean W. Smith, and Steve Weingart, Building the IBM 4758 secure Coprocessor, revista Computer, outubro 2001.

[6.] INTEL WAN/LAN Access Switch Example Design for the Intel IXP 1200 Network Processor, May, 2001, http://www.intel.com

[7.] INTEL “IXP 1200 - Network Processor”, Datasheet, May 2000, http://www.intel.com

[8.] MENEZES, P van Oorschot and S. Vanstone, CRC Press, 1996 - Cap. 1, 3, 8, 9, 11 e 13.

[9.] MORENO, E. et al. Projeto, Desempenho e Aplicações de Sistemas Digitais em Circuitos Programáveis (FPGAs). Bless, 2003.

[10.] MORENO, Edward David; PEREIRA, Fábio Dacêncio., CHIARAMONTE, Rodolfo Barros., Criptografia em Software e Hardware. Novatec, 2005.

[11.] MUZZI, Fernando Augusto Garcia. O Padrão de Segurança PKCS#11 em FPGAs: RSA Um estudo de caso. Dissertação de Mestrado, Ciência da Computação, UNIVEM – Centro Universitário Eurípides Soares da Rocha de Marília, p.134, 2005

[12.] MMC Networks, “EPIF-105, EPIF-200, GPIF-207, XPIF-300, Packet Processors”, 2006. http://www.mmcnet.com

[13.] MYERS, M. et al 1999, “X.509 Internet Public Key Infrastructure – Online Certificate Status Protocol - OCSP”.

[14.] PATTERSON, D. A., J. L. Hennessy, “Computer Organization and Design: The Hardware/Software Interface”, Morgan Kaufmann Publisher, 1997.

[15.] PRADO, Ricardo P., NPSOC – ARQUITETURA E PROTÓTIPO DE UM NOVO PROCESSADOR DE REDE, Dissertação de Mestrado, Ciência da Computação, Univem, Centro Universitário Eurípides Soares da Rocha de Marília, p. 92, 2004.

[16.] RSA Labs. Public Key Criptography Standards (PKCS). Version 2.1 - 2002, disponível em http://www.rsasecurity.com/rsalabs/pkcs/pkcs-1/index.html.

[17.] RSA Company , Disponível em www.rsasecurity.com/rsalabs/pkcs/pkcs-11/index.html

[18.] RSA Labs. Factorization of RSA-155. http://www.rsasecurity.com/rsalabs/challenges/factoring/rsa155.html, 1999.

[19.] RSA Labs. Has the RSA algorithm been compromised as a result of Bernstein’s Paper?

[20.] http://www.rsasecurity.com/rsalabs/technotes/bernstein.html, 2002.

[21.] RSA Labs. Public Key Criptography Standards (PKCS). Version 2.20 – 2004, disponível em ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-11/v2-20/pkcs-11v2-20fd.doc

[22.] STALLINGS, William, Cryptography and Network Security – Principles and Practice – Second Edition, 1996.

[23.] TERADA, R.; Segurança de Dados Criptografia em Redes de Computadores., Ed. Edgard Blücher, 1ª Edição, 2000.

[24.] XILINX Development Systems, “Synthesis and Simulation Design Guide – Designing FPGAs with HDL”, 2008.

Fernando Augusto Garcia Muzzi . Received the BS and MSc degrees in Computing Sciences from UNIVEM – Euripides Foundation of Marilia – Brazil, in 2002 and 2005. He is pursuing the PhD at the University of Sao Paulo, working in strategies on hardware security and energy optimization techniques for mobile applications. He now is professor at the IST – UNIVEM. He is interested in reconfigurable computing, hardware security and digital systems.

Rodolfo Barros Chiaramonte. Received the BS and MSc degrees in Computing Sciences from UNIVEM – Euripides Foundation of Marilia – Brazil, in 2004 and 2006. He now is professor at the IST – UNIVEM. He is interested in information security, distributed systems and reconfigurable computing.

Edward David Moreno Ordoñez. Received the MSc. and PhD degrees in Electrical Engineering from University of Sao Paulo - Brazil, in 1994 and 1998. During 1996 and 1997 he stayed as invited researcher at University of Toronto, Canada, and Chalmers University of Technology, Sweden. He is professor. at the DCOMP/UFS (Federal University of Sergipe), Aracaju, SE, Brazil. Prof. Moreno has participated on 100 events as International Program Committee and he is editorial board of 4 important Journals: JUCS – Journal Universal on Computer

Science, Springer Transactions on Computational Science and IJCSNS Intl. Journal of Computer Science and Network Security and JCP – Journal of Computers. He has published five books about digital systems, FPGAs, Microcontrollers, Reconfigurable Computing and Hardware Security. The research areas are: computer architecture, reconfigurable computing, embedded systems, hardware security, power aware computing and performance evaluation.


the hardware-based pkcs#11 standard using the rsa algorithm · de 1977 pelos professores do mit...

Documents