PONTIFICIA UNIVERSIDADE CATÓLICA PUCPR ENGENHARIA DA...

PONTIFICIA UNIVERSIDADE CATÓLICA – PUCPR

ENGENHARIA DA COMPUTAÇÃO

ESCOLA POLITÉCNICA

FERNANDO BRASIL BABONI

PEDRO AUGUSTO CORSI DO NASCIMENTO

PROVENDO SEGURANÇA AO MEDIDOR INTELIGENTE COM

SMART CARDS

IMPLEMENTAÇÃO FINAL

CURITIBA

2016

FERNANDO BRASIL BABONI

PEDRO AUGUSTO CORSI DO NASCIMENTO


SMART CARDS

IMPLEMENTAÇÃO FINAL

Implementação final do Projeto, a ser

apresentado à disciplina Projeto Final II,

como parte da documentação do Projeto

Final a ser entregue para a conclusão do

curso de Engenharia de Computação da

Pontifícia Universidade Católica do

Paraná.

___________________________

Altair Olivo Santin (Orientador)

CURITIBA

2016


SMART CARDS

Fernando Brasil Baboni, Pedro Augusto Corsi do Nascimento

[email protected], [email protected]

Resumo. Devido à falta de proteção da memória do Medidor Elétrico

Inteligente (Smart Meter), produto largamente utilizado no mercado, e a

necessidade de armazenamento de dados privados no mesmo, o projeto

objetiva integrar o Smart Cards ao medidor e desenvolver as técnicas de

armazenamento/recuperação de dados privados e chaves criptográficas no

mesmo, a fim de proteger os dados contra invasores.

Desenvolver uma solução através do BasicCard da ZeitControl para

armazenar e criptografar todos os dados recebidos pelo Smart Meter. A

comunicação deles será através de protocolos e passados ao Smart Card

Reader. Também, será desenvolvido e validado um cenário de utilização de

teste do ambiente proposto.

___________________________

Fernando Brasil Baboni

___________________________

Pedro Augusto Corsi do Nascimento

ÍNDICE DE IMAGENS

Figura 1 - Diagrama de Blocos ......................................................................................... 9

Figura 2 - Diagrama de Blocos ....................................................................................... 10

Figura 3 - Arquitetura do Smart Card ............................................................................. 10

Figura 4 - Circuito Integrado Smart Card ....................................................................... 11

Figura 5 - Comunicação ................................................................................................. 19

Figura 6 - Protocolo T=1 ................................................................................................ 20

Figura 7 - Arquitetura do I-block ................................................................................... 21

Figura 8 - Leitor de Smart Card ...................................................................................... 22

Figura 9 - Leitor de Smart Card ...................................................................................... 28

Figura 10 – Gravado com sucesso .................................................................................. 33

Figura 11 – Dados armazenados com sucesso ................................................................ 33

ÍNDICE DE TABELAS

Tabela 1 - Enhanced Cards ............................................................................................. 14

Tabela 2 - Professional Cards .......................................................................................... 14

Tabela 3 - Multiapplication Cards ................................................................................... 15

Tabela 4 – Legenda dos Algoritmos ................................................................................ 15

Tabela 5 - Legenda das Criptografias .............................................................................. 16

Sumário 1. INTRODUÇÃO .................................................................................................................... 7

2. DETALHAMENTO DO PROJETO ..................................................................................... 9

2.1. SMART CARD ............................................................................................................... 10

2.2. BASICCARD .................................................................................................................. 13

2.3. PROGRAMAÇÃO ZC-BASIC ....................................................................................... 17

2.4. COMUNICAÇÃO ........................................................................................................... 19

2.8. SMART CARD READER .............................................................................................. 22

3. IMPLEMENTAÇÃO .......................................................................................................... 23

3.1. LEITURA DE DADOS ................................................................................................... 23

3.2. ARMAZENAMENTO DE DADOS ............................................................................... 23

3.3. CHAVE CRIPTOGRAFADA DESSES DADOS........................................................... 24

3.4. ARMAZENAMENTO/RECUPERAÇÃO DA CHAVE ................................................ 24

3.5. DETERMINAÇÃO DE ESPAÇO LIVRE ...................................................................... 24

3.6. DELEÇÃO/SUBSTITUIÇÃO DE CONTEÚDO ........................................................... 24

3.7. INSERÇÃO DE CONTEÚDO NUMA POSIÇÃO ESPECÍFICA DO SMART CARD 25

3.8. PROTEÇÃO DA CHAVE .............................................................................................. 25

4. PROCEDIMENTOS DE TESTES E VALIDAÇÃO DE PROJETO ................................. 26

5. MANUAL DO CÓDIGO .................................................................................................... 28

5.1. CÓDIGO DO CARTÃO ................................................................................................. 28

5.2. CÓDIGO DO USUÁRIO ................................................................................................ 29

5.3. CÓDIGO DO MEDIDOR ............................................................................................... 30

6. RESULTADOS ................................................................................................................... 33

7. CONCLUSÃO .................................................................................................................... 34

8. REFERÊNCIAS BIBLIOGRÁFICAS ................................................................................ 36

APÊNDICE A ............................................................................................................................. 37

APÊNDICE B ............................................................................................................................. 39

APÊNDICE C ............................................................................................................................. 43

APÊNDICE D ............................................................................................................................. 51

7

1. INTRODUÇÃO

A segurança de dados sempre foi uma preocupação. Com o surgimento da era

digital, esta dobrou principalmente com o receio de vazamento de informações sigilosas

e a integridade de transferências bancárias. A origem dos computadores, qualquer tipo de

serviço, alteração, execução de atividades requeriam um certo tipo de autenticação de

usuário, a fim de prevenir contra falhas e desastres.

Com o avanço tecnológico, novas técnicas de segurança vêm surgindo, como o

código de barras, radiofrequência, reconhecimento facial, biometria, senhas de acesso,

tags, e outros, e o Smart Card, que basicamente é um cartão com capacidade de

processamento e armazenamento de informações.

Discute-se muito a utilização de dispositivos como Smart Meter e Smart Cards, e

também a preocupação com os riscos de segurança e comprometimento da privacidade

dos dados. Assim como aplicações aonde estas tecnologias vêm sendo implantadas, como

transações digitais, compras e serviços pela internet, e também negociações e acessos

digitais. No atual cenário do mercado é possível encontrar Smart Cards sendo,

principalmente, utilizados como cartões de pagamento (débito/crédito) e sistemas de

identificação para login e acesso.

Diversas empresas vêm trabalhando fortemente com a evolução destas

tecnologias de longa data, porém há peculiaridades do ponto de vista construtivo nos

medidores inteligentes. Se os Smart Cards forem acessados fisicamente e o protocolo de

comunicação com o medidor atacado, existe a possibilidade de inferir nos dados. Desta

forma, o Smart Card não pode ser substituído ou a comunicação, entre o Smart Meter e

o Smart Card, seja violada sem que o medidor detecte.

Um grande estudo é então realizado sob estes devices, a busca pela segurança e

garantia de sigilo total de dados é um dos assuntos de maior importância. Este projeto tem

como finalidade provar o quanto as informações podem ser asseguradas e quão benéfico

as implementações de soluções a partir destes dispositivos podem ser para o usuário.

Este documento serve como Relatório e Implementação Final para o Projeto Final

de conclusão de curso de Engenharia da Computação e está dividido em diversas partes.

