# Apontamentos & Miscellaneous
###### tags: `lectures`
:::info
:warning:
Atenção, estes apontamentos avulsos tirados aquando das aulas não substituem, de maneira alguma, os apontamentos teóricos e guias laboratórias práticos disponibilizados no _Moodle_.
:::
---
## Apontamentos Teóricos
### CriptoLOGIA
LOGIA é a ciência; pode ter várias partes:
Criptografia - é a parte que se preocupa com manter mensagens secretas.
Criptoanálise - é a parte que se preocupa com quebrar os mecanismos da Criptografia.
**DISCLAIMER:** Hoje em dia, a Criptografia já suplanta em muito as cifras.
Como se constroí uma cifra?
1. especifica-se o modelo de ataque;
(fazer de conta que as coisas vão correr mal para sabermos o que é preciso)
```
+---------+ TCP/IP +----------+
|_browser_| <-------------------------------> | servidor |
+---------+ +----------+
```
* Podemos ter um atacante que instala software no computador da vitima;
* Podemos ter um atacante que escuta e altera comunicações;
* Podemos ter um atacante que tem acesso ao servidor;
2. Propõe-se uma construção que evite/resolva os ataques;
* E.g., todas as comunicações vão ser cifras com AES-128-CBC, e mantidas corretas com HMAC-SHA256;
3. Defende-se/prova-se que o comprometimento da construção proposta corresponde a resolver um problema tido como intratável até à data.
E.g., o caso do RSA (Rivest Shamir Adleman):
$N = p \times q$
### Cifras de Chave Simétrica
* A chave para cifrar é a mesma que é usada para decifrar.
```
+----------+
chave de cifra -----> | cifra |
texto-limpo --------> | | -----> criptograma
+----------+
```
**Definição**
Definem-se por 2 algoritmos:
ENC: $k \times m \rightarrow c$
DEC: $k \times c \rightarrow m$
$DEC(k, ENC(k, m)) = m$
* O algoritmo de cifra é um algoritmo aleatório;
* O algoritmo de decifra é deterministico.
#### Cifras de Chave Simétrica Contínuas
* Exemplos canónicos: _Rivest Cipher 4_ (RC4); muito utilizada no _Wired Equivalent Privacy_ (WEP), o primeiro protocolo usado para cifrar comunicações _wireless_. Este algoritmo está desencorajado, mas é um bom exemplo canónico.
* Só são tipicamente usadas dessa forma: contínua.
* São boas para cifrar comunicações em curso.
#### Cifras de Chave Simétrica por Blocos
* Exemplos canónicos: _Data Encryption Standard_ (DES), o antecessor do _Advanced Encryption Standard_ (AES). O núcleo destas cifras funciona por blocos.
* Estas cifras podem ser usadas de várias formas: modos de cifra. Alguns modos de cifra transformam cifras de chave Simétrica por blocos em cifras de chave Simétrica contínuas.
* Os modos mais conhecidos são:
* ECB - _Electronic Code Book_ (desencorajado);
Só se deve utilizar para cifrar 1 bloco de informação, no máximo.
No caso do AES, o bloco é de 128 bits.
```
|-------|-------|-------|---4444|
v v v ...
E(k,b1) E(k,b2) E(k,b3)
v v v ...
|ccccccc|ccccccc|ccccccc|ccccccc|
v v v ...
D(k,c1) D(k,c2) D(k,c3)
v v v ...
|-------|-------|-------|---|
```
* CBC - _Cipher Block Chaining_ (bom para cifrar ficheiros em disco);
```
|-------| -------| -------|---4444|
v -XOR v v ...
E(k,b1)| E(k,b2) E(k,b3)
v . v v ...
|ccccccc| ccccccc| ccccccc|ccccccc|
```
* CTR - _CounTeR Mode_ (bom para cifrar comunicações em curso).
```
b1 b2 b3 ...
|-------|-------|-------|---4444|
xOR xOR xOR ...
E(k,001)E(k,010)E(k,011)
v v v ...
|ccccccc|ccccccc|ccccccc|ccccccc|
E(k,IV 001) = 00101
E(k,010) = 10010
E(k,011) = 11011
E(k,100) = 01010
E(k,101) = 00110
```
* Isto é para cifrar
```
texto-limpo 100010110101001010101100011010101
xOR 0010110010110110101000110
criptograma 1010011111100100000011110
```
* Para decifrar
```
E(k,001) = 00101
E(k,010) = 10010
E(k,011) = 11011
E(k,100) = 01010
E(k,101) = 00110
criptograma 1010011111100100000011110
xOR 0010110010110110101000110
texto-limpo 1000101101010010101011000
1000101101010010101011000
```
A _Advanced Encryption Standard_ (AES) escolhe uma cifra (Rijdael) que opera sobre blocos de 128 bits. Quando usamos o _CounTeR Mode_, ciframos um contador com 128 bits. Normalmente, metade desse contador começa num numero aleatório.
```
--------------- ... --------------------------
|<-- 128 bits -->|
|<-- 64 bits -->|<-- 0000000000000001 -->|
|<-- vetor inicia.-->|<-- contador -->|
```
#### Vantagens do _Counter Mode_
* Só usa um algoritmo tanto para cifrar como para decifrar;
* Não precisa de _padding_;
* Suporta pré-processamento da _stream_ de cifra;
* Pode ser usada para cifrar/decifrar enquanto os dados são gerados ou carregam;
* Suporta processamento paralelo.
#### Desvantagens do _Counter Mode_
* As cifras de chave simétrica continuas são maneáveis, o que significa que, se alguém alterar um bit do criptograma, mesmo sem o decifrar, está a alterar o mesmo bit no texto-limpo.
### Cifras de Chave Pública (a.k.a. Cifras Assimétricas)
Nas cifras de chave pública:
* Existem 2 chaves (Pública e outra Privada);
* A chave pública é usada para cifrar;
* A chave privada é usada para decifrar.
**Definição**
Definem-se por 3 algoritmos:
GER: $p \rightarrow pk, sk$
ENC: $pk \times m \rightarrow c$
DEC: $sk \times c \rightarrow m$
Propriedade principal:
$DEC(sk, ENC(pk, m)) = m$
### Funções de _Hash_
As funções de _Hash_ são funções que transformam um _input_ de qualquer tamanho num _output_ de tamanho fixo. Estas funções são tipicamente muito eficientes.
```
+---------+
mensagem ---> | função | ----> output de tamanho fixo
| de hash | [e aparentemente aleatório]
+---------+
```
* São eficientes de calcular;
* Têm um _output_ de tamanho fixo;
(se adicionarmos o qualificador "Criptográficas")
* Resistência a colisões;
* Resistência à descoberta de um texto original;
SHA256(f1)
f1
* Resistência à descoberta de um segundo texto original.
Ficheiro f1 SHA256(f1)
f2 SHA256(f1)
#### Exemplos Canónicos de Funções de _Hash_
* CRC32 - _Cyclic Redundancy Check_ é uma função de _Hash_.
#### Exemplos Canónicos de Funções de _Hash_ Criptográficas
* MD5 - _Message Digest 5_, que tem 128bits de _output_ (desencorajado);
* SHA1 - _Sardinha Hash Algorithm_ 1, tem _output_ de tamanho 160bits (desencorajado);
* SHA256 - _Sardinha Hash Algorithm_ 256, que tem _output_ de tamanho 256bits;
* SHA512 - _Sardinha Hash Algorithm_ 256, que tem _output_ de tamanho 512bits;
* SHA3-x - _Sardinha Hash Algorithm_ 3, que tem _output_ de tamanho xbits.
#### Utilidades das Funções de _Hash_
* São usadas para derivar chaves de cifra;
```
Covilhã Lisboa
| K |
| k1 = SHA256(K || 'a') | k1 = SHA256(K || 'a')
| k2 = SHA256(K || 'b') | k2 = SHA256(K || 'b')
| k3 = SHA256(K || 'c') | k3 = SHA256(K || 'c')
| k4 = SHA256(K || 'd') | k4 = SHA256(K || 'd')
```
* São usadas para guardar representações de palavras-passe;
* Funções de _Hash_ são usadas para garantir integridade.
* _Blockchains_ utilizam funções de _Hash_.
```sequence
Participant Alice
Participant Microondas
Participant Bob
Note left of Alice: f1, h1=SHA256(f1)
Note right of Bob: f1' h1
Note right of Bob: h2=SHA256(f1')
Note right of Bob: h1==h2? tudo bem!
Note right of Bob: caso contrário erro!
```
```sequence
Participant Alice
Participant Claire
Participant Bob
Note left of Alice: f1, h1=SHA256(f1)
Note over Claire: f1', h3=SHA256(f1')
Note right of Bob: f1' h3
Note right of Bob: h2=SHA256(f1')
Note right of Bob: h3==h2? tudo bem!
Note right of Bob: caso contrário erro!
```
### Códigos de Autenticação de Mensagens (da Origem da Informação)
* São mecanismos da Criptografia Moderna e Simétrica cujo propósito é proteger mensagens contra a alteração aleatória ou maliciosa!
```sequence
Participant Alice
Participant Claire
Participant Bob
Note left of Alice: k1
Note right of Bob: k1
Note left of Alice: k1, f1, s1=HMAC(k1,f1)
Note over Claire: f1' s1'
Note over Claire: s1'?=HMAC(??,f1')
Note right of Bob: f1', s1'
Note right of Bob: s2=HMAC(k1,f1')
Note right of Bob: s1==s2? tudo bem
Note right of Bob: caso contrário erro!
```
* Existem várias construções para estes tipos de códigos, nomeadamente HMAC e ECBC-MAC.
#### HMAC - _Hash based Message Authentication Code_
Este mecanismo combina funções de _Hash_ e chaves de integridade.
$\text{HMAC-SHA256}(k,m) = \text{SHA256}(opad \oplus k || \text{SHA256}(ipad \oplus k || m ) )$
No caso de usarmos SHA256(m), o HMAC-SHA512:
* Quantos bits tem o _output_? 512
* Quantas vezes é aplicada a função de _Hash_? Duas vezes.
#### MAC e Cifra
Imagine que, durante a análise dos requisitos de segurança, chegaram à conclusão de que precisam de
1. Confidencialidade e
2. Integridade contra ataques de homem no meio ativos.
Para preencher o requisito 1., precisam de cifras!
Para preencher o requisito 2., precisam de MACs (ou assinaturas digitais).
**Q.:** Como devo combinar os dois mecanismos?
- [x] Cifro primeiro e depois calculo o MAC do criptograma - _Encrypt then MAC_.
- [ ] Calculo primeiro o MAC e depois cifro o ficheiro junto com o MAC - _MAC then Encrypt_.
- [ ] Calculo primeiro o MAC, cifro só o ficheiro e junto os dois antes de enviar - _MAC and Encrypt_.
#### Ataques de Homem no Meio
Referem-se tipicamente dois grantes tipos de Ataques de Homem no Meio:
* **Ataques de homem no meio ativos,** em que o atacante pode (i) escutar a comunicação e (ii) alterar a comunicação **antes** de chegar ao destino;
* **Ataques de homem no meio passivos,** em que o atacante pode (i) escutar a comunicação (PONTO).
### Protocolos de Acordo de Chaves
* Servem para trocar segredos de Criptografia (chaves de cifra, de integridade, etc.) entre duas entidades sem que necessariamente elas se encontrem fisicamente.
* O protocolo de acordo de chaves mais conhecido é o Protocolo de Acordo de Chaves Diffie-Hellman.
#### Problema do Logaritmo Discreto
Considere que $P$ é um número primo muito grande ($> 2^{1024}$). Considerem também que há um número chamado $g$, que gera todos os números entre 1 e P-1 se fizermos o seguinte cálculo: $g^i \bmod P$, em que $i \in \{1,...,P-1\}$.
O problema do logaritmo discreto específica que, nas condições enunciadas no parágrafo anterior, sabendo o valor de $P$ e $g$ e o resultado de $X=g^x \bmod P$, é impossível descobrir $x$. I.t., sabendo $P,g,X$, é impossível descobrir $x$ em tempo útil.
#### Protocolo de Acordo de Chaves Diffie-Hellman
```sequence
Participant Alice
Participant Claire
Participant Bob
Note left of Alice: g, P
Note right of Bob: g, P
Note left of Alice: gera x entre [1, P-1]
Note left of Alice: X=g^x mod P
Alice->Bob: X
Note right of Bob: gera y entre [1, P-1]
Note right of Bob: Y=g^y mod P
Bob->Alice: Y
Note left of Alice: k=Y^x mod P=(g^y)^x mod P
Note right of Bob: k=X^y mod P
Note over Claire: g, P, X, Y
Note over Claire: x=?
Note over Claire: X=g^x mod P
Note over Claire: y=?
```
> Claire **nunca** vai descobrir o $x$ nem o $y$
**Alerta Vermelho!** Isto só funciona em casos de ataque de homem no meio **passivo**.
#### Protocolo de Acordo de Chaves Diffie-Hellman em Cenário de Ataque de Homem no Meio Ativo
```sequence
Participant Alice
Participant Claire
Participant Bob
Note left of Alice: g, P
Note over Claire: g, P
Note right of Bob: g, P
Note left of Alice: gera x entre [1, P-1]
Note left of Alice: X=g^x mod P
Alice->Claire: X
Note over Claire: X
Note over Claire: gera z entre [1, P-1]
Note over Claire: z=g^z mod P
Claire->Bob: Z
Note right of Bob: gera y entre [1, P-1]
Note right of Bob: Y=g^y mod P
Bob->Claire: Y
Note over Claire: Y
Note over Claire: gera w entre [1, P-1]
Note over Claire: W=g^w mod P
Claire->Alice: W
Note over Claire: K1=X^w mod P
Note over Claire: K2=Y^z mod P
Note left of Alice: K1=W^x mod P
Note right of Bob: K2=Z^y mod P
```
### Cifras de Chave Pública
As cifras de chave pública são definidas por um terno (três) de algoritmos:
* Um algoritmo para cifrar;
* Outro para decifrar;
* Um para gerar chaves.
#### ElGamal
```sequence
Participant Alice
Participant Bob
Note over Alice, Bob: Algoritmo de geração de chaves ElGamal
Note left of Alice: P >2^1024, g
Note left of Alice: gera x entre [1, P-1]
Note left of Alice: X=g^x mod P
Note left of Alice: sk=x, pk=(g,P,X)
Note over Alice, Bob: Algoritmo de cifra
Note right of Bob: pk=(g,P,X)
Note right of Bob: gera y entre [1, P-1]
Note right of Bob: Y=g^y mod P, K=X^y mod P
Note right of Bob: c1=AES(H(K),m)
Note right of Bob: t=MAC(H(H(K)),m)
Note left of Alice: Y, c1
Note over Alice, Bob: Algoritmo de decifra
Note left of Alice: K=Y^x mod P
Note left of Alice: m=AES^-1(H(K),c1)
Note left of Alice: Verificar o MAC
```
#### _Rivest Shamir Adleman_ (RSA)
As cifras de chave pública são definidas por um terno (três) de algoritmos:
* Um algoritmo para gerar chaves pk, sk
1. Geramos dois números primos grandes $p$, $q$ (> $2^{1024}$);
2. $N = p \times q$, $phi = (p-1) \times (q-1)$;
> Se eu souber o número N, e souber que é o produto de dois números primos extremamente grandes, não consigo encontrar os dois números em tempo útil.
3. Encontra dois números $e$ e $d$ que preencham a seguinte condição
$e \times d \bmod phi = 1$
Assume-se $e = 3$, e encontra-se o número $d$ que preenche aquela condição.
4. Devolver a chave pública e a chave privada
$pk = (e, N), sk = d$
:::info
O algoritmo para gerar as chaves é o mais complicado dos três!
:::
* Um algoritmo para cifrar (algoritmo em modo livro de escola);
Bob pede à Alice a chave pública **dela** (porque ele quer enviar uma mensagem para ela)!
$m$
$c = m^e \mod N$.
* Outro para decifrar;
Para decifrar, a Alice simplesmente faz o seguinte cálculo
$m = c^{sk} \mod N$
Por que é que isto acontece?
$m = c^{sk} \mod N = m^{e^d} \mod N = m^{e \times d} \mod N = m^1 \mod N = m$
:::warning
**Infelizmente,** por omissão, a RSA é **determinística** e suscetível a ataques de texto limpo escolhido adaptativamente.
Se cifrar o número 2 com a chave pública agora, e a cifra der 25.
Mais tarde, se voltar a cifrar o número 2 com a mesma chave pública, volta a dar 25.
Mais, se o que nós estamos a cifrar pertencer a um **espaço muito pequeno**, qualquer atacante pode obter o texto-limpo.
:::
```sequence
Participant Alice
Participant Claire
Participant Bob
Note left of Alice: sk, pk=(N,e)
Note over Claire: pk=(N,e)
Note right of Bob: pk=(N,e), c=2^e mod N
Note over Claire: c
Note over Claire: c = ??^e mod N
Note over Claire: c ?= 1^e mod N
Note over Claire: c ?= 2^e mod N (já encontrei!)
Note over Claire: c ?= 3^e mod N
Note over Claire: c ?= 4^e mod N
Note left of Alice: c, m=c^sk mod N
```
Portanto, o modo de cifra que foi explicado em cima, só deve ser usado diretamente se o que estivermos a cifrar for:
1. Aleatório;
2. De um espaço de mensagens grande (> 128 bits)!
#### Tipos de *Padding* usados no Contexto da RSA
:::info
Os *paddings* usados no contexto da RSA procuram resolver um problema bastante específico: o facto do RSA ser determinístico.
:::
:::warning
Quando se aplica *padding*, este aplica-se antes de cifrarmos; o que significa que, quando decifrarmos, temos de voltar a retirar o *padding*.
:::
* *Public Key Cryptography Standard* (PKCS) 1.5
```
EM = 0x00 || 0x02 || PS || 0x00 || M.
```
* *Optimal Assymetric Encryption Padding* (OAEP)
1. Primeiro gera-se um número aleatório $r$;
2. Passa-se o número aleatório pela função de hash $h_1=H_1(r)$;
3. O resultado é xORed com o número que queremos cifrar (preenchido com zeros);
4. O resultado do passo 3 é passado pela função hash $h_2=H_2(m\oplus h_1)$;
5. $X = m\oplus h_1$ e $Y=H_2(m\oplus h_1) \oplus r$
No final ciframos o número constituido por $X || Y$.
#### Problema Geral da Criptografia de Chave Pública
A "coisa boa" da criptografia de chave pública é que eu agora despreocupo-me com o secretismo de uma chave. O problema é que posso não ter sempre a certeza de que uma chave é de determinada entidade (confiança).
```sequence
Participant Alice
Participant Claire
Participant Bob
Note left of Alice: vamos usar RSA
Note right of Bob: vamos usar RSA
Note left of Alice: pkA, skA
Note right of Bob: pkB, skB
Note over Claire: pkC, skC
Note right of Bob: pkC=(e,N)
Note right of Bob: c=m^pkC mod N
Note over Claire: c
```
Os dois mecanismos que vão salvar a situação são as assinaturas digitais e os certificados de chave pública.
### Assinaturas Digitais
**Definição**
Definem-se por 3 algoritmos:
GER: $p \rightarrow pk, sk$
SIGN: $sk \times m \rightarrow s$
VERI: $pk \times s \times m \rightarrow$ verifica (1/true), não verifica (0/false)
Propriedade que tem de preencher:
$\text{VERI}(pk, \text{SIGN}(sk, m), m) = \text{true}$
:::info
Existem várias formas de construir assinaturas digitais. A maior parte dessas formas, combinam funções de _hash_ criptográficas com cifras de chave pública.
:::
:::warning
Quando estamos a falar de cifras de chave pública, para cifrar usamos a chave pública do destino. Para decifrar usamos a chave privada do destino.
Quando estamos a falar de assinaturas digitais, usamos a chave privada da origem para fazer a assinatura; e usamos a chave pública de quem faz a assinatura para verificar a assinatura.
:::
:::warning
Um par de chaves pública e privada usadas para cifrar costuma ser diferente do par de chaves usadas para assinaturas digitais.
Mais, é possível também usar criptografia de chave pública e assinaturas digitais para autenticação de entidades. Neste caso, o par de chaves para autenticação é tipicamente diferente dos outros pares de chaves.
No final podemos ter:
1. Um par de chaves para cifrar e decifrar;
2. Um par de chaves para assinatura digital;
3. Um par de chaves para autenticação.
:::
**Q.:** Que chave usa o Bob para cifrar uma mensagem para a Alice?
- [x] Chave pública da Alice.
- [ ] Chave privada da Alice.
- [ ] Chave pública do Bob.
- [ ] Chave privada do Bob.
**Q.:** Que chave usa a Alice para decifrar uma mensagem para a Alice?
- [ ] Chave pública da Alice.
- [x] Chave privada da Alice.
- [ ] Chave pública do Bob.
- [ ] Chave privada do Bob.
**Q.:** Que chave usa o Bob para criar uma assinatura digital a enviar para a Alice?
- [ ] Chave pública da Alice.
- [ ] Chave privada da Alice.
- [ ] Chave pública do Bob.
- [x] Chave privada do Bob.
**Q.:** Que chave usa a Alice para verificar uma assinatura digital feita pelo Bob?
- [ ] Chave pública da Alice.
- [ ] Chave privada da Alice.
- [x] Chave pública do Bob.
- [ ] Chave privada do Bob.
**Q.:** Será que a Alice, ou qualquer outra entidade, tem sempre forma de verificar uma assinatura digital?
- [x] Sim, tem sempre forma, porque a chave usada é a chave **pública** do Bob.
- [ ] Pode haver casos em que não.
**Q.:** Pode a Alice fazer uma assinatura em nome do Bob?
- [ ] Sim, sem problema.
- [x] Não, impossível.
**Q.:** Quais são os algoritmos implícitos às questões anteriores?
* Construção de assinaturas digitais.
* Verificação de assinaturas digitais.
* (geração de chaves)
**Q.:** Quantos algoritmos compõem um esquema de assinatura digital?
- [ ] 1
- [ ] 2
- [x] 3
- [ ] infinitos
- [ ] -5
**Q.:** Quantos são os _inputs_ de um algoritmo de construção de assinatura digital?
- [ ] 1
- [x] 2, ficheiro a assinar, chave privada
- [ ] 3
- [ ] infinitos
- [ ] -5
**Q.:** Quantos são os _outputs_ de um algoritmo de construção de assinatura digital?
- [x] 1, sai a assinatura
- [ ] 2
- [ ] 3
- [ ] infinitos
- [ ] -5
**Q.:** Quantos são os _inputs_ de um algoritmo de verificação de assinatura digital?
- [ ] 1
- [ ] 2
- [x] 3, ficheiros cuja assinatura quero verificar, a própria assinatura e a chave pública da entidade que fez a assinatura.
- [ ] infinitos
- [ ] -5
**Q.:** Quantos são os _outpus_ de um algoritmo de verificação de assinatura digital?
- [x] 1, um booleano a informar se a assinatura está válida ou não.
- [ ] 2
- [ ] 3
- [ ] infinitos
- [ ] -5
#### Construção de Esquemas de Assinatura Digital
Existem vários, mas um dos mais utilizados recorre a RSA e a SHA512 (utiliza uma cifra de chave pública e uma função de _hash_ criptográfica).
`RSAwithSHA512`:
* O algoritmo de geração de chaves é igual ao do RSA.
* O algoritmo de construção da assinatura digital é simples:
F é o ficheiro para o qual queremos calcular a assinatura digital;
s = RSA(skB, SHA512(F))
F,s,pkB
* O algoritmo de verificação é simples:
F,s,pkB
1. O verificador decifra a assinatura $h_1=RSA^{-1}(pkB,s)$;
2. O verificador calcula também o valor de hash do ficheiro $h_2=SHA512(F)$;
3. Verifica se os dois valores de *hash* são iguais:
Se sim, a assinatura está boa!
Caso contrário, a assinatura está inválida.
Se o resultado for _"se sim, a assinatura está boa!"_, isto significa que:
1. Só pode ter sido o Bob a assinar aquele documento (**autenticidade**).
2. O Bob nunca pode vir mais tarde dizer que não ele que assinou (**não repúdio**), caso contrário, está a admitir negligência.
3. Que o documento não tem erros!
4. Se alguém alterasse o documento, teria de ser feita uma assinatura nova (**unicidade**).
5. Ninguém, para além do dono da chave secreta pode construir uma assinatura digital válida (**dificuldade de falsificação**).
Se o resultado for _"assinatura inválida"_, devemos imediatamente descartar o ficheiro.
**Q.:** É verdade que dois ficheiros muito semelhantes podem ter assinaturas digitais iguais ou muito semelhantes?
- [ ] Sim, é verdade.
- [x] Não, é completamente mentira.
:::info
Na verdade, é curioso reparar que esta propriedade é interessante do ponto de vista prático:
Cada documento tem a sua própria assinatura, mesmo que feita pela mesma chave.
:::
:::warning
Uma assinatura digital é mais potente que um MAC. Uma assinatura digital é tipicamente um mecanismo da criptografia de chave pública; um MAC é um mecanismo da criptografia de chave simétrica.
:::
### Certificados Digitais e _Transport Layer Security_ (TLS)
HTTPS é HTTP sobre TLS
**Q.:** O que é um certificado Digital?
É um documento digital.
**Q.:** Para que serve um certificado Digital?
Um certificado certifica ou dá uma certeza. Uma certeza é a ligação de dois conceitos.
Normalmente um certificado digital liga um
```
hackmd.io
pkHack...
assinatura digital (de alguém em quem nós confiamos) (válido)
```
Riscos ao não usar TLS (não é cifrada nem correta):
* Não é cifrada;
* Não tem MACs.
**Q.:** Os certificados digitais são públicos?
- [x] Sim, são.
- [ ] Não, não são. Xiuuu!!
**Q.:** Um certificado digital tem uma assinatura digital?
- [x] Pois claro que tem.
- [ ] Não, não tem.
**Q.:** O que contém um certificado digital?
- [x] Nome da entidade a quem é passado o certificado;
- [x] Tem a chave pública dessa entidade;
- [x] Nome da entidade que passa o certificado;
- [x] Assinatura digital da entidade que passa o certificado;
- [ ] Assinatura digital da entidade a quem é passado o certificado :sob:;
- [x] Quando foi emitido;
- [x] Quando expira, santinho!
**Q.:** Pode um certificado digital conter chaves privadas?
- [x] Chiça penico!
- [ ] Pode.
- [ ] Pode, em determinadas ocasiões!
Os certificados que estão guardados na nossa máquina são as raízes da confiança.
Algumas entidades passam certificados a outras, que por sua vez passam certificados a entidades mais pequenas.
**Q.:** Quais os tipos de autenticação suportadas no TLS?
- [x] Autenticação do servidor.
- [ ] Autenticação do cliente.
- [x] Autenticação mútua.
- [x] Sem autenticação.
```sequence
Browser->Servidor: Hello
Servidor->Browser: Hello
Servidor->Browser: Certificado
Note left of Browser: Verifica os certificados
Note left of Browser: Gera um segredo
Note left of Browser: Deriva 4 chaves
Browser->Servidor: RSA(pkServidor, segredo)
Note right of Servidor: Decifra segredo
Note right of Servidor: Deriva 4 chaves
Note left of Browser: Gera um nonce
Browser->Servidor: nonce
Note right of Servidor: Calcula assinatura
Servidor->Browser: signature
Note left of Browser: Verifica a assinatura
Note left of Browser: k1 para cifrar
Note left of Browser: k2 para MAC
Note right of Servidor: k3 para cifrar
Note right of Servidor: k4 para MAC
```
### Autenticação de Entidades
https://hackmd.io/hCFOMgXcTC6fawoh1WrIPQ?view
### SSH
https://hackmd.io/jzCGs_cCQKmjOvUvjieWIw?view
### Criptografia em Curvas Elípticas
https://hackmd.io/9ewQ_Bn1SpKcxfbBCi-4ig?view
### Proteção em Sistemas Operativos
https://hackmd.io/ohXz79uMTnOjuT_-ej8ePA?view
### Vulnerabilidades em Aplicações Web
https://hackmd.io/QnkQdUvcRLCOEHNpvSxNMQ?view
### Vulnerabilidade de _Buffer Overflow_
https://hackmd.io/2aInj-w-Q_W1Lc19UDCQDQ?view
### Proteção Dinâmica e Corridas
https://hackmd.io/vd_j-_FwS4S4GrTr4v3JxA?view
---
## Aulas Práticas
### Laboratório 10
https://hackmd.io/Eu0NmYDqRB-qwJ7xA0KHMg?view
### Laboratório 9
https://hackmd.io/kf92neWvQ5610H8lEdx31A?view
### Laboratório 8
https://hackmd.io/00zMex7bQUy9PhNpXD4ufg?view
### Laboratório 7
https://hackmd.io/430J3od_T9Kvz0RA3_ETkg?view
### Laboratório 6
https://hackmd.io/-xhQyMd0SFCmsoRb-d06Nw?view
### Laboratório 5
https://hackmd.io/tWhqpBRwRfSNNEViuITPvA
### Laboratório 4
https://hackmd.io/ZOo0I_tjRoWflSB7obgXFw?view
---
### Laboratório 3
#### Geração de Números Pseudo Aleatórios
##### Tarefa 1
`openssl rand 10` (gera 10 bytes aleatórios).
`openssl rand -hex 10` (sequência pseudo-aleatória -> cada 2 caracteres hex são 1 byte).
**Q.:** Qual o comando que gera exatamente 10 caracteres hexadecimais?
`openssl rand -hex 5`
> [10 caracteres hexadecimais são 5 bytes]
**Q1.:** Qual deve ser o valor da entropia calculada para bytes produzidos com o comando anterior?
- [x] Deve ser próximo do máximo.
#### Tratamento e Armazenamento de Palavras-Passe
##### Tarefa 2
No meu caso, eram apenas dois!
**Q2.:** Sabe a password de *root* do computador do laboratório?
- [x] Sim, é `labredespc`
##### Tarefa 3
Calcular representação de uma _password_ no computador:
```shell=
openssl passwd -6 -salt YTEdZjE3Q/z
```
Calcular a representação da _password_ superman com o salt "LoisLane":
```shell=
openssl passwd -6 -stdin -salt LoisLane
superman #colocar no stdin
```
**Q3.:** Um método arcaico de _password cracking_:
- [x] Sim.
1. Roubar o ficheiro `/etc/shadow`;
2. Identificar o algoritmo, ler o _salt_ e a representação R;
3. _Loop_:
* 1 tentava _password_ 1, 2, 3, 4, ..., fim dicionário de passes;
* 2 calculava representação com openssl com o _salt_ lido e aquela _password_;
* 3 verificava se a representação era igual a R.
* Se sim, tinha encontrado a password; imprimia e fazia exit;
#### Teste de Comunicações TLS
##### Tarefa 4
`openssl s_client -connect www.google.com:443 -tls1_2`
`openssl s_client -connect www.google.com:443 -tls1_3`
**Q4.:** Qual o tamanho do segredo mestre (Master-Key) trocado no estabelecimento da ligação?
- [x] 50 bytes para TLS1.2
- [x] 32 bytes para TLS1.3 (usa curvas elípticas)
**Q5.:** Qual é o algoritmo de cifra utilizado para efeitos de confidencialidade da ligação?
- [x] AES, TLS1.3
- [ ] 3DES
- [ ] RSA
- [x] Salsa20, TLS1.2
- [ ] RC4
**Q6.:** Qual é o algoritmo usado para troca de chaves de sessão?
- [x] ECDHE - Eliptic Curve Diffie-Hellman Key Exchange, para ambos
**Q7.:** Qual é a função de hash usada para cálculo do código da origem da informação?
- SHA384 no TLS1.3
- POLY1305 no TLS1.2 (para o google)
**Q8.:** Quantos certificados fazem parte da cadeia de certificação deste site?
- [x] 3 certificados
**Q9.:** Quantos certificados fazem parte da cadeia de certificação do site da UBI (www.ubi.pt:443)?
- [x] 3 certificados
##### Tarefa 5
**Q10.:** Os certificados foram verificados com sucesso?
- [x] Não.
**Q11.:** Caso tenha respondido _não_ à questão anterior, qual acha ser a causa do insucesso? Por outras palavras, qual foi o primeiro erro que obteve?
- [x] _unable to get local issuer certificate_
**Q12.:** Experimentou fornecer ao `openssl` uma localização dos certificados que considera como sendo de confiança
SIM! :smile_cat:
```shell=
openssl s_client -connect www.ubi.pt:443 -verify 4 -CApath /etc/ssl2/certs/
```
##### Tarefa 6
**Q13.:** Verificou (observação humana) que a página foi, de facto, descarregada após inserir a instrução anterior?
- [x] A página foi descarregada.
##### Tarefa 7
**Q.:** A página da UBI pode ser obtida sem ligação segura?
- [x] Mais ou menos
##### Tarefa 8
`openssl s_client -connect www.ubi.pt:443 -msg -tls1_2`
O `-msg` mostra cada uma das mensagens TLS que são trocadas.
Número de mensagens: 9
**Q14.:** O número de mensagens bate certo com o que é especificado, e.g., na wikipedia em http://en.wikipedia.org/wiki/Transport_Layer_Security?
- [x] Sem tirar nem por.
#### Simular um Servidor TLS
##### Tarefa 9
**Q15.:** Dos três tipos de autenticação suportados pelo SSL/TLS, qual o tipo que é forçado pelo comando antes inserido?
- [x] Ligação Anónima (sem autenticação).
**Q16.:** Qual a porta em que o servidor que colocou a correr fica a correr?
- [x] 4433.
##### Tarefa 10
```shell=
openssl s_server -nocert -cipher ADH:@SECLEVEL=0
openssl s_client -connect localhost:4433 -cipher ADH:@SECLEVEL=0
```
**Q17.:** Consegue comunicar tipo _chat?_
- [x] Sim, consigo.
##### Tarefa 11
Ver se o tráfego da rede está cifrado:
`sudo tcpdump -X -i lo`
**Q18.:** As mensagens enviadas usando `openssl` vão cifradas ou em texto limpo?
- [x] Vão cifradas (pelo menos eu não as consigo ver no terminal usando o tcpdump.
##### Tarefa 12
**Q19.:** Se lhe pedissem a sua opinião de especialista, diria que o OpenSSL é capaz de fornecer as funcionalidades de servidor HTTPS?
- [x] Dá.
- [x] E já agora também cantava como se fosse o Bono dos U2?
```shell=
openssl s_server -CAfile server.pem -key serverkey.pem -WWW
```
> Coloca o servidor a correr e serve páginas HTML com HTTPS
**Q20.:** Já experimentou aceder com o comando openssl `s_client`? Funciona?
- [x] Sim e sim.
**Q21.:** É possível aceder à página `index.html` (e site) usando um _browser?_
- [x] Mas é claro que sim!
**Q22.:** Qual é a opção do `openssl s_server` que lhe permite devolver uma página depois de obter um pedido HTTPS válido através do openssl `s_client` (ou e.g., de um *browser*)?
- [x] `-WWW`
- [x] `-HTTP`
---
### Laboratório 2
#### Prova de Trabalho – Mining Bitcoins
**Q1.:** Quantos bits devolve o SHA256?
- [x] Depende do tamanho do ficheiro de entrada.
##### Tarefa 1
**Q2:** Como se compila o código incluido antes?
Podem ser as 2 primeiras, dependendo das distribuições.
> cc sha1sum.c -lcrypto
> ./a.out 111111111111
**Q3.:** O que faz o código anterior?
5ª opção.
##### Tarefa 2
**Q4.:** Observando o segundo bloco de código incluído antes, de quantos bits iguais a 0 é que o procedimento vai andar à procura?
- [x] 16 bits.
##### Tarefa 3
**Q5.:** Quanto tempo demora o programa a executar?
- [x] 0,01s
##### Tarefa 4
0,25s
**Q6.:** Em comparação com o anterior, quanto tempo mais demora este programa a executar?
Devia ser 256 vezes mais.
**Q7.:** Sempre que se adiciona um novo bit igual a 0, qual é o decremento da performance?
- [x] A performance passa para metade.
##### Tarefa 5
**Q8.:** Partindo do princípio de que precisava de aproximadamente 3 segundos para encontrar hashes com os primeiros 24 bits iguais a 0, de quantos dias precisaria para minerar 25BTC?
3s ------------ 2^24 bits iguais a 0
? ------------- 2^70 bits iguais a 0
R: 2211106232532992.0 seg / (60* 60 *24) = 2443359172.8355556 dias só com 1 PC.
**Q9.:** Nas condições da questão anterior, de quantos computadores iguais ao seu precisaria para calcular um valor de hash que valesse 25BTC em 8,6 minutos (que é o tempo médio atual para se minerar 25BTC)?
+/- 409 milhares de milhões.
**Q10.:** Um mineiro de Bitcoins gasta dinheiro verdadeiro no processo de mineração?
- [x] Sim, gasta. (eletricidade, equipamento,...)
**Q11.: Quem é que paga a eletricidade do mineiro, enquanto o computador deste procura valores de hash intensivamente?**
1ª opção.
#### 2 Cifras de Chave Pública
##### Tarefa 6
`openssl rsa` é a parte que lida com **gestão de chaves públicas e privadas RSA** no `openssl`.
Quando o `openssl` gera chaves, estas ficam codificadas num formato chamado BASE64. A BASE64 tem:
* todos os carateres do alfabeto em minúsculas 26;
* todos os carateres do alfabeto em maiúsculas 26;
* Todos os digitos 10;
* o `+` e `/`.
Usa-se o BASE64 porque se acredita que ao codificarmos desta forma, todos os caracteres passam todos os _routers_ e _switches_ na Internet.
:::warning
Quando usamos `openssl rsa`, o `openssl` julga sempre que vamos dar-lhe uma chave privada, por omissão; o que significa que temos de explicitamente dizer-lhe que será dada uma chave pública, caso seja essa a situação usando a opção `-pubin`.
:::
`openssl rsa -in pk1.pem -pubin -text`
**Q12.:** Tamanho do módulo: 1024.
**Q13.:** O tamanho da chave parece-lhe seguro para utilizações atuais?
- [x] Está quase a sair de moda, mas sim. (>2048 bits)
- [ ] Não, é muito grande.
- [ ] Não, é muito pequena.
:::warning
O RSA pode acabar imediatamente se o computador quantico aparecer.
:::
**Q14.:** O que significa o acrónimo RSA?
- [x] Nenhuma das anteriores (correta seria Rivest Shamir Adleman).
**Q15.:** Num sistema criptográfico de chave pública, que chave utilizaria para cifrar uma mensagem para um(a) colega seu(ua)?
- [ ] A minha chave pública.
- [ ] A minha chave privada.
- [x] A chave pública do(a) colega.
- [ ] A chave privada do(a) colega.
##### Tarefa 7
`openssl rsautl` é a parte do `openssl` que lida com cifras de chaves pública RSA.
Resolução da tarefa:
```shell=
echo -n "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" > numero.txt
openssl rsautl -inkey pk1.pem -pubin -in numero.txt -out numero2.rsa -raw
diff numero.rsa numero2.rsa
echo -n "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002" > numero.txt
openssl rsautl -inkey pk1.pem -pubin -in numero.txt -out numero2.rsa -raw
diff numero.rsa numero2.rsa
...
echo -n "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006" > numero.txt
openssl rsautl -inkey pk1.pem -pubin -in numero.txt -out numero2.rsa -raw
diff numero.rsa numero2.rsa
```
**Q17.:** Qual foi o número cifrado?
- [ ] 1
- [ ] 2
- [ ] 3
- [ ] 4
- [ ] 5
- [x] 6
- [ ] 7
- [ ] 8
- [ ] 9
- [ ] 0
:::warning
:warning: Não decifrámos nada! Cifrámos foi 6 vezes!
:::
**Q18.:** É seguro usar o RSA em modo livro de escola para cifrar valores pequenos?
- [x] Não é seguro...
**Q19.:** Qual o *padding* aplicado, por omissão, quando se usa `openssl` para cifrar com RSA?
- [ ] Optimal Assymetric Encryption Padding (OAEP).
- [x] Public Key Cryptography Standards (PKCS) 1.5.
- [ ] Nenhum.
#### 3 Assinatura Digital
##### Tarefa 8
`echo "O Eduardo levaria uma valente coça se jogasse CoD comigo" > es-feio.txt`
##### Tarefa 9: Crie um par de chaves RSA
`openssl genrsa -out pk-and-sk.pem 1024`
**Q20.:** Quantos bits tem o módulo da chave gerada com o comando anterior?
1024.
:::warning
:warning: Se não soubermos quantos bits tem o módulo de uma pk-and-sk.pem, podemos usar o comando `openssl rsa -in pk-and-sk.pem -text -noout`.
:::
**Q.:** Quantos são os _inputs_ do algortimo de geração de chaves pública/privada?
- [x] 1, o tamanho do módulo
- [ ] 2
- [ ] 3
- [ ] 4
- [ ] 500
**Q21.:** Se quiser assinar o ficheiro es-feio.txt que chave deve utilizar?
- [x] A minha chave privada.
##### Tarefa 10: Escreva o comando que permite extrair a chave pública, contida no ficheiro pk-and-sk.pem
`openssl rsa -in pk-and-sk.pem -out pk.pem -pubout`
##### Tarefa 11: escreva o comando OpenSSL que permite criar a assinatura digital do ficheiro es-feio.txt com a combinação MD5 e RSA.
`openssl dgst -md5 -sign pk-and-sk.pem es-feio.txt > es-feio.MD5withRSA`
##### Tarefa 12
**Q22.:** O que é que falta no comando seguinte para que a verificação seja feita com sucesso?: `openssl dgst -md5 -verify pk.pem -signature es-feio.md5-with-rsa...` .
- [x] Falta o `nome` do `ficheiro` para o qual a assinatura foi calculada.
`openssl dgst -md5 -verify pk.pem -signature es-feio.MD5withRSA es-feio.txt`
**Q23.:** Depois da emissão correta do comando anterior, o que é que lhe diz se uma assinatura digital está ou não está válida?
- [x] Depois de emitir o comando, o OpenSSL escreve no ecrã que a assinatura está OK.
##### Tarefa 13
```
nano es-feio.txt
openssl dgst -md5 -verify pk12589.pem -signature es-feio.MD5withRSA es-feio.txt
```
**Q26.:** O que é que o OpenSSL devolve desta vez?
`Verification Failure`
##### Tarefa 14
O que é uma assinatura digital no contexto específico desta aula?
A assinatura digital é a cifra de um valor de _hash_! Se tentarmos decifrar, por passos uma assinatura digital, devemos encontrar lá dentro um valor de _hash_.
```
openssl dgst -md5 -binary es-feio.txt
openssl rsautl -verify -inkey pk12589.pem -pubin -in es-feio.MD5withRSA
```
##### Tarefa 15
1. Gerar 2 pares de chaves:
* Um para cifrar;
* Outro para assinaturas digitais.
`openssl genrsa ...`
2. Enviar chaves públicas para o(a) colega(a).
3. Um dos dois cria um ficheiro com um poema de Fernando Pessoa, o outro coloca lá 2 oitavas dos Lusíadas.
4. Assine o ficheiro com a chave respetiva, usando a combinação de algoritmos `SHA1withRSA`.
`openssl dgst -sha1 -sign ...`
5. Cifre o ficheiro à moda do PGP usando RSA e AES em modo CTR.
```sequence
Participant Alice
Participant Bob
Note left of Alice: fernando.txt
Note left of Alice: s=SIGN(pkAS,fernando.txt)
Note left of Alice: gera uma chave simétrica K1
Note left of Alice: c1=AES-CTR(K1,fernando.txt)
Note left of Alice: c2=RSA(pkB,K1)
Alice->Bob: c1,c2,s
Note right of Bob: c1,c2,s
```
```shell=
openssl rand ...
openssl enc -aes-128-ctr...
openssl rsautl ...
```
6. Envie o ficheiro e a assinatura ao(à) colega.
```sequence
Participant Alice
Participant Bob
Note right of Bob: c1,c2,s
Note right of Bob: Decifra K1
Note right of Bob: K1=D-RSA(skB,c2)
Note right of Bob: fernando.txt=D-AES-CTR(K1,c1)
Note right of Bob: Verifica a assinatura digital
```
```shell=
openssl rsautl -decryt ...
openssl enc -d -aes-128-ctr ...
openssl dgst -sha1 -verify ...
```
---
### Laboratório 1
#### 1. Cifras de Chave Simétrica
##### Tarefa 1: Crie o ficheiro confidential.txt com a sequência 111111111111222222222222 (doze 1s e doze 2s) repetida 3 vezes.
```shell=
echo -n "111111111111222222222222"> confidential.txt
echo -n "111111111111222222222222">> confidential.txt
echo -n "111111111111222222222222">> confidential.txt
```
##### Tarefa 2: Cifre o ficheiro com a cifra RC4, usando a chave em hexadecimal fff22f2fff
```shell=
openssl enc -rc4 -K fff22f2fff -in confidential.txt -out confidential.rc4
openssl enc -rc4 -K 'openssl rand -hex 16' -in confidential.txt -out confidential.rc4
```
- No rc4 a chave é de 128 bits.
- -K: diz q a chave de cifra é em hexadecimal.
- enc: parte do ssl q trata de criptografia de chave simétrica.
##### Tarefa 3:
**Q1.:** Experimentou abrir o ficheiro cifrado?
- [x] Sim.
```shell=
cat confidential.rc4
hexdump confidential.txt
hexdump confidential.rc4
```
**Q2.:** Quantos caracteres hexadecimais diferentes são produzidos pelo comando anterior para um ficheiro cifrado?
No ficheiro não cifrado há 3 caracteres hexadecimais diferentes.
No ficheiro cifrado existem 16 chars hexadecimais. -> se a cifra for boa há sempre os 16.
**Q3.:** Qual lhe parece ser o valor mais provável para a entropia deste ficheiro?
Propriedades das cifras:
- Propriedade 1 - Dispersão:
Se a cifra for boa, a sua aplicação provoca um criptograma sem propriedades estatísticas notáveis (o mesmo que aparecem todos os caracteres com distribuição normal).
Isto também significa que, quando aplicamos uma cifra BOA, o criptograma fica com entropia próxima da máxima.
A entropia máxima tem uma fórmula simples:
$Emax = log(n)$,
em que n é o número total de ocorrências da variável que estamos a analisar que podem ocorrer (nos ficheiros é uma unidade de informação: bits, hexas ou bytes).
$ln(n) = log(n) / log(e)$
```shell=
python
import math
math.ln(256) ---> o py não tem "ln", logo:
math.log(256)/math.log(math.exp(1)) -> se o log não estiver na base 10
math.log(256) -> o log neste caso já está na base 10.
2.40
```
**Q4.:** Se voltar a cifrar o ficheiro que já foi cifrado, vai conseguir ler facilmente o seu conteúdo ou não?
- [x] Se cifrar com a mesma chave sim, caso contrário não.
##### Tarefa 4: Volte a cifrar o ficheiro (com a mesma chave) e tente abrir o ficheiro resultante com um editor de texto. Chame ao novo ficheiro confidential.2times.rc4.
```shell=
openssl enc -rc4 -K fff22f2fff -in confidential.rc4 -out confidential.2times.rc4
cat confidential.2times.rc4
```
**Q5.:** O resultado coaduna-se com o que respondeu na pergunta anterior?
- [x] Sim.
**Q6.:** Que tipo de cifra é a RC4?
- [x] Chave simétrica contínua.
**Q7.:** O que significa RC4?
Rivest Cipher 4
##### Tarefa 5: Cifre o ficheiro confidential.txt com a cifra AES no modo ECB com a chave de cifra hexadecimal 11232233. O ficheiro resultante deve chamar-se confidential.aes-ecb. Tente visualizar o conteúdo este ficheiro.
```shell=
openssl enc -aes-128-ecb -K 11234455 -in confidential.txt -out confidential.aes-ecb
cat confidential.aes-ecb
hexdump confidential-aes-ecb
```
**Q8.:** Consegue detetar padrões no ficheiro cifrado?
A 1º linha é igual à 4ª.
**Q9.:** De acordo com a experiência que fez antes, qual é o tamanho do bloco que esta cifra utiliza?
- [x] 16 bytes.
**Q10.: O modo ECB precisa de vetor de inicialização?**
- [x] Não.
Os vetores de inicialização servem para aumentar a entropia.
**Q11.: Que tipo de cifras concretizam a família de algoritmos especificados pela AES?**
Chave simétrica por blocos (entra um bloco de cada vez, e sai um de cada vez também).
**Q12.: O que significa AES?**
Advanced Encryption Standard.
##### Tarefa 6:
**Q13.:**
_Challenger/Adversary._
**Q14.:**
```shell=
echo "11111111111111111111111111111111" > 1.txt
echo "11111111111111111111211111111111" > 2.txt
```
```shell=
openssl enc -aes-128-ecb -K ffffff11112ff1 -in 2.txt -out x.enc
```
```shell=
hexdump x.enc
```
```shell=
openssl enc -aes-128-ecb -K ffffff11112ff1 -in 1.txt -out x.enc
```
```shell=
hexdump x.enc
```
**Q14.:**
Canja de galinha se formos o adversário.
#### Tarefa 7: Use o seguinte comando para cifrar o ficheiro confidential.txt: `openssl enc --aes-128-cbc -K 11232233 -in confidential.txt -out confidential.aes-cbc`
**Q15.:** O comando antes enunciado funcionou?
- [x] Não.
**Q16.:** Como é que se resolve a situação?
Vetor de inicialização.
```shell=
openssl enc -aes-128-cbc -K 11232233 -in confidential.txt -out confidential.aes-cbc -iv 001122
```
**Q17.:** O que significa CBC?
_Chiper Block Chaining_.
**Q18.:** O que é o CBC?
- [x] Modo de utilização de uma cifra.
**Q19.:** Se voltar a cifrar o ficheiro que já foi cifrado com --aes-128-cbc, vai conseguir ler facilmente o seu conteúdo ou não?
- [x] Acho que não, porque não é uma cifra contínua.
##### Tarefa 8: Volte a cifrar o ficheiro e tente abrir o ficheiro resultante com um editor de texto. Chame ao novo ficheiro confidential.2times.aes-cbc.
```shell=
openssl enc -aes-128-cbc -K 11232233 -in confidential.aes-cbc -out confidential.2times.aes-cbc -iv 001122
```
**Q20.:** O resultado coaduna-se com o que respondeu na pergunta anterior?
Impecável. É uma cifra por blocos e não contínua.
**Q21.:** Como é que se decifra um ficheiro cifrado no modo CBC?
Usando a opção -d.
```shell=
openssl enc -aes-128-cbc -d -K 11232233 -in confidential.aes-cbc -out confidential.decifrado -iv 001122
cat confidential.decifrado
```
##### Tarefa 9: Quando se especifica uma palavra-passe em vez de uma uma chave de cifra (i.e., usar a opção -k em vez de -K), é conveniente definir uma pitada de sal usando a opção -S (para além do iv).
**Q22.:** Porquê?
-K: chave de cifra hexadecimal.
-k palavra-passe.
A pitada de sal aumenta a entropia.
**Q23.:** Acha que é preciso inserir o mesmo valor do salt quando se vai decifrar o ficheiro, ou basta a palavra-chave e o iv?
Cifrar com palavra-passe:
```shell=
openssl enc -aes-128-cbc -k pass -in confidential.txt -out cifrado-pass.aes-cbc
Podemos usar um algoritmo e o salt :
openssl enc -aes-128-cbc -k pass -in confidential.txt -out cifrado-pass.aes-cbc -pbkdf2 -S 112233
```
Decifrar:
```shell=
openssl enc -d -aes-128-cbc -k pass -in cifrado-pass.aes-cbc -pbkdf2 -S 112233
(...mas sem o -S (salt) ele decifra na mesma).
```
R: deixa experimentar...ver o que lá vai dentro.
Se não metermos o salt, ele gera um salt automaticamente.
#### 2. Maneabilidade
##### Tarefa 10: Crie o ficheiro texto-limpo.txt e coloque lá a mensagem "Enviar 2 euros para o Bob". De seguida, cifre o ficheiro com uma cifra por blocos.
```shell=
mkdir Alice
mkdir Banco
mkdir Claire
cd Alice
echo "Enviar 2 euros para o Bob" > msg.txt
# modo cbc
openssl enc -aes-128-cbc -K 0123456789abcdef0123456789abcdef -in msg.txt -out cifrado.aes -iv 0
```
##### Tarefa 11
```shell=
mv Alice/cifrado.aes Claire/ # Claire apanha o ficheiro
cd Claire
cat cifrado.aes # Não consegue ver a msg, mas consegue alterá-la
# temos que usar o alterbyte.c, para alterar um byte da msg
cc alterbyte.c
./a.out cifrado.aes cifrado-2.aes 8 #8, é o byte que quero alterar
cat cifrado.aes # assim parecem iguais
cat cifrado-2.aes # assim paracem iguais
# por isso fazemos hexdump
hexdump cifrado.aes
hexdump cifrado-2.aes # vemos que o byte 8 está alterado
mv Claire/cifrado-2.aes Banco
cd Banco/
openssl enc -aes-128-cbc -d -K 0123456789abcdef0123456789abcdef -in cifrado-2.aes -out decifrado.txt -iv 0
cat decifrado.txt # não dá para ler tudo
```
**Q24.:** Consegue ler a mensagem original?
- [x] Não...
**Q25.:** Diria que, se alguém alterasse qualquer byte no ficheiro durante a sua transmissão, o recetor iria notar essa alteração?
- [x] Sim...
##### Tarefa 12: Apague os ficheiros cifrado.aes, cifrado-2.aes e texto-limpo-2.txt e recomece, desta feita com o modo CounTeR (CTR).
```shell=
cd Alice
echo "Enviar 2 euros para o Bob" > msg.txt
# modo ctr
openssl enc -aes-128-ctr -K 0123456789abcdef0123456789abcdef -in msg.txt -out cifrado.aes -iv 0
```
**Q26.:** Em que tipo de cifra se transforma qualquer cifra por blocos quando se usa este modo?
- [x] Simétrica contínua (por isso também não é preciso por o -d, quando é para decifrar...)
##### Tarefa 13
```shell=
mv Alice/cifrado.aes Claire/ # Claire apanha o ficheiro
cd Claire
cat cifrado.aes # Não consegue ver a msg, mas consegue alterá-la
# temos que usar o alterbyte.c, para alterar um byte da msg
cc alterbyte.c
./a.out cifrado.aes cifrado-2.aes 8 # 8, é o byte que quero alterar
cat cifrado.aes # assim parecem iguais
cat cifrado-2.aes # assim paracem iguais
# por isso fazemos hexdump
hexdump cifrado.aes
hexdump cifrado-2.aes #vemos que o byte 8 está alterado
mv Claire/cifrado-2.aes Banco
cd Banco/
openssl enc -aes-128-ctr -d -K 0123456789abcdef0123456789abcdef -in cifrado-2.aes -out decifrado.txt -iv 0
cat decifrado.txt # dá para ler tudo e a msg parece real
```
**Q27.:** Nota algo estranho no ficheiro decifrado?
- [x] Não...
**Q28.:** Será que um atacante poderia mudar o texto-limpo sem o conhecer, alterando apenas o criptograma respetivo, e sem ser notado?
- [x] Sim...
**Q29.:** De 0 a 5, em que 0 é muito má e 5 é muito boa, como classifica o facto de uma cifra ser maneável?
- [x] 0.
**Q30.:** Usaria uma cifra simétrica contínua para transmitir uma mensagem confidencial sobre um canal que está sujeito a escutas, mas não a alteração das mensagens?
- [x] Sim, sem problema.
#### 3. Funções de Hash
```
+-+-+-+-+-+
mensagem -->| função |--> output de tamanho fixo
| de hash |(e aparentemente aleatorio)
+-+-+-+-+-+
```
##### Tarefa 14:
```shell=
openssl dgst # calcula valores de hash
openssl enc # manipula cifras de chave simétrica
echo -n "" > vazio.txt # Cria um ficheiro vazio. O -n é para o echo não por o char "new line"
touch vazio.txt # Tb cria um ficheiro vazio/altera a data de um ficheiro já vazio
openssl dgst -sha1 vazio.txt # está em desuso
openssl dgst -sha256 vazio.txt
openssl dgst -sha512 vazio.txt
openssl dgst -md5 vazio.txt #está em desuso, ñ é segura
openssl dgst -md5 # calcula o hash de um ficheiro stdin, ou seja, abre o teclado para escrevermos algo.
# Se não escrevermos nada, e imediatamente fecharmos o ficheiro (ctr + d) ele supoe-o como um ficheiro vazio.
```
**Q31.:** Obteve os valores d41d8cd98f00b204e9800998ecf8427e e da39a3ee5e6b4b0d3255bfef95601890afd80709?
- [x] Sim.
```shell=
openssl dgst -sha1
```
The quick brown fox jumps over the lazy dog
(ctrl + d)
```shell=
openssl dgst -sha256
```
The quick brown fox jumps over the lazy dog
(ctrl + d)
**Q32.:** O que abrevia a letra S do acrónimo SHA1?
*Secure*.
**Q33.:** O que tem a dizer acerca da seguinte
frase: O autor do RC4 é o mesmo do SHA1
Falsa.
O autor do RC4, o Rivest, fez o md5 (fez os mds).
##### Tarefa 15:
**Q34.:** Acha que, sabendo isto, consegue descobrir a palavra-passe ou decifrar o raça da frequência?
- [x] Canja de galinha...
**Q35.:** Acha correto que os autores de sites de cracking de valores de hash usem a palavra decrypt (decifrar) para se referirem ao serviço que disponibilizam?
Não, porque eles não estão a decifrar...apenas recorrem a Bases de Dados com muitas palavras e o respetivo valor de *hash*...
**Q36.:** Caso tenha respondido canja de galinha na questão anterior, o que é que recomenda que o Professor faça na próxima vez para proteger melhor o documento?
- Todos.
##### Tarefa 16: Crie um ficheiro chamado ficheiro.txt com a letra b.
```shell=
echo -n "b" > ficheiro.txt
```
**Q37.:** O que é que acontece ao valor de hash do ficheiro, se mudar a letra b pela letra c, no caso em que a função de hash utilizada é de qualidade comprovada?
```shell=
echo -n "c" > ficheiro.txt
```
Mudam aproximadamente metade dos bits de acordo com uma distribuição binomial.
Traduzir cada caracter para binário:
```python=
python
bin (0x3733bbd43bd029e3bd660b44a20dac43e9c922e3)
```
A probabilidade de cada bit mudar é de 0,5.
SHA1: tem _output_ de 160 bits. Metade são 80 bits.
**Q38.:** Que nome se dá ao efeito que provoca a alteração mencionada na questão anterior?
Se alterar 1 bit no texto limpo, o valor de *hash* muda aproximadamente em metade: **efeito avalanche/em cadeia**.
**Q39.:** Só por curiosidade, quantos bits mudaram no ficheiro quando trocou a letra b pela letra c
Não é nenhuma das opções.
##### Tarefa 1
```shell=
md5sum vazio.txt # calcula o valor de hash md5 do ficheiro vazio.txt
sha1sum vazio.txt # calcula o valor de hash sha1 do ficheiro vazio.txt
```
#### 4. Códigos de Autenticação de Mensagens
##### Tarefa 18: crie um ficheiro chamado ficheiro.txt com a letra b. De seguida, calcule o Hash based Message Authentication Code (HMAC) para este ficheiro com a função SHA512.
**Q40.:** Precisa de alguma informação adicional?
Sim, da chave.
```shell=
openssl dgst -sha256 -hmac 1122334455 ficheiro.txt > ficheiro.hmac
```
As opções começam com "-..." e os parâmetros não.
**Q41.:** Para que é que serve um MAC?
3ª opção: sobre integridade
2ª opção: sobre confidencialidade --> as cifras fazem isto, não o MAC
MAC:
* Evitar que hajam erros aleatórios ou intencionais
**Q42.:** Quantas entidades podem calcular um HMAC?
- [x] Só as entidades que possuem a chave.
**Q43.:** Quantas entidades podem calcular o valor de hash SHA1 de um ficheiro?
- [x] Qualquer entidade envolvida...
##### Tarefa 19:
**Q44.:** Quantas chaves de integridade estão envolvidas na geração de um ECBC-MAC?
- [x] 2 (k e k1).
**Q45.:** O OpenSSL permite calcular este MAC diretamente?
- [x] Não, não permite.
Calcular o MAC:
1º - cifrar os blocos com o modo AES-CBC com uma chave k1
2º - guardo só o último bloco
3º - cifrar o ultimo bloco com AES-ECB com uma chave k2
```shell=
openssl enc -aes-128-cbc -K 1223344 -iv 0 -in ficheiro.txt | tail -c 16 > bloco.aes
```
* O comando _tail_ mostra os últimos x caracteres de um ficheiro
* Neste caso, o _tail -c 16_ mostra os últimos 16 bytes (tamanho de cada bloco) do ficheiro, e guarda-os no ficheiro bloco.aes
```shell=
openssl enc -aes-128-ecb -K 22334455 -in bloco.aes -out ficheiro.mac
```
* O ficheiro.mac é o MAC.
##### Tarefa 20
**Q46:** É possível produzir um MAC com o comando openssl dgst que não seja um HMAC?
Sim,...
Sign in with Wallet
Connect another wallet