MAC336- CRIPTO - 1a.

Prova - mai02016
Questão 1 (50%)
O algoritmo K64 de chave secreta, definida a seguir, criptografa um bloco de 64 bits após aplicar
rounds (iterações), como no AES. O número de rounds é R.
(Ia) Escrever a função inversa, na pseudo-linguagem usada neste enunciado,
(Ia. l) de apenas um round do K64 e
(l a.2) da transformação final T do K64;
(l b) demonstrar matematicamente, que as suas duas funções inversas do item anterior são
corretas, i.e., que recupera o bloco de entrada original de 64 bits.
Todas as operações, como soma, subtração, logaritmo, etc., são sobre operandos em bytes de 8
bits, resultando um byte, como veremos a seguir. Por exemplo, sendo x e y valores inteiros
positivos armazenados, cada um em um byte, x + y será um valor de 8 bits.
Uma mesma função é aplicada um certo número de rounds R, através de r I, 2, 3,... , R.
Um bloco B de entrada, de 64 bits, é dividido em 8 sub-blocos B 1, E então, R
rounds são aplicados a estes sub-blocos, e depois uma transformação final Té aplicada,
obtendo-se a saída final.
Descrição de um round
Cada round utiliza duas subchaves e K2r, sendo cada uma de 64 bits e geradas da chave
principal K, também de 64 bits, como veremos mais tarde neste enunciado.
ePrimeiro passo
Primeiramente cada sub-bloco BJ é submetido a XOR (ou-exclusivo) ou somado a bytes da
subchave da seguinte forma (sendo , , , , 2r-l, OS8
bytes de K2r-l
= CI,B2 + Pir_l = C2,B3+ ICr_l = = Q,
= C5,B6+ = C6,B7+ =
- Segundo passo
Os 8 bytes C) (j = 1,2, ... 8) resultantes são submetidos a dois tipos de operações:
y = 45Xmod257 = 0 sex = 128,pois 45 128mod257 = 256)
A segunda operação é a inversa da anterior, i.e., log45(45Xmod257) = x. Convenciona-se que:
x = log40' (x = 128 se y = 0, para ser consistentecom a operação anterior)
Por exemplo: y = 453mod 247 = 229, e = 3.
As operações são da seguinte forma:
(45) CI = Dl, log45C2= D2, = D3, (45)c4 = D4,
(45)c5 = D5, = = D7, (45)c8 =
- Terceiro passo
Os 8 blocos DJ de um byte obtidos no Segundo Passo são agora submetidos a operações de soma
e XOR com os bytes da chave 1<2rda seguinte forma (sendo os
8 bytes de K2r,):
= = = E3,D4 + ICr = E4,
+ = = = E7,D8+ = E8
Quarto passo
Finalmente, os 8 bytes Ej obtidos são sumetidos à operação HT2 de 2 entradas ai , a2 (dois bytes)
e duas saídas bl, b2 (dois bytes) definida por:
bl = (2a1+ a-z)mod256
b2 = (ai + a2)mod256 ) -(E.ce)
As operações são da seguinte forma: (28 = 256)
FI = (2El (El +E2)mod256
F3 = (2E3+ = (E3 +
F5 = (2E5 = (E5 +E6)mod256 — C SL
F? = (2E7 = (E7 + E8)mod256
 Descrição da transformação final T
Depois de R rounds, os 8 blocos são submetidos a uma transformação final T que é exatamente
igual ao Primeiro Passo descrito acima, só que a subchave utilizada deve ser a última: K2R+l. E o
resultado é a saída final do algoritmo K64.
Descrição da geração das subchaves
A primeira subchave, Kl, é a própria chave principal K de 64 bits. Para r 1 2,3, ...,2R as
subchaves seguintes são geradas a partir de Kl pela fórmula: 10+1 = Kl <<< 3r, onde v <<< t
significa aplicar sobre v um deslocamento circular para a esquerda de t posições de bit.

Questão 2 (50%)
Um protocolo de combinação de uma chave secreta K entre Alice e Beto é como segue, e tem
como premissas os seguintes itens:
l, p é um inteiro primo longo, e Z; possui um elemento primitivo (gerador) g. Ep e g são para
todos os usuários.
2. Alice possui uma chave (SA,TA) : TA = gSA(modp), SA é a chave particular, p, g, TAsão
públicos.
3. Analogamente, chaves (SB, TB) para o usuário Beto.
4. Cada usuário Alice possui um certificado certA = (IdA, TA)), onde SgnAuté a
assinatura da autoridade idônea Aut, verificável publicamente, e IdA é a identidade de Alice.
5. Analogamente, certB = (IdB, TB,SgnAut(IdB,TB)) para Beto.

O protocolo é como segue:

l. Alice escolhe rAaleatório (NONCE) tal que 2 rA p 2, e calcula: uA —g PAmodp
2. Alice envia (certA, para Beto
3. Beto escolhe rB aleatório (NONCE) tal que 2 rB —2, e calcula: —g rBmodp
4. Beto envia (certB,u» para usuária Alice
5. Alice calcula K = modp, onde o valor TBé obtido de certB
6. Beto calcula K = modp, onde o valor TAé obtido de certA

Esta questão consiste em:

Demonstrar algebricamente que a chave K calculada nos dois passos finais do protocolo é o
mesmo valor para Alice e Beto.
2. Explicar como as assinaturas SgnAut(IdA,TA) e SgnAut(IdB,TB) são verificáveis
publicamente.
3 Justificar porque o protocolo garante à Alice que a chave K a ser usada com Beto é
autêntica, e vice-versa (isto é, justificar porque o protocolo garante a Beto que a chave K a
ser usada com Alice foi enviada pela Alice verdadeira, e vice-versa).
4 Analisar e justificar a inviabilidade computacional de um Intruso I utilizar o seu certificado
certl, os seus valores de chave (SI, TI), e as mensagens trocadas entre Alice e Beto para
personificar Alice perante Beto (ou vice-versa). Ou seja, a inviabilidade de sucesso no ataque
do tipo 'hnan-in-the-middle".
FIM
 MAC336 - CRIPTOGRAFIA - 2a. Prova - junho 2016
Questão 1 (50%)
Alice,
Um protocolo de identificação para identificarum usuário, digamos
perante Beto, é como segue. A escolha dos parâmetros gerais é:
longos p, q
1. Um tipo de cartório idóneo seleciona dois primos relativamente
p, q.
(como no RSA) e publica n pq mas mantém erp segredo os valores
s n —1 e
2. Alice, escolheum inteiro$ relativamente primo a n tal que 1 da
calcula v s2 mod n-e registra v no cartório como sendo a chave pública
Alice.
de
Feitas estas escolhas,o protocolo consiste em iterar t vezes um protocolo
quatro passos:
1. Alice escolhe aleatoriamente r : 1 r n —-1 e envia para Beto a;
r 2 mod n. é chamado testemunho.
Alice r2 n Beto

2. Beto esColhealeatoriamente um bit e 0 ou e 1 com proúbilidade 1/2 é

envia e para Alice. e é chamado desafio.

3. Alice calcula e envia para Betó uma resposta y tal que g = r se e = 0, ou

y = modn se e = 1.

Alice Ú= r ou = rs Beto

4. Beto rejeita a resposta se y = 0 ou senão aceita Se y? cvemod n. 226

Alice é— rejeita se y = 0; senão aceita se U2 = xvemodn 4—- Beto

Esta questão consiste em:

1. Exemplificareste Protocolo para os dados seguintes; p = 11, s :

20,T 7, t

H00
31
LHO c
 2. Por quê r deve ser aleatório?
3. Por quê e deve ser aleatório?
4. Por quê y 0 deve ser verificado?
5. Demonstrar algebricamente que se Alice de fato conhece s, então a igualdade
g/ = anf mod n é verdadeirano Protocolo de identificação considerando-
se parâmetros gerais.
6. Se uma falsa Alice conseguisseadivinhar o valor de e correto antes de ser
enviado pelo Beto, mostrar como ela poderia personificar a Alice verdadeira
perante Beto. Qual seria a probabilidade de}falsa Alice obter sucesso desta
forma? Justifique.
7. Quais problemas computacionais difíceis justificarn a inviabilidade prática
de uma falsa Alice personificara verdadeira? Ou seja, em cada passo do
protocolo, dar o nome e definir o problema computacionalmente difícil que
protege a chave s ou algum outro parâmetro crítico para a segurança contra
personificação.

Questão 2 (50%)
Os algoritmos para Alice assinar um inteiro x G e verificar se uma assinatura
é verdadeira são como segue. Os parâmetros' são:

1. Para um primo p > 2 relativamentelongo, considera-seum gerador g do

conjunto Z* dos inteiros relativamente _primosa p.
2. Alice escolhe inicialmente um inteiro S tal que 1 S p —2.
3. O conjunto de chaves é K { (p, g, S, T) : T gs modp}
4. Os valores p, g, e T são públicos; S é secreto que supostamente
só a Alice
conhece.

Algoritmo para assinar e Z*. Os passospara Aliceassinar um texto legível'

€ com a sua chave secreta S são os seguintes:

1. Escolherum inteiro aleatório k e Recomenda-seusar um k distinto

para cada a ser assinado.

2
 Z. Calcular y =
gk modp.
3. Calcular z = (m
— mod(p —1).
4. (y, z) é a assinatura,
que é anexada a x.
Algoritmo de Verificação de uma assinatura (y,z) sobrex. O algoritmode
verificação de uma assinatura é como segue:
1. Se y não satisfizer 1 y (p—i), então a assinatura é incorreta, e rejeitá-la.
2. se = gr modp, então a assinatura é aceita comocorreta.
3. Senão, a assinatura é incorreta. e rejeitá-la.
Esta questão consiste em:

1. Provar algebricamente que o Algoritmo de Verificação,dado acima, de fato

verifica a assinatura corretamente.
2. Por quê k deve satisfazer k e Z* ?
3. Por quê recomenda-se usar um k distinto para cada a: a ser assinado?
4. Por quê a assinatura deve ser rejeitada se y não satisfizer 1 y (p —1)?
Ou seja, mostrar que se a verificação1 y (p —1) não fosse feita, e se
uma assinatura válida (y, z) sobre um e fosse conhecida,uma pessoa
qualquer poderia falsificar uma assinatura (d, z') de um inteiro x?
JuStifique a sua resposta.

5. A verificação da assinatura exige (ou não) a presença do autor da assinatura

no ato da geração dá assinatura? Por quê?
6. Por quê a possibilidadede uma assinatura ser falsificadaé computacional-
mente inviável? Ou seja, em cada passo dos dois algoritmos, escrever o nome
e definir o problema computacionalmente difícil que protege a chave secreta
-S ou algum outro parâmetro crítico para a segurança contra ataques de um
mal-intencionadoque intercepte (y, z, x) e queira falsificaruma assinatura
sobre um outro € Z*.

7. A geração da assinatura demora mais ou menos que a verificação? Justifique

a sua resposta em termos de númerb de operações básicas relativamente mais
demoradas.