Inicialmente, é o detalhamento do projeto, onde será apresentado o diagrama de blocos

para se ter uma visão geral do projeto, bem como o modelo de Smart Card escolhido e

suas características. Logo após, vem os procedimentos de testes e validação do projeto

onde é apresentado uma lista de teste para serem realizados em módulos, tanto

individualmente como em conjunto. A finalização do documento encontra-se na etapa de

8

conclusão. Por fim, a referência bibliográfica com sua respectiva lista de sites, artigos e

livros acadêmicos.

9

2. DETALHAMENTO DO PROJETO

Para prover maior segurança de informação, o Smart Card foi escolhido para ser

o carro forte do projeto. Considerado o mais difícil para falsificação e com baixa taxa de

falhas, o cartão inteligente lidera no segmento de armazenamento e segurança de dados.

Para sua comunicação, é necessário um Smart Card Reader que serve como uma solução

de baixo custo para leitura e escrita de dados no cartão inteligente.

Figura 1 - Diagrama de Blocos

Os dados recebidos são processados pelo Smart Meter e passados para o Smart

Card através do Smart Card Reader. O cartão inteligente foi programado anteriormente

por um computador através de seu leitor. O cartão criptografa os dados recebidos e

armazena em sua memória EEPROM.

10

2.1. SMART CARD

Os Smart Cards são divididos em leitura/escrita de dados, tipos de Chip

implementado no cartão e sua capacidade. Existem milhares de modelos para todos os

tipos de projeto.

Figura 2 - Diagrama de Blocos

A arquitetura do Smart Card é padrão para todos os fabricantes, assim, torna-se

mais fácil estudá-los e programá-los. Matos afirma que a estrutura física é dividida em

três segmentos de acordo com a especificação da International Standards Organization

(ISO) 7810, 7816/1 e 7816/2. Elas são: cartão plástico de dimensões 85,60mm x 53,98mm

x 0,80mm, um circuito impresso e um chip de circuito integrado no cartão.

Figura 3 - Arquitetura do Smart Card

O circuito integrado no cartão, de acordo com a ISO 7816/3, mantém apenas cinco

pontos de conexão para dados e alimentação. Este é banhado a ouro para melhor condução

e é fixado na cavidade do cartão. Nguyen diz que o circuito protege o chip integrado do

estresse mecânico e de eletricidade estática, sendo sua comunicação através do contato

que atravessa o circuito impresso.

11

Esta comunicação para transmissão de dados é feita por uma serial bidirecional

conforme o padrão ISO 7816/3. Estas trocas de informações estão sob controle da

Unidade Central de Processamento do Chip. Para maior privacidade de dados, os

comandos dados pelo cartão sob a entrada de dados são mandados para o Chip que

responde com palavras de status e dados de saída até a confirmação desses comandos e

dados. A informação então é mandada em modo half duplex, ou seja, em apenas uma

única direção de transmissão de informações.

Figura 4 - Circuito Integrado Smart Card

Sua aparência é semelhante a um Chip de celular, porém enquanto um cartão de

telefone contém apenas memória, um Smart Card contém uma CPU, isto é, o cartão

possui capacidade de processar dados. Uma placa com processador típica de hoje pode

conter entre 32 a 256 k bytes de memória ROM (Read-Only Memory) para o Sistema

Operacional, 8 a 72 k bytes de memória EEPROM (Electrically-Erasable Programmable

Read-Only Memory) para os dados do cartão, e 256 a 4096 bytes de RAM (Random Access

Memory). A EEPROM é o "disco rígido" do cartão, ou seja, dados gravados na EEPROM

mantém seu valor quando o cartão é desligado. O aspecto mais importante do cartão com

processador é sua segurança.

A segurança do Smart Card varia com a sua funcionalidade. Borba cita exemplos

de uso deles: No sistema bancário, a sua segurança é baseada em senhas para que

estranhos não possam utilizar o cartão para realizar compras ou sacar dinheiro. Como

também, o cartão SIM, em outras palavras o Chip do celular, onde nele contém todas as

informações do usuário e do celular, tais como o número, tarifas e serviços acionados

pelo dono. Neste caso, o Smart Card tem a funcionalidade de criptografar essas

informações e as chamadas para a segurança do usuário final.

12

Nesses dois exemplos, é possível ver que o Smart Card cumpre bem o seu papel

de proteger os dados para que intrusos não possam acessá-las ou modificá-las para o seu

interesse. Bem como, uma forma de identificação do usuário na rede.

Unificando essas vantagens do uso do cartão inteligente, com sua simplicidade e

custo benefício, o Smart Card será usado para armazenar dados recebidos e analisados

pelo medidor, também para a mobilidade das informações contidas nele.

Para atender todas essas demandas, foram estudados diversos cartões inteligentes,

mas apenas os da ZeitControl passaram no teste. Assim, foram selecionados diversos

modelos deles, cada qual com suas características de memória e criptografia.

13

2.2. BASICCARD

O BasicCard da ZeitControl é um cartão inteligente com microprocessador. Rankl

et al (2010) afirma que cartões inteligentes com CPU são capazes de processar e

criptografar os dados sem necessidade de componentes instaladas, pois essas capacidades

já estão instaladas em sua arquitetura.

Sua arquitetura possui protocolo de comunicação baseado na ISO 7816/3, ou seja,

possui plena implementação de nível de bloco de T=0 e T=1 para sinais eletrônicos e

protocolos de transmissão. Também tem comandos internos para o carregamento da

EEPROM, permitir a criptografia, entre outros. Em relação a criptografia, o modelo da

ZeitControl possui comandos e respostas criptografados automaticamente.

De acordo com seu Datasheet, estes modelos de cartões inteligentes ainda

possuem uma memória EEPROM de 2 a 72k bytes, superando assim, todos os outros

pesquisados. Tem até quatro criptografias diferentes, sendo elas: DES, AES, EAX e

OMAC. Ele ainda conta com o algoritmo de segurança HASH SHA-256.

A criptografia utilizada no trabalho é o algoritmo DES (Data Encryption

Standard), aonde utiliza uma cifra em bloco, ou seja, é um algoritmo que recebe uma

string de tamanho fixo de um texto ou comando e transforma-o em um texto cifrado de

mesmo tamanho. Essa transformação é uma série de operações complicadas e invisíveis

ao usuário.

Para facilitar a sua implementação, o BasicCard é programado pela linguagem

ZC-BASIC e não precisa de um microcontrolador para processar seus dados.

Os cartões da ZeitControl são divididos em até três modalidades com diferentes

modelos: Enhanced (Aperfeiçoado), Professional (Profissional) e MultiApplication

(MultiAplicações). As diferenças deles vão desde criptografia, memória e até

comunicação. A programação é a mesma para todos, o que difere é o algoritmo de

criptografia a ser utilizado e o espaço de memória.

14

ENHANCED:

VERSÃO EEPROM RAM PROTOCOLO CRIPTOGRAFIA

ZC3.14 2k 256

bytes T = 1 DES

ZC3.34 8k 256

bytes T = 1 DES

ZC3.44 16k 256

bytes T = 1 DES

ZC3.54 32k 256

bytes T = 1 DES

Tabela 1 - Enhanced Cards

PROFESSIONAL:

VERSÃO ALGORITMO

PK EEPROM RAM PROTOCOLO CRIPTOGRAFIA EXTRAS

