implementaÇÃo do algoritmo hash sha-1 em …siaibib01.univali.br/pdf/douglas barbonaglia sathler...
TRANSCRIPT
UNIVERSIDADE DO VALE DO ITAJAÍ CENTRO DE CIÊNCIA TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE ENGENHARIA DE COMPUTAÇÃO
Douglas Barbonaglia Sathler Figueiredo
IMPLEMENTAÇÃO DO ALGORITMO HASH SHA-1 EM PROCESSADOR DIGITAL DE SINAIS (DSP)
Prof. Walter Antônio Gontijo, M. Eng Professor orientador
São José, junho de 2008
2
UNIVERSIDADE DO VALE DO ITAJAÍ CENTRO DE CIÊNCIA TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE ENGENHARIA DE COMPUTAÇÃO
IMPLEMENTAÇÃO DO ALGORITMO HASH SHA-1 EM PROCESSADOR DIGITAL DE SINAIS (DSP)
Área de Segurança
Douglas Barbonaglia Sathler Figueiredo Acadêmico
Proposta de trabalho apresentada ao Responsável pela Coordenação de Trabalho de Conclusão do Curso de Engenharia da computação da Universidade do Vale do Itajaí - São José, para o desenvolvimento durante as disciplinas de Trabalho de Conclusão de Curso do 9o período e do 10o período.
Prof. Walter Antônio Gontijo, M. Eng
São José, junho de 2008
3
DEDICATÓRIA
Dedico este trabalho a todos meus
familiares e amigos, em especial a minha a
namorada Thayse, que sempre me apoiou e
incentivou nos estudos e que sem ela este
trabalho jamais seria o mesmo.
4
AGRADECIMENTOS
Agradeço primeiramente a Deus por ter me proporcionando esta experiência de
conclusão de curso. E por ter me dado saúde e condições de prosseguir nesta árdua
caminhada.
Agradeço a minha família pela compreensão e dedicação, fazendo o possível para me
incentivar a continuar nesta jornada.
Agradeço a minha namorada Thayse por sempre estar comigo me ajudando e
incentivando nos estudos. E acima de tudo participando, em grande parte, na confecção deste
trabalho.
Agradeço a todos meus amigos que estiveram presentes durante esta jornada, me
proporcionando momentos de diversão que foram essenciais para a conclusão deste curso.
Agradeço a meu parceiro e amigo Ronaldo, que assim como eu, passou por dias de
muito empenho para conclusão do curso e que por muitas vezes dividimos conhecimentos e
realizamos trabalhos da universidade como equipe. Também a todos os amigos graduandos
em Engenharia da Computação, que sempre estivemos juntos como uma família ajudando uns
aos outros.
Agradeço a todos os professores por compartilharem seus conhecimentos e acima de
tudo serem grandes amigos que adquiri durante minha formação. Agradeço especialmente ao
professor e orientador, Walter, que não foi somente orientador, mas sim um companheiro que
sempre esteve auxiliando não só neste trabalho, mas também em minha vida profissional.
Agradeço também a professora Anita que apesar da curta convivência se demonstrou uma
grande amiga, sempre se empenhando em tornar este trabalho uma realidade.
5
SUMÁRIO
RESUMO ...................................................................................................................................8
ABSTRACT ...............................................................................................................................9
LISTA DE FIGURAS...............................................................................................................10
LISTA DE QUADROS ............................................................................................................13
LISTA DE TABELAS..............................................................................................................14
1 INTRODUÇÃO................................................................................................................16
1.1 CONTEXTUALIZAÇÃO ..............................................................................................17
1.2 PROBLEMA ..................................................................................................................20
1.3 OBJETIVOS...................................................................................................................20
1.3.1 Objetivo geral ...................................................................................................20
1.3.2 Objetivos específicos........................................................................................20
1.3.3 Escopo e delimitação do trabalho.....................................................................20
1.4 RESULTADOS ESPERADOS ......................................................................................21
1.5 JUSTIFICATIVA ...........................................................................................................21
1.6 ASPECTOS METODOLÓGICOS.................................................................................22
1.6.1 Metodologia......................................................................................................22
6
1.7 ESTRUTURA DO TRABALHO ...................................................................................22
2 FUNDAMENTAÇÃO TEÓRICA....................................................................................24
2.1 CARACTERÍSTICAS....................................................................................................24
2.2 O ALGORITMO HASH SHA-1 ....................................................................................25
2.3 OPERAÇÕES E FUNÇÕES PARA IMPLEMENTAÇÃO...........................................26
2.3.1 Operações matemáticas ....................................................................................26
2.3.2 Função Message Padding .................................................................................27
2.3.3 Funções utilizadas na função Gera resumo ......................................................28
2.3.4 Constantes utilizadas na função Gera resumo ..................................................29
2.3.5 Gerando o resumo da mensagem......................................................................29
2.4 CONSIDERAÇÕES .......................................................................................................37
3 PROCESSADOR DIGITAL DE SINAIS ........................................................................38
3.1 INTRODUÇÃO AO DSP...............................................................................................38
3.2 PROCESSADOR DIGITAL DE SINAIS TMS320C5410.............................................40
3.2.1 Gerações de Códigos-Compatíveis...................................................................41
3.2.2 Arquitetura da geração de DSPs TMS320C54x™ ...........................................42
3.2.3 Modos de endereçamento .................................................................................44
3.2.4 Pipeline .............................................................................................................45
3.3 AMBIENTE DE DESENVOLVIMENTO (CCS)..........................................................46
3.3.1 Projeto da Aplicação.........................................................................................46
3.3.2 Código e Configuração .....................................................................................47
7
3.3.3 Debug................................................................................................................48
3.3.4 Análise e ajuste.................................................................................................48
3.4 CONSIDERAÇÕES .......................................................................................................49
4 IMPLEMENTAÇÃO........................................................................................................50
4.1.1 Implementação em linguagem “C” e Assembly ...............................................50
4.2 CONSIDERAÇÕES .......................................................................................................57
5 RESULTADOS ................................................................................................................58
5.1 SIMULAÇÃO DO ALGORITMO.................................................................................58
5.2 RECURSOS COMPUTACIONAIS...............................................................................59
5.2.1 Comparação com implementação comercial ....................................................60
5.3 CONSIDERAÇÕES .......................................................................................................61
6 COMENTÁRIOS E CONCLUSÕES...............................................................................62
6.1 CONCLUSÕES..............................................................................................................62
6.2 TRABALHOS FUTUROS .............................................................................................63
REFERÊNCIAS BIBLIOGRÁFICAS......................................................................................64
RESUMO
Diante do uso crescente de documentos digitais, surge a necessidade de utilizar uma
tecnologia que torne possível a autenticação destes documentos, visando à confirmação de
seus autores e buscando impedir fraudes. Este trabalho tem como objetivo a implementação
do algoritmo SHA-1 (Secure Hash Algorithm) definido pela National Institute of Standards
and Technology (NIST). Este foi escolhido por ser considerado pela NIST o algoritmo hash
padrão na implementação de um sistema de assinatura digital. Para realizar esta
implementação foi utilizado um processador digital de sinais (DSP), devido a sua alta
capacidade de realizar as operações contidas no algoritmo. O desempenho do algoritmo
implementado é compatível com implementações comerciais.
Palavras-chave: criptografia, hash, processador digital de sinais, SHA-1.
9
ABSTRACT
Ahead of the increasing use of digital documents, arises the needs to use a technology that
becomes possible the authentication of these documents, aiming confirmation of their authors
and preventing fraud. This paper presents the implementation of SHA-1 algorithm (Secure
Hash Algorithm) defined by National Institute of Standards and Technology (NIST). This
algorithm was chosen for being considered by NIST, a standard of hash algorithm to
implement digital signature systems. To perform this implementation was used a digital signal
processor (DSP), because of its high capacity to perform the operations contained in the
algorithm. The performance of the implemented algorithm was compatible with commercial
implementations.
10
LISTA DE FIGURAS
Figura 1 - Sistema para geração de assinatura digital...............................................................18
Figura 2 - Sistema para verificação de assinatura digital. ........................................................19
Figura 3 - Fluxograma do algoritmo SHA-1. ...........................................................................26
Figura 4 - Mensagem Original (Exemplo da função Message Padding). ................................27
Figura 5 - Inserção de um bit “1” (Exemplo da função Message Padding). ............................27
Figura 6 - Inserção de n bits “0” (Exemplo da função Message Padding)...............................28
Figura 7 – Bloco resultante (Exemplo da função Message Padding).......................................28
Figura 8 - Pseudo-código da função que gera o resumo da mensagem. ...................................30
Figura 9 - Mensagem (Exemplo da função Gera resumo)........................................................30
Figura 10 - Inicialização das variáveis H0, H1, H2, H3 e H4 (Exemplo da função Gera resumo).
..................................................................................................................................................31
Figura 11 - Primeiro Bloco (Exemplo da função Gera resumo)...............................................31
Figura 12 - Processamento do primeiro bloco (Exemplo da função Gera resumo)..................33
Figura 13 - Resultado do processamento do primeiro bloco (Exemplo da função Gera
resumo). ....................................................................................................................................33
Figura 14 - 64 bits referentes ao tamanho da mensagem original (Exemplo da função Gera
resumo). ....................................................................................................................................34
11
Figura 15 - Segundo bloco (Exemplo da função Gera resumo). ..............................................34
Figura 16 - Processamento do segundo bloco (Exemplo da função Gera resumo). .................36
Figura 17 - Resultado do processamento do segundo bloco (Exemplo da função Gera resumo)
..................................................................................................................................................36
Figura 18 - Resultado do processamento do segundo bloco (Exemplo da função Gera resumo).
..................................................................................................................................................36
Figura 19 - Diagrama de bloco da geração de DSPs TMS320C54XX.....................................43
Figura 20 - Arquitetura pipeline da família TMS320C54X .....................................................45
Figura 21 - Code Composer Studio IDE...................................................................................46
Figura 22 - Código fonte em linguagem “C” do laço de repetição para espalhamento do bloco
de 512. ......................................................................................................................................50
Figura 23 - Código fonte em linguagem assembly do laço de repetição para espalhamento do
bloco de 512..............................................................................................................................51
Figura 24 - Código fonte em linguagem “C” do primeiro laço de repetição da função gera
resumo. .....................................................................................................................................52
Figura 25 - Código fonte em linguagem “C” do segundo laço de repetição da função gera
resumo. .....................................................................................................................................52
Figura 26 - Código fonte em linguagem “C” do terceiro laço de repetição da função gera
resumo. .....................................................................................................................................53
Figura 27 - Código fonte em linguagem “C” do quarto laço de repetição da função gera
resumo. .....................................................................................................................................53
Figura 28 - Código fonte em linguagem assembly do primeiro laço de repetição da função
gera resumo...............................................................................................................................54
12
Figura 29 - Código fonte em linguagem assembly do segundo laço de repetição da função gera
resumo. .....................................................................................................................................55
Figura 30 - Código fonte em linguagem assembly do terceiro laço de repetição da função gera
resumo. .....................................................................................................................................56
Figura 31 - Código fonte em linguagem assembly do quarto laço de repetição da função gera
resumo. .....................................................................................................................................57
13
LISTA DE QUADROS
Quadro 1 - Características dos algoritmos SHA.......................................................................24
Quadro 2 - Aplicações referentes às famílias dos DSPs...........................................................40
14
LISTA DE TABELAS
Tabela 1 - Operações utilizadas pelo SHA-1............................................................................27
Tabela 2 - Funções e constantes utilizadas pelo SHA-1...........................................................29
Tabela 3 - Entradas e saídas em linguagem “C” e Assembly. ..................................................59
Tabela 4 - Comparação com implementação de uso comercial................................................60
15
LISTA DE ABREVIATURAS
A/D Analógico/Digital BIOS Basic Input/Output System (Sistema básico de entrada e saída) CCS Code Composer Studio (Algoritmo de assinatura digital) CD Compact disc (Disco compacto) DSA Digital Signature Algorithm (Algoritmo de assinatura digital) DSP Digital Signal Processor (Processador digital de sinais) ECC Eliptic Curve Cryptography (Criptografía de Curvas Elípticas) FIPS PUB Federal Information Processing Standards Publications (Padrão de
Processamento de Informação Federal) ICP-BRASIL Infra-Estrutura de Chaves Públicas Brasil IDE Integrated Development Environment (Ambientes de
Desenvolvimento Integrado) NIST National Institute of Standards and Technology (Instituto Nacional de
Padrões e Tecnologia) RSA Ron Rivest, Adi Shamir e Len Adleman SHA Secure Hash Algorithm (Algorítmo de Resumo Seguro) TI Texas Instruments ULA Unidade de lógica aritmética UNIVALI Universidade do Vale do Itajaí
1 INTRODUÇÃO
Os primeiros registros sobre a utilização de criptografia para ocultar o conteúdo de uma
mensagem são datados de 2000 a.C. no Egito (MENEZES, OORSCHOT & VANSTONE,
1996, p. 1). Outro registro de utilização da criptografia refere-se aos Romanos que
empregaram técnicas conhecidas como cifra de César1 para tornar o conteúdo inelegível
(LIMA, 2005, p. 143). O termo criptografia se origina do Grego, no qual “kryptós lógos”
significa “palavra escondida”.
A importância da criptografia se deve à necessidade de tornar possível que um documento
com informações sigilosas seja lido apenas por pessoas autorizadas e, além disso, que este não
possa ser alterado durante o processo de envio sem o conhecimento do receptor. Desta
maneira, ao receber uma mensagem que tenha sido alterada, o receptor terá conhecimento do
ocorrido (TERADA, 2000, p. 16). Neste contexto, os algoritmos de criptografia são
considerados de grande importância pelos países que os desenvolvem, visto que possuem a
característica de manter secretas as informações desejadas (MENEZES, OORSCHOT &
VANSTONE, 1996, p. 1). Um marco importante na história da criptografia foi o surgimento
da criptografia assimétrica2, que além de garantir a confidencialidade do documento, permite
também que seja feita a integridade, autenticidade e o não-repudio do mesmo (BURNETT &
PAINE, 2002, p. 116).
Diferente dos algoritmos de criptografia que têm como finalidade tornar as informações do
documento inelegível, os algoritmos hash têm por objetivo a verificação da autoria e conteúdo
dos dados enviados (VOLPI, 2001, p. 16). Os algoritmos hash são comumente utilizados em
1Baseava-se na substituição dos caracteres originais de uma mensagem pelos seus sucessores no alfabeto, dependendo da chave escolhida (LIMA, 2005, p. 143). 2Sistemas de criptografia assimétrica operam com uma chave para codificação e uma para decodificação. Em aplicações, para garantir sigilo, a chave de codificação é pública e a chave de decodificação é privada. Isso significa que todos podem cifrar, porém, apenas o dono da chave de decodificação pode decifrar (MENEZES, OORSCHOT, VANSTONE, 1996, p. 283).
17
casos em que o usuário não deseja tornar os dados inelegíveis, porém, quer ter a certeza de
que o receptor saberá se ocorreu alteração nos dados. Por não tornar os dados inelegíveis, os
algoritmos hash são muito mais rápidos que os de criptografia assimétrica, já que apenas
geram um resumo do documento3 (BURNETT & PAINE, 2002, p. 120).
A utilização de algoritmos hash e de criptografia assimétrica torna possível realizar a
implementação de um sistema de assinatura digital. Este sistema tem por objetivo substituir as
assinaturas tradicionais por uma assinatura eletrônica. Em 1° de julho de 2000, o presidente
norte-americano Bill Clinton aprovou a lei que concebe o mesmo poder da assinatura
tradicional à assinatura digital (CNN, 2000). Já no Brasil, isto ocorreu em 24 de agosto de
2001 quando foi instituído o ICP-Brasil (Infra-Estrutura de Chaves Públicas Brasileira), órgão
responsável por garantir a autenticidade, a integridade e a validade jurídica de documentos em
forma eletrônica (CASA CIVIL, 2001).
Os processadores digitais de sinais (DSP) são largamente utilizados em sistemas embarcados,
nos quais há necessidade de agregar funcionalidades, tais como de assinatura digital. Uma
possível implementação dos algoritmos que compõem o sistema de assinatura digital é
considerar o processador digital de sinais (DSP). Este processador tem como principais
características sua capacidade de executar instruções em paralelo e otimizações em operações
de soma e produto. Tal processador vem sendo largamente empregado em aplicações de
telecomunicações.
1.1 CONTEXTUALIZAÇÃO
A implementação do algoritmo hash SHA-1 tem por finalidade prover parte de um sistema de
assinatura digital para sistemas embarcados4, agregando funções ao mesmo. Desta maneira é
possível implementar um sistema de assinatura digital em dispositivos eletrônicos, como por
exemplo: telefones, celulares e palmtops.
3Resumo do documento é uma das maneiras de autenticação de um documento (SCHNEIER, 1996, p. 52). 4Sistemas embarcados são sistemas computacionais embutidos em outro dispositivo eletrônico (VAHID, GIVARGIS, 2000).
18
Este sistema de assinatura digital pode ser observado no fluxograma de um sistema para
geração da assinatura digital mostrado na Figura 1 e apresenta duas etapas: “SHA-1” e
“Operação de assinatura do DSA5”. Estas etapas processam a mensagem original, obtendo sua
respectiva assinatura. Na primeira etapa, a função “SHA-1” processa a mensagem, obtendo
seu respectivo resumo. Na segunda etapa, a função “Operação de assinatura do DSA” utiliza
uma chave privada para processar o resumo obtido pela função “SHA-1”, obtendo sua
respectiva assinatura digital.
Figura 1 - Sistema para geração de assinatura digital.
Fonte: Adaptado de NIST (1995).
De forma correspondente, o fluxograma de um sistema para verificação da assinatura digital é
mostrado na Figura 2 e apresenta duas etapas: “SHA-1” e “Operação de verificação do DSA”.
Estas etapas processam a mensagem recebida, obtendo sua respectiva assinatura, visando
compará-la com a assinatura recebida. Na primeira etapa a função “SHA-1” processa a
mensagem, obtendo seu respectivo resumo. Na segunda etapa a função “Operação de
verificação do DSA” utiliza uma chave pública para processar o resumo obtido pela função
“SHA-1”, adquirindo sua respectiva assinatura digital. Após obter a assinatura da mensagem,
5DSA (Digital Signature Algorithm) é o algoritmo padrão utilizado em operações de assinatura de documentos especificado no DSS (Digital Signature Standard) (NIST, 1995).
19
esta é comparada com a assinatura recebida e, somente se ambas forem iguais, a assinatura é
considerada válida.
Figura 2 - Sistema para verificação de assinatura digital.
Fonte: Adaptado de NIST (1995).
O resumo da mensagem gerado pelo algoritmo hash é comumente confundido com a
assinatura digital da mensagem. A assinatura digital é obtida por meio da codificação do
resumo da mensagem. O resumo da mensagem representa unicamente qualquer mensagem
que seja submetida ao algoritmo (LIMA, 2005, p. 137). O resumo possui tamanho fixo que
especifico para cada algoritmo. Quanto maior for o tamanho do resumo da mensagem maior
será a segurança do mesmo (VOLPI, 2001, p. 22).
Os algoritmos hash também são conhecidos como algoritmos de sentido único. Estes têm por
meio como característica a rápida obtenção do resultado (resumo da mensagem), porém é
computacionalmente improvável reproduzir a mensagem original a partir do resumo da
mensagem. Outra característica é o fato dos resultados gerados serem únicos e de difícil
duplicação, o que torna praticamente impossível encontrar o mesmo resumo para mensagens
diferentes (VOLPI, 2001, p. 22).
O principal objetivo para gerar um resumo de mensagem é a obtenção da autenticidade, ou
seja, a garantia de que a mensagem ou arquivo não foi alterado durante o envio. O SHA-1
20
(Secure Hash Algorithm) é um algoritmo hash definido pelo NIST (National Institute of
Standards and Technology) como o algoritmo padrão para um sistema de assinatura digital
(MENEZES, OORSCHOT & VANSTONE, 1996, p. 348).
1.2 PROBLEMA
A implementação do algoritmo hash SHA-1 em processadores digitais de sinais (DSP) com
complexidade computacional compatível com soluções comerciais.
1.3 OBJETIVOS
1.3.1 Objetivo geral
Implementar o algoritmo hash SHA-1 em processador digital de sinais (DSP).
1.3.2 Objetivos específicos
1. Analisar o algoritmo hash SHA-1.
2. Implementar o algoritmo hash SHA-1 em linguagem “C”.
3. Implementar o algoritmo hash SHA-1 em linguagem assembly do processador
digital de sinais (DSP) escolhido.
4. Validar e Testar por meio de simulações no computador.
1.3.3 Escopo e delimitação do trabalho
Este trabalho consiste no desenvolvimento do algoritmo hash SHA-1 em linguagem assembly
com finalidade de utilização em processadores digitais de sinais (DSP). Este trabalho não
contempla o desenvolvimento de algoritmos criptográficos, como por exemplo: DAS (Digital
Signature Algorithm), RSA (Ron Rivest, Adi Shamir e Len Adleman) e ECC (Elliptic Curve
Cryptosystem), necessários na implementação do sistema de assinatura digital, apesar de
serem citados como uma aplicação para o algoritmo hash.
21
1.4 RESULTADOS ESPERADOS
Espera-se ao final deste trabalho que a implementação do algoritmo hash SHA-1 em
linguagem assembly do processador digital de sinais, seja funcional e compatível com
implementações comerciais disponíveis.
1.5 JUSTIFICATIVA
A implementação do algoritmo hash SHA-1 em linguagem “C”, tem por objetivo o
desenvolvimento do mesmo de maneira rápida, tendo em vista que implementações em
linguagem de alto nível são de baixa complexidade computacional. Ao implementar
utilizando a linguagem “C”, as características da arquitetura do processador digital de sinais
(DSP) podem ser desconsideradas. Isto torna a implementação mais rápida, porém, degrada o
desempenho da aplicação (DACS SOFTWARE, 2001).
A implementação do algoritmo hash SHA-1 em linguagem assembly, tem como finalidade a
utilização deste algoritmo em processadores digitais de sinais, fazendo com que tais
processadores obtenham seu melhor desempenho. A principal vantagem ao programar em
linguagem assembly é obter o máximo aproveitamento do hardware no qual a aplicação é
executada, reduzindo o tamanho do código e aumentando significativamente o desempenho da
aplicação (DACS SOFTWARE, 2001). Com isso, buscou-se tornar a execução do algoritmo
rápida e eficiente.
Validações e testes por meio de simulações no computador, têm por objetivo ter a certeza de
que o algoritmo hash SHA-1 está funcionando de acordo com o esperado. Para estas
validações e testes utiliza-se um documento de entrada, do qual já se conhece o resumo da
mensagem (digest) por meio de exemplos em artigos ou até mesmo de simulações do
algoritmo hash SHA-1 em linguagem “C”. Utilizando o simulador para a implementação em
assembly, é comparado o resumo da mensagem (digest) gerada com a conhecida, caso sejam
iguais, significa que o algoritmo hash está funcionando como deveria.
Uma característica importante dos sistemas embarcados é o desempenho obtido na execução
de algoritmos. Tal desempenho decorre de um tempo de processamento menor em relação à
22
implementações em computadores pessoais utilizando linguagem de alto nível. Outra
característica que deve ser considerada é que o sistema embarcado tem menor custo, baixo
consumo de energia e é pequeno em relação aos computadores pessoais.
1.6 ASPECTOS METODOLÓGICOS
1.6.1 Metodologia
Este trabalho se baseia na implementação do algoritmo hash SHA-1. Para obter a
implementação foi usada uma metodologia qualitativa e com caráter de pesquisa aplicada,
tendo em vista, que o algoritmo hash SHA-1 já foi implementado (NIST, 1995).
Esta pesquisa abrange as áreas de criptografia e de processamento digital de sinais. Com
respeito à criptografia, foi analisado e implementado o algoritmo hash SHA-1. Já em relação
ao processamento digital de sinais, foi utilizado um processador DSP como alvo desta
implementação.
1.7 ESTRUTURA DO TRABALHO
Este trabalho esta dividido em cinco capítulos. O primeiro capítulo apresentou uma breve
contextualização sobre o trabalho, o motivo pelo qual este foi desenvolvido e descreve os
resultados esperados que foram alcançados satisfatoriamente.
No segundo capítulo foram descritas as características que envolvem o algoritmo hash SHA-
1, assim como um exemplo passo a passo da sua execução.
O terceiro capítulo apresentou características do DSP (TMS320C54XX) e do ambiente de
desenvolvimento (CCS) que foi utilizado na implementação do algoritmo.
No quarto capítulo foram apresentados aspectos do desenvolvimento do algoritmo em
linguagem “C” e assembly, assim como peculiaridades de cada linguagem.
23
O capítulo 5 apresentou os resultados obtidos por meio da implementação em linguagem “C”
e assembly. Também foi realizada uma comparação entre a implementação em linguagem
assembly e uma implementação de uso comercial.
24
2 FUNDAMENTAÇÃO TEÓRICA
Este capítulo apresenta uma abordagem sobre o funcionamento do algoritmo hash SHA-1,
descrito pelo NIST no documento FIPS PUB 180-1 (Federal Information
Processing Standards Publication) (NIST, 1995). Este algoritmo hash pode ser aplicado em
conjunto com um algoritmo de criptografia assimétrica, a fim de realizar um sistema de
assinatura digital.
2.1 CARACTERÍSTICAS
Existem diversos tipos de algoritmos SHA, porém o algoritmo SHA-1 é considerado pela
NIST o algoritmo hash padrão na implementação de um sistema de assinatura digital, por este
motivo o SHA-1 foi escolhido como o algoritmo a ser implementado.
No Quadro 1 pode-se observar que o algoritmo hash SHA-1 recebe como entrada uma
mensagem menor que 264 bits gerando assim um resumo fixo de 160 bits independente do
tamanho do arquivo. Outras características importantes são: tamanho do bloco6, tamanho da
palavra7 (operandos) e segurança.
Quadro 1 - Características dos algoritmos SHA.
Fonte: Adaptado de NIST (2002).
6Bloco é a divisão do texto original em fragmentos de dados (BURNETT, 2002, p. 32). 7Palavra é um grupo de bits. O algoritmo SHA-1 utiliza um grupo de 32 bits como palavra (NIST, 2002, p. 4).
25
No algoritmo hash SHA-1, o tamanho da mensagem deve ser múltiplo de 512 bits, porém esta
característica é transparente ao usuário. Todos os operandos das funções matemáticas
utilizados pelo algoritmo são de 32 bits. A segurança refere-se à resistência às colisões8, que é
de aproximadamente 2n/2, na qual n é o tamanho do resumo da mensagem. Isto significa que
ao utilizar um ataque de força bruta no algoritmo SHA-1, é necessário testar 280 mensagens
para encontrar colisões, ou seja, duas mensagens distintas com o mesmo resumo.
2.2 O ALGORITMO HASH SHA-1
O fluxograma do algoritmo SHA-1 mostrado na Figura 3, apresenta três etapas principais:
“Message Padding”, “Fragmenta Padded Message” e “Gera resumo da mensagem”. Estas
etapas processam a mensagem original, obtendo seu respectivo resumo. Na primeira etapa a
função “Message Padding” altera o tamanho da mensagem original para um tamanho múltiplo
de 512 bits. Na segunda etapa a função “Fragmenta Message Padded” fragmenta um bloco de
512 bits em 16 palavras de 32 bits. Na última etapa a função “Gera resumo” processa estas 16
palavras de 32 bits, obtendo o resumo deste bloco.
A mensagem da qual se deseja obter a autenticação é o parâmetro de entrada para o algoritmo
SHA-1. Esta mensagem original deve possuir o tamanho de 0 a 264 bits. Entretanto, o
algoritmo SHA-1 trabalha com blocos de 512 bits, de modo que o tamanho da mensagem
original também deve ser múltiplo de 512 bits. Desta forma, para autenticar qualquer
mensagem, independente de seu tamanho, o algoritmo SHA-1 utiliza a função “Message
Padding”.
A função “Fragmenta Padded Message” tem por objetivo fragmentar o bloco de 512 bits em
16 palavras de 32 bits, tendo em vista que, o algoritmo SHA-1 utiliza operandos de 32 bits
para autenticar a mensagem.
8Colisões referem-se à possibilidade de existir mensagens distintas com o mesmo resumo de mensagem (MENEZES, OORSCHOT, VANSTONE, 1996, p. 321).
26
Se a mensagem for composta por mais de um bloco, o processo se repetirá até que todos os
blocos sejam processados pelo algoritmo para a obtenção do resumo da mensagem. Logo, o
número de iterações necessárias para a obtenção do resumo da mensagem é de t/512, na qual t
é o tamanho da mensagem original em bits (0 ≤ t < 264 bits).
O resumo da mensagem é composto pela concatenação de cinco palavras de 32 bits, o que
resulta em um resumo de 160 bits. O tamanho do resumo é fixo (160 bits) e independe do
tamanho da mensagem original a ser autenticada. Deve-se considerar que o tamanho da
mensagem seja de 0 a 264 bits.
Figura 3 - Fluxograma do algoritmo SHA-1.
2.3 OPERAÇÕES E FUNÇÕES PARA IMPLEMENTAÇÃO
2.3.1 Operações matemáticas
Neste tópico são abordadas as operações matemáticas necessárias para a implementação do
algoritmo hash SHA-1. Estas operações utilizam operandos de 32 bits e podem ser observadas
na Tabela 1.
27
Tabela 1 - Operações utilizadas pelo SHA-1.
Operações
X ^ Y Operação lógica “E”. X v Y Operação lógica “OU”. X XOR Y Operação lógica “OU Exclusivo”. ~ X Operação lógica “Complemento”. X + Y Operação soma de inteiros. Rn(X) Rotação circular, onde são rotacionados n bits de X.
2.3.2 Função Message Padding
Esta função tem por objetivo tornar a mensagem de entrada múltipla de 512 bits, visto que o
algoritmo hash SHA-1 utiliza blocos com tamanho de 512 bits. Para realizar esta operação é
acrescentado ao final do último bloco um bit ‘1’, seguido de n bits ‘0’, até que o bloco totalize
448 bits. Para que este bloco tenha o tamanho de 512 bits, é necessário acrescentar 64 bits
referentes ao tamanho da mensagem original em bits. Para melhor compreensão da função
Message padding, será apresentado um exemplo do seu funcionamento:
Neste exemplo é utilizada uma mensagem de tamanho igual a 32 bits. Esta é composta por
uma string de quatro caracteres ASCII, “doug”. Na Figura 4 é apresentada a mensagem
original, representada em binário.
Figura 4 - Mensagem Original (Exemplo da função Message Padding).
Na Figura 5 pode-se observar a mensagem resultante após a inserção de um bit ‘1’ ao final do
último bloco.
Figura 5 - Inserção de um bit “1” (Exemplo da função Message Padding).
28
Tendo em vista que já foi acrescentado um bit “1” na etapa anterior e como o tamanho da
mensagem original é de 32 bits, são acrescentados 415 bits “0”, totalizando assim 448 bits. Na
Figura 6 pode-se observar o bloco resultante, representado em hexadecimal.
Figura 6 - Inserção de n bits “0” (Exemplo da função Message Padding).
Nesta etapa, são concatenados os 64 bits referentes ao tamanho da mensagem original que é
de 32 bits (20H). A Figura 7 apresenta o bloco resultante após esta concatenação:
Figura 7 – Bloco resultante (Exemplo da função Message Padding).
2.3.3 Funções utilizadas na função Gera resumo
Para realizar o processamento do resumo da mensagem, o algoritmo SHA-1 utiliza uma
seqüência de funções lógicas. Estas utilizam três operandos de 32 bits (B, C e D) como
entrada e têm como resultado um operando de 32 bits. Estas funções são utilizadas de acordo
com as 80 iterações necessárias para o processamento de cada bloco de 512 bits no algoritmo
SHA-1. A seguir tem-se a seqüência de funções F0 a F79:
Ft(B,C,D) = (B ^ C) v ((~B) ^ D) 0 ≤ t ≤ 19
Ft(B,C,D) = (B XOR C XOR D) 20 ≤ t ≤ 39
Ft(B,C,D) = (B ^ C) v (B ^ D) v (C ^ D) 40 ≤ t ≤ 59
Ft(B,C,D) = (B XOR C XOR D) 60 ≤ t ≤ 79
29
2.3.4 Constantes utilizadas na função Gera resumo
O algoritmo SHA-1 possui quatro constantes que são utilizadas de acordo com a iteração que
estiver sendo processada ao gerar o resumo da mensagem. Na Tabela 2 são apresentados os
valores em hexadecimal das constantes correspondentes a cada iteração:
Tabela 2 - Funções e constantes utilizadas pelo SHA-1
Funções Constantes Iterações Ft(B,C,D) = (B ^ C) v ((~B) ^ D) 5A827999 0 a 19 Ft(B,C,D) = B XOR C XOR D 6ED9EBA1 20 a 39 Ft(B,C,D) = (B ^ C) v (B ^ D) v (C ^ D) 8F1BBCDC 40 a 59 Ft(B,C,D) = B XOR C XOR D CA62C1D6 60 a 79
Fonte: Moreno, Pereira, & Chiaramonte (2005).
2.3.5 Gerando o resumo da mensagem
O resumo da mensagem é gerado utilizando o resultado da função message padding. Este é
dividido em 16 palavras de 32 bits que são processadas para a obtenção do resumo. Na Figura
8 pode-se observar o pseudo-código da função Gera resumo.
30
Figura 8 - Pseudo-código da função que gera o resumo da mensagem.
Para melhor compreensão da função Gera resumo será apresentado um exemplo do seu
funcionamento.
Este exemplo utiliza uma mensagem de 448 bits composta por uma string de 56 caracteres
ASCII. A Figura 9 apresenta uma mensagem em código ASCII.
Figura 9 - Mensagem (Exemplo da função Gera resumo).
Fonte: Adaptado de NIST (1995).
31
Para o processo de geração do resumo são utilizadas cinco variáveis com valores constantes
pré-definidos. Na Figura 10 pode-se observar os valores pré-definidos das variáveis H0, H1,
H2, H3 e H4.
Figura 10 - Inicialização das variáveis H0, H1, H2, H3 e H4 (Exemplo da função Gera resumo).
Fonte: Adaptado de NIST (1995).
A função message padding é de uso obrigatório na mensagem original, tornando necessário,
neste exemplo, a utilização de dois blocos. Tendo em vista que a mensagem original possui
448 bits, ao inserir os bits referentes à função message padding não haveria como acrescentar
os 64 bits referentes ao tamanho da mensagem original. Então para completar os 512 bits do
bloco é necessário acrescentar um bit ‘1’ seguido de n bits ‘0’, na qual n é 63. Na Figura 11 é
apresentada o primeiro bloco, representado em hexadecimal.
Figura 11 - Primeiro Bloco (Exemplo da função Gera resumo).
Fonte: Adaptado de NIST (1995).
Ao processar um bloco são utilizadas cinco variáveis auxiliares A, B, C, D e E. Nestas são
atribuídos os valores de H0, H1, H2, H3 e H4 respectivamente. Na Figura 12 são apresentadas
as alterações nas variáveis auxiliares decorrentes as 80 iterações da função Gera resumo ao
processar o primeiro bloco.
32
33
Figura 12 - Processamento do primeiro bloco (Exemplo da função Gera resumo).
Fonte: Adaptado de NIST (1995).
Após o processamento do primeiro bloco são somadas as variáveis auxiliares A, B, C, D e E
com as variáveis H0, H1, H2, H3 e H4 respectivamente. Na Figura 13 pode-se observar o
resultado desta adição.
Figura 13 - Resultado do processamento do primeiro bloco (Exemplo da função Gera resumo).
Fonte: Adaptado de NIST (1995).
34
Como não foi possível adicionar os 64 bits referentes ao tamanho da mensagem original no
bloco anterior, devido à obrigatoriedade da utilização da função message padding, é
necessário processar o segundo bloco. Este é composto por n bits ‘0’, na qual n é 448, e por
mais 64 bits referentes ao tamanho da mensagem original. Na Figura 14 pode-se observar a
representação do tamanho da mensagem original em hexadecimal, que é de 448 bits (1C0H).
Figura 14 - 64 bits referentes ao tamanho da mensagem original (Exemplo da função Gera resumo).
Fonte: Adaptado de NIST (1995).
A Figura 15 apresenta o segundo bloco.
Figura 15 - Segundo bloco (Exemplo da função Gera resumo).
Fonte: Adaptado de NIST (1995).
Na Figura 16 pode-se observar as alterações nas variáveis auxiliares A, B, C, D e E
decorrentes as 80 iterações da função Gera resumo ao processar o segundo bloco.
35
36
Figura 16 - Processamento do segundo bloco (Exemplo da função Gera resumo).
Fonte: Adaptado de NIST (1995).
Após o processamento do segundo bloco são somadas as variáveis auxiliares A, B, C, D e E
com as variáveis H0, H1, H2, H3 e H4 respectivamente. Na Figura 17 pode-se observar o
resultado desta adição.
Figura 17 - Resultado do processamento do segundo bloco (Exemplo da função Gera resumo)
Fonte: Adaptado de NIST (1995).
O resumo da mensagem gerado após o processamento dos dois blocos é apresentado na Figura
18.
Figura 18 - Resultado do processamento do segundo bloco (Exemplo da função Gera resumo).
Fonte: Adaptado de NIST (1995).
37
2.4 CONSIDERAÇÕES
Neste capítulo foram apresentados aspectos funcionais do algoritmo SHA-1, bem como suas
principais características: mensagem, resumo, operando e bloco e funções utilizadas. Estas
características são consideradas no Capítulo 4 na implementação do algoritmo SHA-1.
38
3 PROCESSADOR DIGITAL DE SINAIS
Este capítulo apresenta a história dos processadores digitais de sinais, assim como as
características do ambiente de desenvolvimento Code Composer Studio (CCS) e do
processador digital de sinais escolhido para realizar a implementação do algoritmo hash SHA-
1.
3.1 INTRODUÇÃO AO DSP
Com a introdução dos microprocessadores em 1970, tornou-se possível a utilização do
processamento digital de sinais em larga escala. Em 1980 a importância crescente dos
processadores dedicados para realizar aplicações de processamento digital de sinais conduziu
diversos fabricantes de dispositivos eletrônicos (tais como Texas Instruments, Analog
Devices, Motorola) a desenvolverem microprocessadores especializados com a arquitetura
projetada para realizar as operações requeridas no processamento digital de sinais
(DSPTUTOR, 2008).
Os processadores digitais de sinais são dispositivos programáveis que operam em tempo real.
Estes dispõem de grande capacidade de processamento de dados e velocidade superior aos
microprocessadores de propósito geral (WOLTER, 2007). O processador digital de sinais,
como o termo sugere, é um processador de sinais digitais. Neste contexto, o termo digital vem
da palavra digito que significa um número, e sinal refere-se a um sinal eletrônico carregado
por fio, linha telefônica ou ondas de rádio (DSPTUTOR, 2008).
Como um microprocessador de propósito geral, um DSP possui seu próprio conjunto de
instruções. Os DSPs são capazes de realizar milhões de operações por segundo, e como os
39
demais processadores de propósito geral, estão sendo introduzidas continuamente novas
versões com melhor desempenho (DSPTUTOR, 2008).
Em alguns casos, o sinal está em formato analógico de tensão ou corrente, produzido por meio
de um microfone ou algum outro tipo de dispositivo transdutor. Logo, o sinal analógico
precisa ser convertido para um sinal digital tornando possível a utilização do mesmo em
DSPs. Para realizar tal conversão é utilizado um conversor analógico/digital (A/D). Já em
outras situações como, por exemplo, um leitor de CD o sinal é adquirido já no formato digital
sem a necessidade de realizar esta conversão (DSPTUTOR, 2008).
Os DSPs são utilizados em telefones celulares, computadores multimídia, gravadores de
vídeo, tocadores de CD, controladores da movimentação de disco rígido e modens. Uma
importante aplicação do DSPs é na compressão e descompressão de sinais. A compressão de
sinais é utilizada em sistemas telefônicos permitindo que um grande número de ligações sejam
administradas simultaneamente. A técnica de compressão de sinais além de permitir a
conversação, permite também a utilização na transmissão de imagem em tempo real. Em
sistemas de CD de áudio, o DSP é usado na detecção e correção de erros nos dados de leitura
do CD (DSPTUTOR, 2008).
Algumas das técnicas da teoria matemática dos DSPs, tais como a transformada de Fourier e
de Hilbert, a compressão e o projeto de um filtro digital, podem ser razoavelmente complexas.
Porém, as operações numéricas requeridas para executar estas técnicas são muito simples
como, por exemplo, multiplicação e acumulação, consistindo principalmente nas operações
que poderiam ser feitas em uma calculadora de quatro funções. A arquitetura de um DSP é
projetada para realizar tais operações de maneira rápida, processando milhões de amostras a
cada segundo, fornecendo o desempenho de tempo real (DSPTUTOR, 2008).
Os principais fabricantes de eletrônica investiram massivamente na tecnologia de DSP, pois
encontraram aplicações do mesmo em produtos vendidos em larga escala. Com isto, as vendas
atingem bilhões de dólares anualmente, e tendem a aumentar rapidamente (DSPTUTOR,
2008). Os DSPs caracterizam a fração que mais cresce no mercado de semicondutores e são
capazes de suprir a crescente demanda por processamento rápido de informações, como nas
conexões entre redes de computadores. Os DSPs são os principais componentes em 70 por
40
cento dos telefones celulares existentes em todo o mundo e permitem melhorias no
desempenho dos sistemas de freios em automóveis (TI, 2008a).
3.2 PROCESSADOR DIGITAL DE SINAIS TMS320C5410
O processador digital de sinais escolhido para realizar a implementação em assembly é o
TMS320C5410 da família C5000 da Texas Instruments. No Quadro 2 pode-se observar as
possíveis aplicações desta família de processadores e o que a difere das demais. Esta é uma
família de processadores de baixo custo e é utilizada em aplicações de áudio, biometria,
controle digital e telecomunicação (TI, 2008a).
Quadro 2 - Aplicações referentes às famílias dos DSPs.
Fonte: Adaptado de TI (2008a).
A Texas Instruments (TI) além de ser a pioneira é também a líder no mercado mundial de
DSPs. A TI possui três famílias de processadores com arquiteturas específicas:
TMS320C6000™, TMS320C5000™ e TMS320C2000™ (TI, 2008a).
Os processadores da família TMS320C6000™ são processadores de alta desempenho, ou seja,
têm maior capacidade de processamento. Esta alta capacidade de processamento provê
benefícios adicionais às aplicações em tempo real, como por exemplo, digitalização de
imagens e redes de banda larga (TI, 2008a).
Já os processadores da família TMS320C2000™ são processadores utilizados em controle
digital otimizado. Estes oferecem um conjunto de soluções para controle digital possibilitando
a redução do custo do sistema total. Dentro desta família o DSP C24x™ possui uma
combinação de capacidade de processamento e funções periféricas específicas para controle.
41
Esta combinação permite maior eficiência em controle de motores elétricos, menores níveis de
ruídos, consumos de energia mais baixos e maior confiabilidade em eletrodomésticos (TI,
2008a).
Os processadores da família TMS320C5000™ têm como principal característica o baixo
consumo de energia, oferecendo DSPs com grande eficiência em termos de potência, com
reduções de consumo que atingem até 0,9 V e 0,05 mW/MIPS e com desempenho de até 800
MIPS. Estas características fazem com que esta família seja a melhor escolha para aplicações
em sistemas embarcados como tocadores de música digital (MP3 players), telefones celulares
e câmeras fotográficas digitais (TI, 2008a).
O DSP TMS320C5410 opera com freqüência de 100MHz, realiza 100 Milhões de instruções
por segundo (MIPS), possui 128KB de memória RAM e 32KB de memória ROM. Este
processador tem 64K palavras de 16 bits de memória de dados e sua memória de programa é
configurável, podendo ser configurada com endereços internos ou externos (TI, 2000).
3.2.1 Gerações de Códigos-Compatíveis
A geração de TMS320C54x possui mais de 17 dispositivos com códigos compatíveis. Estes
possuem uma larga escala de desempenho e opções periféricas, baixo consumo de energia e
uma inovadora arquitetura e conjunto de instruções, proporcionando ao desenvolvedor uma
maneira eficaz de adquirir alto desempenho, baixo consumo de energia e um sistema de baixo
custo (TI, 2008a).
Após o surgimento da família de DSPs TMS320C54x foi desenvolvida outra família de
código compatível, porém com maior eficiência. Esta família de DSPs é a TMS320C55x, que
utiliza técnicas avançadas de gerência de energia que automaticamente desativam periféricos,
memórias e unidades funcionais do processador que estejam inoperantes, aumentado assim a
vida útil da bateria em aplicações portáteis (TI, 2008a).
42
3.2.2 Arquitetura da geração de DSPs TMS320C54x™
Esta é uma geração de processadores de ponto fixo baseados em uma arquitetura Harvard
modificada que tem um barramento de memória de programa e três barramentos de memória
dos dados conforme apresentado na Figura 19.
43
Figura 19 - Diagrama de bloco da geração de DSPs TMS320C54XX.
Fonte: TI (1997).
44
Estes processadores fornecem também uma unidade lógica aritmética (ULA) com elevado
grau de paralelismo, além de um conjunto de instrução altamente especializado, que é a base
da flexibilidade e da velocidade operacional destes DSPs (TI, 2000).
Internamente, há diversos barramentos como:
• P-Bus, usado para buscar instruções da memória do programa.
• C-Bus e D-Bus, dois barramentos de dados que permitem buscar dois operandos ou
uma palavra de 32 bits em um único ciclo de clock.
• E-Bus, um barramento de dados, separado para saída, que permite leitura e escrita
simultânea em uma instrução paralela.
A arquitetura Harvard modificada permite acesso simultâneo às instruções e aos dados do
programa, fornecendo um elevado grau de paralelismo, permitindo realizar duas leituras e
uma escrita em um único ciclo de clock. As instruções com armazenamento paralelo e as
instruções de aplicações específicas podem utilizar esta arquitetura. Tal paralelismo suporta
um poderoso conjunto de operações aritméticas, lógicas e manipulação de bit que podem ser
executadas em um único ciclo de clock, além de incluir os mecanismos de controle para laços
de repetições, chamadas de funções e controle de interrupções (TI, 2000).
3.2.3 Modos de endereçamento
A família de DSPs TMS320C54x tem três tipos de endereçamento: endereçamento imediato,
endereçamento diretos (página + deslocado (offset)), e endereçamento indireto (TI, 1997).
O endereçamento imediato é simples; por exemplo, para armazenar 15h no acumulador A
basta utilizar o comando:
LD #15h,A
O endereçamento direto requer o uso de um ponteiro apontado para a página dos dados (DP) e
um offset na página de 128-word.
45
O endereçamento indireto do TMS320C54x permite muitas alternativas. Por exemplo, *ARn
acessa o valor que o ponteiro ARn está apontado. Outro exemplo, *ARn+, *ARn+0, e
*ARn+0% respectivamente, fornecem o incremento em uma posição de memória na qual o
ponteiro está apontando, o incremento com o tamanho variável, e a fila circular (TI, 1997).
3.2.4 Pipeline
Os DSPs da família TMS320C54x tem um pipeline9 de seis níveis, como mostra a Figura 20.
Pré-busca – Lê instruções permitindo a previsão de desvios estáticos ou dinâmicos;
Busca – Busca a instrução a ser executada;
Decodifica – Decodifica a instrução;
Acessa - Realiza operações de Store/Load;
Lê – Lê os operandos necessários para execução da instrução; e
Executa – Executa a instrução.
O pipeline fornece um aumento na taxa de transferência de dados, mas requer atenção ao
programar, pois apesar da maioria dos registradores ter seu valor atualizado na fase de
execução do pipeline, alguns são atualizados em outras fases, tais como os registradores
auxiliares (AR) que são atualizados durante a fase de acesso (TI, 1997).
Figura 20 - Arquitetura pipeline da família TMS320C54X
Fonte: Adaptado de TI (1997).
9Pipeline é uma estrutura de hardware que permite ao DSP realizar a execução de instruções em paralelo
(SILVA, 2008).
46
3.3 AMBIENTE DE DESENVOLVIMENTO (CCS)
A Figura 21 apresenta o ambiente de desenvolvimento Code Composer Studio IDE, que
oferece uma robusta plataforma de programação. Este ambiente possui ferramentas gráficas,
para que o sistema seja projetado com rapidez, e características que são utilizadas durante o
ciclo de desenvolvimento. Suas principais ferramentas são: (TI, 2008a).
• Projeto da aplicação - esta etapa inclui a BIOS do DSP e estruturas de
referência.
• Código e configuração - esta etapa inclui o editor C/C++ e Assembly.
• Debug - esta etapa inclui a depuração e simulação do código.
• Análise e ajuste - esta etapa inclui a análise em tempo real do compilador.
Figura 21 - Code Composer Studio IDE.
Fonte: Texas Instruments.
3.3.1 Projeto da Aplicação
Ao projetar um sistema em DSP se consome a maior parte do tempo realizando o projeto da
aplicação e o planejamento. O Code Composer Studio possui poderosas ferramentas de
desenvolvimento como, por exemplo, configuração da BIOS do DSP, algoritmo padrão
47
eXpressDSP e Update Advisor, que permitem realizar o planejamento e a configuração da
estrutura da aplicação de forma mais eficiente (TI, 2008a).
3.3.1.1 Configuração da BIOS do DSP
A BIOS do DSP é projetada para ser pequena e rápida para suportar aplicações
multifuncionais avançadas. O Code Composer Studio inclui uma ferramenta de configuração
da BIOS para realizar os ajustes de serviços. Usando a ferramenta de configuração da BIOS,
pode-se configurar rapidamente os seguintes serviços: Múltiplas threads; Mecanismo de
comunicação entre threads; Interrupções; Análise de tempo real (TI, 2008a).
3.3.1.2 Algoritmo padrão eXpressDSP
O algoritmo padrão eXpressDSP realiza o gerenciamento de soluções que simplifica a
integração do sistema, provendo estruturas da aplicação que melhorem a qualidade dos
componentes e da reutilização do software (TI, 2008a).
3.3.1.3 Update Advisor
O Update Advisor é um componente que permite receber atualizações, novas características e
reparos de erro do Code Composer Studio.
3.3.2 Código e Configuração
O Code Composer Studio oferece aos desenvolvedores um conjunto de ferramentas para a
criação e edição do código, e a gerência de projeto. O ambiente Code Composer Studio possui
uma IDE projetada para maximizar a produtividade com uma aparência altamente intuitiva.
Esta possui a navegação e os ícones intuitivos baseados em padrões populares da indústria,
permitindo que os desenvolvedores tornem-se produtivos imediatamente. Os desenvolvedores
têm a flexibilidade para ajustar o ambiente de desenvolvimento para servir à suas
necessidades em algum ponto durante seu ciclo de desenvolvimento. Janelas podem ser
movidas, adicionadas ou removidas de acordo com a necessidade, dando ao desenvolvedor
controle completo do ambiente (TI, 2008a).
48
3.3.2.1 Code Generation Tools
No passado, o desenvolvimento de códigos com alto desempenho para DSP requeria um
código otimizado em linguagem assembly e um conhecimento da arquitetura particular do
DSP. Devido à importância de que o produto chegue rapidamente ao mercado e à dificuldade
de se obter tempo e habilidade de codificar de maneira otimizada para DSP, há a necessidade
de um ambiente de desenvolvimento de código mais robusto. A Texas Instruments compila
ferramentas dirigidas a esta necessidade de otimização do código em assembly para o
compilador de linguagem “C”. Com estas ferramentas é possível explorar o desempenho
elevado de plataformas de DSP sem a necessidade de programar em linguagem assembly (TI,
2008a).
3.3.3 Debug
Desenvolvedores gastam aproximadamente 60% do seu tempo eliminando erros do processo
de desenvolvimento. A ferramenta de depuração do Code Composer Studio inclui
características que ajudam os desenvolvedores a encontrar e reparar os erros (TI, 2008a).
3.3.3.1 Debugger
Os desenvolvedores requerem um depurador que suporte uma larga escala de potencialidades.
Estas potencialidades variam de funções básicas como a inserção de pontos de parada
(brakepoints) a funções avançadas como a análise em tempo real. O depurador do Code
composer studio fornece todas essas funcionalidades com uma interface ergonômica (TI,
2008a).
3.3.4 Análise e ajuste
A análise e o processo de ajuste são áreas que distinguem o desenvolvimento em tempo real
dos outros tipos de desenvolvimento de software. Este estágio crítico focaliza em superar as
restrições de desempenho em tempo real visando aumentar o número de tarefas que são
executadas no processador, ou reduzir o desperdício de memória na operação. Boas
49
ferramentas nestas áreas podem reduzir em semanas o tempo necessário para codificação e a
redução do custo do sistema para os clientes (TI, 2008a).
3.3.4.1 Análise em tempo real
A análise em tempo real permite que o usuário visualize as informações capturadas mesmo
após a aplicação ter sido interrompida. Estas informações são apresentadas por meio da
ferramenta de análise em tempo real do Code composer studio, esta fornece a seqüência de
eventos até alcançar o ponto atual da execução. Além disso, estruturando a aplicação em torno
da BIOS do DSP e de objetos que fornecem suporte a múltiplas threads e I/O, é possível
capturar e atualizar informações em tempo real (TI, 2008a).
3.4 CONSIDERAÇÕES
Neste capítulo foi apresentada uma breve história sobre os processadores digitais de sinais,
assim como algumas aplicações nas quais estes são utilizados e características da sua
arquitetura. Também foi apresentado o ambiente de desenvolvimento CCS, assim como suas
características e funcionalidades.
50
4 IMPLEMENTAÇÃO
Este capítulo apresenta uma abordagem sobre a implementação do algoritmo hash SHA-1 em
linguagem “C” e Assembly. A implementação em linguagem “C” foi desenvolvida por Paul E.
Jones e é utilizada como base para a implementação em linguagem assembly. Este capítulo
apresenta a comparação da função gera resumo de mensagem em linguagem “C” e Assembly
verificando,suas particularidades. Esta foi escolhida, pois é a principal função do algoritmo
SHA-1.
4.1.1 Implementação em linguagem “C” e Assembly
Uma vantagem deste DSP é possuir dois acumuladores auxiliares “A” e “B” de 40 bits, que
permitem o processamento de operações de 32 bits de forma direta, tais como as existentes no
algoritmo SHA-1, facilitando a implementação.
A Figura 22 apresenta o laço de repetição que realiza a expansão do bloco de 512 bits (16
palavras de 32 bits) em um bloco de 2560 bits (80 palavras de 32 bits). Para realizar tal tarefa
leva-se em consideração que o bloco já esteja preenchido com as 16 palavras de 32 bits
referentes ao arquivo de entrada. Este laço de repetição utiliza a função SHA1CircularShift
que recebe como entrada dois parâmetros, o primeiro referente ao número de bits a serem
rotacionados à esquerda e o segundo é referente ao operando de 32 bits a ser rotacionado (Este
operando é obtido pela operação W[t-3] XOR W[t-8] XOR W[t-14] XOR W[t-16], onde W é
o bloco de 512 bits a ser expandido). Esta função retorna um operando de 32 bits rotacionado
em n bits à esquerda.
Figura 22 - Código fonte em linguagem “C” do laço de repetição para espalhamento do bloco de 512.
51
A Figura 23 apresenta o laço de repetição que realiza a expansão do bloco, porém em
linguagem assembly. Para realizar tal tarefa foi necessário utilizar cinco ponteiros apontando,
respectivamente, para W[t], W[t-3], W[t-8], W[t-14] e W[t-16], onde W representa o bloco
expandido de 2560 bits (80 palavras de 32 bits). Como o DSP escolhido é de 16 bits foi
necessário alocar 160 palavras de 16 bits para representar o bloco, onde a primeira palavra
corresponde à parte alta do operando e a segunda a parte baixa do operando.
Figura 23 - Código fonte em linguagem assembly do laço de repetição para espalhamento do bloco de 512.
Para realizar a função SHA1CircularShift foi utilizada a operação SFTL. Esta recebe dois
parâmetros, da mesma forma que a função em linguagem “C”, porém retorna somente o
operando deslocado em n bits. Para que este resulte no operando rotacionado, é necessário
verificar se ao deslocar à esquerda ele ultrapassou os 32 bits, caso isso tenha ocorrido basta
adicionar 1 ao operando de 32 bits para obter o operando rotacionado, caso contrário, o
operando já está rotacionado e não há necessidade de realizar nenhuma outra operação.
52
Outros recursos utilizados neste laço de repetição são as operações DLD (Dual Load) e DST
(Dual Store), na qual DLD carrega simultaneamente dois operandos de 16 bits para a variável
“A” ou “B”. Já a operação DST realiza o armazenamento simultâneo de 32 bits da variável
“A” ou “B” para duas variáveis de 16 bits alocadas sequencialmente no DSP.
Na Figura 24 pode-se observar o primeiro laço de repetição necessário para gerar o resumo da
mensagem. Este laço realiza as iterações T0 a T19, nas quais utilizam as variáveis auxiliares de
32 bits “A”, “B”, “C”, “D” e “E”, que representam o resumo de mensagem no atual momento,
e uma variável temporária (temp) de 32 bits necessária para armazenar o resultado da variável
“A”.
Figura 24 - Código fonte em linguagem “C” do primeiro laço de repetição da função gera resumo.
Na Figura 25 pode-se observar o segundo laço de repetição necessário para gerar o resumo da
mensagem que realiza as iterações T20 a T39.
Figura 25 - Código fonte em linguagem “C” do segundo laço de repetição da função gera resumo.
Na Figura 26, pode-se observar o terceiro laços de repetição necessário para gerar o resumo da
mensagem que realiza as iterações T40 a T59.
53
Figura 26 - Código fonte em linguagem “C” do terceiro laço de repetição da função gera resumo.
Na Figura 27, pode-se observar o quarto laço de repetição necessário para gerar o resumo da
mensagem que realiza as iterações T60 a T79.
Figura 27 - Código fonte em linguagem “C” do quarto laço de repetição da função gera resumo.
Todos os quatro laços de repetição utilizam a função SHA1CircularShift para rotacionar, à
esquerda, a variável “A” em 5 bits e a variável “B” em 30 bits. Já o que difere estes laços, são
as funções e constantes que variam de iteração para iteração. Estas diferenças podem ser
observadas na Tabela 2 (Capítulo 2) que apresenta as funções e constantes utilizadas pelo
algoritmo hash SHA-1 para a obtenção do resumo de mensagem.
Na Figura 28 pode-se observar o primeiro laço de repetição necessário para gerar o resumo da
mensagem em linguagem assembly, este realiza as iterações T0 a T19. Neste caso, para obter o
resultado da função F0 a F19 é necessário realizar a operação B & C e armazenar o resultado
em uma variável temporária (Temp1), depois realizar a operação (~B) & D e armazenar o
resultado em outra variável temporária (Temp2) e finalmente carregar as duas variáveis
temporárias e realizar o operação Temp1 OU Temp2 obtendo o resultado da função.
54
Figura 28 - Código fonte em linguagem assembly do primeiro laço de repetição da função gera resumo.
A Figura 29 apresenta o segundo laço de repetição necessário para gerar o resumo da
mensagem em linguagem assembly, este realiza as iterações T20 a T39. Neste caso, não é
necessário à utilização de variáveis temporárias para a obtenção do resultado da função F20 a
F39, devido ao fato de não haver prioridade sobre qual operação será realizada primeiro.
55
Figura 29 - Código fonte em linguagem assembly do segundo laço de repetição da função gera resumo.
Na Figura 30 pode-se observar o terceiro laço de repetição necessário para gerar o resumo da
mensagem em linguagem assembly, este realiza as iterações T40 a T59. Neste caso, para obter o
resultado da função F40 a F59 é necessário realizar a operação B & C e armazenar o resultado
em uma variável temporária (Temp1), depois realizar a operação B & D e armazenar o
resultado em outra variável temporária (Temp2), depois realizar a operação C & D e
armazenar em uma terceira variável temporária (Temp3) e por final carregar as duas variáveis
temporárias e realizar o operação Temp1 OU Temp2. Após esta etapa basta carregar a terceira
variável e realizar a operação (Temp1 OU Temp2) OU Temp3 obtendo o resultado da função.
56
Figura 30 - Código fonte em linguagem assembly do terceiro laço de repetição da função gera resumo.
A Figura 31 apresenta o quarto laço de repetição necessário para gerar o resumo da mensagem
em linguagem assembly, este realiza as iterações T60 a T79. Neste caso, não há necessidade de
utilização de variáveis temporárias, de maneira similar ao segundo laço de repetição.
57
Figura 31 - Código fonte em linguagem assembly do quarto laço de repetição da função gera resumo.
4.2 CONSIDERAÇÕES
Neste capítulo foram apresentadas as principais funções do algoritmo hash SHA-1 em
linguagem “C” e assembly, assim como suas característica e o que as diferem ao implementar
em linguagem “C” e Assembly. Também foi abordada a vantagem de utilizar o DSP escolhido
para a implementação, visto que o mesmo possui dois acumuladores auxiliares de 40 bits que
facilitam a implementação em assembly.
58
5 RESULTADOS
Este capítulo apresenta resultados obtidos na implementação do algoritmo hash SHA-1.
Também são analisados os recursos computacionais que foram utilizados na implementação
do algoritmo, como, uso de memória e a mipagem10. Apresenta-se também uma comparação
entre outra implementação comercial do algoritmo visando validar a viabilidade desta
implementação comercialmente.
5.1 SIMULAÇÃO DO ALGORITMO
Na Tabela 3 são apresentadas as cinco variações possíveis de entrada para o algoritmo hash
SHA-1. Como primeira entrada foi escolhida uma mensagem de tamanho menor que 448 bits
para, validar o algoritmo com mensagens pequenas de apenas um bloco (448 bits referentes ao
tamanho da mensagem e 64 bits necessário para indicar o tamanho da mensagem, totalizando
um bloco de 512 bits). A segunda entrada possui tamanho de mensagem igual a 448 bits
validando o algoritmo para mensagens pequenas, mas que não fosse possível processá-las
utilizando apenas um bloco, sendo necessário utilizar um segundo bloco para inserir os 64 bits
referentes ao tamanho da mensagem.
10Mipagem é uma medida também conhecida por MIPS (milhões de instruções por segundo), que tem por objetivo obter a velocidade de processamento de um computador (CRAGON, 2000).
59
Tabela 3 - Entradas e saídas em linguagem “C” e Assembly.
Nº Mensagem de Entrada/Resumo de Mensagem 1 “doug”
0798EBEC FB7BC4DF B9D0445C CFA030EB 64E1FA1C 2 “abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq”
84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
3 “abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopqopqrpqrs” 79EA0C76 F0056373 FFD6A5AA D389DD90 8B0C0E94 4 200 vezes letra “a”
E61CFFFE 0D9195A5 25FC6CF0 6CA2D771 19C24A40 5 250 vezes letra “a” B5D5E3E0 FCCCFB49 D704A1E1 0BC97CE9 761A14FE
A terceira entrada possui tamanho de mensagem de 512 bits para, validar o algoritmo com
mensagens que necessitem processar n blocos para gerar o resumo de mensagem. A quarta
entrada possui tamanho de mensagem de 1600 bits, validando o algoritmo para casos em que
a mensagem necessite processar n blocos para gerar o resumo de mensagem sendo que o
último
bloco é menor que 448 bits, de forma similar à primeira entrada. A última entrada possui
tamanho de mensagem de 2000 bits, validando o algoritmo para casos em que a mensagem
necessite de n blocos para gerar o resumo de mensagem sendo que o último bloco é maior que
448 bits, caso similar à segunda entrada.
Tanto o algoritmo em linguagem “C” quanto o algoritmo em linguagem Assembly obtiveram
os mesmo resultados para as cinco mensagens de entrada como esperado, comprovando que a
implementação está funcionando de maneira correta.
5.2 RECURSOS COMPUTACIONAIS
Este tópico apresenta uma breve comparação do algoritmo implementado em relação a uma
implementação comercial. A comparação foi baseada nos recursos computacionais utilizados
para a implementação do algoritmo hash SHA-1 em linguagem assembly tais como o
60
consumo de memória e a mipagem necessária para a execução do algoritmo. Estes recursos
computacionais são obtidos por meio de simulação no ambiente de desenvolvimento CCS.
5.2.1 Comparação com implementação comercial
A implementação comercial usada para esta comparação foi desenvolvida pela empresa
Snapshield Ltd. conforme referência (TI, 2008b). Para tal implementação foi utilizado um
DSP da família TMS320C54XX. Na Tabela 4 pode-se observar o consumo computacional da
implementação comercial e da desenvolvida.
Tabela 4 - Comparação com implementação de uso comercial.
Implementação Memória de programa Memória Total Mipagem Snapshield Ltd. 1,4 kb 1,5 kb 3,2 MIPS
Desenvolvida 1,58 kb 1,59 kb 4 MIPS
Para a obtenção da ocupação de memória do algoritmo desenvolvido foi utilizado o mapa de
memória que é obtido por meio da compilação do programa utilizando o CCS, e os resultados
obtidos foram de 1,58 kb de memória de programa e 1,59 kb de ocupação total de memória.
Comparando a ocupação de memória da implementação comercial com a implementação
desenvolvida pode-se observar que os resultados são equivalentes.
Para realizar o cálculo da mipagem do algoritmo implementado é necessário saber quantos
ciclos de clock foram utilizados para a execução do algoritmo por completo. Este valor é
obtido utilizando a ferramenta Profile do CCS, que retorna quantos ciclos de clock foram
necessários para a execução do algoritmo utilizando um bloco de 512 bits como entrada. Este
recurso também permite analisar a demanda de processamento de cada função o que permite
saber quais são as funções criticas do seu algoritmo, possibilitando assim realizar otimizações
no software.
O valor obtido por meio do cálculo é de 4 MIPS, já a implementação comercial tem mipagem
de 3,2 MIPS. Em relação à mipagem, o algoritmo implementado demonstrou certa
inferioridade, tendo em vista que a implementação comercial tem a mipagem inferior.
61
Uma alternativa para alcançar o desempenho de 3,2 MIPS obtida pela implementação
comercial é a utilização de instruções em paralelo, a fim de, reduzir os ciclos de clock
necessários para a execução do algoritmo. Algo que se deve considerar é que o algoritmo
comercial foi desenvolvido por uma empresa líder no que se refere a projetar e desenvolver
sistemas criptográficos para redes de dados.
5.3 CONSIDERAÇÕES
Neste capítulo foram apresentados os resultados obtidos por meio da implementação em
linguagem assembly. Também foram analisados os recursos computacionais utilizados na
implementação e uma breve comparação em relação a uma implementação comercial do
algoritmo hash SHA-1.
62
6 COMENTÁRIOS E CONCLUSÕES
6.1 CONCLUSÕES
Este trabalho abordou a implementação do algoritmo hash SHA-1 para o processador digital
de sinais TMS320C5410 da Texas Instruments.
Inicialmente foi realizado a análise das principais características do algoritmo hash SHA-1, de
forma a facilitar sua implementação.
Posteriormente o algoritmo SHA-1 foi implementado em linguagem “C”. O funcionamento da
implementação foi validado para as diferentes combinações possíveis de entrada. Este
resultado permitiu que a implementação em linguagem “C” fosse utilizada como referência
para a implementação do SHA-1 em linguagem assembly.
Na seqüência o algoritmo SHA-1 foi implementado em linguagem assembly para o DSP
TMS320C5410, sendo seu funcionamento validado por meio de simulações no computador,
utilizando arquivos no qual já se conhecia o resumo de mensagem. Finalmente foram
realizados testes de desempenho, onde a complexidade computacional e a ocupação de
memória mostraram-se compatíveis com uma implementação comercial.
Algo que deve ser levado em consideração é o fato de não ter sido encontrada nenhuma
implementação em DSP do algoritmo SHA-1 desenvolvida por empresas nacionais. Há um
custo elevado para aquisição desta implementação no exterior, tornando a implementação
desenvolvida uma alternativa interessante para empresas nacionais.
63
6.2 TRABALHOS FUTUROS
Algumas sugestões de trabalhos futuros são:
• Desenvolvimento do sistema de assinatura digital integrando o SHA-1 e o DSA.
• Desenvolvimento de algoritmos hash mais robustos como SHA-256, SHA-512.
• Implementação do algoritmo SHA-1 em hardware.
64
REFERÊNCIAS BIBLIOGRÁFICAS
BURNETT, Steve, PAINE, Stephen. Criptografia e segurança: o guia oficial RSA. 1. ed. Rio de Janeiro: Campus, 2002. ISBN 85-352-1009-1.
CASA CIVIL – Presidência da República. Medida provisória No 2.200-2. 2001. Disponível em https://www.planalto.gov.br/ccivil_03/MPV/Antigas_2001/2200-2.htm. Acessado em 23 de agosto de 2007.
CNN.com. Clinton signs e-signature bill into law. 2000. Disponível em http://archives.cnn.com/2000/ALLPOLITICS/stories/06/30/clinton.e.signatures.04/index.html. Acessado em 23 de agosto de 2007.
DACS SOFTWARE. DSP Compilers: challenges for efficient DSP code generation. 2001. Disponivel em www.dacsindia.com/embedded/tech/DSP_COMP_WP01.pdf. Acessado em 29 de agosto de 2007.
CRAGON, Harvey G. Computer Architecture and Implementation. Cambridge University Press, New York, 2000. ISBN 0-521-65168-9.
DSPTUTOR. Digital Signal Processing. Disponível em www.dsptutor.freeuk.com. Acessado em 22 de abril de 2008.
LIMA, Marcelo Ferreira de. Assinatura digital: solução delphi & capicom. Florianópolis: Visual Books LTDA., 2005. ISBN 85-7502-171-0
MENEZES, Alfred J., OORSCHOT, Paul C. van, VANSTONE, Scott A. Handbook of Applied Cryptography. New York: CRC Press, Inc., 1996. ISBN 0849385237.
MORENO, Edward David, PEREIRA, Fábio Dacêncio, CHIARAMONTE, Rodolfo Barros. Criptografia em Software e Hardware. São Paulo: Novatec, 2005. ISBN 8575220691.
NIST. Secure Hash Standard. 1995. Disponível em http://www.itl.nist.gov/fipspubs/fip180-1.htm. Acessado em 24 de agosto de 2007.
NIST. Secure Hash Standard. 2002. Disponível em http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf. Acessado em 16 de setembro de 2007.
JONES, Paul E. Implementação do algoritmo SHA-1 em linguagem "C". Disponível em: http://www.ietf.org/rfc/rfc3174.txt. Acessado em 25 abril de 2008.
SCHNEIER, Bruce. Applied cryptography. 2.ed. New York: John Wiley & Sons, Inc., 1996. ISBN 0-471-11709-9.
65
SILVA, Gabriel P. Arquitetura de Computadores II. Pipeline. Disponível em http://equipe.nce.ufrj.br/gabriel/arqcomp2/Pipeline.pdf. Acessado em 25 abril de 2008.
TERADA, Routo. Segurança de dados Criptografia em redes de computador. 1. ed. São Paulo: Edgard Blücher LTDA., 2000. ISBN 8521202830.
TI. Texas Instruments. 2008a. Disponível em http://focus.ti.com/paramsearch/docs/parametricsearch.tsp?family=dsp§ionId=2&tabId=132&familyId=324. Acessado em 14 de abril de 2008.
TI. Implementação comercial. 2008b. Disponível em http://focus.ti.com/dsp/docs/thirdparty/catalog/embeddedsoftwarefulldetails.tsp?productId=134. Acessado em 6 de maio de 2008.
TI. TMS320VC5410 Fixed-Point Digital Signal Processor Data manual. 2000. Disponível em focus.ti.com/lit/ds/symlink/tms320vc5410.pdf Acessado em 14 de abril de 2008.
TI. TMS320C54x DSP Programming Environment. 1997. Disponível em http://focus.ti.com/lit/an/spra182/spra182.pdf Acessado em 17 de abril de 2008.
WOLTER, Stefan Klaus. Processador digital de sinais. 2007. Disponivel em http://www.eletrica.ufpr.br/marcelo/TE810/012007/Stefan-DSP.pdf . Acessado em 22 de abril de 2008.
VAHID, Frank, GIVARGIS, Tony D. Embedded System Design: A Unified Hardware/Software Introduction. New York: John Wiley & Sons, Inc., 2002. ISBN: 0471386782.
VOLPI, Marlon Marcelo. Assinatura digital: aspectos técnicos, práticos e legais. Rio de Janeiro: Axcel Books do Brasil Editora LTDA., 2001. ISBN 85-7323-151-3.