---
# System prepended metadata

title: Apontamentos & Miscellaneous
tags: [lectures]

---

#    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 ﬁcheiro 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 ﬁcheiro 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 ﬁcheiro 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 veriﬁcaçã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,...