ZC5.4

EC-167

16k 1.8k

T=0 EAX

SHA-256 OMAC

EC-211 T=1 AES

DES

ZC5.5

EC-167

32k 1.8k

T=0 EAX

SHA-256 OMAC

EC-211 T=1 AES

DES

ZC5.6

EC-167

60.5k 1.8k

T=0 EAX

SHA-256 OMAC

EC-211 T=1 AES

DES

ZC7.5

RSA

32k 4k

T=0 EAX

SHA-256 T=1 OMAC

EC-p T-CL² AES

DES

ZC7.6

RSA

72k 4k

T=0 EAX

SHA-256

T=1 OMAC

EC-p T-CL² AES

DES

Tabela 2 - Professional Cards

15

MULTIAPPLICATION:

VERSÃO ALGORITMO

PK EEPROM RAM PROTOCOLO CRIPTOGRAFIA EXTRAS

ZC6.5

EC-167

31k 1.5k

T=0 EAX

SHA-256 OMAC

EC-211 T=1 AES

DES

ZC8.5

RSA

32k 4k

T=0 EAX

SHA-256 OMAC

EC-p T=1 AES

DES

ZC8.6

RSA

72k 4k

T=0 EAX

SHA-256 T=1 OMAC

EC-p T=CL² AES

DES

Tabela 3 - Multiapplication Cards

LEGENDAS:

ALGORITMOS PK (PUBLIC

KEYS) DESCRIÇÃO TAMANHO

RSA Rivest-Shamir-

Adleman algorithm Até 4k

EC-p

Elliptic Curve

Cryptography over

the field GF(p)

Até 512 bits

EC-211

Elliptic Curve

Cryptography over

the field GF(2211)

211 bits

EC-167

Elliptic Curve

Cryptography over

the field GF(2167 )

167 bits

EC-161

Elliptic Curve

Cryptography over

the field

GF(2168 )

161 bits

Tabela 4 – Legenda dos Algoritmos

16

ALGORITMO DE

CRIPTOGRAFIA DESCRIÇÃO TAMANHO

EAX

Encryption with

Authentication for

Transfer

(using AES)

128/192/256 bits

OMAC One-Key CBC-

MAC (using AES) 128/192/256 bits

AES

Advanced

Encryption

Standard

128/192/256 bits

DES Data Encryption

Standard 56/112/168 bits

Tabela 5 - Legenda das Criptografias

No projeto serão utilizados os modelos ZC3.14 e o ZC5.4, pois estes possuem o

melhor custo benefício, bem como algoritmo de criptografia e memória compatível com

a aplicação.

17

2.3. PROGRAMAÇÃO ZC-BASIC

Programar um cartão inteligente não é o mesmo que programar um computador

desktop, por exemplo, tela e teclado não existem no universo dos cartões. Então, este

comunica com o mundo exterior através de seu contato bidirecional de Entrada e Saída.

A comunicação ocorre a 9600 baud (número de vezes em um segundo que um sinal em

um canal de comunicação muda) ou mais, de acordo com os protocolos T = 0 e T = 1

definidos nas normas ISO 7816/3. Entretanto, isso é completamente invisível para o

programador Basic, bastando definir os comandos e seus procedimentos.

A linguagem de programação ZC-BASIC é completamente funcional, com

funções e chamadas de sub-rotina, tipos de dados definidos pelo usuário, diretivas de pré-

processador e arquivos I/O. Além disso, ela tem alguns recursos especiais para o ambiente

de Smart Card, incluindo a definição de comando e invocação, criptografia de I/O, e

arquivo de controle de acesso.

Essas diretivas de pré-processador são instruções para o compilador ZCMBasic,

por exemplo, elas contam ao compilador quais as linhas de código-fonte para compilar e

se estas linhas devem ser escritas na lista pré-solicitada. Fora isso, elas podem ser usadas

para especificar vários parâmetros de linha de comando no código em si. Neste caso, o

compilador aceita a primeira ocorrência do parâmetro, de modo que as diretivas no

código-fonte sejam substituídas por parâmetros na linha de comando.

A ZC-BASIC permite que os dados sejam armazenados em classes: EEPROM,

Public, Static e Private.

No caso da EEPROM, ela funciona como o disco rígido de um computador,

armazenando, assim, os dados mesmo se o equipamento for desligado.

EEPROM CustomerName$ = “ “

EEPROM Balance& = 500

Seu escopo é global, o que significa que pode ser acessado por todos os

procedimentos do programa.

Já as classes Public e Static são armazenadas na memória RAM, onde serão

conservados os valores enquanto o cartão estiver conectado ao leitor. Os dados na Public

têm escopo global, já os da Static são locais, ou seja, apenas acessado quando forem

declarados. Os dados Public e Static podem ser inicializados, assim como dados de

EEPROM. A inicialização ocorre sempre que o cartão é ligado.

Os dados declarados em Private só existem até que o procedimento retorne. Ele

tem escopo local e eles podem ser inicializados com os valores constantes:

PRIVATE LoopCounter = 100

18

2.4. ISO 7618/3

A ISO 7816/3 é importante para os fabricantes de Smart Card Reader ou para

desenvolvedores que desejam estabelecer uma comunicação com um cartão inteligente

em um nível muito baixo (o nível do sinal). Resumindo, a ISO 7816/3 é tudo aquilo que

está envolvido na criação de software de I/O. Isso pode ser tanto para comunicar por um

microcontrolador ou um PC pela porta serial/paralelo/USB/PCMCIA.

Descrição dos Sinais Elétricos encontrados no Smart Card:

I/O: Entrada ou Saída para dados em série para o circuito integrado dentro do

cartão.

VPP: Entrada de tensão de programação (uso opcional pelo cartão).

GND: Terra (tensão de referência).

CLK: Clocking ou sinal de temporização (uso opcional pelo cartão). É

configurado apenas em versões ZC7.X e ZC8.X.

RST: Usado (sinal de reinicialização fornecido pelo dispositivo de interface) ou

em combinação com um circuito de controle de reinicialização interno (uso opcional pelo

cartão). Se o Reset interno for implementado, a tensão fornecimento em Vcc é

obrigatório.

VCC: Entrada da fonte de alimentação (uso opcional pelo cartão).

NOTA - O uso dos dois contatos restantes será definido nos padrões de aplicação

apropriados.

Ver figura 3 para maior esclarecimento.

19

2.4. COMUNICAÇÃO

Para compreender o projeto, é necessário entender a comunicação do Smart Card

com outro dispositivo externo. Como foi escolhido o BasicCard, o estudo da

comunicação será baseado nele.

A transmissão de dados entre o Terminal e um cartão inteligente, via Reader, é

feita por uma série de comandos, iniciados pelo Terminal e respondido pelo Smart Card.

Figura 5 - Comunicação

Como observado, o primeiro comando vem do Leitor pedindo para que o Smart

Card reinicie e inicie o processo de leitura dos comandos do Terminal.

O protocolo de comunicação do BasicCard é o ISO 7618/3, ou seja, um protocolo

de nível de bit através de nível de byte para nível de bloco. Serão vistos três aspectos:

- A estrutura do ATR (Answer to Reset);

- O protocolo de transmissão de caracteres T=0;

- O protocolo de transmissão de blocos T=1.

O primeiro é referente ao cartão inteligente identificar ele mesmo e indicar qual

