Branch data     Line data    Source code

       1                 :            : /*
       2                 :            :    Copyright (c) 2021 Fraunhofer AISEC. See the COPYRIGHT
       3                 :            :    file at the top-level directory of this distribution.
       4                 :            : 
       5                 :            :    Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
       6                 :            :    http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
       7                 :            :    <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
       8                 :            :    option. This file may not be copied, modified, or distributed
       9                 :            :    except according to those terms.
      10                 :            : */
      11                 :            : 
      12                 :            : #include <stdio.h>
      13                 :            : 
      14                 :            : #include "oscore.h"
      15                 :            : 
      16                 :            : #include "oscore/oscore_cose.h"
      17                 :            : #include "oscore/security_context.h"
      18                 :            : 
      19                 :            : #include "common/crypto_wrapper.h"
      20                 :            : #include "common/memcpy_s.h"
      21                 :            : #include "common/print_util.h"
      22                 :            : 
      23                 :            : #include "cbor/oscore_enc_structure.h"
      24                 :            : 
      25                 :            : /*the additional bytes in the enc_structure are constant*/
      26                 :            : #define ENCRYPT0_ENCODING_OVERHEAD 16
      27                 :            : 
      28                 :            : /**
      29                 :            :  * @brief Encode the input AAD to defined COSE structure
      30                 :            :  * @param external_aad: input aad to form COSE structure
      31                 :            :  * @param out: output encoded COSE byte string
      32                 :            :  * @return err
      33                 :            :  */
      34                 :         28 : static enum err create_enc_structure(struct byte_array *external_aad,
      35                 :            :                                      struct byte_array *out)
      36                 :            : {
      37                 :            :         struct oscore_enc_structure enc_structure;
      38                 :            : 
      39                 :         28 :         uint8_t context[] = { "Encrypt0" };
      40                 :         28 :         enc_structure.oscore_enc_structure_context.value = context;
      41                 :         28 :         enc_structure.oscore_enc_structure_context.len =
      42                 :         28 :                 (uint32_t)strlen((char *)context);
      43                 :         28 :         enc_structure.oscore_enc_structure_protected.value = NULL;
      44                 :         28 :         enc_structure.oscore_enc_structure_protected.len = 0;
      45                 :         28 :         enc_structure.oscore_enc_structure_external_aad.value =
      46                 :         28 :                 external_aad->ptr;
      47                 :         28 :         enc_structure.oscore_enc_structure_external_aad.len =
      48                 :         28 :                 external_aad->len;
      49                 :            : 
      50                 :         28 :         size_t payload_len_out = 0;
      51                 :            : 
      52         [ -  + ]:         28 :         TRY_EXPECT(cbor_encode_oscore_enc_structure(out->ptr, out->len,
      53                 :            :                                                     &enc_structure,
      54                 :            :                                                     &payload_len_out),
      55                 :            :                    0);
      56                 :            : 
      57                 :         28 :         out->len = (uint32_t)payload_len_out;
      58                 :         28 :         return ok;
      59                 :            : }
      60                 :            : 
      61                 :         13 : enum err oscore_cose_decrypt(struct byte_array *in_ciphertext,
      62                 :            :                              struct byte_array *out_plaintext,
      63                 :            :                              struct byte_array *nonce,
      64                 :            :                              struct byte_array *recipient_aad,
      65                 :            :                              struct byte_array *key)
      66                 :            : {
      67                 :            :         /* get enc_structure */
      68                 :         13 :         uint32_t aad_len = recipient_aad->len + ENCRYPT0_ENCODING_OVERHEAD;
      69   [ -  +  -  + ]:         13 :         BYTE_ARRAY_NEW(aad, MAX_AAD_LEN, aad_len);
      70         [ -  + ]:         13 :         TRY(create_enc_structure(recipient_aad, &aad));
      71                 :         13 :         PRINT_ARRAY("AAD encoded", aad.ptr, aad.len);
      72                 :         13 :         struct byte_array tag = BYTE_ARRAY_INIT(
      73                 :            :                 (in_ciphertext->ptr + in_ciphertext->len - 8), 8);
      74                 :            : 
      75                 :         13 :         PRINT_ARRAY("Ciphertext", in_ciphertext->ptr, in_ciphertext->len);
      76                 :            : 
      77         [ -  + ]:         13 :         TRY(aead(DECRYPT, in_ciphertext, key, nonce, &aad, out_plaintext,
      78                 :            :                  &tag));
      79                 :            : 
      80                 :         13 :         PRINT_ARRAY("Decrypted plaintext", out_plaintext->ptr,
      81                 :            :                     out_plaintext->len);
      82                 :         13 :         return ok;
      83                 :            : }
      84                 :            : 
      85                 :         15 : enum err oscore_cose_encrypt(struct byte_array *in_plaintext,
      86                 :            :                              struct byte_array *out_ciphertext,
      87                 :            :                              struct byte_array *nonce,
      88                 :            :                              struct byte_array *sender_aad,
      89                 :            :                              struct byte_array *key)
      90                 :            : {
      91                 :            :         /* get enc_structure  */
      92                 :         15 :         uint32_t aad_len = sender_aad->len + ENCRYPT0_ENCODING_OVERHEAD;
      93   [ -  +  -  + ]:         15 :         BYTE_ARRAY_NEW(aad, MAX_AAD_LEN, aad_len);
      94                 :            : 
      95         [ -  + ]:         15 :         TRY(create_enc_structure(sender_aad, &aad));
      96                 :         15 :         PRINT_ARRAY("aad enc structure", aad.ptr, aad.len);
      97                 :            : 
      98                 :         15 :         struct byte_array tag =
      99                 :         15 :                 BYTE_ARRAY_INIT(out_ciphertext->ptr + in_plaintext->len, 8);
     100                 :            : 
     101                 :         15 :         out_ciphertext->len -= tag.len;
     102         [ -  + ]:         15 :         TRY(aead(ENCRYPT, in_plaintext, key, nonce, &aad, out_ciphertext,
     103                 :            :                  &tag));
     104                 :            : 
     105                 :         15 :         PRINT_ARRAY("tag", tag.ptr, tag.len);
     106                 :         15 :         PRINT_ARRAY("Ciphertext", out_ciphertext->ptr, out_ciphertext->len);
     107                 :         15 :         out_ciphertext->len += tag.len;
     108                 :         15 :         PRINT_ARRAY("Ciphertext + tag", out_ciphertext->ptr,
     109                 :            :                     out_ciphertext->len);
     110                 :            : 
     111                 :         15 :         return ok;
     112                 :            : }