protocolo ele suporta. Muitos desses dados são ignorados pelos programadores, mas é

necessário estar atento a alguns pontos importantes:

- Se o cartão suporta protocolos T=0 e T=1;

- A velocidade máxima de transmissão que o Smart Card suporta;

- O histórico de caracteres.

O primeiro protocolo é o T=0, definido para ser um protocolo de transmissão a

nível de caracteres do circuito integrado com contatos. Este é usado apenas quando o T=1

20

não está disponível ou não é suportado. Ele é definido por uma sequência de mensagens

trocada entre o IFD (Interface Device ou Equipamento de Interface) e o ICC (Integrated

Circuit Card ou Cartão de Circuito Integrado). Para melhor entendimento, o IFD é o

Terminal enquanto o ICC é o Smart Card. Assim, o IFD envia uma unidade de dado

contendo um comando e o ICC responde com uma unidade de dado contendo a resposta.

Por último é o T=1, protocolo definido para transmissão a nível de bloco. Ele é

mais rápido, mais fácil de usar e contem menor probabilidade de erro que o T=0. Assim

como o T=0, neste protocolo é uma sequência de troca de dados através do IDF com o

ICC, porém algumas vezes o ICC pode transmitir um pedido de WTX (Waiting Time

Extension ou Tempo de Extensão de Espera) para pedir mais tempo.

Figura 6 - Protocolo T=1

21

Quando se trata de T=1, é necessário entender o conceito de I-blocks. Estes são

unidades de transmissão e são acorrentados para produzir um Comando ou uma Resposta.

Sua arquitetura é definida na Figura 7:

Figura 7 - Arquitetura do I-block

Sendo eles:

- NAD: Node Address Byte. Aqui contém o endereço (0-7) do remetente e o

endereço (0-7) do possível receptor.

- PCB: Protocol Control Byte. Embora é possível ignorar esse byte, é interessante

analisar que ele alterna entre 00 e 40.

- LEN: Lengh of the INF field. Tamanho em bytes do INF.

- INF: Information Field. Aqui contém o conteúdo do I-block.

- LRC: Longitudinal Redundancy Check. É apenas um XOR para todos os bytes

anteriores.

Também é necessário entender o conceito do BWT (Block Waiting Time). Este é

definido no ATR para contar o tempo de espera por uma resposta antes do tempo limite.

Por padrão é 12,8 segundos, mas caso um comando estiver demorando mais do que isso,

ele deve requisitar mais tempo utilizando o WTX.

22

2.8. SMART CARD READER

O Smart Card Reader CyberMouse USB 38U fornece uma solução de baixo custo

para leitura e escrita de dados para cartões inteligentes. Bolchini e Schreiber argumentam

que mesmo com toda a capacidade de um Smart Card, é necessário energiza-lo para

acessar seus dados e seu processamento.

Figura 8 - Leitor de Smart Card

Este possui suporte para detectar automaticamente inserção de Smart Cards em

seu slot. Bem como uma fácil interface programável em BASIC compatível com o cartão

inteligente escolhido. “Após a inserção do cartão na leitora, ela se encarregará de fazer a

interface com o cartão, enquanto o computador suporta e gerencia as aplicações” (Ladeira

e Tavares). Seu protocolo de comunicação varia com o cartão escolhido, no caso do

projeto, é o protocolo ISO 7618/3.

Os pinos do IC embarcado no cartão inteligente são acessados através das placas

de contato de ouro na parte superior do cartão. O leitor de cartão inteligente faz esta

conexão através de oito contatos dentro do módulo leitor (cartão deve ser inserido com

as bases de ouro para cima). Uma vez conectados, os pinos do Smart Card são divididos

na placa com espaçamento próximos de 0,1 polegadas.

23

3. IMPLEMENTAÇÃO

Para melhor entendimento e implementação, o Protótipo do Projeto foi dividido

em diversas partes conforme o cronograma. Cada uma delas requereu estudos do

documento e testes para a melhor funcionalidade.

- Leitura de dados;

- Armazenamento de dados;

- Chave criptografada desses dados;

- Armazenamento/recuperação da chave;

- Determinação de espaço livre

- Deleção/substituição de conteúdo

- Inserção de conteúdo numa posição específica do Smart Card

- Proteção da chave

Abaixo são alguns exemplos de códigos em ZC-Basic.

3.1. LEITURA DE DADOS

Para ler os dados armazenados na EEPROM, é necessário o conhecimento da

syntax em ZC-Basic. O comando é basicamente READ EEPROM dando os parâmetros

necessários.

Call ReadEeprom (P1P2=addr%, data$, Le=len@)

Para o melhor entendimento, o código vai ler o tamanho len bytes iniciando no

endereço addr da EEPROM.

3.2. ARMAZENAMENTO DE DADOS

Para escrever dados na EEPROM, é necessário especificar o tamanho e o endereço

que será inicializado. Então, o código de escrita fica:

Call WriteEeprom (P1P2=addr%, data$)

24

Sendo addr o endereço a ser inicializado a escrita e data o dado que será

armazenado.

3.3. CHAVE CRIPTOGRAFADA DESSES DADOS

O ZC-BASIC permite a implementação de algoritmos de criptografia de maneira

extremamente rápida e fácil. Primeiro, é necessário criar uma chave criptografada através

de um programa KeyGen. Em seguida, incluir esta chave no programa e no BasicCard,

assim é possível definir o início da criptografia e seu fim através de comandos:

Call StartEncryption (P1=algorithm, P2=keynum, RND, RND)

Call EndEncryption()

Para ficar mais fácil de entender, P1 recebe o algoritmo de criptografia e o P2 é o

valor entre 0 a 255 para especificar o tamanho da chave.

3.4. ARMAZENAMENTO/RECUPERAÇÃO DA CHAVE

Para armazenar uma chave e recuperá-las mais tarde, deve-se utilizar um KeyGen

para gerar diversas chaves criptogramas de dados. Essas keys devem ser passadas para o

Terminal e o Cartão para assim, os dois terem acesso aos dados.

Para gerar essas chaves, deve rodar o programa KeyGen:

KeyGen TestKeys –K108

Logo em seguida, a saída deve ser parecida com:

Declare Key 108 = &H03,&HAF,&H59,&H92,&HC9,&HE5,&H0D,&HC6

3.5. DETERMINAÇÃO DE ESPAÇO LIVRE

Para determinar o espaço livre da EEPROM, é necessário utilizar o código

EEPROMSIZE, onde são passados os parâmetros de início e tamanho. Sendo assim:

Call EepromSize (start%, length%)

3.6. DELEÇÃO/SUBSTITUIÇÃO DE CONTEÚDO

O comando para limpar um conteúdo pré existente na EEPROM, é dado por Clear

EEPROM. Sendo os parâmetros endereço e o tamanho que deseja deletar.

Call ClearEeprom (P1P2=addr%, length%)

25

3.7. INSERÇÃO DE CONTEÚDO NUMA POSIÇÃO ESPECÍFICA DO

SMART CARD

O comando de escrita em um lugar específico não é recomendado pelo fabricante

e não é liberado para o uso comum. Utilizar esse comando por risco pode danificar o

cartão permanentemente. Assim, essa seção do protótipo foi cancelada.

3.8. PROTEÇÃO DA CHAVE

A proteção das chaves é feita pelo KeyGen que gera o arquivo com diferentes

chaves. Essas chaves servem para que os dados transferidos do Smart Card para o

Terminal, e vice-versa, não sejam abertos por terceiros. Ao enviar um dado, ele deve

chegar ao destinatário com sua respectiva chave, caso um terceiro capte este, ele não

conseguirá abrir devido a criptografia.

26

4. PROCEDIMENTOS DE TESTES E VALIDAÇÃO DE PROJETO

Para testar o projeto, foram precisos realizar uma bateria de testes dentre os quais

constituem em técnicas de Engenharia de Software, são eles:

TESTE EM CAIXA BRANCA: Estes testes são feitos com base interna do

programa, afim de verificar sua funcionalidade a nível de código. Para isso, foram

selecionados testes nas áreas:

- CRIPTOGRAFIA: Verificar se a criptografia foi realizada com sucesso.

- ENVIO/RECEBIMENTO DE DADOS: Verificar se o cartão recebe os dados

enviados pelo medidor.

- PIN: Verificar se o PIN aceito permite acesso ao cartão, e o PIN errado deve

bloquear o acesso.

- DADOS ARMAZENADOS: Verificar se os dados foram armazenados com

sucesso no cartão mesmo após o desligamento de energia.

TESTE EM CAIXA PRETA: Estes testes focam na aplicação do projeto, assim,

nas ações que ele deve desempenhar.

- ENVIAR DADOS INVÁLIDOS: Verificar se o cartão armazena dados inválidos

pelo terminal, tais como números negativos em data.

- DADOS COMPATÍVEL: Verificar a originalidade dos dados armazenados na

memória.

- RETIRAR O CARTÃO DURANTE A GRAVAÇÃO DE DADOS: Verificar se

o cartão armazenou o último dado antes de ser interrompido.

- INICIALIZAR APÓS ENERGIZÁ-LO: Verificar se o cartão está pronto para o

uso após conectá-lo ao Reader.

Para validar o projeto, foi necessário criar uma API em C# para comunicar os dois

mundos. Esta API (Application Programming Interface) foi feita para ser um conjunto de

rotinas e padrões de programação para acessar o cartão. Assim que foi possível acessá-

lo, foram feitas as check-lists mencionadas anteriormente no item 3. Assim, foi realizado

estudos na ISO 7618/3 para entender seu funcionamento e poder coloca-los em prática.

Por meio da API foi possível invocar as funções implementadas no cartão

inteligente pelo ambiente do Visual Studio C#. A empresa responsável pelo BasicCard já

27

possui uma API base para que possa desenvolver em .Net e Java, mas é necessário

implementar todas as funções que estão no cartão para embarcar a aplicação.

Isto é, a API do BasicCard permite que ele inicialize o Framework do Smart Card,

fazendo assim, a comunicação com o Smart Card Reader. A partir disso, foi possível

enviar comandos e receber respostas do leitor diretamente da APDU do leitor.

Logo, foi possível validar o projeto, uma vez que foi comprovado que a

implementação criada no cartão inteligente pode ser utilizada em outras plataformas de

desenvolvimento, além da do próprio fabricante, de maneira funcional.

28

5. MANUAL DO CÓDIGO

O Projeto está dividido em três partes principais: o código do cartão, código do

medidor e o código do usuário. O código do cartão é aonde se encontra todas as funções

evocadas pelo medidor e pelo usuário, sendo que este código é gravado no cartão físico.

O código do medidor utiliza as funções do cartão e informações geradas pelo medidor

físico para gravar dados no cartão, este é gravado no medidor físico. O código do usuário

representa uma configuração inicial do cartão, pode ser utilizado no próprio sistema

operacional Windows/Linux.

Figura 9 - Leitor de Smart Card

5.1. CÓDIGO DO CARTÃO

O código do cartão contém dois arquivos principais, a implementação do cartão,

com extensão .bas, e um código de definição, com extensão .def. Este último é também

utilizado pelo usuário e pelo medidor, pois as funções implementadas no cartão são

evocadas.

Segue o código das principais funções da implementação do cartão:

Declare Command &H80 &H00 PersonaliseCard (ID as String*16, IDType as

String*16, User as String*16, NewPIN As String*4)

Declare Command &H80 &H02 VerifyPIN (TestPIN As String*4)

Declare Command &H80 &H06 RegisterMetric (Timestamp as String*16, Value

as String*16, Flag as Byte)

Declare Command &H80 &H08 ChangePIN (NewPIN As String*4)

29

Declare Command &H80 &H0A GetCardData (ID as String*16, IDType as

String*16, User as String*16 , Timestamp as String*16, Value as String*16, Flag as

Byte, PINCount)

5.2. CÓDIGO DO USUÁRIO

O código do usuário contém um arquivo principal, sendo do tipo terminal, com

extensão .zct. Esses arquivos de terminais podem gerar vários tipos de saídas, tornando

fácil o seu uso por outro sistemas, esses tipos consistem de: .exe, .img, .list e .map.

Esse código irá utilizar o arquivo de definição criado para o cartão para evocar

funções gravadas no cartão físico.

Segue o código das principais funções da implementação do usuário:

Call WaitForCard()

ResetCard : Call CheckSW1SW2()

Rem Check that the application name is correct

Private Name$ : Call GetApplicationID (Name$) : Call CheckSW1SW2()

If Name$ <> ApplicationName$ Then Print "Card Error" : Exit

Rem Variaveis privadas para receber inputs do usuario

Private PIN$, ID$, IDType$, User$, Len@, result$

Private teste$ as String*8

Rem Dados do medidor

FgCol = Cyan : Print "Meter ID (Enter to abort): ";

FgCol = BrightYellow : Line Input ID$

If ID$ = "" Then Exit

FgCol = Cyan : Print "Meter ID Type (Enter to abort): ";

FgCol = BrightYellow : Line Input IDType$

If IDType$ = "" Then Exit

FgCol = Cyan : Print "User (Enter to abort): ";

FgCol = BrightYellow : Line Input User$

If User$ = "" Then Exit

30

Rem Pin definido pelo fornecedor

Do

FgCol = Cyan : Print "PIN (Enter to abort): ";

FgCol = BrightYellow : Line Input PIN$

If PIN$ = "" Then Exit

If Len (PIN$) = 4 Then Exit Do

FgCol = Red : Print "PIN must be 4 characters long"

Loop

Rem Inicializa a criptografia, a partir daqui toda a comunicação cartão - terminal

é criptografada

Call AutoEncryption (0, "\Key0") : Call CheckSW1SW2()

Rem Salva os dados do medidor no cartão, só pode ser realizado por dados

criptografados pela chave de criptografia do usuario

Call PersonaliseCard (ID$, IDType$, User$, PIN$) : Call CheckSW1SW2()

Call EndEncryption() : Call CheckSW1SW2()

Print "Configuration successful."

5.3. CÓDIGO DO MEDIDOR

O código do medidor contém 1 arquivo principal, sendo do tipo terminal, com

extensão .zct. Esses arquivos de terminais podem gerar vários tipos de saídas, tornando

fácil o seu uso por outro sistemas, esses tipos consistem de: .exe, .img, .list e .map.

Esse código irá utilizar o arquivo de definição criado para o cartão para evocar

funções gravadas no cartão físico.

Segue o código das principais funções da implementação do medidor:

Call WaitForCard()

ResetCard : Call CheckSW1SW2()

Rem Verifica a aplicacao

Private Name$ : Call GetApplicationID (Name$) : Call CheckSW1SW2()

If Name$ <> ApplicationName$ Then Print "Error: Wrong Application " : Exit

31

Rem Le os dados no cartao

Private PINCount, PIN$

Private ID$, IDType$, User$

Private Timestamp$

Private Value$

Private Flag as Byte

Call AutoEncryption (1, "\Key1") : Call CheckSW1SW2()

Call GetCardData (ID$, IDType$, User$ , Timestamp$, Value$, Flag, PINCount)

If SW1SW2 = swNotPersonalised Then

Print "Card has not been configured"

Exit

End If

Call CheckSW1SW2()

FgCol = Green: Print "Meter"

FgCol = Cyan: Print "ID: " ; : FgCol = BrightYellow: Print ID$

FgCol = Cyan: Print "ID Type: "; : FgCol = BrightYellow: Print IDType$

FgCol = Cyan: Print "User: "; : FgCol = BrightYellow: Print User$

Print

FgCol = Green: Print "Metric"

FgCol = Cyan: Print "Timestamp: " ; : FgCol = BrightYellow: Print Timestamp$

FgCol = Cyan: Print "Value: "; : FgCol = BrightYellow: Print Value$

FgCol = Cyan: Print "Flag: "; : FgCol = BrightYellow: Print Flag

Rem Inicia a criptografia, dessa vez usando a chave do usuario para inicialização

Rem Requisita o PIN do cartào

Do

PIN$ = ""

FgCol = Cyan: Print "Enter PIN (Esc to abort): " ;

FgCol = BrightYellow

Do

Private Key$

Key$ = InKey$

Select Case Key$

Case Chr$ (27) : Print : Exit ' Esc

Case Chr$ (13) ' Enter

If Len (PIN$) = 4 Then Print: Exit Do ' Exit Keys pressed loop

Case Chr$ (8) ' Backspace

If Len (PIN$) <> 0 Then

PIN$ = Left$ (PIN$, Len (PIN$) - 1)

CursorX = CursorX - 1

Print " " ;

CursorX = CursorX - 1

End If

32

Case Else

If Len (Key$) = 1 And Len (PIN$) <> 4 Then

Print "*" ;

PIN$ = PIN$ + Key$

End If

End Select

Loop

Call VerifyPIN (PIN$)

Select Case SW1SW2

Case swPINErrorsExceeded : Print "Too many PIN errors - card disabled" : Exit

Case swInvalidPIN: Print "Invalid PIN"

Case Else : Call CheckSW1SW2() : Exit Do

End Select

Loop

Timestamp$ = "2015-01-01T08:45:00.0Z"

Value$ = "0.111"

Flag as Byte = 0

Call RegisterMetric(Timestamp$, Value$, Flag)

Call GetCardData (ID$, IDType$, User$ , Timestamp$, Value$, Flag, PINCount)

33

6. RESULTADOS

Gravação de dados do Usuário:

Figura 10 – Gravado com sucesso

Gravação de dados do Medidor:

Figura 11 – Dados armazenados com sucesso

34

7. CONCLUSÃO

Existem diversas maneiras para prevenir ataques e perda de dados, e o Smart Card

é o melhor nessa categoria. Com sua capacidade de armazenar dados, com difícil

falsificação e baixa taxas de falhas, o cartão inteligente foi então escolhido para

armazenar os dados recebidos por um Smart Meter.

O projeto inclui o BasicCard para leitura e armazenamento de dados, bem como

a criptografia das informações recebidas pelo Smart Meter. Seu leitor é capaz de

comunicar esses dois mundos através de uma placa USB/I²C. Sua capacidade de memória

EEPROM é o suficiente para armazenar esses dados seguros.

A partir desses componentes, foi feito o protótipo de simulação de comunicação

do Smart Card. Foram realizados diversos testes que incluíam transferências de dados

entre o Terminal e o Cartão, bem como a criptografia entre eles. Foi verificado a

consistência dos dados armazenados e funções uteis que prepararam o projeto para as

próximas etapas, como a comunicação com o Smart Meter.

Com o passar dos anos, a preocupação com o meio ambiente vem aumentando, e

isso fez com que as pessoas optassem por produtos com maior sustentabilidade. Os Smart

Cards deverão adotar novas alternativas no plástico utilizado para proteção, aonde estes

podem ser substituídos por plásticos biodegradáveis ou pelos feitos por cana de açúcar.

Já os que vieram de fábrica com o plástico podem ser descartados e substituídos pelos

exemplos citados e devem ser reciclados imediatamente, pois o mesmo leva anos para se

decompor e animais silvestres podem confundi-los com alimentos. Existem programas

que facilitam a reciclagem de cartões inteligentes, tais como o PapaCartão, que é um

sistema que destrói o cartão com segurança, sem precisar de energia elétrica, totalmente

feito por manivela.

O projeto foi validado através de API feita em C# para que pudesse inicializa-lo,

manter a comunicação, iniciar o processo de leitura e escrita de dados, criptografar os

dados e armazena-los em segurança em sua EEPROM. Com isso, foi possível realizar os

testes e garantir as melhores opções de armazenamento e segurança aos dados.

As dificuldades do projeto foram a falta de conhecimento inicial de cartões

inteligentes, bem como comunicação bit-a-bit de dados e criptografias. A falta de artigos

específicos para a utilização foi uma das barreiras inicias, mas logo foram cessadas

através de muito estudo e pesquisa.

Em virtude dos fatos mencionados, o projeto permite ser uma ótima base para

trabalhos futuros, como a própria implementação do medidor inteligente ou melhoria na

35

comunicação entre eles. O mesmo proporciona conhecimento sobre a arquitetura dos

cartões para ser utilizado em outras aplicações ou para aprimorar tecnologias já existentes.

36

8. REFERÊNCIAS BIBLIOGRÁFICAS

Bolchini, C.; Schreiber, F. Smart card embedded information systems: a methodology for

privacy oriented architectural design. Data & Knowledge Engineering, v. 41, n. 2-3, p.

159-182, 2002.

Rankl, W.; Effing, W.; Cox, K. Smart card handbook, fourth edition. Tradução .

Chichester, West Sussex, U.K.: ohn Wiley & Sons Ltd, 2010.

Sade Ladeira, I.; Alves Tavares, E. Arquitetura de Sistemas de Segurança baseado em

Smart Card. [s.d.].

SHANGHAI FM. Datasheet: FM4428, 8KBits Memory Card Chip. Datasheetlib, 2008.

INFINEON. Datasheet: SLE5542, Intelligent 256-Byte EEPROM with Write Protection

function and Programmable Security Code. Zotei, 2006.

INTEGRATED SILICON SOLUTION. Datasheet: IS24C16A, 16K-bit 2-WIRE

SERIAL CMOS EEPROM. ALLDATASHEET, 2006.

ZEITCONTROL. Datasheet: Z5.4, the ZeitControl Professional and MultiApplication

BasicCards. BasicCard, 2012.

KETEREX. Datasheet: USB-910H, Embedded Systems Interface. Katerex, 2009.

Leiras Matos, C. SMART CARD. Disponível em:

<http://www.gta.ufrj.br/grad/01_2/smartcard/smartcard.html>. Acesso em: 14 jun. 2016.

Nguyen, A. Smart Card Types. Disponível em: <http://www.smartcardbasics.com/smart-

card-types.html>. Acesso em: 3 abr. 2016.

Assis Borba, E. TECNOLOGIA SMART CARD. [s.d.].

37

APÊNDICE A

CÓDIGO DO USUÁRIO:

using BasicCard;

using BasicCard.BasicCards;

namespace Meter

{

/// <summary>

/// Service class for managing issuer functions for BasicCard debit example card.

/// </summary>

public class UserService : MeterService

{

/// <summary>

/// Constructs a IssuerService object

/// </summary>

public UserService()

: base()

{

byte[] key =

{

(byte) 0xF1,

(byte) 0xA8,

(byte) 0xF4,

(byte) 0x3E,

(byte) 0x04,

(byte) 0x04,

(byte) 0x8D,

(byte) 0xEB };

SetKey(0, key);

}

/// <summary>

/// Override of start encryption using issuer key.

/// </summary>

public override void StartEncryption()

{

AutoEncryption(0, "\\Key0");

}

public void PersonaliseCard(decimal Amount, string NewPIN, string

Name)

{

38

BasicCardCommand cmd = new BasicCardCommand(0x80,

0x00);

cmd.AppendBasicLong(FromDecimal(Amount));

cmd.AppendBasicStringN(

new BasicCardStringN(4, NewPIN,

BasicCardString.CharsetIdAscii));

cmd.AppendBasicString(new BasicCardString(Name,

StringEncoding));

cmd.DisableLE(); // we do not need response data

BasicCardResponse rsp = DoCommandAndResponse(cmd);

rsp.CheckSW1SW2();

}

public void PersonaliseCard(string Id, string Type, string User, string NewPin)

{

BasicCardCommand cmd = new BasicCardCommand(0x80, 0x00);

// cmd.AppendBasicString(new BasicCardString(Id, StringEncoding));

// cmd.AppendBasicString(new BasicCardString(Type, StringEncoding));

// cmd.AppendBasicString(new BasicCardString(Meter, StringEncoding));

cmd.AppendBasicStringN(new BasicCardStringN(16, Id,


cmd.AppendBasicStringN(new BasicCardStringN(16, Type,


cmd.AppendBasicStringN(new BasicCardStringN(16, User,


cmd.AppendBasicStringN(new BasicCardStringN(4, NewPin,


//cmd.DisableLE();


rsp.CheckSW1SW2();

}

}

}

39

APÊNDICE B

IMPLEMENTAÇÃO DO USUÁRIO:

/*

* Created on 14.07.2005

* Project: BasicCard .Net

* --------------------------------

* Copyright 2005 ZeitControl cardsystems GmbH

* --------------------------------

* $Archive: $

* $Revision: 1.1 $

* $Modtime: $

* --------------------------------

* $History: $

*/

using System;

using BasicCard;

using BasicCard.Framework;

using BasicCard.GenericCards;

namespace Meter

{

public class UserExitException : Exception

{

public UserExitException()

: this("Personalization aborted")

{

}

public UserExitException(string message)

: base(message)

{

}

}

class Issuer

{

private static UserService issuerService;

40

[STAThread]

static void Main(string[] args)

{

try

{

CardReaderObserver.Instance.Start();

System.Console.WriteLine(

"Please insert a BasicCard.");

issuerService =

(UserService) CardReaderObserver

.Instance

.WaitForCardService(

new UserService(),

new TimeSpan(0,0,30));

if (null == issuerService)

{

System.Console.WriteLine("No matching

BasicCard was inserted.");

}

else

{

decimal Amount;

string PIN;

string Name;

string Id;

string Type;

string User;

System.Console.Write("ID (Enter to abort): ");

Id = System.Console.ReadLine();

if (Id.Length == 0)

throw new UserExitException();

System.Console.Write("Type (Enter to abort): ");

Type = System.Console.ReadLine();

if (Type.Length == 0)


System.Console.Write("Meter (Enter to abort): ");

User = System.Console.ReadLine();

if (User.Length == 0)


while (true)

41

{

System.Console.Write("PIN (4 characters,

or enter to abort): ");

PIN = System.Console.ReadLine();

if (PIN.Length == 0)



break;

System.Console.WriteLine("PIN must be 4

characters long");

}

/*

while (true)

{

System.Console.Write(string.Format("Initial balance (e.g. {0:0.00}): ", 12.50));

try

{

Amount =

decimal.Parse(System.Console.ReadLine());

break;

}

catch (FormatException)

{

System.Console.WriteLine("Invalid

number");

}

}

*/

issuerService.StartEncryption();

issuerService.PersonaliseCard(Id, Type, User,

PIN);

issuerService.Dispose();

System.Console.WriteLine("Personalization

succesful");

}

}

catch (CommsException ex)

{

if (null != issuerService)

{

issuerService.ShowMessage(ex);

}

else

{

42

ex.Dump();

}

}

catch (UserExitException ex)

{

System.Console.Error.WriteLine(ex.Message);

// terminate

}

catch (Exception ex)

{

System.Console.Error.WriteLine(ex.ToString());

}

finally

{

// stop the BasicCard framework

CardReaderObserver.Instance.Stop();

}

System.Console.WriteLine("Press enter to terminate");

System.Console.ReadLine();

}

}

}

43

APÊNDICE C

SERVIÇO DO MEDIDOR

using System;

using BasicCard;

using BasicCard.BasicCards;

namespace Meter

{

/// <summary>

/// Card data

/// </summary>

public class CardData

{

private decimal amount;

private int pinCount;

private string name;

private string id;

public string Id

{

get { return id; }

set { id = value; }

}

private string type;

public string Type

{

get { return type; }

set { type = value; }

}

private string user;

public string User

{

get { return user; }

set { user = value; }

}

private string timestamp;

public string Timestamp

{

get { return timestamp; }

set { timestamp = value; }

}

44

private string metricvalue;

public string Metricvalue

{

get { return metricvalue; }

set { metricvalue = value; }

}

private Byte flag;

public Byte Flag

{

get { return flag; }

set { flag = value; }

}

/// <summary>

/// Objeto tipo CardData

/// </summary>

internal CardData()

{

this.id = "";

this.type = "";

this.user = "";

this.timestamp = "";

this.metricvalue = "";

this.flag = 0;

this.PinCount = 0;

}

/// <summary>

/// Amount left within card.

/// </summary>

public decimal Amount

{

get

{

return amount;

}

set

{

amount = value;

45

}

}

/// <summary>

/// Retorna .

/// </summary>

public string AmountString

{

get

{

return amount.ToString("0."+new string('0',

MeterService.DecimalNumbers));

}

}

/// <summary>

/// Card owners name.

/// </summary>

public string Name

{

get

{

return name;

}

set

{

name = value;

}

}

/// <summary>

/// Number of PIN tries left.

/// </summary>

public int PinCount

{

get

{

return pinCount;

}

set

{

pinCount = value;

}

}

}

46

/// <summary>

/// Classe de serviço para implementação das funções do cartão inteligente.

/// </summary>

public class MeterService : AbstractBasicCardService

{

public enum MeterStatus

{

swNotPersonalised = 0x6B00,

swEncryptionRequired = 0x6B02,

swIssuingKeyRequired = 0x6B03,

swPINRequired = 0x6B04,

swInvalidPIN = 0x6B05,

swPINErrorsExceeded = 0x6B06,

}

// Change this to use different encodings when translating between

// BasicCard String and .Net String

protected const string StringEncoding = BasicCardString.CharsetIdAscii;

// Decimal representation used internal. E.g. when

// DecimalNumbers = 2 then an amount of 10.25 will be encoded to (int)

1025

internal const int DecimalNumbers = 2;

private const int DecimalFactor = 100; // DecimalNumbers^10

protected static int FromDecimal(decimal val)

{

return (int) decimal.Round(val * DecimalFactor, 0);

}

protected static decimal ToDecimal(int val)

{

return ((decimal)val) / DecimalFactor;

}

/// <summary>

/// Constructs a DealerService object.

/// </summary>

public MeterService()

// Select card by application "ZeitControl DebitCard"

: base("TCC - Fernando e Pedro")

{

// Meter key

byte[] key =

47

{

(byte) 0x86,

(byte) 0x75,

(byte) 0x90,

(byte) 0x03,

(byte) 0xED,

(byte) 0x88,

(byte) 0xF2,

(byte) 0xB3 };

SetKey(1, key);

}

/// <summary>

/// Start encryption for BasicCard commands using dealer key.

/// </summary>

public virtual void StartEncryption()

{

AutoEncryption(1, "\\Key1");

}

/// <summary>

/// Stop encryption of BasicCard commands.

/// </summary>

public void EndEncryption()

{

CmdEndEncryption();

}

/// <summary>

/// Get card data.

/// </summary>

/// <returns>card data</returns>

public CardData GetCardData()

{

CardData carddata = new CardData();


0x0A);

cmd.LE=0;


rsp.CheckSW1SW2();

carddata.Type =

rsp.FetchBasicStringN(16).ToString(BasicCardString.CharsetIdAscii);

carddata.User =


48

carddata.Timestamp =


carddata.Metricvalue =


carddata.Id = rsp.FetchBasicString().ToString(BasicCardString.CharsetIdAscii);

return carddata;

}

/// <summary>

///

/// Call VerifyPIN command

/// </summary>

/// <param name="pin">PIN for verification</param>

public void VerifyPin(string pin)

{

if (!IsExclusive)

{

throw new CommsException("Must not validate a PIN to

a card not owned exclusivly.");

}


0x02);

// for PIN we always use ASCII encoding


new BasicCardStringN(4, pin,


cmd.DisableLE(); // we do not need to receive data


rsp.CheckSW1SW2();

}

/// <summary>

/// Call ChangePIN command.

/// </summary>

/// <param name="pin">PIN for verification</param>

public void ChangePin(string pin)

{


0x08);

// for PIN we always use ASCII encoding


new BasicCardStringN(4, pin,


cmd.DisableLE(); // we do not need to receive data


49

rsp.CheckSW1SW2();

}

/// <summary>

/// Call IncreaseAmount command.

/// </summary>

/// <param name="diff"></param>

public void IncreaseAmount(decimal diff)

{


0x04);

cmd.AppendBasicLong(FromDecimal(diff));

cmd.DisableLE(); // we do not need response data


rsp.CheckSW1SW2();

}

/// <summary>

/// Call DecreaseAmount command.

/// </summary>

/// <param name="diff">value to subtract (>0)</param>

public void DecreaseAmount(decimal diff)

{


0x06);

cmd.AppendBasicLong(FromDecimal(diff));

cmd.DisableLE();


rsp.CheckSW1SW2();

}

public void ChangeMetric(string Timestamp , string Value, Byte Flag)

{

BasicCardCommand cmd = new BasicCardCommand(0x80, 0x06);

cmd.AppendBasicStringN(new BasicCardStringN(16, Timestamp,


cmd.AppendBasicStringN(new BasicCardStringN(16, Value,


cmd.AppendBasicByte(Flag);

cmd.DisableLE();


rsp.CheckSW1SW2();

}

public void ShowMessage(CommsException e)

50

{

string message = "";

switch ((MeterStatus)e.SW1SW2)

{

case MeterStatus.swNotPersonalised :

message = "Card is not personalised!";

break;

case MeterStatus.swEncryptionRequired :

message = "Encryption required!";

break;

case MeterStatus.swIssuingKeyRequired :

message = "Issuing key required!";

break;

case MeterStatus.swPINRequired :

message = "PIN required!";

break;

case MeterStatus.swInvalidPIN :

message = "Invalid PIN!";

break;

case MeterStatus.swPINErrorsExceeded :

message = "Too many PIN errors - card disabled";

break;

default :

e.Dump();

break;

}

System.Console.WriteLine(message);

}

}

}

51

APÊNDICE D

IMPLEMENTAÇÃO DO MEDIDOR

using System;

using BasicCard;

using BasicCard.Framework;

using BasicCard.GenericCards;

namespace Meter

{

public class UserExitException : Exception

{

public UserExitException()

: this("Action aborted")

{

}

public UserExitException(string message)

: base(message)

{

}

}

class Meter

{

private static MeterService meterService;

/// <summary>

/// The main entry point for the application.

/// </summary>

[STAThread]

static void Main(string[] args)

{

CardData finalCarddata=null;

try

{

CardReaderObserver.Instance.Start();


"Please insert a BasicCard loaded

with Meter code.");

meterService =

52

(MeterService) CardReaderObserver

.Instance

.WaitForCardService(

new MeterService(),

new TimeSpan(0,0,30));

if (null == meterService)

{

System.Console.WriteLine("No matching

BasicCard was inserted.");


"Please load a BasicCard with

debit example for using");

System.Console.WriteLine("this .Net

example.");

}

else

{

string PIN;

CardData carddata =

meterService.GetCardData();

System.Console.WriteLine("Card Info: " );

System.Console.WriteLine("ID: " + carddata.Id);

System.Console.WriteLine("Type: " +

carddata.Type);

System.Console.WriteLine("User: " + carddata.User);

System.Console.WriteLine("");

System.Console.WriteLine("Timestamp: " +

carddata.Timestamp);

System.Console.WriteLine("Metric Value: " +

carddata.Metricvalue);

System.Console.WriteLine("Flag: " + carddata.Flag);

meterService.StartEncryption();

while (true)

{

System.Console.Write("");

System.Console.Write("PIN (4

characters, or enter to abort): ");

PIN = System.Console.ReadLine();




53

break;

System.Console.WriteLine("PIN must

be 4 characters long");

}

meterService.VerifyPin(PIN);

carddata.Timestamp = "2015-01-01T08:45:00.0Z";

carddata.Metricvalue = "1.5768";

meterService.ChangeMetric(carddata.Timestamp,

carddata.Metricvalue, 1);

finalCarddata=meterService.GetCardData();

meterService.Dispose(); // release smart

card resources

System.Console.WriteLine("Action

succesful");

}

}

catch (CommsException ex)

{

if (null != meterService)

{

meterService.ShowMessage(ex);

}

else

{

ex.Dump();

}

}

catch (UserExitException ex)

{

System.Console.Error.WriteLine(ex.Message);

}

catch (Exception ex)

{

System.Console.Error.WriteLine(ex.ToString());

}

finally

{

CardReaderObserver.Instance.Stop();

}

System.Console.WriteLine("Press enter to terminate");

54

System.Console.ReadLine();

}

}

}

PONTIFICIA UNIVERSIDADE CATÓLICA PUCPR ENGENHARIA DA...

Documents

Transcript of PONTIFICIA UNIVERSIDADE CATÓLICA PUCPR ENGENHARIA DA...